26.12.2013 Aufrufe

93kB - Praktische Informatik

93kB - Praktische Informatik

93kB - Praktische Informatik

MEHR ANZEIGEN
WENIGER ANZEIGEN

Erfolgreiche ePaper selbst erstellen

Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.

Architektur von DBMS<br />

Udo Kelter<br />

26.11.2013<br />

Zusammenfassung dieses Lehrmoduls<br />

Dieses Lehrmodul gibt eine erste Einführung in die Architektur<br />

von DBMS. Einleitend betrachten wir ein DBMS aus einer Gesamtsicht<br />

und konzentrieren uns dann auf zwei wichtige Aspekte des<br />

DBMS-Kerns: (a) wir zeigen, daß i.d.R. der Datenbankkern als eigener<br />

Hintergrundprozeß ausgeführt werden muß, und wir diskutieren<br />

die Konsequenzen hinsichtlich der Performanceoptimierung. (b) Wir<br />

skizzieren, in welchen Stufen die Datenobjekte, mit denen das Datenbankmodell<br />

operiert, auf Datenstrukturen im Hauptspeicher und<br />

letztlich auf Magnetplatten oder anderen persistenten Speichermedien<br />

abgebildet werden.<br />

Vorausgesetzte Lehrmodule:<br />

obligatorisch:<br />

empfohlen:<br />

– Datenverwaltungssysteme<br />

– Schnittstellen zu Datenbankinhalten<br />

Stoffumfang in Vorlesungsdoppelstunden: 1.0<br />

1


Architektur von DBMS 2<br />

Inhaltsverzeichnis<br />

1 Einleitung 3<br />

2 Produkt vs. Laufzeitkern 3<br />

3 Prozeßarchitektur von Informationssystemen 4<br />

4 Eine Abstraktionshierarchie von Datenbankobjekten 8<br />

4.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8<br />

4.2 Ebene 0: physische Blöcke . . . . . . . . . . . . . . . . . . . . 10<br />

4.3 Ebene 1: DB-Segmente und DB-Seiten . . . . . . . . . . . . . 10<br />

4.4 Ebene 2: Zugriffsmethode für Sätze . . . . . . . . . . . . . . . 12<br />

4.4.1 Zugriffsstrukturen . . . . . . . . . . . . . . . . . . . . 12<br />

4.4.2 Realisierung von Sätzen auf Seiten . . . . . . . . . . . 15<br />

4.4.3 Indexe . . . . . . . . . . . . . . . . . . . . . . . . . . . 17<br />

4.5 Ebene 3: Einzelobjekt-Operationen . . . . . . . . . . . . . . . 17<br />

4.6 Ebene 4: Mengen-Schnittstelle . . . . . . . . . . . . . . . . . 18<br />

4.7 Beziehung zur 3-Ebenen-Schema-Architektur . . . . . . . . . 18<br />

Literatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19<br />

Glossar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19<br />

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20<br />

c○2013 Udo Kelter Stand: 26.11.2013<br />

Dieser Text darf für nichtkommerzielle Nutzungen als Ganzes und unverändert in elektronischer oder<br />

gedruckter Form beliebig weitergegeben werden und in WWW-Seiten, CDs und Datenbanken aufgenommen<br />

werden. Jede andere Nutzung, insb. die Veränderung und Überführung in andere Formate, bedarf<br />

der expliziten Genehmigung. Die jeweils aktuellste Version ist über http://kltr.de erreichbar.


Architektur von DBMS 3<br />

1 Einleitung<br />

Dieses Lehrmodul gibt einen ersten Einblick in den Aufbau und die<br />

Struktur eines DBMS.<br />

Der Begriff Architektur ist mehrdeutig (eine allgemeinere Diskussion<br />

dieses Begriffs findet sich in [SAR]); wir werden hier primär<br />

die Software-Komponenten betrachten, aus denen ein DBMS besteht.<br />

Hierbei kann es sich sowohl um selbständig lauffähige Programme als<br />

auch um Schichten innerhalb von Programmen, insb. dem Laufzeitkern,<br />

handeln. Wir werden hier ebenfalls auf die Prozeßarchitektur,<br />

also die Struktur der Prozesse zur Laufzeit, eingehen.<br />

Es gibt keine Einheitsarchitektur, die bei allen DBMS gleichartig<br />

anzutreffen wäre, noch nicht einmal bei einer vergröberten Betrachtung.<br />

Die Architektur eines DBMS hängt ganz erheblich von mehreren<br />

Faktoren ab:<br />

– natürlich vom Datenbankmodell, hier insb. davon, ob ein navigierendes<br />

oder ein mengenorientiertes Datenbankmodell vorliegt<br />

– von der Art, wie Applikationen technisch an das DBMS angebunden<br />

werden<br />

– von den ggf. vorhandenen Verteilungskonzepten<br />

– von der “Größenklasse” und damit zusammenhängend den Optimierungszielen.<br />

2 Produkt vs. Laufzeitkern<br />

Wenn man ein DBMS-Produkt kauft, wird man auf der Installations-<br />

CD eine (erschreckend) hohe Zahl von Programmen finden, die man<br />

wie folgt gruppieren kann:<br />

– Laufzeitkern: diese Programme und Programmteile (Bibliotheken)<br />

werden während der “produktiven” Nutzung des DBMS ausgeführt.<br />

– Administrations- und Dienstprogramme (s. auch Bild 3 in [DVS])<br />

für diverse Zwecke:<br />

– Installation<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 4<br />

– Überwachung des laufenden Betriebs und Gewinnung von statistischen<br />

Daten<br />

– Performance-Tuning<br />

– Sicherheitsüberwachung<br />

– Backup der Datenbank, Verwaltung von Tertiärspeichermedien,<br />

Prüfen und ggf. Reparieren der Datenbank<br />

– Benutzeradministration<br />

– Verwaltung registrierter Anwendungen<br />

– Accounting<br />

– Programme, die das Entwickeln von Applikationen unterstützen;<br />

man kann diese als eine angepaßte Software-Entwicklungsumgebung<br />

ansehen. Beispiele sind Präprozessoren, die in Quelltexte<br />

eingebettete Anweisungen vorübersetzen, oder Editoren, mit denen<br />

man die Datenbankschemata spezifizieren kann.<br />

Die Abgrenzung zwischen den Dienstprogrammen und den Entwicklungswerkzeugen<br />

ist nicht ganz scharf. Wenn separate Entwicklungs-<br />

und “Produktions”rechner benutzt werden, sind die Entwicklungswerkzeuge<br />

typischerweise nur auf dem Entwicklungsrechner installiert.<br />

Dienstprogramme und Entwicklungswerkzeuge sind zwar für die<br />

praktische Nutzung von DBMS sehr wichtig, auf sie wird aber in Vorlesungen<br />

und Lehrbüchern über Datenbanken fast nicht eingegangen<br />

– so auch hier. Allgemeine Kenntnisse über Datenmodelle und Kenntnisse<br />

über die Laufzeitkerne haben insofern höhere Priorität, als sie<br />

bei der Behandlung der Dienstprogramme und Entwicklungswerkzeuge<br />

stets vorausgesetzt werden müssen.<br />

3 Prozeßarchitektur von Informationssystemen<br />

Informationssysteme kann man i.d.R. in 3 Softwareschichten strukturieren<br />

(s. Bild 1 in [DVS]):<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 5<br />

– GUI / Benutzerinteraktion<br />

– Realisierung der Fachkonzepte, Applikationssemantik<br />

– Datenverwaltung<br />

Im einfachsten Fall kann man die zugehörigen Module zu einem<br />

einzigen Programm zusammenbinden, d.h. diese Module würden in<br />

den virtuellen Hauptspeicher eines Betriebssystemprozesses geladen<br />

und dort gemeinsam ausgeführt. Hinsichtlich der Ziele, die durch den<br />

Einsatz von DBMS angestrebt werden, hätte eine solche 1-Prozeß-<br />

Architektur aber gravierende Nachteile:<br />

– Das DBMS kann aus Performancegründen nicht nur auf den persistenten<br />

Medien (also Platten) arbeiten, sondern muß große Teile der<br />

Datenbank in Puffer in den Hauptspeicher laden und primär auf diesen<br />

Pufferinhalten arbeiten. Nun war es ein Ziel von DBMS, vielen<br />

Benutzern und Applikationen gleichzeitig Zugriff auf die Datenbank<br />

zu ermöglichen. Dies würde bei einer 1-Prozeß-Architektur bedeuten,<br />

daß jede Applikation eigene Puffer hätte und daß dort Teile der<br />

Datenbank lägen, die ggf. schon gegenüber dem Zustand auf der<br />

Platte verändert worden sind. Wollte eine andere Applikation jetzt<br />

auf diese Teile der Datenbank zugreifen, müßte sie herausfinden, ob<br />

eine und ggf. welche andere Applikation diese Teile der Datenbank<br />

gerade puffert und sich an diese Applikation wenden. Jedes Applikationsprogramm<br />

müßte also gleichzeitig als Server für die zufällig<br />

gerade in seinen Puffern befindlichen Teile der Datenbank arbeiten.<br />

Dies ist völlig inpraktikabel.<br />

– Ein weiteres Ziel von DBMS bestand darin, Zugriffskontrollen zu<br />

realisieren, d.h. nicht autorisierten Benutzern den Zugang auf bestimmte<br />

Daten zu verwehren. Bei einer 1-Prozeß-Architektur können<br />

solche Dienste aber nicht sicher implementiert werden (zumindest<br />

bei allgemein verfügbaren Programmiersprachen und Betriebssystemen).<br />

In fast allen gängigen höheren Programmiersprachen<br />

und erst recht in maschinennahen Sprachen können Zeiger manipuliert<br />

werden, und es kann im Prinzip auf beliebige Adressen im<br />

(virtuellen) Hauptspeicher zugegriffen werden. Dies bedeutet, daß<br />

die Applikation auch direkt auf die Inhalte der Datenbankpuffer<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 6<br />

zugreifen und dort Daten auslesen und verändern könnte, d.h. die<br />

Zugriffskontrollmechanismen sind umgehbar.<br />

– Unkontrollierte Zugriffe des Applikationsprogramms könnten darüber<br />

hinaus interne Datenstrukturen des DBMS zerstören und so<br />

zu Programmabstürzen führen.<br />

Die einzige praktikable Alternative, das DBMS und die Datenbankpuffer<br />

vor direkten Zugriffen durch die Applikation zu schützen,<br />

besteht darin, diese Programme bzw. Daten in einen separaten Betriebssystemprozeß<br />

zu laden, s. Bild 1. Aus der Sicht von Applikationen<br />

ist diese Verlagerung des DBMS-Laufzeitkerns in einen anderen<br />

Prozeß i.w. nicht sichtbar, denn das API zum DBMS bleibt völlig<br />

unverändert. “Hinter dem API” liegt aber jetzt keine Implementierung<br />

mehr, sondern eine Bibliothek oder ein RPC- (remote procedure<br />

call) Mechanismus, der die Operationsaufrufe i.w. unverarbeitet an<br />

den Serverprozeß sendet, welcher die eigentliche Operation ausführt<br />

und die Ergebnisse zurücksendet.<br />

[G]UI der<br />

Applikation<br />

Server<br />

Applikations-<br />

DBMS-<br />

Server<br />

Appl-API<br />

Bibliothek<br />

DBMS-API<br />

Bibliothek<br />

Datenbank<br />

Abbildung 1: Prozeßarchitektur von Informationssystemen<br />

Aus Performance-Gründen kann es sinnvoll sein, auch das GUI und<br />

die Applikationssemantik verschiedenen Prozessen zuzuordnen; es ergibt<br />

sich dann die in Bild 1 gezeigte Struktur mit 3 Prozessen.<br />

Für die technische Realisierung eines solchen entfernten Operationsaufrufs<br />

gibt es diverse Alternativen, die nicht hier, sondern im<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 7<br />

Rahmen von Vorlesungen über Rechnernetze behandelt werden. Die<br />

Merkmale dieser Mechanismen sind für unsere Diskussion weitgehend<br />

irrelevant bis auf die beiden folgenden Punkte:<br />

– Wenn ein Applikationsprogramm gestartet wird, muß es herausfinden<br />

können, ob schon ein Serverprozeß für die Datenbank läuft und<br />

wie es Kontakt zu diesem Serverprozeß aufnehmen kann. Hierzu<br />

müssen Hilfssysteme verfügbar sein, die entsprechende Auskünfte<br />

geben können und den Verbindungsaufbau teilweise automatisieren.<br />

Die Struktur dieser Hilfssysteme hängt stark von der Kommunikationstechnologie<br />

ab, die eingesetzt wird. Insgesamt ist die<br />

Installation und Benutzung eines DBMS im Vergleich zu Dateien<br />

dadurch wesentlich komplizierter und erfordert Kenntnisse in der<br />

gewählten Kommunikationstechnologie.<br />

– Ein entfernter Operationsaufruf ist deutlich ineffizienter als ein lokaler.<br />

Ein lokaler Operationsaufruf innerhalb eines Programms verursacht<br />

einen Aufwand, der je nach Umfang der Parameter in der<br />

Größenordnung von einigen Dutzend oder hundert Maschineninstruktionen,<br />

bei heutigen Prozessoren also in der Größenordnung<br />

von Mikrosekunden liegt. Bei einem entfernten Operationsaufruf<br />

sind zwei Fälle zu unterscheiden:<br />

1. Der Serverprozeß läuft auf dem gleichen Rechner: in diesem<br />

Fall werden zuerst die Parameter geeignet codiert, der aufrufende<br />

Prozeß wird stillgelegt, der wartende Serverprozeß wird<br />

aktiviert, er entpackt die Parameter und führt die gewünschte<br />

Operation aus. Nach Beendigung der Operationsausführung<br />

werden umgekehrt die Ergebnisse an den aufrufenden Prozeß<br />

zurücktransferiert. Die beiden Prozeßwechsel und die beiden<br />

Datenübertragungen kosten typischerweise Rechenzeit in der<br />

Größenordnung von 0.1 Millisekunden.<br />

2. Der Serverprozeß läuft auf einem anderen Rechner. In diesem<br />

Fall kommt bei beiden Kommunikationen der Kommunikationsaufwand<br />

hinzu; hier muß mit einem Mindestaufwand in der<br />

Größenordnung von 1 Millisekunde (bei langsamen Netzen auch<br />

mehr) gerechnet werden, ferner ist die Übertragungsbandbreite<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 8<br />

signifikant kleiner.<br />

Hieraus folgt bereits, daß ein entfernter Aufruf bedeutend teurer<br />

(Faktor: ca. 1000 bis 10000) ist als ein lokaler und daß man<br />

sich in interaktiven Systemen, die gute Antwortzeiten haben sollen,<br />

nur wenige (Größenordnung 10 bis 100) Datenbankzugriffe pro<br />

Interaktion leisten kann.<br />

Sofern die Menge der als Eingabeparameter oder Rückgabewerte<br />

übertragenen Daten in der Größenordnung von einigen kB liegt, hat<br />

sie auf diese Zeiten praktisch keinen Einfluß, erst bei deutlich größeren<br />

Datenmengen oder sehr langsamen Netzwerken beeinflußt sie<br />

die Gesamtzeit proportional zum Übertragungsvolumen. Hieraus<br />

folgt als weitere Erkenntnis, daß es performanter ist, wenige umfangreichere<br />

Operationen aufzurufen als viele kleine.<br />

4 Eine Abstraktionshierarchie von Datenbankobjekten<br />

4.1 Übersicht<br />

Jedes DBMS muß letztlich die Datenstrukturen seines Datenbankmodells<br />

auf Basis des unterliegenden Dateisystems oder, bei direktem Zugriff<br />

auf die Hardware, der Platten realisieren. Die Diskrepanz dieser<br />

beiden Denkwelten ist erheblich, daher wird diese Realisierung typischerweise<br />

in mehrere Schritte eingeteilt, bei denen - von unten nach<br />

oben gesehen - jeweils ein neuer Typ von internen Speichereinheiten<br />

realisiert wird. Man kann sich diese Schichtung durch mehrere aufeinander<br />

aufbauende Pakete veranschaulichen (s. Bild 2) 1 . Wir skizzieren<br />

i.f. ein derartiges Schichtenmodell für interne Speichereinheiten bzw.<br />

Datenbankobjekte und gehen anschließend im Detail auf die Schichten<br />

ein:<br />

– Die unterste Ebene operiert mit Blöcken, die über Medienadressen<br />

1 Reale DBMS-Kerne sind deutlich komplizierter, insofern ist dieses Bild keine<br />

exakte, sondern allenfalls eine partielle und vereinfachende Darstellung der Architektur<br />

eines DBMS-Kerns.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 9<br />

Ebene 4: n-Tupel/Objekte<br />

Ebene 3: 1-Tupel/Objekt<br />

Ebene 2: Speichersätze<br />

Ebene 1: Segmente/Seiten<br />

Ebene 0: physische Blöcke<br />

Abbildung 2: Vereinfachte Schichtenarchitektur eines Laufzeitkerns<br />

und resultierende Abstraktionshierarchie von Datenbankobjekten<br />

identifiziert werden und die zwischen den persistente Medien und<br />

dem Arbeitsspeicher übertragen werden.<br />

– Auf Ebene 1 wird die durch die Hardware vorgegebene Menge der<br />

Blöcke zu Segmenten gruppiert. Segmente ähneln insofern Dateien,<br />

als sie angelegt und gelöscht werden können und ihre Größe (also<br />

die Menge der zugeordneten Blöcke) wachsen oder schrumpfen<br />

kann.<br />

– In Ebene 2 wird der Inhalt einzelner Segmente, der sich auf Ebene<br />

1 noch als Folge von Seiten darstellt, feinkörniger strukturiert,<br />

typischerweise als Folge oder Verzeichnis von (Speicher-) Sätzen.<br />

Integriert hierin sind (primäre) Indexe, z.B. B*-Bäume.<br />

– In Ebene 3 wird der Inhalt einzelner Sätze, der sich auf Ebene 2<br />

noch als unstrukturiertes Bytefeld darstellt, in Felder strukturiert,<br />

die den Attributen von Tupeln oder Objekten entsprechen. Auf<br />

dieser Ebene werden die konzeptuellen Schemata in konkrete Speicherstrukturen<br />

umgesetzt.<br />

– Während Ebene 3 Operationen realisiert, die mit einzelnen Tupeln<br />

oder Objekten arbeiten, realisiert Ebene 4 Operationen mit Menc○2013<br />

Udo Kelter Stand: 26.11.2013


Architektur von DBMS 10<br />

gen von Objekten. Dieser Ebene ist u.a. der Problemkomplex der<br />

Optimierung zuzuordnen.<br />

Wir betrachten i.f. die Ebenen detaillierter und beginnen bei der<br />

Hardware als unterster Ebene.<br />

4.2 Ebene 0: physische Blöcke<br />

Ein physischer Block ist ein Datenbereich auf einem Permanentspeicher<br />

wie Magnetplatte, optische Platte, Band usw., dessen (Netto-)<br />

Inhalt von der Hardware und den zugehörigen Treibern zwischen dem<br />

Speichermedium und dem Hauptspeicher transportiert werden kann.<br />

Normalerweise werden physische Blöcke nur durch das Dateimanagementsystem<br />

des Betriebssystems verwaltet, d.h. Anwendungsprogramme<br />

können überhaupt nicht direkt damit arbeiten, sondern arbeiten<br />

nur mit Dateien, die bereits eine eigene Abstraktionsschicht oberhalb<br />

der physischen Blöcke darstellen. Die von Betriebssystemen realisierten<br />

Dateisysteme sind allerdings nicht optimal angepaßt an den Bedarf<br />

von DBMS, daher umgehen manche DBMS das Betriebssystem und<br />

greifen “direkt” auf die Platte zu.<br />

Für uns sind nur zwei Operationen mit physischen Blöcken relevant,<br />

nämlich der Transport vom Medium in einen Hauptspeicherbereich<br />

und umgekehrt. Für die Speicherung einer Datenbank eignen<br />

sich nur solche Medien, bei denen man direkt, also schnell, auf jeden<br />

vorhandenen physischen Block zugreifen kann. Hierzu hat jeder<br />

Block, der auf dem Medium vorhanden ist, eine eindeutige Medienadresse.<br />

Die Gesamtmenge der Blöcke auf einem Medium hängt<br />

von dessen Hardware-Eigenschaften und ggf. von Parametern bei der<br />

Formatierung des Mediums ab.<br />

4.3 Ebene 1: DB-Segmente und DB-Seiten<br />

Aus Sicht der höheren Schichten besteht der auf Ebene 1 realisierte<br />

persistente Speicher aus mehreren Segmenten. Jedes Segment besteht<br />

aus einer Folge von Seiten. Man kann Segmente anlegen und löschen.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 11<br />

Typischerweise wird z.B. beim Erzeugen einer Relation oder eines Index<br />

ein Segment angelegt, das die zugehörigen Daten aufnimmt.<br />

Die Seiten haben eine feste Größe, z.B. 2 kB, diese Größe kann<br />

ggf. beim Anlegen des Segments gewählt werden. Im einfachsten Fall<br />

entspricht eine Seite einem Block, eine Seite kann aber auch mehrere<br />

Blöcke groß sein. Innerhalb eines Segments wird eine Seite durch eine<br />

laufende Nummer identifiziert (Medienadressen sind hier nicht mehr<br />

sichtbar). Segmente können “hinten” seitenweise wachsen oder gekürzt<br />

werden.<br />

Über die Seitenummer zusammen mit dem Segmentidentifizierer<br />

kann direkt auf die Seite zugegriffen werden. Hierzu müssen die Blöcke,<br />

die der Seite entsprechen, vorher geladen, d.h. in den Arbeitsspeicher<br />

übertragen werden.<br />

Ein Segment ähnelt einer Datei, wobei ganze Seiten statt einzelner<br />

Bytes oder Sätze Übertragungseinheiten sind. Im Gegensatz zu<br />

Dateisystemen kann aber die Identifizierung in einem DBMS weitaus<br />

einfacher gestaltet werden, d.h. wir benötigen hier keine Dateiverzeichnisse<br />

oder Zugriffskontrollen.<br />

Zu jedem Segment verwaltet das DBMS einen Segmentdeskriptor,<br />

der alle relevanten Administrationsdaten enthält. Innerhalb derselben<br />

wird vermerkt, wie Seitennummern und Medienadressen einander zugeordnet<br />

sind; diese Zuordnung kann sich dynamisch ändern. Ferner<br />

werden die freien Blöcke auf den Medien verwaltet. Für die höheren<br />

Schichten ist nicht mehr erkennbar, an welcher konkreten Medienadresse<br />

eine Seite steht.<br />

Die vorstehend beschriebene Struktur nennt man auch Zugriffsmethode<br />

für Seiten 2 .<br />

2 In manchen Betriebssystemen wird eine solche Zugriffsmethode direkt für Anwendungen<br />

nutzbar angeboten, in anderen Betriebssystemen existiert sie nur intern,<br />

während auf ihrer Basis für Anwendungen Zugriffsmethoden für Zeichen oder Sätze<br />

angeboten werden.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 12<br />

4.4 Ebene 2: Zugriffsmethode für Sätze<br />

Diese Schicht simuliert sozusagen die Speichereinheit Satz bzw. Zeichen<br />

auf der Speichereinheit Seite. Eine Seite enthält i.a. mehrere<br />

Sätze.<br />

Sätze sind als Speichereinheit in DBMS deutlich wichtiger als Zeichen<br />

(bei Zugriffsmethoden in Betriebssystemen ist es umgekehrt).<br />

Aus Sicht der höheren Schichten besteht ein Segment nunmehr aus<br />

einer Menge von Sätzen bzw. Zeichen und einer Zugriffsstruktur.<br />

4.4.1 Zugriffsstrukturen<br />

Eine Zugriffsstruktur bestimmt, wie einzelne Speichereinheiten identifiziert<br />

und lokalisiert werden können und wie die Menge der Speichereinheiten<br />

des Segments verändert werden kann. Eine Zugriffsstruktur<br />

sollte man als generischen abstrakten Datentyp (ähnlich wie Liste,<br />

Array, Baum, Hash-Tabelle usw.) ansehen. Eine konkrete Zugriffsmethode<br />

ist also ein abstrakter Datentyp, der aus einer generischen Zugriffsstruktur<br />

durch Wahl einer bestimmten Speichereinheit entsteht.<br />

Unter einer Speichereinheit verstehen wir i.f. einen Satz oder ein Zeichen.<br />

Zugriffsstrukturen verstehen wir hier nur als Spezifikationen; für<br />

eine bestimmte Spezifikation kann es unterschiedliche Implementierungen<br />

geben. Die Literatur enthält eine unübersehbare Vielfalt konkreter<br />

Datenstrukturen und Algorithmen, die einzelne Zugriffsstrukturen<br />

implementieren. Aus Platzgründen können wir hier nur Beispiele skizzieren.<br />

Sequentielle Zugriffsstruktur: Diese Zugriffsstruktur entspricht<br />

einer einfach verketteten Liste von Speichereinheiten. Sie ist auch auf<br />

sequentiellen Medien (Bändern, Bandkassetten) realisierbar.<br />

Nur eine einzige Speichereinheit des Segments ist “aktuell lokalisiert”<br />

und damit direkt les- oder schreibbar. Von dort aus kann nur<br />

schrittweise zum nächsten (und ggf. vorigen) Element navigiert werden.<br />

Der (effiziente) Direktzugriff zum n-ten Satz ist nicht möglich.<br />

Nur die erste Speichereinheit kann direkt lokalisiert werden, manchmal<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 13<br />

auch das Ende, also die Position hinter der letzten Speichereinheit.<br />

Die Folge der Speichereinheiten kann nur am Ende verlängert oder<br />

gekürzt werden, Einfügen oder Löschen in der Mitte ist nicht möglich.<br />

Die wesentlichen Operationen sind somit:<br />

– beim Schreiben eines Segments:<br />

– Überschreiben der aktuell lokalisierten Speichereinheit<br />

– Anhängen einer Speichereinheit am Ende<br />

– beim Lesen eines Segments:<br />

– Abfrage, ob Segmentende erreicht<br />

– Kopieren der lokalisierten Speichereinheit in einen Puffer<br />

Direktzugriffsstrukturen: Bei Direktzugriffsstrukturen können<br />

einzelne Speichereinheiten durch eine Nummer oder einen Schlüsselwert<br />

identifiziert werden und “direkt”, d.h. für beliebige Sätze in ungefähr<br />

gleicher Zeit, lokalisiert und dann gelesen oder überschrieben<br />

werden, ferner ggf. erzeugt oder gelöscht werden.<br />

Neben dem direkten Zugriff muß natürlich immer auch ein effizienter<br />

sequentieller Zugriff durch alle Sätze möglich sein, bei dem jede<br />

Seite nur einmal übertragen werden muß; hier interessiert, ob hierbei<br />

die Sätze in der Reihenfolge geliefert werden, die der aufsteigenden<br />

Reihenfolge ihrer Schlüsselwerte entspricht.<br />

Es gibt i.w. zwei Formen von Direktzugriffsstrukturen: die arrayartige<br />

Direktzugriffsstruktur und die Verzeichnisstruktur.<br />

Arrayartige Direktzugriffsstruktur: Diese Zugriffsstruktur entspricht<br />

einem hinten dynamisch erweiterbaren Array. Speichereinheiten<br />

werden durch laufende Nummern identifiziert. Es gibt Operationen,<br />

mit denen man die aktuelle Länge des Arrays abfragen und diese<br />

herauf- oder heruntersetzen kann. Nicht möglich ist das Einfügen einer<br />

Speichereinheit zwischen zwei vorhandenen Speichereinheiten. Da<br />

laufende Nummern natürlicherweise sortiert sind, kann man zusätzlich<br />

sehr leicht eine sequentielle Zugriffsstruktur anbieten.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 14<br />

Effizient realisiert werden kann eine arrayartige Direktzugriffsstruktur<br />

in Zugriffsmethoden für Zeichen oder Sätze fester Länge, bei<br />

variabler Satzlänge treten Probleme auf. Zugriffsmethoden für Seiten<br />

realisieren übrigens ebenfalls eine arrayartige Direktzugriffsstruktur.<br />

Verzeichnisstruktur: Diese Zugriffsstruktur tritt nur bei Sätzen<br />

als Speichereinheit auf. Jeder Satz hat hier einen zugeordneten<br />

Schlüsselwert 3 . Die Schlüsselwerte stammen aus einem Schlüsselwertbereich.<br />

Beispiele für Schlüsselwertbereiche sind die ganzen Zahlen<br />

von 0 bis 2 32 -1 oder alle Texte von 8 Zeichen Länge über einem gegebenen<br />

Alphabet. Der Schlüsselwertbereich ist i.a. in der Schnittstelle<br />

und in der Implementierung der Zugriffsmethode “hart verdrahtet”;<br />

die Schlüsselwerte müssen ja in diversen Operationen als Parameter<br />

übergeben werden. Die Verzeichnisstruktur wirkt auf den ersten Blick<br />

sehr ähnlich wie die arrayartige Direktzugriffsstruktur, dieser Eindruck<br />

täuscht aber. Der entscheidende Unterschied besteht darin,<br />

– daß immer der gesamte, sehr große Schlüsselwertbereich verfügbar<br />

ist, es gibt also keine variable Obergrenze für die gültigen Schlüsselwerte,<br />

und<br />

– daß es sein kann, daß zu einem Schlüsselwert aktuell kein Satz<br />

vorhanden ist. I.a. ist sogar nur für einen winzigen Bruchteil der<br />

zulässigen Schlüsselwerte ein Satz vorhanden.<br />

Ein Schlüsselwert identifiziert entweder keinen oder genau einen<br />

Satz in einem Segment. Während bei einer arrayartigen Direktzugriffsstruktur<br />

die Nummern der aktuell vorhandenen Speichereinheiten ein<br />

geschlossenes Intervall bilden, können die Schlüsselwerte der aktuell<br />

vorhandenen Sätze bei einer Verzeichnisstruktur beliebig verstreut im<br />

Schlüsselwertbereich liegen.<br />

Daher kommen für Verzeichnisstrukturen keine Implementierungen<br />

in Frage, bei denen sich der Schlüsselwert implizit durch die Position<br />

des Satzes im Segment ergibt, sondern nur solche Implementierungen,<br />

bei denen der Schlüsselwert jedes Satzes explizit gespeichert wird.<br />

3 Oft wird die Bezeichnung “Schlüssel” als Synonym zu Schlüsselwert benutzt;<br />

dies vermeiden wir hier ganz bewußt.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 15<br />

Binäre Suchbäume und Hash-Tabellen sind bekannte Beispiele für derartige<br />

Datenstrukturen im Hauptspeicher. Von diesen grundlegenden<br />

Datenstrukturen gibt es diverse angepaßte und erweiterte Varianten,<br />

die auf die Besonderheiten einer seitenorientierten Speicherung abgestimmt<br />

sind, z.B. B-Bäume oder B*-Bäume.<br />

Da B-Bäume auch ein effizientes sequentielles Durchlaufen aller<br />

Sätze in aufsteigender Reihenfolge der vorhandenen Schlüsselwerte erlauben,<br />

spricht man hier auch von einer indexsequentiellen Zugriffsmethode<br />

(ISAM; index sequential access method).<br />

Verzeichnisstruktur mit Intervallabfrage: Hier ist im Vergleich<br />

zur normalen Verzeichnisstruktur eine zusätzliche (effizient realisierte)<br />

Operation vorhanden, die alle Speichereinheiten liefert, deren<br />

Schlüsselwert zwischen einer unteren und einer oberen Schranke liegt.<br />

4.4.2 Realisierung von Sätzen auf Seiten<br />

Wir betrachten hier beispielhaft einige einfache Verfahren, wie die sequentielle<br />

Zugriffsstruktur und die arrayartige Direktzugriffsstruktur<br />

auf Seiten effizient realisiert werden können. Die Verzeichnisstruktur<br />

erfordert komplizierte Verfahren, auf die wir hier nicht eingehen.<br />

Die Varianten der Zugriffsmethoden für Sätze unterscheiden sich<br />

darin, ob alle Sätze des Segments gleiche bzw. unterschiedliche Länge<br />

haben. Die zugehörigen Angaben, z.B. die feste Satzlänge oder die<br />

maximale Satzlänge bei variabler Satzlänge, werden innerhalb des Segmentdeskriptors<br />

gespeichert.<br />

Anordnung von Sätzen fester Länge. Bei fester Satzlänge<br />

braucht die Länge eines Satzes nicht bei jedem Satz gespeichert zu<br />

werden. Die Speicherabschnitte für je einen Satz können einfach hintereinandergelegt<br />

werden. Bild 3 zeigt zwei prinzipielle Alternativen:<br />

1. Man bildet gedanklich aus den Inhalten der Seiten einen durchgehenden<br />

Adreßraum und legt die Sätze dicht in diesen Adreßraum (s.<br />

Bild 3 oben). Nachteilig ist hier, daß ein Satz ggf. nicht komplett<br />

in einer Seite liegt und daß, um einen solchen Satz zu lesen oder zu<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 16<br />

Seite 1 Seite 2 Seite 3<br />

Satz 1 Satz 2 Satz 3 Satz 4 Satz 5 Satz 6<br />

Seite 1 Seite 2<br />

Seite 3<br />

Satz 1 Satz 2 Satz 3 Satz 4 Satz 5 Satz 6<br />

Abbildung 3: Anordnung von Sätzen fester Länge auf Seiten<br />

schreiben, zwei Blöcke übertragen werden müssen, sofern eine Seite<br />

einem Block entspricht.<br />

2. Man legt nur so viele Sätze in eine Seite, wie ganz hineinpassen.<br />

Nachteil ist hier der ungenutzte Verschnitt am Ende der Seite.<br />

Der Nachteil der doppelten Blockübertragung ist in den meisten<br />

Fällen gravierender als der des Verschnitts.<br />

Satzanordnung bei variabler Satzlänge. Bei allen Zugriffsmethoden<br />

für variable Satzlänge steht man (unabhängig von der Zugriffsstruktur)<br />

vor dem Problem, daß die Länge jedes einzelnen Satzes in<br />

irgendeiner Form erkennbar sein muß. Am einfachsten ist ein Längenfeld<br />

vor dem Satz: Die ersten 2 oder 4 Bytes eines Satzes enthalten<br />

dessen Länge als Binärzahl. Die tatsächliche Länge des Satzes wird<br />

i.d.R. noch auf ein ganzes Vielfaches von 4 oder 8 aufgerundet.<br />

Die Sätze können z.B. analog zu Sätzen fester Länge hintereinander<br />

in der Seite stehen (s. Bild 3 unten).<br />

Bei variabler Satzlänge entsteht prinzipiell das Problem, daß<br />

– der noch freie Platz innerhalb der Seite verwaltet werden muß<br />

– wenn Sätze verlängert oder neu eingefügt werden, eine Seite überlaufen<br />

kann<br />

– wenn Sätze verkürzt oder gelöscht werden, der Füllungsgrad der<br />

Seite schlecht werden kann<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 17<br />

– die Zahl der Sätze pro Seite variabel ist und daher die Seite, in der<br />

sich der i-te Satz eines Segments befindet, nicht berechnet werden<br />

kann.<br />

4.4.3 Indexe<br />

Indexe sind generell Datenstrukturen, die einen effizienten Zugriff zu<br />

Daten ermöglichen, die durch einen gegebenen Attributwert identifiziert<br />

werden. Bei manchen Zugriffsmethoden sind Indexe in die<br />

Primärdaten integriert; einen solchen Index bezeichnet man auch als<br />

Primärindex. Primärindexe sind also integraler Bestandteil einer<br />

Zugriffsmethode für Sätze.<br />

Indexe können auch unabhängig von den Primärdaten existieren<br />

und heißen dann Sekundärindex. Ein Sekundärindex ist ein Verzeichnis,<br />

das zu jedem auftretenden Wert eines Attributs eine Liste<br />

von Referenzen auf die Tupel bzw. Objekte, bei denen dieser Attributwert<br />

auftritt, enthält. Während pro Segment nur ein Primärindex<br />

vorhanden sein kann, können beliebig viele Sekundärindexe angelegt<br />

werden.<br />

Naheliegend ist es, für einen Sekundärindex ein eigenes Segment<br />

mit einer Direktzugriffsstruktur anzulegen. Für jeden auftretenden<br />

Attributwert wird ein Satz angelegt,<br />

– dessen Schlüsselwert der Attributwert ist (problematisch können<br />

hier Text-Attribute sein, bei denen die Länge stark variiert) und<br />

– dessen Inhalt die Liste der Referenzen auf die primären Daten ist.<br />

Als Referenzen kommen Primärschlüsselwerte, Surrogate von Objekten<br />

oder sogenannte Tupel-Identifizierer in Frage. Wenn man Sekundärindexe<br />

auf diese Weise realisiert, bauen sie auf Primärindexen<br />

auf, können also als eigene (Zwischen-) Schicht betrachtet werden.<br />

4.5 Ebene 3: Einzelobjekt-Operationen<br />

Diese Ebene exportiert Operationen, die mit einzelnen Tupeln oder<br />

Objekten arbeiten. Ein Tupel oder Objekt wird i.d.R. als Inhalt eines<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 18<br />

Satzes gespeichert, die Menge der Tupel einer Relation in den Sätzen<br />

eines Segments.<br />

Die Details (mögliche Attributtypen usw.) hängen vom Datenbankmodell<br />

ab. In navigierenden Datenbankmodellen wird insb. die<br />

Navigation zwischen Objekten auf dieser Ebene realisiert, in relationalen<br />

Systemen die Behandlung von Cursors.<br />

4.6 Ebene 4: Mengen-Schnittstelle<br />

Diese Ebene entfällt weitgehend bei rein navigierenden Datenbankmodellen.<br />

Bei textuellen Schnittstellen muß hier zunächst die textuelle Formulierung<br />

einer Anweisung in eine interne Darstellung übersetzt werden.<br />

Dies beinhaltet diverse Prüfungen, u.a. der Syntax, des Vorhandenseins<br />

von referenzierten Relationen oder Typen, der Zugriffsrechte<br />

usw. Im Erfolgsfall wird danach im Rahmen der Optimierung<br />

ein möglichst effizient ausführbarer Plan erstellt, der den Auftrag<br />

realisiert; entgegen der Bezeichnung “Optimierung” wird allerdings<br />

aus Aufwandsgründen nicht versucht, wirklich einen optimalen<br />

Ausführungsplan zu finden, sondern nur anhand von Heuristiken einen<br />

wahrscheinlich recht guten. Der erstellte Plan wird schließlich ausgeführt.<br />

Nach Abarbeitung müssen die Ergebnisse entweder in geeigneten<br />

Datenstrukturen bereitgestellt werden (bei einem API) oder für<br />

eine externe Darstellung aufbereitet werden.<br />

4.7 Beziehung zur 3-Ebenen-Schema-Architektur<br />

In Abschnitt 5.2 in [DVS] wurde die 3-Ebenen-Schema-Architektur<br />

für DBMS eingeführt. Diese korreliert lose mit der hier in Abschnitt<br />

4 eingeführten Abstraktionshierarchie von Datenbankobjekten.<br />

Bei der Abstraktionshierarchie von Datenbankobjekten hatten wir<br />

unterstellt, daß es sich primär um Nutzdaten handelt. Schemadaten<br />

müssen natürlich auch persistent verwaltet werden, und die Speicherungsoperationen<br />

können hierfür im Prinzip auch ausgenutzt werden<br />

(z.B. auf der Ebene von Speichersätzen); auf dieses Thema wollen wir<br />

aber hier nicht eingehen.<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 19<br />

Vereinfachend kann man den Zusammenhang zwischen den Hierarchien<br />

wie folgt ausdrücken:<br />

– Die beiden oberen Schichten der Schema-Architektur (Sichten und<br />

konzeptionelles Schema) beeinflussen die Arbeitsweise der oberen<br />

Schichten der Datenbankobjekt-Hierarchie (1- und n-Tupel-<br />

Schicht).<br />

– Das interne Schema beeinflußt die Arbeitsweise der drei unteren<br />

Schichten der Datenbankobjekt-Hierarchie.<br />

In der 1- bzw. n-Tupel-Schicht finden z.B. Prüfungen statt, ob angegebene<br />

Typnamen (z.B. Attribute oder Relationentypen) bekannt<br />

sind; hierzu werden das externe und das konzeptuelle Schema herangezogen.<br />

Auf der Speichersatzebene muß z.B. eine gewünschte Sortierung<br />

eingehalten werden, und es müssen Indexstrukturen bei Änderungen<br />

an den indexierten Daten gewartet werden.<br />

Literatur<br />

[DVS] Kelter, U.: Lehrmodul “Datenverwaltungssysteme”; 2002<br />

[SAR] Kelter, U.: Lehrmodul “Software-Architekturen”; 2002/10<br />

Glossar<br />

Index: Datenstruktur, die einen effizienten Zugriff zu Speichereinheiten<br />

ermöglicht, die durch einen Attributwert identifiziert werden<br />

Laufzeitkern: Teil eines DVS, das als geladenes Programm die Funktionen<br />

des API ausführt<br />

Primärindex: in die Nutzdaten integrierter Index<br />

Seite (Kontext: interne Architektur eines DBMS-Laufzeitkerns):<br />

Speichereinheit der Seitenebene<br />

Sekundärindex: Verzeichnis, das zu einzelnen Werten eine Liste von Referenzen<br />

auf die Speichereinheiten enthält, in denen dieser Attributwert<br />

auftritt<br />

c○2013 Udo Kelter Stand: 26.11.2013


Architektur von DBMS 20<br />

Speichersatz: Speichereinheit der Speichersatzebene in der internen Architektur<br />

eines DBMS-Laufzeitkerns<br />

Serverprozeß: im Betriebssystem selbständig oder sogar auf einem separaten<br />

Rechner laufender Prozeß, der die Funktionen einer Schicht eines<br />

Informationssystems (z.B. Datenhaltungsschicht) ausführt<br />

Zugriffsmethode (access method): wird in Begriffen wie indexsequentielle<br />

Zugriffsmethode (ISAM; index sequential access method) verwendet;<br />

bezeichnet eine Methode, wie die Speichereinheiten (Sätze bzw. Seiten)<br />

einer bestimmten Ebene intern auf Basis der nächsttieferen Ebene<br />

organisiert werden und wie einzelne Einheiten lokalisiert und bearbeitet<br />

werden können; beinhaltet sowohl die (abstrakten) Schnittstellen<br />

als auch die Hauptmerkmale der Implementierung<br />

Zugriffsstruktur: abstrakte Schnittstelle, über die eine Menge von Speichereinheiten<br />

(i.d.R. Sätze) verwaltet wird<br />

c○2013 Udo Kelter Stand: 26.11.2013


Index<br />

Architektur, 3<br />

Block, 10<br />

Dateimanagementsystem, 10<br />

DBMS<br />

Administration, 3<br />

Laufzeitkern, 3<br />

Hauptspeicher, 10<br />

Index, 17, 19<br />

Längenfeld, 16<br />

Laufzeitkern, 3, 19<br />

Sekundärindex, 17, 19<br />

active ss, 6, 20<br />

Kommunikationsaufwand, 7<br />

Sicherheit, 6<br />

Speichersatz, 9, 19<br />

Zugriffskontrollen, 5<br />

Zugriffsmethode, 11, 12, 20<br />

Zugriffsstruktur, 12, 20<br />

Direktzugriffsstruktur, 13–15<br />

sequentielle, 12, 13<br />

Verzeichnisstruktur, 14<br />

Medienadresse, 10, 11<br />

Mehrbenutzerzugriff, 5<br />

Operationsaufruf<br />

entfernter, 7<br />

Optimierung, 18<br />

Primärindex, 17, 19<br />

active ssarchitektur, 4<br />

active ss, 5<br />

von Informationssystemen, 6<br />

remote procedure call, 6<br />

Satz, 19<br />

feste Länge, 15<br />

Realisierung, 15<br />

variable Länge, 16<br />

Schichtenmodell, 9<br />

Schlüsselwert, 14<br />

Schlüsselwertbereich, 14<br />

Segment, 9<br />

Seite, 9, 12, 15, 19<br />

21

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!