fertig

BBaum.tex

@@ -54,6 +54,24 @@ Am Ende eines Knotens ist ein Zeiger auf den nächsten enthalten am Ende.
 \textbf{Merke:}\\
 Beim Löschen von Werten bleibt der gleiche Diskriminator in inneren
 Knoten enthalten.
+\subsubsection{Löschen}
+Entsteht durch das LÖschen ein Unterlauf?
+\begin{itemize}
+		\item Nein:\\Entferne Satz aus Blatt
+		\item Ja:\\
+				Mische das Blatt mit einem Nachbarknoten. Ist die 
+				Summe der Einträge in beiden Knoten größer als 2k?
+				\begin{itemize}
+						\item Nein:\\
+								Fass beide Blätter zu einem Blatt zusammen. Falls Unterlauf
+								in Vaterknoten entsteht: Misch die inneren Knoten analog
+						\item Ja:\\
+								Teil die Sätze neu auf beide Knoten auf, so dass ein Knoten
+								jeweils die Hälfte der Sätze übernimmt. Der Diskriminator ist
+								zu aktualisieren.
+
+				\end{itemize}
+\end{itemize}
 \subsection{Vergleich}
 \begin{itemize}
 		\item BBaum:
@@ -73,3 +91,22 @@ Knoten enthalten.
 								Datensätzen vorkommen
 				\end{itemize}
 \end{itemize}
+\subsection{Bitmap Index}
+\textbf{B-Bäume (und Hashing) machen nur Sinn bei hoher Selektivität! ($\approx 5\%$)}
+Lege für jeden Schlüsselwert eine Bitliste an. Bitwert 1 bedeutet, der
+Schlüssel hat im Satz den Wert zu dem die Liste gehört. 0 bedeutet er hat keinen anderen Wert.\\
+Gut bei Wertigkeiten bis ca. 500. Hilft bei einfacher und effizienter
+Verknüpfung.
+
+\subsection{Primär- und Sekundär-Organisation}
+\textbf{Primär-Organisation}:\\
+Bedeutung: Speicherung der Sätze selbst.
+
+\textbf{Sekundär-Organisation}:\\
+Bedeutung: verweist nur auf Sätze, die nach beliebigen anderen Kriterien
+abgespeichert werden. Ist allerdings nur möglich, wenn Primärorganisation
+Direktzugriff auf einzelnen Satz haben.
+
+$\rightarrow$ B-Baum/$\text{B}^*$Baum als Sekundär Organsiation (Di);
+auch gestreute Speicherung als Sekundär Organsiation möglich (Buckets 
+[Schlüsseltwer,Satzadresse] Paare)

IDB.tex

@@ -78,6 +78,8 @@
 \include{./Einfuehrung}
 \include{./Saetze}
 \include{./BBaum}
+\include{./Puffer}
+\include{./Programmschnittstellen}
 \include{./Speicherung}
 \include{./Anfrageverarbeitung}
 \include{./Relationale_Operatoren}

Programmschnittstellen.tex

@@ -0,0 +1,55 @@
+\section{Programmschnittstellen}
+Vor- und Nachteile:\\
+Programmzugriff:
+\begin{itemize}
+		\item Keine SQL Injection nötig
+		\item Kompakt
+		\item spezieller Übersetzer nötig
+\end{itemize}
+Unterprogrammaufruf
+\begin{itemize}
+		\item Optimierung und Typprüfung
+		\item SQL Injection möglich
+		\item Aufwändig für Programmierer
+\end{itemize}
+\subsection{SQL Anfrage}
+Aufruf einer SQL Anfrage mit Index:
+\begin{lstlisting}[language=java]
+RecordFile index = new KeyedRecordFile("KNr","r");
+TID tid = index.read.Key(23);
+RecordFile saetze = new DirectRecord(Kunden", "r");
+Record ergebnis = saetze.read(tid);
+print(ergebnis.toString());
+\end{lstlisting}
+Aufruf einer SQL Anfrage ohne Index:
+\begin{lstlisting}[language = java]
+RecordFile saetze = new DirectRecordFile("Kunden","r");
+Record ergebnis;
+while (saetze.hasNext()){
+		ergebnis = saetze.next();
+		if(ergebnis.getKNr() == 23){
+				print(ergebnis);
+				break;
+		}
+}
+\end{lstlisting}
+
+\subsection{SQL Schnittstelle}
+\begin{enumerate}
+		\item Verbindung aufbauen
+				\begin{lstlisting}[language=java]
+				Connection DriverManager.connect(username, password, database)
+				\end{lstlisting}
+		\item Methode um eine Anfrage auszuführen
+				\begin{lstlisting}[language=java]
+				Handle Connection.executeQuery (String query);
+				\end{lstlisting}
+		\item Methode um zu prüfen, ob es weitere Ergebnisse gibt
+				\begin{lstlisting}[language=java]
+				Boolean Handle.hasNext();
+				\end{lstlisting}
+		\item Methode um überhaupt an Ergebnisse zu kommen		
+				\begin{lstlisting}[language=java]
+				Boolean Handle.hasNext();
+				\end{lstlisting}
+\end{enumerate}

Puffer.tex

@@ -0,0 +1,61 @@
+\section{Puffer}
+Frame = Im HS vorgesehener Platz zur Aufnahme eines Blocks $\rightarrow$ normalerweise so groß wie Block
+
+Bei Zugriff auf Blöcke im HS müssen diese ggf eingelagert werden.
+\subsection{Ersetzungsstrategie}
+\begin{itemize}
+		\item wählt den zu verdrängenden Block aus
+		\item Ziel: Minimierung von physischen Zugriffen
+\end{itemize}
+
+\subsubsection{FIFO}
+Block der am längsten im Puffer ist wird ersetzt.\\ $\rightarrow$ ungünstig
+da häufig benutzte Blöcke gerade im Puffer bleiben sollen
+
+\subsubsection{LFU (least frequently used)}
+Block auf den am seltensten zugegriffen wird ersetzt.
+\begin{itemize}
+		\item $-$ für sequentielles Lesen nicht brauchbar
+		\item $-$ hat ein Block einmal wieder zugegriffen bleibt der lange erhalten
+\end{itemize}
+
+\subsubsection{LRU (least recently used)}
+\begin{itemize}
+		\item bewertetes Alter seit dem letzten Zugriff
+		\item quasi verkettete Liste aller Blöcke im Puffer, wo bei Verdrängung letzter Block der Kette ersetzt wird
+\end{itemize}
+\begin{figure}[H]
+		\begin{center}
+				\includegraphics[scale=0.7]{pics/lru.png}
+				\caption{LRU}
+		\end{center}
+\end{figure}
+\subsubsection{Clock}
+LRU Verhalten mit einfacher Implementierung.
+\textbf{Prinzip}:
+\begin{itemize}
+		\item Benutzt(Dirty)-Bit eines Blocks im Puffer wird bei Zugriff auf
+				1 gesetzt
+		\item bei Verdrängung zyklischer SUche mit dem Auswahlzeiger:
+				\begin{itemize}
+						\item Falls Benutzt Bit = 1, wird es auf 0 gesetzt $\rightarrow$ Zeiger wandert zum nächsten Block
+						\item Falls Benutzt Bit = 0, Block wird ersetzt
+				\end{itemize}
+\end{itemize}
+
+\subsection{Dienste einer Pufferverwaltung}
+Einkapselung der Pufferverwaltung: 
+\begin{lstlisting}[language=C]
+char * Buffer::fix (BlcokFile FIle, int BlockNo, char Mode);
+\end{lstlisting}
+\begin{itemize}
+		\item Block ist zur Verdrängung geschützt
+		\item \textbf{Mode} gibt an welcher Block nur gelesen oder auch
+				geändert werden soll
+\end{itemize}
+\begin{lstlisting}
+void Buffer::unix (char * BufferAddresse)
+\end{lstlisting}
+\begin{itemize}
+		\item gibt Block im Puffer zur Ersetzung frei
+\end{itemize}