Freie Universität Berlin
Fachbereich Mathematik und Informatik
Institut für Informatik

Einführung in die Datenbanksysteme
Projektinformationen

Allgemeines

Das Datenbank-Projekt wird eine Datenbank-Applikation beinhalten, die aus den vorgeben Projekten gewählt werden kann. In Ausnahmefällen sind auch andere Projekte möglich. Das Projekt kann in Gruppen bis zu 2-3 Teilnehmenden durchgeführt werden. Jede Projektgruppe wird sich für ein Thema entscheiden, das Datenbank-Schema und die Datenbank mit Oracle oder Postgres anlegen. Im Folgenden werden alle Erläuterungen exemplarisch für die Oracle Datenbank am Institut beschrieben, Postgres verhält sich jedoch sehr ähnlich.
Für das Projekt werden Daten erfasst, in der Datenbank gespeichert, angefragt und verändert. Die Gruppen werden eine Applikation für Manipulationen auf den Daten programmieren. Ein einfaches Webinterface gibt den Benutzern der Applikation Zugang zur Datenbank. Sie kann interaktiv angefragt und verändert werden

Das Projekt besteht aus 9 Teilen, von denen jeder einzelene bearbeitet werden muss.

Die Projektaufgaben sind nach der Klärung des Projektentwurfs im ersten Teil selbständig über das Semester hinweg durchzuführen und wie schon beschrieben zu dokumentieren.

Im Verlauf der Projektarbeit sind verschiedene Skripte in die Dokumentation einzufügen. Es handelt sich hierbei um dokumentierte Sitzungen in sqlplus. Skripte zu editieren vor dem Einreichen kommt Betrug gleich und ist gegen die Spielregeln! Skripte sollten keine Syntax-Fehler enthalten, sie sollten eine Auswahl von Anfrageergebnissen enthalten aber nicht hunderte Zeilen von Tabelleninhalt. Jedes Resultat sollte direkt nach der entsprechenden Query dokumentiert sein. Falls das dokumentierte Vorgehen im Skript nicht eindeutig und sonnenklar zu erkennen ist, fügt Kommentare hinzu.

Alle angebenen Abgabetermine sind einzuhalten. Bei Verspätung werden Punkte abgezogen bzw. das Projekt nicht mehr gewertet.

Lest die Aufgaben sorgfältig durch, ihr erspart Euch damit viel Arbeit und unnötige Ärgernisse.

Projektauswahl

Der erste Schritt ist die Entscheidung für einen Applikationsbereich, den die Projektgruppe mit der Datenbank abdecken möchte. Folgende Projekte stehen zur Auswahl:

Ablauf

Das Projekt wird mehrere kleinere Teile beinhalten. Abgabe und Vorführung des Gesamtergebnisse ist zum Semesterende. Die ersten Schritte der Themenfindung und des Anfangsentwurfs werden intensiver betreut werden, die weitere Arbeitsplanung unterliegt dann Eurer eigenen Zeiteinteilung. Es ist jedoch dringend zu empfehlen, kontinuierlich am Projekt zu arbeiten, und die Betreuungsangebote zu nutzen.

Die folgende Aufgaben ist zum Start des Projektes zu erfüllen:

Beschreibt Eure geplante Datenbank-Applikation noch einmal etwas ausführlicher und genauer als in der obigen Projektbeschreibung. Beschreibt die zu erfassenden Daten und die Funktionen ausführlich. Ein kleines Beispiel gibt es hier. Die "Spezifikation" sollte 1-2 Seiten umfassen. Sie wird hinsichtlich Eignung und Prägnanz bewertet.
Erstellt ein UML-Diagramm für die vorgeschlagene Datenbank. Schlüssel-Attribute sollten gekennzeichnet sein, die Kardinalitäten der Beziehungen ebenfalls angegeben.

Nutzten sie die Sprechstunden, um Schwierigkeiten bei der Entscheidung für eine Applikation zu klären. Auch vorhandene UML-Designs sollten rechtzeitig diskutiert werden. Für den guten und weitestgehend stressfreien Verlauf des Projektes ist ein guter Entwurf sehr entscheidend.

Projekt-Dokumentation

Zusätzlich zu den Implementierungsarbeiten muß pro Gruppe ein Projektbericht erstellt werden, der zusammen mit der Projektabgabe eingereicht werden soll. Der Bericht soll folgende Aspekte beschreiben:

Aufgabenverteilung innerhalb der Gruppe (,Wer hat was gemacht?`).
Erfahrungen bei der Gruppenarbeit.
Wie hat die Zeiteinteilung der Gruppe funktioniert? Ist ein anfänglicher Plan eingehalten worden?
Erfahrungen beim Programmieren.
Beschreibung der Implementation (Entwurf, Konzepte, auftretende Probleme,...).
Wie haben Sie Ihr Programm getestet? (Qualität/Funktion)?

Alle Arbeitsschritte und Ergebnisse sollen in der Projekt-Dokumentation beschrieben werden, darauf wird zusätzlich bei den Aufgaben jeweils nochmals hingewiesen.

Technische Realisierung

Als Datenbanken sollte möglichst Oracle10g oder Postgres 8.0 verwendet werden. Für beide Systeme gibt es am Institut Accounts. Datenbanken oder andere Datenbanksysteme gibt es keine Unterstützung.
Die Anwendung und das Webinterface werden mit Java (Servlets, JSP) realisiert.

Teil 1: Entwurf des UML-Diagramms

Für die ausgewählte Applikation ist ein UML-Diagramm zu entwickeln. Je nach Projekt schwankt die Anzahl der Entitäten zwischen 5 und 10, analog dazu verhält sich die Anzahl der Relationships. Verschiedene Typen von Beziehungen (1:1,1:N, N:M) ebenso wie verschiedene Datentypen (string, integer, etc.) sind dabei enthalten. Fortgeschrittene Konstrukte, wie weak entity, "is-a" relationships, oder Rollen sind nicht in allen Projekten bzw. nur teilweise enthalten.

Teil 2: Relationales Schema

1. Falls das UML-Diagramm aus Teil 1 erweitert wurde oder noch wird, dokumentiert das bitte gut. Das veränderte Design wird dann die Grundlage für die Wertung der restlichen Projektaufgaben sein.
2. Entwickelt das entsprechende relationale Modell (Schema) für euren UML-Entwurf. Kennzeichnet Schlüsselattribute durch Unterstreichen.

Teil 3: Relationen in Oracle/Postgres

Kurztutorial: Wie stelle ich die Verbindung zur Oracle, SQLPlus / Postgres DB her.

Richtet euren Oracle Account ein, verändert dazu die Environment-Variablen, wie beschrieben.
Erzeugt Relationen basierend auf dem relationalen Schema aus Teil 2. Deklariert die Attribute, deren Typ, Schlüssel und Fremdschlüssel. Zu Attributen mit Datums oder Zeit-Typ findet ihr weitere Hinweise in der Oracle-Dokumentation. In der Projektdokumentation soll ein Ausdruck der Session eingefügt sein, in der die Relationen erfolgreich angelegt wurden. Legt ebenfalls eine Beschreibung jeder Relation bei, die durch das Kommando describe relation erzeugt wurde.
Für diese Aufgabe werdet ihr das Projekt-Schema neu erzeugen, Spezifikationen für zusätzliche Schlüssel, referentielle Integrität und andere Bedingungen hinzufügen. Verändert euer create table Kommando wie folgt:

Für jede Relation in eurem Schema: falls die Relation weitere Schlüssel als den Primary Key hat, so kennzeihnet diese als Unique. Falls es keine zusätzlichen Schlüssel gibt, fügt einen Kommentar ein, der auf diesen Umstand verweist.
Für jede referentielle Integritäts-Bedingung in eurem Schema spezifiziert die Bedingung mit dem reference -Kommando. Jedes Projekt sollte mindestens eine Bedingung zur referentiellen Integrität, was bei gut entworfenen Projekten keinerlei Problem darstellen sollte.
Fügt mindestens zwei Attribut-basierte und zwei Tupel-basierte check-Bedingungen ein.
Die Dokumentation soll das .sql-File enthalten und das Skript, das die erfolgreiche Ausführung zeigt.

Schreibt Datenmodifikations-Kommandos, die die folgenden Szenarios illustrieren:

Ein INSERT Kommando, das eine Schlüssel-Verletzung erzeugt.
Ein UPDATE Kommando, das eine Schlüssel-Verletzung erzeugt.
Ein INSERT Kommando, das eine Verletzung der referentillen Integrität erzeugt.
Ein UPDATE Kommando, das eine Verletzung der referentillen Integrität erzeugt.
Ein DELETE Kommando, das eine Verletzung der referentillen Integrität erzeugt.
Ein INSERT Kommando, das eine CHECK-Bedingungs-Verletzung erzeugt.
Ein UPDATE Kommando, das eine CHECK-Bedingungs-Verletzung erzeugt.

Die Dokumentation soll ein .sql-File enthalten mit allen sieben Kommandos und ein Skript, dass deren problematische Ausführung in Oracle zeigt.

Teil 4: Datenbasen

In den folgenden Schritten sollen zwei verschiedene Datenbasen entwickelt werden. Die Idee ist, einerseits mit einer kleinen Datenbank mit realistischen Daten zu arbeiten und andererseits mit einer umfangreicheren Datenbank mit Dummy-Werten zu operieren, die jedoch eine realistischere Größe hat. Ihr werdet im weiteren Verlauf abwechselnd mit den Daten arbeiten, Ihr solltet also entweder die Daten jeweils neu in die Datenbank laden, oder zwei Instanzen der Datenbank mit unterschiedlichen Daten erzeugen.
Erzeugt für jede Relation eine Datei mit ca. 5-10 Dateneinträgen, benutzt die bulk-load-Möglichkeiten von Oracle, um diese in die Realtionen zu laden. Die Dokumentation soll ein Listing der Dateien enthalten und ein Listing der Tabelleninhalte (erzeugt mit select *).
Schreibt ein Programm in einer beliebigen Sprache, das grosse Dateien mit (Zufalls-)Daten für eure Tabellen erzeugt. Falls reale Daten vorhanden sind, soll euer Programm diese an das benötigte Oracle-Format anpassen. Die Daten sollten die Grösse von "normalen" Datensätzen haben (z.B. längere Strings), um mit ihnen experimentieren zu können. Die Daten sollten in mindestens zwei Relationen aus Hunderten von Tupel bestehen. Beachtet, dass die Daten die vorher definierten Funktionalen Abhängigkeiten einhalten. Die Dokumentation sollte den Programmcode für die Generierung oder Transformation der Daten enthalten und das Skript, das das erfolgreiche Laden der Daten zeigt.

Teil 5: SQL-Anfragen

Die folgenden Aufgaben sollen auf der grossen Datenbank ausgeführt werden. Testen könnt ihr sie natürlich an der kleinen. Versucht interessante SQL-Anweisungen zu finden. Falls diese eine leere Antwortmenge ergeben, solltet ihr über eine Anpassung der Datengeneratoren nachdenken, sodass passende Datentupel vorliegen. Extrem einfache Queries und Datentupel werden nicht gewertet. Die Kommandos sind unter sqlplus interaktiv abzusetzen, für wiederholte Eingabe ist ein Skript empfehlenswert.
Entwickelt und testet mindestens 8 sinnvolle Anfragen ( select).
Entwickelt und testet mindestens zwei der vier Datenmodifikations-Kommandos: insert einzelnes Tupel, insert subquery, delete, update.
Die Dokumentation soll eine Kopie aller SQL-Kommandos enthalten und ein Skript, das deren erfolgreiche Ausfürung dokumentiert. Die Lösungsmengen sind gegebenenfalls gekürzt darzustellen, keine Ausdrucke von hunderten von Tupeln!

Teil 6: Sichten

1. Testet die folgende Aufgabe mit der grossen Datenbank
2. Erzeugt zwei sinnvolle Sichten auf eure Projektdatenbank. Dokumentiert das create view-Kommando und die Antwort des Systems.

Teil 7: Webanbindung der Datenbank

Alle Beispiele und Hinweisetexte für den Umgang mit JSP/Tomcat/Eclipse sind auf der Unterlagen Seite zu finden.

Programmiert ein nutzerfreundliches Web-Interface für eure Projektanwendung. In Analogie zum Nutzer-Interface im schon bearbeiteten Teil sollen dem Nutzer mindestens fünf verschiedene Arten der Interaktion angeboten werden. Ihr könnt die gleichen fünf Interaktionen wählen oder auch neue oder zusätzliche.
Je weniger eure Webseite nach einem Interface zu einer Datenbank aussieht, desto besser. Zumindest sollte der Benutzer von jeglichen SQL-Anfragen abgeschirmt werden.
Ausgefeilte Fehlerbehandlung ist nicht notwendig, die Webseite sollte sich aber keinesfalls "aufhängen" möglichen Nutzer-Aktionen.
Die meisten Interaktionen sollten Eingabewerte abfragen und mit einem Submit-Button versehen sein. Wann immer möglich, sollten diese Werte durch Menüs, Radio-Buttons, Checkboxen etc. erfasst werden. Text-Eingabefelder können ebenfalls angebracht sein.
Seid kreativ!
Die Interaktion mit der Datenbank kann über Java Servlets oder JSP mit JDBC umgesetzt werden.
Dieser Teil des Projektes wird am höchsten gewertet.
Die Dokumentation soll das Programmlisting (nur bei der elektronischen Version der Doku.), Screenshots und die URL unter der die Applikation zu testen ist, enthalten.

Teil 8: Indexierung

In Teil 5 werdet Ihr festgestellt haben, dass einige Queries auf der grossen Datenbank sehr langsam laufen. Wie in der VL besprochen, sind Indexe eine wichtige Technik, um die Performanz zu steigern.
Beachtet, dass Oracle automatisch auf jedem Schlüsselattribut einen Index anlegt, für Schlüsselattribute brauchen daher von euch keine Indexe angelegt werden.
Die gemessenen Zeiten sind natürlich abhängig von der Systemauslastung, jedoch solltet ihr bei einigen Queries bei richtig gewählten Indexen einen signifikaten Geschwindigkeitszuwachs verzeichnen können. Falls andere Queries keinen Performanz-Zuwachs aufweisen, fügt in die Dokumentation einen kurzen Abschnitt über mögliche Hintergründe ein.

Legt mindestens 3 sinnvolle Indexe für eure Projekt-Datenbank an.
Testet die Queries aus Teil 5 auf der Datenbank mit und ohne Indexe. Die Dokumentation sollte ein Skript enthalten, dss das Anlegen der Indexe dokumentiert und die relativen Zeiten der Query-Abarbeitung mit und ohne Indexe zeigt (Kommando: set timing on in sqlplus).

Teil 9: Transaktionen

Transaktionskontrolle in Oracle zu testen ergibt für euch das Problem, mehrere Nutzer und ihren Zugriff auf die Datenbank zu simulieren. Wir werden daher hier nur Experimente mit den Eigenschaften von der Transaktions-Befehle commit und rollback vorsehen.
Dokumentiert eine Session, in der ein oder mehrere Daten-Modifikationen vorgenommen werden und die Transaktion mit commit beendet wird. Führt vor und nach der Transaktion Kommandos auf der Datenbank aus, die die Veränderungen an der Datenbasis demonstrieren.
Zeigt nun eine Session, in der analoge Datentransformationen ausfgeführt werden, beendet die Transaktion aber mit rollback. Das Skript sollte zeigen, dass die Aktionen nicht ausgeführt worden sind.

Empfohlener Zeitplan

Der folgende Zeitplan ist eine Schätzung. Prinzipiell gilt, sich so früh wie möglich an die einzelnen Aufgaben zu setzen und bei Problemen nicht zu lange zu abzuwarten, sondern um Hilfe nachzufragen bei anderen Studierenden oder der/dem Betreuer(in).

Teil 1: Entwurf, bis 02.05.2005 (1. Meilenstein)
Teile 2-6: Entwurf in Oracle/Postgres, 07.06.2005 (2. Meilenstein)
Teil 7: Webanbindung, Mitte Juni bis Projektabgabe
Teil 8: Indexierung, Ende Juni
Teil 9: Transaktionen, Anfang Juli
Projektabgabe: 28.7.2005