\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 spezeille \begriff{Overflow-Buckets}: Bucket verweist auf \enquote{\wichtig{seinen}} Overflow-Bucket
\end{itemize}
\item\begriff{virtuelles Hashing} zur konstanten Reorganisation: \begin{itemize}
\item Anzahl der Buckets $q$, Sätze pro Bucket $b$$\Rightarrow$ Kapazität $\coloneqq q \cdot b$
\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 betrachte doe Blattknoten mit direktem Vorgänger $S'$ und direktem Nachfolger $S''$ von $S$
\item wähle den größeren
\item ersetze $S$ je nach Wahl durch $S'$ bzw. $S''$
\item lösche entsprechenden Schlüssel $S'$ bzw. $S''$ und ggf. Unterlauf behandeln
\item Sätze stehen \wichtig{ausschließlich} in Blattknoten
\item innerer Knoten: \begin{itemize}
\item Anzahl der verwendeten Einträge $n$
\item Eintrag: Tupel (Referenzschlüssel, Blocknummer des Kindknotens)
\end{itemize}
\item Blattknoten: \begin{itemize}
\item Anzahl der verwendeten Einträge $n$
\item Vorgänger-Zeiger, Nachfolger-Zeiger
\item Eintrag: Tupel (Schlüsselwert, Datensatz)
\end{itemize}
\item Löschen ohne Unterlauf: lösche Satz aus Blatt; Diskriminator muss \wichtig{nicht} geändert werden
\item Löschen mit Unterlauf:\begin{itemize}
\item Ist Anzahl der Einträge des Blatts und eines Nachbarknotens größer als 2k, verteile Sätze neu auf beide Knoten
\item ansonsten mische beide Blätter zu einem einzigen
\end{itemize}
\end{itemize}
\item Müssen nicht zwangsläufig zur \begriff{Primärorganisation} verwendet werden, können als \enquote{Sätze} z.B. auch nur Satzadressen enthalten
\end{itemize}
\item\begriff{Bitmap-Indizes}: eine Bitmap \wichtig{pro Schlüsselwert}
\end{itemize}
\section{Puffer}
\begin{itemize}
\item Hauptspeicherbereich, der Blöcke aufnehmen kann, um (Lese-/Schreibe-) Zugriffe zu \wichtig{beschleunigen}
\item\begriff{Ersetzungsstrategie}: \enquote{Welcher Block wird verdrängt?}\begin{itemize}
\item\begriff{first in, first out} (FIFO): \enquote{ältester} Block
\item\begriff{least frequently used} (LFU): am seltensten benutzter Block
\item\begriff{least recently used} (LRU): am längsten nicht mehr benutzter Block
\item\begriff{second chance} (CLOCK): Approximation von LRU mit einfacherer Implementierung: \begin{itemize}
\item Jeder Block im Puffer besitzt ein \begriff{Benutzt-Bit}
\item bei Verdrängung Suche mit Zeiger
\item falls Benutzt-Bit 1, auf 0 setzen
\item falls Benutzt-Bit 0, Block ersetzen
\item\textbf{TODO:} Muss immer weitergegangen werden?
\end{itemize}
\end{itemize}
\item Zustand im Fehlerfall hängt unter anderem von \begriff{Einbringstrategie} (siehe \textbf{TODO} Recovery) und \begriff{Seitenzuordnung} ab
\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{Compiler-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 kann durch Präprozessort direkt als \begriff{stored procedure}\textbf{TODO: Verlinkung} angelegt werden