diff --git a/00-META.md b/00-META.md
new file mode 100644
index 0000000..7ae8f0c
--- /dev/null
+++ b/00-META.md
@@ -0,0 +1,5 @@
+---
+lang: de
+numbersections: true
+VersionODT: 0.3 (05.02.2020)
+---
\ No newline at end of file
diff --git a/00-TITLE.md b/00-TITLE.md
new file mode 100644
index 0000000..061faea
--- /dev/null
+++ b/00-TITLE.md
@@ -0,0 +1,7 @@
+---
+title: Datenbanken
+subtitle: Eine Einführung mit InstaHub
+author: Reinhard Nitzsche
+date: Version 0.3 (05.02.2020)
+---
+
diff --git a/000-Liesmich.md b/000-Liesmich.md
new file mode 100644
index 0000000..502178d
--- /dev/null
+++ b/000-Liesmich.md
@@ -0,0 +1,43 @@
+---
+title: Technisch-Didaktisches Liesmich für das InstaHub-Skript
+lang: de
+numbersections: true
+author: Reinhard Nitzsche
+VersionODT: 0.2 (21.01.2020)
+version: 0.2 (21.01.2020)
+---
+
+# Ziel
+
+- Aus den MD-Dateien werden einsatzbereite ODT-, PDF- und EPUB-Dateien erstellt.
+- EPUB kann als Moodle-Buch in Moodleimportiert werden
+- Die vielfältigen Dateiformate bieten Raum für Differenzierungen und individuelle Entscheidungen der Lehrkraft.
+
+# Ordner im Stammverzeichnis
+
+- Abbildungen: Abbildungen, die im Skript und in Moodle verwendet werden in der Rohfassung bzw. im Quellformat
+- Assets: Abbildungen, die in den MD-Dateien referenziert werden. Diese sind so skaliert, dass sie in EPUB, ODT und PDF einigermaßen vernünftig aussehen
+- EPUB, ODT und PDF: In diese Ordner werden die konvertierten Dateien geschrieben. Der Inhalt wird also ohne Rückfrage überschrieben!
+- Video: Screencasts zur Ergänzung des Skriptes
+
+# Dateien im Stammverzeichnis
+
+- *.md: Die einzelnen Kapitel des Buches. Folgende Ausnahmen:
+
+ - 000-Liesmich.md: Diese Datei
+ - 00-Meta.md: Meta-Angaben, die in jede EPUB- und die Einzel-ODT-Dateien geschrieben werden sollen. Das YAML-Feld VersionODT soll denselben Wert wie das Feld date in 00-Titel.md enthalten. Es wird in der Fußzeile der ODT-Dateien als Feld eingefügt.
+ - 00-Titel.md: Meta-Angaben, die in die Komplett-Dateien, aber nicht in die ODT-Dateien geschrieben werden sollen.
+
+- instahub.css: CSS-Informationen, die in EPUB eingebettet werden, von vielen Readern aber offenbar nicht interpretiert werden.
+
+- instahub.xml: Meta-Daten für EPUB. Ob die neben den YAML-Angaben noch nötig sind, habe ich nicht getestet. Kofler schreibt das aber so. (Vgl. Kofler: Markdown & Pandoc, 2. Auflage)
+
+- InstaHubCover.png: Das Titelbild für das EBook
+
+- instahubTemplate.odt: Die Vorlage, nach der die ODT-Dateien geschrieben werden. Laut Pandoc ist das kein Template, aber es funktioniert fast wie eines. Die Datei darf offenbar keine Bilder enthalten. Übernommen werden Seiteneinstellungen inkl. der Inhalte der Kopf- und Fußzeilen.
+
+ Sie ist derzeit so eingerichtet, dass zwei A4-Seiten auf eine A4-Seite kopiert werden könnnen.
+
+- makeall.bat: Eine Batch-Datei, die alle EPUB-, ODT- und PDF-Dateien erstellt.
+
+
\ No newline at end of file
diff --git a/01-Vorwort.md b/01-Vorwort.md
new file mode 100644
index 0000000..43622d7
--- /dev/null
+++ b/01-Vorwort.md
@@ -0,0 +1,55 @@
+
+# Vorwort
+
+Julian Dorns InstaHub ist ein wundervolles Werkzeug, um Datenbanken zu unterrichten. Das vorliegende Skript orientiert sich an dem von ihm vorgeschlagene Vorgehen, weicht aber an einigen Stellen ab.
+
+Zielgruppe des Skriptes und des unterstützenden Moodle-Kurses sind Schüler*innen mit Mittlerem Bildungsabschluss auf dem Weg zur (Fach-)Hochschulreife. Entstanden ist es für den Unterricht in beruflichen Vollzeitschularten. Der Einsatz in allgemeinbildenden Schulen und mit leistungsstarken jüngeren Schüler\*innen ist aber möglich.
+
+## Pfade durch dieses Skript {-}
+
+Einige Kapitel sind optional. Sie behandeln interessante Themen, die aber in den späteren Kapiteln nicht wieder aufgegriffen werden. Sie können also weggelassen werden, wenn dies notwendig ist. Eventuell ist auch ein Einsatz im Rahmen der Binnendifferenzierung sinnvoll.
+
+Je nach zur Verfügung stehender Zeit, bestehenden Vorkenntnissen und gewünschtem Fokus kann auf die Behandlung der folgenden Kapitel auch verzichtet werden:
+
+- Kapitel 4 Suchmaske
+- Kapitel 8 Passwörter speichern
+- Kapitel 10 Vertiefung ER-Modell
+- Kapitel 11 SQL-Abfragen über mehrere Tabellen (JOIN)
+
+*Reinhard Nitzsche*
+
+## Lizenz {-}
+
+
+
+Datenbanken. Eine Einführung mit Instahub von Reinhard Nitzsche ist lizenziert unter einer [Creative Commons Namensnennung-Nicht kommerziell 3.0 Deutschland Lizenz](http://creativecommons.org/licenses/by-nc/3.0/de/).
+
+Klarstellung: Der Einsatz im Unterricht und in Arbeitsgemeinschaften in öffentlichen Schulen ist nicht kommerziell.
+
+## Nur möglich durch {-}
+
+Dieses Skript entstand unter Einsatz folgender Software:
+
+1. Die Markdown-Dateien wurden mit Typora editiert, die
+2. pandoc in verschiedene Zielformate übersetzt hat, darunter
+3. ODT, aus dem Libre Office und PDFCreator dann PDF-Dateien erzeugt haben.
+4. Die Screenshots wurden mit Greenshot erzeugt und annotiert.
+5. Der Moodle-Kurs wurde wäre ohne Moodle undenkbar (ach nee...),
+6. Die Lernspiele im Moodle-Kurs entstanden bei LearningApps.com.
+7. Die Screencasts im Moodle-Kurs wurden mit OBS erstellt.
+
+Allen an der Entwicklung dieses Tools beteiligten herzlichen Dank.
+
+Wertvolle Hinweise verdanke ich den Schüler\*innen der Klassen Abi21b, BOM19-2 und BOM19-3 der Beruflichen Schule Elmshorn.
+
+## Bildnachweis {-}
+
+Alle verwendeten Grafiken sind eigene Werke oder stammen aus der Public Domain:
+
++ tango-Projekt
++ Open Clipart Library
+
+Allen Zuträger\*innen herzlichen Dank.
+
+
+
diff --git a/02-Einstimmung.md b/02-Einstimmung.md
new file mode 100644
index 0000000..cc8aa20
--- /dev/null
+++ b/02-Einstimmung.md
@@ -0,0 +1,159 @@
+# Einstimmung
+
+## InstaHub?
+
+InstaHub ist ein soziales Netz, das Instagram ähnelt. Es gibt aber einen ganz wichtigen Unterschied: Anders als Instagram lässt InstaHub Sie hinter die Kulissen blicken. So gewinnen Sie Einblicke in die Arbeitsweise von sozialen Netzen und lernen ganz nebenbei, wie Datenbanken funktionieren.
+
+Die folgenden Screenshots geben Ihnen einen Eindruck davon, was Sie in InstaHub erwartet:
+
+
+
+
+
+
+
+
+
+InstaHub funktioniert also fast wie Instagramm. Inklusive Werbung. Der entscheidende Unterschied ist, dass alles in InstaHub fiktiv ist. Die Menschen gibt es genauso wenig wie die Unternehmen, die die Werbung schalten.
+
+Unter https://instahub.org/#guest können Sie sich schon einmal umsehen.
+
+## Datenbanken?
+
+Eine Datenbank ist wie eine Bank, der man sein Geld bringen kann. Nur eben für Daten.
+Das schöne an einer Bank ist, das man ihr sein Geld anvertrauen kann, und es auch wieder bekommt, wenn mann will:
+
+
+
+Bei einer Datenbank ist es ganz ähnlich, nur dass die Benutzer:innen statt Geld dort Daten abgeben und wiederholen:
+
+
+
+
+
+## Datenbanken sind überall
+
+Programme, die Datenbanken verwalten, heißen **Datenbankmanagementsysteme** (DBMS). Kleinere DBMS sind Microsoft Access oder Libre Office Base. Größere DBMS sind MySQL und der MS SQL-Server.
+
+Im Grund stellen die meisten DBMS lediglich die Möglichkeit bereit, gigantische Tabellen zu erstellen und sie in Windeseile zu verknüpfen.
+
+Wenn Sie zum Beispiel mit Google[^10] nach "instahub" suchen, schlägt Google in seinen Datenbanken nach und stellt in 0,36 s fest, dass sie fast 30 Millionen Treffer hat:
+
+
+
+[^10]: Die anderen Suchmaschinen machen es genauso, aber die Zeit gibt nur Google aus...
+
+Kein Onlineshop kommt ohne Datenbanken aus - z. B. für die Produktpräsentation und die Verwaltung der Bestellungen:
+
+
+
+Aber auch beim Versand der Ware geht nichts ohne Datenbanken:
+
+
+
+#### Aufgabe 2.1: Datenbanken sind überall {-}
+
+*Überlegen* Sie: Wo sind Sie in den letzten Tagen wohl Datenbanken begegnet? Wo *vermuten* Sie Datenbanken, die Informationen über Sie speichern?
+
+## Eigenschaften von DBMS
+
+### Warum Datenbanken, wir haben doch Tabellenkalkulationen!
+
+Wenn die meisten Datenbanken aus lauter Tabellen bestehen, drängt sich die Frage auf, warum wir dafür nicht einfach eine Tabellenkalkulation wie z. B. Microsoft EXCEL oder Libre Office Calc verwenden. Hier also die wichtigsten Gründe für die Verwendung von Datenbankmanagementsystemen (DBMS):
+
+### Viele Köche verderben nicht immer den Brei
+
+DBMS ermöglichen in der Regel zahlreichen Benutzer:innen gleichzeitig den Zugriff auf die gespeicherten Daten. Man spricht auch von **Mehrbenutzerfähigkeit**.
+
+Mehrere Benutzer:innen können also zeitgleich auf eine Tabelle zugreifen, eventuell sogar auf die selbe Zeile (Bei Datenbanken spricht man von *Datensatz*). Tabellenkalkulationen erlauben dies in der Regel allenfalls zum lesen.
+
+Über diese Möglichkeit verfügen zwar zunehmend auch Tabellenkalkulationen, aber nur in eingeschränkter Weise und nich für eine große Zahl gleichzeitiger Zugriffe.
+
+### Was ich darf, darfst Du noch lange nicht!
+
+DBMS erlauben **Zugriffsbeschränkungen**. Das heißt, dass nicht alle Benutzer:innen über die selben Rechte verfügen. Einige typische Rechte sind z. B.:
+
+- Erstellen neuer Tabellen
+- Ändern der Struktur bestehender Tabellen
+- Datensätze ansehen
+- Datensätze einfügen
+- Datensätze löschen
+- Datensätze verändern
+
+### Jedem das Seine
+
+DBMS müssen den unterschiedlichen Bedürfnissen und Fähigkeiten der Benutzer:innen Rechnung tragen und für jede Benutzergruppe unterschiedliche Schnittstellen zur Verfügung stellen. Man spricht von **Mehrbenutzerschnittstellen**. Z. B. gibt es Oberflächen für gelegentliche Nutzer:innen, oder Schnittstellen für die Programmierer:innen von Datenbankanwendungen oder hochentwickelte Anfragesprachen für versierte Nutzer:innen mit sehr speziellen Informationsbedürfnissen.
+
+### Ich sehe was, was Du nicht siehst!
+
+DBMS ermöglichen die Einrichtung von Datensichten (*views*), d. h. unterschiedlicher Perspektiven auf die Datenbank. So könnte z. B. jede:r Dozent:in einer Universität eine Liste aller Teilnehmer:innen seines Kurses inklusive der vorher besuchten Kurse sehen, obwohl diese Daten in vielen Tabellen verstreut liegen.
+
+### Lass mich mal abschreiben!
+
+Wie viele Stellen im Betrieb benötigen eigentlich die Adresse eine:r Kund:in? Mindestens folgende:
+
+- Kundenbuchhaltung,
+- Versand und
+- Marketing.
+
+Dieses mehrfache Speichern derselben Sachverhalte nennt man *Redundanz*. (lat. *redundare* „im Überfluss vorhanden sein“). Redundanz bringt Probleme mit sich:
+
+- Wenn ein- und dieselben Daten an verschiedenen Stellen gespeichert sind, werden Daten mehrfach erfasst (mehrfacher Zeitaufwand) und mehrfach gespeichert (mehrfacher Speicherplatz).
+- Das wäre noch nicht so schlimm. Es gibt noch ein viel größeres Problem: Das der Inkonsistenz. (lat.: *in* nicht, *con* zusammen, *sistere* halten) Die Wahrscheinlichkeit ist groß, dass irgendwann Versand und die Kundenbuchhaltung unterschiedliche Adressen verwenden, weil der Kunde umgezogen ist, aber einer von beiden das nicht mitbekommen hat. Die Pakete gehen dann z. B. schon an die neue Adresse, während die Rechnung an die alte Adresse geht.
+
+DBMS sollten über eine **Redundanzkontrolle** verfügen, so dass bei (manchmal unvermeidlicher) redundanter Speicherung von Daten Inkonsistenzen verhindert werden.
+
+### Beziehungskisten
+
+Die Tabellen einer Datenbank hängen untereinander logisch zusammen. DBMS unterstützen diese komplexen Beziehungen, in dem sie diese Beziehungen verwalten und effizient miteinander verbinden und aktualisieren können. Z. B. dient die Personalnummer in vielen Tabellen der Personalabteilung zur Identifizierung eines Mitarbeiters. Diese **Beziehung zwischen Daten** nennt man auch **Relation**. Sie ist so wichtig, dass die wichtigste Gruppe von DBMS sogar nach ihr benannt wurde: Die **relationalen Datenbanken**. Instahub liegt eine solche relationale Datenbank zu Grunde. Auch Access und Base sind relationale Datenbanken.
+
+### Vertrauen ist gut, Kontrolle besser!
+
+Datenbanken können in DBMS so definiert werden, dass bestimmte **Integritätsbedingungen** (Integrität: lat. *integritas* „unversehrt“, „vollständig“) zu jedem Zeitpunkt eingehalten sein müssen. Auf diese Weise kann z. B. sicher gestellt werden, dass jeder Kurs eine*n Dozent\*in bekommt und kein\*e Student\*in einen Kurs belegen kann, den es gar nicht gibt.
+
+### Daten, Daten, Daten – soweit das Auge reicht!
+
+DBMS sind darauf ausgerichtet, mit sehr großen Datenmengen umgehen zu können. Das Selektieren von tausenden Datensätzen aus einer Datenbank mit Millionen von Datensätzen dauert in modernen DBMS nur Bruchteile von Sekunden.
+
+### Sicher ist sicher!
+
+Sollte es zu einem Problem mit dem DBMS kommen, z. B. wegen eines Soft- oder Hardwarefehlers, sorgen DBMS durch geschickte Speicherung der Daten auf der Festplatte für die Möglichkeit, auf einem korrekten Zustand kurz vor Entstehen des Problems wieder aufzusetzen. (**Recovery**)
+
+#### Aufgabe 2.2: Eigenschaften von DBMS {-}
+
+*Erstellen* Sie eine Tabelle, in der Sie zu jeder in diesem Abschnitt genannten Eigenschaft von DBMS ein Beispiel aus einem Warenwirtschaftsystem eines Unternehmens finden. Warenwirtschaftssysteme dienen zur Abbildung der Warenströme in Unternehmen.
+
+## Die Client-Server-Architektur
+
+Es vermeidet Missverständnisse, wenn wir vor der Arbeit mit InstaHub noch einen Blick auf die Client-Server-Architektur (oft auch: Client-Server-Modell) werfen.
+
+Den Begriff "Server" kennen sie bestimmt bereits. Zum Beispiel wissen Sie, dass ein Server ausfallen kann und dann etwas nicht mehr funktioniert, auf das Sie dringend angewiesen sind.
+
+Beispiel: Herr Ölgemöller arbeitet in der Buchhaltung der Hausverwaltung Sörkeling. In seinem Büro befindet sich ein Drucker, auf den er über das lokale Netz (LAN) zugreift. Der Druckserver ist ausgefallen. Obwohl sowohl sein Rechner als auch der Drucker dienstbereit sind, kann Herr Ölgemöller nicht drucken, da der vom Server angebotene Dienst "Drucken" nicht verfügbar ist.
+
+
+
+Bei der Client-Server-Architektur gibt es mindestens zwei IT-Systeme. Das eine ist der Server, der Dienste anbietet und das andere ist der Client, der diese Dienste in Anspruch nehmen kann. Meist greifen mehrere Clients auf einen einzigen Server zu.
+
+In einem IT-Lexikon liest sich das dann so:
+
+> **Client-Server-Architektur** (engl.: *client-server architecture*) Kooperative Form der Informationsverarbeitung bei der sich ergänzende Softwarekomponenten meist (aber nicht zwangsläufig) auf unterschiedliche Rechner verteilt werden, die über ein Rechnernetz verbunden sind. Ein Client-Server-System ist eine einfache Form eines verteilten Systems, bei dem die Rollenverteilung zwischen dem Serverprogramm und Klientenprogramm statisch ist und meist eine 1:n-Beziehung darstellt. (Vgl. Hansen, S. 64)
+
+Beachten Sie: Client und Server sind im Sinne der Client-Server-Architektur *Softwarekomponenten* und keine *Hardware* (Geräte)! Daher können Client und Server auch durchaus auf ein- und demselben Rechner laufen. Z. B. wird bei der Entwicklung von Websites gerne auf das Packet XAMP zurück gegriffen. Es stellt einen vollen Webserver zur Verfügung , der u.a. aus den folgenden Komponenten besteht:
+
++ HTTP-Server
++ Datenbankserver
++ Mailserver
+
+Wenn es InstaHub nicht gebe, wäre der Einsatz von XAMPP eine Möglichkeit, im Unterricht mit Datenbanken zu arbeiten. Wir arbeiten aber mit Instahub. Jede:r Schüler:in wird im Browser (=Client) die Website von Instahub aufrufen und dort Datenbankabfragen an den Server senden. Sie brauchen den Inhalt Ihres Instahubs also nicht auf einem USB-Stick zu speichern. Ihre Daten sind immer auf dem Server. Alles was Sie brauchen, ist ein Internetfähiger Rechner und eine Internetverbindung.
+
+## Quellen zu diesem Kapitel {.unnumbered}
+
++ Abschnitt [Eigenschaften von DBMS]:
+ + *Elmasri*, Rami und Shamkant B. Navathe: Grundlagen von Datenbanksystemen. Ausgabe Grundstudium. 3. Auflage. Pearson. S. 24-35.
+
++ Abschnitt [Die Client-Server-Architektur]:
+ + *Hansen*, H. R. und Neumann, G.: Arbeitsbuch Wirtschaftsinformatik. IT-Lexikon, Aufgaben, Lösungen. UTB. 7. Auflage.
+
+
+
diff --git a/03-Erste-Schritte.md b/03-Erste-Schritte.md
new file mode 100644
index 0000000..2a6561e
--- /dev/null
+++ b/03-Erste-Schritte.md
@@ -0,0 +1,105 @@
+
+# Erste Schritte mit InstaHub
+
+## Den eigenen Hub erstellen
+
+***ACHTUNG:* Bitte bearbeiten Sie diesen Abschnitt sehr sorgfältig. Der Antragsprozess funktioniert so, aber Unaufmerksamkeiten führen schnell zu Verdruss.**
+
+#### Aufgabe 3.1: Beantragen Sie einen eigenen InstaHub! {-}
+
+Zur Arbeit mit InstaHub arbeitet jede:r Schüler\:in auf einem eigenen InstaHub. Es hat also jeder sein eigenes soziales Netzwerk.
+
+Um einen InstaHub zu beantragen, gehen Sie wie folgt vor:
+
+1. *Rufen* Sie InstaHub in Ihrem Browser (**nicht** Internet Explorer!)[^20] auf: [instahub.org](https://instahub.org/)!
+
+ [^20]: InstaHub unterstützt alle gängigen Browser mit Ausnahme des Internet Explorers.
+
+2. *Klicken* Sie unten mittig auf den Button `SchülerInnen`:
+
+
+
+3. Klicken Sie auf `Hub erstellen`:
+
+
+
+4. Sie sehen das folgende Formular (Ausschnitt):
+
+
+
+5. _Notieren_ Sie sich __jetzt__ den Namen Ihres InstaHubs (im Beispiel: `rubinrot18`): ______________________. Wenn Sie den Namen Ihres Instahubs vergessen, **kommen Sie nur noch mit Hilfe Ihrer Lehrkraft rein!**
+
+6. _Tragen_ Sie unter `Dein/e LehrerIn` den InstaHub-Namen Ihrer Lehrkraft ein. Dies ist ______________________
+
+7. Unter `Name` (_nicht_ Benutzername!) tragen Sie bitte Ihre Klasse gefolgt Ihrem mit Ihrer Lehrkraft abgesprochenen Pseudonym ein.
+
+ Wenn Ihr Pseudonym Hermine ist und Sie in die Klasse BOM20-3 gehen, tragen Sie ein: `BOM20-3 Hermine `.
+
+ _Tragen_ Sie in den folgenden Feldern Angaben ein wie Sie wollen. Denken Sie sich etwas aus, aber nehmen Sie außer der E-Mail-Adresse nicht Ihre echten Daten.
+
+ Die E-Mail-Adresse ist hilfreich, **um das Passwort zurücksetzen zu können**.
+
+9. Wählen Sie ein sicheres Passwort.
+
+10. _Senden_ Sie Ihre Registrierung durch einen Klick auf `Register`ab und ***warten* Sie nun darauf, dass Ihre Lehrkraft Ihren InstaHub frei schaltet**. Erst danach kann es für Sie weiter gehen!
+
+## Am eigenen InstaHub anmelden
+
+#### Aufgabe 3.2 Verwenden Ihres eigenen InstaHubs {-}
+
+Nachdem Ihre Lehrkraft Ihren InstaHub nun freigeschaltet hat, können Sie Ihren eigenen InstaHub verwenden. Gehen Sie dazu wie folgt vor:
+
+1. Melden Sie sich unter https://rubinrot18.instahub.org/login anmelden, wobei Sie `rubinrot18` durch den Namen Ihres InstaHubs ersetzen. Zum Glück haben Sie sich vorhin den Namen Ihres InstaHubs notiert... Ihr Benutzername lautet `admin`.
+
+
+
+2. Nach dem erfolgreichen Login sehen Sie die derzeit noch recht leere Startseite von InstaHub:
+
+
+
+ Sie erreichen die Startseite immer wieder, wenn Sie auf das **Fotoapparat-Symbol** oben links klicken.
+
+3. Ein Klick auf das **Kompass-Symbol** bringt Sie zur Nutzerübersicht:
+
+
+
+ Wie Sie sehen Sie, haben sich ganz ohne Ihr Zutun schon etwa 200 Nutzer\:innen an Ihrem InstaHub angemeldet.[^21]
+
+[^21]:Keine Angst, diese Nutzer\:innen wurden beim Anlegen Ihres InstaHubs angelegt. Es handelt sich **nicht** um echte Menschen. Die Fotos stammen aus Qullen, die den freien Einsatz der Fotos erlauben.
+
+4. Vielleicht werden Sie enttäuscht sein, denn InstaHub ist ja derzeit frei von Fotos. Es gibt irgendwie nur Nutzer\:innen, aber die tun nichts. Das kommt noch.
+
+## Nutzer\:innen und Administrator\:innen
+
+Der Account `admin`, der gemeinsam mit Ihrem InstaHub angelegt wurde, ist ein besonderer Account, der viele Dinge kann, die ein\*e normale\*r Nutzer\:in nicht können darf. Zum Beispiel andere Benutzer\:innen löschen. Auch sehen Sie mit Ihrem Administrator-Account Bereiche von InstaHub, die normalen Benutzer\:innen verborgen bleiben.
+
+#### Aufgabe 3.3 Ein eigene\*r Nutzer\:in {-}
+
+Es wird an einigen Stellen hilfreich sein, wenn Sie in InstaHub auch in die Rolle eine\*r normale\*n Nutzer\:in schlüpfen können. *Erstellen* Sie einen neuen Benutzeraccount für Ihren InstaHub!
+
+1. Melden sie sich als Administrator ab und rufen Sie Ihren InstaHub auf! (z. B. [rubinrot18.instahub.org]())
+2. Wählen Sie `Account erstellen` und geben Sie wieder minimale Daten ein (s. oben). Wählen Sie ein sicheres Passwort!
+3. InstaHub sagt, dass der Account noch freigeschaltet werden muss. Das tun Sie als Administrator: Melden Sie sich nun wieder als Administrator an. Suchen Sie über das Kompass-Symbol und die Suchfunktion Ihren neuen Account.
+4. Rufen Sie den Account auf und klicken Sie auf `Bearbeiten`:
+
+
+
+6. Schalten Sie den Account frei, in dem Sie den entsprechenden Haken setzen:
+
+
+
+#### Aufgabe 3.4 Unterschiede zwischen Benutzer- und Admin-Account {-}
+
+*Melden* Sie sich abwechselnd mit beiden Accounts an und *vergleichen* Sie deren Arbeitsmöglichkeiten! Wenn möglich, melden Sie sich dazu am besten in zwei verschiedenen Browsern gleichzeitig an. Denken Sie daran, dass der Internet Explorer nicht unterstützt wird.
+
+#### Aufgabe 3.5: Ausblick {-}
+Das Hamburger Abendblatt hat wohlwollend über Ihr soziales Netzwerk berichtet. Wie viele der angemeldeten Nutzer\:innen wohnen in Hamburg?
+
+_Beschreiben_ Sie, wie Sie vorgehen würden, wenn Sie diese Frage mit Ihrem **bisherigen Kenntnisstand**, quasi "von Hand" beantworten müssten!
+
+## Häufige Fehler beim Anmelden in InstaHub
+
+Achten Sie bitte beim Anmelden immer darauf, dass ...
+
+- Sie auf dem richtigen Hub unterwegs sind, und nicht auf einem falschen oder direkt als Lehrkraft auf instahub.org und
+- Sie oben links immer den Namen des verwendeten InstaHubs sehen.
diff --git a/04-Suchmaske.md b/04-Suchmaske.md
new file mode 100644
index 0000000..54fbf46
--- /dev/null
+++ b/04-Suchmaske.md
@@ -0,0 +1,65 @@
+# Die Suchmaske
+
+Viele IT-Systeme geben den Benutzer\*innen die Möglichkeit, ohne Kenntnis einer Abfragesprache mehr oder weniger einfache Anfragen an das System zu stellen. Sie heißen dort oft "erweiterte Suche", "Expertensuche" oder ähnliches.
+
+Wir werden die Suchmaske in diesem Skript nur kurz streifen, da wir uns mit der Abfrage- und Manipulationssprache SQL beschäfigen wollen, da diese mächtiger ist.
+
+## Die Suchmaske aufrufen
+
+Sie gelangen wie folgt zur Suchmaske:
+
+Klicken Sie auf der Startseite oben rechts das Datenbanken-Symbol, hinter dem sich ein Untermenu befindet, aus dem Sie den Punkt `Suche` auswählen:
+
+ 
+
+## Die Suchmaske verwenden
+
+Die Suchmaske sieht zunächst sehr aufgeräumt aus:
+
+
+
+Wenn Sie in das Feld `Tabelle auswählen` klicken, erscheint eine Drop-Down-Liste, aus der Sie eine Tabelle auswählen können:
+
+
+
+Nachdem Sie eine Tabelle ausgewählt haben, verändert sich die Suchmaske:
+
+
+
+Die einzelnen Elemente in der obigen Abbildung haben folgende Bedeutung:
+
+1. Hier sehen Sie die Tabelle, die Sie ausgewählt haben und auf die sich Ihr Suchauftrag bezieht.
+2. Wenn `Spalten filtern` ankreuzen, öffnet sich ein Bereich in dem Sie angeben können, welche der Spalten der Tabelle Sie in Ihre Abfrage einfügen wollen. Diese Auswahl von Spalten wird in Datenbanken auch **Projektion** genannt:
+
+
+
+3. Wenn Sie ``Ergebnisse filtern`` ankreuzen, können Sie Kriterien angeben, denen alle ausgegebenen Datensätze entsprechen müssen. Man spricht hier von **Selektion**. Die Details entnehmen Sie bitte dem nächsten Abschnitt "[Selektion in der Suchmaske]"
+4. Das Auswahlfeld ``Experte`` führt zu einigen Optionen, mit deren Hilfe etwas komplexere Abfragen möglich sind. Diese Möglichkeit wird in diesem Skript nicht behandelt, da wir derartige Abfragen mit der Sprache SQL (siehe Kapitel 4) formulieren werden.
+5. ``Zeige SQL``: Die in dem Formular eingegebene Suchabfrage wird in die Sprache SQL übersetzt und ausgegebn.
+6. ``Ausführen``: Die formulierte Suchabfrage wird ausgeführt.
+
+## Selektion in der Suchmaske
+
+Die Selektion, also das Auswählen von Datensätzen aus einer Datenbank an Hand vorgegebener Kriterien ist die vielleicht wichtigste Aufgabe, die ein Datenbankmanagementsystem zu erledigen hat.
+
+Wenn Sie die Daten von Fabian Möller anzeigen wollen, gehen Sie wie folgt vor:
+
+
+
+1. Wählen Sie in der Suchmaske die Tabelle ``users`` aus.
+2. Wählen Sie ``Ergebnisse filtern`` an.
+3. Wählen Sie das Feld ``name`` aus und geben Sie ``ist gleich`` aus und tragen sie in das leere Feld den Namen ``Fabian Möller`` ein.
+4. Klicken Sie auf ``Ausführen``. InstaHub meldet folgendes Ergebnis:
+
+
+
+Die Suchmaske kann noch mehr: Sie können mehrere Filterregeln angeben. Dann müssen Sie angeben, ob die Suchergebnisse *allen* Filterregeln oder *mindestens einer* entsprechen müssen.
+
+#### Aufgabe 4.1 Einfache Abfragen mit der Suchmaske {-}
+
+*Beantworten* Sie die folgenden Fragen mit Hilfe der Suchmaske! *Dokumentieren* Sie Ihre Lösung, z. B. mit Hilfe eines Screenshots.
+
+1. Welche Mitglieder wohnen in Hamburg? Gesucht sind Name, Benutzername und Stadt.
+2. Welche Mirglieder wurden nach dem 01.12.1998 geboren? Gesucht sind Name, Benutzername und Geburtstag. (Hinweis: Das Datum müssen sie als ``1998-12-01`` eingeben.)
+3. Welche Mitglieder sind größer als 190 cm und nach dem 01.12.1998 geboren? Gesucht sind Name, Benutzername und Geburtstag.
+
diff --git a/05-Einfache-SQL-Abfragen.md b/05-Einfache-SQL-Abfragen.md
new file mode 100644
index 0000000..db20a6e
--- /dev/null
+++ b/05-Einfache-SQL-Abfragen.md
@@ -0,0 +1,195 @@
+# Einfache SQL-Abfragen
+
+## SQL kennen lernen
+
+SQL (_structured query language_) ist eine Programmiersprache, mit der man auf Datenbanken zugreifen kann. SQL ist eine Vertreterin der so genannten **deklarativen Programmierung**, da man mit ihr nur das Ergebnis beschreibt, nicht aber den Weg dorthin.
+
+### Die erste SQL-Abfrage
+
+1. _Rufen_ Sie Ihren InstaHub auf und melden Sie sich als `Admin` dort an!
+
+1. Klicken oben rechts auf das Symbol *Datenbank* und wählen Sie ``SQL``:
+
+
+
+
+3. Sie gelangen in den SQL-Editor:
+
+
+
+4. Setzen Sie den Cursor in das leere, im obigen Screenshot rot markierten, Eingabefeld und tippen Sie die folgende SQL-Abfrage exakt so ein:
+
+ ```mysql
+ SELECT username, name, birthday, city
+ FROM users
+ ```
+
+ **Tipps:** Nach dem `SELECT` bzw. `FROM` tippen Sie die Tab-Taste, damit der Befehl übersichtlich aussieht. Am Ende der ersten Zeile können Sie `ENTER` drücken, um in eine neue Zeile zu wechseln.
+
+5. Klicken Sie auf `Ausführen`! Sie sehen nun eine Ergebnistabelle mit gut 200 Zeilen:
+
+
+
+### Tipps:{-}
+
++ Beachten Sie, dass die Spaltennamen exakt mit den Bezeichnungen nach dem `SELECT`übereinstimmen!
+
++ SQL unterscheidet nicht zwischen Groß- und Kleinschreibung. Es ist aber üblich, die SQL-Befehle in GROSSBUCHSTABEN zu notieren. Halten Sie sich bitte an diese Gepflogenheit.
+
++ Wenn Sie *alle* Spalten ausgeben wollen, können Sie statt alle Spalten aufzuzählen auch einfach ein ``*`` notieren, z. B.;
+
+ ```
+ SELECT *
+ FROM users
+ ```
+
++ Wenn Sie statt einer Antwort wie der obigen eine englische Fehlermeldung bekommen, haben Sie bei der Eingabe des Befehls einen Fehler gemacht. Kontrollieren Sie noch einmal ganz genau, ob Sie irgendwo einen kleinen Fehler gemacht haben. Sind die Kommata wirklich da, wo sie sein sollen und sind es wirklich Kommata? Kein kleiner Tippfehler in den Spaltennamen?
+
+
+## SQL-Abfragen verschönern und sortieren
+
+Wenn Sie die Ergebnistabelle ausdrucken wollen, kann es hilfreich sein, die Spaltenbezeichnungen verändern zu können. _Probieren_ Sie aus, was passiert, wenn Sie statt `birthday` den Text `birthday AS "Geburtstag"`eintragen!
+
+```mysql
+SELECT username, name,
+ birthday AS "Geburtstag", -- Spalte eingedeutscht
+ city AS "Stadt" -- Spalte eingedeutscht
+FROM users
+ORDER BY birthday ASC
+LIMIT 10
+```
+
+Mit der Klausel `ORDER BY` können Sie die Ausgabe sortieren lassen, mit `LIMIT` begrenzen Sie die Zahl der ausgegebenen Datensätze.
+
+### Kommentare{-}
+
+In dem vorangegangenen Beispiel hat der SQL-Interpreter alles, was von ```--``` bis zum Zeilenende kam, ignoriert.
+Beginnt eine Zeile beginnt mit zwei Minuszeichen, wird diese vom SQL-Interpreter ignoriert:
+
+```mysql
+-- verschönerte Anfrage
+SELECT username, name, birthday AS "Geburtstag",
+ city AS "Stadt"
+FROM users
+```
+
+Man nennt solche ignorierten Zeilen *Kommentar*. Kommentare sind beim Programmieren wichtig, um zu erklären, was man gerade macht. Zum Beispiel kann man der Lehrkraft mitteilen, welche Aufgabe man bearbeitet. Das ist übrigens auch für Sie selbst hilfreich, wenn Sie (z. B. zur Klausurvorbereitung) noch einmal die alten Aufgaben herausholen.
+
+Es gibt da nur ein Problem: InstaHub verarbeitet nur den ersten Befehl, den man in das SQL-Fenster eingibt. Kommentare sind Befehle. Daher wird der Kommentar "ausgeführt" und nicht die Abfrage.
+
+Also: **Keine Kommentare als *erste* Zeile im SQL-Fenster von InstaHub!**
+
+Wenn Sie mehrere Zeilen als Kommentar markieren wollen, verwenden Sie `/*` und `*/`:
+
+```sql
+/* Verschoenerte Abfrage
+ Liefert alle Nutzer:innen nach Geburtstag sortiert. */
+SELECT username, name, birthday AS "Geburtstag",
+ city AS "Stadt"
+FROM users
+ORDER BY birthday ASC
+LIMIT 10
+```
+
+### ORDER und LIMIT{-}
+
+Statt `ASC` können Sie in der ORDER-Klausel auch `DESC` oder gar nichts verwenden. _Beschreiben_ Sie, was jeweils passiert!
+
+_Beschreiben_ Sie, welche Bedeutung die `LIMIT`-Klausel hat!
+
+#### Aufgabe 5.1: Erste SQL-Abfragen {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage, die die folgenden verbalen Anfragen möglichst schön beantworten:
+
+1. Wer sind die zehn jüngsten InstaHub-User:innen?
+2. Wo wohnen die fünf am längsten angemeldeten InstaHub-User:innen?
+3. Wer ist der erste InstaHub-User:iin gewesen?
+
+## Dubletten aussortieren
+
+Uns interessiert brennend, in welchen Städten wir bereits mindestens eine/n Nutzer:in haben. Wir probieren es mit der folgenden Abfrage:
+
+``` mysql
+SELECT city
+FROM users
+ORDER BY city ASC
+```
+
+Das Ergebnis ist eine lange Liste von Städten, in denen aber einige Städte mehrfach vorkommen.
+
+Probieren Sie es einmal mit
+
+```mysql
+SELECT DISTINCT city
+FROM users
+ORDER BY city ASC
+```
+
+Nun werden alle Zeilen aussortiert, die mehr als einmal vorkommen.
+
+#### Aufgabe 5.2: Dubletten aussortieren {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage, die folgenden verbalen Anfragen möglichst schön beantworten:
+
+1. Welche Körpergrößen haben unser Nutzer:innen?
+2. Welche verschiedenen Werte kommen in der Spalte `role` vor?
+
+## Datensätze filtern
+
+Welche InstaHub-Nutzer:innen leben eigentlich in Dresden?
+
+Wir könnten nun die Liste nach Städten sortieren und dann scrollen, bis wie bei _Dresden_ angekommen sind. Das muss einfach gehen. Na klar. Die wohl wichtigste Klausel des `SELECT`-Befehls fehlt uns noch: `WHERE`
+
+``` mysql
+SELECT username, name, city
+FROM users
+WHERE city = "Dresden"
+```
+
+#### Aufgabe 5.3: Deutschlandreise I {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage, die folgenden verbalen Anfragen möglichst schön beantworten:
+
+1. Welche Nutzer:innen wohnen in Leipzig?
+2. Welche Nutzer:innen haben die Rolle ``dba``?
+3. Welche Nutzer:innen wohnen in Bokholt-Hanredder?
+4. Welche Nutzer:innen wohnen in Hamburg?
+5. Ist Justin Schuster bei uns angemeldet?
+
+#### Aufgabe 5.4 Ups... {-}
+
+_Überprüfen_ Sie Ihre Ergebnisse aus den beiden letzten Abfragen der vorangegangenen Aufgabe noch einmal genau und _begründen_ Sie, warum Ihre Ergebnisse offenbar nicht ganz korrekt sind!
+
+### Zeichenketten vergleichen
+
+Beim Vergleichen von Zeichenketten ist es oft hilfreich, wenn man nach Teilzeichenketten suchen kann. Hierfür hat SQL den Operator `LIKE`, der anders als `=` nicht die exakte Übereinstimmung erfordert, sondern mit Hilfe von Platzhalten (_Wildcards_) auch Wortteile finden kann. So würde `WHERE name LIKE "Justin%Schuster%"` auch die folgenden Personen finden, wenn Sie denn als Nutzer\*innen angemeldet wären:
+
++ Justine Schuster
++ Justin Frederik Augustus Frederikus Freiherr von Schuster-Boomzwickel
+
+Während mit `%` beliebig viele Zeichen (inklusive keinem) gefunden werden, wird mit dem Zeichen `_` (Unterstrich, Shift+Minuszeichen) nur genau ein Zeichen gefunden.
+
+#### Aufgabe 5.5 Deutschlandreise II {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage, die folgenden verbalen Anfragen möglichst schön beantworten:
+
+1. Welche Nutzer:innen wohnen in Hamburg?
+2. Welche Nutzer:innen mit dem Namen Schuster sind bei uns angemeldet?
+3. Welche Nutzer:innen mit dem haben wir, die so klingen wie Meier? (Hier können Sie einen Beifang irrelevanter Datensätze wohl nicht völlig verhindern!)
+
+### Numerische Vergleiche
+
+Mit den Vergleichsoperatoren `>`, `>=`, `<` und `<=`können auch numerische Werte verglichen werden.
+
+Das funktioniert auch mit Kalenderdaten. `WHERE created_at < "2017-12-31"` liefert alle Benutzer\*Innen, deren Datensätze vor dem 31.12.2017 erstellt wurden.
+
+#### Aufgabe 5.6 Riesen und Zwerge {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage, die folgenden verbalen Anfragen möglichst schön beantworten:
+
+1. Welche InstaHub-Nutzer:innen sind größer als 188 cm?
+2. Welche InstaHub-Nutzer:innen sind kleiner als 155 cm?
+3. Welche InstaHub-Nutzer:innen sind heute am Tag der Aufgabenbearbeitung *nicht* volljährig?
+4. Welche InstaHub-Nutzer:innen sind älter als 70 Jahre?
+5. Gibt es eine/n Nutzer:in, die am selben Tag Geburtstag hat wie Sie? (Hinweis: Wenn Sie am 12.10.1998 geboren sein sollten, suchen Sie, ob jemand am 12.10.1998 geboren ist!)
+
diff --git a/06-SQL-Abfragen-mit-einer-Tabelle.md b/06-SQL-Abfragen-mit-einer-Tabelle.md
new file mode 100644
index 0000000..c1258a3
--- /dev/null
+++ b/06-SQL-Abfragen-mit-einer-Tabelle.md
@@ -0,0 +1,99 @@
+# SQL-Abfragen: Logik und Aggregate
+
+## Logische Operatoren
+
+#### Aufgabe 6.1 Analyse {-}
+
+_Überlegen_ Sie zunächst, welche Ergebnisse die folgenden SELECT-Befehle liefern *könnten*! _Beschreiben_ Sie, welche Datensätze in der Ergebnistabelle enthalten sein werden!
+
+```sql
+-- Beispiel 1:
+SELECT username, city
+FROM users
+WHERE city = "Berlin" AND name LIKE "Fabian%"
+-- Beispiel 2:
+SELECT username, city
+FROM users
+WHERE city = "Berlin" OR city = "Hamburg"
+-- Beispiel 3:
+SELECT username, city
+FROM users
+WHERE city = "Berlin" AND NOT gender LIKE "female"
+```
+Die folgende Tabelle zeigt die Bedeutung der logischen Operatoren:
+
+|`A` | `B` | `NOT A` | `A AND B` | `A OR B` |`NOT (A AND B)` | `NOT(A OR B)` |
+|---- |------|----|---|---|---|---|
+|`FALSE`|`FALSE`| `TRUE` |`FALSE`|`FALSE`|||
+|`FALSE`|`TRUE`| `TRUE` |`FALSE`|`TRUE`|||
+|`TRUE`|`FALSE`| `FALSE` |`FALSE`|`TRUE`|||
+|`TRUE`|`TRUE`| `FALSE` |`TRUE`|`TRUE`|||
+
+#### Aufgabe 6.2 Logikübung
+
+_Vervollständigen_ Sie die beiden letzten Spalten in der obigen Tabelle!
+
+#### Aufgabe 6.3 Mehrere logische Operatoren {-}
+
+_Erstellen_ Sie _je_ eine SQL-Abfrage, die
+
+1. alle Berliner:innen auflistet, die *Marc* heißen,
+2. alle Leipziger Frauen auflistet,
+3. alle Linas und Lorenas auflistet,
+4. alle Männer nach ihrer Körpergröße auflistet, die mindestens 16 Jahre alt sind und
+5. alle Nutzer:innen liefert, die weder männlich noch weiblich sind.
+
+#### Aufgabe 6.4 Logische Operatoren mit Klammern {-}
+
+_Erstellen_ Sie _je_ eine SQL-Abfrage (Tipp: Verwenden Sie Klammern wie beim Taschenrechner), die
+
+1. alle Benutzer:innen mit dem Namen "Xaver" auflistet, die nicht in München oder Nürnberg leben und
+2. alle Benutzer:innen auflistet, die 10 cm größer als der Durchschnitt ihrer Geschlechtsgenossen sind. (Die Durchschnittsgröße von Männern beträgt in Deutschland 179,9 cm, die von Frauen 165,9 cm)
+
+## Zusammenfassungen (Aggregate)
+
+Bisher haben Sie bei Abfragen
+
++ die Spalten, die angezeigt werden sollen, ausgewählt (*Projektion*) oder
+
++ die Zeilen, die im Ergebnis stehen sollen, ausgewählt (*Selektion*).
+
+
+Aber was, wenn wir wissen wollen, wie groß unser größtes Mitglied in jeder Stadt ist? Oder wir für jede Stadt wissen wollen, wie viele Mitglieder wir dort haben?
+
+Die Lösung hierfür heißt Aggregat (aggregieren: lat. _anhäufen)_. Die Idee ist in der folgenden Abbildung dargestellt:
+
+
+
+Aggregate fassen also mehrere Zeilen der Quelltabellen zu einer einzigen Zeile in der Ergebnistabelle zusammen.
+
+#### Aufgabe 6.4 Unser erstes Aggregat {-}
+
+Der folgende SELECT-Befehl liefert für jede Stadt die Körpergröße der größten und kleinsten Benutzer:innen:
+
+```sql
+SELECT city AS "Stadt", MIN(centimeters) AS "kleinsteR",
+ MAX(centimeters) AS "groessteR"
+FROM users
+GROUP BY city
+```
+
+_Probieren_ Sie den Befehl aus und _erklären_ Sie, wie er funktioniert. *Beachten* Sie dabei *alle* neuen SQL-Wörter.
+
+`MAX` ist eine **Aggregatsfunktion**. Weitere Aggregatsfunktionen sind beispielsweise `COUNT`, `SUM` und `AVG` (Durchschnitt, engl. _average_).
+
+Der folgende SQL-Befehl zählt die Mitglieder:
+
+```sql
+SELECT COUNT(username) AS "Registrierte Mitglieder"
+FROM users
+```
+
+#### Aufgabe 6.5 Aggregatsfunktionen {-}
+
+_Erstellen_ Sie _je_ eine SQL-Abfrage, die
+
+1. alle Werte des Feldes `gender` liefert und angibt, wie oft diese auftreten,
+2. die durchschnittliche Größe aller Mitglieder in Dresden liefert und
+3. das Geburtsdatum des jüngsten männlichen und des jüngsten weiblichen Mitglieds liefert.
+4. die Anzahl aller Mitglieder pro Stadt ausgibt
diff --git a/07-Daten-aendern.md b/07-Daten-aendern.md
new file mode 100644
index 0000000..8083f58
--- /dev/null
+++ b/07-Daten-aendern.md
@@ -0,0 +1,118 @@
+# CRUD
+
+#### Aufgabe 7.1 Was ist CRUD? {-}
+
+_Recherchieren_ Sie, was unter CRUD im Zusammenhang mit Datenbanken verstanden wird!
+
+## INSERT - Datensätze einfügen
+
+_Überlegen_ Sie, was der folgende SQL-Befehl vermutlich tun wird!
+
+```sql
+INSERT
+INTO users (
+ username, email, password,
+ name, bio, gender,
+ birthday, city, country,
+ centimeters, avatar, role,
+ is_active, remember_token, created_at,
+ updated_at
+)
+VALUES (
+ 'guenther37', 'guenther@instahub.app', '12345',
+ 'Günther Müller', 'Günther mag Kartoffelsalat.', 'male',
+ '2006-06-06 00:00:00', 'Leipzig', 'Deutschland',
+ '173', 'avatar.png', 'user',
+ '0', NULL, now(),
+ now()
+)
+```
+
+#### Aufgabe 7.2 Ihr erstes Insert {-}
+
+1. _Geben_ Sie den obigen Befehl ein.
+2. _Überprüfen_ Sie das Ergebnis.
+3. _Erklären_ Sie, was `now()` bedeutet! (Tipp: Sehen Sie sich an, was in den beiden Spalten in der Tabelle steht!)
+
+#### Aufgabe 7.3 Noch ein paar Inserts {-}
+
+1. _Fügen_ Sie einen Datensatz für Joachim Löw mit allen leicht öffentlich zugänglichen Daten in die Datenbank ein!
+2. _Fügen_ Sie einen weiteren Datensatz für eine Person Ihrer Wahl in die Datenbank ein!
+
+#### Aufgabe 7.4 Spezialaufgabe {-}
+
+_Überlegen_ Sie, warum das Feld `id` nicht eingetragen wurde und dennoch gefüllt wurde!
+
+## UPDATE - Datensätze verändern
+
+Um Datensätze zu verändern, gibt es den Befehl `UPDATE`. In einer SQL-Referenz finden Sie folgende Beschreibung:
+
+----
+
+``UPDATE`` *< table_name >*
+
+``SET`` *< column1 >* `=` *< value1 >*`, ` *< column2 >* `=` *< value2 >*`,` *...*
+
+`WHERE` *< condition >*`; `
+
+-----
+
+Dabei müssen Sie alle in `Schreibmaschinenschrift` geschriebenen Texte *exakt* so eingeben, wie Sie da stehen. Texte in *< spitzen Klammern >* sind Platzhalter und sollen von Ihnen durch konkrete Inhalte ersetzt werden. Die `WHERE`-Klausel kennen Sie bereits aus dem `SELECT`-Befehl. Und sie funktioniert hier sogar genauso. ;-)
+
+**ACHTUNG:** Sie können mit einem einzigen `UPDATE`-Befehl viel Unheil anrichten. Wenn Ihnen etwas passiert ist, kontaktieren Sie Ihre Lehrkraft, sie kann Ihre Datenbank zurücksetzen.
+
+#### Aufgabe 7.5 Update {-}
+
+_Erstellen_ Sie jeweils ein UPDATE-Kommando:
+
+1. Alle weiblichen Nutzerinnen sollen 160 cm groß sein.
+2. Statt "Germany" soll es im Feld `country` immer "Deutschland" heißen.
+3. _Ersetzen_ Sie die Körpergröße bei allen Dresdnern mit dem Wert `FLOOR(RAND()*45)+150`.
+ 1. _Ermitteln_ Sie, was dieser Befehl bewirkt hat!
+ 2. _Recherchieren_ Sie, was es mit den Funktionen `FLOOR` und `RAND` auf sich hat!
+4. _Aktivieren_ Sie den Account von Jogi Löw. (Tipp: Überlegen Sie, welche Spalte für die Aktivierung eines Accounts zuständig sein mag.)
+5. _Ersetzen_ Sie die Körpergröße bei allen Münchnern mit einen zufälligen Wert zwischen 130 cm und 190 cm!
+
+## DELETE - Datensätze löschen
+
+*Suboptimal*
+Um Datensätze zu löschen, gibt es den Befehl `DELETE`. In einer SQL-Referenz finden Sie folgende Beschreibung:
+
+------
+
+``DELETE FROM`` *< table_name >*
+
+`` WHERE`` *< condition >*`; `
+
+------
+
+Die `WHERE`-Klausel kennen Sie bereits aus dem `SELECT`- und dem `UPDATE`-Befehl.
+
+**Achtung:** _Vor_ dem Absetzen eines `DELETE`-Kommandos sollte man immer die verwendete `WHERE`-Klausel in einem `SELECT`-Kommando ausprobieren.
+
+#### Aufgabe 7.6 Delete {-}
+
+_Erstellen_ Sie jeweils ein DELETE-Kommando:
+
+1. _Löschen_ Sie alle nicht aktivierten Accounts.
+2. _Löschen_ Sie Jogi Löw.
+
+## Grenzen von CRUD
+
+Kaufleute müssen Ihre Geschäfte in Handelsbüchern dokumentieren (Buchhaltung). Heute werden diese Bücher in der Regel nicht auf Papier, sondern in Datenbanken geführt. Im Handelsgesetzbuch wird im §239 Absatz 3 bestimmt:
+
+> Eine Eintragung oder eine Aufzeichnung darf nicht in einer Weise
+> verändert werden, daß[!] der ursprüngliche Inhalt nicht mehr feststellbar
+> ist. [...]
+
+**Beispiel: ** Wenn die Bank auf Grund eines Fehlers von Ihrem Konto Geld abbucht und ihren Fehler danach korrigiert, ist die Bank verpflichtet, den Fehler nicht unkenntlich zu machen:
+
+| Text | Datum | Betrag | Saldo |
+| --------------------------------------------------- | ---------- | --------------: | --------------: |
+| DB Hamburg
Fahrkarte | 22.05.20 | 19,80- | 10,03+ |
+| Barabhebung
Kiel Hbf | 22.05.20 | 5.052.202,00- | 5.052.192,00- |
+| Storno
Wir bitten unser
Versehen zu ent-
schuldigen | 27.05.20 | 5.052.202,00+ | 10,03+ |
+
+#### Aufgabe 7.7 Darf der das...? {-}
+1. _Begründen_ Sie, warum eine vollständige Unterstützung von CRUD in der Buchhaltung nicht zulässig ist.
+2. _Finden_ Sie Beispiele für Daten, bei denen Sie _vermuten_, dass sie ebenfalls nicht ohne weiteres verändert oder gelöscht werden dürfen.
diff --git a/08-Passwoerter-speichern.md b/08-Passwoerter-speichern.md
new file mode 100644
index 0000000..6e13246
--- /dev/null
+++ b/08-Passwoerter-speichern.md
@@ -0,0 +1,117 @@
+# Passwörter speichern
+
+## Was viele Menschen glauben, was beim Login passiert
+Wenn Sie sich an einem IT-System anmelden, geben Sie in den meisten Fällen Ihren Benutzernamen und ein Passwort ein. Jede\*r, der diese beiden Informationen _weiß_, kann sich als Sie ausgeben (_authentisieren_). Man spricht daher von einem _wissensbasierten System_.
+
+Sie wenden bestimmt Regeln für sichere Passwörter an, unter anderem wissen Sie, dass Sie niemandem Ihr Passwort sagen dürfen. Aber irgendwie muss das IT-System, an dem Sie sich anmelden, ja Ihr Passwort kennen, sonst kann es ja nicht entscheiden, ob das eingegebene Passwort das richtige ist. Man _könnte_ also glauben, dass alles ganz einfach ist, und wie folgt abläuft:
+
+1. Die\*Der Benutzer*in schickt den Benutzernamen und das Passwort an den Server.
+2. Der Server sucht in der Benutzertabelle nach dem Benutzernamen und vergleicht das eingegebene Passwort mit dem gespeicherten.
+3. Stimmen beide überein, lässt der Server die\*den Benutzer\*in rein, sonst nicht.
+
+Diese naive Vorstellung wird auch in der Lach- und Sachgeschichte "Internet" der Sendung mit der Maus präsentiert:
+
+![Naiver Passwortvergleich in der Lach- und Sachgeschichte "Internet" der Sendung mit der Maus [https://www.wdrmaus.de/filme/sachgeschichten/internet.php5]](Assets/08-Passwort-Maus.png)
+
+Nun haben sie in der Tabelle `users` ja bereits die Spalte `password` gesehen:
+
+|username| password|
+|----|-----|
+|niclas258| `\$2y\$10\$VdoILxrn6CZU/PtClCDJY.eB3s0lzYiGkY7NokYpZJpMsJ2pq/tuK` |
+|rafael54| ` \$2y\$10\$HkuheWgNzbw9KLo8N3kOHeM6hh7LTpLwqMOcAY7QpqKzOi7NIYqUm` |
+
+Vielleicht haben Sie sich gedacht, dass solche Passwörter sicherlich kein Mensch eingeben würde, aber es sind ja schließlich nur Testdaten. Oder sind das gar nicht die Passwörter? Oder sind sie verschlüsselt?
+
+#### Aufgabe 8.1 Passwörter im Klartext? {-}
+
+_Überprüfen_ Sie, ob InstaHub die Passwörter im Klartext speichert, indem Sie folgende Tests unternehmen:
+
+1. _Versuchen_ Sie, sich an Ihrem InstaHub mit einem beliebigen Benutzernamen und dem zugehörigen Wert in der Spalte `password` anzumelden.
+2. _Überprüfen_ Sie, ob das von Ihnen verwendete `admin`-Passwort in der Datenbank steht.
+3. _Überprüfen_ Sie, ob sich der Wert des `admin`-Passworts ändert, wenn Sie das Passwort über das Profil ändern.
+
+#### Aufgabe 8.2 Admins Probleme mit Passwörtern {-}
+
+1. _Recherchieren_ Sie, wann in der letzten Zeit einem Server unverschlüsselte Passwörter abhanden gekommen sind!
+2. _Finden_ Sie Gründe, die dafür sprechen, Passwörter nicht unverschlüsselt zu speichern.
+3. _Finden_ Sie Gründe für die Forderung, dass Passwörter so gespeichert werden müssen, dass es auch den Administratoren nicht möglich ist, deren Klartext wieder herzustellen!
+
+## Was wirklich beim Login passiert
+
+Das klingt merkwürdig. Man muss das Passwort vergleichen können, aber zugleich soll man es nicht speichern. Wie soll das nur gehen? Zeit für einen kleinen Exkurs:
+
+### Falltüren
+
+Es ist sehr einfach durch die Falltür nach unten zu gelangen, während sich der Weg zurück manchmal als ausgesprochen schwierig, wenn nicht gar unmöglich, erweist:
+
+
+
+Diese Idee kann man auf das Speichern von Passwörtern übertragen. Wir schicken das Passwort durch die Falltür und speichern das Ergebnis. Bei der Anmeldung schicken wir das eingegebene Passwort ebenfalls durch die Falltür und vergleichen dann das Ergebnis mit dem gespeicherten Wert. Stimmen beide überein, war das Passwort richtig. Klingt erstmal merkwürdig.
+
+Wie Sie wissen, können Computer nur Zahlen speichern. Auch Texte werden intern als Zahlen gespeichert. Und mit denen kann man rechnen. Mathematiker\*innen kennen so genannte _Einwegfunktionen_. Die Funktionswerte solcher Einwegfunktionen sind zwar verhältnismäßig leicht auszurechnen, aber es ist fast unmöglich in der Gegenrichtung aus einem Funktionswert zurück zum eingegebenen Wert zu kommen.
+
+Als Beispiel für eine Funktion die einer Einwegfunktion ähnelt, kann die Primfaktorzerlegung dienen. Die Zerlegung der Zahl 21 in ihre Primfaktoren ist leicht: 7 und 3. Die Primfaktorzerlegung wird bei sehr großen Zahlen aber sehr zeitaufwendig. Versuchen Sie doch mal, die Zahl 162.249 in ihre Primfaktoren zu zerlegen! Sie werden ziemlich lange suchen müssen, bis Sie eine Lösung finden. Ihnen bleibt nur der Reihe nach alle Primzahlen ausprobieren. Umgekehrt ist es für Sie aber ein Leichtes, die Aufgabe 433 · 443 zu lösen. Das Ergebnis ist: 162.249. Wenn man jetzt die Zahlen noch viel, viel größer wählt, wird die Primfaktorzerlegung ein sehr großes Problem.
+
+In der Informatik nennt man diese Funktionen **Hashfunktionen** (engl. _hash_: **Hackfleisch**). Falls Sie sich fragen, warum so etwas Hackfleischfunktion heißt: Spielen Sie die Falltür-Idee mit den Begriffen Katze und Fleischwolf durch ...
+
+Nennen wir die Hashfunktion $h(p)$. Dann läuft unsere Anmeldeprozess so ab:
+
+1. Der\*die Benutzer\*in gibt ihren\*seinen Benutzernamen und das Passwort $p$ ein.
+2. Der Server bildet $h(p)$ und vergleicht das Ergebnis mit dem gespeicherten Wert.
+3. Sind die beiden Werte gleich, war die Authentisierung erfolgreich.
+
+#### Aufgabe 8.3 Der Wert der Hashtabelle {-}
+
+Durch Umstände, die wir an dieser Stelle nicht weiter ergründen wollen, sind suspekte Individuen aus Ihrem Informatik-Kurs in den Besitz der Passworttabelle des Schulverwaltungsprogrammes gekommen. _Erklären_ Sie, warum es ihnen nicht ohne weiteres möglich sein wird, sich am Schulverwaltungsprogramm als Lehrkraft auszugeben!
+
+### Gebräuchliche Hashfunktionen
+
+Gebräuchliche Hashfunktionen sind u. a. MD5, SHA-1, SHA-256 oder bcrypt. Letztere wird übrigens von InstaHub verwendet. Die Hashfunktionen bilden aus jeder übergebenen Zeichenkette einen Hashwert fester Zeichenlänge. Egal ob Sie "Hallo Welt!" oder die ganze Bibel hashen - es kommt eine wüste Zeichenkette stets derselben Länge heraus, schon eine geringfügige Änderung der Eingabe führt zu einem völlig anderen Hash-Wert:
+
+| Text | Hash-Wert (SHA-1) |
+| ------------------------------ | ------------------------------------------ |
+| Die Bibel[^footnote] | `0f1a3d197eb98fb4638ef02866159160269b89b8` |
+| "Hallo Welt!" | `726c3e8861ab0652a5043ea5faff6d3ef33fb209` |
+| "Hallo Welt?" | `dff4b83f415b61a06594dc57c4972c77da0c833f` |
+[^footnote]: Luther-Ausgabe 1912
+
+Es gibt also mit Sicherheit mehrere Texte, die zu demselben Hashwert wie "Hallo Welt!" führen. Eine sichere Hashfunktion erkennt man daran, dass man diese so genannten _Kollisionen_ nur zufällig finden kann.
+
+#### Aufgabe 8.4 Kollisionen {-}
+
+Nehmen wir an, als (völlig ungeeignete) Hashfunktion wird verwendet "Nimm die ersten zwei und die letzten zwei Zeichen."
+
+1. _Ermitteln_ Sie den Hashwert des Passwortes `Geheim!`.
+2. _Finden_ Sie ein kollidierendes Passwort zu `Geheim!`.
+3. _Erklären_ Sie, warum es problematisch ist, wenn sich Kollisionen anders als durch Ausprobieren finden lassen!
+
+### Angriffsmöglichkeiten auf Ihr Hackfleisch
+
+Auf den ersten Blick haben wir alles getan, um die Passwörter unserer Benutzer\*innen zu schützen. Aber...
+
+Bei aller Sorgfalt kann es überall passieren, dass die Tabelle mit den gehashten Passwörtern abhanden kommt. Wir müssen also damit rechnen, dass sich jemand in aller Ruhe zu Hause hinsetzen kann und die Tabelle unter die Lupe nimmt.
+
+Die\*der Angreifer\*in kann nun sehr viele verschiedene Passwörter ausprobieren und $h(p)$ bilden. Wenn der Hashwert in der Tabelle enthalten ist, hat sie\*er ein Passwort geknackt. Dieser Angriff kann sowohl in Form eines _Wörterbuchangriffs_ als auch in Form eines _Brute-Force-Angriffs_ erfolgen.
+
+#### Aufgabe 8.5 Angriffsarten{-}
+
+_Erklären_ Sie, was ein Wörterbuchangriff und was ein Brute-Force-Angriff ist.
+
+### Salz und Pfeffer erschweren Angriffe
+
+Der Einsatz einer Hashfunktion alleine reicht also leider nicht aus. Wir müssen das entstandene Hackfleisch noch ordentlich würzen. Hierzu verwenden wir Salz (_salt_) und Pfeffer (_pepper_). Informatiker\*innen mögen offenbar keine Zwiebeln.
+
+
+
+Der oben beschriebene Angriff auf die Hashtabelle war ja erfolgversprechend, weil man jeden erzeugten Hashwert in vielen Zeilen und vielen Tabellen suchen konnte. Wenn wir dieses Problem beheben können, sind wir sehr viel weiter. Man kann sich das Vorgehen wie folgt vorstellen:
+
+1. An das Passwort wird ein von dem\*von der Benutzer\*in abhängiger Text (das _salt_) angehängt, z. B. der Benutzername. Wenn man das Passwort jetzt hasht und speichert, muss die\*der Angreifer\*in also den Hashwert für jede\*n Benutzer\*in einzeln ermitteln. Das kostet viel Zeit.
+2. An das um das _salt_ verlängerte Passwort hängt der Server vor dem hashen aber noch einen Text an, ein geheimes _pepper_. Er bildet also $h(passwort + salt + pepper)$. Jetzt kann der\*die Angreifer\*in nicht einmal mehr für mehrere Server zugleich die Hashwerte ermitteln, sondern muss dies für jeden Server einzeln tun. Und dafür braucht er\*sie auch noch Kenntnisse über _pepper_ und _salt_ und vor allem: sehr viel Zeit!
+
+#### Aufgabe 8.6 Salz und Pfeffer{-}
+
+Ein Server verwendet zur Speicherung der Passwörter SHA-256. Als _salt_ wird der Benutzername verwendet. Das _pepper_ ist `Kvillbuche`. Der Hashwert wird in der Form $h(p\&salt\&pepper)$ ermittelt. Wobei $\&$ für die Aneinanderreihung von Zeichenketten steht.
+2. Der\*Die Nutzer\*in `niclas258` meldet sich mit dem Passwort `TaKaLu908#`an. _Ermitteln_ Sie (z. B. auf www.hashgenerator.de) den zugehörigen Hashwert!
+3. _Überprüfen_ Sie Ihre Lösung, indem Sie den folgenden QR-Code entschlüsseln:
+
+
diff --git a/09-Tabellen-erstellen.md b/09-Tabellen-erstellen.md
new file mode 100644
index 0000000..9c7ac58
--- /dev/null
+++ b/09-Tabellen-erstellen.md
@@ -0,0 +1,97 @@
+# Tabellen erstellen und das Entity-Relationship-Modell
+
+## CREATE TABLE
+
+#### Aufgabe 9.1 Das erste CREATE TABLE verstehen{-}
+
+_Erklären_ Sie was der folgende SQL-Befehl genau tut. Ziehen Sie dabei das Glossar im folgenden Abschnitt [Glossar zu SQL-Create] (oder eine SQL-Referenz Ihres Vertrauens) zu Rate.
+
+Tipp: Es ist vielleicht zunächst hilfreich herauszufinden, wie die neue Tabelle und ihre Spalten heißen werden.
+
+```sql
+CREATE TABLE photos (
+ id INT(4) UNSIGNED NOT NULL AUTO_INCREMENT,
+ user_id INT(4) UNSIGNED NOT NULL,
+ description VARCHAR(255) NOT NULL,
+ url VARCHAR(255) NOT NULL,
+ created_at TIMESTAMP NOT NULL DEFAULT now(),
+ updated_at TIMESTAMP NOT NULL DEFAULT now(),
+ PRIMARY KEY (id),
+ FOREIGN KEY (user_id)
+ REFERENCES users(id)
+ ON DELETE CASCADE
+)
+```
+
+### Glossar zu SQL-Create
+
++ **`AUTO_INCREMENT`** bedeutet, dass bei jedem neu eingefügten Datensatz dieser Wert automatisch um 1 hochgezählt wird. Darum braucht man sich also nicht zu kümmern.
+- **`DEFAULT`** regelt, welchen Wert ein Datensatz bekommt, wenn beim Anlegen des Datensatzes kein Wert angegeben wird. (engl. _default_: Standard, Vorgabe)
++ **`FOREIGN KEY`**: Diese Spalte ist ein Verweis auf eine andere Tabelle. Jeder Wert in dieser Spalte befindet sich in einer Spalte der Zieltabelle. Diese Spalte heißt in der aktuellen Tabelle **Fremdschlüssel**. Die Tabelle, auf die verwiesen wird, heißt **Zieltabelle**.
+
+ Bei InstaHub ist die Zieltabelle die Tabelle `users` und die Spalte, in der dort gesucht werden soll ist die Spalte `id`. Wie fast immer ist der referenzierte Fremdschlüssel in der Zieltabelle der dortige Primärschlüssel (s. `PRIMARY KEY`).
+
+ Jeder Wert eines Fremdschlüssels muss zwingend in der Zieltabelle enthalten sein. Das kontrolliert die Datenbank. Und damit sie das kann, deklariert man Fremdschlüssel als `FOREIGN KEY`.
+ In der Tabelle ``Städte`` verweisen die Werte in der Spalte ``Land_ID`` auf die die Tabelle ``Länder`` und zwar auf die Spalte ``Land_ID``. In der Tabelle ``Länder`` ist ``Land_ID`` der **Primärschlüssel**. In der Tabelle ``Städte`` ist die Spalte ``Land_ID`` ein **Fremdschlüssel**, der auf eine Zeile in einer anderen Tabelle verweist.
+
+ Das Prinzip sehen Sie im folgenden Schaubild:
+
+
+
++ **`INT`** ist ein Datentyp. Jede Spalte kann nur Werte einer bestimmten Art enthalten. Es geht also nicht, dass in einer Spalte mal eine Zahl, mal ein Text und dann wieder ein Datum steht. `INT (4)` bedeutet, dass in der Spalte ganze Zahlen (engl. _integer_) von -2.147.483.648 bis +2.147.483.647 stehen können. Da sie hier aber als `UNSIGNED` deklariert wurden, sind sie immer positiv und können von 0 bis 4.294.967.295 reichen. Die Zahl in Klammern ist von untergeordneter Bedeutung. Sie gibt an, wie viele Stellen zur Ausgabe der Zahl bereit gestellt werden sollen.
++ **`NULL`** bedeutet nicht "0", sondern "nichts, leer". `NULL` ist nicht gleich etwas anderem, auch nicht dem Wert 0. Wenn eine Tabellenspalte in jeder Zeile einen Wert haben soll, kann man `NOT NULL` notieren, dann wird die Datenbank dort unter keinen Umständen erlauben, nichts einzutragen. Notiert man `NULL`, erlaubt man auch leere Tabellenzellen.
++ **`ON DELETE`**: Dies ist Teil der Deklaration eines Fremdschlüssels, siehe `FOREIGN KEY`. Diese Regel beantwortet die Frage, was passiert, wenn der Zieldatensatz gelöscht wird. `ON DELETE CASCADE` bedeutet, dass beim Löschen eines Datensatzes in der Tabelle `USERS` alle zugehörigen Datensätze in der Tabelle `photos` gelöscht werden. Würde man dies nicht vereinbaren, müssten zunächst alle Fotos des\*r Benutzer\*in gelöscht werden, damit der Datensatz in der Tabelle `users` gelöscht werden kann.
++ **`PRIMARY KEY`**: Vereinfacht gesehen hat jede Tabelle eine Spalte, in der kein Wert doppelt vorkommt. Diese Spalte nennt man **Primärschlüssel**. Wenn man hier nach einem Wert sucht findet man also immer keine oder genau eine Zeile, niemals aber mehrere. Mit der Deklaration `PRIMARY KEY` geben Sie an, welche Spalte der Primärschlüssel ist.
++ **`TIMESTAMP`** ist ein Datum mit Uhrzeit. Das frühest mögliche Datum ist 1970, das spätest mögliche 2038.
++ **`VARCHAR`** ist ebenfalls ein Datentyp (s. `INT`). Bei `VARCHAR` handelt es sich um eine Zeichenkette variabler Länge. Die maximale Länge wird in Klammern angegeben.
+
+### Weitere SQL-Datentypen
+
+SQL verfügt über zahlreiche Datentypen. Leider wird nicht jeder Datentyp von jedem SQL-Server unterstützt oder gleich interpretiert. Die Datentypen in der folgenden Auswahl wird zwar in diesem Kapitel nicht verwendet, ist aber trotzdem wichtig:
+
+| Datentyp | Bedeutung |
+| -------------------------- | ------------------------------------------------------------ |
+| ``DECIMAL(p, s)`` | Eine Zahl mit festem Nachkommateil. `s` gibt die Zahl der Nachkommastellen an, `p` die Zahl der Stellen insgesamt. Der Datentyp ist sehr geeignet für Geldbeträge. |
+| ``CHARACTER LARGE OBJECT`` | Wie ``VARCHAR``, aber es gibt keinerlei obere Grenze, so dass ganze Textdokumente gespeichert werden können. Umständliche Handhabung, daher wird ``VARCHAR`` bevorzugt. |
+| ``FLOAT`` | Zahl mit gleitend vielen (engl. *to float*) Nachkommastellen, wie beim Taschenrechner. Achtung: Es kommen Rundungsungenauigkeiten vor. Der Datentyp ist geeignet für technische Zahlen und nicht für Geldbeträge. |
+| ``SMALL INT`` | Kleiner Ganzzahlwert (meist -32. 768 bis +32 .767) |
+| ``CHAR(n)`` | Zeichenkette der festen Länge ``n``. Die Nutzung ist weniger aufwändig als ``VARCHAR``. |
+
+
+
+#### Aufgabe 9.2 CREATE TABLE photos{-}
+
+1. _Erzeugen_ Sie die Tabelle `photos` so wie zu Anfang dieses Kapitls angegeben. Achten Sie besonders auf die Datentypen und die Namen der Spalten.
+2. _Füllen_ Sie die Tabelle mit Hilfe der von Ihrer Lehrkraft bereitgestellten Datei mit Daten!
+3. _Schauen_ Sie sich in Ihrem InstaHub um!
+4. _Überlegen_ Sie sich, wie die Fotos in den Hub gekommen sind. Sie haben ja schließlich nur eine Textdatei hochgeladen...
+
+## Das Entity-Relationship-Modell
+
+Wir haben nun drei Tabellen in unserer Datenbank. Um den Überblick zu behalten, wäre es schön, die Tabellenstrukturen grafisch darzustellen. Hierzu gibt es das Entity-Relationship-Modell, kurz **ER-Modell** oder ERM. Ein ER-Modell besteht aus den folgenden vier Elementen:
+
+1. **Gegenstände (Entities)**: Eine *Entität* (engl. _entity_) stellt eine Klasse von *Objekten* der *realen* Welt im ER-Modell ab. Z. B. `Produkt`, `Kunde`, `Schüler` oder `Informatikkurs`. (Sie sehen, dass Objekte nicht unbedingt gegenständlich sein müssen.) Entities werden in ER-Modellen als Rechtecke dargestellt:
+
+
+
+2. **Attribute**: Entitäten und Beziehungen haben _Eigenschaften_, die durch _Attribute_ beschrieben werden. Diese Attribute findet man in der Datenbank in den Tabellenspalten. Typische Eigenschaften für die Entität `Produkt` könnten z. B. Bezeichnung, Gewicht, Preis und Artikelnummer sein.
+
+ Attribute werden in ER-Modellen als Ovale an die Entitäten angehängt. Die Primärschlüssel heißen im ER-Modell eigentlich _identifizierende Attribute_ und werden unterstrichen:
+
+
+
+3. **Beziehungen (Relationships)**: Ein *Relationship* stellt eine Beziehung zwischen den Objekten der realen Welt dar. Z. B. die Beziehungen _kaufte_ zwischen `Kunde` und `Produkt` _besucht_ zwischen den Entitäten `Schüler` und `Informatikkurs`. Relationships verbinden _immer_ genau zwei Entitäten. Realationships werden als Raute dargestellt:
+
+
+
+4. **Kardinalität**: Beziehungen verbinden nicht immer genau ein Exemplar einer Entität mit genau einem Exemplar einer anderen Entität. So kann ein Kunde mehrere Produkte gekauft haben.
+
+ Kardinalitäten werden leider sehr verschieden notiert. Wir verwenden hier die in der folgenden Abbildung verwendete Notation: Ein bestimmte\*r Schüler*In hat genau einen (`1..1`) Informatikkurs und jeder Informatikkurs wird von 0 bis beliebig vielen Schüler\*Innen (`0..n`) besucht.)
+
+
+
+**Bitte beachten Sie:** Die **Fremdschlüssel** werden im ER-Modell *nicht* notiert, nur die **Primärschlüssel**. Die Fremdschlüssel werden erst beim Umsetzen der ER-Modells in Tabellen ergänzt. Im obigen Beispiel müsste in der Tabelle `Informatikkurs` der Primärschlüssel der Entität `Schüler`, `SchülerNr` eingefügt werden. Wir werden uns in Abschnitt 10.3 und in Kapitel 17 näher mit diesem Thema beschäftigen.
+
+#### Aufgabe 9.3 Das ER-Modell von InstaHub (1){-}
+
+_Erstellen_ Sie ein ER-Modell Ihrer InstaHub-Datenbank! Bei den Attributen wählen Sie einige exemplarische aus.
diff --git a/10-ERM.md b/10-ERM.md
new file mode 100644
index 0000000..68d1666
--- /dev/null
+++ b/10-ERM.md
@@ -0,0 +1,123 @@
+# Vertiefung Entity-Relationship-Modell
+
+## ER-Modelle besser verstehen
+
+#### Aufgabe 10.1 ER-Diagramm beschreiben - Dienstwagen {-}
+
+_Beschreiben_ Sie in eigenen Worten, was das folgende ER-Modell modelliert!
+
+
+
+#### Aufgabe 10.2 ER-Diagramm interpretieren Mann und Frau {-}
+
+_Beschreiben_ Sie in eigenen Worten, was das folgende ER-Modell modelliert. _Beurteilen_ Sie es! Berücksichtigen Sie dabei die deutsche Rechtsordnung und gesellschaftliche Erwartungen!
+
+
+
+## Kardinalitäten verwenden
+
+#### Aufgabe 10.3 Kardinalitäten festlegen{-}
+
+_Notieren_ Sie in den folgenden ER-Diagrammen jeweils die Kardinalitäten!
+
+
+
+
+
+
+
+
+
+## Schlüssel
+
+Alle Exemplare einer Entität müssen sich hinsichtlich ihrer Attribute unterscheiden. Es darf also keine zwei identischen Exemplare geben.
+
+Schlüssel sind Mengen von Attributen, die ein Exemplar einer Entität identifizieren, als eindeutig bestimmen.
+
+Dabei werden die in der folgenden Abbildung ersichtlichen Schlüsselarten unterschieden:
+
+
+
+Diese Schlüsselarten sehen wir uns an Hand eines Beispiels genauer an. Die folgende Abbildung zeigt einen Ausschnitt eines ERM für die Verwaltung einer Hochschule:
+
+
+
++ **Superschlüssel** (auch "Oberschlüssel") sind *alle* Attributmengen, die identifizierend sind, den\*die Studierende\*n also eindeutig bestimmen. Es gibt also fast immer mehrere Superschlüssel:
+
+ + Da jedes Exemplar der Entität anders sein muss, ist die Menge aller Attribute schon mal ein (trivialer) Superschlüssel: {E-Mail, Vorname, Name, Geburtstag, Adresse, Sozialversicherungsnummer, Fach}
+ + Streicht man das studierte Fach aus dem Superschlüssel, bleibt der Rest der Attribute identifizierend und damit Superschlüssel: {E-Mail, Vorname, Name, Geburtstag, Adresse, Sozialversicherungsnummer}
+ + Auch die Adresse kann man aus dem Superschlüssel entfernen: {E-Mail, Vorname, Name, Geburtstag, Sozialversicherungsnummer}
+
++ Ein Superschlüssel, aus dem man kein Attribut mehr entfernen kann, ohne dass er kein Superschlüssel mehr wäre, heißt **Schlüsselkandidat**. In unserem Beispiel sind das:
+
+ + {Vorname, Name, Geburtstag, Adresse}, wenn wir davon ausgehen, dass es bei großen Gebäuden unter derselben Adresse durchaus zwei Kevin Schulzes geben könne, die am selben Tag geboren wurden. Ein solcher Schlüssel, der aus mehreren Attributen zusammengesetzt ist, heißt **zusammengesetzer** Schlüssel.
+ + {E-Mail-Adresse}, wenn wir davon ausgehen, dass jede\*r Studierende eine eigene E-Mail-Adresse verwendet.
+ + {Sozialversicherungsnummer}, wenn wir davon ausgehen, dass jede\*r Studierende eine Sozialversicherungsnummer hat.
+
++ Aus der Menge der Schlüsselkandidaten sucht sicher der\*die Datenbankdesigner\*in einen aus, den er\*sie zum **Primärschlüssel** ernennt. Da man den Primärschlüssel auch mal eingeben muss, sind zusammengesetzte und lange Primärschlüssel meist ungünstig. Daher verwendet man häufig **künstliche Schlüssel**, bei denen das Attribut extra eingeführt wird, damit man ein identifizierendes Merkmal hat. Im deutschen Sozialversicherungssystem ist das die Sozialversicherungsnummer. In Hochschulen verwendet man oft eine so genannte *Matrikelnummer*, Unternehmen haben Kunden-, Lieferanten-, Rechnungs- und Materialnummern.
+
+ Im ERM wird der Primärschlüssel unterstrichen:
+
+
+
+Im obigen Beispiel dient die gelbe Färbung des Attributes "Matrikelnummer" lediglich der Hervorhebung der Änderung. Das Datenbankdesign-Team hätte sich auch für auch jeden der anderen Schlüsselkandidaten entscheiden können. Wobei der zusammengesetzte Schlüsse sehr umfangreich und damit unpraktisch gewesen wäre. Bei der E-Mail-Adresse dachte sich das Team, dass hier Tippfehler vorkommen werden und zur Sozialversicherungsnummer hatte das Immatrikulationsbüro gesagt, dass einige Studierenden vorher nicht in Deutschland gearbeitet haben und daher keine Sozialversicherungsnummer haben.
+
+Vielleich fragen Sie sich: "Wenn es Primärschlüssel gibt, gibt dann auch **Sekundärschlüssel**?". Die Antwort lautet "Ja". Sekundärschlüssel sind Attribute, die zum Suchen in der Datenbank verwendet werden. Sie sind nicht unabdingbar, aber für die Geschwindigkeit der Datenbank von hoher Bedeutung. Will man z. B. in einer Artikeldatenbank oft nach dem Gewicht der Artikel suchen, könnte man das Gewicht als Sekundärschlüssel deklarieren. Da es dabei "nur" um eine Verbesserung der Performanz geht, werden Sekundärschlüssel *nicht* im ERM notiert. Auch müssen sie Sekundärschlüssel in den meisten Datenbankmanagementsystemen nicht eindeutig sein. Sie sind also eigentlich keine Schlüssel. Der Begriff "Indizee" ist daher der bessere.
+
+#### Aufgabe 10.4: Schlüssel in der Lohnbuchhaltung{-}
+
+Für die Lohnbuchhaltung wurde das folgende ERM entworfen (Ausschnitt):
+
+
+
+1. *Ermitteln* Sie Oberschlüssel und Schlüsselkandidaten.
+2. *Entscheiden* Sie sich *begründet* für einen der Schlüsselkandidaten als Primärschlüssel.
+
+## ER-Modelle entwickeln
+
+Die Umsetzung der in der realen Welt erkannten relevanten Objekte und Beziehungen in ein Datenbank-Schema erfolgt in mehreren Schritten:
+
+1. **Bildung von Entities**: Wir müssen Einzelobjekte der realen Welt erkennen und zu Entitäten zusammenfassen. (Beispiel: Die Kollegen Fritz Maier und Paul Lehmann und viele weitere werden zur Entität „Angestellte“).
+
+2. **Bestimmung der relevanten Attribute**: Wie jedes Modell ist auch ein ER-Modell (ERM) eine vereinfachte Abbildung der Wirklichkeit, daher werden nicht alle denkbaren Attribute in das ERM aufgenommen werden. (Beispiel: Die Hobbys eines Mitarbeiters sind im Betrieb in der Regel nicht relevant und werden nicht in das ERM aufgenommen.)
+
+ In Aufgaben in diesem Skript wird oft gefordert, dass nur exemplarische Attribute angegeben werden. Dies dient dann der Arbeitsersparnis. Sie müssen dann bei einer Person nicht Name, Vorname, Geburtstag, Straße usw. angeben, sondern beschränken sich auf einige Beispielattribute.
+
+3. **Bildung von Relationships**: Als nächstes müssen wir Einzelbeziehungen zwischen Objekten der realen Welt erkennen und sie zu Relationships zusammen fassen.
+
+ Beispiele:
+
+ + Der Angestellte Fritz Maier *ist Mitglied* des Qualitätszirkels. ⇒ Relationship „Angestellter ist Mitglied in Gremium“;
+ + Die Angestellte Paulinna Lehmann *leitet* das Projekt „Verbesserung des Betriebsklimas.“ ⇒ Relationship „Ist Projektleiter“).
+
+ Ergänzen Sie hier auch die Kardinalitäten!
+
+
+### Aufgabe 10.5 Buchempfehlung {-}
+
+Für eine Volkshochschule soll ein ER-Modell entwickelt werden, dass die folgenden Anforderungen erfüllt:
+
+> Wir haben verschiedene Kurse. Jeder Kurs wird von ein bis zwei Dozenten\*innen geleitet.
+>
+> Die Dozenten\*innen geben für jeden ihrer Kurse maximal fünf empfohlene Bücher an.
+
+_Entwickeln_ Sie das geforderte ER-Modell! (Tipp: Sie benötigen drei Entitäten und zwei Relationships.) Beschränken Sie sich bitte jeweils auf fünf exemplarische Attribute.
+
+### Aufgabe 10.6 Laufeventmanager {-}
+
+Sie sind Mitarbeiter/in einer eines Softwarehauses und dort u.a. für Datenbanken zuständig. Ihr Unternehmen will ein Content-Management-System zur Verwaltung von Laufsportveranstaltungen entwickeln. Es liegt folgende Beschreibung vor:
+
+> Es gibt verschiedene Laufveranstaltungen. Z. B. den Quentiner Stadtlauf des TSV Quentin. Derselbe Veranstalter bietet manchmal aber auch verschiedene Laufveranstaltungen an. So veranstaltet der TSV Quentin auch den Quentiner Adventslauf.
+>
+> Bei vielen Laufveranstaltungen werden mehrere Distanzen angeboten, z. B. 3, 5 und 10 km, (Halb-)Marathon usw. Es gibt Läufer\*innen, die bei einer Veranstaltung mehrere Distanzen absolvieren.
+>
+> Für jede Distanz erhält jede\*r Läufer\*in eine Startnummer. Innerhalb der Veranstaltung ist diese Startnummer eindeutig. Die Läufer\*innen melden sich zuvor für bestimme Veranstaltungen und Distanzen an. Die Startnummern werden nicht sofort vergeben, sondern erst, wenn das Startgeld eingegangen ist und der Anmeldeschluss abgelaufen ist.
+>
+> Die gelaufene Zeit wird gemessen und in die Datenbank eingetragen, um Urkunden und Bestenlisten erstellen zu können. Dabei muss unterschieden werden können, ob ein\*e Läufer\*in ins Ziel gekommen ist, gestartet aber nicht angekommen ist oder gar nicht erst gestartet ist.
+>
+> Dabei erfolgt die Auswertung getrennt nach Geschlechtern und Altersklassen. So gibt es z. B. eine Altersklasse "M90", in der alle männlichen Senioren zwischen 84 und 90 Jahren zusammengefasst sind. In der Altersklasse "W30" sind alle weiblichen Seniorinnen (die heißen wirklich so!) zwischen 26 und 30 Jahren zusammengefasst.
+
+1. _Finden_ Sie die nötigen Entitäten für den Laufeventmanager! (Tipp: 5 Entitäten werden es schon sein müssen.)
+2. _Bestimmen_ Sie relevante (exemplarische) Attribute!
+3. _Verbinden_ Sie die Entitäten durch passende Relationships!
+
diff --git a/11-JOIN.md b/11-JOIN.md
new file mode 100644
index 0000000..e1e6f81
--- /dev/null
+++ b/11-JOIN.md
@@ -0,0 +1,189 @@
+# SQL-Abfragen über mehrere Tabellen (JOIN)
+
+Zuletzt hatten Sie in Kapitel 9 mit SQL gearbeitet. Sie hatten die neue Tabelle ``photos`` erstellt und mit Inhalt gefüllt. Wir kommen nun zurück zu SQL und zu ``SELECT`` und starten erst einmal in einer Aufwärmübung:
+
+``aaron183`` ist einer Ihrer Benutzer. In der Benutzeransicht sehen Sie, dass er 12 Fotos eingestellt hat:
+
+
+
+Wie bekommt InstaHub eigentlich heraus, dass ``aaron183`` 12 Fotos hochgeladen hat? In der Tabelle ``photos`` enthält das Feld ``user_id`` Werte, die in der Tabelle ``users`` in der Spalte ``id`` stehen. In Zukunft schreiben wir statt "_Die Spalte ``user_id`` in der Tabelle ``photos``_" einfach kurz "_``photos.user_id``._"
+
+#### Aufgabe 11.1: Aarons Fotos
+
+1. _Erklären_ Sie das Konzept der Primär- und Fremdschlüssel an Hand des obigen Beispiels!
+2. *Erstellen* Sie einen ``SELECT``-Befehl der in der Tabelle ``users`` die ``id`` des Users mit dem Benutzernamen ``aaron183`` ermittelt!
+3. *Erstellen* Sie einem zweiten ``SELECT``-Befehl, der in der Tabelle ``photos`` die Zahl der von ``aaron183`` hochgeladenen Fotos ermittelt!
+
+Die folgenden QR-Codes enthalten Lösungsvorschläge für diese Aufgabe:
+
+
+
+## Zwei Tabellen verbinden
+
+Nach diesem Wiedereinstieg in ``SELECT`` stellen wir uns natürlich die Frage, ob man immer zwei ``SELECT``-Befehle braucht.
+
+Braucht man nicht. Man kann in der ``FROM``-Klausel auch eine _Liste von Tabellen_ angeben:
+
+#### Aufgabe 11.2 Erster Versuch, zwei Tabellen zu verbinden
+
+Geben Sie den folgenden SQL-Befehl ein:
+
+```sql
+SELECT COUNT(username)
+FROM users, photos -- 2 Tabellen in der FROM-Klausel!
+WHERE username="aaron183"
+```
+
+1. *Beschreiben* Sie das Ergebnis.
+2. *Begründen* Sie welches Ergebnis Sie ungefähr erwartet hätten.
+3. *Probieren* Sie einmal folgendes: *Ermitteln* Sie mittels ``COUNT`` die Zahl der Datensätze der Tabellen ``users`` und ``photos``. *Ermitteln* Sie dann mittels ``COUNT`` die Zahl der Datensätze, die herauskommen, wenn Sie im obigen ``SELECT`` die ``WHERE``-Klausel weglassen. In welcher mathematischen Beziehung stehen diese drei Zahlen?
+
+## (INNER) JOIN
+
+Wir müssen SQL sagen, dass nur die zu einander passenden Datensätze aus den beiden Tabellen miteinander kombiniert werden sollen. Das geht so:
+
+```sql
+SELECT COUNT(username)
+FROM users, photos
+WHERE users.id = photos.user_id -- Nur die passenden!
+ AND username = "aaron183" -- Nur die von Aaron!
+```
+
+In beiden Tabellen gibt es eine Spalte ``id``. Woher soll SQL wissen, welche Spalte wir meinen? Daher muss bei ``users.id`` die Tabelle angegeben werden. Die Spalte ``user_id`` gibt es (derzeit) nur einmal daher muss hier ebenso wenig wie bei ``username`` eigentlich keine Tabelle angegeben werden. In der Abfrage oben wurde die Tabelle ``photos`` aus optischen Gründen angegeben.
+
+Man kommt recht weit mit dieser Art, Abfragen über mehrere Tabellen zu verfassen. Aber es geht übersichtlicher!
+
+#### Aufgabe 11.3: JOIN analysieren
+
+*Betrachten* Sie das folgende SQL-``SELECT`` mit dem neuen Schlüsselwort ``JOIN`` (engl. *to join:* sich verbinden):
+
+```sql
+SELECT count(users.id)
+FROM users JOIN photos
+ ON (users.id = user_id)
+WHERE username="aaron183"
+```
+
+1. *Markieren* Sie in dem obigen ``SELECT``-Befehl alle Stellen, die neue Sprachelemente enthalten!
+2. *Begründen* Sie warum die Lösung mit ``JOIN`` übersichtlicher ist als die Lösung ohne ``JOIN``. (Wenn Sie noch nicht restlos überzeugt sind: Sie werden gleich noch sehen, dass Sie mit ``JOIN`` mächtiger als ohne ``JOIN`` sind.)
+3. _Probieren_ Sie den Befehl aus!
+
+#### Aufgabe 11.4: JOIN anwenden
+
+*Entwickeln* Sie jeweils eine SQL-Abfrage mit ``JOIN``!
+
+1. Welche Fotos haben die Mitglieder aus Hamburg hochgeladen?
+2. Welches sind die Top-10 der Mitglieder, bezogen auf die Zahl der Fotouploads?
+3. Zu jedem Mitglied ist die Zahl der von ihm\*ihr hochgeladenen Fotos gesucht.
+
+## Mehr Tabellen für InstaHub! (Tabellenmodelle)
+
+Um komplexere Abfragen behandeln zu können, benötigen wir ein wenig mehr Tabellen.
+
+Bisher fehlen InstaHub noch folgende für soziale Netze wichtige Funktionen:
+
+1. Man will anderen Nutzer\*innen *folgen* können.
+2. Man will Fotos anderer Nutzer*innen *liken* können.
+3. Man will Fotos anderer Nutzer*innen *kommentieren* können.
+
+Diese Funktionen bekommt InstaHub jetzt!
+
+#### Aufgabe 11.5: ER-Modell von InstaHub (2)
+
+*Analysieren* Sie das folgende ER-Modell für das erweiterte InstaHub!
+
+
+
+1. *Beurteilen* Sie die vorgeschlagenen Kardinalitäten!
+2. *Beurteilen* Sie ob das neue Modell die versprochenen neuen Funktionen ermöglicht!
+
+Jeder Datensatz in der Tabelle ``users`` kann mit jedem Datensatz in der Tabelle ``photos`` verbunden werden. Und umgekehrt kann jeder Datensatz in der Tabelle ``photos`` kann mit jedem Datensatz in der Tabelle ``users`` verbunden werden. Eine solche Beziehung nennt man auch n:m-Beziehung.
+
+n:m-Beziehungen werden in der Datenbank mit Hilfe einer neuen Tabelle realisiert, die die Primärschlüssel der verbundenen Tabellen als Fremdschlüssel enthält, sie enthält also _zwei Fremdschlüssel_. Die Relation ``likes`` könnte als Tabelle so aussehen:
+
+| user_id | photo_id |
+| ------- | -------- |
+| 15 | 12 |
+| 15 | 14 |
+| 18 | 14 |
+
+In diesem Beispiel hat die\*der Benutzer\*in mit der ``user_id`` 15 die Fotos 12 und 14 geliked. Das Foto 14 gefällt auch der\*dem Benutzer\*in mit der id 18.
+
+Einfacher notiert man Tabellen in der folgenden Form, dem so genannten _Tabellenmodell_:
+
+ likes(^ [](user id), ^ [](photo id))
+
+Der Pfeil bedeutet, dass es sich um einen Fremdschlüssel handelt, unterstrichene Attribute sind Teil des Primärschlüssels. Tabellenmodelle sind nicht genormt, daher werden Sie viele verschiedene Notationen finden.
+
+Anders als ER-Modelle enthalten Tabellenmodelle auch die Fremdschlüssel. Es ist vielfach hilfreich, bei der Umsetzung eines ER-Modells in eine Datenbank das ER-Modell zunächst in ein Tabellenmodel zu überführen.
+
+#### Aufgabe 11.6: Die Tabellen konstruieren (1)
+
+*Entwickeln* Sie für die neuen Relationships ``comments`` und ``follows`` ein Tabellenmodell!
+
+#### Aufgabe 11.7: Die Tabellen konstruieren (2)
+
+_Entwickeln_ Sie für jede der drei neuen Tabellen einen SQL-``CREATE``-Befehl!
+
+*Bevor* Sie Ihren Befehl abschicken, vergleichen Sie Ihre Lösung unbedingt mit dem Lösungsvorschlag Ihrer Lehrkraft!
+
+**Tipp:** Gehen Sie dabei wie folgt vor:
+
+1. *Bestimmen* Sie die nötigen Attribute.
+2. *Bestimmen* Sie zu jedem Attribut den passenden Datentyp sowie einen Default-Wert und legen Sie fest, ob ``NULL`` erlaubt sein soll.
+3. *Geben* Sie die *Primärschlüssel* an.
+4. *Fügen* Sie die *Fremdschlüssel* hinzu.
+
+#### Aufgabe 11.8: Die Tabellen konstruieren (3)
+
+*Setzen* Sie Ihre ``Create``-Befehle aus der vorherigen Aufgabe ab! *Überlegen* Sie zuvor, ob die Reihenfolge Ihrer Befehle eine Rolle spielt!
+
+#### Aufgabe 11.9: Die Tabellen füllen
+
+*Füllen* Sie die neuen Tabellen mit den Daten, die Ihre Lehrkraft für Sie bereit gestellt hat. *Überlegen* Sie zuvor, ob die Reihenfolge Ihrer Befehle eine Rolle spielt!
+
+## OUTER JOIN
+
+In Aufgabe 11.4, Nr. 3 hatten Sie zu jedem Mitglied die Zahl seiner Foto-Uploads ermittelt. Sie haben dabei in der ``JOIN``-Klausel etwas geschrieben wie ``... ON users.id = photos.userid``. Damit bekommen Sie alle Datensätze, bei denen die Werte in den beiden Spalten übereinstimmen. Was aber ist mit einem Mitglied, dass keine Fotos hochgeladen hat? Da seine ``id`` in der Spalte ``photos.userid`` nicht auftaucht, wird es nicht in dem Ergebnis gelistet.
+
+Wir haben also als Ergebnis eine Liste aller Mitglieder mit Foto-Uploads erzeugt, aber nicht diejenigen Mitglieder die *keine* Foto-Uploads getätigt haben.
+
+In der folgenden Abbildung sehen Sie die vier verschiedenen Formen des ``JOINS``:
+
+
+
+1. Beim ``INNER JOIN`` werden wie gesagt nur diejenigen Datensätze in das Zwischenergebnis übernommen , die einen passenden Datensatz *sowohl* in der linken als auch in der rechten Tabelle haben. In SQL kann das Wort ``INNER`` weggelassen werden.
+2. Beim ``LEFT OUTER JOIN`` werden alle Datensätze in das Zwischenergebnis übernommen, die in der *linken* Tabelle enthalten sind. Wenn es passende Werte in der *rechten* Tabelle gibt, werden diese aufgenommen, ansonsten wird ``NULL`` eingetragen. In SQL kann das Wort ``OUTER`` weggelassen werden.
+3. Beim ``RIGHT OUTER JOIN`` werden alle Datensätze in das Zwischenergebnis übernommen, die in der *rechten* Tabelle enthalten sind. Wenn es passende Werte in der *linken* Tabelle gibt, werden diese aufgenommen, ansonsten wird ``NULL`` eingetragen. In SQL kann das Wort ``OUTER`` weggelassen werden.
+4. Der ``FULL OUTER JOIN`` hat in der Praxis nur ein geringe Bedeutung. Hier werden alle Datensätze in das Zwischenergebnis aufgenommen, die in nur in einer der beiden Tabellen stehen. Viele DBMS können keinen ``FULL OUTER JOIN``, so auch das von InstaHub.
+
+Auf das Ergebnis des ``JOINs`` werden dann die ``WHERE``- und die ``GROUP-BY-``Klausel angewendet.
+
+SQL kennt außerdem noch den ``NATURAL JOIN``. Dies ist ein ``INNER JOIN``, bei dem das ``ON`` weggelassen wird und automatisch alle Attribute herangezogen werden, die denselben Namen haben. Der Befehl
+
+```sql
+SELECT *
+FROM users NATURAL JOIN photos
+```
+
+ist identisch mit dem Befehl
+
+```sql
+SELECT *
+FROM users INNER JOIN photos
+ ON (users.created_at=photos.created_at AND users.updated_at = photos.updated_at)
+```
+
+Wenn man mit ``NATURAL JOIN`` arbeiten will, muss man also bei der Benennung der Spaltennamen sehr aufpassen.
+
+#### Aufgabe 11.10 Mehr Aufgaben mit JOIN
+
+*Entwickeln* Sie jeweils eine SQL-Abfrage mit ``JOIN``! (Tipp: Sie benötigen sowohl ``INNER`` als auch ``OUTER JOIN``!)
+
+1. Gesucht sind die Top 10 der am häufigsten gelikten Fotos!
+2. Gesucht sind die Top 10 der am häufigsten kommentierten Fotos!
+3. Gesucht sind die Top 10 der am häufigsten gefolgten User!
+4. Gesucht sind die "Bottom 10", also die am seltensten gelikten Fotos. Ihre Abfrage muss berücksichtigen, dass diese Liste sowohl völlig ungelikte als auch selten gelikte Fotos enthalten kann.
+5. Gesucht sind die "Bottom 10", also die am seltensten gefolgten Nutzer\*innen, die nach dem 31.12.1990 geboren wurden. Ihre Abfrage muss berücksichtigen, dass diese Liste sowohl Personen ohne jeglichen Follower als auch selten Personen mit wenigen Followern enthalten kann.
+
+
diff --git a/12-komplexe-SQL-Abfragen.md b/12-komplexe-SQL-Abfragen.md
new file mode 100644
index 0000000..f2c6eb5
--- /dev/null
+++ b/12-komplexe-SQL-Abfragen.md
@@ -0,0 +1,150 @@
+# Komplexe SQL-Abfagen
+
+## Aggregate selektieren
+
+Einige Nutzer\*innen haben noch immer keine Fotos auf InstaHub geliket. Diese sollen nun per E-Mail dazu ermuntert werden. Geben Sie eine SQL-Abfrage an, die die E-Mail-Adresse und den Namen der betroffenen Nutzer\*innen liefert!
+
+Als ersten Schritt schreiben Sie mit Ihrem derzeitigen Kenntnisstand vielleicht eine Abfrage, die zu allen Nutzer\*innen die Zahl aller von ihnen geliketen Nutzer\*innen liefert, z. B. etwas wie:
+
+```sql
+SELECT users.id, users.email, COUNT(___________)
+FROM users __________ JOIN likes
+ ON (________ = likes.user_id)
+GROUP BY _________
+```
+
+#### Aufgabe 12.1: Vervollständigen Sie die SQL-Abfrage {-}
+
+_Vervollständigen_ Sie die obige Abfrage!
+
+_Kontrollieren_ Sie Ihre Lösung mit Hilfe des folgenden QR-Codes:
+
+
+
+Aber wie bekommen Sie nur diejenigen Nutzer\*innen angezeigt, bei denen die `COUNT`-Spalte den Wert `0` enthält? Sie könnten probieren, es mit einer `WHERE`-Klausel zu versuchen, aber das wird erfolglos sein, weil `WHERE` die Datensätze selektiert, die danach mittels `GROUP BY` gruppiert werden und nicht die gruppierten Ergebniszeilen filtert. Hierzu benötigen Sie die Klausel `HAVING`. Sie funktioniert fast genauso wie die `WHERE`-Klausel, nur dass sie aus denen durch `GROUP BY` erstellten aggregierten Zeilen diejenigen auswählt, die einem Kriterium entsprechen. Dies wird in der folgenden Abbildung veranschaulicht:
+
+
+
+#### Aufgabe 12.2: SQL-Abfrage vervollständigen {-}
+
+_Vervollständigen_ Sie Ihre SQL-Abfrage aus Aufgabe 12.1, so dass sie nun nur noch diejenigen Benutzer\*innen liefert, die keine Fotos geliket haben!
+
+#### Aufgabe 12.3: Aggregate selektieren {-}
+
+_Erstellen_ Sie jeweils eine SQL-Abfrage:
+
+1. Welche Fotos wurden bisher gar nicht oder maximal einmal geliket?
+2. Welche Nutzer\*innen haben noch kein Foto kommentiert?
+3. Welche Fotos wurden bisher noch gar nicht oder maximal einmal kommentiert?
+
+#### Aufgabe 12.4: Einzelgänger\*innen finden (schwer) {-}
+
+Einige Nutzer\*innen folgen noch immer niemanden auf InstaHub. Diese sollen nun per E-Mail dazu ermuntert werden. Geben Sie eine SQL-Abfrage an, die die E-Mail-Adresse und den Namen der betroffenen Nutzer\*innen liefert!
+
+Erstellen Sie eine entsprechende Abfrage!
+
+**Hinweise:**
+
+- Diese Aufgabe ist deutlich schwerer als man zunächst meint.
+- Es ist mehr als ein\*e Benutzer\*in betroffen.
+- Tasten Sie sich am besten schrittweise an die (vielleicht überraschende) Lösung heran, denn ``HAVING COUNT(...)=0`` funktioniert leider nicht.
+
+## Anfragen verschachteln 1: ``UNION`` und ``IN``
+
+Gesucht sind alle Benutzer\*innen in Leipzig, Dresden und Hamburg. In diesem Abschnitt sehen wir uns verschiedene Lösungsansätze für diese Anforderung an.
+
+### Lösung 1: `OR`
+
+Sie können diese Anforderung bereits umsetzen, und zwar mit Hilfe des `OR`-Operators umsetzen:
+
+```
+SELECT username, city, name
+FROM users
+WHERE city = "Leipzig" OR city = "Dresden" OR
+ city = "Hamburg"
+```
+
+### Lösung 2: `IN`
+
+Eine andere Möglichkeit ist der ``IN`` Operator:
+
+```
+SELECT username, city, name
+FROM users
+WHERE city IN ("Leipzig", "Dresden", "Hamburg")
+```
+
+Richtig mächtig wird der ``IN``-Operator aber, wenn Sie berücksichtigen, dass in die Klammern ein ``SELECT``-Befehl gesetzt werden kann. Das brauchen wir zwar zur Lösung unserer Aufgabe an dieser Stelle nicht, aber es würde wie folgt aussehen:
+
+```
+SELECT username, city, name, created_at
+FROM users
+WHERE city IN (
+ SELECT DISTINCT city
+ FROM users
+ WHERE created_at < "2017-08-31"
+)
+```
+
+Dieser Befehl liefert die Namen aller Benutzer\*innen, die in einer Stadt wohnen, in der jemand wohnt, der vor September 2017 in InstaHub angemeldet war. (Wofür auch immer die Geschäftsleitung das wissen wollte... ;-))
+
+### Lösung 3: ``UNION``
+
+Sie können die Ergebnisse zweier SQL-Anfragen mit Hilfe des SQL-Befehls ``UNION`` zusammenfügen:
+
+```mysql
+SELECT username, city, name
+FROM users
+WHERE city = "Leipzig"
+
+UNION
+
+SELECT username, city, name
+FROM users
+WHERE city = "Dresden"
+
+UNION
+
+SELECT username, city, name
+FROM users
+WHERE city = "Hamburg"
+```
+
+Dabei muss die Zahl der Ergebnisspalten der Teiltabellen übereinstimmen.
+
+#### Aufgabe 12.5: Unterwegs für die Kriminalpolizei {-}
+
+Auf Grund einer Anzeige durch ein InstaHub-Mitglied ist die Kripo auf Ihren InstaHub aufmerksam geworden. Es besteht der Verdacht, dass auf Ihrem InstaHub volksverhetzende Äußerungen verbreitet werden. Menschen zweifelhafter Gesinnung sollen ihr Unwesen treiben und harmlose Bilder mit Bezügen zu Adolf Hitler kommentieren. Ihnen wird ein richterlicher Beschluss präsentiert, der Sie dazu verpflichtet, folgende Daten herauszugeben:
+
+1. Eine Liste mit allen Benutzer\*innen (Name, E-Mail-Adresse, Geburtstagsdatum), die einschlägig kommentierten Fotos ebenfalls geliket, kommentiert oder hochgeladen haben. Jede\*r Nutzer\*in darf nur einmalig auf der Liste stehen, es ist nicht wichtig, zu wissen _warum_ diese\*r Nutzer\*in auf die Liste gelangt ist.
+2. Eine Liste _aller_ Kommentare, die die fraglichen Nutzer\*innen abgegeben haben.
+
+## ``CASE``
+
+Für die folgende Aufgabe können Sie den ``CASE``-Operator benutzen. Hier sehen Sie ihn in freier Wildbahn:
+
+```my
+SELECT url, COUNT(likes.photo_id) AS Anzahl,
+ CASE
+ WHEN COUNT(likes.photo_id)>10 THEN "***"
+ WHEN COUNT(likes.photo_id)>5 THEN "**"
+ WHEN COUNT(likes.photo_id)>1 THEN "*"
+ ELSE "-"
+ END AS Sterne
+FROM photos JOIN likes ON (photos.id = likes.photo_id)
+GROUP BY photos.id
+ORDER BY COUNT(likes.photo_id) DESC
+```
+
+#### Aufgabe 12.7: Texte generieren
+
+1. Die Geschäftsleitung wünscht einen Bericht, in dem hinter jede\*m Nutzer\*in die Zahl der erhaltenen Likes steht und je nach Geburtsdatum der Text "minderjährig" bzw. "volljährig".
+2. Erweitern Sie die Abfrage aus der vorangegangen Aufgabe um eine von Ihnen festgelegte Sternebewertung für die Zahl der für alle hochgeladenen Fotos erhaltenen Likes.
+
+## Anfragen verschachteln 2: ``EXISTS``, ``ANY`` und ``ALL`` und ``NULL``
+
+- Dieser Abschnitt wird noch bearbeitet.
+
+## Zusammenfassende Aufgaben
+
+- Dieser Abschnitt wird noch bearbeitet.
\ No newline at end of file
diff --git a/13-komplexe-CRUD-Befehle.md b/13-komplexe-CRUD-Befehle.md
new file mode 100644
index 0000000..741e5c5
--- /dev/null
+++ b/13-komplexe-CRUD-Befehle.md
@@ -0,0 +1,5 @@
+# Komplexe CRUD-Befehle
+
+** Dieses Kapitel ist in Bearbeitung **
+
++ Integritäten revisited
\ No newline at end of file
diff --git a/14-Big-Data.md b/14-Big-Data.md
new file mode 100644
index 0000000..5f0e551
--- /dev/null
+++ b/14-Big-Data.md
@@ -0,0 +1,4 @@
+# Big Data
+
+** Dieses Kapitel ist in Bearbeitung **
+
diff --git a/15-Datenschutz.md b/15-Datenschutz.md
new file mode 100644
index 0000000..c0ae9b7
--- /dev/null
+++ b/15-Datenschutz.md
@@ -0,0 +1,6 @@
+# Datenschutz
+
+** Dieses Kapitel ist in Bearbeitung **
+
+
+
diff --git a/16-Normalisierung.md b/16-Normalisierung.md
new file mode 100644
index 0000000..e7a0cfd
--- /dev/null
+++ b/16-Normalisierung.md
@@ -0,0 +1,5 @@
+# Normalisierung
+
+** Dieses Kapitel ist in Bearbeitung **
+
+##
\ No newline at end of file
diff --git a/17-ERM2Tabelle.md b/17-ERM2Tabelle.md
new file mode 100644
index 0000000..4985434
--- /dev/null
+++ b/17-ERM2Tabelle.md
@@ -0,0 +1,6 @@
+# Datenbankmodelle und Tabellenmodelle
+
+** Dieses Kapitel ist in Bearbeitung **
+
+
+
diff --git a/18-ERM-entwickeln.md b/18-ERM-entwickeln.md
new file mode 100644
index 0000000..08c8e1e
--- /dev/null
+++ b/18-ERM-entwickeln.md
@@ -0,0 +1,4 @@
+# Datenbankmodelle entwickeln
+
+** Dieses Kapitel ist in Bearbeitung **
+
diff --git a/19-Top-10.md b/19-Top-10.md
new file mode 100644
index 0000000..2722e25
--- /dev/null
+++ b/19-Top-10.md
@@ -0,0 +1,14 @@
+# Top 10 der Themen, die nicht behandelt wurden
+
+Datenbanken sind ein sehr weites Gebiet der Informatik. Wir konnten uns nicht um alle Aspekte kümmern. Interessant wäre z. B. noch gewesen:
+
+1. **Office-Datenbanken**: Insbesondere die Datenbank MS Access kann zur Entwicklung kleinerer Datenbankanwendungen verwendet werden.
+2. **Integration von Datenbanken in Office-Pakete**, z. B. kann Writer eine einzelne Adressen aus einer Datenbank holen holen oder einen Serienbrief an alle in einer Abfrage befindlichen Adressen drucken.
+3. **PHP und MySQL** sind zwei frei verfügbare Pakete, auf denen viele dynamische Websites basieren. OOo Base kann übrigens auf MySQL-Datenbanken zugreifen.
+4. **Tuning von Datenbanken**, z. B. Erstellen von Indizees, mit denen bei großen Datenbanken der Zugriff auf die Datensätze beschleunigt wird, und Berücksichtigung technischer Aspekte bei Entwurfsentscheidungen: Datenbanken werden denormalisert oder Tabellen geteilt, obwohl dies semantisch unnötig ist.
+5. **Relationale Algebra**, die formalisierte Darstellung der Funtkion von Datenbanken. Mit ihr kann man sehr präzise beschreiben, wie Datenbanken funktionieren.
+6. **Objektorientierte Datenbanken**: Hier müssen nicht alle Datensätze dieselben Attribute haben. Objektorientierte Datenbanken passen gut zur objektorientierten Softwareentwicklung, haben sich aber noch nicht durchgesetzt.
+7. **Transaktionssteuerung**: Wie kann man verhindern, dass zwei Reisebüros gleichzeitig den letzten freien Platz im Flugzeug reservieren?
+8. **Data Mining**: z. B. Data Warehouses, zentrale Datenbanken von Unternehmen, die fast alle Daten des Unternehmens zusammenfasst) und Data Mining (Auswerten von Datenbeständen um darin Muster zu erkennen, z. B. zur Marktanalyse oder Prognosebildung).
+9. **Normalformen**: Diese haben wir angerissen. Es gibt deutlich mehr als drei Normalformen und man kann diese sehr formalisiert beschreiben.
+
diff --git a/20-SQL-CheatSheet.md b/20-SQL-CheatSheet.md
new file mode 100644
index 0000000..b52df5e
--- /dev/null
+++ b/20-SQL-CheatSheet.md
@@ -0,0 +1,130 @@
+# SQL- und ER-Modell-Cheat-Sheet
+
+## SQL
+
+### Einfache SQL-Abfragen
+
+```sql
+SELECT username AS "Name", city AS "Stadt"
+FROM users
+WHERE city = "Berlin" AND NOT name LIKE "%Ma_er"
+```
+
+- Logische Operatoren: ``AND``, ``OR``, ``NOT``
+- Vergleiche: ``>``, ``<``, ``>=``, ``<=``, ``=``, ``LIKE``
+- Duplikate in einer Spalte ausschließen: ``DISTINCT``
+- Sortieren: ``ORDER BY``
+- Zahl der Ausgabezeilen begrenzen: ``LIMIT``
+
+### Aggregate
+
+```sql
+SELECT city, MIN(centimeters), MAX(centimeters)
+FROM users
+GROUP BY city
+```
+
+- Aggregatfunktionen: ``AVG``, ``MIN``, ``MAX``, ``COUNT``, ``SUM``
+- Aggregate filtern: ``HAVING``
+
+### INSERT
+
+```sql
+INSERT
+INTO users (
+ username, email, password,
+ name, bio, gender,
+ birthday, city, country,
+ centimeters, avatar, role,
+ is_active, remember_token, created_at,
+ updated_at
+ )
+VALUES (
+ 'guenther37', 'guenther@instahub.app', '12345',
+ 'Günther Müller', 'Günther mag Kartoffeln', 'male',
+ '2006-06-06 00:00:00', 'Leipzig', 'Deutschland',
+ '173', 'avatar.png', 'user',
+ '0', NULL, now(),
+ now()
+ )
+```
+
+### UPDATE
+
+```sql
+UPDATE users
+SET country = "Deutschland"
+WHERE country = "DDR"
+```
+
+### DELETE
+
+```sql
+DELETE FROM users
+WHERE birthday > "2018-01-01"
+```
+
+### CREATE
+
+```sql
+CREATE TABLE photos (
+ id INT(4) UNSIGNED NOT NULL AUTO_INCREMENT,
+ user_id INT(4) UNSIGNED NOT NULL,
+ description VARCHAR(255) NOT NULL,
+ url VARCHAR(255) NOT NULL,
+ created_at TIMESTAMP NOT NULL DEFAULT now(),
+ updated_at TIMESTAMP NOT NULL DEFAULT now(),
+ PRIMARY KEY (id),
+ FOREIGN KEY (user_id)
+ REFERENCES users(id)
+ ON DELETE CASCADE
+)
+```
+
+Datentypen:
+- ``INT`` - ganze Zahlen
+- ``SMALL INT`` - ganze Zahlen, meist zwischen -32.768 und +32.767
+- ``TIMESTAMP`` - Datum und Uhrzeit
+- ``VARCHAR(n)`` - Zeichenkette der variablen Länge _n_
+- ``DECIMAL(p, s)`` - _p_ Stellen insgesamt, _s_ davon sind Nachkommastellen
+- ``FLOAT`` - Gleitkommazahl (wie beim Taschenrechner)
+- ``CHAR (n)`` - Zeichenkette fester Länge
+
+### JOIN
+
+```sql
+SELECT count(users.id)
+FROM users JOIN photos
+ ON (users.id = user_id)
+WHERE username="aaron113"
+```
+
+- ``LEFT JOIN`` - Alle Datensätze der linken Tabelle, auch wenn es keinen passenden Datensatz in der rechten Tabelle gibt.
+- ``RIGHT JOIN``
+- ``INNER JOIN`` - identisch mit ``JOIN``
+- ``NATURAL JOIN`` - identisch mit ``JOIN``, wobei alle Spalten mit identischen Namen in die ``ON``-Klausel übernommen werden.
+
+### Verschachtelungen
+
+- ``WHERE city IN ("Dortmund", "Essen", "Köln")``
+- ``WHERE city IN (SELECT city FROM users WHERE ...)``
+- ``SELECT ... UNION SELECT ... ``
+
+### CASE
+
+```my
+SELECT url, COUNT(likes.photo_id) AS Anzahl,
+ CASE
+ WHEN COUNT(likes.photo_id) > 10 THEN "***"
+ WHEN COUNT(likes.photo_id)>5 THEN "**"
+ WHEN COUNT(likes.photo_id)>1 THEN "*"
+ ELSE "-"
+ END AS Sterne
+FROM photos JOIN likes ON (photos.id = likes.photo_id)
+GROUP BY photos.id
+ORDER BY COUNT(likes.photo_id) DESC
+```
+
+## ER-Diagramme
+
+
\ No newline at end of file
diff --git a/Assets/01-cc-by-nc.eu.png b/Assets/01-cc-by-nc.eu.png
new file mode 100644
index 0000000..cb6b5d0
Binary files /dev/null and b/Assets/01-cc-by-nc.eu.png differ
diff --git a/Assets/02-Bank.png b/Assets/02-Bank.png
new file mode 100644
index 0000000..1afb452
Binary files /dev/null and b/Assets/02-Bank.png differ
diff --git a/Assets/02-Client-Server.png b/Assets/02-Client-Server.png
new file mode 100644
index 0000000..001d989
Binary files /dev/null and b/Assets/02-Client-Server.png differ
diff --git a/Assets/02-Datenbank.png b/Assets/02-Datenbank.png
new file mode 100644
index 0000000..019acda
Binary files /dev/null and b/Assets/02-Datenbank.png differ
diff --git a/Assets/02-Googlesuche.png b/Assets/02-Googlesuche.png
new file mode 100644
index 0000000..f3becb0
Binary files /dev/null and b/Assets/02-Googlesuche.png differ
diff --git a/Assets/02-InstaHub-Screenshot-1.png b/Assets/02-InstaHub-Screenshot-1.png
new file mode 100644
index 0000000..7372c52
Binary files /dev/null and b/Assets/02-InstaHub-Screenshot-1.png differ
diff --git a/Assets/02-InstaHub-Screenshot-2.png b/Assets/02-InstaHub-Screenshot-2.png
new file mode 100644
index 0000000..169149b
Binary files /dev/null and b/Assets/02-InstaHub-Screenshot-2.png differ
diff --git a/Assets/02-InstaHub-Screenshot-3.png b/Assets/02-InstaHub-Screenshot-3.png
new file mode 100644
index 0000000..1b97ca6
Binary files /dev/null and b/Assets/02-InstaHub-Screenshot-3.png differ
diff --git a/Assets/02-InstaHub-Screenshot-4.png b/Assets/02-InstaHub-Screenshot-4.png
new file mode 100644
index 0000000..4c93e4b
Binary files /dev/null and b/Assets/02-InstaHub-Screenshot-4.png differ
diff --git a/Assets/02-Onlineshop.png b/Assets/02-Onlineshop.png
new file mode 100644
index 0000000..0390bb1
Binary files /dev/null and b/Assets/02-Onlineshop.png differ
diff --git a/Assets/02-UPS-Sendungsverfolgung.png b/Assets/02-UPS-Sendungsverfolgung.png
new file mode 100644
index 0000000..1d369b4
Binary files /dev/null and b/Assets/02-UPS-Sendungsverfolgung.png differ
diff --git a/Assets/03-CreateInstaHub-2.png b/Assets/03-CreateInstaHub-2.png
new file mode 100644
index 0000000..9cf6d4f
Binary files /dev/null and b/Assets/03-CreateInstaHub-2.png differ
diff --git a/Assets/03-CreateInstaHub-3.png b/Assets/03-CreateInstaHub-3.png
new file mode 100644
index 0000000..294becb
Binary files /dev/null and b/Assets/03-CreateInstaHub-3.png differ
diff --git a/Assets/03-CreateInstahub-1.png b/Assets/03-CreateInstahub-1.png
new file mode 100644
index 0000000..5338c40
Binary files /dev/null and b/Assets/03-CreateInstahub-1.png differ
diff --git a/Assets/03-LogInInstaHub-1.png b/Assets/03-LogInInstaHub-1.png
new file mode 100644
index 0000000..fc92117
Binary files /dev/null and b/Assets/03-LogInInstaHub-1.png differ
diff --git a/Assets/03-LogInInstaHub-2.png b/Assets/03-LogInInstaHub-2.png
new file mode 100644
index 0000000..799e130
Binary files /dev/null and b/Assets/03-LogInInstaHub-2.png differ
diff --git a/Assets/03-LogInInstaHub-3.png b/Assets/03-LogInInstaHub-3.png
new file mode 100644
index 0000000..c5fc1e8
Binary files /dev/null and b/Assets/03-LogInInstaHub-3.png differ
diff --git a/Assets/03-NeuerUser-1.png b/Assets/03-NeuerUser-1.png
new file mode 100644
index 0000000..0e3b1d2
Binary files /dev/null and b/Assets/03-NeuerUser-1.png differ
diff --git a/Assets/03-NeuerUser-2.png b/Assets/03-NeuerUser-2.png
new file mode 100644
index 0000000..5d3a7ae
Binary files /dev/null and b/Assets/03-NeuerUser-2.png differ
diff --git a/Assets/04-SuchmaskeMenu.png b/Assets/04-SuchmaskeMenu.png
new file mode 100644
index 0000000..d2c0a12
Binary files /dev/null and b/Assets/04-SuchmaskeMenu.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-1.png b/Assets/04-SuchmaskeVerwenden-1.png
new file mode 100644
index 0000000..f66145d
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-1.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-2.png b/Assets/04-SuchmaskeVerwenden-2.png
new file mode 100644
index 0000000..9d526aa
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-2.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-3.png b/Assets/04-SuchmaskeVerwenden-3.png
new file mode 100644
index 0000000..4ef4edd
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-3.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-4.png b/Assets/04-SuchmaskeVerwenden-4.png
new file mode 100644
index 0000000..ee57eea
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-4.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-5.png b/Assets/04-SuchmaskeVerwenden-5.png
new file mode 100644
index 0000000..0881986
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-5.png differ
diff --git a/Assets/04-SuchmaskeVerwenden-6.png b/Assets/04-SuchmaskeVerwenden-6.png
new file mode 100644
index 0000000..9a934be
Binary files /dev/null and b/Assets/04-SuchmaskeVerwenden-6.png differ
diff --git a/Assets/05-SQL-1.png b/Assets/05-SQL-1.png
new file mode 100644
index 0000000..9a8e2cb
Binary files /dev/null and b/Assets/05-SQL-1.png differ
diff --git a/Assets/05-SQL-2.png b/Assets/05-SQL-2.png
new file mode 100644
index 0000000..df4b9df
Binary files /dev/null and b/Assets/05-SQL-2.png differ
diff --git a/Assets/05-SQL-3.png b/Assets/05-SQL-3.png
new file mode 100644
index 0000000..87eab59
Binary files /dev/null and b/Assets/05-SQL-3.png differ
diff --git a/Assets/06-Aggregat.png b/Assets/06-Aggregat.png
new file mode 100644
index 0000000..0338fa7
Binary files /dev/null and b/Assets/06-Aggregat.png differ
diff --git a/Assets/08-Falltuer.png b/Assets/08-Falltuer.png
new file mode 100644
index 0000000..f2e72f5
Binary files /dev/null and b/Assets/08-Falltuer.png differ
diff --git a/Assets/08-Hack.jpg b/Assets/08-Hack.jpg
new file mode 100644
index 0000000..41c54f6
Binary files /dev/null and b/Assets/08-Hack.jpg differ
diff --git a/Assets/08-Passwort-Maus.png b/Assets/08-Passwort-Maus.png
new file mode 100644
index 0000000..7f46974
Binary files /dev/null and b/Assets/08-Passwort-Maus.png differ
diff --git a/Assets/08-QR-Hashbeispiel.png b/Assets/08-QR-Hashbeispiel.png
new file mode 100644
index 0000000..c8cd700
Binary files /dev/null and b/Assets/08-QR-Hashbeispiel.png differ
diff --git a/Assets/09-AaronsPhotos.png b/Assets/09-AaronsPhotos.png
new file mode 100644
index 0000000..ed5043a
Binary files /dev/null and b/Assets/09-AaronsPhotos.png differ
diff --git a/Assets/09-ER1-Attribute.png b/Assets/09-ER1-Attribute.png
new file mode 100644
index 0000000..e48127e
Binary files /dev/null and b/Assets/09-ER1-Attribute.png differ
diff --git a/Assets/09-ER1-Entitaeten.png b/Assets/09-ER1-Entitaeten.png
new file mode 100644
index 0000000..92ef6d8
Binary files /dev/null and b/Assets/09-ER1-Entitaeten.png differ
diff --git a/Assets/09-ER1-Kardinalitaeten.png b/Assets/09-ER1-Kardinalitaeten.png
new file mode 100644
index 0000000..3b320f5
Binary files /dev/null and b/Assets/09-ER1-Kardinalitaeten.png differ
diff --git a/Assets/09-ER1-Relationship.png b/Assets/09-ER1-Relationship.png
new file mode 100644
index 0000000..ce6aee7
Binary files /dev/null and b/Assets/09-ER1-Relationship.png differ
diff --git a/Assets/09-Fremdschluessel.png b/Assets/09-Fremdschluessel.png
new file mode 100644
index 0000000..0a26d38
Binary files /dev/null and b/Assets/09-Fremdschluessel.png differ
diff --git a/Assets/10-CREATE-TABLE-1.png b/Assets/10-CREATE-TABLE-1.png
new file mode 100644
index 0000000..ba4fd34
Binary files /dev/null and b/Assets/10-CREATE-TABLE-1.png differ
diff --git a/Assets/10-ER-Dienstwagen.png b/Assets/10-ER-Dienstwagen.png
new file mode 100644
index 0000000..2b55a69
Binary files /dev/null and b/Assets/10-ER-Dienstwagen.png differ
diff --git a/Assets/10-ER-Kardinalitaet-Bester-Freund.png b/Assets/10-ER-Kardinalitaet-Bester-Freund.png
new file mode 100644
index 0000000..ee2e1a1
Binary files /dev/null and b/Assets/10-ER-Kardinalitaet-Bester-Freund.png differ
diff --git a/Assets/10-ER-Kardinalitaet-Fussballverein.png b/Assets/10-ER-Kardinalitaet-Fussballverein.png
new file mode 100644
index 0000000..b599ea7
Binary files /dev/null and b/Assets/10-ER-Kardinalitaet-Fussballverein.png differ
diff --git a/Assets/10-ER-Kardinalitaet-Geliebter.png b/Assets/10-ER-Kardinalitaet-Geliebter.png
new file mode 100644
index 0000000..19fa2a0
Binary files /dev/null and b/Assets/10-ER-Kardinalitaet-Geliebter.png differ
diff --git a/Assets/10-ER-Kardinalitaet-Kind.png b/Assets/10-ER-Kardinalitaet-Kind.png
new file mode 100644
index 0000000..95bac18
Binary files /dev/null and b/Assets/10-ER-Kardinalitaet-Kind.png differ
diff --git a/Assets/10-ER-Mann-Frau.png b/Assets/10-ER-Mann-Frau.png
new file mode 100644
index 0000000..f9087b2
Binary files /dev/null and b/Assets/10-ER-Mann-Frau.png differ
diff --git a/Assets/10-ERM-Kunde.png b/Assets/10-ERM-Kunde.png
new file mode 100644
index 0000000..9a477da
Binary files /dev/null and b/Assets/10-ERM-Kunde.png differ
diff --git a/Assets/10-ERM-Student-PK.png b/Assets/10-ERM-Student-PK.png
new file mode 100644
index 0000000..7bf95b3
Binary files /dev/null and b/Assets/10-ERM-Student-PK.png differ
diff --git a/Assets/10-ERM-Student.png b/Assets/10-ERM-Student.png
new file mode 100644
index 0000000..26a15cc
Binary files /dev/null and b/Assets/10-ERM-Student.png differ
diff --git a/Assets/10-Schluessel.png b/Assets/10-Schluessel.png
new file mode 100644
index 0000000..1dcfc22
Binary files /dev/null and b/Assets/10-Schluessel.png differ
diff --git a/Assets/11-ERM-InstaHub-2.png b/Assets/11-ERM-InstaHub-2.png
new file mode 100644
index 0000000..066d4d9
Binary files /dev/null and b/Assets/11-ERM-InstaHub-2.png differ
diff --git a/Assets/11-OUTER-JOIN.png b/Assets/11-OUTER-JOIN.png
new file mode 100644
index 0000000..6477600
Binary files /dev/null and b/Assets/11-OUTER-JOIN.png differ
diff --git a/Assets/11-qrcode-SQL.png b/Assets/11-qrcode-SQL.png
new file mode 100644
index 0000000..8b601d0
Binary files /dev/null and b/Assets/11-qrcode-SQL.png differ
diff --git a/Assets/12-WHERE-GROUP-HAVING.png b/Assets/12-WHERE-GROUP-HAVING.png
new file mode 100644
index 0000000..cdf4d96
Binary files /dev/null and b/Assets/12-WHERE-GROUP-HAVING.png differ
diff --git a/Assets/12-qr-code-SQL-vor-HAVING.png b/Assets/12-qr-code-SQL-vor-HAVING.png
new file mode 100644
index 0000000..bc5e1ab
Binary files /dev/null and b/Assets/12-qr-code-SQL-vor-HAVING.png differ
diff --git a/EPUB/instahub.epub b/EPUB/instahub.epub
new file mode 100644
index 0000000..f3d42bc
Binary files /dev/null and b/EPUB/instahub.epub differ
diff --git a/InstahubCover.png b/InstahubCover.png
new file mode 100644
index 0000000..be80711
Binary files /dev/null and b/InstahubCover.png differ
diff --git a/ODT/00-META.odt b/ODT/00-META.odt
new file mode 100644
index 0000000..0fef18d
Binary files /dev/null and b/ODT/00-META.odt differ
diff --git a/ODT/00-TITLE.odt b/ODT/00-TITLE.odt
new file mode 100644
index 0000000..23acfd6
Binary files /dev/null and b/ODT/00-TITLE.odt differ
diff --git a/ODT/000-Liesmich.odt b/ODT/000-Liesmich.odt
new file mode 100644
index 0000000..8d63ab6
Binary files /dev/null and b/ODT/000-Liesmich.odt differ
diff --git a/ODT/01-Vorwort.odt b/ODT/01-Vorwort.odt
new file mode 100644
index 0000000..9c328d8
Binary files /dev/null and b/ODT/01-Vorwort.odt differ
diff --git a/ODT/02-Einstimmung.odt b/ODT/02-Einstimmung.odt
new file mode 100644
index 0000000..1479308
Binary files /dev/null and b/ODT/02-Einstimmung.odt differ
diff --git a/ODT/03-Erste-Schritte.odt b/ODT/03-Erste-Schritte.odt
new file mode 100644
index 0000000..b85da9e
Binary files /dev/null and b/ODT/03-Erste-Schritte.odt differ
diff --git a/ODT/04-Suchmaske.odt b/ODT/04-Suchmaske.odt
new file mode 100644
index 0000000..a3d0f57
Binary files /dev/null and b/ODT/04-Suchmaske.odt differ
diff --git a/ODT/05-Einfache-SQL-Abfragen.odt b/ODT/05-Einfache-SQL-Abfragen.odt
new file mode 100644
index 0000000..526522e
Binary files /dev/null and b/ODT/05-Einfache-SQL-Abfragen.odt differ
diff --git a/ODT/06-SQL-Abfragen-mit-einer-Tabelle.odt b/ODT/06-SQL-Abfragen-mit-einer-Tabelle.odt
new file mode 100644
index 0000000..e6ca527
Binary files /dev/null and b/ODT/06-SQL-Abfragen-mit-einer-Tabelle.odt differ
diff --git a/ODT/07-Daten-aendern.odt b/ODT/07-Daten-aendern.odt
new file mode 100644
index 0000000..b852de0
Binary files /dev/null and b/ODT/07-Daten-aendern.odt differ
diff --git a/ODT/08-Passwoerter-speichern.odt b/ODT/08-Passwoerter-speichern.odt
new file mode 100644
index 0000000..1bb3a31
Binary files /dev/null and b/ODT/08-Passwoerter-speichern.odt differ
diff --git a/ODT/09-Tabellen-erstellen.odt b/ODT/09-Tabellen-erstellen.odt
new file mode 100644
index 0000000..be6574f
Binary files /dev/null and b/ODT/09-Tabellen-erstellen.odt differ
diff --git a/ODT/10-ERM.odt b/ODT/10-ERM.odt
new file mode 100644
index 0000000..78180e1
Binary files /dev/null and b/ODT/10-ERM.odt differ
diff --git a/ODT/11-JOIN.odt b/ODT/11-JOIN.odt
new file mode 100644
index 0000000..b38afda
Binary files /dev/null and b/ODT/11-JOIN.odt differ
diff --git a/ODT/12-komplexe-SQL-Abfragen.odt b/ODT/12-komplexe-SQL-Abfragen.odt
new file mode 100644
index 0000000..a34c5e9
Binary files /dev/null and b/ODT/12-komplexe-SQL-Abfragen.odt differ
diff --git a/ODT/13-komplexe-CRUD-Befehle.odt b/ODT/13-komplexe-CRUD-Befehle.odt
new file mode 100644
index 0000000..437f4e2
Binary files /dev/null and b/ODT/13-komplexe-CRUD-Befehle.odt differ
diff --git a/ODT/14-Big-Data.odt b/ODT/14-Big-Data.odt
new file mode 100644
index 0000000..d751d17
Binary files /dev/null and b/ODT/14-Big-Data.odt differ
diff --git a/ODT/15-Datenschutz.odt b/ODT/15-Datenschutz.odt
new file mode 100644
index 0000000..623a220
Binary files /dev/null and b/ODT/15-Datenschutz.odt differ
diff --git a/ODT/16-Normalisierung.odt b/ODT/16-Normalisierung.odt
new file mode 100644
index 0000000..36640c1
Binary files /dev/null and b/ODT/16-Normalisierung.odt differ
diff --git a/ODT/17-ERM2Tabelle.odt b/ODT/17-ERM2Tabelle.odt
new file mode 100644
index 0000000..9068b2d
Binary files /dev/null and b/ODT/17-ERM2Tabelle.odt differ
diff --git a/ODT/18-ERM-entwickeln.odt b/ODT/18-ERM-entwickeln.odt
new file mode 100644
index 0000000..b9a00e7
Binary files /dev/null and b/ODT/18-ERM-entwickeln.odt differ
diff --git a/ODT/19-Top-10.odt b/ODT/19-Top-10.odt
new file mode 100644
index 0000000..425a555
Binary files /dev/null and b/ODT/19-Top-10.odt differ
diff --git a/ODT/20-SQL-CheatSheet.odt b/ODT/20-SQL-CheatSheet.odt
new file mode 100644
index 0000000..b996cc8
Binary files /dev/null and b/ODT/20-SQL-CheatSheet.odt differ
diff --git a/ODT/20-SQL-CheatSheet.pdf b/ODT/20-SQL-CheatSheet.pdf
new file mode 100644
index 0000000..f92ef6d
Binary files /dev/null and b/ODT/20-SQL-CheatSheet.pdf differ
diff --git a/ODT/Planung.odt b/ODT/Planung.odt
new file mode 100644
index 0000000..041af97
Binary files /dev/null and b/ODT/Planung.odt differ
diff --git a/ODT/instahub.odt b/ODT/instahub.odt
new file mode 100644
index 0000000..edc72ca
Binary files /dev/null and b/ODT/instahub.odt differ
diff --git a/ODT/old12 zu komplexes Beispiel.odt b/ODT/old12 zu komplexes Beispiel.odt
new file mode 100644
index 0000000..984edcd
Binary files /dev/null and b/ODT/old12 zu komplexes Beispiel.odt differ
diff --git a/PDF/00-META.pdf b/PDF/00-META.pdf
new file mode 100644
index 0000000..9f32649
Binary files /dev/null and b/PDF/00-META.pdf differ
diff --git a/PDF/00-TITLE.pdf b/PDF/00-TITLE.pdf
new file mode 100644
index 0000000..4af0a4a
Binary files /dev/null and b/PDF/00-TITLE.pdf differ
diff --git a/PDF/000-Liesmich.pdf b/PDF/000-Liesmich.pdf
new file mode 100644
index 0000000..9fa98eb
Binary files /dev/null and b/PDF/000-Liesmich.pdf differ
diff --git a/PDF/01-Vorwort.pdf b/PDF/01-Vorwort.pdf
new file mode 100644
index 0000000..718d6b3
Binary files /dev/null and b/PDF/01-Vorwort.pdf differ
diff --git a/PDF/02-Einstimmung.pdf b/PDF/02-Einstimmung.pdf
new file mode 100644
index 0000000..de5fa7f
Binary files /dev/null and b/PDF/02-Einstimmung.pdf differ
diff --git a/PDF/03-Erste-Schritte.pdf b/PDF/03-Erste-Schritte.pdf
new file mode 100644
index 0000000..d62bb04
Binary files /dev/null and b/PDF/03-Erste-Schritte.pdf differ
diff --git a/PDF/04-Suchmaske.pdf b/PDF/04-Suchmaske.pdf
new file mode 100644
index 0000000..673b5ba
Binary files /dev/null and b/PDF/04-Suchmaske.pdf differ
diff --git a/PDF/05-Einfache-SQL-Abfragen.pdf b/PDF/05-Einfache-SQL-Abfragen.pdf
new file mode 100644
index 0000000..6d80bb2
Binary files /dev/null and b/PDF/05-Einfache-SQL-Abfragen.pdf differ
diff --git a/PDF/06-SQL-Abfragen-mit-einer-Tabelle.pdf b/PDF/06-SQL-Abfragen-mit-einer-Tabelle.pdf
new file mode 100644
index 0000000..47d66e9
Binary files /dev/null and b/PDF/06-SQL-Abfragen-mit-einer-Tabelle.pdf differ
diff --git a/PDF/07-Daten-aendern.pdf b/PDF/07-Daten-aendern.pdf
new file mode 100644
index 0000000..caacf51
Binary files /dev/null and b/PDF/07-Daten-aendern.pdf differ
diff --git a/PDF/08-Passwoerter-speichern.pdf b/PDF/08-Passwoerter-speichern.pdf
new file mode 100644
index 0000000..9a415d1
Binary files /dev/null and b/PDF/08-Passwoerter-speichern.pdf differ
diff --git a/PDF/09-Tabellen-erstellen.pdf b/PDF/09-Tabellen-erstellen.pdf
new file mode 100644
index 0000000..4ea204d
Binary files /dev/null and b/PDF/09-Tabellen-erstellen.pdf differ
diff --git a/PDF/10-ERM.pdf b/PDF/10-ERM.pdf
new file mode 100644
index 0000000..d722097
Binary files /dev/null and b/PDF/10-ERM.pdf differ
diff --git a/PDF/11-JOIN.pdf b/PDF/11-JOIN.pdf
new file mode 100644
index 0000000..6de7018
Binary files /dev/null and b/PDF/11-JOIN.pdf differ
diff --git a/PDF/12-komplexe-SQL-Abfragen.pdf b/PDF/12-komplexe-SQL-Abfragen.pdf
new file mode 100644
index 0000000..1318973
Binary files /dev/null and b/PDF/12-komplexe-SQL-Abfragen.pdf differ
diff --git a/PDF/13-komplexe-CRUD-Befehle.pdf b/PDF/13-komplexe-CRUD-Befehle.pdf
new file mode 100644
index 0000000..6718ade
Binary files /dev/null and b/PDF/13-komplexe-CRUD-Befehle.pdf differ
diff --git a/PDF/14-Big-Data.pdf b/PDF/14-Big-Data.pdf
new file mode 100644
index 0000000..dcf1b0a
Binary files /dev/null and b/PDF/14-Big-Data.pdf differ
diff --git a/PDF/15-Datenschutz.pdf b/PDF/15-Datenschutz.pdf
new file mode 100644
index 0000000..cc2d779
Binary files /dev/null and b/PDF/15-Datenschutz.pdf differ
diff --git a/PDF/16-Normalisierung.pdf b/PDF/16-Normalisierung.pdf
new file mode 100644
index 0000000..b81f429
Binary files /dev/null and b/PDF/16-Normalisierung.pdf differ
diff --git a/PDF/17-ERM2Tabelle.pdf b/PDF/17-ERM2Tabelle.pdf
new file mode 100644
index 0000000..d7365dc
Binary files /dev/null and b/PDF/17-ERM2Tabelle.pdf differ
diff --git a/PDF/18-ERM-entwickeln.pdf b/PDF/18-ERM-entwickeln.pdf
new file mode 100644
index 0000000..beac49e
Binary files /dev/null and b/PDF/18-ERM-entwickeln.pdf differ
diff --git a/PDF/19-Top-10.pdf b/PDF/19-Top-10.pdf
new file mode 100644
index 0000000..cc72b98
Binary files /dev/null and b/PDF/19-Top-10.pdf differ
diff --git a/PDF/20-SQL-CheatSheet.pdf b/PDF/20-SQL-CheatSheet.pdf
new file mode 100644
index 0000000..ff95fb3
Binary files /dev/null and b/PDF/20-SQL-CheatSheet.pdf differ
diff --git a/PDF/Planung.pdf b/PDF/Planung.pdf
new file mode 100644
index 0000000..ff61fe5
Binary files /dev/null and b/PDF/Planung.pdf differ
diff --git a/PDF/instahub.pdf b/PDF/instahub.pdf
new file mode 100644
index 0000000..a78ce04
Binary files /dev/null and b/PDF/instahub.pdf differ
diff --git a/Video/05 ER-Modell mit DIA.flv b/Video/05 ER-Modell mit DIA.flv
new file mode 100644
index 0000000..51d08f0
Binary files /dev/null and b/Video/05 ER-Modell mit DIA.flv differ
diff --git a/Video/05 ER-Modell mit DIA.mp4 b/Video/05 ER-Modell mit DIA.mp4
new file mode 100644
index 0000000..b2595c9
Binary files /dev/null and b/Video/05 ER-Modell mit DIA.mp4 differ
diff --git a/_sidebar.md b/_sidebar.md
index 70c23a9..30e8340 100644
--- a/_sidebar.md
+++ b/_sidebar.md
@@ -1,8 +1,27 @@
-* [InstaHub](index.md)
-* [Bedienung](frontend.md)
-* [ERM](erm.md)
-* Didaktik
- * [Übersicht](didactic.md)
- * [Modellierung und SQL](didactic-modellierung-sql)
-* [Übungen](exercices.md)
+## Datenbanken
+### Eine Einführung mit InstaHub
++ [01 Vorwort](01-Vorwort.md)
++ [02 Einstimmung](02-Einstimmung.md)
++ [03 Erste Schritte](03-Erste-Schritte.md)
++ [04 Suchmaske](04-Suchmaske.md)
++ [05 Einfache SQL-Abfragen](05-Einfache-SQL-Abfragen.md)
++ [06 SQL-Abfragen mit einer Tabelle](06-SQL-Abfragen-mit-einer-Tabelle.md)
++ [07 Daten ändern](07-Daten-aendern.md)
++ [08 Passwörter speichern](08-Passwoerter-speichern.md)
++ [09 Tabellen erstellen](09-Tabellen-erstellen.md)
++ [10 ERM](10-ERM.md)
++ [11 JOIN](11-JOIN.md)
++ [12 komplexe SQL-Abfragen](12-komplexe-SQL-Abfragen.md)
++ [13 komplexe CRUD-Befehle](13-komplexe-CRUD-Befehle.md)
++ [14 Big Data](14-Big-Data.md)
++ [15 Datenschutz](15-Datenschutz.md)
++ [16 Normalisierung](16-Normalisierung.md)
++ [17 ERM und Tabellenmodell](17-ERM-und-Tabellenmodell)
++ [18 ERM entwickeln](18-ERM-entwickeln)
++ [19 Top 10 der Themen, die wir nicht behandelt haben](19-Top-10.md)
++ [20 SQL Cheat-Sheet](20-SQL-CheatSheet.md)
+-----
+* [InstaHub](https://instahub.org)
+* [InstaHub-Dokumentation](https://wi-wissen.github.io/instahub-doc-de/#/)
+-----
diff --git a/didactic.md b/didactic.md
deleted file mode 100644
index d29b43e..0000000
--- a/didactic.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Didaktik
-
-## Ansätze
-
-Es bieten sich folgende grundsätzliche didaktische Ansätze an:
-
-* Auswerten und Modellieren von Datenbanken
-* Datenschutz und -sicherheit
-* Perspektivenwechsel: Rolle des Administrator und Werbekunden eines sozialen Netzwerks
-
-### Auswerten und Modellieren von Datenbanken
-
-Dieser didaktische Ansatz wurde vom Autor bereits mit über 150 SchülerInnen erfolgreich durchgeführt. Es lässt sich damit nach dem sächsischen Lehrplan Informatik der gesamte Lernbereich Datenbanken in der Sekundarstufe II behandeln. Hier erlernen SchülerInnen Fähigkeiten im Modellieren (ERM, Kardinalitäten, Schlüssel etc.) und im Umgang mit SQL (CRUD-Abfragen in einer und verknüpften Tabellen, sowie Anlagen von Tabellen).
-
-**Den Ablaufplan findest du unter [Modellierung und SQL]( didactic-modellierung-sql)**
-
-**Alle Aufgaben findest du vollständig unter [Übungen](exercices)**
-
-### Datenschutz und -sicherheit
-
-SchülerInnen ist oft nicht klar, wie verfügbar ihre persönlichen Daten abgespeichert werden und wie leicht sie gefunden und geclustert werden können. Dies zu erzählen ist das eine, aber tatsächlich alle "Nazis" in einem sozialen Netzwerk zu finden, ist ein sehr nachhaltiges Erlebnis, welches bereits schon zu drastischen Reaktionen geführt hat.
-
-Was passiert wenn mal wieder Nutzerdaten bei einem großen Anbieter verloren gegangen sind? Schaut euch gemeinsam an, wie Passwörter heut gespeichert werden (`bcrypt()` in PHP).
-
-### Perspektivenwechsel
-
-Ganz neu ist hinzugekommen, dass InstaHub die Aktivität derr Nutzer tracken kann und ihnen individuell zugeschnittene (fiktive) Werbung ausliefert. Endlich ist es für SchülerInen möcht zu verstehen wie Werbung und Tracking technisch funktionieren und können so fundiert über die gesellschaftliche Entwicklung diskutieren. Besonders im Rahmen des DSGVO kann hier nüchtern betrachtet werden, was eigentlich passiert.
-
-Diese Funktionalität ist sehr neu. Der Autor wird dies auch erst im Frühjahr ausprobieren können. **Es wäre großartig, wenn du hier didaktische Ideen und ggf. Material mit beitragen könntest.**
-
-## Werkzeuge
-
-Um InstaHub zu benutzen sind keine weiteren Werkzeuge notwendig. Alle Aufgaben lassen sich direkt im Browser mithilfe der Sprache SQL bearbeiten.
-
-Nun kann es sein, dass SQL nicht Bestandteil des Lehrplans ist oder die Zeit zum Erlernen nicht ausreicht. Hier gibt es zwei Möglichkeiten:
-
-InstaHub ausschließlich über die "reguläre" Administratoroberfläche nutzen. Hier können neben den normalen Aktionen des Nutzers auch fremde Eintrage gelöscht und fremde Nutzerprofile bearbeitet werden.
-
-InstaHub mithilfe eines externen Werkzeugs wie etwa [Microsoft Access](https://de.wikipedia.org/wiki/Microsoft_Access), [LibreOffice Base](https://de.libreoffice.org/discover/base/) oder [phpMyAdmin](https://de.wikipedia.org/wiki/PhpMyAdmin) verwenden. Alle genannten Werkzeuge können sich mit entfernten Datenbanken verbinden. Damit eine Verbindung möglich ist, muss der InstaHub-Server entsprechend konfiguriert sein:
-
-**Achtung: Dies ist aus sicherheitsgründen und Ressourcenmangel auf dem offiziellen [InstaHub.org](https://instahub.org/)-Server deaktiviert.**
-
-In der `.env` Konfiguration muss *vor* dem Anlagen dern Nutzer `ALLOW_PUBLIC_DB_ACCESS=true` gesetzt werden. Nun können in der Database-Seite die Verbindungsdaten zum Server ausgelesen werden:
-
-
-
diff --git a/frontend.md b/frontend.md
deleted file mode 100644
index fa51309..0000000
--- a/frontend.md
+++ /dev/null
@@ -1,185 +0,0 @@
-# Bedienung
-
-## instahub.org
-
-Die Hauptseite des Projektes ermöglicht es sich als interessierter Besucher zu informieren. Bei Interesse können hier:
-
-* Ein Lehreraccount erstellt werden (Registrieren)
-* Sich mit einem Lehreraccount angemeldet werden (Anmelden)
-* Ein InstaHub erstellt werden (Erstelle deinen InstaHub)
-
-Um sich als Lehrer zu registrieren, muss ein Account angelegt werden. Dabei ist es wichtig, dass die Emailadresse stimmt, da sonst kein Account geprüft und angelegt werden kann.
-
-Um einen Lehreraccount zu aktivieren, kannst du entweder gleich deine Schulmailadresse verwenden [sendest](https://wi-wissen.de/contact.php) mir einen anderen geeigneten Nachweis mit Angabe deines Benutzernamen. Das ist wichtig, dass nur volljährige Lehrer Schüler administrieren können und auf die Einhaltung der Regelungen achten.
-
-Ein InstaHub kann nur angelegt werden, wenn dieser einem Lehrer zugeordnet wird. So ist sichergestellt, dass zum einen unter fachkundiger Anleitung ein Lernerfolg erzielt werden kann.
-
-Wurde einer Lehrkraft ein InstaHub zugeordnet, so muss dieser ebenfalls erst aktiviert werden. Dies kann durch die Lehrkraft selbst durchgeführt werden.
-
-
-
-### Verwaltung der Instahubs
-
-
-
-Nach dem erfolgreichen Login mit einem Lehrer Account wird eine List mit allen zugeordneten Hubs angezeigt. Folgende Aktionen sind möglich:
-
- * **Aktivieren** – Erst hierdurch wird der Instahub aktiviert.
- * **DB Admin** – siehe Verwaltung eines InstaHub
- * **Login as DBA** – Hierdurch wird der Lehrer auf den ausgewählten InstaHubweitergeleitet und loggt sich automatisch - ohne Kenntnisse desBenutzerkennwortes - als der erste DBA-Benutzer ein. Dies ist in der Regel der Schüler Account.
- * **Fill all Tables** - Um alle Funktionalitäten des Hubs zu aktivieren können hierüber alle Tabellen angelegt und mit Dummy-Daten gefüllt werden. Je nach [didaktischen Vorgehen]() kann dies sinnvoll sein.
- * **Maintenance** – Ist dieser Modus aktiviert kann nur noch lesend auf die Datenbank zugegriffen werden. Ausnahme davon ist die `Analytics`-Tabelle, welche weiterhin neue Einträge hinzufügt. Der ausschließliche Lesezugriff greift sofort wird im Hub aber erst angezeigt, wenn man sich abmeldet.
- * **Deaktivieren** – Hier kann ein InstaHub deaktiviert werden. Es ist dann kein Login mehr möglich.
- * **Delete** – Hier kann der InstaHub mitsamt der gesamten Datenbank nachBeendigung der Lerneinheit vollständig gelöscht werden. (Achtung: Hierfür ist keine Bestätigung erforderlich.). Bitte lösche nicht mehr benötigte Hubs, um Speicherplatz auf dem Server zu sparen.
-
-
-
-### Verwaltung eines Instahubs
-
-
-
-Im oberen Bereich werden alle aktuell verfügbaren Tabellen mit der Anzahl aller Einträge angezeigt.
-
-Darunter befinden sich kopiert alle Tabellen es sind jeweils folgende Aktionen möglich:
-
-* (Re)Create - Hierdurch wird die Tabelle ohne Einträge neu angelegt.
-* (Re)Fill - Hierdurch wird die Tabelle mit Dummyeinträgen neu angelegt
-* Drop - Hier drüber wird die Tabelle vollständig gelöscht.
-
-Üblicherweise ist diese Hilfestellung Für Schüler notwendig, die einen Fehler gemacht haben, nicht mitgekommen sind oder krank waren.
-
-Sicher ist Ihnen schon aufgefallen, dass das Löschen etwa der Tabelle `Photo` kritisch sein sollte, da dadurch ja etwa die darauf aufbauende Tabelle `Like` ebenfalls gelöscht werden sollte. Dies wird hier aber absichtlich unterbunden, indem das Ausführen von Constraints ausgesetzt wird.
-
-Dadurch ist es möglich auch zu einem späteren Zeitpunkt die Tabelle `Photo` neu aufzubauen, ohne dass bisherige Errungenschaften in den darauf aufbauenden Tabellen vernichtet werden. Natürlich können dadurch Inkonsistenzen in der Datenbank entstehen, welche aber nicht zu einem Absturz des Systems führen werden. Ist es dennoch notwendig diese Inkonsistenzen aufzulösen, so kann dies entweder manuell geschehen oder die abhängigen Tabellen werden ebenfalls neu aufgebaut.
-
-
-
-## *hub*.instahub.org
-
-Wird der Hauptdomain der InstaHub Name vorangestellt, so befindet sich der Benutzer in seinem eigenen InstaHub. Jeder InstaHub funktioniert vollkommen unabhängig von allen anderen InstaHub.
-
-Ein InstaHub ist von der Funktion her an das soziale Netzwerk Instagram angelehnt. So ist es möglich Fotos hoch zu laden und mithilfe des Hashtag-Zeichens (`#`) zu verschlagworten, mit dem `@`-Zeichen können Nutzer verlinkt werden. Ebenfalls können Fotos kommentiert und geliked werden:
-
-
-
-Interessanten Mitgliedern des sozialen Netzwerkes kann gefolgt werden, sodass sich ein individueller Newsfeed für jeden Benutzer bildet. Ein Benutzer besitzt eine Profilseite mit seinen Photos:
-
-
-
-Die Besonderheit des sozialen Netzwerkes sind hier seine zwei Rollen:
-
-* `User` - Dies sind alle regulären Benutzer des sozialen Netzwerkes. Ähnlich wie es der Schüler auf seinen sozialen Netzwerken wie etwa Facebook oder Instagram ist.
-* `DBA` - hier hat der Schüler zusätzliche Rechte: Dazu zählt etwa fremde Bilder und Kommentare zu löschen. Fremde Profile zu editieren (und damit auch das vollständige Geburtsdatum und E-Mail zu sehen) und der Menüeintrag Database
-
-
-
-### Database
-
-Hier findet die eigentliche Besonderheit des eigenen InstaHubs statt: Es ist möglich mit SQL-Befehlen die Datenbank nach Belieben zu verändern. Ergebnisse werden dabei Übersicht präsentiert:
-
-
-
-Da jeder Hub seine eigene Datebank hat können hierüber tatsächlich alle SQL-Befehle abgesendet werden. Auch das Löschen der eigenen `User`-Tabelle ist möglich. `SELECT`-Abfragen liefern das Ergebnis in einer Tabelle zurück. Andere Abfragen, ob sie erfolgreich ausgeführt wurden, oder welcher Fehler aufgetreten ist. Dabei wird immer der von MySQL gemeldete Fehler zurückgegeben.
-
-
-
-## Business
-
-Mit der Tabelle `Ads` aktiviert InstaHub die Werbeanzeigen. Alle mitgelieferten Anzeigen sind selbstverständlich frei erfunden. Werbung findet auf den einzelnen Photoseiten
-
-
-
-oder als dritter Eintrag im Newsfeed statt:
-
-
-
-Werbeanzeigen werden dabei personalisiert ausgeliefert. Wie diese geschieht, kann mit SQL-Kenntnissen vollständig selbst bestimmt werden:
-
-Die Tabelle `ads` besitzt folgende Attribute, um eine Werbeanzeige zu definieren:
-
-* `id` - fortlaufende Nummer als Primärschlüssel
-* `priority` - Wenn mehrere Bedingungen zutreffen wird die Anzeige mit der niedrigsten Zahl ausgewählt (Priorität 1 ist als die höchste)
-* `name` - Name der Werbeanzeige zum Wiederfinden, wird aktuell nicht verwendet
-* `type` - `photo` oder `banner`. Photos werden nur im Newsfeed und Banner nur unter einzelen Photos in der Detailansicht angezeigt.
-* `url` - Ziellink, auf den der Nutzergeleitet wird. Es wird empfohlen `/noad` als Adresse zu verwenden, dann kommt der Nutzer auf eine eingerichtete Fehlerseite, dass die Werbekampagne bereits ausgelaufen sei. Die Schulhomepage als Adresse ist aber ebenfalls möglich
-* `img` - Anzuzeigendes Bild. Aktuell sind nur die unter Business angezeigten Werbebanner im System hinterlegt. Es ist aber auch möglich die Werbegrafik einfach als Photo hochzuladen oder einen absoluten Link auf eine Grafik im Internet zu verwenden (Beachte, dass du das nur machen darft, wenn das für den fremden Werbserverinhaber in Ordnung ist).
-* `query` - SQL Ausdruck, der ermittelt, ob die Anzeige geeignet ist. Als Platzhalter können `$user` für die User-ID des Benutzers und wenn es vom `type` `banner` ist die dazugehörige Photo-ID `$photo` verwendet werden.
-* `created_at` - aktueller Zeitstempel, wird aktuell nicht verwendet
-* `updated_at` - aktueller Zeitstempel, wird aktuell nicht verwendet
-
-Im Ergebnis der `query` können verschiedene Ergebnisse ausgewertet:
-
-* kein Ergebnis - die Anzeige wird als nicht geeignet gewertet.
-* Genau ein Ergebnis - Das erste Attribut mit dem ersten Attributwert geprüft. Ist das Ergebnis nicht `false`, `null` oder `0`, so wird die Anzeige als geeignet gewertet.
-* Eine Liste von `id`s. In diesem Fall wird geprüft, ob die Photo- bzw. User-ID in der Abfrage enthalten ist. Ist dem der fall wird die Anzeige als geeignet gewertet.
-
-Hier zwei Beispiele für eine `query`:
-
-```sql
-SELECT
- CASE gender
- WHEN 'male' THEN true
- ELSE false
- END
-FROM users where id=$user
-```
-
-Dieser Befehl gibt `true` zurück, wenn das Geschlecht des aktuellen Nutzers `male` ist. Ansonsten `false`.
-
-Alternativ kann auch der folgende Ausdruck geschrieben werden:
-
-```sql
-SELECT id
-FROM users
-WHERE gender = 'male'
-```
-
-Auch komplexere Abfragen lassen sich realisieren:
-
-```sql
-SELECT
- CASE
- WHEN device = 'desktop' THEN true
- ELSE false
- END
-FROM analytics
-WHERE user_id=$user
-ORDER BY id DESC
-LIMIT 1
-```
-
-Es können beliebige Befehle geschrieben werden. Bitte beachte aber, dass der dafür gut geeignete Befehl [`WITH`](https://mariadb.com/kb/en/library/with/) erst ab MariaDB 10.2.1 und in MySQL in Version 8 eingeführt wurd. Diese Versionen sind noch nicht auf allen Servern - wie etwa dem offiziellen InstaHub.org Server.
-
-```sql
-SELECT id FROM users WHERE id=$user
-```
-
-In diesem Fall wird ja immer die User-ID zurückgegeben. Da diese größer als `0` ist, wird diese Anzeige immer als möglich betrachtet. Sie sollte daher mit einer sehr geringen Priorität (etwa `99`) als Fallback-Lösung eingerichtet werden.
-
-Der vollständige SQL-Befehl kann etwa so aussehen:
-
-```sql
-INSERT INTO ads (priority, name, type, url, img, query, created_at, updated_at) VALUES
-(1, 'default', 'photo', '/noad',
- '/img/ad/freizeitpark.jpg',
- 'SELECT
- CASE
- WHEN device = "desktop"
- THEN true
- ELSE false
- END
- FROM analytics WHERE user_id=$user
- ORDER BY id DESC
- LIMIT 1',
- '2018-10-06 22:00:00', '2018-10-06 22:00:00')
-```
-
-Wichtig ist, dass der eingebettete SQL-Befehl als Zeichenkette übergeben wird. Werden Anführungszeichen verwendet dürfen diese nicht mit den umschließenden Anführungszeichen übereinstimmen. (Hier werden `""` von `''` umschlossen.)
-
-
-
-## Werbeblocker
-
-Kann Werbung nicht angezeigt werden, wird ein Hinweis angezeigt. In diesem Fall nutzt dein Browser einen Adblocker wie etwa [uBlock Origin](https://de.wikipedia.org/wiki/UBlock_Origin). Eine Filterung im Schulnetzwerk ist eher unwahrscheinlich, da die fiktiven Anzeigen ja vom selben Server kommen.
-
-Bei größeren SchülerInnen kann auch die Funktion eines [Anti-Adblock Killers](https://github.com/reek/anti-adblock-killer#anti-adblock-killer--reek) besprochen werden. Dieser unterdrückte nämlich zuerst die hier [implementierte Lösung](https://stackoverflow.com/a/20505898), um die Warnanzeige zu umgehen. Diese ist so weit oben bei Google zu finden, dass der Skript einfach auf Verdacht `var canRunAds = true;` in die Webseiten injected. Daher habe ich die Variable auf einen zufälligen Namen geändert und schon klapptes es wieder. Das kann natürlich auch ausgehebelt werden, aber dafür müsste dies individuell für die Seite gemacht werden. Sehr schwer wird es, wenn ich den Variablennamen serverseitig jedes Mal neu auswürfeln würde. Dann könnte man das `div`-Element mit einer speziellen CSS-Regel ausblenden oder mit JavaScript löschen, wodurch ich auch dessen `id` ändern müsste. Jetzt müsste man das Element anhand des CSS-Pfades bzw. XPath suchen, wodurch ich die Position variieren müsste. Du erkennst wohin die Reise geht?
\ No newline at end of file
diff --git a/index.md b/index.md
index 4e2ef6c..4d0db7f 100644
--- a/index.md
+++ b/index.md
@@ -4,35 +4,9 @@ InstaHub ist ein soziales Netzwerk ähnlich Instagram, welches im Unterricht zu
Schüler sind in InstaHub nicht Nutzer, sondern selbst Administratoren. Sie haben so vollen Zugriff auf alle Funktionen des sozialen Netzwerks, die in echten Netzwerken verborgen sind.
-Mit InstaHub können folgende Lernziele erreicht werden:
+Das Skript ist für die Berufsoberschule und das Berufliche Gymnasium entwickelt worden. Es sollte aber auch allgemein in der Sek II einsetzbar sein. In dieser Form sollte (ähnlich wie beim Ansatz von Julian Dorn) etwa ein Halbjahr (2 Stunden pro Woche) angesetzt werden.
-* Datenbanken
- * SQL - SELECT, INSERT UPDATE DELETE in einer und mehreren Tabellen
- * Anforderungen an ein Datenbank-Managementsystem
-* Entity-Relationship-Modell verstehen und zeichnen.
-* Einblick in Benutzertracking
-* Erstellen von personalisierte Werbung
-* Einblick in die Funktion von Werbeblockern
-* Bedeutung von Datenschutz und Datensicherheit erkennen
-* Client Server Architektur einer Webanwendung
-
-Der Vorgänger von InstaHub ist die [friendzone](https://blog.wi-wissen.de/post/friendzone). Diese wurde 2017 mit dem [Unterrichtspreis der Gesellschaft für Informatik](https://www.gi.de/aktuelles/meldungen/detailansicht/article/julian-dorn-erhaelt-unterrichtspreis-2017-der-gesellschaft-fuer-informatik-fuer-friendzone.html) ausgezeichnet.
-
-# Gliederung der Dokumentation
-
-Diese Dokumentation richtet sich hauptsächlich an Lehrkräfte. Es werden folgende Themenbereiche behandelt:
-
-**[Bedienung](frontend)** - hier wird die Bedienung von InstaHub besonders aus der Sicht für Lehrkräfte vorgestellt.
-
-[**Didaktik**](didactic) - hier wird ein Vorschlag zur didaktischen Nutzung von InstaHub gemacht.
-
-[**Übungen**](exercices) - hier sind Vorschläge für Aufgabenstellungen an die Schüler.
-
-# Mitmachen!
-
-Die Plattform InstaHub und diese Dokumentation sind im Quelltext vollständig verfügbar. Durch offene Lizenzen ist es möglich, sowohl die technische Plattform als auch diese Dokumentation nach eigenen Wünschen zu gestalten.
-
-In dieses Projekt ist bereits sehr viel Energie, Freude und viele Erfahrungen eingeflossen. Wenn Sie neue tolle Ideen oder auch nur einen Rechtschreibfehler gefunden haben, wäre es sehr schön wenn Sie diese einbringen würden. Das geht ganz einfach indem Sie Ihre Änderungen direkt als Push Request bei GitHub einreichen. Alternativ können Sie auch gerne eine E-Mail senden.
+**Bitte lesen Sie die [Liesmich-Datei](readme.md) für weitere Informationen.**
# Nur möglich durch
diff --git a/instahub.css b/instahub.css
new file mode 100644
index 0000000..0d245df
--- /dev/null
+++ b/instahub.css
@@ -0,0 +1,41 @@
+body, p, blockquote, li {
+ text-align: left important!;
+ font-family: Liberation Sans, Sans-Serif, Arial;
+}
+pre {
+ background-color: #ffffcc;
+ border: 1px solid #ffdddd;
+ padding: 2px;
+ font-size: 85%;
+}
+figcaption {
+ font-size: 85%;
+ font-style: italic;
+}
+h4 span.header-section-number {
+ display: none !important;
+}
+
+h4 {
+ font-size: 130% !important;
+ margin-top: 0px !important;
+ padding-top: 0px !important;
+ margin-bottom: 0px !important;
+ padding-bottom: 0px !important;
+}
+h4 + p {
+ margin-top: 0px !important;
+ padding-top: 0px !important;
+}
+section.level4 {
+ background-color: #ffdddd !important;
+ padding-right: 5px !important;
+ padding-left: 5px !important;
+}
+h1 span.header-section-number {
+ font-size: 200%;
+ color: #aa0000;
+}
+img {
+ max-width:100%;
+}
\ No newline at end of file
diff --git a/instahub.xml b/instahub.xml
new file mode 100644
index 0000000..79fba3e
--- /dev/null
+++ b/instahub.xml
@@ -0,0 +1,3 @@
+cc-by-sa Reinhard Nitzsche
+Einführung in Datenbanken mit Instahub
+de
diff --git a/instahubTemplate.odt b/instahubTemplate.odt
new file mode 100644
index 0000000..dd985f2
Binary files /dev/null and b/instahubTemplate.odt differ
diff --git a/makeall.bat b/makeall.bat
new file mode 100644
index 0000000..7dc414f
--- /dev/null
+++ b/makeall.bat
@@ -0,0 +1,37 @@
+@REM Projekt "Skript für InstaHub"
+@REM Make-File für die Erstellung von EPUB- und ODT-Dateien aus MD-Dateien
+@REM NIT 09.07.19
+@CLS
+@ECHO ***
+@ECHO *** Generiere EPUB...
+@ECHO ***
+@REM Alle Dateien manuell in der richtigen Reihenfolge einbinden. Exporttyp angeben.
+@REM Metadaten aus XML-Datei einbinden. Deckblatt und CSS einbinden.
+@REM Nummerierte Überschriften
+@REM Ausgabedatei angeben.
+pandoc "00-TITLE.md" "00-META.md" "01-Vorwort.md" "02-Einstimmung.md" "03-Erste-Schritte.md" "04-Suchmaske.md" "05-Einfache-SQL-Abfragen.md" "06-SQL-Abfragen-mit-einer-Tabelle.md" "07-Daten-aendern.md" "08-Passwoerter-speichern.md" "09-Tabellen-erstellen.md" "10-ERM.md" "11-JOIN.md" "12-komplexe-SQL-Abfragen.md" "13-komplexe-CRUD-Befehle.md" "14-Big-Data.md" "15-Datenschutz.md" "16-Normalisierung.md" "17-ERM2Tabelle.md" "18-ERM-entwickeln.md" "19-Top-10.md" "20-SQL-CheatSheet.md" -t epub3 --epub-metadata instahub.xml --epub-cover-image instahubcover.png --css instahub.css --number-sections -o .\EPUB\instahub.epub
+
+@ECHO.
+@ECHO ***
+@ECHO *** Generiere gesamtes ODT ...
+@ECHO ***
+@REM Alle Dateien manuell in der richtigen Reihenfolge einbinden. Exporttyp angeben.
+@REM Referenzdatei angeben, laut pandoc ist das kein Template. Ich nenne es aber so.
+@REM Nummerierte Überschriften
+@REM Inhaltsverzeichnis einfügen
+@REM Ausgabedatei angeben.
+pandoc "00-TITLE.md" "00-META.md" "01-Vorwort.md" "02-Einstimmung.md" "03-Erste-Schritte.md" "04-Suchmaske.md" "05-Einfache-SQL-Abfragen.md" "06-SQL-Abfragen-mit-einer-Tabelle.md" "07-Daten-aendern.md" "08-Passwoerter-speichern.md" "09-Tabellen-erstellen.md" "10-ERM.md" "11-JOIN.md" "12-komplexe-SQL-Abfragen.md" "13-komplexe-CRUD-Befehle.md" "14-Big-Data.md" "15-Datenschutz.md" "16-Normalisierung.md" "17-ERM2Tabelle.md" "18-ERM-entwickeln.md" "19-Top-10.md" "20-SQL-CheatSheet.md" --reference-doc instahubtemplate.odt --number-sections --toc -t ODT -o .\ODT\instahub.odt
+
+@ECHO.
+@ECHO ***
+@ECHO *** Generiere je Kapitel einzelnes ODT ...
+@ECHO ***
+FOR %%I IN (*.md) DO pandoc "00-META.md" "%%I" --reference-doc instahubtemplate.odt -t ODT -o ".\ODT\%%~nI.odt"
+
+@ECHO.
+@ECHO ***
+@ECHO *** Generiere je Kapitel einzelnes PDF via Libre Offfice ...
+@ECHO ***
+@REM Libre Office konvertiert alle Dateien in PDF, k.A. wozu --headless da ist. Geht sonst nicht
+FOR %%I IN (ODT\*.odt) DO "C:\Program Files\LibreOffice\program\soffice" --headless --convert-to pdf:writer_pdf_Export --outdir .\PDF "%%I"
+@PAUSE
diff --git a/readme.md b/readme.md
index a974730..912c64b 100644
--- a/readme.md
+++ b/readme.md
@@ -1,31 +1,61 @@
-# InstaHub Dokumentation (German)
+# InstaHub Script (German)
-German documentation for [InstaHub](https://github.com/wi-wissen/InstaHub). Please help to translate!
+German script for pupils for [InstaHub](https://github.com/wi-wissen/InstaHub). Please help to translate!
-Online: https://wi-wissen.github.io/instahub-doc-de/
+**GitHub Pages: https://rnitzsche.github.io/instahub-doc-de/**
+
+Online-Dokumentation von Julian Dorn: https://wi-wissen.github.io/instahub-doc-de/
## Über
-Diese Dokumentation dienst dazu Lehrkräften einen Überblick über InstaHub zu geben.
+**Das Skript ermöglicht ein weitgehend selbstgesteuertes Vorgehen der Schüler/-innen.
+Es ist nicht so perfekt dokumentiert und vollständig, wie es sein sollte, aber evtl. hilft es in Coronazeiten in halbgarem Zustand mehr als in 100% in einigen Monaten.**
-Es wird ein Vorschlag für das didaktische Vorgehen gemacht. Außerdem werden alle dazu benötigten Aufgaben beigefügt.
+**Das Skript ist für die Berufsoberschule und das Berufliche Gymnasium entwickelt worden. Es sollte aber auch allgemein in der Sek II einsetzbar sein. In dieser Form sollte (ähnlich wie beim Ansatz von Julian Dorn) etwa ein Halbjahr (2 Stunden pro Woche) angesetzt werden.**
-Die Dokumentation ist aus dem Git [InstaHub](https://github.com/wi-wissen/InstaHub) ausgegliedert, da sie zum einen nur in deutscher Sprache ist und zum anderen vermutlicher vom Projekt unabhängige Commits erhalten wird.
+## Ein Skript in mehreren Formen (Cross-Media)
-Sie sind sehr gern eingeladen, eigene Aufgaben beizustuern oder bestehende Inhalte zu verbessern!
+Das Skript kommt in mehreren Formaten:
++ Für jedes Kapitel ein MD-File, Abbildungen im Ordner /Assets. (Dies sind die Dateien, aus denen alles andere erstellt wird.)
++ Für jedes Kapitel eine ODT-Datei
++ Für jedes Kapitel eine PDF-Datei
++ Das gesamte Skript als ODT, PDF und EPUB
+Idee: Damit kann man KMK-konform unterschiedliche Medien ausprobieren und evaulieren.
+## Moodle-Kurs
+[Moodle (Onedrive, 50MB)](https://1drv.ms/u/s!AugTRHF_26_Mh6dHLklj9jjbZCnlaQ?e=CD9fyO): es gibt einen (leider korrekturintensiven) Moodle-Kurs dazu.
-Die Dokumentation ist mit Markdown geschrieben. Es ist zu Beginn etwas ungewohnt, bietet aber viele Vorteile:
+Zur vollständigen Unterstützung benötigt ihr einen Moodle-Server mit aktiviertem:
++ Stash (https://moodle.org/plugins/block_stash)
++ Lernpaket (https://docs.moodle.org/38/de/Lernpaket)
+... aber ohne sollte es eigentlich auch gehen.
-* Markdown kann dank [Pandoc](http://www.pandoc.org/) in HTML, PDF oder auch DOCX übersetzt werden.
-* Anstelle eines schwer zu lesenden HTML-Syntax wird eine einfachere zu schreibende und lesende Annotation bereitgestellt.
-* Markdown wird hier bei GitHub automatisch gerendert.
+## Kapitel
++ [01 Vorwort](https://github.com/RNitzsche/instahub-doc-de/blob/master/01-Vorwort.md)
++ [02 Einstimmung](https://github.com/RNitzsche/instahub-doc-de/blob/master/02-Einstimmung.md)
++ [03 Erste Schritte](https://github.com/RNitzsche/instahub-doc-de/blob/master/03-Erste-Schritte.md)
++ [04 Suchmaske](https://github.com/RNitzsche/instahub-doc-de/blob/master/04-Suchmaske.md)
++ [05 Einfache SQL-Abfragen](https://github.com/RNitzsche/instahub-doc-de/blob/master/05-Einfache-SQL-Abfragen.md)
++ [06 SQL-Abfragen mit einer Tabelle](https://github.com/RNitzsche/instahub-doc-de/blob/master/06-SQL-Abfragen-mit-einer-Tabelle.md)
++ [07 Daten ändern](https://github.com/RNitzsche/instahub-doc-de/blob/master/07-Daten-aendern.md)
++ [08 Passwörter speichern](https://github.com/RNitzsche/instahub-doc-de/blob/master/08-Passwoerter-speichern.md)
++ [09 Tabellen erstellen](https://github.com/RNitzsche/instahub-doc-de/blob/master/09-Tabellen-erstellen.md)
++ [10 ERM](https://github.com/RNitzsche/instahub-doc-de/blob/master/10-ERM.md)
++ [11 JOIN](https://github.com/RNitzsche/instahub-doc-de/blob/master/11-JOIN.md)
++ [12 komplexe SQL-Abfragen](https://github.com/RNitzsche/instahub-doc-de/blob/master/12-komplexe-SQL-Abfragen.md)
++ [13 komplexe CRUD-Befehle](https://github.com/RNitzsche/instahub-doc-de/blob/master/13-komplexe-CRUD-Befehle.md)
++ 14 Big Data
++ 15 Datenschutz
++ 16 Normalisierung
++ 17 ERM und Tabellenmodell
++ 18 ERM entwickeln
++ [19 Top 10 der Themen, die wir nicht behandelt haben](https://github.com/RNitzsche/instahub-doc-de/blob/master/19-Top-10.md)
++ [20 SQL Cheat-Sheet](https://github.com/RNitzsche/instahub-doc-de/blob/master/20-SQL-CheatSheet.md)
-Als Editor empfehle ich [Typora](https://typora.io/)
## Lizenz
-[Attribution-ShareAlike 4.0 International (CC BY-NC-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)
\ No newline at end of file
+[Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)](https://creativecommons.org/licenses/by-sa/4.0/)