Benjamin B. Hargarten - Homepage Datenbanksysteme€¦ · Benjamin B. Hargarten R-Baume¨ Eine...

Benjamin B. Hargarten

R-Baume

Eine dynamische Indexstruktur fur mehrdimensionaleDaten

[email protected]

Universitat Hannover — Institut fur InformatikFachgebiet Datenbanken und Informationssysteme

Prof. Dr. Lipeck

15. Juni 1999

Zusammenfassung

Um mit raumlichen Daten effizient zu arbeiten, sind Indexstrukturennotwendig, die den Zugriff auf mehrdimensionale Daten unterstutzen.Da herkommliche Indexe wie B- oder B∗-Baume nur den eindimen-sionalen Zugriff beschleunigen, wurde der R-Baum entwickelt. Die-ser strukturiert raumliche Daten mit Hilfe der kleinsten umgebendenRechtecke in einem hohenbalancierten Baum.

Im Rahmen der Studienarbeit wurde eine R-Baum-Klasse, mit Opera-tionen zum Einfugen und Suchen, objektorientiert in C++ entwickelt.Die Implementation speichert die Indexe extern in Dateien und wur-de so gestaltet, daß spater eine Speicherung derselben in einer Da-tenbank leicht hinzugefugt werden kann. Weiterhin wurde eine grafi-sche Experimentieroberflache in Java entwickelt, die auf der R-Baum-Implementation basiert und den Aufbau und die Entwicklung von R-Baumen visualisiert.

Mit diesen Werkzeugen wurden Geschwindigkeits- und Effizienzver-suche unter anderem mit raumlichen Objektdaten der Stadt Hannoversowie zufallig generierten Daten durchgefuhrt und ausgewertet.

2

Inhaltsverzeichnis

Zusammenfassung 2

Abbildungsverzeichnis 7

1 Motivation und Uberblick 81.1 Einordnung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.2 Aufbau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.2.1 Definierende Eigenschaften . . . . . . . . . . . . . . . . . 9Einfache Folgerungen . . . . . . . . . . . . . . . . . . . . 9

1.2.2 Beispiele . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Implementation der Datenstruktur . . . . . . . . . . . . . 10

1.2.3 Verzeichnis-Rechtecke . . . . . . . . . . . . . . . . . . . . 101.3 Kriterien fur effiziente Anfragen . . . . . . . . . . . . . . . . . . 12

2 Algorithmen 132.1 Suchen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132.2 Einfugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Insert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14ChooseLeaf . . . . . . . . . . . . . . . . . . . . . . . . . . 15AdjustTree . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.3 Loschen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16Delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16FindLeaf . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16CondenseTree . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.4 Andere Operationen . . . . . . . . . . . . . . . . . . . . . . . . . 182.4.1 Andern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.4.2 Suchvarianten . . . . . . . . . . . . . . . . . . . . . . . . . 182.4.3 Bereiche loschen . . . . . . . . . . . . . . . . . . . . . . . 18

2.5 Knoten aufteilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.5.1 Der triviale Algorithmus . . . . . . . . . . . . . . . . . . . 192.5.2 Ein Algorithmus mit quadratischen Kosten . . . . . . . . 19

QuadraticSplit . . . . . . . . . . . . . . . . . . . . . . . . . 20

3

PickSeeds . . . . . . . . . . . . . . . . . . . . . . . . . . . 20PickNext . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.5.3 Ein Algorithmus mit linearen Kosten . . . . . . . . . . . 21LinearPickSeeds . . . . . . . . . . . . . . . . . . . . . . . 21

3 Bedienungsanleitung zu rt 223.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.2 Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223.3 Befehle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.3.1 Befehlsreferenz . . . . . . . . . . . . . . . . . . . . . . . . 24insert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24flush . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24count . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28filling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28find . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29quit und exit . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.3.2 Generelle Ruckgabedaten . . . . . . . . . . . . . . . . . . 30

4 Bedienungsanleitung zu rtview 314.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.2 Start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314.3 Fensterbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.3.1 Das Hauptfenster RT View . . . . . . . . . . . . . . . . . . 324.3.2 Das Kommandofenster Command . . . . . . . . . . . . . . 324.3.3 Das Grafikfenster Graphic View . . . . . . . . . . . . . . . 334.3.4 Das Statistikfenster Statistics . . . . . . . . . . . . . . . . 35

5 Tests und Ergebnisse 375.1 Testspezifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.1.1 Testdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375.1.2 Testumgebung . . . . . . . . . . . . . . . . . . . . . . . . 375.1.3 Testanfragen . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Mogliche Anfragen . . . . . . . . . . . . . . . . . . . . . . 38Eliminierung aquivalenter Anfragen . . . . . . . . . . . . 38Getestete Anfragen . . . . . . . . . . . . . . . . . . . . . . 38

5.1.4 Meßverfahren . . . . . . . . . . . . . . . . . . . . . . . . . 395.1.5 Geschwindigkeitsbeeinflussende Parameter . . . . . . . 39

5.2 Ergebnisse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405.2.1 ATKIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 40m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 40m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 41

4

5.2.2 checkers mit 10 000 Tupeln . . . . . . . . . . . . . . . . . 41m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 41m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 42m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 42

5.2.3 checkers mit 100 000 Tupeln . . . . . . . . . . . . . . . . . 43m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 43m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 43m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 44

5.2.4 checkers mit 1 000 000 Tupeln . . . . . . . . . . . . . . . . 44m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 44m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 45m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 45

5.2.5 random1 mit 10 000 Tupeln . . . . . . . . . . . . . . . . . 46m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 46m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 46m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.2.6 random1 mit 100 000 Tupeln . . . . . . . . . . . . . . . . 47m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 47m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 48m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.2.7 random1 mit 1 000 000 Tupeln . . . . . . . . . . . . . . . 49m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 49m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 49m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 50

5.2.8 random2 mit 10 000 Tupeln . . . . . . . . . . . . . . . . . 50m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 50m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 51m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 51

5.2.9 random2 mit 100 000 Tupeln . . . . . . . . . . . . . . . . 52m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 52m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 52m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 53

5.2.10 random2 mit 1 000 000 Tupeln . . . . . . . . . . . . . . . 53m = 2, M = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 53m = 5, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . . 54m = 25, M = 50 . . . . . . . . . . . . . . . . . . . . . . . . . 54

5.2.11 Bemerkung . . . . . . . . . . . . . . . . . . . . . . . . . . 545.3 Uberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6 Ausblick 576.1 Erweiterung der Datenstruktur . . . . . . . . . . . . . . . . . . . 576.2 Anbindung an ein Datenbanksystem . . . . . . . . . . . . . . . . 576.3 Optimierung der Cache-Verwaltung . . . . . . . . . . . . . . . . 58

5

7 rt Implementationsdokumentation 607.1 Uberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607.2 Klassendokumentation . . . . . . . . . . . . . . . . . . . . . . . . 61

7.2.1 class CharReader . . . . . . . . . . . . . . . . . . . . . . . 617.2.2 class Error . . . . . . . . . . . . . . . . . . . . . . . . . . . 627.2.3 class Interpreter . . . . . . . . . . . . . . . . . . . . . . . . 637.2.4 class Intervall . . . . . . . . . . . . . . . . . . . . . . . . . 647.2.5 class Key . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657.2.6 class Parser . . . . . . . . . . . . . . . . . . . . . . . . . . 667.2.7 class Rectangle . . . . . . . . . . . . . . . . . . . . . . . . 677.2.8 class RTDisk . . . . . . . . . . . . . . . . . . . . . . . . . . 697.2.9 class RTHandle . . . . . . . . . . . . . . . . . . . . . . . . 717.2.10 class RTMemIN . . . . . . . . . . . . . . . . . . . . . . . . 727.2.11 class RTMemLN . . . . . . . . . . . . . . . . . . . . . . . 747.2.12 class RTMemNode . . . . . . . . . . . . . . . . . . . . . . 757.2.13 class RTree . . . . . . . . . . . . . . . . . . . . . . . . . . . 777.2.14 class Scanner . . . . . . . . . . . . . . . . . . . . . . . . . 797.2.15 class Timer . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

7.3 Das Dateiformat der Indexdatei . . . . . . . . . . . . . . . . . . . 81

8 rtview Implementationsdokumentation 848.1 Uberblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848.2 Klassendokumentation . . . . . . . . . . . . . . . . . . . . . . . . 85

8.2.1 class DialogOK . . . . . . . . . . . . . . . . . . . . . . . . 858.2.2 class DoubleField . . . . . . . . . . . . . . . . . . . . . . . 858.2.3 class FileLineReader . . . . . . . . . . . . . . . . . . . . . 878.2.4 class InputStreamLineReader . . . . . . . . . . . . . . . . 878.2.5 class IntegerField . . . . . . . . . . . . . . . . . . . . . . . 888.2.6 class Interpreter . . . . . . . . . . . . . . . . . . . . . . . . 898.2.7 class MultiLineLabel . . . . . . . . . . . . . . . . . . . . . 908.2.8 class NumberField . . . . . . . . . . . . . . . . . . . . . . 918.2.9 class RT . . . . . . . . . . . . . . . . . . . . . . . . . . . . 928.2.10 class rtview . . . . . . . . . . . . . . . . . . . . . . . . . . 948.2.11 class RectangleCanvas . . . . . . . . . . . . . . . . . . . . 948.2.12 class Zoom . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

A Hilfsprogramme 98A.1 rtconv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98A.2 Programme zum Erzeugen der Zufallstestdaten . . . . . . . . . 98

A.2.1 randomized1 und randomized2 . . . . . . . . . . . . . . 98A.2.2 checkered . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

Literatur 102

6

Abbildungsverzeichnis

1.1 Grafische Darstellung. m=2 und M = 4 . . . . . . . . . . . . . . . 111.2 Schema der Datenstruktur . . . . . . . . . . . . . . . . . . . . . . 11

2.1 Suchrechteck schneidet Verzeichnisrechteck aber nicht Objekt . 142.2 Varianten der Aufspaltung von Knoten . . . . . . . . . . . . . . 19

3.1 Grafische Interpretation der Ausgabe von print fur innere Knoten 263.2 Grafische Interpretation der Ausgabe von print fur Blattknoten . 263.3 Grafische Interpretation der Ausgabe des print level Befehls . . . 273.4 Grafische Interpretation des Suchergebnisses . . . . . . . . . . . 30

4.1 Das Hauptfenster von rtview . . . . . . . . . . . . . . . . . . . . . 324.2 Das Kommandofenster von rtview . . . . . . . . . . . . . . . . . 334.3 Das Popup-Menu im Grafikfenster . . . . . . . . . . . . . . . . . 334.4 Das Grafikfenster von rtview . . . . . . . . . . . . . . . . . . . . . 344.5 Das Statistikfenster von rtview . . . . . . . . . . . . . . . . . . . . 35

7.1 Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

8.1 Klassendiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

A.1 Listing von random1 . . . . . . . . . . . . . . . . . . . . . . . . . 99A.2 Listing von random2 . . . . . . . . . . . . . . . . . . . . . . . . . 100A.3 Listing von checkered . . . . . . . . . . . . . . . . . . . . . . . . 101

7

Kapitel 1

Motivation und Uberblick

Um raumliche Daten effizient zu speichern, genugen die herkommlichen In-dexstrukturen wie B- und B+-Baum nicht mehr. Bei diesen findet eine Indexie-rung nur in einer Dimension statt. Eine Losung, um auch im mehrdimensiona-len effizient zu suchen, ist der R-Baum, welcher erstmals in [Gut84] beschrie-ben wurde.

Der R-Baum ist eine Zugriffsmethode, die mittels umgebender Rechtecke,raumliche Daten indiziert, um einen effizienten Zugriff zu gewahrleisten.

1.1 Einordnung

R-Baume sind, wie auch B+-Baume, eine vollstandig dynamische Datenstruk-tur. Der Hauptunterschied zwischen R-Baumen und B+-Baumen resultiert ausder Art der zu speichernden Daten und der typischen Anfragen. WahrendB+-Baume zu den Point Access Methods (PAM) zahlen, gehoren R-Baume zuden Spatial Access Methods (SAM). Insbesondere ist aber der R-Baum auch einhohenbalancierter Baum.

1.2 Aufbau

Die Knoten eines R-Baumes speichern n-dimensionale Rechtecke. Fur die n-dimensionale Datenstruktur des R-Baum gilt fur die Angabe der RechteckeI = (I0, I1, . . . , In−1), wobei Ii eindimensionale Intervalle beschreiben.

• Innere Knoten haben Eintrage der Form (child, I). Dabei steht child fureinen Verweis auf einen Kindknoten und I fur das kleinste Rechteck,das alle Rechtecke des Kindknotens und somit den kompletten Teilbaum

8

uberdeckt. I steht hier fur ein (mehrdimensionales) Intervall.

• Blatter im R-Baum haben Eintrage der Form (key, I). Hierbei steht key furden Schlussel (welcher ggf. eine Referenz auf ein Objekt in einer Daten-bank ist). Raumliche Daten einer Datenbank konnen so durch Lage undAusdehnung ihrer kleinsten umgebenden Rechtecke I beschrieben wer-den.

• Das Rechteck, das alle Rechtecke eines Knotens uberdeckt und zudemminimal ist, wird Verzeichnis-Rechteck (directory-rectangle) genannt. DieVerzeichnis-Rechtecke eines Baumes konnen Uberschneidungen aufwei-sen, so daß Suchpfade in einem R-Baum nicht eindeutig sein mussen.

Die Struktur wird gepragt durch die minimale und maximale Anzahl von Ein-tragen in einem Knoten m bzw. M. Diese Werte sind Implementierungsvorga-ben und bestimmen unter anderem die Effizienz der Datenstruktur. Es gilt

2≤m≤ M

2.

1.2.1 Definierende Eigenschaften

1. Außer der Wurzel haben alle Blatter zwischen m und M Index-Eintrage

2. Fur jeden Index-Eintrag (key, I) in einem Blatt ist I das kleinste umgeben-de Rechteck, der raumlichen Daten, die durch key spezifiziert werden.

3. Jeder Knoten, der kein Blatt und nicht die Wurzel ist, hat zwischen m

und M Kinder.

4. Fur jeden Index-Eintrag (child, I) in einem Blatt, ist I das kleinste Rechteck,daß die Rechtecke des Teilbaums child uberdeckt.

5. Die Wurzel hat mindestens zwei Kinder oder ist ein Blatt

6. Alle Blatter liegen auf der gleichen Hohe.

Einfache Folgerungen

Die Hohe eines R-Baums fur N Index-Eintrage ist maximal dlogm Ne, da derVerzweigungsfaktor jedes Knotens mindestens m ist.

Die maximale Anzahl an Knoten ist∣∣∣∣Nm∣∣∣∣+ ∣∣∣∣ N

m2

∣∣∣∣+ · · ·+1.

9

Im schlechtesten Fall liegt die Speicherauslastung der Knoten, bis auf die Wur-zel, bei m

M . Im allgemeinen werden die Knoten aber dazu tendieren mehr als m

Eintrage zu haben, was dann die Baumhohe verringert und die Speichereffizi-enz verbessert.

Die Anderung der Parameter m und M sind eine Optimiermoglichkeit. So wer-den durch große M Baume erzeugt, die sehr breit werden. Es mussen dann beijedem Suchvorgang viele Eintrage in den Knoten sequentiell gepruft werdenund gegebenenfalls viele Teilbaume durchsucht werden. Wahlt man M sehrklein, wachst der Baum sehr schmal und hoch. Es werden sehr viele Knotenerzeugt, die keinen Schlussel enthalten. Die Speichereffizienz ist gering.

1.2.2 Beispiele

Implementation der Datenstruktur

#define dimension 2

#define M 5

typedef t_pos int;

typedef t_key int;

struct intervall

{

t_pos from, till;

}

struct r_node

{

intervall I[dimension];

r_node *child;

t_key key;

}

1.2.3 Verzeichnis-Rechtecke

Das allgemeine Problem fur R-Baume ist nun: “Finde, fur eine beliebige Men-ge von Rechtecken, Verzeichnis-Rechtecke, mit zwischen m und M Eintragen,so daß beliebige Operationen mit Abfrage-Rechtecken, wie Suchen, Einfugen,Loschen und Andern, effizient unterstutzt werden.”

Methoden (und deren Optimierungen) unterscheiden sich in der dynamischenErzeugung dieser Verzeichnis-Rechtecke.

10

Verzeichnis-Rechteck Blatteintrag

R7

R8

R6

R5

R4

R3

R2

R1

Root

Abbildung 1.1: Grafische Darstellung. m=2 und M = 4

R7 R8R6R6R5R4R3

R1 R2

Abbildung 1.2: Schema der Datenstruktur

11

1.3 Kriterien fur effiziente Anfragen

Diese Kriterien wurden in [BKSS90] zusammengefaßt.

K1 Flachenminimierung der RechteckeHierbei soll die Flache der Verzeichnisrechtecke, die keine Rechteckedes entsprechenden Teilbaumes uberdeckt, minimiert werden. Als Fol-ge konnen Entscheidungen bezuglich des Suchpfades im allgemeinenschon auf hoherer Ebene getroffen werden.

K2 Minimale Uberlappung der Verzeichnis-RechteckeDadurch minimiert man die Anzahl der zu unterscheidenden Pfade.

K3 Randminimierung der Verzeichnis-RechteckeAls Rand bezeichnet man hier die Summe der Kantenlangen eines Recht-ecks. Wenn wir die Flache als gegeben betrachten, dann ist das Quadratdas Rechteck mit dem kleinsten Rand. Durch die Minimierung des Ran-des werden Verzeichnisrechtecke also eher quadratisch geformt. Da nundiese Rechtecke leichter zu bundeln bzw. zu packen sind, wird das um-gebende Rechteck vieler Quadrate auch kleiner.

K4 Optimierung der SpeicherausnutzungEine bessere Fullung der Knoten impliziert im allgemeinen auch eineSenkung der Anfragekosten, da vollere Knoten den Baum flacher haltenund somit weniger Speicherzugriffe notwendig sind.

Der R-Baum in seiner Standardform (in [Gut84] beschrieben) verfolgt nur K1und teilweise K2. Die anderen Kriterien werden erst von den Erweiterungendes R-Baums, dem R∗-Baum (vgl. [BKSS90]) betrachtet. Beim R∗-Baum entwarfman Algorithmen, die zuzuglich den Rand und den Schnitt von Verzeichnis-Rechtecken berucksichtigen.

12

Kapitel 2

Algorithmen

Samtliche Algorithmen sind Umsetzungen der Beschreibungen aus [Gut84].

2.1 Suchen

Der Suchalgorithmus durchlauft den Baum von der Wurzel an abwarts, ahn-lich dem Suchen in einem B-Baum. Beachtet werden muß, daß gegebenenfallsmehr als ein Teilbaum von jedem besuchten Knoten aus durchlaufen werdenmuß. Daraus folgt, daß es nicht moglich ist, eine nicht-triviale Abschatzungfur die worst-case-Performance anzugeben, denn im schlimmsten Fall muß derkomplette Baum durchsucht werden.

Der Einfuge-Algorithmus wird, wenn moglich, den Baum in einer Form belas-sen, die es dem Suchalgorithmus erlaubt, irrelevante Regionen im indiziertenRaum zu eliminieren und nur Daten in der Nahe des Suchgebietes zu unter-suchen.

Search

Gegeben sei ein R-Baum mit Wurzel T. Gesucht werden alle Index-Eintrage,die das Suchrechteck S schneiden.

S1 Durchsuche die TeilbaumeWenn T kein Blatt ist, prufe jeden Eintrag E(child, I) darauf, ob E.I sich mitS schneidet. Fur alle schneidenden Eintrage rufe nun den Suchalgorith-mus fur den Teilbaum E.child auf.

S2 Durchsuche die Blatt-KnotenWenn T ein Blatt ist, prufe alle Eintrage E(key, I) darauf, ob E.I sich mit S

schneidet. Wenn ja, so ist E.key ein Suchergebnis.

13

Bemerkung Wenn das Suchrechteck das Verzeichnisrechteck schnei-det, folgt daraus nicht unmittelbar, daß auch das Objekt, welches mitdem Verzeichnisrechteck beschrieben wird, das Suchrechteck schneidet.Hier muß gegebenenfalls noch eine zusatzliche Uberprufung stattfinden.

Verzeichnisrechteck

Suchrechteck

Objekt

Abbildung 2.1: Suchrechteck schneidet Verzeichnisrechteck aber nicht Objekt

2.2 Einfugen

Das Einfugen neuer Index-Eintragen zu Daten-Tupeln ist ahnlich demEinfugen in B-Baumen. Neue Index-Eintrage werden zu den Blattern hinzu-gefugt. Knoten, die uberlaufen, werden geteilt und diese Teilungen setzen sichim Baum nach oben fort.

Insert

Fuge einen neuen Index-Eintrag E in einen R-Baum ein.

I1 Finde Position fur den neuen EintragRufe ChooseLeaf auf um ein Blatt L zu finden, in das E eingetragen wer-den soll.

I2 Fuge Eintrag zum Blatt hinzuWenn L genug Platz fur einen weiteren Eintrag hat, dann fuge E ein.Sonst rufe SplitNode um L und LL zu erhalten, welche E und alle altenEintrage von L enthalten.

14

I3 Fortpflanzen der Anderungen nach obenRufe AdjustTree auf L auf. Wenn eine Teilung erfolgte, dann rufe Ad-justTree auch mit LL auf.

I4 Lasse den Baum großer wachsenWenn die Knotenspaltung sich soweit fortgepflanzt hat, daß nun auchdie Wurzel gespalten werden muß, erzeuge eine neue Wurzel, deren Kin-der die beiden Knoten der aufgespaltenen alten Wurzel sind.

ChooseLeaf

Wahle einen Blattknoten, in den ein neuer Index-Eintrag E eingefugt werdenkann.

CL1 InitialisierungSetze N auf den Wurzelknoten.

CL2 BlattprufungWenn N ein Blatt ist, dann gib N zuruck.

CL3 Wahle TeilbaumWenn N kein Blatt ist, dann sei F der Eintrag in N, dessen Flache desRechtecks F.I die kleinste Vergroßerung benotigt, um E.I zu uberdecken.Wenn dieser nicht eindeutig ist, dann wahle das Rechteck mit der klein-sten Flache.

CL4 Steige ab, bis ein Blatt erreicht istSetze N auf den Kindknoten F.child und fahre fort bei CL2.

AdjustTree

Steige von einem Blatt L bis zur Wurzel auf und passe dabei die Verzeichnis-rechtecke an und teile Knoten, wenn notwendig.

AT1 InitialisierungSetze N = L. Wenn L vorher geteilt wurde, dann setze NN auf den entstan-denen zweiten Knoten.

AT2 Prufen ob fertigWenn N die Wurzel ist, dann beende diesen Algorithmus.

AT3 Passe das uberdeckende Rechteck in den Elternknoten anSei P ein Elternknoten von N und sei E(N) der Eintrag von N in P. AndereE(N).I so, daß es gerade noch alle Rechtecke in N uberdeckt.

15

AT4 Pflanze die Knotenaufspaltung nach oben fortWenn N einen Partner NN hat, der durch eine fruhere Aufspaltung ent-stand, dann erzeuge einen neuen Eintrag E(NN), wobei E(NN).child auf NN

zeigt und E(NN).I alle Rechtecke in NN uberdeckt. Fuge E(NN) zu P hinzu,wenn noch Platz ist. Sonst rufe SplitNode auf, um P und PP zu erzeugen,welche E(NN) und alle alten Eintrage von P enthalten.

AT5 Steige eine Stufe aufSetze N = P. Wenn eine Aufspaltung stattfand, dann setze auch NN = PP.Fahre fort mit AT2.

Der Algorithmus SplitNode wird in 2.5 auf Seite 18 beschrieben.

2.3 Loschen

Losche einen Index-Eintrag E aus einem R-Baum.

Delete

D1 Finde den Knoten mit dem zu loschenden EintragRufe FindLeaf auf, um den Knoten L zu finden, der den Eintrag E

enthalt. Beende den Algorithmus wenn der Knoten nicht gefunden wer-den konnte.

D2 Losche den EintragLosche E aus L.

D3 Pflanze Anderungen fortRufe CondenseTree auf mit Parameter L.

D4 Verkurze den BaumWenn die Wurzel nur ein Kind hat, nachdem der Baum ausbalanciertwurde, dann mache dieses Kind zur neuen Wurzel.

FindLeaf

Gegeben ist ein R-Baum mit Wurzel T. Finde den Blatt-Knoten, der den Index-Eintrag E enthalt.1

FL1 Durchsuche die TeilbaumeWenn T kein Blatt ist, prufe jeden Eintrag F von T darauf, ob E.I von F.I

1 Diese Suche ist analog dem Suchen in 2.1 auf Seite 13

16

uberdeckt wird. Fur jeden solchen Eintrag rufe nun erneut FindLeaf aufmit dem Teilbaum, desse Wurzel F.child ist, bis E gefunden wurde oderalle Eintrage gepruft wurden.

FL2 Durchsuche den Blattknoten nach dem EintragWenn T ein Blatt ist, prufe jeden Eintrag, ob er mit E ubereinstimmt.Wenn E gefunden wurde, dann liefere T zuruck.

CondenseTree

Gegeben ist ein Blatt-Knoten L, von dem ein Eintrag geloscht wurde. Loschediesen Knoten, wenn er zu wenig Eintrage hat, siedele seine Eintrage in ande-re Knoten um. Pflanze diese Knotenloschung fort, falls notwendig. Passe alleuberdeckenden Rechtecke auf dem Weg zur Wurzel an und mache sie kleiner,wenn moglich.

CT1 InitialisierungSetze N = L. Setze Q, die Menge der geloschten Knoten, auf leer.

CT2 Suche den Eltern-EintragWenn N die Wurzel ist, fahre fort bei CT6. Ansonsten sei P der Vater vonN, und sei E(N) der Eintrag von N in P.

CT3 Losche unterfullte KnotenWenn N weniger als m Eintrage hat, dann losche E(N) aus P und fuge N

zu Q hinzu.

CT4 Passe uberdeckende Rechtecke anWenn N nicht geloscht wurde, dann passe E(N).I so an, daß es geradenoch alle Eintrage von N uberdeckt.

CT5 Steige eine Stufe im Baum aufSetze N = P und fahre fort mit CT2.

CT6 Fuge die verwaisten Knoten einFuge nun alle Eintrage der Knoten der Menge Q wieder ein. Eintragevon geloschten Blatt-Knoten werden eingefugt, wie in Insert beschrie-ben. Eintrage von hoherliegenden Knoten mussen hoher im Baum ein-gefugt werden, so daß die Blatter ihrer anhangenden Teilbaume auf dergleichen Hohe sind, wie die Blatter des Hauptbaumes.

17

2.4 Andere Operationen

2.4.1 Andern

Wenn ein Datentupel geandert wird, so daß sich sein Verzeichnisrechteckandert, muß sein Index-Eintrag geloscht und mit den neuen Werten wiederein-gefugt werden. Durch die Anderung des Verzeichnisrechtecks, andern sich inder Regel auch die Verzeichnisrechtecke auf hoheren Stufen. Der Baum wurdeineffizient werden, wenn man diesen Eintrag nun an der gegebenen Positionbelassen wurde. Da man den Eintrag also an eine neue Position im Baum ver-schieben muß, ist der effizienteste Weg, den Eintrag zu loschen und komplettneu in den Baum einzufugen.

2.4.2 Suchvarianten

Andere Arten des Suchens, die nicht wie im obigen Beispiel die Rechtecke, dievon einem Suchrechteck geschnitten werden, finden, sondern zum Beispielalle Rechtecke, die einen Punkt oder ein Suchrechteck uberdecken oder al-ler Rechtecke, die in einem Suchrechteck enthalten sind finden, konnen durcheinfache Variationen des Search-Algorithmus erreicht werden. Hierzu andertman im Algorithmus einfach den Vergleich in S1 und S2 in die entsprechendeOperation. Zu bemerken ware, daß fur eine Suche, die alle Rechtecke findet,die in einem Suchrechteck enthalten sind, das Problem aus 2.1 auf Seite 14nicht auftritt.

Eine Suche, die nach einem Eintrag, dessen Index-Eintrag E man kennt, wirdvom Losch-Algorithmus benotigt und kann durch eine leichte Variation desFindLeaf-Algorithmus erzeugt werden.

2.4.3 Bereiche loschen

Varianten des Bereich-Loschen, in dem alle Eintrage, die in einem bestimmtenRechteck liegen, geloscht werden, sind auch durch einfache Variationen dervorhandenen Algorithmen moglich, indem man die Algorithmen Search undDelete passend kombiniert. Das heißt man benutzt das Ergebnis aus Searchals Eingabe fur Delete.

2.5 Knoten aufteilen

Wenn man einen neuen Eintrag in einen vollen Knoten mit M Eintragen hin-zufugen mochte, ist es notig die M + 1 Eintrage auf zwei Knoten aufzu-

18

Gute AufspaltungSchlechte Aufspaltung

Abbildung 2.2: Varianten der Aufspaltung von Knoten

teilen. Diese Aufteilung soll so stattfinden, daß nachfolgende Suchvorgangemoglichst nicht beide Teilbaume durchsuchen mussen. Die Entscheidung, obein Teilbaum besucht werden muß oder nicht, hangt davon ab, ob das Ver-zeichnisrechteck eines Knoten den Suchbereich uberdeckt oder nicht. Die Ge-samtflache2 der beiden entstehenden Verzeichnisrechtecke soll minimal sein.

Dieselben Kriterien benutzt man in der Prozedur ChooseLeaf, um zu entschei-den, wo ein neuer Index-Eintrag eingefugt werden soll. In jeder Stufe im Baumwurde der Teilbaum gewahlt, dessen Verzeichnisrechteck am wenigsten ver-großert werden mußte.

Wir betrachten nun den Algorithmus zum Aufteilen der M + 1 Eintrage in zweiGruppen.

2.5.1 Der triviale Algorithmus

Der offensichtliche Weg, die minimale Flache der aufgeteilten Knoten zu fin-den, ist alle moglichen Gruppierungen zu finden und die beste zu wahlen. DieAnzahl der moglichen Gruppierungen ist 2M−1 und fur einen Wert fur M vonzum Beispiel 50 wird die Anzahl der Moglichkeiten3 sehr groß.

2.5.2 Ein Algorithmus mit quadratischen Kosten

Dieser Algorithmus versucht eine Aufteilung mit kleinen Flachen zu finden,aber garantiert nicht, daß er die Aufteilung mit der kleinstmoglichen Flachefindet. Die Kosten dieses Algorithmus sind O(M2).

2 Hier konnen je nach Optimierkriterium andere Aspekte in den Vordergrund treten3 Ein zweidimensionales Rechteck kann durch vier Zahlen zu je vier Byte reprasentiert wer-

den. Wenn ein Zeiger ebenfalls vier Byte benotigt, so benotigt jeder Eintrag 20 Bytes. Eine Seitemit 1024 Byte kann also 50 Eintrage enthalten. Die Zahl 50 ist also gar nicht so abwegig.

19

Der Algorithmus wahlt die zwei der M + 1 Eintrage als Startelemente derzwei neuen Gruppen aus, welche das großte Verzeichnisrechteck benotigenwurden, wenn sie beide in einer Gruppe liegen wurden. Die verbleibendenEintrage werden dann nacheinander den Gruppen zugewiesen. Bei jedemSchritt wird berechnet, um wieviel sich die Flache erhohen wurde, wenn dasneue Element zur Gruppe hinzugefugt wurde und es wird dann der Gruppehinzugefugt, in der der Flachenzuwachs kleiner ist.

QuadraticSplit

Teile eine Menge von M + 1 Index-Eintragen in zwei Gruppen auf.

QS1 Wahle den ersten Eintrag fur jede GruppeFuhre den Algorithmus PickSeeds aus, um zwei Eintrage zu wahlen,welche die ersten Elemente der Gruppen werden. Weise jedes einerGruppe zu.

QS2 Prufen ob der Algorithmus fertig istWenn alle Eintrage zugewiesen wurden, dann beende den Algorithmus.Wenn eine Gruppe so wenig Eintrage hat, daß ihr alle verbleibenden Ein-trage zugewiesen werden mussen, um die minimale Anzahl m zu errei-chen, dann weise sie zu und beende den Algorithmus.

QS3 Wahle Eintrag und weise ihn einer Gruppe zuRufe den Algorithmus PickNext auf, um den nachsten Eintrag, der zuge-wiesen werden soll, zu wahlen. Wahle die Gruppe nach folgender Stra-tegie:4

1. Wahle die Gruppe, deren Verzeichnisrechteck am wenigsten ver-großert werden muß, um den neuen Eintrag zu uberdecken.

2. Wahle die Gruppe, deren Verzeichnisrechteck kleiner ist.

3. Wahle die Gruppe, die weniger Elemente hat.

4. Wahle eine beliebige Gruppe.

Fahre fort mit QS2.

PickSeeds

Wahle die zwei Elemente, welche die ersten in den beiden Gruppen sein sol-len.

4 Das heißt wahle zuerst die Gruppe nach 1. Wenn das nicht eindeutig ist, dann nach 2. usw.

20

PS1 Berechne die verschwendete Flache des Verzeichnisrechtecks, wenn zwei Elemen-te gruppiert werdenFur jedes Paar von Eintragen E1 und E2, erzeuge das minimale RechteckJ, welches E1.I und E2.I enthalt. Berechne

d = Flache(J)−Flache(E1.I)−Flache(E2.I).

PS2 Wahle das verschwenderischste PaarWahle das Paar mit dem großten d.

PickNext

Wahle einen verbleibenden Eintrag, um ihn einer Gruppe zuzuordnen.

PN1 Berechne die Kosten fur jeder EintragFur jeden Eintrag E, der noch nicht einer Gruppe zugeordnet wurde,berechne d1 = der Flachenzuwachs des Verzeichnisrechteck der erstenGruppe, wenn sie a. tE.I enthalten wurde. Berechne d2 analog fur diezweite Gruppe.

PN2 Wahle Eintrag mit der Praferenz fur eine GruppeWahle den Eintrag mit der großten Differenz zwischen d1 und d2.

2.5.3 Ein Algorithmus mit linearen Kosten

Dieser Algorithmus ist linear zu M und zur Anzahl der Dimensionen. Linear-Split ist identisch zu QuadraticSplit benutzt aber eine andere Version vonPickSeeds. PickNext wahlt einfach irgendeinen der verbliebenen Eintrage.

LinearPickSeeds

Wahle zwei Eintrage, welche die ersten Elemente der zwei Gruppen bilden.

LPS1 Finde die extremen Rechtecke uber alle DimensionenFinde fur jede Dimension die Rechtecke, welche die hochste und dieniedrigste Koordinate annehmen.

LPS2 Reguliere die Form des Rechteck-ClustersNormalisiere die gefundenen Rechtecke durch Division mit der Streckezwischen Minimal- und Maximalwert in jeder Dimension.

LPS3 Wahle das extremste PaarWahle das Paar, mit der großten normalisierten Separierung in einer Di-mension.

21

Kapitel 3

Bedienungsanleitung zu rt

Um das Verhalten und die Leistungsfahigkeit von R-Baumen zu studieren,wurde das Programm rt entwickelt, welches es ermoglicht mit dieser Daten-struktur zu experimentieren.

Die Algorithmen sowie die entsprechenden Datenstrukturen wurden ob-jektorientiert in der Programmiersprache C++ sowie unter Benutzung derStandard-Template-Library (STL) implementiert.

3.1 Installation

Ein vorhandenes Binary fur das entsprechende System kann ohne vorheri-ge Installation gestartet werden. Um es ohne Pfadangabe starten zu konnen,muß es in ein Verzeichnis kopiert werden, welches von der Shell fur executa-bles durchsucht wird. In der Regel sind diese in der Umgebungsvariablen PATH

definiert.

Um aus den Quelldateien ein Programm zu generieren, entpacke man al-le Quelldateien (Endung hpp und cpp) sowie das Makefile aus der Dateirt.tar.gz in ein Verzeichnis. Den Ubersetzungsvorgang stoße man nun mitmake build an. Standardmaßig wird mit dem Compiler g++ ubersetzt, welcherein C++-Compiler nach ANSI-Standard sein muß (zum Beispiel egcs 1.1.2 abBuild 2.91.66).

3.2 Start

Das Programm rt wird in der Kommandozeile mit dem gleichnamigen Befehlgestartet. Folgende Kommandozeilenoptionen stehen zur Verfugung:

22

-warn n setzt den Warn-Level auf die Stufe n mit n ∈ {1, . . . ,6}, wobei einhoherer Wert bedeutet, daß mehr Meldungen ausgegeben werden. DerDefault-Wert ist 5.

-M n setzt die maximale Anzahl an Eintragen je Knoten auf n. Der Default-Wert ist 5. Zu beachten ist, daß M immer die Ungleichung 2 ≤ m ≤ M

2

erfullt, ansonsten wird das Programm mit einer Fehlermeldung beendet.

-m n setzt die maximale Anzahl an Eintragen je Knoten auf n. Der Default-Wert ist 2. Zu beachten ist, daß m immer die Ungleichung 2 ≤ m ≤ M

2

erfullt, ansonsten wird das Programm mit einer Fehlermeldung beendet.

-cache n setzt die Anzahl der Eintrage, die maximal gleichzeitig im Cache ge-halten werden sollen auf n. Der Default-Wert ist 100.

-p path setzt den Pfad, in dem die Index-Datei erzeugt werden soll, auf path.

-f file benutzt file als Index-Datei. Wenn file noch nicht existiert, wird versuchtdie Datei im aktuellen Verzeichnis, bzw. falls -p angegeben wurde imangegebenen Verzeichnis zu erzeugen. Wenn -f nicht angegeben wird,wird eine temporare Index-Datei erzeugt, die nach Beenden des Pro-gramms wieder geloscht wird.

-i Mit Angabe dieses Schalters, wird das Programm in den interaktiven Mo-dus geschaltet, in dem es die direkte Kommunikation erleichtert.

-t Dieser Schalter gibt nach jedem Befehl die benotigte Zeit in Millisekundenauf der Standardausgabe aus. Diese Option ist unbedingt notig, wenn rtaus rtview heraus gestartet werden soll.

Ein typischer Aufruf sieht also folgendermaßen aus:

rt -f myindex.rt -i

Nach dem Start wartet das Programm auf Eingaben uber die Standardeinga-be und gibt Ergebnisse auf der Standardausgabe zuruck. Fehler werden uberden Standardfehlerkanal geliefert. rt kann selbstverstandlich auch mit einerSteuerdatei aufgerufen werden. Ein solcher Aufruf kann folgendermaßen aus-sehen:

rt -f myindex.rt < control.txt

3.3 Befehle

Das Programm wird uber Befehle gesteuert, die eine recht einfache Strukturhaben. Jeder Befehl hat die Form:

23

COMMAND [OPTION] [PARAMETER]

Ein Zeilenvorschub (Return) wird als Befehlsende interpretiert. Mehrere Be-fehle konnen in eine Zeile geschrieben werden, indem sie mit einem Semiko-lon getrennt werden. Leerzeilen werden ignoriert.

3.3.1 Befehlsreferenz

Die folgenden Befehle sind sowohl Befehle die der Benutzer im interaktivenModus eingeben kann, als auch die Befehle, die rtview benutzt um rt zu steuern.Es folgt nun ein alphabetischer Uberblick uber die Befehle.

insert

Mit insert werden neue Eintrage in den R-Baum eingefugt. Ein Eintrag wirdspezifiziert durch einen numerischen Schlussel und sein Verzeichnisrechteck.Der Syntax des Befehls ist

insert key rectangle

Ein Rechteck wird als (x1, y1, x2, y2) eingegeben, wobei x1, y1 die x- und y-Koordinate der oberen linken Ecke und x2 und y2 die x- und y-Koordinateder unteren rechten Ecke des Verzeichnisrechtecks sind. Ein Beispielaufruf desBefehls ist

insert 2 (10, 10, 15, 19)

flush

Samtliche Knoten werden generell extern in der Index-Datei gespeichert undbearbeitet. Um die Zugriffsanzahl auf diese Datei so gering wie moglich zuhalten, werden eine Anzahl bereits gelesener Knoten in einem internen Puffergehalten. Somit werden die Kosten fur ein erneutes Lesen reduziert, also dieGeschwindigkeit erhoht.

Durch Eingabe des Befehls flush wird der Cache geloscht. Samtliche geander-ten Eintrage werden spatestens jetzt in die Index-Datei geschrieben. Der Befehlhat keine Parameter oder Optionen.

print

Variante 1: Ausgabe des kompletten Baums

Der Befehl print hat mehrere Optionen. Durch Eingabe ohne Parame-ter und Option, wird der komplette Baum ausgegeben. Dabei wird der

24

Baum durchlaufen und alle Knoten in dem folgenden Format ausgege-ben:

P{parent}–>type{id}: entries

Dabei ist parent die ID des Vorgangerknoten. type ist entweder L wennder Knoten ein Blatt ist oder I wenn der Knoten ein innerer Knoten ist.Die ID des Knotens selbst steht an der Position id. Die entries haben furBlatter die Form

rectangle K key

und fur innere Knoten

rectangle N {id}

wobei rectangle intervallweise in der Form [a0,b0] . . . [ad−1,bd−1], ausgege-ben werden. Dabei ist d die Dimension der Rechtecke1 und ai und bi dieuntere bzw. die obere Grenze des Intervalls in der Dimension i.

key ist ein numerischer Wert, der den Schlussel des Eintrags darstellt.Uber diesen muß der Zugriff auf die Eintrage in einer Datenbank er-folgen. Dies kann z. B. geschehen, indem der Key der row-ID der zu-gehorigen Tabelle entspricht. Der Zugriff sollte so gestaltet werden, daßer bei vorhandenem key mit einem Laufzeitverhalten von O(1) stattfin-den kann.

id ist die ID des entsprechenden Nachfolgerknotens.

Die entries besteht aus mehreren Eintragen2 dieser Form.

Eine typische Ausgabe ware

P{NONODE}–>I{ ROOT }: [9:10][2:20]N{000224} [9:10][2:20]N{000112}

fur einen inneren Knoten (hier speziell fur die Wurzel). Ein Blatt kannz. B. so aussehen:

P{ ROOT }–>L{000224}: [9:10][2:20]K1 [9:10][2:20]K2 [9:10][2:20]K3

Variante 2: Ausgabe einer Stufe des Baums

Um alle Verzeichnisrechtecke einer Stufe des Baums auszugeben kannman den Befehl

print level n

verwenden. Hiermit werden die Verzeichnisrechtecke der Stufe n ausge-geben. Fur n = 0 wird das Verzeichnisrechteck der Wurzel ausgegeben.

1 in der Regel ist diese 22 nach Definition mindestens m und maximal M

25

ROOT

000224 000112

NONODE Dummy Knoten

Innerer Knoten

Nachfolgerknoten

Abbildung 3.1: Grafische Interpretation der Ausgabe von print fur innere Kno-ten

000224

Vorgängerknoten

Blattknoten

ROOT

Blatteinträge

K1 K2 K3

Abbildung 3.2: Grafische Interpretation der Ausgabe von print fur Blattknoten

26

Wenn die Hohe des Baumes h ist, werden fur n≥ h die Verzeichnisrecht-ecke der Blatteintrage ausgegeben. Fur 0< h< n ist h die Stufe des Bau-mes, die ausgegeben werden soll.

Die Ausgabe hat die Form

# Rectangles rectangles

wobei rectangles die Verzeichniseintrage dieser Stufe in Intervallschreib-weise sind (siehe Variante 1 – Ausgabe des kompletten Baums).

Ein Ausgabe konnte z. B. so aussehen:

# Rectangles [9:10][2:20] [3:13][2:5] [1:4][4:7] [9:10][2:20] [4:8][8:10]

2 4 6 8 10 12 14 16 18 20 22

2

4

6

8

10

12

14

16

18

20

22

Abbildung 3.3: Grafische Interpretation der Ausgabe des print level Befehls

Mit dem print-Befehl ist es weiterhin moglich die Hohe des Baumes auszuge-ben und die Anzahl der momentanen im cache gehaltenen Knoten. Die Syntaxhierfur ist

27

print height

bzw.

print cache

Die Hohe eines leeren Baumes ist 0. Wenn nur die Wurzel enthalten ist, ist dieHohe 1. Die Hohe gibt an, wieviele Knoten besucht werden mussen um zueinem Blatt zu gelangen (inklusive) des erreichten Blattes.

count

Mit diesem Befehl kann das Auftreten bestimmter Elemente im Baum gezahltwerden. Im einzelnen sind dies:

count nodes zahlt die Anzahl der Knoten, also sowohl Blatter als auch innereKnoten, im Baum.

count leafs zahlt die Anzahl der Blatter im Baum.

count innernodes zahlt die Anzahl der inneren Knoten im Baum.

count branches zahlt die Anzahl der Nachfolgerknoten im Baum. Nachfol-gerknoten ist jeder Knoten, der Nachfolger eines inneren Knoten ist.

count entries zahlt die Anzahl der Eintrage in den Blattern. Diese Anzahlist gleich der Anzahl zuvor aufgerufener insert-Operationen abzuglichevtl. durchgefuhrter Loschungen. Die Anzahl entspricht nicht der An-zahl der Blatter!

filling

Mit diesem Befehl kann der durchschnittliche Fullgrad der Knoten ermitteltwerden. Im einzelnen sind dies:

filling nodes bestimmt die durchschnittliche Fullung aller Knoten. Dasarithmetische Mittel wird bestimmt durch

#Nachfolgerknoten +#Blatteintrage#Knoten

filling leafs bestimmt die durchschnittliche Fullung der Blatter. Das arith-metische Mittel wird bestimmt durch

#Blatteintrage#Blatter

28

filling innernodes bestimmt die durchschnittliche Fullung der innerenKnoten. Das arithmetische Mittel wird bestimmt durch

#Nachfolgerknoten#innere Knoten

find

In rt sind vier verschieden Suchvarianten implementiert worden. Dies sind imeinzelnen

find in rect sucht alle Eintrage, die sich innerhalb eines Suchrechtecksrect befinden.

find intersect rect sucht alle Eintrage, die das Suchrechteck rect schnei-den.

find contain rect sucht alle Eintrage, die das Suchrechteck rect enthal-ten.

find point x y sucht alle Eintrage, die den Punkt (x , y ) enthalten.

Die Suchrechtecke werden immer in der Form (x1, y1, x2, y2) erwartet. Die Ko-ordinaten sind dabei, wie auch die Parameter von find point ganzzahlige po-sitive Zahlen.

Als Ausgabe liefert rt eine Liste gefundener Rechtecke in folgender Form

# Found result 1 . . . result n

Wenn kein Ergebnis gefunden wurde ist n = 0. Es wird also kein result i hin-ter # Found ausgegeben. Ansonsten haben die Ergebnisse die gleiche Form wiedie Ausgabe der Blatter beim Befehl print.

Eine Beispielausgabe ware:

# Found [1:3][2:4]K1 [4:7][1:5]K2

Bemerkung Es gilt zu beachten, daß bei allen Suchergebnissen außer beifind in noch zu prufen ist, ob auch die gefundenen Objekte und nicht nurihre Verzeichnisrechtecke, das Suchkriterium erfullen.3

3 siehe auch 2.1 auf Seite 14

29

2 4 6 80

0

2

4

6

8

K1K2

Abbildung 3.4: Grafische Interpretation des Suchergebnisses

quit und exit

Mit diesen Befehlen wird das Programm beendet. Das Programm wird auchbeendet, wenn es uber den Eingabestrom ein End of file Signal erhalt. Dieseslaßt sich unter den meisten Unix-Shells mit der Tastenkombination Ctrl-D er-zeugen.

3.3.2 Generelle Ruckgabedaten

Nach Ausfuhrung von jedem Befehl wird, neben der befehlsspezifischen Aus-gabe, die verstrichene Zeit fur den letzten Befehl in Millisekunden zuruckge-geben. Diese Ausgabe hat die Form:

# Elapsed n ms.

wobei n die Anzahl der Millisekunden ist.

30

Kapitel 4

Bedienungsanleitung zu rtview

Die grafische Benutzeroberflache rtview dient zum Experimentieren mit R-Baumen zu experimentieren. Diese wurde in Java entwickelt und benutztrt durch Kommunikation uber den Standardeingabe-, Standardausgabe- undStandardfehlerkanal. Die Befehle konnen grafisch eingegeben und die Ausga-ben visualisiert werden.

Die Oberflache eignet sich in der Regel nur fur eine geringe Anzahl von Ope-rationen, da sowohl die Ubersichtlichkeit der grafischen Ausgabe bei großerAnzahl nicht mehr gegeben ist, als auch die derzeitige Leistungsfahigkeit derImplementation einiger Java-internen Routinen ein effizientes Arbeiten ver-hindern.

4.1 Installation

rtview erfordert ein lauffahiges Java Runtime Environment (JRE) sowie rtlauffahig installiert.1 Die Java-Klassendateien konnen mit dem zugehorigenMakefile mit make java erzeugt werden. Alternativ ist auch eine Kapselungmit jar2 moglich.

4.2 Start

Gestartet wird rtview ublicherweise mit java rtview bzw. uber einen entspre-chenden Wrapper. Um rtview zu starten, muß ein lauffahiges Java-Runtime-Environment ab Version 1.1.3 installiert sein. Weiterhin muß rt lauffahig aufdem System installiert sein. Alle Kommandozeilenoptionen die angegeben

1 siehe 3.1 auf Seite 222 siehe Dokumentation zum JDK [Sun97]

31

werden, werden an den voreingestellten Startaufruf von rt angehangt. Um al-so mit einem bestehenden Index zu starten kann man zum Beispiel schreiben:

java rtview -f meinIndex.idx

Die fur rtview notwendige Option -t ist voreingestellt im Startkommando vonrt eingefugt.

4.3 Fensterbeschreibung

4.3.1 Das Hauptfenster RT View

Abbildung 4.1: Das Hauptfenster von rtview

Das Hauptfenster (siehe Abbildung 4.1) enthalt ein Menu, uber das weitereFenster aktiviert werden konnen und das Programm beendet werden kann.Weiterhin existiert ein Schalter, uber den rt gestartet und beendet werdenkann. Eine Eingabezeile enthalt den Startaufruf von rt. Hier konnen wahlweiseauch alle Optionen, die in der Eingabezeile eingegeben werden konnen, ange-geben werden. Wichtig: Es muß immer die Option -t angegeben werden, da sonstrtview nicht korrekt arbeitet! Weiterhin wird im Hauptfenster die Ausfuhrungs-zeit des letzten Befehls angezeigt.

4.3.2 Das Kommandofenster Command

Das Kommandofenster (siehe Abbildung 4.2) protokolliert alle Befehle in derForm, die der Benutzer auch in der direkten Kommunikation mit rt gebrau-chen wurde. Auch Befehle die grafisch im Fenster Graphic View eingegebenwurden, erscheinen hier in ihrer Textreprasentation. Weiterhin werden alleRuckgaben uber die Standardausgabe hier ausgegeben. Uber dem Protokoll-textfeld findet sich eine Eingabezeile, in der ein Befehl direkt an rt abgesendetwerden kann. Dies entspricht einer Eingabe an rt im interaktiven Modus.

Es findet sich weiterhin ein Schalter Clear, der das Ausgabefenster loscht undein Schalter Submit, der den Befehl der in der Eingabezeile steht erneut an rt

32

Abbildung 4.2: Das Kommandofenster von rtview

sendet.

4.3.3 Das Grafikfenster Graphic View

In diesem Fenster werden die Befehle grafisch dargestellt und konnen eben-so eingegeben werden. Unterhalb des Grafikfeldes finden sich Schalter, umdie Vergroßerung zu andern, die Stufe des Baums, die ausgegeben wird, zuerhohen oder zu erniedrigen, den Koordinaten-Offset zu andern, sowie dieAusgabe zu aktualisieren und zu loschen. Durch Druck auf den Schalter Align

werden Offset und Zoom so berechnet, daß die komplette Ausgabe mit maxi-maler Große in das Grafikfenster passen.

Abbildung 4.3: Das Popup-Menu im Grafikfenster

Um einen Befehl grafisch einzugeben, drucke man auf dem Grafikfelddie rechte Maustaste. Es offnet sich ein Popup-Menu, mit den Eintrageninsert rectangle, Find contain, Find intersect, Find in und Find contain point. NachAuswahl eines Menupunktes andert sich der Mauszeiger in ein Fadenkreuz

33

und in der oberen linken Ecke erscheint eine Anzeige, welche die Koordinaten,in Umrechnung uber den Zoom-Faktor und den Koordinaten-Offset, anzeigt.Nach dem ersten Druck auf die linkte Maustaste wird eine Ecke des Rechtecksfestgelegt. Nun wird ein Rechteck angezeigt, daß sich mit der Bewegung derMaus andert. Der zweite Mausklick setzt die zweite diagonal gegenuber lie-gende Ecke des Rechtecks. Der Befehl ist nun komplett eingegeben und wirdan rt gesendet.

Abbildung 4.4: Das Grafikfenster von rtview

Als Ergebnis werden bei Suchanfragen die gefundenen Rechtecke hervorge-hoben in grun dargestellt. Bei einer Einfugeoperation verbleibt das eingefugteRechteck in blau im Fenster. Das Ergebnis kann durch Ausgabe der Baumesauf der untersten Stufe kontrolliert werden.

Es konnen weiterhin die Verzeichnisrechtecke der verschiedenen Stufen desBaumes dargestellt werden. Hierfur andert man einfach den Wert der Stufe,oder druckt auf den Refresh-Button um die aktuelle Stufe erneut darzustellen.

Auch Befehle, die uber das Command-Fenster eingegeben werden, konnen hiergrafisch dargestellt werden.

34

4.3.4 Das Statistikfenster Statistics

Abbildung 4.5: Das Statistikfenster von rtview

In diesem Fenster (siehe Abbildung 4.5) werden einige allgemeine Daten uberden R-Baum angezeigt. Diese sind im einzelnen:

Filling of nodes Der arithmetische Mittelwert der belegten Eintrage je Kno-ten. Entspricht

Filling of nodes =#Nachfolgerknoten +#Blatteintrage

#Knoten.

Filling of leafs Der arithmetische Mittelwert der Anzahl der belegten Blat-teintrage. Entspricht

Filling of leafs =#Blatteintrage#Blattknoten

.

Filling of inner nodes Der arithmetische Mittelwert der Anzahl der belegtenEintrage der inneren Knoten. Entspricht

Filling of inner nodes =#Nachfolgerknoten

#Innerer Knoten.

Filling of cache Anzahl der momentan im Cache gehaltenen Eintrage.

Height Die Hohe des Baumes, wobei ein Wert von 0 “kein Knoten” entsprichtund ein Wert von 1 heißt: “nur die Wurzel”.

Nodes Die Anzahl der Knoten.

Leafs Die Anzahl der Blatter. Hiermit ist nicht die Anzahl der Blatteintrage(entspricht der Anzahl der durchgefuhrten insert-Operationen) gemeint,denn jedes Blatt kann bis zu M Blatteintrage halten.

Inner nodes Die Anzahl der inneren Knoten.

35

Weiterhin findet sich ein Schalter, mit dem der Cache geloscht wird. Die Funk-tion dieses Schalters entspricht der des Befehls flush (siehe 3.3.1 auf Seite 24) inrt und einen Schalter Refresh all. Dieser entspricht der Befehlssequenz

print height; count leafs; count nodes; count innernodes; filling leafs; filling nodes;

filling innernodes; print cache;

Hiermit werden alle Werte im Statistics-Fenster aktualisiert. Diese Operationkann bei großeren Baumen einige Sekunden dauern.

36

Kapitel 5

Tests und Ergebnisse

5.1 Testspezifikation

5.1.1 Testdaten

Mit der Implementation des R-Baums rt wurden Test mit folgenden Datendurchgefuhrt:

ATKIS Dies ist ein reale Datenbank, welche geographische Objekte der StadtHannover enthalt. Die Datenbank enthalt 6312 Tupel.

checkers Diese Datenbank enthalt schachbrettartig angeordnet quadratischedisjunkte Rechtecke.

random1 Dies sind Rechtecke, bei denen Start- und Endpunkt zufallig auseinem Intervall ermittelt werden

random2 Dies sind Quadrate, deren Position zufallig ermittelt wird, wahrendihre Kantenlange einen konstanten Wert haben.

Bei den Tests checkers, random1 und random2 werden Indexe fur 10 000, 100 000und 1 000 000 Eintrage erzeugt.

5.1.2 Testumgebung

Die Tests wurden auf dem folgenden System durchgefuhrt:

Prozessor Cyrix 6x86 P150+Taktfrequenz 120 MHzSpeicher 64 MByteBetriebssystem Linux (Kernel 2.2.9)Compiler egcs-2.91.66 19990314 (egcs-1.1.2 release)

37

5.1.3 Testanfragen

Bei derartigen Tests stellt sich immer die Frage, welche Anfragen ein moglichstreprasentatives Verhalten wiederspiegeln. Um diese Anfragen zu bestimmen,sollen hier erst die moglichen Anfragen aufgelistet werden und dann aquiva-lente Anfragen eliminiert werden.

Mogliche Anfragen

• Das Einfugen von Schlusseln.

• Das Generieren eines kompletten Baumes aus vorhandenen Tupeln

• Das Suchen nach Rechtecken (in verschiedenen Varianten)

• Das Suchen nach einem nicht vorhandenen Rechteck

Eliminierung aquivalenter Anfragen

Da das Generieren eines kompletten Baumes durch Einfugen einzelner Tupelgeschieht, wird als erster Test die Zeit fur das Erstellen des kompletten Baumesgemessen.

Die Suchanfragen sind bis auf die Vergleichsoperation aquivalent implemen-tiert und konnen sich hochstens um einen konstanten Faktor unterscheiden.Unterschiede konnen nur durch die Anzahl der gefundenen Rechtecke entste-hen. Wir werden deshalb eine Anfrage formulieren, die genau ein Ergebnishat und welche mit mehreren Ergebnissen, in der Hoffnung daß sich hier dieImplementierung des Cache vorteilhaft auswirkt.

Das Suchen nach einem nicht vorhandenen Rechteck hingegen wird keineneuen Erkenntnisse liefern, denn im Idealfall liegt die Anfrage außerhalb desWurzelrechteck. Fur solche Anfragen reagiert das Programm mit einer un-ter des Meßgrenze liegenden Geschwindigkeit. Im schlechtesten Fall muß derBaum bis zur Blattebene durchsucht werden. Damit ist die Geschwindigkeitaquivalent zur Suche nach einem Rechteck.

Getestete Anfragen

Es werden also folgende Anfragen getestet:

• Die Zeit fur das Erstellen des Baumes aus einer Steuerdatei mit entspre-chend aufbereiteten insert-Kommandos.

38

• Die Zeit fur das Finden genau eines Rechtecks.

• Die Zeit fur das Finden von 10, 100 und 1000 Rechtecken.

5.1.4 Meßverfahren

Die Zeit fur den Aufbau des Baumes wurde mit dem time Kommando gemes-sen, wobei hier die user time die ausschlaggebende war. Die Zeiten fur die an-deren Tests wurden mit der eingebauten Option -t gemessen. Die Ausgabenwurden nach /dev/null umgeleitet, damit die Verzogerung durch die Ausga-be auf der Konsole die Meßergebnisse nicht beeinflußt. Ungenauigkeiten imBereich von ±10%konnen jedoch nicht ausgeschlossen werden.

5.1.5 Geschwindigkeitsbeeinflussende Parameter

Folgende Parameter werden in den Tests variiert, um Ihren Einfluß auf dieGeschwindigkeit zu beobachten:

• Die Konstanten des R-Baum m und M welche beschreiben, wieviele Ein-trage ein Knoten mindestens haben muß und wieviele er hochstens ha-ben darf. Zu beachten ist hier naturlich die Bedingung

2≤m≤ M

2.

Es werden die folgenden Großen getestet

m = 2, M = 5 Dies ist der kleinstmogliche Wert fur m. Fur M wurde 2·m+1 gewahlt, damit bei einer Knotenspaltung die beiden resultieren-den Knoten nicht beide mit m Elementen gefullt werden.

m = 5, M = 50 Hier wurde M auf eine Große gesetzt, die es erlaubt einenKnoten innerhalb einer 1 KByte großen Speicherseite zu halten. m

wurde auf einen extrem kleinen Wert gesetzt.

m = 25, M = 50 Dies ist wieder eine Kombination, die in eine 1 KByteSpeicherseite paßt. Hier wurde jedoch m auf den großtmoglichenWert gesetzt.

• Die Große des zur Verfugung stehenden Cache.

– Als Minimalwert testen wir 2·M. Dies ist der kleinstmogliche Wert,der implementierungstechnisch moglich ist. Er entspricht einer Im-plementierung ohne Cache. Alle Daten werden direkt in der Dateibzw. im Systemcache geandert.

– Als großen Wert wird eine Cachegroße von 2·M2 Eintragen getestet.

39

5.2 Ergebnisse

Fur jeden Test wird eine Tabelle mit statistischen Informationen des erzeugtenBaumes sowie eine Tabelle, in der die Zeiten fur die jeweiligen Test stehen,angegeben.

5.2.1 ATKIS

m = 2, M = 5

Große der Indexdatei 280 896 ByteHohe des Baumes 7Anzahl der Knoten 2 508Anzahl der inneren Knoten 715Anzahl der Blatter 1 793Durchschnittliche Fullung der Knoten 3,51635Durchschnittliche Fullung der inneren Knoten 3,50629Durchschnittliche Fullung der Blatter 3,52036

Anfrage Cache 2·M Cache 2·M2

Aufbau des Baumes 8,560 s 5,880 sFinde 1 Rechteck 4 ms 2 msFinde 10 Rechtecke 96 ms 70 msFinde 100 Rechtecke 232 ms 198 msFinde 1000 Rechtecke 508 ms 458 ms

m = 5, M = 50

Große der Indexdatei 253 000 ByteHohe des Baumes 3Anzahl der Knoten 250Anzahl der inneren Knoten 9Anzahl der Blatter 241Durchschnittliche Fullung der Knoten 26,244Durchschnittliche Fullung der inneren Knoten 27,6667Durchschnittliche Fullung der Blatter 26,1909



40

m = 25, M = 50




5.2.2 checkers mit 10 000 Tupeln

m = 2, M = 5




41

m = 5, M = 50




m = 25, M = 50




42

5.2.3 checkers mit 100 000 Tupeln

m = 2, M = 5

Große der Indexdatei 3 783 024 ByteHohe des Baumes 9Anzahl der Knoten 33 777Anzahl der inneren Knoten 8 713Anzahl der Blatter 25 064Durchschnittliche Fullung der Knoten 3,9563Durchschnittliche Fullung der inneren Knoten 3,87651Durchschnittliche Fullung der Blatter 3,98404



m = 5, M = 50

Große der Indexdatei 2 382 248 ByteHohe des Baumes 4Anzahl der Knoten 2 354Anzahl der inneren Knoten 65Anzahl der Blatter 2 289Durchschnittliche Fullung der Knoten 43,4193Durchschnittliche Fullung der inneren Knoten 36,2000Durchschnittliche Fullung der Blatter 43,6243


Aufbau des Baumes 110,450 s 117,470Finde 1 Rechteck 2 ms 2 msFinde 10 Rechtecke 3 ms 2 msFinde 100 Rechtecke 8 ms 7 msFinde 1000 Rechtecke 64 ms 59 ms

43

m = 25, M = 50



Aufbau des Baumes 127,180 132,570 sFinde 1 Rechteck 2 ms 2 msFinde 10 Rechtecke 2 ms 2 msFinde 100 Rechtecke 8 ms 8 msFinde 1000 Rechtecke 67 ms 67 ms

5.2.4 checkers mit 1 000 000 Tupeln

m = 2, M = 5



Aufbau des Baumes 31 min 31,513 s 11 min 40,380 sFinde 1 Rechteck 1 ms 1 msFinde 10 Rechtecke 6 ms 2 msFinde 100 Rechtecke 15 ms 7 msFinde 1000 Rechtecke 140 ms 116 ms

44

m = 5, M = 50




m = 25, M = 50

Große der Indexdatei 39 005 516 ByteHohe des Baumes 4Anzahl der Knoten 38 543Anzahl der inneren Knoten 1 168Anzahl der Blatter 37 375Durchschnittliche Fullung der Knoten 26.945Durchschnittliche Fullung der inneren Knoten 32,9983Durchschnittliche Fullung der Blatter 26,7559



45

5.2.5 random1 mit 10 000 Tupeln

m = 2, M = 5




m = 5, M = 50




46

m = 25, M = 50





m = 2, M = 5



Aufbau des Baumes 2 min 39,580 s 1 min 21,070 sFinde 1 Rechteck 47 ms 36 msFinde 10 Rechtecke 128 ms 94 msFinde 100 Rechtecke 532 ms 434 msFinde 1000 Rechtecke 2 475 ms 2 011 ms

47

m = 5, M = 50



Aufbau des Baumes 2 min 7,230 s 2 min 11,070 sFinde 1 Rechteck 36 ms 36 msFinde 10 Rechtecke 68 ms 63 msFinde 100 Rechtecke 363 ms 212 msFinde 1000 Rechtecke 1 312 ms 781 ms

m = 25, M = 50



Aufbau des Baumes 1 min 59,170 s 2 min 2,980 sFinde 1 Rechteck 52 ms 47 msFinde 10 Rechtecke 136 ms 85 msFinde 100 Rechtecke 405 ms 231 msFinde 1000 Rechtecke 1 138 ms 728 ms

48

5.2.7 random1 mit 1 000 000 Tupeln

m = 2, M = 5



Aufbau des Baumes 53 min 4,380 s 17 min 52,240 sFinde 1 Rechteck 46 ms 35 msFinde 10 Rechtecke 330 ms 277 msFinde 100 Rechtecke 1 080 ms 891 msFinde 1000 Rechtecke 220 s 214 s

m = 5, M = 50



Aufbau des Baumes 28 min 37,930 s 29 min 45,830 sFinde 1 Rechteck 50 ms 52 msFinde 10 Rechtecke 628 ms 356 msFinde 100 Rechtecke 8 935 ms 1 059 msFinde 1000 Rechtecke 112 s 83 s

49

m = 25, M = 50



Aufbau des Baumes 27 min 8,970 s 28 min 42,360 sFinde 1 Rechteck 42 ms 47 msFinde 10 Rechtecke 626 ms 380 msFinde 100 Rechtecke 1 804 ms 1 060 msFinde 1000 Rechtecke 103 s 77 s


m = 2, M = 5




50

m = 5, M = 50




m = 25, M = 50




51


m = 2, M = 5




m = 5, M = 50




52

m = 25, M = 50




5.2.10 random2 mit 1 000 000 Tupeln

m = 2, M = 5



Aufbau des Baumes 55 min 56,510 s 17 min 33,980 sFinde 1 Rechteck 8 min 13 s 5 min 39 sFinde 10 Rechtecke 408 ms 325 msFinde 100 Rechtecke 44,539 s 78,431 sFinde 1000 Rechtecke 101,318 s 155,937 s

53

m = 5, M = 50



Aufbau des Baumes 28 min 50,400 s 29 min 59,080 sFinde 1 Rechteck 280,048 s 196,157 sFinde 10 Rechtecke 564 ms 328 msFinde 100 Rechtecke 2,624 s 1,428 sFinde 1000 Rechtecke 45,398 s 43,691 s

m = 25, M = 50



Aufbau des Baumes 27 min 22,400 s 28 min 43,820 sFinde 1 Rechteck 284,238 s 195,718 sFinde 10 Rechtecke 606 ms 328 msFinde 100 Rechtecke 2,502 s 1,417 sFinde 1000 Rechtecke 38,575 s 35,822 s

5.2.11 Bemerkung

Die Tests fur “Finde 1 Rechteck” wurden durch eine find point Anfrage reali-siert. Das gesuchte Rechteck war in der Regel im inneren des gesamten Such-bereichs zu finden. Alle anderen Anfragen wurden durch ein find intersect gete-stet. Das Suchrechteck begann bei diesen Anfragen im Punkt (0,0) und wurdesoweit in das Zentrum vergroßert, bis die gewunschte Anzahl an Rechtecken

54

als Suchergebnis geliefert wurden.

Die teilweise erheblichen Unterschiede zwischen einer Suche nach einemRechteck und der Suche nach zehn Rechtecken lassen sich nun damit erklaren,daß ergebnislose Suchen am Rand haufiger vorkommen, dort auch bei zufalli-gen Daten weniger Uberlappung vorhanden ist und damit schneller ein (nichtvorhandenes) Ergebnis liefern. Diese Vermutung mußte allerdings durch wei-tere Tests noch verifiziert werden.

5.3 Uberblick

Der folgende Punkte sollen einen Uberblick uber die ersten Erkenntnisse, dieaus den Versuchen gewonnen werden konnten, liefern.

• Viele kleine Rechtecke konnen schneller verwaltet werden als große.So erfolgt der Zugriff auf die Daten im random2-Test und vor allem imcheckers-Test im Mittel deutlich schneller, als auf die Daten im random1-Test.

• Anfragen nach 1 000 Rechtecken liefen in Datenbanken mit bis zu 100 000Eintragen schneller, als zehn Anfragen mit 100 Ergebnissen ab. Bei Da-tenbanken mit 1 000 000 Satzen dauerte diese Anfrage langer als zehnAnfragen mit 100 Ergebnistupeln.

• Die Dateigroße ist bei der Datenbank checkers in der Einstellung m = 5und M = 50 am kleinsten. Bei den beiden random-Datenbanken wurdedie kleinste Indexdatei mit der Einstellung m = 25 und M = 50 erreicht.Welche Einstellung hier die besten Ergebnisse liefert ist offensichtlichstark Datenabhangig, so erzielt die Anderung von m allgemein sehr un-terschiedliche Resultate.

• Der cache liefert in den meisten Fallen eine Geschwindigkeitssteigerungvon 10 – 30 %. In einigen Fallen deutlich mehr in anderen liefen Anfragenmit einem großen Pufferspeicher sogar langsamer.

• Die Daten der ATKIS-Datenbank entsprechen in Ihrem Laufzeitverhal-ten ungefahr denen der random1-Datenbank. Dies war die langsamsteim Vergleich.

Dieses Resultat ist wahrscheinlich darauf zuruckzufuhren, daß in die-ser Datenbank komplette Straßenzuge und Flusse durch Ihre Verzeich-nisrechtecke reprasentiert werden. Die dadurch entstehenden Rechteckesind sehr groß. Eine hohere Effizienz wurde wohl durch eine Segmentie-rung der Straßen in kleinere Strecken erreicht werden.

55

• Alle Anfragen liefen mit einem großen M (hier 50) schneller als mit M =5. Bei zu großem M endet dies jedoch in einer linearen Suche.

56

Kapitel 6

Ausblick

6.1 Erweiterung der Datenstruktur

Der R-Baum, einer der popularsten Index-Strukturen fur Rechtecke, basiertauf einer heuristischen Optimierung der Flache der eingeschlossenen Recht-ecke der inneren Knoten. Aufgrund zahlreicher Tests war es moglich eine imDurchschnitt effizientere Datenstruktur zu entwickeln (vgl. [BKSS90]), den R∗-Baum. Diese Datenstruktur benutzt als Optimierkriterium eine Kombinationaus Flache, Rand und Uberlappung der Rechtecke (siehe auch 1.3 auf Seite 12).

Im Vergleich benotigt der mit linearSplit (2.5.3 auf Seite 21) generierte R-Baumbei Suchanfragen ungefahr 2.331 mal so lange wie der R∗-Baum. Der mit qua-draticSplit (2.5.2 auf Seite 20) aufgebaute Baum ist im Mittel 1.759 mal so lang-sam bei Suchanfragen.

Die Datenstruktur der R∗-Baums ist im Prinzip identisch zu der des R-Baums.geandert wurde nur der Algorithmus zum Einfugen von Elementen und damitdann auch fur die Split- und zugehorigen Algorithmen. Es wird außerdemeine Methode benutzt, die forced reinsert genannt wird. Hierbei werden, wennder Knoten ubervoll geworden ist, einige altere Elemente erneut in den Baumeingefugt.

Zusammenfassend ergeben die Tests von [BKSS90], daß der R∗-Baum beimEinfugen und Suchen bis zu doppelt so schnell ist, wie der R-Baum.

6.2 Anbindung an ein Datenbanksystem

Die Implementierung von rt wurde so gestaltet, daß eine Anbindung an einDatenbanksystem leicht hinzugefugt werden kann. Der bisher als externe Da-tei realisierte Index kann so als Tabelle realisiert werden.

57

In dieser Tabelle sind folgende Tupel notwendig:

• Eine eindeutige Identifikation des Tupels. In der Regel kann diese im-plizit durch die Row-ID realisiert werden. Dies hat auch den Vorteil, daßuber diese bei den meisten DBMS mit einem Laufzeitverhalten von O(1)auf das entsprechende Tupel zugegriffen werden kann.

• Eine Identifizierung, ob das Tupel einen Blattknoten oder einen inne-ren Knoten beschreibt. Alternativ konnen Blattknoten und innere Kno-ten auch in zwei verschiedenen Tabellen gespeichert werden, was jedochdie Analogie zur jetzt vorhandenen Indexdatei verringert und eventuellmehr Anderungen erfordert. Man spart jedoch so ein Attribut ein.

• Einen Verweis auf den Vorgangertupel. Hier empfiehlt sich ein Attribut,welches die Row-ID des Vorgangerknoten speichert.

• Einen Eintrag, der angibt, wieviele Eintrage im Tupel belegt sind. DieserWert kann in der Regel auch implizit berechnet werden.

• Weiterhin benotigt man M Attribute recti , um die Verzeichnisrechteckeder Nachfolgerknoten bzw. der Eintrage in den Blattern zu beschrei-ben. Wenn das DBS keine Struktur zum Beschreiben von Rechtecken zurVerfugung stellt, sind hier dann 2·M ·Dim Attribute notig, um die Recht-ecke durch Zahlen zu beschreiben.

• Letztendlich benotigt man noch M Attribute, fur die Nachfolgerknotenbzw. M Attribute fur die Schlussel (entryi). Da sowohl Schlussel als auchNachfolgerknoten Tupel, wenn auch aus verschiedenen Tabellen, be-schreiben, konnen dies die gleichen Attribute sein.

Eine solche R-Baum-Indextabelle konnte nun also das folgende Format haben:

row-ID Typ Parent Anzahl rect1 . . . rectM entry1 . . . entryM

0 NULL1 0...

...

Aufgrund des gekapselten Zugriffs auf die externen Daten sind Anderungenim Programm ausschließlich in der Klasse RTDisk und in den Methoden load

und save der jeweiligen Klassen notig.

6.3 Optimierung der Cache-Verwaltung

Die implementierte Version der Cache-Verwaltung bietet zahlreiche Ansatzefur eine Geschwindigkeitsoptimierung. Die vorhandene Cache-Strategie

58

schreibt den kompletten Cache in die Datei, sobald er voll ist. Folgende Anstzewaren denkbar:

• Da Schreiboperationen auf den meisten Systemen langsamer sind als Le-seoperationen, jedoch immer der komplette Cache gespeichert wird, ob-wohl nur wirklich veranderte Daten geschrieben werden mußten, ließesich hier ein große Geschwindigkeitssteigerung erzielen.

Dieser Umstand erklart auch, warum einige Tests mit großem Cachelangsamer waren als mit kleinem.

• Vor der Schreiboperation konnten die Daten, die geschrieben werdenmussen sortiert werden nach der Reihenfolge, in der sie im Index stehen.Hierdurch werden die Kopfbewegungen der Festplatte optimiert. Da je-doch die meisten Systeme ohnehin mit einem Festplattencache arbeiten,durfte der hierdurch erzielte Geschwindigkeitsgewinn gering sein.

• Die Cache-Strategie selbst sollte uberdacht werden. In der Regel ist esnicht notwendig immer den kompletten Cache zu leeren. So ist durchaussinnvoll Knoten auf hoheren Stufen im Baum langer im Baum zu haltenals Knoten auf niedrigeren Stufen. Der Geschwindigkeitsgewinn durfteauch hier erheblich sein.

59

Kapitel 7

rtImplementationsdokumentation

7.1 Uberblick

rectanglesdirectory-contains

RTHandle*

2..M

RTDisk

RTree RTMemIN RTMemLN

11

Parser

InterpreterScanner Key

contains

1

1

workswith

contains

Intervall

Rectangle

RTMemNodehas parent

11

2..M

is

1

contains

2..M

1

ist Unterklasse von

Timer

Error

1..d

11

*

holds in cache

CharReader

Abbildung 7.1: Klassendiagramm

60

Die Programmhauptschleife befindet sich in Parser. Dieser versucht die Befeh-le, die er aus den Tokens von Scanner bekommt zu erkennen und ruft diese inInterpreter auf. Interpreter wendet diese dann auf RTree an.

RTHandle ist eine speicherunabhangige Zeigerstruktur fur einen Knoten im R-Baum. RTDisk ubernimmt hierbei die implizite Verwaltung des Caches und derexternen Datei und liefert auf Anfrage eine Speicherreprasentation eines Kno-ten (RTMemNode). Mit anderen Worten ist RTHandle ein intelligenter Zeiger, derbenotigte Knoten in den Speicher ladt und nicht mehr benotigte extern sichert.

Jede Speicherreprasentation eines Knoten enthalt einen Verweis auf den Kno-tenvorganger und die Verzeichnisrechtecke der Nachfolger bzw. Blatteintrage.RTMemIN stellt hierbei nun den Nachfolger von RTMemNode dar, der einen in-neren Knoten reprasentiert und dementsprechend eine Anzahl von Zeigernauf Nachfolgerknoten enthalt. RTMemLN ist das analoge Gegenstuck, welchesbis zu M Eintrage fur Schlussel aufnimmt.

Rectangle enthalt als multidimensionales Rechteck d Intervalle, welche die In-tervallgrenzen des Rechtecks in der entsprechenden Dimension darstellen.

7.2 Klassendokumentation

Es folgen nun die Klassen in alphabetischer Reihenfolge.

7.2.1 class CharReader

Diese Klasse wandelt zeilenweise Eingaben aus einem Eingabestrom (z. B.stdin) in eine zeichenweise zugreifbare Eingabe um. Diese benotigt z. B. derScanner.

CharReader+ interactive : bool

– inp : istream

– buffer : string

+ CharReader (in i : istream)

# topChar (out char)

# popChar (out char)

– fillBuffer()

public CharReader (istream &i)Der Konstruktor initiiert den CharReader mit dem Eingabestrom i.

protected char topChar (void)Liefert das nachste Zeichen aus dem Eingabestrom, ohne es zu loschen.

61

protected char popChar (void)Liefert das nachste Zeichen im Eingabestrom und loscht es.

private void fillBuffer (void)Liest eine neue nichtleere Zeile in den Eingabepuffer.

private string bufferAlle nichtgeloschten Zeichen der Eingabe werden in diesem Puffer ge-halten.

private istream &inpDer Eingabestrom aus dem die Eingabezeilen gelesen werden.

7.2.2 class Error

Uber diese Klasse werden programmweit alle Fehlermeldungen behandelt. Siesorgt fur die Ausgabe der entsprechenden Meldung und an welchem Ort eraufgetreten ist. Gegebenenfalls wird das Programm auch von hier beendet.Die Fehlermeldungen sind unterteilt in sieben verschiedene Stufen.

Error– warn level : int

+ Error (in loc : char*, in msg : char*, in level : int, in exit status : int)

+ getWarn (out : int)

+ setWarn (in v : int)

1. fatal: Dies bezeichnet Anwender oder Benutzerfehler, nach denen einweiterer Betrieb des Programms nicht moglich ist. Das Programm wirdnach Ausgabe der Fehlermeldung beendet.

2. internal: Bezeichnet interne Systemfehler. Diese wurden nicht vom An-wender verursacht, sondern sind auf fehlerhaften Programmcode oderfehlerhafte Dateien zuruckzufuhren.

3. error: Dies sind Anwenderfehler, die durch Fehlbedienung entstehen.

4. warning: Dies sind Warnungen, die ausgegeben werden, wenn mogli-cherweise ein Anwenderfehler vorliegt.

5. status: Dies sind Meldungen, die wichtige Statusinformationen des Pro-gramms an den Anwender weitergeben.

6. message: Dies sind weitere Meldungen, die dem Anwender helfen, sowiedie Programmbedienung erleichtern, sollen.

62

7. gossip: Beliebige weitere Meldungen uber Programmaktivitaten, die dasVerstandnis des Programms erleichtern sollen und in der Testphase be-hilflich sind.

Welche Meldungen tatsachlich ausgegeben werden, bestimmt die statische Va-riable warn level.

public Error (const char *loc, const char *msg, int level, int exit status)Void Konstruktor. Generiert eine neue Fehlermeldung msg in Funktionloc der Stufe level. Sollte dieser Fehler non-recoverable sein (level 1),wird das Programm mit dem Status exit status beendet.

public fatal, internal, error, warning, status, message, gossipDies sind Abkurzungen fur den Aufruf von Error mit bestimmtem error-level.

7.2.3 class Interpreter

Der Interpreter bildet die Schnittstelle zwischen den Befehlen des Parsers undder Implementierung des R-Baums in der Klasse RTree. Er setzt die Befehle,die vom Parser erkannt wurden in entsprechende Methodenaufrufe von RTreeum.

Interpreter– rt : RTree

# insert (in x1 : tKoordinate, in y1 : tKoordinate, in x2 : tKoordinate, in y2 : tKoordinate)

# print()

# flush()

# insert (in r : Rectangle, in k : Key)

# printLevel (in l : int)

protected void insert (tKoordinate x1, tKoordinate y1, tKoordinate x2, tKoor-dinate y2, Key k)Diese Methode ruft die entsprechende Methode insert von RTree auf.

protected void print (void)Diese Methode gibt den kompletten Baum aus.

protected void flush (void)Diese Methode schreibt den kompletten Knoten-Cache in die Datei undleert anschließend den Cache. Dabei wird auch der allozierte Speicherder enthaltenen Speicherreprasentationen der Knoten freigegeben, sodaß verweise, die nicht uber Handles realisiert wurden, nun ungultigsind.

63

protected void insert (Rectangle r, Key k)Wie obiger insert-Aufruf, nur wird hier statt der Koordinaten eines zwei-dimensionalen Rechtecks, eine Instanz der Klasse Rechteck ubergeben.

private RTree rtDiese Eigenschaft ist eine Instanz vom Typ RTree, welche das eigentlicheAttribut des Baumes ist.

7.2.4 class Intervall

Diese Klasse beschreibt eindimensionale Intervalle.

Intervall– from : tKoordinate

– till : tKoordinate

+ Intervall()

+ Intervall (in f : tKoordinate, in t : tKoordinate)

+ in (in value : tKoordinate)

+ setMin (in f : tKoordinate)

+ setMax (in t : tKoordinate)

+ minimum (out : tKoordinate)

+ maximum (out : tKoordinate)

+ length (out : tKoordinate)

+ save (out : bool, in f : FILE*)

+ load (out : bool, in f : FILE*)

public Intervall (void)Der Void Konstruktor definiert das Intervall [0,0].

public Intervall (tKoordinate f, tKoordinate t)Dieser Konstruktor definiert das Intervall [ f , t].

public bool in (tKoordinate value)Diese Methode gibt true zuruck, wenn value ∈ [from, till] und sonstfalse.

public void setMin (tKoordinate f)Diese Methode setzt die untere Grenze des Intervalls

public void setMax (tKoordinate f)Diese Methode setzt die obere Grenze des Intervalls

public tKoordinate minimum (void)Diese Methode liefert die untere Grenze des Intervalls

public tKoordinate maximum (void)Diese Methode liefert die obere Grenze des Intervalls.

64

public tKoordinate length (void)Diese Methode liefert die Lange des Intervalls.

public bool save (FILE *f)Diese Methode speichert das Intervall in die Datei, welche durch denDateideskriptor F beschrieben wird. Treten dabei Fehler auf, wird false

zuruckgegeben, ansonsten true.

public bool load (FILE *f)Diese Methode liest das Intervall aus die Datei, welche durch den Da-teideskriptor F beschrieben wird. Treten dabei Fehler auf, wird false


private tKoordinate from, tillDies sind die Attribute, welche die untere bzw. die obere Grenze be-schreiben.

7.2.5 class Key

Diese Klasse regelt den Zugriff auf Schlussel. Uber diese findet der eigent-liche Zugriff auf die Nutzdaten statt, indem diese als Ergebnis von Suchan-fragen zuruckgegeben werden. Uber diese Schlussel muß ein ubergeordnetesProgramm die Relation zu den Nutzdaten herstellen (etwa uber die Row-IDin einem Datenbanksystem). Die Schlussel sollten so gewahlt werden, daß einZugriff auf die Nutzdaten uber den Schlussel mit einem Laufzeitverhalten vonO(1) moglich ist.

Key– val : tKey

+ Key()

+ Key (in k : tKey)

+ setKey (in k : tKey)

+ getKey (out : tKey)



+ operator== (in right : Key)

public Key (void)Der Void Konstruktor initialisiert einen Schlussel mit Wert 0. Er solltenur aufgerufen werden, fur Instanzen, die erst nach ihrer Definition in-itialisiert werden.

public Key (tKey k)Dieser Konstruktor erzeugt einen Schlussel mit dem Wert k.

65

public void setKey (tKey v)Mit dieser Methode kann der Wert eines Schlussel geandert werden.

public tKey getKey (void)Diese Methode gibt den Schlussel zuruck.

public bool load (FILE *f)Diese Methode ladt einen Schlussel aus der Datei F und speichert ihn.Sollte dabei ein Fehler auftreten wird false zuruckgegeben, sonst true.

public bool save (FILE *F)Diese Methode speichert den Schlussel in der Datei F. Sollte dabei einFehler auftreten wird false zuruckgegeben, sonst true.

public bool operator== (const Key &right)Diese Methode uberladt den Gleichheitsoperator. Dies ist notig, ummit dem Symbol == Vergleiche zwischen zwei Instanzen dieser Klas-se durchzufuhren. Sollten diese gleich sein, wird true zuruckgegeben,sonst false.

private tKey valDieses Attribut speichert den eigentlichen Wert des Schlussels.

7.2.6 class Parser

Diese Klasse ist Unterklasse von Scanner und Interpreter.

Sie versucht aus den vom Scanner gelieferten Tokens Befehle zu erkennen unddiese dann entsprechend im Interpreter aufzurufen.

Parser– t : Token

+ Parser()

– print (out : bool)

– rectangle (out : bool, out r : Rectangle)

– number (out : bool, out n : long)

– insert (out : bool)

– mainLoop()

– skip()

public Parser (void)Dieser Konstruktor ruft mainLoop auf. So wird das Programm gleich nachder Instanzierung eines Parsers in die Eingabeschleife verzweigen, in derauf Benutzereingaben gewartet und reagiert wird.

66

private bool print (void)Diese Methode versucht die Parameter fur das Benutzerkommando print

zu lesen. Sollte dies gelingen, ruft sie die entsprechende Methode im In-terpreter auf und gibt true zuruck. Ansonsten wird false zuruckgege-ben.

private bool rectangle (Rectangle &r)Es wird versucht ein Eingabe vom Typ Rectangle zu erkennen. Soll-te dies gelingen, werden in dem call-by-reference Parameter r die ge-lesenen Werte gesetzt und true zuruckgegeben. Ansonsten wird false

zuruckgegeben.

private bool number (long &n)Es wird versucht ein Eingabe vom Typ long zu erkennen. Sollte dies ge-lingen, werden in dem call-by-reference Parameter n die gelesenen Wertegesetzt und true zuruckgegeben. Ansonsten wird false zuruckgegeben.

private bool insert (void)Diese Methode versucht die Parameter fur das Kommando insert zu le-sen. Sollte dies gelingen, ruft sie die entsprechende Methode im Inter-preter auf und gibt true zuruck. Ansonsten wird false zuruckgegeben.

private void mainLoop (void)Dieses ist die Haupteingabeschleife. Es wird auf Benutzereingabengewartet und nach dem Lesen entsprechender tokens in die ent-sprechenden Programmteile verzweigt. Nach dem Lesen des TokensScanner::QUIT, wird diese Methode beendet.

private void skip (void)Diese Funktion uberliest die folgenden Token bis zum nachsten Semiko-lon bzw. Zeilenende. Dies ist sinnvoll nach syntaktischen Fehleingaben.

private Token tHier wird das jeweils zuletzt gelesene Token gespeichert.

7.2.7 class Rectangle

Diese Klasse beschreibt aufbauend auf Intervall ein mehrdimensionales In-tervall. Die Instanzen dieser Klasse konnen außerdem den Zustand gultig oderungultig haben. Nur initialisierte Rechtecke sind gultig und nur mit diesendurfen die meisten Operationen durchgefuhrt werden.

67

Rectangle– rect[DIM] : Intervall

– valid : bool

+ Rectangle()

+ Rectangle (in r : Rectangle)

+ setIntervall (in i : Intervall, in d : int)

+ in (out : bool, in value[DIM] : tKoordinate)

+ intersect (out : bool, in r : Rectangle)

+ area (out : tKoordinate)

+ areaWith (out : tKoordinate, in r : Rectangle)

+ areaEnlargement (out : tKoordinate, in r : Rectangle)

+ minimum (out : tKoordinate, in d : int)

+ maximum (out : tKoordinate, in d : int)

+ increase (in r : Rectangle)

+ setRectangle (in r : Rectangle)



Die Funktionen, die mit der Flache eines Rechtecks arbeiten, benutzen bzw.liefern fur Rechtecke hoherer Dimensionen entsprechend das Volumen.

public Rectangle (void)Dieser Konstruktor erzeugt ein ungultiges Rechteck.

public Rectangle (const Rectangle &r)Dieser Konstruktor ubernimmt die Werte aus r.

public bool setIntervall (const Intervall &i, int d)Setzt das Rechteck in der Dimension d auf das Intervall i. Wenn d ∈[0;DIM] liegt wird true zuruckgegeben, ansonsten false.

public bool in (tKoordinate value[DIM])Liefert true, wenn value innerhalb des Rechtecks liegt, sonst false

public bool intersect (const Rectangle &r)Liefert true, wenn sich r und das Rechteck uberlappen.

public tKoordinate area (void)Liefert die Flache des Rechtecks zuruck.

public tKoordinate areaWith (const Rectangle &r)Liefert die Flache, wenn das Rechteck auch r umschließen wurde.

public tKoordinate areaEnlargement (const Rectangle &r)Liefert den Flachenzuwachs, wenn das Rechteck auch r umschließenwurde.

68

public tKoordinate minimum (int d)Liefert das Minimum des Rechtecks in der Dimension d.

public tKoordinate maximum (int d)Liefert das Maximum des Rechtecks in der Dimension d.

public void increase (const Rectangle &r)Vergroßert das Rechteck, so daß es auch r umfaßt.

public void setRectangle (const Rectangle &r)Setzt das Rechteck auf r.

public bool load (FILE *f)Ladt das Rechteck aus F. Wenn dabei ein Fehler auftrat, wird false


public bool save (FILE *f)Speichert das Rechteck in F. Wenn dabei ein Fehler auftrat, wird false


private Intervall rect [DIM]Die Koordinaten des Rechteck werden in diesen Intervallen gespeichert.

private bool validHier wird gespeichert, ob das Rechteck gultig ist.

7.2.8 class RTDisk

Uber diese Klasse wird der Zugriff auf die externe Indexdatei abgewickelt.Gleichzeitig verwaltet diese Klasse alle bisher geladenen Knoten in einer ArtCache, so daß ein erneuter Zugriff auf einen bereits geladenen Knoten keineDateioperationen hervorruft.

RTDisk+ max cache : unsigned int

+ index filename : string

– diskfile : FILE*

– filesize : long

– cache[0..*] : pair <long, RTMemNode*>

+ RTDisk()

+ cacheSize (out : unsigned int)

+ existNode (out : bool, in fp : long)

+ flush()

# getNode (out : RTMemNode&, in fp : long)

# getNodePtr (out : RTMemNode*, in fp : long)

# newNode (out : long, in mn : RTMemNode*)

# newRoot (in mn : RTMemNode*)

69

public RTDisk (void)Der Void Konstruktor offnet bzw. legt die Datei an, falls dies nicht durcheinen vorhergehenden Aufruf bereits geschehen ist.

public int cacheSize (void)Liefert die Anzahl der Eintrage im Cache.

public bool existNode (long fp)Pruft, ob ein Knoten existiert, indem gepruft wird, ob die Dateipositionfp gultig ist. (D. h. ob sie großer oder gleich 0 und kleiner oder gleichder Dateigroße ist). Wenn dies der Fall ist, wird true zuruckgegeben,ansonsten false.

public void flush (void)Diese Methode schreibt den Inhalt des Cache in die Datei und leert an-schließend den Cache. Es wird auch samtlicher allozierter Speicher furdie bisher geladenen Knoten freigegeben. Alle bisher benutzten Spei-cheradressen sind danach ungultig.

Diese Methode wird immer dann aufgerufen, wenn ein neuer Knotengeladen werden muß und alle Platze im Cache belegt sind.

protected RTMemNode &getNode (long fp)Liefert eine Referenz auf den Knoten, der in der Datei an der Stelle fp

steht.

protected RTMemNode *getNodePtr (long fp)Liefert einen Zeiger auf die Speicherreprasentation von dem Knoten, derin der Datei an der Stelle fp steht.

protected long newNode (RTMemNode *mn)Erzeugt einen neuen Knoten (in der Datei) mit den Daten, die durch mn

spezifiziert. Es wird die Dateibposition, ab welcher der Knoten gespei-chert, wird zuruckgegeben.

protected void newRoot (RTMemNode *mn)Erzeugt eine neue Wurzel mit den Daten mn.

private static FILE *diskfileStatische Eigenschaft, welche den Dateideskriptor fur die Indexdateispeichert.

private static long filesizeStatische Eigenschaft, in der die Dateigroße gespeichert wird.

private typedef map <long, RTMemNode *> tCacheTypendefinition fur den Knoten-Cache.

70

private typedef tCache::value type tCacheEntryTypendefinition fur einen Eintrag im Cache.

private static tCache cacheStatische Komponente, welche den Cache reprasentiert.

7.2.9 class RTHandle

Diese Klasse erbt von RTDisk. Uber sie wird der jeder Zugriff auf Knoten ab-gewickelt. Sie stellt (uber RTDisk) sicher, daß der Knoten, auf den zugegriffenwird, sich im Speicher befindet.

RTHandle– fp : long

+ RTHandle()

+ RTHandle (in r : RTHandle)

+ initialized (out : bool)

+ loadRoot (out : bool)

+ createNode (in t : RTNodeType)

+ newRoot (in a : RTHandle, in b : RTHandle)

+ moveEntriesTo (out : bool, in right : RTHandle)

+ insert (in r : Rectangle, in h : RTHandle)

+ insert (in r : Rectangle, in k : Key)

+ full (out : bool)

+ size (out : int)

+ print()

+ operator* (out RTMemNode&)

+ operator–> (out RTMemNode*)

+ operator== (out : bool, in r : RTHandle)



public RTHandle (void)Initialisiert ein neues Handle mit einem ungultigen (negativen) Wert.

public RTHandle (const RTHandle &r)Kopierkonstruktor kopiert das Handle r.

public bool initialized (void)Liefert true, wenn das Handle ein gultiges (initialisiertes) ist.

public bool loadRoot (void)Weißt diesem Handle die Eigenschaft Root zu. (Setzt also den Wert 0)

public void createNode (RTNodeType t)Erzeugt einen neuen Knoten vom Typ t.

71

public void newRoot (RTHandle &a, RTHandle &b)Erzeugt eine neue Wurzel mit den Nachfolgern a und b.

public bool moveEntriesTo (RTHandle &right)Verschiebt alle Eintrage des aktuellen Knoten zum Knoten right.

public void insert (const Rectangle &r, RTHandle &h)Fugt einen neuen Eintrag in den inneren Knoten mit dem Verzeichnis-Rechteck r und dem Nachfolger h ein.

public void insert (const Rectangle &r, const Key &k)Fugt einen neuen Eintrag in den Blatt-Knoten mit dem Verzeichnis-Rechteck r und dem Schlussel k ein.

public bool load (FILE *f)Ladt den Knoten aus der Datei F.

public bool save (FILE *f)Speichert den Knoten in die Datei F.

public bool full (void)Liefert true, wenn alle Eintrage in diesem Knoten belegt sind.

public int size (void)Liefert die Anzahl der Eintrage, die belegt sind.

public void print (void)Gibt den Knoten aus.

public RTMemNode &operator* (void)Referenziert den Knoten in der Speicherstruktur.

public RTMemNode *operator-> (void)Referenziert den Knoten fur Memberzugriff der Speicherstruktur.

public bool operator== (const RTHandle &r)Uberladung des Vergleichsoperator. Liefert true wenn die Handlesgleich sind, sonst false.

private long fpDiese Eigenschaft speicher die Dateiposition an welcher der Knoten ge-speichert ist. Uber diesen Wert wird ein Knoten eindeutig identifiziert.

7.2.10 class RTMemIN

Diese Klasse reprasentiert einen inneren Knoten im Speicher. Sie erbt vonRTMemNode.

72

RTMemIN– childHandle[0..M] : RTHandle

+ RTMemIN()

+ ∼RTMemIN()

+ type (out : RTNodeType)

+ insert (out bool, in r : Rectangle, in h : RTHandle)

+ clear()

+ getEntryNo (out int, in h : RTHandle)

+ getChild (out RTHandle, in i : int)

+ print()

+ print (in i : int)



public RTMemIN (void)Der Void Konstruktor initialisiert einen inneren Knoten mit Null Ein-tragen.

public RTNodeType type (void)Gibt INNERNODE zuruck.

public bool load (FILE *f)Ladt einen Knoten aus der Datei F. Wenn ein dabei ein Fehler auftratwird false zuruckgegeben, ansonsten true.

public bool save (FILE *f)Speichert einen Knoten in der Datei F. Wenn ein dabei ein Fehler auftratwird false zuruckgegeben, ansonsten true.

public bool insert (const Rectangle &r, const RTHandle &h)Fugt einen neuen Nachfolgerknoten h mit dem Verzeichnisrechteck r ein.Gibt true zuruck wenn das gelang, sonst false.

void clear (void)Loscht alle Eintrage.

public int getEntryNo ( const RTHandle &h )Gibt die Nummer des Eintrags zuruck, auf den h zeigt. Wenn der keinEintrag auf h zeigt wir -1 zuruckgegeben.

public RTHandle getChild (int i)Liefert das Handle des i-ten Eintrag.


public void print (int i)Gibt den i-ten Eintrag aus.

73

private vector <RTHandle> childHandleDie Nachfolgerknoten werden hier gespeichert.

7.2.11 class RTMemLN

Diese Klasse reprasentiert einen Blatt-Knoten im Speicher. Sie erbt vonRTMemNode.

RTMemLN– key[0..M] : Key

+ RTMemLN()

+ ∼RTMemLN()


+ insert (out bool, in r : Rectangle, in k : Key)

+ clear()

+ getEntryNo (out int, in h : RTHandle)

+ getKey (out Key, in i : int)

+ print()

+ print (in i : int)



public RTMemLN (void)Der Void Konstruktor initialisiert einen Blatt-Knoten mit Null Eintragen.

public RTNodeType type (void)Gibt LEAFNODE zuruck.

public bool load (FILE *f)Ladt einen Knoten aus der Datei F. Wenn ein dabei ein Fehler auftratwird false zuruckgegeben, ansonsten true.

public bool save (FILE *f)Speichert einen Knoten in der Datei F. Wenn ein dabei ein Fehler auftratwird false zuruckgegeben, ansonsten true.

public bool insert (const Rectangle &r, const Key &k)Fugt einen neuen Schlussel k mit dem Verzeichnisrechteck r ein. Gibttrue zuruck falls dies gelang, sonst false.

public void clear (void)Loscht alle Eintrage.

public int getEntryNo ( const Key &k )Gibt die Nummer des Eintrags zuruck, der den Schlussel k enthalt. Wennkein solcher Eintrag existiert, wird -1 zuruckgegeben.

74

public Key getKey (int i)Liefert den Schlussel des i-ten Eintrag.


public void print (int i)Gibt den i-ten Eintrag aus.

private vector <Key> keySpeichert die Schlussel.

7.2.12 class RTMemNode

Abstrakte Basisklasse fur die Speicherreprasentation von Knoten.

RTMemNode# par : RTHandle

# nextFree : unsigned int

# dirRect[0..M] : Rectangle

+ RTMemNode()

+ ∼RTMemNode()

+ full (out : bool)

+ size (out : int)

+ clear()


+ insert (out : bool, in r : Rectangle, in h : RTHandle)

+ insert (out : bool, in r : Rectangle, in k : Key)

+ rect (out : Rectangle)

+ rect (out : Rectangle, in i : int)

+ area (out : tKoordinate)

+ area (out : tKoordinate, in i : int)

+ alterRect (in r : Rectangle, in i : int)

+ print()

+ print(in i : int)

+ getEntryNo (out : int, in h : RTHandle)

+ getEntryNo (out : int, in k : Key)

+ getChild (out RTHandle, in i : int)

+ getKey (out Key, in i : int)

+ setParent (in p : RTHandle)

+ parent (out : RTHandle)



public RTMemNode (void)Der Void Konstruktor initialisiert den Knoten indem er die Anzahl derVerzeichnisrechtecks auf M setzt und den nachsten freien Eintrag auf 0.

75

public virtual bool load (FILE *f)Ladt die Verzeichnisrechtecke, Anzahl der belegten Eintrage und dasHandle auf den Vaterknoten aus der Datei F.

public virtual bool save (FILE *f)Speichert die Verzeichnisrechtecke, Anzahl der belegten Eintrage unddas Handle auf den Vaterknoten in die Datei F.

public bool full (void)Liefert true wenn der Knoten voll ist, sonst false.

public int size (void)liefert die Anzahl der belegten Eintrage.

public virtual void clear (void)Loscht alle Eintrage.

public virtual RTNodeType type (void) = 0] Abstrakte Methode.

public virtual bool insert (const Rectangle &r, const RTHandle &h)Gibt eine Fehlermeldung aus.

public virtual bool insert (const Rectangle &r, const Key &k)Gibt eine Fehlermeldung aus.

public tKoordinate area (void)Liefert die Flache des Verzeichnisrechteck des Knoten.

public Rectangle rect (void)Liefert das Verzeichnisrechteck des Knoten.

public tKoordinate area (int i)Liefert die Flache des Verzeichnisrechteck des i-ten Eintrag.

public Rectangle rect (int i)Liefert das Verzeichisrechteck des i-ten Eintrag.

public void alterRect (const Rectangle &r, unsigned int i)Andert das i-te Verzeichnisrechteck auf r.

public virtual void print (void) = 0Abstrakte Methode.

public virtual void print (int i) = 0Abstrakte Methode.

public virtual int getEntryNo (const RTHandle &h)Gibt eine Fehlermeldung aus.

76

public virtual int getEntryNo (const Key &k)Gibt eine Fehlermeldung aus.

public virtual RTHandle getChild (int i)Gibt eine Fehlermeldung aus.

public virtual Key getKey (int i)Gibt eine Fehlermeldung aus.

public void setParent (RTHandle p)Setzt den Vater auf p.

public RTHandle parent (void)Liefert den Vaterknoten.

protected RTHandle parHandle des Vorgangerknoten.

protected unsigned int nextFreeDer nachste freie Eintrag (von 0 beginnend) bzw. die Anzahl belegterEintrage.

protected vector <Rectangle> dirRectDie Verzeichnisrechtecke der Eintrage.

7.2.13 class RTree

Diese Klasse reprasentiert den eigentlichen R-Baum. Module, die einen R-Baum benutzen mochten, generieren eine Instanz von dieser Klasse.

77

RTree+ m : unsigned int

+ M : unsigned int

– rootHandle : RTHandle

+ RTree()

+ ∼RTree()

+ insert (in r : Rectangle, in k : Key)

+ root (out : RTHandle)

+ print (in n : RTHandle)

+ printLevel (in h : RTHandle, in l : int)

– chooseLeaf (out : RTHandle, in r : Rectangle)

– splitNode (inout L : RTHandle, inout LL : RTHandle, in r : Rectangle, in k : Key)

– pickSeeds (inout L : RTHandle, inout LL : RTHandle,

in poolRect[0..*] : Rectangle, in poolKey[0..*] : Key)

– pickSeeds (inout L : RTHandle, inout LL : RTHandle,

in poolRect[0..*] : Rectangle, in poolHandle[0..*] : RTHandle)

– pickNext (out : int, inout L : RTHandle, inout LL : RTHandle, in poolRect[0..*] Rectangle)

– splitNode (inout L : RTHandle, inout LL : RTHandle, in r : Rectangle, in h : RTHandle)

– adjustTree (out : bool, inout L : RTHandle)

– adjustTree (out : bool, inout L : RTHandle, inout LL : RTHandle)

public RTree (void)Erzeugt einen neuen R-Baum, bzw. initialisiert den Zugriff auf einen vor-handenen.

public RTree (void)Der Destruktor speichert alle Anderungen in die Datei.

public void insert (Rectangle r, Key k)Fugt einen neuen Schlussel k mit dem Verzeichnisrechteck k ein.

public RTHandle root (void)Gibt das Handle der Wurzel des R-Baumes zuruck.

public void print (RTHandle n)Gibt den kompletten R-Baum aus.

private RTHandle chooseLeaf (const Rectangle &r)Dies ist die choose leaf Implementierung von Guttmann [Gut84].

private void splitNode (RTHandle &L, RTHandle &LL, const Rectangle &r,Key k)Dies ist die quadratic split Implementierung von Guttmann [Gut84] furBlatt-Knoten.

private void pickSeeds (RTHandle &L, RTHandle &LL,vector <Rectangle> &poolRect, vector <Key> &poolKey)

78

Dies ist die quadratic pick seeds Implementierung von Guttmann [Gut84]fur Blatt-Knoten.

private void pickSeeds (RTHandle &L, RTHandle &LL,vector <Rectangle> &poolRect, vector <RTHandle> &poolHandle)Dies ist die quadratic pick seeds Implementierung von Guttmann [Gut84]fur innere Knoten.

private int pickNext (RTHandle &L, RTHandle &LL,const vector <Rectangle> &poolRect)Dies ist die quadratic pick next Implementierung von Guttmann [Gut84].

private void splitNode (RTHandle &L, RTHandle &LL,const Rectangle &r, RTHandle h)Dies ist die quadratic split Implementierung von Guttmann [Gut84] furinnere Knoten.

private bool adjustTree (RTHandle &N)Dies ist die adjust tree Implementierung von Guttmann [Gut84] fur un-gespaltene Knoten.

private bool adjustTree (RTHandle &N, RTHandle &NN)Dies ist die adjust tree Implementierung von Guttmann [Gut84] fur ge-spaltene Knoten.

private RTHandle rootHandleDies ist das Handle der Wurzel des R-Baum.

7.2.14 class Scanner

Der Scanner ist Unterklasse von CharReader. Er wandelt eine zeichenweiseEingabe in Tokens um, welche dann von einem Parser weiterverarbeit werdenmussen.

Scanner– KW[0..*] : pair < string, KeyWord > {frozen}– number : long

– text : string

+ Scanner()

# nextToken (out : Token)

# whichKW (out : KeyWord)

# valNumber (out : long)

# valString (out : string)

– readKW (out Token)

– readNumber (out Token)

79

public enum KeyWordDiese Aufzahlung definiert Konstanten fur alle Schlusselworter, die derScanner erkennen soll, sowie eine Konstante UNKNOWN = 0 fur ein unbe-kanntes Schlusselwort.

public enum TokenDie Aufzahlung Token definiert alle zu unterscheidenden Tokens, sowieein Token ERROR fur ein unbekanntes Token.

public Scanner (void)Der Void Konstruktor initialisiert unter anderem die Schlusselworttabel-le.

protected Token nextToken (void)Diese Methode liefert das nachste Token.

protected KeyWord whichKW (void)Diese Methode liefert das zuletzt gelesene Schlusselwort. Sollte derRuckgabewert des vorhergehenden nextToken-Aufruf nicht KEYWORD ge-wesen sein, ist der Ruckgabewert undefiniert.

protected long valNumber (void)Liefert den Wert der zuletzt gelesenen Zahl.

protected string valText (void)Liefert den Wert der zuletzt gelesenen Zeichenkette.

private Token readKW (void)Versucht ein Schlusselwort aus der Eingabe zu lesen.

private Token readNumber (void)Versucht eine Zahl aus der Eingabe zu lesen.

private typedef map <string, KeyWord, less <string> > tKWDie Typdefinition fur die Schlusselworttabelle.

private typedef tKW::value type tKWentryDie Typdefinition fur einen Eintrag in der Schlusselworttabelle.

private tKW KWDie Instanziierung der Schlusselworttabelle.

private KeyWord kwDas zuletzt gelesene Schlusswelwort.

private long numberDie zuletzt gelesene Zahl.

private string textDie zuletzt gelesene Zeichenkette.

80

7.2.15 class Timer

Diese Klasse dient im allgemeinen zur Kurzzeitmessung von hochstens eini-gen Sekunden. Im speziellen wird hiermit der Zeitbedarf fur die Ausfuhrungeines Befehls ermittelt.

Sollte eine Messung uber die Tagesgrenze hinweg gefuhrt werden, so ist dasErgebnis im allgemeinen falsch!

Timer– tv : timeval

+ Timer()

+ init()

+ get (out long)

public Timer (void)Der Void Konstruktor ruft init auf.

public void init (void)Diese Methode setzt den Startzeitpunkt fur die Messung. Alle folgendenAufrufe von get sind relativ zu diesem Zeitpunkt.

public long get (void)Gibt die Anzahl an Mikrosekunden zuruck, die seit dem letzten Aufrufvon init vergangen sind.

private struct timeval tvHier werden die Daten des letzten init gespeichert.

7.3 Das Dateiformat der Indexdatei

Die Indexdatei enthalt aus Effizienzgrunden die Struktur des R-Baums in ei-nem Binarformat. Im Gegensatz zu Klartextformaten ist hier beim Arbeitenkein Parsen der Datei notig.

In dieser Beispielbeschreibung gehe man von einer Datentypgroße von 4 Byteaus. Sollte diese systemabhangige Große einen anderen Wert haben, verschiebtsich der Dateiaufbau entsprechend.

81

Bytes Beschreibung0 . . . 3 Typ des Knoten (0: Blatt; 1: Innerer Knoten)4 . . . 7 Fileposition des Vaterknoten8 . . . 11 Anzahl der Eintrage (n)ab 12 n-mal die Daten von Verzeichnisrechtecken

anschließend n Schlussel (Blattknoten) oder n Nachfolger (innerer Knoten)

Die Daten der Verzeichnisrechtecke haben folgenden Aufbau:

Bytes Beschreibungi . . . i +3 Start von Intervall 1i +4 . . . i +7 Ende von Intervall 1...

......

i +8· (Dim−1) . . . i +8· (Dim−1)+3 Start von Intervall Dim

i +8· (Dim−1)+4 . . . i +8· (Dim−1)+7 Ende von Intervall Dim

Fur Dim = 2 sieht die Datei ab Position i also folgendermaßen aus:

Bytes Beschreibung0 . . . 3 x1

4 . . . 7 x2

8 . . . 11 y1

12 . . . 15 y2

Die Schlussel bzw. die Nachfolgerknoten haben folgenden Aufbau:

Bytes Beschreibungj Schlussel 1 bzw. Nachfolger 1...

...j +4·Dim Schlussel Dim bzw. Nachfolger Dim

Folgendes ist hier zu beachten:

• Das Dateiformat ist systemabhangig, da die Große von long, bool, int, etc.implementierungsabhangige Details des Compilers und des Betriebssy-stems sind. Daher sind Indexdateien im allgemeinen nicht zwischen ver-schiedenen Rechnersystemen austauschbar.

• Es muß darauf geachtet werden, die Große einer Dateiposition und desDatentyps fur die Koordinaten eines Rechtecks gleich sind, da Knoten imLaufe ihrer Existenz sowohl als Blatt als auch als innerer Knoten genutztwerde.

82

• Der Wurzelknoten steht immer am Anfang der Datei, hat also die Positi-on 0.

• Ein negativer Wert als Eintrag fur der Vaterknoten bedeutet “keinVorganger”. Dies ist naturlich im allgemeinen nur fur die Wurzel sinn-voll und weist an anderer Stelle auf einen Fehler in der Datei hin.

• Bei einer anderen Große als 4 Byte fur long bzw. Dateizeigern verschiebensich obige Tabellen entsprechend.

• Es konnen in einem Index nicht mehr als max value(long) Eintrage ver-waltet werden. Diese Grenze wird nicht gepruft, liegt jedoch bei einerDateigroße von uber 250 MB und uber 2·109 Tupeln, wenn M = 5 ist. Furgroßere M liegt der Wert noch hoher.

83

Kapitel 8

rtviewImplementationsdokumentation

8.1 Uberblick

InputStreamLineReader

RT NumberField

RectangleCanvas

Zoom

FileLineReader Interpreter

MultilineLabel

DoubleField IntegerField

uses

1

2

drawsin

1

1

scaleswith

1

*

uses*

1

DialogOK

rtview

Abbildung 8.1: Klassendiagramm

Die Klasse rtview enthalt die Startfunktion. Nach der Initialisierung des GUIarbeitet das Programm interaktiv und wartet auf Events, welche durch denBenutzer auf der Oberflache erzeugt werden.

84

Grundsatzlich laufen nach Aktivierung von rt zwei Threads parallel. Einer, derdie Eingaben des Benutzers in Kommandos an rt umformt und einer, der dieRuckgaben von rt interpretiert und verarbeitet. Wahrend die Klasse rtview furdie Oberflache zustandig ist, steuert RT die Kommunikation mit rt.

Die ubrigen Klassen erfullen im wesentlichen Hilfsfunktionen die nicht furdas wesentliche Verstandnis von Bedeutung sind.

8.2 Klassendokumentation

Es folgen nun die Klassen in alphabetischer Reihenfolge.

8.2.1 class DialogOK

Diese Klasse stellt einen modalen Dialog dar, der einen Meldungstext ausgibtund im Vordergrund bleibt, bis der Benutzer mit dem Ok bestatigt.

DialogOK– butOk : Button {frozen}+ DialogOK (in title : String, in mesg : String )

public DialogOK (String title, String mesg)Konstruktor, der auch den Aufruf des Dialogs darstellt.

8.2.2 class DoubleField

Diese Klasse erweitert ein NumberField indem es nur Werte vom Typ doubleannimmt. Sie stellt also ein numerisches Eingabefeld mit Inkrement- und De-krement Schalter dar.

85

DoubleField+ min value : Double

+ max value : Double

+ step size : Double

+ DoubleField ()

+ DoubleField (in label : String)

+ DoubleField (in buttons : boolean)

+ DoubleField (in label : String, in buttons : boolean)

+ DoubleField (in d : double)

+ DoubleField (in label : String, in d : double)

+ DoubleField (in d : double, in buttons : boolean)

+ DoubleField (in label : String, in d : double, in buttons : boolean)

+ DoubleField (in label : String, in d : double, in buttons : boolean, in size : int)

+ getDouble (out : double)

+ setDouble (in d : double)

+ increase()

+ decrease()

+ checkValue (out : String, in s : String)

min value max value sind die obere und untere Grenze der Zahl im Eingabe-feld.

step size ist die Schrittweite um die der Wert durch den Inkrement- oderDekrement-Schalter geandert wird.

DoubleField ( . . . )Sind verschieden Konstruktoren, die das Feld initialisieren. Im einzelnensind die moglichen Parameter:

label Ein Label, der links vom Eingabefeld dargestellt wird.

buttons Wenn dieser Wert true ist, dann werden Inkrement- undDekrement-Schalter dargestellt, sonst nicht.

d Ein Default-Wert, der beim Erzeugen in das Feld eingetragen wird.

size Die Anzahl der Stellen die im Feld darstellbar sind. (Default: 3)

getDouble ()Liest den aktuellen Zahlwert aus.

setDouble (double d)Setzt als neuen Wert d.

increase, decrease Erhohen und erniedrigen das Feld um step size. DieseFunktionen werden auch von den Inkrement- und Dekrement-Schalternbenutzt.

checkValue (String s)Modifiziert den String so, daß er einen korrekten double-Wert darstellt.

86

Der String s wird in einen double-Wert umgewandelt und wieder zuruckin einen String, welcher dann zuruckgegeben wird. Diese Funktion wirdauch intern zum Uberprufen der Eingaben benutzt.

8.2.3 class FileLineReader

Diese Klasse erweitert FileReader, so daß sie wahlweise ganze Zeilen (durchnewline getrennt) einliest.

FileLineReader

+ FileLineReader (in f : File)

+ FileLineReader (in fd : FileDescriptor)

+ FileLineReader (in s : String)

+ readln (out String)

FileLineReader ( . . . )Der Konstruktor initialisiert den Reader entweder mit einem File, einemFileDescriptor oder einem Dateiname s. Bei einem Fehler wird eine File-NotFoundException geworfen.

readln ()liest eine komplette durch newline abgeschlossene Zeile ein. Die Funk-tion kehrt erst zuruck, wenn nach Aufruf eine komplette Zeile gelesenwerden konnte. Bei einem Fehler wird eine IOException geworfen.

8.2.4 class InputStreamLineReader

Diese Klasse erweitert InputStreamReader, so daß sie wahlweise ganze Zeilen(durch newline getrennt) einliest.

InputStreamLineReader

+ InputStreamLineReader (in in : InputStream)

+ readln (out : String)

InputStreamLineReader (InputStream in)Initialisiert den InputStreamLineReader mit einem Stream in.

readln ()liest eine komplette durch newline abgeschlossene Zeile ein. Die Funk-tion kehrt erst zuruck, wenn nach Aufruf eine komplette Zeile gelesenwerden konnte. Bei einem Fehler wird eine IOException geworfen.

87

8.2.5 class IntegerField

Diese Klasse erweitert NumberField indem es nur Werte vom Typ int an-nimmt. Sie stellt also ein numerisches Eingabefeld mit Inkrement- und De-krement Schalter dar.

IntegerField+ min value : int

+ max value : int

+ step size : int

+ IntegerField()

+ IntegerField (in label : String)

+ IntegerField (in buttons : boolean)

+ IntegerField (in label : String, in buttons : boolean)

+ IntegerField (in i : int)

+ IntegerField (in label : String, in i : int)

+ IntegerField (in i : int, in buttons : boolean)

+ IntegerField (in label : String, in i : int, in buttons : boolean)

+ getInt (out : int)

+ setInt (in i : int)

+ increase()

+ decrease()


min value max value sind die obere und untere Grenze der Zahl im Eingabe-feld.

step size ist die Schrittweite um die der Wert durch den Inkrement- oderDekrement-Schalter geandert wird.

IntegerField ( . . . )Sind verschieden Konstruktoren, die das Feld initialisieren. Im einzelnensind die moglichen Parameter:

label Ein Label, der links vom Eingabefeld dargestellt wird.

buttons Wenn dieser Wert true ist, dann werden Inkrement- undDekrement-Schalter dargestellt, sonst nicht.

i Ein Default-Wert, der beim Erzeugen in das Feld eingetragen wird.

size Die Anzahl der Stellen die im Feld darstellbar sind. (Default: 3)

getInt ()Liest den aktuellen Zahlwert aus.

setInt (int i)Setzt als neuen Wert i.

88

increase, decrease Erhohen und erniedrigen das Feld um step size. DieseFunktionen werden auch von den Inkrement- und Dekrement-Schalternbenutzt.

checkValue (String s)Modifiziert den String so, daß er einen korrekten int-Wert darstellt. DerString s wird in einen int-Wert umgewandelt und wieder zuruck in einenString, welcher dann zuruckgegeben wird. Diese Funktion wird auch in-tern zum Uberprufen der Eingaben benutzt.

8.2.6 class Interpreter

Der Interpreter parst die Ruckgabewerte von rt und speichert sie ggf. in offent-lichen Variablen.

Interpreter+ long value : long

+ int value : int

+ double value : double

+ rect[0..*] : Rectangle

+ UNKNOWN : int = 0 {frozen}+ TIME : int = 1 {frozen}+ QUIT : int = 2 {frozen}+ RECTANGLES : int = 3 {frozen}+ FOUND : int = 4 {frozen}+ HEIGHT : int = 5 {frozen}+ NODES : int = 6 {frozen}+ LEAFS : int = 7 {frozen}+ INODES : int = 8 {frozen}+ CACHE : int = 9 {frozen}+ NODEFILLING : int = 10 {frozen}+ INODEFILLING : int = 11 {frozen}+ LEAFFILLING : int = 12 {frozen}– readRectangle (out : Rectangle, in s : String)

– readDouble (out : double, in s : String)

+ parse (out : int, in s : String)

<type> value speichert das Ergebnis der jeweiligen Ruckgabe.

rect speichert die zuruckgegebenen Rechtecke in einem Feld.

readRectangle (String s)liest die Koordinaten eines Rechtecks aus dem String und gibt diese alsRectangle zuruck.

readDouble (String s)liest einen double-Wert aus dem String und liefert ihn zuruck.

89

parse (String s)parst den String s. Speichert erkannte Ruckgabewerte in den offentlichenAttributen und liefert den Typ der erkannten Ruckgabe zuruck.

8.2.7 class MultiLineLabel

Diese Klasse erweitert einen Label derart, daß er auch mehrere Zeilen darstel-len kann. Sie wurde in [Fl97] vorgestellt und da sie nicht zu den Kernklassenvon rtview gehort, verweise ich zur naheren Dokumentation auf dieses Buch.

MultiLineLabel# label : String

+ LEFT : int = 0 {frozen}+ CENTER : int = 1 {frozen}+ RIGHT : int = 2 {frozen}# lines[1..*] : String

# line widths[1..*] : int

# margin width : int

# alignment : int

# num lines : int

# max width : int

# line height : int

# line ascent : int

# measured : boolean = false

+ MultiLineLabel (in label : String, in margin width : int, in margin height : int)

+ MultiLineLabel (in label : String, in alignment : int)

+ MultiLineLabel (in label : String)

+ MultiLineLabel()

+ setLabel (in label : String)

+ setFont (in f : Font)

+ setForeground (in c : Color)

+ setAlignment (in a : int)

+ setMarginWidth (in mw : int)

+ getLabel (out : String)

+ getAlignment (out : int)

+ getMarginWidth (out : int)

+ getMarginHeight (out : int)

+ getPreferredSize (out : Dimension)

+ getMinimumSize (out : Dimension)

+ paint (in g : Graphics)

# newLabel()

# measure()

90

8.2.8 class NumberField

Dies ist eine abstrakte Klasse, die ein Textfeld auf die Eingabe numerischerWerte einschrankt und wahlweise eine Dekrement- und Inkrement-Buttondarstellt. Die Klassen IntegerField und DoubleField implementieren diese.

NumberField+ def : String = “0”

# t : TextField

# linear : boolean = true

– inc : Button

– dec : Button

+ NumberField (in b : boolean)

+ NumberField (in lab : String, in b : boolean)

+ NumberField (in lab : String, in size : int, in b : boolean)

+ addActionListener (in l : ActionListener)

– createButtons (in b : boolean, in size : int)

+ increase()

+ decrease()


t ist das TextFiel, welches die Ziffern darstellt.

inc, dec sind die Button zum Erhohen und Erniedrigen der Zahl.

def ist der Default-Wert des Textfeldes.

linear gibt an, ob die Inkrementierung bzw. Dekrementierung durch Additionbzw. Subtraktion eines konstanten Wertes stattfindet (true) oder durchMultiplikation bzw. Division (false).

NumberField ( . . . )Dies sind verschieden Konstruktoren. Die moglichen Parameter sind imeinzelnen:

b Wenn dieser Parameter true ist, werden die Dekrement- undInkrement-Schalter dargestellt, sonst nicht.

lab stellt einen Label links vom Eingabefeld dar.

size gibt an, wieviele Zeichen im Eingabefeld sichtbar sein sollen.

addActionListenerist eine Systemfunktion, die uberschrieben wird. Sie fugt die ActionListe-ner fur die Buttons und das Textfeld in das Event-Handling ein.

createButtonserzeugt die Buttons fur die De- und Inkrementierung.

91

increase, decreasesind abstrakte Methoden die von Nachfolgerklassen implementiert wer-den mussen. Sie Erhohen bzw. Erniedrigen das Feld.

checkValue (String s)Pruft den String s und gibt einen String zuruck, der den Konventionenfur die jeweilige Zahl entspricht.

8.2.9 class RT

Diese Klasse steuert die Kommunikation mir rt. Befehle werden gesendet undRuckgaben gepruft, interpretiert und ggf. ausgewertet.

RT– co : Thread

# rtOutput : TextArea

# rtName : TextField

# tOffsetX : IntegerField

# tOffsetY : IntegerField

# tLevel : IntegerField

# tZoom : DoubleField

# labTime : Label

# labVnodefill : Label

# labVleaffill : Label

# labVinodefill : Label

# labVcachefill : Label

# labVheight : Label

# labVnodes : Label

# labVleafs : Label

# labVinodes : Label

# bRun : Button

# runFlag : boolean

# mGfx : CheckboxMenuItem

# gfxOutput : RectangleCanvas

# out rt : InputStreamLineReader

# err rt : InputStreamLineReader

# in rt : OutputStreamWriter

# align initiated : boolean

– alignNow (in r : Rectangle)

# alignGfx()

# inRT (in s : String)

# outRT()

# startRT (in run : boolean)

co Ist der Thread, der die Ausgabe von rt uberwacht und, falls dort Daten an-liegen, diese zum Interpreter schickt.

92

rtOutput ist das TextField, welches die Kommandos im Command-Fenster mit-protokolliert.

rtName enthalt den Startaufruf von rt im Hauptfenster.

tOffsetXY ist das IntegerField im Grafikfenster, welches den Offset bestimmt.

tLevel, tZoom bestimmen im Grafiskfenster den print level und die Skalie-rung.

labTime ist der Lebel, welcher im Hauptfenster die Zeit des letzten Befehlsausgibt.

labVstatistic-type enthalt im Statistikfenster den Wert der entsprechendenAusgabe.

bRun ist der Startbutton im Hauptfenster.

runFlag gibt an ob rt momentan lauft oder nicht.

mGfx ist der Menueintrag fur das Grafikfenster. Er gibt insbesondere an, obdieses momentan geoffnet ist oder nicht.

gfxOutput ist das Canvas in dem die Grafikausgabe stattfindet.

out rt, err rt, in rt sind die Datenstrome fur die Kommunikation mit rt.

align initiated gibt an, ob das Programm gerade auf das Ergebnis einer align-Berechnung wartet und nachfolgende Ausgaben anders interpretiertwerden mussen, da sie nicht vom Benutzer direkt gestartet wurden.

align now (Rectangle r)fuhrt die Auswertung eines align-Kommandos durch. Das heißt berech-net die Skalierung und den Offset neu und stellt die Grafik neu dar.

align Gfx startet ein align. Sendet den Befehl um das Wurzelverzeichnisrecht-eck zu ermitteln und setzt align initiated. Wenn das Ergebnis zuruckge-kommen ist, wird die Berechnung in align now durchgefuhrt.

inRT (String s)sendet die Befehlszeichenkette s an rt.

outRT ()Pruft, ob eine Ruckgabe von rt an den Datenstromen anliegt und sen-det diese an den Interpreter. Wenn dieser erfolgreich eine Auswertungvorgenommen hat, dann werden die entsprechenden Befehle von hiergestartet.

startRT (boolean b)Startet (b = true) oder beendet (b = false) rt. Beim Start wird auch einThread gestartet, der in regelmaßigen Abstanden outRT aufruft.

93

8.2.10 class rtview

Diese Klasse enthalt die main-Funktion. Sie erstellt im wesentlichen das GUIund wertet grafische Kommandos des Benutzers aus und leitet sie weiter.

rtview– gf, tf, sf, mf : Frame

– mText, mStat : CheckboxMenuItem

– rtInput : TextField

– quit()

– makeGfxFrame()

– makeComFrame()

– makeStatFrame()

– add (in p : Panel, in c : GridBagConstraints, in x, y, w, h : int, in l : Component)

– makeMenuBar(out : MenuBar)

– makeGUI()

+ main()

gf, tf, sf, mf sind die Frames fur die Fenster: Grafik, Textkommandos, Statistikund Main.

mText, mStat sind die Menueintrage fur das Offnen und Schließen desKommando- und Statistikfenster.

rtInput ist das Textfeld indem im Kommandofenster direkt Befehle eingege-ben werden konnen.

quit Beendet das Programm ordentlich. Beendet ggf. vorher noch rt.

makeTypeFrame erzeugt die entsprechenden Komponenten des Fensters.

add (Panel p, GridBagConstraints c, int x, int y, int w, int h, Component l)Dies ist eine Hilfsfunktion zum Erzeugen des Statistikfenster mit demGridBagLayout-Managers.

makeMenuBarErzeugt die Menuleiste im Hauptfenster.

main Die Mainfunktion hangt alle Kommandozeilenparameter an den rt-Startaufruf an, erzeugt das GUI und stellt dann das Hauptfenster dar.

8.2.11 class RectangleCanvas

Diese Klasse erbt von Canvas. Sie erweitert diese um Funktionen zum skalier-ten Zeichnen von Rechtecken und um ein PopUp-Menu.

94

RectangleCanvas+ offset : Point

+ zoom : Zoom

– info label : Label

– a, b : Point

– old b : Point

– scanning : int

– popup : PopupMenu

+ RectangleCanvas (in pop : PopupMenu)

+ processMouseEvent (in e : MouseEvent)

+ processMouseMotionEvent (in e : MouseEvent)

+ initRectangleScan()

+ initRectangleScan (in l : Label)

+ initPointScan()

+ initPointScan (in l : Label)

+ clear()

+ drawRect (in x : int, in y : int, in width : int, in height : int)

+ drawRect (in r : Rectangle)

+ drawRect (in r : Rectangle, in c : Color)

+ getPoint (out : Point)

+ getRectangle (out : Rectangle)

– drawRect (in a : Point, in b : Point, in xor : boolean, in c : Color)

offset enthalt den Offset fur die Darstellung der Rechtecke.

zoom enthalt die Skalierung fur die Darstellung der Rechtecke.

inf label enthalt ein optionales Label fur die Ausgabe der momentanenMauskoordinaten.

a, b, old b speichern Mauskoordinaten. Bei der Eingabe von Rechtecken unddem Zeichnen des momentanen Rechtecks sind dies Startpunkt, End-punkt und Endpunkt vor der letzten Mausbewegung.

scanning gibt an in welchem Modus sich das Canvas gerade befindet. Diesekonnen sein:

0 kein Scanvorgang ist zur Zeit aktiv.

1 Der Benutzer muß den Startpunkt eines Rechtecks durch Mausklickspezifizieren.

2 Der Benutzer muß den Endpunkt eines Rechtecks durch Mausklickspezifizieren.

10 Der Benutzer soll einen einzelnen Punkt spezifizieren.

popup Ist das Popup-Menu, das bei Druck auf die rechte Maustaste uber demCanvas erscheint.

95

RectangleCanvas (PopupMenu pop)Der Konstruktor initialisiert das Canvas und klinkt das Popup-Menu inden Event-Handler ein.

drawRect (Point a, Point b, boolean xor, Color c)zeichnet das Rechteck (a, b) in der Farbe c. Wenn xor true ist, wird imXOR-Modus gezeichnet. Das Rechteck wird mit zoom skaliert und mitoffset positioniert.

processMouseEvent (MouseEvent e)stellt, wenn das entsprechende Event generiert wurde, das Popup-Menu dar und schaltet zwischen den verschiedenen Scan-Modi um.

processMouseMotionEvent (MouseEvent e)Je nach Scan-Modus werden Rechtecke und Koordinaten abhangig vonder Mausbewegung dargestellt.

initRectangleScan ( . . . )Startet die grafische Eingabe eines Rechtecks. Wenn ein Label angegebenwurde, werden die Koordinaten ausgegeben.

initPointScan ( . . . )Startet die grafische Eingabe eines Punktes. Wenn ein Label angegebenwurde, werden die Koordinaten ausgegeben.

clearloscht das Canvas.

drawRect ( . . . )Zeichnet ein Rechteck mit zoom skaliert und offset positioniert.

getPointliefert einen Punkt als Ergebnis eines Punkt-Scan.

getRectangleliefert ein Rechteck als Ergebnis eines Rechteck-Scan.

8.2.12 class Zoom

Diese Klasse skaliert mit einem Faktor Zahlen, Rechtecke und Punkte.

96

Zoom– zoom : double

+ Zoom()

+ Zoom (in z : double)

+ getZoom (out : double)

+ scale (out : int, in v : int)

+ scale (out : double, in v : double)

+ scale (out : Rectangle, in v : Rectangle)

+ scale (out : Dimension, in v : Dimension)

+ scale (out : Point, in v : Point)

+ rescale (out : int, in v : int)

+ rescale (out : double, in v : double)

+ rescale (out : Rectangle, in v : Rectangle)

+ rescale (out : Dimension, in v : Dimension)

+ rescale (out : Point, in v : Point)

+ align (out : int, in v : int)

+ align (out : double, in v : double)

+ align (out : Rectangle, in v : Rectangle)

+ align (out : Dimension, in v : Dimension)

+ align (out : Point, in v : Point)

zoom Dieses Attribut reprasentiert den Skalierungsfaktor.

ZoomDer Konstruktor setzt den Skalierungsfaktor auf z. Wenn kein Parameterangegeben wurde, wird der Skalierungsfaktor auf den Wert 1.0 gesetzt.

getZoomliefert den momentanen Skalierungsfaktor.

scale ( . . . )skaliert den als Parameter ubergebenen Wert durch Multiplikation mitdem Skalierungsfaktor.

rescale ( . . . )skaliert den als Parameter ubergebenen Wert durch Division mit demSkalierungsfaktor.

align ( . . . )“glattet” den Wert auf ein ganzzahliges Vielfaches von zoom. Wird durchHintereinanderausfuhrung von rescale und scale erzeugt.

97

Anhang A

Hilfsprogramme

A.1 rtconv

Das Programm rtconv wurde benotigt um die Verzeichnisrechtecke der ATKIS-Daten zu berechnen. Diese lagen zeilenweise in folgender Form vor:

ID 16 X-Werte 16 Y-Werte

Hierbei konnen, wenn ein Objekt mehr als 16 Stutzpunkte hat, die IDs ver-schiedener Zeilen gleich sein. Um nun die umgebenden Rechtecke zu berech-nen, ermittele man aus allen X- und Y-Werten einer ID das Minumum und dasMaximum.

Das Programm rtconv liest zeilenweise die Standardeingabe und ermittelt dasMaximum und das Minimum der entsprechenden Werte. Wenn die nachsteZeile eine verschiedene ID hat, werden die Daten geschrieben, ansonsten wer-den auch diese Daten mit den bisher gefundenen Extrema verglichen. Wenndas End-of-file Signal gelesen wurde, werden die letzten Extrema geschrieben.Die Daten werden in die Standardausgabe als insert-Befehle fur rt geschrieben.Die ID fur diesen Befehl ist eine fortlaufende Nummer, da sie fur die Tests(siehe Kapitel 5 auf Seite 37) ohne Relevanz ist.

A.2 Programme zum Erzeugen der Zufallstestdaten

A.2.1 randomized1 und randomized2

Die Testdaten fur die Tests random1 und random2 wurden mit Hilfe der bei-den C++-Programme randomized1 und randomized2 generiert. Die Programmesind sehr kurz, so daß ihr Aufbau am besten mit Hilfe des Listings erkennbarwird. In Zeile 6 wird gepruft ob ein Parameter ubergeben wurde, dieser be-

98

1 #include <stdlib.h>

2 #include <string>

3

4 int main (int count, char **param)

5 {

6 if (count != 2) return 1;

7 long till = atol (param[1]);

8 cerr << "Generating randoms till " << till << endl;

9 for (long i = 0; i < till; i++) {

10 long

11 x1 = random() % till,


13 y1 = random() % till,

14 y2 = random() % till;

15 cout << "insert " << i

16 << " (" << x1 << ", " << y1 << ", "

17 << x2 << ", " << y2 << ")" << endl;

18 }

19 }

Abbildung A.1: Listing von random1

99

1 #include <stdlib.h>

2 #include <string>

3

4 int main (int count, char **param)

5 {

6 if (count != 2) return 1;

7 long till = atol (param[1]);

8 cerr << "Generating randoms till " << till << endl;

9 for (long i = 0; i < till; i++) {

10 long


12 x2 = x1 + ((long) (till * 0.02)),

13 y1 = random() % till,

14 y2 = y1 + ((long) (till * 0.02));

15 cout << "insert " << i

16 << " (" << x1 << ", " << y1 << ", "

17 << x2 << ", " << y2 << ")" << endl;

18 }

19 }

Abbildung A.2: Listing von random2

stimmt die Anzahl der zu generierenden Eintrage till. Dann wird eine Schleifetill-mal durchlaufen und es werden die Koordinaten eines Rechtecks mit Hilfedes Zufallsgenerators ermittelt. Anschließend werden diese ausgegeben. DasProgramm randomized2 ist beinahe identisch, bis auf die Zeilen 12 und 14. DieGroße der Rechtecke wird hier nicht mit der Zufallsfunktion bestimmt, son-dern ist konstant.

A.2.2 checkered

Die Daten fur den Test checkers wurden mit Hilfe des folgenden Shell-Scriptserzeugt. Die Funktion count a b erzeugt Zahlen von a bis b

100

1 #!/bin/sh

2 for x in ‘count 1 $1‘

3 do

4 echo "$x" 1>&2

5 for y in ‘count 1 $1‘

6 do

7 echo "insert $[x*$1+y] ($[x*3], $[y*3], $[x*3+2], $[y*3+2])"

8 done

9 done

Abbildung A.3: Listing von checkered

101

Literaturverzeichnis

[Abd93] Abdelhamid, Rames: Das Vieweg LATEX-Buch. Vieweg, 2. Aufl., 1993

[Bre96] Breymann, Ulrich: Die C++ Standard Template Library. Addison-Wesley, 1996

[BKSS90] Beckmann, Norbert; Kriegel, Hans-Peter; Schneider, Ralf; Seeger,Bernhard: “The R∗-tree: An Efficient and Robust Access Methodfor Points and Rectangles” Proc. ACM SIGMOD International Con-ference on Management of Data 322 – 331, 1990.

[Egg95] Eggink, Bernd: C++ fur C-Programmierer. RRZN, 6. Aufl, 1995

[Fl97] Flanagan, David: Java in a nutshell. O’Reilly, 2. Aufl., 1997

[FE97] Flanagan, David: Java examples in a nutshell. O’Reilly, 1997

[GIS96] Hinrichs, Klaus; Hammelbeck, Stefan; Gottker, Stefan: “RaumlicheDatenstrukturen”: “Grundlagen von Geo-Informationssystemen”Seminar Datenbanken SS 96 an der Universitat Munsterhttp://www.math.uni-muenster.de, 1996

[Gun98] Gunther, Oliver: Environmental Information Systems. Springer-Verlag, 1998.

[Gut84] Guttman, Antonin: “R-trees: A dynamic index structure for spatialsearching”. Proc. ACM SIGMOD International Conference on Mana-gement of Data 47 – 57, 1984.

[Jos97] Josuttis, Nicolai: Die C++ Standardbibliothek. Addison-Wesley, 1996

[KR83] Kernighan, Ritchie: Programmieren in C. Hanser, 1983

[Mey97] Meyers, Scott: Mehr effektiv C++ programmieren. Addison-Wesley,1997

[OW90] Ottmann, T.; Widmayer, P.: Algorithmen und Datenstrukturen. BIWissenschaftsverlag, 1990

102

[Sam89] Samet, Hanan: The Design and analysis of spatial data structures.Addison–Wesley, 1990

[Sed93] Sedgewick, Robert: Algorithmen in C. Addison-Wesley, 1993

[Sch98] Schutte, Lothar: Java. RRZN, 3. Aufl., 1998

[SP97] Schwarz, Stefan; Potucek, Rudolf: Das TEXikon, Referenzhandbuchfur TEX und LATEX. Addison-Wesley, 1997

[Str98] Stroustrup, Bjarne: Die C++ Programmiersprache., Addison-Wesley,3. Aufl, 1998

[Sun97] Kramer, Doug: The Java Tutorial, Sun Microsystems, Inc.http://java.sun.com/docs/books/tutorial/index.html

[Wir96] Wirth, Niklaus: Grundlagen und Techniken des Compilerbaus.Addison-Wesley, 1996

103

Benjamin B. Hargarten - Homepage Datenbanksysteme€¦ · Benjamin B. Hargarten R-Baume¨ Eine...

Documents

Transcript of Benjamin B. Hargarten - Homepage Datenbanksysteme€¦ · Benjamin B. Hargarten R-Baume¨ Eine...