93kB - Praktische Informatik
93kB - Praktische Informatik
93kB - Praktische Informatik
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