Grundkurs Datenbanksysteme

Inhaltsverzeichnis

Vorwort

Teil I: Einleitung

1 Was sind eigentlich Datenbanken?

1.1 Konsistenz ist Grundvoraussetzung

1.2 Keine Datenbank ohne Datenbankmanagementsystem

1.3 Dauerhafte Speicherung

1.4 Alle auf einen

1.5 Auf Nummer sicher

1.6 Damit alles stimmt

1.7 Tornadosicher

1.8 Der Mensch

1.9 Warum nicht selber machen?

1.10 Das ANSI SPARC-Modell als Lösung

1.11 Wie alles anfing

1.12 Mit IMS zum Mond

1.13 Und heute?

1.14 Wie geht es weiter?

2 Relationale Datenbanken – eine kurze Übersicht

2.1 Relationen gibt es schon lange

2.2 Die zwölf Gebote

2.3 Funktioniert das überhaupt?

2.4 Wo bekommt man ein RDBMS?

2.5 Ein RDBMS zum Anfassen

2.6 Erste Schritte mit SQL

2.7 Der Systemkatalog

2.8 Was kann SQL?

3 Das relationale Modell

3.1 Mengen

3.2 Das kartesische Produkt

3.3 Relationen

3.4 Die Projektion

3.5 Superschlüssel

3.6 Schlüsselkandidaten

3.7 Relationentyp

3.8 Fremdschlüssel

3.9 Alles nur graue Theorie?

4 Die Relationenalgebra

4.1 Die Projektion

4.2 Abgeschlossenheit

4.3 Produkt, Vereinigung und Differenz

4.4 Prädikate

4.5 Die einfache Selektion

4.6 Der Durchschnitt

4.7 Die allgemeine Selektion

4.8 Der Join

4.9 Wo sind die Grenzen?

4.10 Was soll das?

4.11 Atomare Werte

4.12 Wiederholungsgruppen

Teil II: Die Datenbank wird erschaffen

5 Tabellen und Constraints

5.1 Die Wirklichkeit ist nicht vollkommen

5.2 Keine Relationentypen in SQL

5.3 Domänen – ein selten besuchtes Gebiet

5.4 Der Typ ist wichtig

5.5 Die reine Lehre

5.6 Dubletten verhindern

5.7 Primärschlüssel

5.8 Fremdschlüssel

5.9 Natürliche Schlüssel

5.10 Künstliche Schlüssel leicht gemacht

5.11 Statische Regeln

5.12 Es muss nicht immer statisch sein

5.13 Tabellen mit gleichen Namen

5.14 null – die unbekannte Dimension

5.15 Änderungen von referenzierten Daten

5.16 Datentypen

6 Von der Idee zum Konzept

6.1 Entitäten und ihre Attribute

6.2 Entitätstypen

6.3 Beziehungen

6.4 Wie viel Entität darf's denn sein?

6.5 Rekursive Beziehungen

6.6 Hält doppelt gemoppelt besser?

6.7 Ist doch ganz einfach?

7 Von einem Modell zum nächsten

7.1 Mehrwertige Datentypen

7.2 Zusammengesetzte Attribute

7.3 Aus Entitätstypen werden Tabellen

7.4 Beziehungen mit mehr als zwei Teilnehmern

7.5 Binäre Beziehungen

7.5.1 C-CM-Beziehungen

7.5.2 1-CM-Beziehungen

7.5.3 1-C-Beziehungen

7.5.4 C-C-Beziehungen

7.5.5 CM-CM-Beziehungen

7.5.6 1-1-Beziehungen

7.5.7 Weitere Beziehungstypen

7.5.8 Beziehungen mit Attributen

8 Normalisierung

8.1 Anomalien

8.2 Die 1. Normalform

8.3 Funktionale Abhängigkeiten

8.4 Neuer Wein in alten Schläuchen

8.5 Die 2. Normalform

8.6 Der Weg in die Normalität

8.7 Die 3. Normalform

Teil III: Ran an die Daten

9 Grundlagen von SQL

9.1 Merkmale von SQL

9.2 Die Bestandteile von SQL

9.3 Der Standard

10 Einfache select-Anweisungen

10.1 Viele Möglichkeiten, um Spalten zu beschreiben

10.2 Datensätze mit where auswählen

10.3 Einige nützliche Operatoren

10.4 Sortieren

10.5 Alles in einen Topf

11 Funktionen in SQL-Anweisungen

11.1 Funktionen zur Textverarbeitung

11.2 Funktionen für Zahlen

11.3 Funktionen für Datumsangaben

11.4 Aggregatfunktionen

12 Daten zusammenfassen

12.1 Die group by-Komponente

12.2 Die having-Komponente

13 Datensätze verbinden

13.1 Joins mit SQL

13.2 Eine andere Syntax

13.3 Outer Joins

13.4 Muss es immer natürlich sein?

13.5 Joins mit mehr als zwei Tabellen

14 Geschachtelte Abfragen

14.1 Tabellen ohne Join verbinden

14.2 Vorsicht bei Mengen

14.3 Weitere Operatoren für Mengen

14.3.1 all

14.3.2 any

14.3.3 exists

14.4 Geschachtelte Abfragen oder Joins?

14.5 Korrelierte geschachtelte Abfragen

15 Views – sehen Sie Ihre Daten mal anders

15.1 Was sind Views?

15.2 Wozu Views?

15.3 Änderungen in Views

15.4 Codds 6. Regel

16 Machen Sie Ihre Datenbanken sicher!

16.1 Benutzerverwaltung

16.2 Welche Rechte gibt es?

16.3 Rechte auf Views

16.4 Weitergabe von Rechten

16.5 Verkettungen von Rechten

Teil IV: Anwendungsentwicklung

17 Transaktionen

17.1 Was schiefgehen kann, geht schief

17.2 Ein Experiment

17.3 Anweisungen gruppieren

17.4 Das Transaktionsprotokoll

17.5 Auch nach außen eine Einheit

17.6 ACID – Transaktionen kurz und bündig

18 JDBC

18.1 Der Cursor – die Verbindung zweier Welten

18.2 Wie bringe ich meiner Programmiersprache SQL bei?

18.3 Einige Vorarbeiten

18.4 Gute Verbindungen sind alles

18.5 Aus der Datenbank in das Programm

18.6 Ohne Transaktionen würde etwas fehlen

18.7 Flottes SQL dank guter Vorbereitung

18.8 Kurz vor Schluss

19 Hibernate

19.1 Was ist O/R-Mapping?

19.2 Aufbau einer Entwicklungsumgebung

19.3 Die Konfiguration

19.4 Ein einfaches Mapping

19.5 Daten einfügen und ändern

19.6 Daten lesen

19.7 Komplexe Attribute

19.8 Kein Allheilmittel

20 Unter der Haube

20.1 Alles kann so einfach sein

20.2 Die Festplatte

20.3 Caching

20.4 Wenn's mal kracht

20.5 Das Transaktionsprotokoll

20.6 Der Optimierer

20.7 Der Index

20.8 B+-Bäume

20.8.1 Idee

20.8.2 Beispiel

20.8.3 Regeln

20.8.4 Suchen

20.8.5 Einfügen

20.8.6 Löschen

20.8.7 Wie schnell ist das?

20.9 Indizierung mit SQL

Teil V: Es muss nicht immer relational sein

21 Objektdatenbanken

21.1 Das Manifest

21.2 db4o

21.2.1 db4o kann so einfach sein

21.2.2 Query By Example

21.2.3 Native Abfragen

21.3 Warum nicht gleich objektorientiert?

22 XML-Datenbanken

22.1 Eine ganz einfache Syntax

22.2 Selbstdefinierte Regeln

22.3 XML und relationale Datenbanken

22.3.1 Datenzentriertes XML

22.3.2 Dokumentenzentriertes XML

22.4 XPath – eine Abfragesprache für XML

22.5 XQuery – fast wie zu Hause

22.6 Der hybride Ansatz

23 NoSQL

23.1 Das Kreuz mit dem Schema

23.2 Gewaltige Datenmengen

23.3 Nicht immer das Gleiche

23.4 Schemafreie Datenbanken mit MongoDB

23.5 Gruppieren und Aggregieren mit MapReduce

23.6 Sharding mit MongoDB

23.7 Drum prüfe, wer sich bindet

Literaturverzeichnis

Stichwortverzeichnis