\item\begriff{Datenabstraktion} / \begriff{Datenunabhängigkeit}: persistentes Speichern und Wiedergewinnen (Auffinden und Aushändigen) von Daten \wichtig{unabhängig} von Details der Speicherung
\item\begriff{Schicht}: realisiert \begriff{Dienst} und stellt ihn per \begriff{Schnittstelle} zur Verfügung
\end{itemize}
\section{Dateiverwaltung}
\begin{itemize}
\item\begriff{physische} Speichergeräte (z.B. Festplatten) werden durch \begriff{logische} abstrahiert (z.B. Neueinlesen bei Checksum-Fehlern)
\item\begriff{Block} als kleinste Einheit der IO
\item\enquote{Adresse} eines Blocks: (Zylinder, Spur, Sektor)
\item\begriff{Dateien} als benannte Menge von Blöcken
\item\begriff{blockorientierte} Zugriffsmethode: verwendet eindeutige, fortlaufende Blockadressen innerhalb der Datei
\end{itemize}
\section{Sätze}
\begin{itemize}
\item\begriff{Satz} als zusammengehörende Daten eines Gegenstands der Anwendung (z.B. Tupel, Objekt) mit variabler oder fester Länge
\item\begriff{Satzdatei} als Sammlung von Sätzen, kann über verschiedene Blöcke verteilt sein
\item Ausprägungen: \begin{itemize}
\item\begriff{sequentiell}: \begin{itemize}
\item Reihenfolge der Abspeicherung und des Auslesens bereits mit Schreiben festgelegt
\item\wichtig{keine} Änderungen / Löschen möglich
\item kein wahlfreier Zugriff
\end{itemize}
\item\begriff{direkt}: \begin{itemize}
\item Verwendung sogenannter \begriff{Satzadressen} (hier als \begriff{TID}s realisiert; \wichtig{eindeutig} und \wichtig{unveränderlich}) als Adresstupel (Block, Index)
\item Abbildung von Index auf Offset innerhalb eines Blockes durch Array am Ende eines Blockes
\item erlaubt wahlfreien Zugriff
\item erlaubt Löschen von Sätzen: Index wird ungültig markiert, folgende Sätze nach vorne verschoben, Anpassung der Offsets
\item erlaubt Ändern von Sätzen: \begin{itemize}
\item\wichtig{ohne} Überlauf: Verschieben der folgenden Sätze, Anpassung der Offsets
\item\wichtig{mit} Überlauf: Satz wird in anderen Block verschoben, Verweis auf diesen wird angelegt, (evtl.) Anpassung der Offsets
\end{itemize}
\end{itemize}
\end{itemize}
\end{itemize}
\section{Schlüssel}
\begin{itemize}
\item\begriff{Schlüsselwerte} als \enquote{inhaltsbezogene Adressen}
\item\begriff{Hashing}: \begin{itemize}
\item\begriff{Hash-Funktion} verteilt Schlüsselwert möglichst gleichmäßig auf verfügbare \begriff{Buckets} (Blöcke)
\item\begriff{Divisions-Rest-Verfahren}: $h(k)=(k \mod q)$ mit Schlüsselwert $k$ und Anzahl der Buckets $q$
\item Problem des \begriff{Überlaufs} mit verschiedenen Lösungsmöglichkeiten: \begin{itemize}
\item\begriff{Open Addressing}: Ausweichen auf Nachbarbuckets
\item jeder \begriff{Knoten} ist genau einen Block groß
\item\wichtig{balanciert}, alle Blätter außer Wurzel immer mindestens zur Hälfte gefüllt
\item Knoten: \begin{itemize}
\item Anzahl der verwendeten Einträge $n$, es gilt $k \leq n \leq2k$
\item\begriff{Eintrag}: Tupel (Schlüsselwert, Datensatz, Blocknummer des Kindknotens)
\item Einträge nach Schlüsselwert \wichtig{sortiert}
\end{itemize}
\item Einfügen: wie Suchen; nur in Blattknoten; bei Überlauf \enquote{linke} und \enquote{rechte} Einträge als neue Knoten, \enquote{mittlerer} als \begriff{Diskriminator} in Eltern-Knoten einfügen
\item Löschen von Schlüssel $S$ im Blattknoten: \begin{itemize}
\item Entfernen und ggf. Unterlauf behandeln
\end{itemize}
\item Löschen von Schlüssel $S$ in innerem Knoten: \begin{itemize}
\item Seitenzuordnung: \enquote{Welche Blöcke (in einer Datei) gehören zu einer Seite (im Puffer)?}\begin{itemize}
\item\begriff{direkt}: aufeinander folgende Seiten werden auf aufeinander folgende Blöcke einer Datei abgebildet
\item\begriff{indirekt}: \begriff{Page Table} enthält zu jeder Seite eine Blocknummer
\end{itemize}
\item Seiteneinbringung: \begin{itemize}
\item\begriff{direkt}: Bei Verdrängung aus Puffer wird genau der Block überschrieben, aus dem ursprünglich eingelagert wurde (\enquote{update-in-place})
\item\begriff{indirekt}: Bei Verdrängung aus Puffer wird in einen freien Block geschrieben.
\end{itemize}
\item Problem der indirekten Seiteneinbringung: \enquote{Wann können alte Blöcke gelöscht werden?}; verschiedene Lösungsansätze: \begin{itemize}
\item\begriff{Schattenspeicher}: \begin{itemize}
\item Änderungen nur auf Kopien, die periodisch dann mit \enquote{gesicherter} Version vertauscht wird
\end{itemize}
\item\begriff{Twin Slots}: \begin{itemize}
\item jede Seite hat zwei Blöcke
\item immer beide lesen, bei Änderungen älteren überschreiben
\item\begriff{Precompiler} übersetzt SQL-Anweisungen (mittels \texttt{EXEC SQL} gekennzeichnet) zur \wichtig{Compile-Zeit} in die verwendete Programmiersprache \begin{itemize}
\item Deklaration der verwendeten Variablen am Anfang mittels \texttt{DECLARE SECTION}
\item Fehlermeldungen und ähnliches werden über die sogenannte \begriff{SQL communication area} verwaltet (\texttt{INCLUDE SQLCA} am Anfang)
\item Mengen-orientes Paradigma des DBVS oft nicht mit Programmiersprache vereinbar $\Rightarrow$ Einrichtung eines \begriff{Cursors} zum tupelweisen Durchlaufen der Ergebnismenge
\item Beispielablauf: \texttt{DECLARE CURSOR}$\rightarrow$\texttt{OPEN}$\rightarrow$ (mehrfach) \texttt{FETCH} bis Fehlercode $==100$$\rightarrow$\texttt{CLOSE}
\item\begriff{Transaktion} als \begriff{logische Einheit} einer Folge von DB-Operationen (von einem logisch konsistenten Zustand zum nächsten): \begin{itemize}
\item bei Fehler vor Ende: Rückgängigmachen der bisher durchgeführten Änderungen
\item bei Fehler nach Ende: kein Problem
\item Anfang meist implizit (oder \begriff{begin})
\item mit \begriff{eingebetteten Längenfeldern}: Gesamtlänge $GL$, Inhalt fester Länge $F$, zu jedem Inhalt variabler Länge $V$ vorher die Länge $L$$\Rightarrow$ satzinterne Adresse kann \wichtig{nicht} direkt aus Katalogdaten berechnet werden\\
\input{fig/eingebettete-laengenfelder.tex}
\item eingebettete Längenfelder mit \begriff{Zeigern}: Länge des festen Strukturteils $FL$, Zeiger auf variable Bereiche $\Rightarrow$ satzinterne Adresse kann aus Katalogdaten berechnet werden\\
\item eine oder mehrere Spalten einer Tabelle (und ggf. anderer, über Fremdschlüssel erreichbare Tabellen) nach einem Attribut sortiert
\item Speicherschlüssel (\begriff{Storage Keys}, \begriff{SK}) für jedes Tupel, aus Position berechenbar
\item\begriff{Verbund-Indizes} (\begriff{Join Indices}): Seien T1 und T2 Projektionen der Tabelle T, dann ist ein Join-Index von T1 zu T2 eine Liste von Tupeln aus T2 um den jeweiligen SK aus T1 ergänzt.
\end{itemize}
\item verschiedene \begriff{Komprimierungen} abhängig von Sortierung und Anzahl der verschiedenen Werte: \begin{itemize}
\item sortiert, wenige verschiedene Werte: Tripel (Wert, Position des ersten Auftretens, Anzahl des gleichen Werts) in B-Baum
\item unsortiert, wenige verschiedene Werte: lauflängenkodierte Bitmaps pro Wert mit B-Baum zum Auffinden der richtigen Bitmap
\item sortiert, viele verschiedene Werte: Delta-Kodierung (DIffertenz zum Vorgänger) mit B-Baum als Primärorganisation
\item unsortiert, viele verschiedene Werte: unkomprimiert, bei Zeichenketten \begriff{Dictionary}
\item\begriff{Programmfehler}: Absturz des Datenbank-Anwendungsprogramms $\Rightarrow$ Daten im Puffer und auf Festplatte in undefiniertem Zustand
\item\begriff{Systemfehler}: DBVS oder BS fällt aus, Hardware-Fehler, \textellipsis$\Rightarrow$ Daten im Puffer verloren, auf Festplatte in undefiniertem Zustand
\item\begriff{Gerätefehler}: Festplattenausfall $\Rightarrow$ Daten auf Festplatte sind verloren
\item\begriff{Transaktionsfehler}: z.B. \begriff{Deadlock}, falsche Operationen, Aufruf von \texttt{rollback} bzw. \texttt{abort}
\item Referentielle Integrität, Primärschlüsseleigenschaft und eigene Assertions sind erfüllt
\item erfordert physische Konsistenz
\end{itemize}
\item Nach Fehler soll ein logisch konsistenter Zustand erreicht werden: \begin{itemize}
\item der Zustand vor Beginn der unvollständigen Änderungen durch \begriff{Rückgängigmachen} dieser (\begriff{undo}) \begin{itemize}
\item\begriff{partial}: nach Transaktionsfehler Zurücksetzen der fehlgeschlagenen Transaktion
\item\begriff{global}: nach Systemfehler mit Verlust des Hauptspeicherinhalts Zurücksetzen aller unvollständigen Transaktion
\item Logging-Informationen müssen \wichtig{vor} dem Einbringen gespeichert werden (\begriff{write-ahead log}, WAL)
\end{itemize}
\item der Zustand nach Abschluss aller Änderungen durch \begriff{Vervollständigung} bzw. \begriff{Wiederholung} der unvollständigen Änderungen (\begriff{redo}) \begin{itemize}
\item\begriff{partial}: nach Systemfehler mit Verlust des Hauptspeicherinhalts Wiederholen aller verlorengegangen Änderungen von abgeschlossenen Transaktionen
\item\begriff{global}: nach Gerätefehler Einspielen des Backups und Nachvollziehen aller danach erfolgreichen Transaktionen
\item Logging-Informationen müssen \wichtig{vor} dem Melden des erfolgreichen Abschlusses geschrieben werden
\end{itemize}
\end{itemize}
\item\begriff{Sicherung} und \begriff{Protokollierung} (\begriff{Logging}) \wichtig{immer} notwendig
\item auch Einbringstrategie von Bedeutung: \begin{itemize}
\item\enquote{Wann \wichtig{darf} geänderte Seite auf die Festplatte geschrieben werden?}\begin{itemize}
\item\begriff{Steal}: auch schon vor Ende der Transaktion bei Verdrängung aus dem Puffer
\item\begriff{NoSteal}: erst am Ende der erfolgreichen Transaktion
\end{itemize}
\item\enquote{Wann \wichtig{muss} geänderte Seite auf die Festplatte geschrieben werden?}\begin{itemize}
\item\begriff{NoForce}: erst bei Verdrängung aus dem Puffer (also auch nach Ende einer Transaktion)
\item\begriff{Force}: spätestens am Ende der erfolgreichen Transaktion
\end{itemize}
\item\enquote{Wie werden geänderte Seiten auf die Festplatte geschrieben?}\begin{itemize}
\item\begriff{Atomic}: indirektes Einbringen, \enquote{Umschalten} von altem auf neuen Zustand
\end{itemize}
\end{itemize}
\item Protokollverfahren: \begin{itemize}
\item\begriff{physisch}: \begin{itemize}
\item\begriff{Zustandprotokollierung}: \begriff{before-image} für undo, \begriff{after-image} für redo, auf Ebene von Seiten oder Sätzen
\item\begriff{Seitenprotokollierung}: für jede geänderte Seite before-image und after-image sichern
\item\begriff{Eintragsprotokollierung}:nur geänderte Teile einer Seite
\end{itemize}
\end{itemize}
\item Begrenzung des Recovery-Aufwands durch \begriff{Sicherungspunkte} (\begriff{checkpoints}): \begin{itemize}
\item\begriff{transaction-oriented checkpoint}: Einbringung mittels Force
\item\begriff{transaction-consistent checkpoint}: Beginn neuer Transaktionen verhindern, auf Abschluss der laufenden warten, dann sichern
\item\begriff{action-consistent checkpoint}: keine Änderungs\wichtig{operation} darf aktiv sein, dann sichern; da aber Transaktionen laufen nur Begrenzung von Redo-Recovery