Add tutorial slide sources

tut09.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+## Evaluation der Lehrevaluation
+
+## Online Analytical Processing
+
+Expertengruppen
+
+## Online Analytical Processing
+
+* ROLAP:
+    * Wird direkt auf Tabellen angewendet, ohne einen Würfel zu erzeugen
+* MOLAP:
+    * Arbeitet auf einem Multi-Dimensionalen Würfel
+* HOLAP:
+    * Kombiniert beides
+    * Aus Tabellen erzeugte Data-Cubes werden zwischengespeichert.
+
+## PostgreSQL einrichten
+
+Auf das Benutzerkonto von PostgreSQL wechseln, und sich mit dem Server verbinden:
+```bash
+sudo -u postgres psql
+```
+
+Datenbank und Datenbankbenutzer erstellen
+```SQL
+create database dbs_project;
+create user dbs;
+grant all privileges on database dbs_project to dbs;
+alter user dbs with password '1234';
+```
+
+Der Benutzer muss mit Standardeinstellungen von PostgreSQL genauso heißen wie der Benutzername auf dem Betriebssystem.
+
+## Verbindung testen
+
+```Python
+import psycopg2
+
+# Connect to your postgres DB
+conn = psycopg2.connect("dbname=dbs_project user=<username>")
+
+# Open a cursor to perform database operations
+cur = conn.cursor()
+
+# Execute a query
+cur.execute("SELECT TRUE")
+
+# Retrieve query results
+records = cur.fetchall()
+
+print("Sucess!")
+```

tut1.md

+---
+theme: "metropolis"
+---
+
+# 1. DBS Tutorium
+
+## Motivation
+
+- Praxisrelevant
+    - Datenbanken kommen vor in
+        - Mobilen Apps
+        - Desktop Apps
+        - Web Service Backends
+- Abwechslungsreiches Themenfeld:
+    - Theoretische Basis durch Relationale Algebra
+    - Technischer Anteil
+    - Projektplanungsanteil
+
+## Übungszettel
+
+- in Gruppen aus 3-4 Leuten **aus einem Tutorium von mir**
+- Mindestens 70% der Punkte über alle Zettel
+- Abgabe bitte nur als PDF
+
+## Korrektur
+
+- Feedback als Kommentare im PDF
+- Bitte aktiv lesen, oft könnt ihr durch Erklärung noch mehr Punkte bekommen
+
+## Aktive Teilnahme
+
+- Mindestens 7 Tutorien müssen besucht werden
+- Projekt muss bestanden werden
+
+## Kennelernen
+
+- Sucht eine Person die ihr noch nicht kennt, und redet mit ihr 2 Minuten lang über ein Thema
+- Themen:
+    - Haustiere
+    - Reisen
+    - wie kommt ihr zur Uni?
+    - Warum belegst du dieses Modul / studierst deinen Studiengang?
+
+## Übungsgruppen finden
+
+
+## Kontakt
+
+Jonah Brüchert
+
+E-Mail: [jonahbeneb02@fu-berlin.de](mailto:jonahbeneb02@fu-berlin.de)
+
+## Entity-Relationship-Modell
+
+![](ER-Modell.jpg)
+
+## Relationalionales Modell
+
+```
+Name(Spalte1, Spalte2, Spalte3)
+```
+
+* Primärschlüssel werden unterstrichen
+
+## Beispiel: Bezahlsystem
+
+Funktionen:
+
+* Produkte
+* Transaktionen
+* Benutzer
+
+Mit min-max Notation
+
+## Beispiel: Videoplattform
+
+* Videos
+* ähnliche Inhalte
+* Kommentare
+* Accounts
+
+## Vorstellen

tut2.md

+---
+theme: "metropolis"
+header-includes:
+    - \usepackage[normalem]{ulem}
+---
+
+## Beispiel: Getränke
+
+Getränke:
+\begin{tabular}{l|l}
+    Name & Koffeingehalt in mg/100ml \\
+    \hline
+    Club Mate & 20 \\
+    Mio Mio Mate & 20 \\
+    Mio Mio Cola & 10 \\
+\end{tabular}
+
+Lager:
+\begin{tabular}{l|l}
+    Name & Menge (Kästen) \\
+    \hline
+    Club Mate & 5 \\
+    Mio Mio Mate & 11 \\
+    Mio Mio Cola & 20 \\
+\end{tabular}
+
+## Abfragen
+
+ * Von welchen Getränken (Namen) sind weniger als 10 im Lager?
+<!-- `SELECT Name FROM Lager WHERE Menge < 10`
+ $\Pi_{Name}(\sigma_{Menge < 10}(Getränke))$-->
+ * Von welchen Getränken (Namen) mit mehr als 10mg Koffein/100ml sind mehr als 10 Kästen vorhanden?
+<!-- $\Pi_{Name}(\sigma_{Koffeingehalt > 10 \land Menge > 10}(Getränke \bowtie Lager))$
+ `SELECT Name FROM Getränke NATURAL JOIN Lager WHERE Koffeingehalt > 10 AND Menge > 10`-->
+
+## SQL als DDL
+
+ * Erstelle die beiden Getränketabellen in SQL
+
+<!--  `CREATE TABLE Getränke (Name TEXT PRIMARY KEY NOT NULL, Koffeingehalt INTEGER NOT NULL);` -->
+
+<!--  `CREATE TABLE Lager (Name TEXT, Menge INTEGER NOT NULL, FOREIGN KEY (Name) REFERENCES Getränke(Name));` -->
+
+## Erweiterung
+
+Füge eine weitere Tabelle für Preise hinzu
+
+## Beispiel
+
+Wie könnten die Übungszettel-Funktionalität des Whiteboards in der Datenbank abgebildet sein?
+Überlegt euch ein Entity-Relationship Modell, das mindestens die Folgenden Inhalte umfasst:
+
+ * Assignments
+ * Grades
+ * Attachments
+ * Submissions
+
+Anschließend, erstellt die Tabellen in SQL
+
+## Nachtrag
+

tut3.md

+---
+theme: "metropolis"
+---
+
+## Beispiel: Getränke
+
+Getränke:
+\begin{tabular}{l|l}
+    Name & Koffeingehalt in mg/100ml \\
+    \hline
+    Club Mate & 20 \\
+    Mio Mio Mate & 20 \\
+    Mio Mio Cola & 10 \\
+\end{tabular}
+
+Lager:
+\begin{tabular}{l|l}
+    Name & Menge (Kästen) \\
+    \hline
+    Club Mate & 5 \\
+    Mio Mio Mate & 11 \\
+    Mio Mio Cola & 20 \\
+\end{tabular}
+
+## Abfragen
+
+ * Von welchen Getränken (Namen) sind weniger als 10 im Lager?
+<!-- `SELECT Name FROM Lager WHERE Menge < 10` -->
+ $\Pi_{Name}(\sigma_{Menge < 10}(Lager))$
+ * Von welchen Getränken (Namen) mit mehr als 10mg Koffein/100ml sind mehr als 10 Kästen vorhanden?
+ $\Pi_{Name}(\sigma_{Koffeingehalt > 10 \land Menge > 10}(Getränke \bowtie Lager))$
+<!--  `SELECT Name FROM Getränke NATURAL JOIN Lager WHERE Koffeingehalt > 10 AND Menge > 10` -->
+
+## SQLite als Testumgebung
+
+Debian, Ubuntu etc.:
+```bash
+sudo apt install sqlite3
+```
+
+Fedora:
+```bash
+sudo dnf install sqlite
+```
+
+Über Uni-Server:
+```bash
+ssh <Zedat-Benutzername>@andorra.imp.fu-berlin.de
+```
+
+SQLite starten:
+```bash
+sqlite3
+```
+
+## SQL als DDL
+
+ * Erstelle die beiden Getränketabellen in SQL
+
+<!--   `CREATE TABLE Getränke (Name TEXT PRIMARY KEY NOT NULL, Koffeingehalt INTEGER NOT NULL);` -->
+
+<!-- `CREATE TABLE Lager (Name TEXT PRIMARY KEY NOT NULL, Menge INTEGER NOT NULL, FOREIGN KEY (Name) REFERENCES Getränke(Name));` -->
+
+## Daten Einfügen und Ändern
+
+* Füge die Beispieldaten in deine Tabelle ein
+
+<!-- `INSERT INTO Getränke (Name, Koffeingehalt) VALUES ("Club Mate", 20), ("Mio Mio Mate", 20), ("Mio Mio Cola", 10);` -->
+
+<!-- `INSERT INTO Lager (Name, Menge) VALUES ("Club Mate", 5), ("Mio Mio Mate", 11), ("Mio Mio Cola", 20);` -->
+
+* Ändere den Bestand von Club Mate auf 10 Kästen
+
+<!-- `UPDATE Lager SET Menge = 10 WHERE Name = "Club Mate";` -->
+
+* Erstelle ein View über die die Gesamtmenge an Getränken
+
+<!--  `CREATE VIEW Gesamt AS SELECT SUM(Menge) FROM Lager;` -->
+
+## Beispiel
+
+Wie könnten die Übungszettel-Funktionalität des Whiteboards in der Datenbank abgebildet sein?
+Überlegt euch ein Entity-Relationship Modell, das mindestens die Folgenden Inhalte umfasst:
+
+ * Assignments
+ * Grades
+ * Attachments
+ * Submissions
+
+Anschließend, erstellt die Tabellen in SQL

tut4.md

+---
+theme: "metropolis"
+aspectratio: 169
+---
+
+## Functional Dependencies
+
+Die Werte von $X$ bestimmen die Werte eines anderen Attributs $Y$.
+
+## Beispiel
+
+\begin{tabular}{l|l|l|l}
+ID & Name & Salary & Location \\
+\hline
+1 & Dana & 50000 & San Francisco \\
+2 & Francis & 38000 & London \\
+3 & Andrew & 25000 & Tokyo \\
+\end{tabular}
+
+## Beispiel
+
+$\{A \rightarrow BD, B \rightarrow C, A \rightarrow D \}$
+
+- Was ist die minimale Form?
+
+## Armstrong Axiome
+
+**Reflexivität**:
+Y $\subseteq$ X, dann $X \rightarrow Y$
+
+**Erweiterung**:
+Wenn $X \rightarrow Y$ und Z Attribute, dann $XZ \rightarrow YZ$
+
+**Transitivität**:
+Wenn $X \rightarrow Y$ und $Y \rightarrow Z$, dann gilt auch $X \rightarrow Z$
+
+## Weitere Regeln
+
+**Vereinigung**:
+Wenn $X \rightarrow Y$ und $X \rightarrow Z$, dann $X \rightarrow YZ$
+
+**Zerlegung**: Wenn $X \rightarrow YZ$, dann $X \rightarrow Y$
+
+**Pseudotransitivität**: Wenn $X \rightarrow Y$, und $ZY \rightarrow T$, dann $XZ \rightarrow T$
+
+## Beispiel
+
+$\{A \rightarrow BD, B \rightarrow C \}$
+
+<!-- $\{A \rightarrow B, A \rightarrow D, B \rightarrow C, A \rightarrow C \}$ -->
+
+- Welche funktionalen Abhängigkeiten können abgeleitet werden?
+
+## Normalisierung
+
+Warum?
+
+- Speicherplatz sparen, für abhängige Attribute die sonst mehrmals den gleichen Wert annehmen würden
+- Konsistenz, keine mehrmalige Aktualisierung von abhängigen Attributen
+- Null-Values vermeiden
+- Feinere Löschung von Informationen
+
+## 1. Normalform
+
+- Jede Spalte in einem Eintrag kann nur einen Wert enthalten
+
+## 2. Normalform
+
+- Das Schema erfüllt die erste Normalform
+- Attribute müssen vom gesamten Schlüssel abhängen, nicht nur von einem Teil von ihm
+
+  $\Rightarrow$ Schemata deren Schlüssel nur aus einem Attribut bestehen, sind automatisch in 2. NF
+
+## 2. Normalform (Beispiel)
+
+\begin{tabular}{l|l|l|l|l|l|l}
+CD & Album & Interpret & Gründ. & Ersch. & Track & Titel \\
+\hline
+4711 & Not That Kind & Anastacia & 1999 & 2000 & 1 & Not That Kind  \\
+4711 & Not That Kind & Anastacia & 1999 & 2000 & 2 & I'm Outta Love  \\
+4711 & Not That Kind & Anastacia & 1999 & 2000 & 3 & Cowboys \& Kisses
+ \\
+4712 & Wish You Were Here & Pink Floyd & 1965 & 1975 & 1 & Shine On You
+Crazy Diamond  \\
+4713 & Freak of Nature & Anastacia & 1999 & 2001 & 1 & Paid my Dues  \\
+\end{tabular}
+
+- Welche Spalten bilden den Schlüssel?
+- Welches Attribut hängt von was ab?
+
+## 3. Normalform
+
+- Das Schema erfüllt die zweite Normalform
+- Attribute hängen nur vom Schlüssel ab. Nicht-Schlüssel-Attribute haben keine Abhängigkeiten untereinander.
+
+## 3. Normalform (Beispiel)
+\begin{tabular}{l|l|l|l|l|}
+ID & Album & Interpret & Gründung & Erscheinung \\
+\hline
+4711 & Not That Kind & Anastacia & 1999 & 2000  \\
+4712 & Wish You Were Here & Pink Floyd & 1965 & 1975  \\
+4713 & Freak of Nature & Anastacia & 1999 & 2001  \\
+\end{tabular}

tut5.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+# Verwendung von SQL
+
+- Einzelnstehend: SQL Abfragen werden von der Anwender*in direkt in das Datenbanksystem eingegeben
+- Eingebettet:
+    - Statisch: Die möglichen Abfragen sind in einem Programm definiert
+    - Dynamisch: Ein Programm generiert verschiedene Abfragen
+
+# Eingebettetes SQL
+
+- SQL-Abfragen werden aus einer anderen Programmiersprache abgesendet
+
+Beispiel:
+```Python
+conn = sqlite3.connect('test.sqlite')
+cursor = conn.execute("SELECT * from test")
+```
+
+# Vorteile (Auswahl)
+
+- Datenbank kann zur Speicherung von Daten eines Programmes verwendet werden
+- Ergebnisse können Domänenspezifisch dargestellt werden
+- Variablen aus der Programmiersprache des Programmes können in SQL verwendet werden
+
+# Vorteile von statischen Abfragen
+
+- Effizienz
+    - Abfragen müssen nur ein mal vom Datenbanksystem interpretiert und optimiert werden
+    - Optimierte Abfrage kann wiederverwendet werden
+
+# Sicherheit
+
+- Anwender*innen des Programmes (z.B. einer Webseite) sollten keine beliebigen Abfragen ausführen können.
+
+  Ungünstig wären z.B. `DROP TABLE accounts;` oder `SELECT * FROM payment_info`.
+
+# Sicherheit
+
+Beispiel:
+```Python
+conn.execute("INSERT INTO accounts (username) VALUES (" + username + ")")
+  ```
+
+Was passiert wenn jemand den Benutzernamen `"Katze123"); DROP TABLE accounts; --` wählt?
+
+# Sicherheit
+
+Zusammengesetzte Abfrage:
+```SQL
+INSERT INTO accounts (username) VALUES ("Katze123");
+DROP TABLE accounts;
+-- )
+```
+
+# Problem
+
+- Das Datenbanksystem kann nicht zwischen Code und Werten unterscheiden
+- alles wird ersteinmal als Code gelesen
+
+# Parameterized queries
+
+Verarbeitung mit Parameterized Queries / Prepared Statements:
+
+1. Code wird interpretiert
+1. Werte werden eingesetzt
+
+$\Rightarrow$ Werte können nicht mehr als Code interpretiert werden, da sie erst eingesetzt werden nachdem das interpretieren Abgeschlossen ist.
+
+# Parameterized queries
+
+Beispiel in Python:
+```Python
+c.execute("INSERT INTO accounts (username) VALUES (?)", username)
+```
+
+# Übung
+
+- Welche Programmiersprachen könnt ihr?
+
+# Übung
+
+- Bildet Gruppen
+- Recherchiert und testet wie man sich in einer anderen Programmiersprache als Python mit einer Datenbank verbindet. Hier empfiehlt sich wieder SQLite, da ihr vermutlich gerade keinen Datenbankserver zur verfügung habt.
+
+# Austausch
+
+- Bildet neue Gruppen, so dass ihr in jeder neuen Gruppe Personen aus jeder vorherigen Gruppe habt
+- Erklärt euch gegenseitig eure Ansätze

tut6.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+# Speicherung
+
+- Datenbank wird in mehreren Dateien gespeichert
+- Jede Datei enthält eine Liste von Einträgen (Records)
+- Jeder Eintrag besteht aus Feldern
+
+# Fixed-length Records
+
+- Einträge sind immer gleich lang
+- Position eines Eintrags lässt sich berechnen ($length \cdot i$)
+
+# Löschung mit Fixed-length Records
+
+Entweder:
+
+- alle späteren Einträge verschieben
+- letzten Eintrag in freien Platz verschieben
+- nichts verschieben, sondern Eintrag nur für wiederverwendung vormerken
+
+# Records mit variabler Länge mit Fixed-length Records
+
+Entweder:
+
+- Speicherung der eigentlichen Daten außerhalb der Tabelle, Verweis mit Pointer
+- Platz rervieren, wenn maximale Länge bekannt ist
+
+# Variable-lengh Records (Byte string representation)
+
+- Einträge können unteschiedlich viel Platz verbrauchen
+- werden mit Endzeichen beendet
+
+# Variable-lengh Records (Pointer Method)
+
+- Weitere Werte werden mittels Pointern an den Eintrag angehängt, als separater Eintrag mit nur diesem Feld
+
+# Transaktionen
+
+$\langle r_1(A), r_2(A) \rangle$ Kein Konflikt
+
+$\langle w_1(A), w_2(A) \rangle$ Konflikt
+
+$\langle w_1(A), w_r(A) \rangle$ Konflikt
+
+# Konfliktgraph
+
+- Knoten sind Transaktionen
+- Wenn zwei Transaktionen $T_x, T_y$ im Konflikt stehen, zeichne Verbindung von zuerst auftauchender Transaktion ($T_x$) zu $T_y$

tut6_2.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+## Attributhülle
+
+$A^+$ ist Menge der Attribute die von $A$ abhängig sind.
+
+## Minimale Hülle
+
+- kleinstmögliche äquivalente Menge von Funktionalen Abhängigkeiten
+
+## Erstellen der minimalen Hülle
+
+1. **Dekomposition**: alle Funktionalen Abhängigkeiten die auf mehrere Attribute verweisen werden aufgeteilt.
+1. **Unnötige Attribute auf der linken Seite** der Abhängigkeiten werden entfernt. Das sind alle Attribute die in der Attributhülle eines anderen Attributs auf der linken Seite vor kommen
+1. Alle Abhängigkeiten die schon implizit durch **transitive Abhängigkeiten** definiert sind, werden entfernt.
+
+## Zerlegung
+
+Zerlegung soll verlustlos sein, und die Abhängigkeiten erhalten
+
+## Zerlegung finden
+
+- Schlüssel aus der Menge der Funktionalen Abhängigkeiten finden. Alle Abhängigkeiten müssen von ihm aus erreichbar sein.
+- Eine neue Relation für jede Funktionale Abhängigkeit erstellen
+- Wenn Schlüssel in einer Relation nicht enthalten ist, hinzufügen
+- Wenn Relation danach in einer anderen Relation enthalten ist, die Relation entfernen

tut7.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+# Speicherung
+
+- Datenbank wird in mehreren Dateien gespeichert
+- Jede Datei enthält eine Liste von Einträgen (Records)
+- Jeder Eintrag besteht aus Feldern
+
+# Fixed-length Records
+
+- Einträge sind immer gleich lang
+- Position eines Eintrags lässt sich berechnen ($length \cdot i$)
+
+<!--# Löschung mit Fixed-length Records
+
+Entweder:
+
+- alle späteren Einträge verschieben
+- letzten Eintrag in freien Platz verschieben
+- nichts verschieben, sondern Eintrag nur für wiederverwendung vormerken-->
+
+# Records mit variabler Länge mit Fixed-length Records
+
+Entweder:
+
+- Speicherung der eigentlichen Daten außerhalb der Tabelle, Verweis mit Pointer
+- Platz rervieren, wenn maximale Länge bekannt ist
+
+# Variable-lengh Records (Byte string representation)
+
+- Einträge können unteschiedlich viel Platz verbrauchen
+- werden mit Endzeichen beendet
+
+# Variable-lengh Records (Pointer Method)
+
+- Weitere Werte werden mittels Pointern an den Eintrag angehängt, als separater Eintrag mit nur diesem Feld
+
+# Transaktionen
+
+$\langle r_1(A), r_2(A) \rangle$ Kein Konflikt
+
+$\langle w_1(A), w_2(A) \rangle$ Konflikt
+
+$\langle w_1(A), r_2(A) \rangle$ Konflikt
+
+# Konfliktgraph
+
+- Knoten sind Transaktionen
+- Wenn zwei Transaktionen $T_x, T_y$ im Konflikt stehen, zeichne Verbindung von zuerst auftauchender Transaktion ($T_x$) zu $T_y$

tut8.md

+---
+theme: "metropolis"
+aspectratio: 169
+header-includes:
+    - \usepackage{listings}
+---
+
+
+# Abfrageoptimierung
+## Lehrevaluation
+
+\centering
+![](evaluation.png)
+
+[lehrevaluation.fu-berlin.de/productive/de/sl/fT7L5K1gaChL](https://lehrevaluation.fu-berlin.de/productive/de/sl/fT7L5K1gaChL)
+
+## Verarbeitung der Abfrage
+
+1. Verstehen der Abfrage (parsing etc.)
+2. Optimieren in relationaler Algebra
+3. Erzeugen eines Ausführungsplans
+4. Ausführen
+
+## Regeln
+
+- Unnötige Joins entfernen
+- Join statt Kreuzprodukt verwenden
+- Selektion soll so früh wie möglich statt finden (Priorität 1)
+- Projektion soll früh stattfinden (Priorität 2)
+- Verundete Selektionen nacheinander anwenden: $\sigma_{A \land B}(R) \rightarrow \sigma_{A}(\sigma_{B}(R))$
+
+## Äquivalenzen
+
+\begin{align*}
+\sigma_P(R_1 \cup R_2) &= \sigma_P(R_1) \cup \sigma_p(R_2) \\
+\sigma_P(R_1 - R_2)    &= \sigma_P(R_1) - \sigma_P(R_2) \\
+(R_1 \cup R_2) \cup R_3 &= R_1 \cup (R_2 \cup R_3) \\
+R_1 \cup R_2 &= R_2 \cup R_1
+\end{align*}