SQL - Grundlagen und Datenbankdesign

SQL
Grundlagen und Datenbankdesi gn
SQL – Grundlagen und Datenbankdesign
Mirco De Roni, 2011
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Inhaltsverzeichnis
1
2
3
4
5
Datenbankgrundlagen ...................................................................................................... 5
1.1
Datenbankmodelle ....................................................................................................... 5
1.1.1
Hierarchische Datenbanken .................................................................................. 5
1.1.2
Netzwerkdatenbanken........................................................................................... 6
1.1.3
Relationale Datenbanken ...................................................................................... 6
1.1.4
Objektorientierte Datenbanken .............................................................................. 6
1.1.5
Objektrelationale Datenbanken ............................................................................. 7
1.2
Aufbau und Organisation einer Datenbank ................................................................... 7
1.2.1
3-Ebenen-Modell ................................................................................................... 7
1.2.2
Datenbankmanagementsystem (DBMS) ............................................................... 7
1.2.3
Weitere Komponenten des DBMS ......................................................................... 8
1.3
Physische Datenbankarchitektur .................................................................................. 9
1.3.1
Zentralisierte DBS ................................................................................................. 9
1.3.2
Verteilte DBS ........................................................................................................ 9
1.3.3
Client-Server DBS ............................................................................................... 10
1.3.4
Parallele DBS ...................................................................................................... 11
Der Datenbankentwurf ................................................................................................... 13
2.1
Einführung .................................................................................................................. 13
2.2
Der Datenbank-Lebenszyklus .................................................................................... 13
2.3
Der Datenbankentwurf ............................................................................................... 14
2.3.1
Die Entwurfsphasen ............................................................................................ 14
2.3.2
Abstraktionskonzepte .......................................................................................... 14
2.4
Das Entity-Relationship-Modell (ERM) ....................................................................... 15
2.4.1
Elemente und grafische Darstellung des ER-Modells .......................................... 15
2.4.2
Datenbankentwurf mit dem ER-Modell ................................................................ 17
Das relationale Datenmodell .......................................................................................... 18
3.1
Begriffe aus dem Bereich relationaler Datenbanken ................................................... 18
3.1.1
Relation ............................................................................................................... 18
3.1.2
Schlüssel............................................................................................................. 18
3.2
Transformation des ER-Modells in ein relationales Modell ......................................... 19
3.3
Normalisierung des Datenbankschemas .................................................................... 21
3.3.1
Probleme beim Ändern, Einfügen und Löschen von Datensätzen (Anomalien) ... 21
3.3.2
Abhängigkeiten ................................................................................................... 21
3.3.3
Der Normalisierungsprozess ............................................................................... 21
3.3.4
1. Normalform (1NF) ........................................................................................... 22
3.3.5
2. Normalform (2NF) ........................................................................................... 22
3.3.6
3. Normalform (3NF) ........................................................................................... 23
3.3.7
Weitere Normalformen ........................................................................................ 23
3.4
Theorie relationaler Sprachen .................................................................................... 24
Datenbanken ................................................................................................................... 25
4.1
Die Datenbankabfragesprache SQL ........................................................................... 25
4.2
Datenbank erstellen ................................................................................................... 25
4.3
Datenbank anzeigen und auswählen .......................................................................... 25
4.3.1
Datenbank anzeigen ........................................................................................... 25
4.3.2
Datenbank auswählen ......................................................................................... 26
4.4
Datenbank löschen .................................................................................................... 26
Tabellen erstellen und verwalten................................................................................... 27
5.1
Tabellen erstellen ....................................................................................................... 27
5.1.1
Einfache Tabellen erstellen ................................................................................. 27
5.1.2
Datentypen.......................................................................................................... 28
5.1.3
Integritätsregeln in Tabellen verwenden .............................................................. 29
5.2
Domänen verwenden ................................................................................................. 30
Mirco De Roni
-2-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
5.2.1
Domänen definieren ............................................................................................ 30
5.2.2
Domänen verwenden .......................................................................................... 30
5.2.3
Domänen ändern ................................................................................................ 31
5.2.4
Domänen löschen ............................................................................................... 31
5.3
Vorhandene Tabellen anzeigen, ändern und löschen ................................................. 31
5.3.1
Vorhandene Tabellen anzeigen ........................................................................... 31
5.3.2
Tabellenstruktur ändern ...................................................................................... 31
5.3.3
Tabellen löschen ................................................................................................. 32
6
Daten einfügen, aktualisieren und löschen .................................................................. 33
6.1
Daten einfügen ........................................................................................................... 33
6.1.1
Einfügen eines Datensatzes ................................................................................ 33
6.1.2
Einfügen mehrerer Datensätze ............................................................................ 33
6.2
Daten aktualisieren .................................................................................................... 33
6.3
Daten löschen ............................................................................................................ 34
7
Einfache Datenabfragen ................................................................................................. 35
7.1
Daten abfragen .......................................................................................................... 35
7.1.1
Einführung........................................................................................................... 35
7.1.2
SELECT-Anweisung verwenden ......................................................................... 35
7.1.3
Besondere Möglichkeit bei der Datenausgabe .................................................... 35
7.2
Bedingungen definieren ............................................................................................. 36
7.2.1
Einführung........................................................................................................... 36
7.2.2
Vergleichsoperatoren .......................................................................................... 36
7.2.3
Bereichsprüfung .................................................................................................. 36
7.2.4
Elementprüfung ................................................................................................... 36
7.2.5
Mustervergleich ................................................................................................... 37
7.2.6
Logische Operatoren ........................................................................................... 37
7.3
Abfrageergebnisse gruppieren ................................................................................... 37
7.4
Sortieren von Abfrageergebnissen ............................................................................. 37
8
Schlüsselfelder und Indizes ........................................................................................... 38
8.1
Einführung .................................................................................................................. 38
8.2
Primärschlüssel .......................................................................................................... 38
8.3
UNIQUE (Sekundärschlüssel) .................................................................................... 38
8.4
FOREIGN KEY (Fremdschlüssel)............................................................................... 38
8.5
Indizes........................................................................................................................ 39
9
Funktionen in Abfragen.................................................................................................. 40
9.1
Standard- und Nichtstandard-Funktionen ................................................................... 40
9.2
Standard-SQL-Funktionen.......................................................................................... 40
9.2.1
Aggregatfunktionen ............................................................................................. 40
9.2.2
Aggregatfunktionen mit Gruppierung verwenden ................................................. 41
9.3
Nicht standardisierte Funktionen ................................................................................ 41
9.3.1
Mathematische Funktionen ................................................................................. 41
9.3.2
Funktionen für Zeichenketten .............................................................................. 41
10 Datenabfrage über mehrere Tabellen ............................................................................ 42
10.1 Tabellen verknüpfen ................................................................................................... 42
10.1.1 Datenbestand in mehreren Tabellen ................................................................... 42
10.1.2 Verknüpfung von Tabellen über Mengenoperationen .......................................... 42
10.1.3 Verbund von Tabellen (Joins).............................................................................. 42
10.2 Einfaches Verknüpfen von Tabellen ........................................................................... 43
10.3 Tabellen verknüpfen mit JOIN .................................................................................... 43
10.3.1 Cross-Join ........................................................................................................... 43
10.3.2 Inner-Join (Equi-Join) .......................................................................................... 43
10.3.3 Natural-Join......................................................................................................... 44
10.3.4 Theta-Join ........................................................................................................... 44
10.3.5 Outer-Join ........................................................................................................... 44
10.3.6 Eine Tabelle mit sich selber verknüpfen (Self-Join) ............................................. 44
Mirco De Roni
-3-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
10.4 Zwei Tabellen vereinigen ........................................................................................... 44
10.5 Schnitt- und Differenzmengen .................................................................................... 45
11 Sichten ............................................................................................................................ 46
11.1 Vordefinierte Abfragen ............................................................................................... 46
11.2 Sichten erstellen......................................................................................................... 46
11.3 Sichten löschen .......................................................................................................... 47
11.4 Daten über Sichten einfügen und ändern ................................................................... 47
12 Transaktionsverwaltung................................................................................................. 48
12.1 Konsistente Datenbestände und Transaktionen ......................................................... 48
12.1.1 Transaktionen ..................................................................................................... 48
12.1.2 Isolationsebenen (Transaction Isolation Level) .................................................... 49
12.1.3 Das Transaktionsprotokoll ................................................................................... 49
12.2 Transaktionen erstellen .............................................................................................. 50
12.3 Transaktionen abschliessen ....................................................................................... 51
12.4 Transaktionen zurücksetzen....................................................................................... 51
12.5 Konkurrierende Zugriffe.............................................................................................. 52
12.5.1 Lost Updates ....................................................................................................... 52
12.5.2 Dirty Reads ......................................................................................................... 53
12.5.3 Nonrepeatable Reads ......................................................................................... 53
12.5.4 Phantome............................................................................................................ 54
12.6 Sperrmechanismen .................................................................................................... 54
12.6.1 Granularität ......................................................................................................... 54
12.6.2 Sperrtypen .......................................................................................................... 57
12.6.3 single-point-of-failure ........................................................................................... 58
13 Trigger ............................................................................................................................. 59
13.1 Prozeduren automatisch ausführen ............................................................................ 59
13.2 Trigger erstellen ......................................................................................................... 59
14 Fragen und Antworten ................................................................................................... 60
15 Glossar ............................................................................................................................ 62
15.1 Transaktionen, konkurrierende Zugriffe, Sperrmechanismen ..................................... 62
15.2 Verteilte DBS.............................................................................................................. 63
16 Quellenverzeichnis ......................................................................................................... 66
Mirco De Roni
-4-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
1
Datenbankgrundlagen
Ein DBS besteht aus einer Anzahl von Datenbanken und dem DBMS. Die Datenbank ist somit die
Sammlung von logisch zusammengehörenden Daten zu einem Sachgebiet. Das DBMS stellt die
Schnittstelle zwischen der Datenbank und deren Benutzern her. Es gewährt einen effizienten und
gezielten Zugriff auf die Daten und sorgt dabei für eine zentrale Steuerung und Kontrolle. Ausserdem wird
durch das DBMS ein Schutz gegen Hard- und Softwarefehler gewährleistet.
Programm zur
Lohn- und
Gehaltsrechn.
Programm zur
Personalverwaltung
Programm zur
Projektverwaltung
Datenbankmanagementsystem (DBMS)
Datenbanksystem
(DBS)
Datenbank (DB)
Eine Datenbank weist somit folgende Eigenschaften auf:
 In Datenbanken sind Daten entsprechend ihren natürlichen Zusammenhängen gespeichert.
Dabei ist es nicht entscheidend, in welcher Form die Daten in Anwendung benötigt werden. Die
Daten der Datenbank bilden einen Ausschnitt aus der realen Welt ab.
 Auf die Daten einer Datenbank können viele Benutzer gleichzeitig zugreifen. Das
Datenbankmanagementsystem verwaltet sowohl die Daten als auch die Zugriffe darauf und sorgt
dafür, dass dieselben Daten nicht gleichzeitig von mehreren Benutzern bearbeitet werden
können.
1.1
Datenbankmodelle
1.1.1
Hierarchische Datenbanken
Das hierarchische Datenmodell wurde entwickelt, um unterschiedlich lange Datensätze
(zusammengehörige Informationen, eine bestimmte Sache betreffend) zu verarbeiten. Die Datensätze
werden so aufgeteilt, dass gleichartige Daten zu kleineren Datengruppen zusammengefasst werden.
Diese Gruppe bilden die Knoten der Hierarchie. So entsteht eine baumartige Struktur, die streng
hierarchisch geordnet ist. Jeder untergeordnete Knoten ist von seinem übergeordneten Knoten abhängig.
Die Struktur entspricht einer Vater-Sohn-Beziehung. Ein Vater kann mehrere Söhne haben, ein Sohn
aber nur einen Vater. Die Struktur kann nicht ohne den Wurzelknoten existieren.
Mirco De Roni
-5-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
1.1.2
Netzwerkdatenbanken
Beim Netzwerkmodell werden gleichartige Daten in Recordsets gespeichert, die miteinander in
Beziehung stehen. Einem Record eines Recordsets können dabei mehrere Records eines anderen
Recordsets zugeordnet werden, was als Pfeil in der grafischen Darstellung erscheint. Durch diese
Beziehungen zwischen den Recordsets entsteht ein gerichteter Graph, der auch als Netzwerk bezeichnet
wird. Die Beziehungen werden hier als Sets (Mengen) bezeichnet. Die Sets sind in der Datenbank fest
definiert.
Beim Netzwerkmodell darf eine Beziehung zwischen zwei Recordsets immer nur in eine Richtung zeigen.
1.1.3
Relationale Datenbanken
Relationale Datenbanken sind am weitesten verbreitet. Die Daten werden in Tabellenform gespeichert, in
so genannten Relationen (mathematische Ausdrucksweise). Zwischen den Relationen (Tabellen) können
Beziehungen definiert werden. Es sind verschiedene Beziehungsarten möglich, die sich durch die Anzahl
der miteinander in Beziehung stehenden Datensätze (Tabellenzeilen, Tupel) unterscheiden (einer mit
einem 1:1, einer mit mehreren 1:n, mehrere mit mehreren n:m). Die grafische Darstellung der Relationen
und der zugehörigen Beziehungen erfolgt meist im Entity-Relationship-Modell (ERM). Die Beziehungen
werden dort durch Linien dargestellt, die mit den Kardinalitäten (1, n, m) versehen sind.
Über Abfragen ist es möglich, für die bestehenden Datenbanken unterschiedliche Auswertungen
durchzuführen. Für die Abfrage und Auswertung der Daten hat sich die Abfragesprache SQL
durchgesetzt.
Personen
Vorname
Mirco
Hans
PersNr
0001
0002
Name
De Roni
Richter
1.1.4
Objektorientierte Datenbanken
Ort
Littau
Luzern
Objektorientierte Datenbanken (OODB) sind nach dem Muster der objektorientierten
Programmiersprachen entwickelt worden. Das Ziel der Entwicklung der objektorientierten DBS war es,
ein DBS zu schaffen, in welchem Objekte unserer Umwelt mit ihren Eigenschaften und ihrem Verhalten
nachgebildet und ohne grossen Aufwand in einer Datenbank gespeichert und verwaltet werden können.
Jedes Objekt der Datenbank enthält Dateninformationen (Attribute), Verweise auf andere Objekte und
Operationen (Methoden), die das Verhalten des Objekts widerspiegeln. Diese Zusammenfassung von
Daten und Operationen über diese Daten wird als Kapselung bezeichnet. Die Definition der Objekte
(Daten, Verweise, Methoden) erfolgt über so genannte Klassen. Durch die freie Beschreibung von
Objekt-Klassen lassen sich selbst komplexeste Datenstrukturen in einer Datenbank verwalten, was in den
flachen Tabellen relationaler DBS nur über mehreren in Beziehung stehenden Tabellen möglich ist.
Neben der Kapselung von Daten und Operationen sind weitere objektorientierte Konzepte in OODBS
implementiert, wie z.B. die Vererbung, die Überladung von Methoden und dynamische Bindungen.
Mirco De Roni
-6-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
1.1.5
Objektrelationale Datenbanken
Objektrelationale Datenbanksysteme (ORDBS) wurden entwickelt, um die Nachteile relationaler DBS zu
beseitigen. Solche Nachteile sind z.B. das „magere“ Typsystem von relationalen DBS (umfangreiche
Texte, Excel-Tabellen, XML-Dokumente, Audiodaten usw. können nur mit erhöhtem Aufwand oder gar
nicht in der DB gespeichert werden) und Probleme bei der Abbildung der Objekte der realen Welt auf das
relationale Modell, was als „impedance mismatch“ bezeichnet wird. Das Ziel der Entwicklung war es,
die Vorteile der Speicherung komplexer Objekte wie im OODBS zu nutzen und dabei die einheitliche
Abfragesprache SQL beizubehalten. Es sollten also die Vorteile des relationalen und des
objektorientierten Modells in dem neuen DB-Modell vereinigt werden.
ORDBS werden heute vorrangig im Multimedia-Bereich eingesetzt.
1.2
Aufbau und Organisation einer Datenbank
Eines der wichtigsten Ziele, welches ein DBS realisieren muss, ist die Datenunabhängigkeit. Diese wird
durch die Trennung der physischen Speicherung der Daten und deren Verwaltung von den
Anwendungsprogrammen erreicht.
1.2.1
3-Ebenen-Modell
Am 3-Ebenen-Modell nach ANSI-SPARC 1978 (American National Standards Institute/Standards
Planning und Requirements Committee) werden die unterschiedlichen Sichtweisen auf einen
Datenbestand dargestellt.
Eine Sicht ist ein Ausschnitt einer Datenbank, der die für eine Anwendung bzw. ein Problem relevanten
Daten enthält.
1.2.2
Datenbankmanagementsystem (DBMS)
Das DBMS ist ein Softwarepaket, welches die Verwaltung der Datenbank übernimmt und alle Zugriffe
darauf regelt.
Es ermöglicht dabei:
 das Anlegen von Datenbanken
 die Speicherung, Änderung und Löschung der Daten
 das Abfragen der Datenbank
 eine Verwaltung von Benutzern, Zugriffen und Zugriffsrechten
Mirco De Roni
-7-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Bearbeitung einer Datenbankabfrage
1. Eine Anfrage wird an das DBMS gestellt.
2. Der Befehl wird analysiert, und die zugehörige
externe Sicht wird ermittelt.
3. Über die Transformationsregeln wird das
konzeptionelle Schema ermittelt.
4. Über Transformationsregeln wird das interne
Schema ermittelt.
5. Ein Teil der Daten wird im Systempuffer
gehalten. Das DBMS prüft, ob sich die
angeforderten Daten im Systempuffer befinden.
6. Sind die Daten nicht im Systempuffer, müssen
sie über das Betriebssystem dorthin geladen
werden.
7. Das Betriebssystem tauscht die vorhandenen
Daten durch die angeforderten Daten aus und
speichert gegebenenfalls geänderte Daten in der
Datenbank.
8. Das Betriebssystem informiert das DBMS über
die Bereitschaft der angeforderten Daten.
9. Die gewünschten Daten werden über die
Transformationsregeln in das Format der
betreffenden Sicht umgewandelt
10. wie 9.
11. Das DBMS übergibt die angeforderten Daten und die Statusinformationen an die Anwendung.
Durch das DBMS wird dabei noch eine Reihe von weiteren Aufgaben ausgeführt:
 Integrität
 Datensicherung (Recovery)
 Synchronisation
 Datenschutz
1.2.3


Weitere Komponenten des DBMS
Data Dictionary / Repositories
Das Data Dictionary (Datenlexikon) dient der Speicherung von Informationen über die Daten der
Datenbank und deren Verwaltung. Es werden darin beispielsweise das Datenbank-Schema, die
Sichten und die Zugriffsrechte auf die Datenbank abgelegt. Der Anwender kann über das
Dictionary Informationen über die Datenbank erhalten und die Leistungsanalysen durchführen
lassen.
Logbuch
Datenbanksysteme verfügen über ein Logbuch, in welchen Informationen über die
Transaktionsvorgängen verzeichnet sind, wie beispielsweise der Beginn und das Ende der
Transaktion und deren Zustand der Daten zu Beginn der Transaktion.
Grössere Datenbanksysteme bieten meist noch zusätzliche Komponenten, die den Anwender bzw. den
Anwendungsprogrammierer bei seiner Arbeit unterstützen:
Entwurfswerkzeuge zum
Datenbank-Entwurf
Abfrage-Generatoren
Report-Generatoren
Tools zur Erstellung von
Business-Grafiken
CASE-Werkzeuge
Mirco De Roni
Entwurfswerkzeuge zum Datenbank-Entwurf unterstützen den
Anwender beim Entwurf der Datenbank, sodass er nicht auf die
Anwendung der Datendefinitionssprache (DDL) angewiesen ist
Abfrage-Generatoren ermöglichen dem Anwender das Erzeugen von
Datenbank-Abfragen auch ohne Kenntnisse der DatenbankAbfragesprache (DQL/ DML).
Report-Generatoren erzeugen Berichte über Datenbankinhalte in den
verschiedensten Formen (z.B. Tabellen mit Kopf- und Fusszeilen und
Zwischensummen).
Tools zur Erstellung von Business-Grafiken ermöglichen die grafische
Darstellung von Daten der Datenbank in Diagramm-Form.
CASE-Werkzeuge (Computer Aided Software Engineering) dienen dem
-8-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Utilities zur Fehleranalyse
Funktionen zur
Komprimierung und
Reorganisation der
Datenbank
Archivierungsfunktionen
1.3
Entwurf von Datenbank-Anwendungen, wobei der Quellcode der
Anwendung automatisch generiert wird.
Utilities zur Fehleranalyse helfen dem Anwender, Fehler in der
Datenbankstruktur aufzufinden und zu beseitigen.
Funktionen zur Komprimierung und Reorganisation der Datenbank sind
notwendig, wenn häufig Daten gelöscht und geändert wurden, da nicht
mehr benötigter Speicherplatz nicht automatisch freigegeben wird. Bei
der Ausführung der Funktionen wird die Datenbank reorganisiert und
nicht benötigter Speicher freigegeben.
Archivierungsfunktionen werden für das Kopieren und Archivieren von
Datenbeständen der Datenbank eingesetzt.
Physische Datenbankarchitektur
Die physischen Konzepte der Architektur von DBS ergeben sich aus dem logischen Konzept der
Datenbank-Entwicklung (3-Ebenen-Architektur) in Verbindung mit der Rechnerumgebung.
1.3.1
Zentralisierte DBS
In einem zentralisierten DBS werden das gesamte DBMS und
die Anwendungen auf einem Rechner abgelegt, der als zentraler
Verwaltungsrechner bzw. Zentralrechner (auch Host oder
Mainframe) bezeichnet wird. An den anderen Standorten befinden
sich „dumme“ Terminals, die nur der Ein- und Ausgabe dienen
(wenig eigene Funktionalität). Von diesen Terminals aus haben
alle Benutzer die gleichen Sichten auf die Datenbank, die von den
auf dem Zentralrechner laufenden Anwendungen erzeugt wird.
Die Datenbank eines zentralisierten DBS ist im Vergleich zu
verteilten Datenbanken relativ einfach zu administrieren.
In modernen Rechnernetzen werden als Endgeräte „intelligente“
Arbeitsplatzrechner eingesetzt.
1.3.2
Verteilte DBS
Verteilte Datenbanken sind eine Menge von mehreren logisch
zusammengehörigen (Teil-) Datenbanken, die in einem Netz auf
mehreren lokal getrennten Computern (z.B. in verschiedenen
Städten) gespeichert sind. Ein verteiltes DBMS besitzt
Mechanismen zur Zusammenführung und Abfrage der verteilten
Datenbanken. Durch das DBMS wird die Verteilung der Daten
vor dem Anwender verborgen. Dem Benutzer erscheint es wie
ein zentralisiertes DBS, da er nur auf der externen Ebene
arbeitet.
Verteilte DBS haben im Vergleich zu zentralisierten DBS
entscheidende Vorteile:
 Lokale Autonomie
 Zuverlässigkeit und Verfügbarkeit
 Leistung
 Erweiterbarkeit
Die Anwendung verteilter DBS bringt aber auch Nachteile mit sich:
 Mangel an praktischer Erfahrung
 Komplexität
 Dezentrale Verwaltung
 Sicherheit
 Kosten
 Übergang von zentralisierten auf verteilte DBS
Mirco De Roni
-9-
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Komponenten eines verteilten Datenbanksystems
Ein verteiltes Datenbanksystem wird von einem Distributed Data Management System (DDBMS)
verwaltet. Das DDBMS steuert sowohl die verteilte Datenverarbeitung als auch die verteilte Datenhaltung
der verteilten Datenbank.
DDBMS muss in der Lage sein:
 zu erkennen, welche Teile der DB-Abfrage lokal bearbeitet werden können und welche über das
Netzwerk ausgeführt werden müssen.
 Optimierung der Datenbankabfrage durchführen, um den optimalen Zugriffsweg zu ermitteln.
 physikalische Standorte der Daten ermitteln und herausfinden, ob die Daten auf dem lokalen
Server gespeichert sind oder auf einem entfernten System,
 Sicherheitsfunktionen implementiert
 Backup and Recovery
Das DDBMS sorgt dafür, dass eine verteilte Datenbank, die sich aus mehreren Fragmenten
zusammensetzt, für einen Client wie eine einzige logische Datenbank aussieht.
Vollständig verteiltes Datenbanksystem
Die Verteilung eines Datenbanksystems kann unter verschiedenen Aspekten erfolgen:
 Ein DBS kann homogen verteilt sein, d.h. logisch zusammengehörige Datenbanken werden auf
verschiedene Orte verteilt. Sie werden von derselben Datenbanksoftware verwaltet.
 Sollen unterschiedliche Datenbanken, z.B. aus verschiedenen Unternehmen,
Unternehmensteilen oder Abteilungen, zusammen verwaltet und soll auf die Daten mehrerer
unterschiedlicher Datenbanken gleichzeitig zugegriffen werden, ist das DBS heterogen verteilt.
Die Datenbanken können auch verschiedene Datenmodelle besitzen. Heterogen verteilte DBS
werden auch als Multidatenbanksysteme (MDBS) bezeichnet.
 Ein weiterer Punkt, nach dem eine Unterscheidung von verteilten DBS möglich ist, ist die
Verwendung replizierten Daten (dieselben Daten befinden sich an verschiedenen Stellen und
werden laufend abgeglichen).
Homogene Verteilung
In der konzeptionellen Ebene findet eine Aufteilung des konzeptionellen Schemas statt. Es wird ein
gemeinsames konzeptionelles Schema für die gesamte Datenbank erstellt, auf dem die externen Sichten
beruhen. Das Gesamtschema wird in lokale konzeptionelle Schemen unterteilt, für jede lokale Datenbank
ein Schema. Für jedes lokale konzeptionelle Schema existiert dann ein lokales internes Schema.
Heterogene Verteilung
Die Daten aus den lokalen Schemen müssen zunächst in ein gemeinsames Datenbankschema
transformiert werden. Ein transformiertes lokales Schema wird im Komponenten-Schema gespeichert.
Die Daten aus den Komponenten-Schemen werden aufgeteilt und in den Exportschemen abgelegt. Ein
Exportschema kann sich aus Teilen eines oder mehrerer Komponenten-Schemen zusammensetzen. Die
Exportschemen werden wiederum im gemeinsamen globalen Schema abgebildet.
1.3.3
Client-Server DBS
Die meisten heutigen DBS arbeiten nach dem Client-Server-Konzept. Es realisiert ein funktional verteiltes
System, in dem zwei unabhängige Prozesse über eine definierte Schnittstelle miteinander kommunizieren
– der Server und der Client. Die Kommunikation erfolgt über einen Anforderungs-Antwort-Dialog. Der
Client stellt eine Anforderung an den Server, der Server bearbeitet die Anforderungen und gibt die
gewünschte Antwort an den Client zurück. Der Server stellt also die Dienstleistungen zur Verfügung und
der Client nimmt sie in Anspruch. Häufig werden die Dienste eines Servers von mehreren Clients auch
gleichzeitig genutzt.
Mirco De Roni
- 10 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Die Initiative geht hierbei immer vom Client aus, der Server verharrt so lange in Warteposition, bis
ein Client seine Anforderungen sendet.


1.3.4
Client und Server können sich physisch sowohl auf dem gleichen Rechner befinden als auch auf
verschiedenen Rechnern, die über ein Netzwerk verbunden sind.
Ein Rechner (bzw. ein Programm) kann sowohl als Client als auch als Server arbeiten. Es ist von
der momentanen Tätigkeit abhängig, ob gerade ein Dienst in Anspruch genommen oder
bereitgestellt wird.
Parallele DBS
Parallele Datenbanksysteme laufen auf Multiprozessorsystemen oder Parallelrechnern und nutzen
gleichzeitig die Leistung mehrerer Prozessoren. Damit werden eine Leistungssteigerung und eine
Verkürzung der Bearbeitungszeit bei Datenbank-Anfragen und Transaktionen erreicht. Bei grossen
Datenbanken mit vielen Benutzern verursacht die sequenzielle Verarbeitung von Abfragen zum Teil
inakzeptable Antwortzeiten.
Unter einem parallelen DBS ist nicht zu verstehen, dass mehrere Benutzer gleichzeitig Anfragen an ein
DBMS richten können und diese Anfragen dann zeitlich versetzt, aber gewissermassen parallel
abgearbeitet werden.
In einem parallelen System sind mehrere Prozessoren, Platten- und Hauptspeicher über eine sehr
schnelle Leitung (Hochgeschwindigkeitsnetz) miteinander verbunden. Die Arbeitsweise paralleler
Datenbanksysteme hängt von der konkreten Rechnerarchitektur ab, die grundsätzliche Arbeitsweise ist
aber die gleiche.


Die Daten werden auf die verfügbaren Platten verteilt.
Datenbank-Abfragen und Transaktionen werden so zerlegt, dass sie auf mehreren Prozessoren
gleichzeitig abgearbeitet werden können.
Prinzipiell gibt es drei verschiedene Architekturtypen für parallele Systeme:
Shared-Memory-Architektur (Shared-Everything-Architektur)
Alle Prozessoren des Systems können auf
den gemeinsamen Speicher zugreifen und
über diesen kommunizieren. Die für die
Ausführung einer Datenbank-Operation
benötigten Daten werden von den
ausführenden Prozessoren über das
Netzwerk angefordert und im Speicher
bereitgestellt.
Shared-Nothing-Architektur
Jedem Prozessor sind eigene
Speichermedien (Haupt- und
Plattenspeicher) zugeordnet, auf die er
exklusiv zugreift. Bei diesem System verfügt
jeder Prozessor über eine Kopie des DBMS.
Eine wichtige Arbeitsweise dieser
Architekturform ist das Weitergeben von
Funktionen an einen anderen nicht
ausgelasteten Prozessor.
Mirco De Roni
- 11 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbankgrundlagen
_____________________________________________________________________________________________
Shared-Disk-Architektur
Die Hauptspeicher sind den Prozessoren
lokal zugeordnet, die Plattenspeicher werden
aber gemeinsam genutzt. Die Arbeitsweise
ist ähnlich wie bei der Shared-NothingArchitektur. Die Daten werden aber wie bei
der Shared-Memory-Architektur über das
Netzwerk angefordert.
Mirco De Roni
- 12 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Der Datenbankentwurf
_____________________________________________________________________________________________
2
Der Datenbankentwurf
2.1



Einführung
Welche logische Struktur soll die Datenbank haben, d.h., welche Sichten werden auf die
Datenbank benötigt, und wie können diese in einem gemeinsamen Schema zusammengefasst
werden?
Wie soll die physische Struktur der Datenbank aussehen, d.h., in welcher Form werden die
Daten gespeichert und wie soll darauf zugegriffen werden?
Welche zusätzlichen Bedingungen müssen eingehalten werden, d.h., gibt es von Seiten der
Anwendungen Bedingungen, Einschränkungen usw.?
Der Entwurf erfolgt nach dem 3-Ebenen-Modell. Es müssen also die Schemen für die externe, die
konzeptionelle und die interne Ebene dargestellt werden.
2.2
Der Datenbank-Lebenszyklus
Die Analyse der Anforderungen grenzt die Inhalte der neuen
Datenbank ein und dient der Festlegung der Benutzergruppen und
Anwendungen. Dabei werden die Datenobjekte, deren Eigenschaften
und Beziehungen sowie mögliche Vorgänge (Aktualisierungen,
Abfragen) und Randbedingungen ermittelt. Das Resultat der
Anforderungsanalyse ist die Anforderungsspezifikation.
Der konzeptionelle Entwurf umfasst die Modellierung der Sichten und
die Integration der Sichten in ein Gesamtschema. Dafür werden meist
Entity-Relationship-Diagramme erstellt.
Diese grafische Darstellungen werden in der Phase des logischen
Entwurfs in das Datenmodell des Ziel-DBS (z.B. in das relationale
Datenmodell) transformiert und die gesamte Datenbank wird so
aufbereitet, dass eine effektive Speicherung möglich ist (das
Datenbankschema wird normalisiert).
Bei verteilten Datenbanken ist ein Entwurf für die Verteilung der
Datenbanken im Netz erforderlich.
Nun kann die Datenbank mithilfe der Sprachmittel des DBMS erstellt
und die benötigten Anfragen können formuliert werden, was als
physischer Entwurf bzw. Implementierung bezeichnet wird.
Die Datenbank und die erstellten Abfragen werden nun getestet und die Ergebnisse werden auf ihre
Gültigkeit bezüglich der Anforderungen geprüft (validiert). So wird die Sicherung der Datenbank-Qualität
gewährleistet.
In der Phase der Anwendung muss die Datenbank ständig gewartet werden. Im Laufe dieser Zeit
können sich Änderungen des Datenbank-Schemas ergeben. In diesem Fall ist eine Reorganisation der
Datenbank notwendig.
Mirco De Roni
- 13 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Der Datenbankentwurf
_____________________________________________________________________________________________
2.3
Der Datenbankentwurf
Bei der Modellierung des Ausschnitts aus der realen Welt (des konzeptionellen Schemas) ist besonders
auf Vollständigkeit und Korrektheit, Minimalität und Modifizierbarkeit zu achten.
2.3.1
Die Entwurfsphasen
Der Entwurf der Datenbank beginnt bei der Analyse der Anforderungen und ist mit dem physischen
Entwurf der Datenbank abgeschlossen.





2.3.2
Anforderungsanalyse
Konzeptioneller Entwurf
Logischer Entwurf
Verfeinerung des logischen Entwurfs
Physischer Entwurf / Implementierung
Abstraktionskonzepte
Bei der Erstellung eines Datenmodells werden die Objekte und deren Eigenschaften untersucht. Es
werden zuerst alle Daten (Objekte) gesammelt. In einem Prozess der Abstraktion werden dann
gleichartige Mengen von Objekten zusammengefasst und auf relevante Eigenschaften untersucht.





Klassifikation
Gleichartige Dinge (Objekte) mit gemeinsamen Eigenschaften werden zu Klassen
zusammengefasst.
Aggregation
Eine neue Klasse wird aus anderen, bereits existierenden Klassen zusammengesetzt bzw.
besteht zum Teil aus Objekten anderer Klassen.
Generalisierung (Verallgemeinerung)
Zwischen bestimmten Klassen wird eine Teilmengenbeziehung hergestellt. Dabei stellt eine
Klasse eine Verallgemeinerung der anderen Klassen dar. Die Eigenschaften der
verallgemeinerten Klasse werden auf die Klassen, die Teilmengen dieser Klasse sind, vererbt.
Assoziation
Objekte bzw. Klassen können miteinander in Beziehung gesetzt (assoziiert) werden. Diese
Beziehung kann zwischen zwei oder mehr Objekten aufgebaut werden.
Identifikation
Eigenschafswerte bzw. Kombinationen von Eigenschaftswerten der Objekte werden als
Schlüssel definiert und dienen der eindeutigen Identifizierung des Objekts. Über diese Schlüssel
werden die Objekte assoziiert.
Mirco De Roni
- 14 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Der Datenbankentwurf
_____________________________________________________________________________________________
2.4
Das Entity-Relationship-Modell (ERM)
Das Entity-Relationship-Modell (ER-Modell oder ERM) ist das bekannteste und meistverwendete
grafische Hilfsmittel für den Datenbankentwurf. Das ER-Modell ermöglicht es, die konzeptionellen
Entwürfe einer Datenbank auf leicht verständliche Art grafisch darzustellen und die Abstraktionskonzepte
anzuwenden. Die zwei Grundbausteine des ER-Modells sind die Entities (Entitäten) und die
Relationships (Beziehungen). Entities und Relationships haben Attribute. Es können beliebig viele
Objekte einer Entitätsmenge und einer Beziehungsmenge existieren.
2.4.1
Elemente und grafische Darstellung des ER-Modells
Entität (Entity), Entitätsmenge (Entity-Set), Entity-Typ
Als Entität (Entity) werden unterscheidbare (identifizierbare) Dinge aus der realen Welt bezeichnet. Dies
können Personen, Gegenstände, Firmen usw. sein. Entitäten unterscheiden sich voneinander durch ihre
jeweiligen Eigenschaften bzw. Eigenschaftswerten. Eine Entität wird synonym als Objekt bezeichnet.
Eine Entitätsmenge (Entity-Set) ist eine Sammlung von gleichartigen Entitäten, d.h. von Entitäten mit
gleichen Eigenschaften, aber unterschiedlichen Eigenschaftswerten, zu einem bestimmten Zeitpunkt.
Entitäten einer Entitätsmenge gehören zu einem bestimmten Entity-Typ. Entitätsmengen sind zeitlich
veränderlich.
Der Entity-Typ kategorisiert gleichartige Entitäten. Zu einem Entity-Typ gehören Entitäten, die sich durch
die gleichen Eigenschaften (Attribute) beschreiben lassen. Entity-Typen werden in Form von Rechtecken
dargestellt.
Attribute (Eigenschaften), Domänen
Attribute bzw. Eigenschaften charakterisieren eine Entität, einen Entity-Typ, eine Beziehung bzw. einen
Beziehungstyp. Die Attribute besitzen einen Namen und einen Wert (Value).
Bei den Attributen wird zwischen beschreibenden Attributen (den anwendungsspezifischen
Eigenschaften) und identifizierenden Attributen (den Schlüsseln zur eindeutigen Identifikation einer Entität
in der Entitätsmenge) unterschieden.
Eine Domäne beschreibt den zulässigen Wertebereich einer Eigenschaft. Das können fest vorgegebene
Werte sein (z.B. Januar, Februar…), Bereiche (z.B. von 0 bis 999, von A bis G) oder Mengenangaben
bzw. Datentypangaben (z.B. natürliche Zahl, reelle Zahl, Datum).
Schlüssel und Primärschlüssel
Ein Schlüssel setzt sich aus einem oder mehreren Attributen zusammen. Sie sollten so kurz wie möglich
(Minimalitätsanforderung), aber so lange wie nötig sein. Ist unter den vorhandenen Attributen und
Attributkombinationen keine, die als Schlüssel eingesetzt werden kann, wird ein künstliches Attribut (z.B.
ein Zählfeld) hinzugefügt. Dieses bekommt für jede Entität einen anderen Wert und wird als Schlüssel
eingesetzt.
Der Primärschlüssel ermöglicht die eindeutige Identifizierung einer Entität einer Entitätsmenge dadurch,
dass sein Wert in einer Entitätsmenge nur ein einziges Mal vorkommt. Ein Entity-Typ kann mehrere
Schlüssel besitzen, die für bestimmte Abfragen oder Sortierungen benötigt werden.
In der grafischen Darstellung werden Primärschlüssel durch unterstrichene Attribute dargestellt.
Beziehung (Relationship), Beziehungsmenge und –typ, Kardinalität (Komplexität)
Durch Beziehungen werden die Wechselwirkungen oder Abhängigkeiten von Entitäten ausgedrückt.
Beziehungen können Eigenschaften besitzen.
Eine Beziehungsmenge (Assoziation) ist eine Sammlung von Beziehungen gleicher Art zur Verknüpfung
von Entitätsmengen (Tabellen).
Ein Beziehungstyp ist, analog zum Entity-Typ, die Abstraktion gleichartiger Beziehungen.
Ein Beziehungstyp wird grafisch durch eine Raute dargestellt, die durch zwei Kanten mit den EntityTypen verbunden ist, die assoziiert werden sollen. In der Raute kann der Name des Beziehungstyp
stehen.
Mirco De Roni
- 15 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Der Datenbankentwurf
_____________________________________________________________________________________________
Beziehungen können durch Attribute beschrieben werden, beispielsweise in welcher Tätigkeit ein
Mitarbeiter an einem Projekt mitarbeitet und zu wie viel Prozent.
Die Anzahl der an einer Beziehung beteiligten Entities wird als Grad der Beziehung bezeichnet.
Folgende Beziehungsgrade sind möglich:
 Binär, wenn genau zwei Entities miteinander verbunden sind
 Ternär, wenn genau drei Entities miteinander verbunden sind
 n-är, wenn mehrere, d.h. genau n Entities miteinander verbunden sind
 Rekursiv binär, wenn ein Entity mit sich selbst in Beziehung steht
Über die Kardinalität wird festgelegt, wie viele Entitäten einer Entitätsmenge mit Entitäten einer anderen
Entitätsmenge in Beziehung stehen können.


1
n, m
-
genau eine Zuordnung
eine oder mehrere Zuordnungen
In erweiterter Form sind auch die folgenden Angaben zulässig:
 c
keine oder eine Zuordnung
 cn
keine oder mehrere Zuordnungen
1 : 1 – eins-zu-eins-Beziehung
1 : n – eins-zu-n-Beziehung
n : m – n-zu-m-Beziehung
Jede Entität einer Entitätsmenge ist genau einer Entität einer
anderen Entitätsmenge zugeordnet.
Jede Entität einer Entitätsmenge ist einer oder mehreren Entitäten
einer anderen Entitätsmenge zugeordnet.
Eine oder mehrere Entitäten einer Entitätsmenge können einer oder
mehreren Entitäten einer anderen Entitätsmenge zugeordnet
werden.
Rekursive Beziehungen entstehen, wenn ein Entity-Typ eine
Assoziation auf sich selbst besitzt (rekursiv binäre Beziehung).
Beispielsweise kann eine rekursive Beziehung zwischen
Bauteilen bestehen, die wiederum aus anderen Bauteilen
zusammengesetzt werden, oder zwischen Personen, die mit
einer anderen Person verheiratet sind.
Das Konzept der Aggregation wird durch eine Part-ofBeziehung (Ist-Teil-von-Beziehung) ausgedrückt (n-äre
Beziehung).
Beispielsweise besteht ein Computer aus einem oder mehreren
Prozessoren, Laufwerken, einem Gehäuse usw.
Mirco De Roni
- 16 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Der Datenbankentwurf
_____________________________________________________________________________________________
Is-a-Beziehungen drücken eine Generalisierung (Verallgemeinerung) oder Spezialisierung aus, d.h., sie
stellen eine Teilmengenbeziehung dar.
Eine Is-a-Beziehung kann folgende Eigenschaften besitzen:
Sie ist entweder disjunkt oder nicht disjunkt.
Disjunkt
Alle Teilmengen sind echte
Teilmengen, kein Element
der einen Teilmenge kommt
in einer anderen Teilmenge
vor.
Nicht disjunkt
Die Teilmengen können
gemeinsame Elemente
enthalten.
Sie ist entweder total oder partiell.
Total
Es gibt keine weitere
Teilmenge zu dieser
Spezialisierung.
Partiell
Es gibt weitere Teilmengen,
die aber nicht aufgeführt
sind.
2.4.2
Datenbankentwurf mit dem ER-Modell
Ist die Anforderungsanalyse abgeschlossen, können Sie das konzeptionelle Schema der Datenbank mit
dem ER-Modell entwerfen. Bei der Top-Down-Methode wird das grob entworfene Modell schrittweise
verfeinert. Diese Verfeinerung wird auf die Entitäten, die Attribute und Beziehungen angewendet. Dabei
werden beispielsweise Entity-Typen und Beziehungstypen zerlegt bzw. zusammengefügt,
Spezialisierungen bzw. Generalisierungen und Aggregationen aufgebaut und Attribute sowie Schlüssel
festgelegt.
Mirco De Roni
- 17 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
3
Das relationale Datenmodell
3.1
Begriffe aus dem Bereich relationaler Datenbanken
Eine Datenbank besteht im relationalen Modell aus einer Menge von Relationen, in denen die logisch
zusammengehörenden Daten gespeichert werden.
3.1.1
Relation
Eine Relation ist im Sinne einer relationalen Datenbank eine Menge von Tupeln (Datensätzen). Sie hat
die Form einer Tabelle und ist damit eine Konstruktion aus Spalten und Zeilen. Sowohl Entitäten als auch
Beziehungen des Entity-Relationship-Modells werden als Relationen modelliert. Datenbanktechnisch
bezieht sich also eine Relation nicht auf die Beziehung (Verknüpfung) zwischen Tabellen. In einer
Relation werden die Daten gespeichert. Diese Daten stellen die Informationen dar, die Sie verwalten
wollen.
Eine Relation ist gekennzeichnet durch
 einen eindeutigen Namen (z.B. Kunde)
 mehrere Attribute (Spalten)
 keine bis beliebig viele Tupeln (Tabellenzeilen oder Datensätze)
 einen einzigen Wert pro Attribut in einem Tupel (Tabellenzelle)
 einen Primärschlüssel, bestehend aus einem oder mehreren Attributen
o Dieser identifiziert jedes Tupel eindeutig.
o Dessen Wert ändert sich während der Existenz des Datensatzes nicht.
Attribute und Tupel
Eine Tabelle besteht aus Spalten und Zeilen. Bei relationalen Datenbanken werden die Spalten Attribute
oder auch Felder genannt. Die Zeilen der Tabelle werden als Tupel oder Datensätze bezeichnet.
Der Inhalt der Tupel muss wegen der Mengendefinition der Relation immer unterschiedlich sein, d.h., es
gibt keine zwei Tupel, die exakt gleich sind; sie unterscheiden sich in mindestens einem Attributwert
(mindestens in dem Primärschlüssel).
Der Aufbau einer Relation wird auch die Struktur oder das Schema der Tabelle genannt.
Datentypen
Jedem Attribut wird ein bestimmter Datentyp zugeordnet. Meist stehen verschiedene Zahlentypen,
Zeichenketten (Text) und Datumstypen zur Verfügung. Der Datentyp bildet den Wertebereich (die
Domain) des Attributs.
Nullwerte oder leere Einträge
Nullwerte entsprechen keinem Datentyp, sondern sind nur symbolische Werte und sind nicht dem
numerischen Wert null gleichzusetzen. Ein Nullwert ist ein Indikatorbyte, das angibt, ob in einem Tupel für
ein Attribut ein Wert eingetragen wurde oder nicht.
3.1.2
Schlüssel
Jede Relation kann nur einen Primärschlüssel besitzen.
Ein Primärschlüssel einer Tabelle kann ein Attribut oder eine Attributkombination sein, deren Werte die
Datensätze dieser Tabelle eindeutig identifizieren. Alle Attribute bzw. Attributkombinationen, deren Werte
eindeutig sind, werden als Schlüsselkandidaten bezeichnet. Nur ein Schlüsselkandidat kann als
Primärschlüssel festgelegt werden. Wenn eine Tabelle keine eindeutigen Datenfelder besitzt, sollte eine
eindeutige ID-Nummer (Identifikationsnummer) als Schlüssel vergeben werden, beispielsweise eine
Kundennummer für eine Relation Kunden.
Fremdschlüssel
Ein Fremdschlüssel ist ein Attribut in einer Relation, welches eine Beziehung zu einem Schlüsselfeld
einer anderen Relation herstellt. Beispielsweise befindet sich in einer Relation Aufträge in jedem Tupel
eine Kundennummer des Kunden, der den Aufrag ausgelöst hat. Diese Kundennummer identifiziert einen
Mirco De Roni
- 18 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
Kunden in der Kundenrelation eindeutig. Die Kundennummer in der Auftragstabelle stellt somit einen
Fremdschlüssel einer anderen Relation dar.
Index
Um den Zugriff auf die Daten zu beschleunigen, können zusätzlich zum Primärschlüssel weitere Indizes
angelegt werden, die auch als Sekundärindizes bezeichnet werden.
3.2
Transformation des ER-Modells in ein relationales Modell
Das folgende ER-Modell soll in ein relationales Modell überführt werden.
Die Anzahl der Relationen, die aus dem ER-Modell erzeugt werden, hängt von den definierten
Entitätsmengen und den Beziehungstypen zwischen den Entitätsmengen ab.
Entitätsmengen
Für jede Entitätsmenge wird eine Relation erstellt, welche für jedes Attribut eine Spalte besitzt. Die
Primärschlüssel werden übernommen.
Abteilung
Attribut
Datentyp
AbteilungsNr
Zahl
Bezeichnung
Text
Attribut
PersonalNr
Name
Vorname
Anschrift
Attribut
ProjektNr
Beschreibung
Mitarbeiter
Datentyp
Zahl
Text
Text
Text
Projekte
Datentyp
Zahl
Text
1:1- und 1:n-Beziehungen
Für die Umsetzung der beiden Beziehungstypen gibt es folgende Möglichkeit:
 Es wird eine neue Relation erzeugt, welche als Attribute (Spalten) die Primärschlüssel der beiden
Relationen, die in Beziehung stehen, enthält. Ausserdem kann die Relation beschreibende
Attribute in einer zusätzlichen Spalte aufnehmen.
Diese Darstellungsform hat den Vorteil, dass keine Nullwerte auftreten und den Nachteil, dass
eine weitere Relation benötigt wird.
besteht_aus
Attribut
Datentyp
PersonalNr
Zahl
AbteilungsNr
Zahl
Position
Text
Mirco De Roni
- 19 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
m:n-Beziehungen
Bei einer m:n-Beziehung ist immer eine zusätzliche Relation erforderlich, um die betreffenden Entitäten
zu verknüpfen. Diese Relation enthält die Primärschlüssel der beiden Relationen und kann zusätzlich
noch beschreibende Attribute enthalten.
Attribut
PersonalNr
ProjektNr
Tätigkeit
prozAnteil
arbeitet_an
Datentyp
Zahl
Zahl
Text
Zahl
Generalisierung/Spezialisierung (is-a-Beziehungen)
Für die Überführung einer is-a-Beziehung gibt es mehrere Möglichkeiten, die von dem jeweiligen Schema
und von der Umgebung (dem Kontext) abhängig sind. In jedem Fall ist aber keine zusätzliche Relation für
die Beziehung nötig:
 Es wird für jede Entitätsmenge eine
Relation mit den relevanten Attributen
angelegt. Den Teilmengen
(Spezialisierungen) wird der
Primärschlüssel der Obermenge
(Generalisierung) als Fremdschlüssel
hinzugefügt, um die Zuordnung zu sichern.
Attribut
PersonalNr
Name
Vorname
Anschrift
GebDatum
Personal
Datentyp
Zahl
Text
Text
Text
Text
Attribut
PersonalNr
Schicht
Arbeitsplatz
Arbeiter
Datentyp
Zahl
Zahl
Zahl
Attribut
PersonalNr
ZimmerNr
TelefonNr
Angestellter
Datentyp
Zahl
Zahl
Zahl
Mirco De Roni
- 20 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
3.3
Normalisierung des Datenbankschemas
Ziel der Normalisierung des relationalen Datenbankschemas ist es,
 Anomalien zu beheben
 Redundanzen zu vermeiden
 einen übersichtlichen und möglichst einfachen Aufbau der Relationen zu erhalten
 eine einfache Datenpflege zu ermöglichen
3.3.1
Probleme beim Ändern, Einfügen und Löschen von Datensätzen
(Anomalien)
Bei einigen Datenbanksystemen müssen Schlüsselattribute bei der Definition der Struktur der Relation
direkt untereinander stehen.
Eine Relation befindet sich in der ersten Normalform (1NF), wenn jedes Attribut der Relation atomar ist.
Das bedeutet, dass die Attribute keine weiteren Untergliederungen aufweisen dürfen bzw. dass für jedes
Attribut eines Tupels nur ein Eintrag zulässig ist. Die erste Normalform ist der Ausgangszustand für
weitere Betrachtungen.
Werden Tupel (Datensätze) geändert, neue eingefügt oder alte gelöscht, können fehlerhafte Zustände
auftreten. Diese werden durch die Datenredundanz hervorgerufen und führen zu Inkonsistenzen. Diese
Fehler werden auch als Anomalien bezeichnet.



3.3.2
Einfüge-Anomalie
Wenn Sie der Relation einen neuen Mitarbeiter hinzufügen, der zu diesem Zeitpunkt an keinem
Projekt mitarbeitet, entstehen leere Datenfelder. Einerseits wird dadurch Speicherplatz
verschwendet.
Lösch-Anomalie
Wenn Sie einen vorhandenen Mitarbeiter löschen, werden auch die zugehörigen Projektdaten
gelöscht. Sind die Daten für dieses Projekt nur bei dem einen Mitarbeiter gespeichert, gehen
diese Daten verloren.
Änderungs-Anomalie
Wenn sich der Familienname eines Angestellten ändert, beispielsweise wenn sich der Name von
Richter zu Meier ändert, müssen alle Datensätze geändert werden, die diesen Wert beinhalten.
Abhängigkeiten
Bei der Normalisierung spielt die Beseitigung von Abhängigkeiten zwischen den Attributen einer Relation
eine grosse Rolle. Es gibt funktionale und transitive Abhängigkeiten.
Funktionale Abhängigkeit
Eine funktionale Abhängigkeit (X  Y) liegt vor, wenn es keine zwei Tupel geben kann, in denen für
gleiche X-Werte verschiedene Y-Werte auftreten können. Umgekehrt kann es aber für gleiche Y-Werte
verschiedene X-Werte geben.
Transitive Abhängigkeit
Eine transitive Abhängigkeit besteht, wenn ein Attribut a von einem Attribut b und ein Attribut b von einem
Attribut c funktional abhängig ist. In diesem Fall ist a transitiv von c abhängig.
Beispiel:
Die Lieferfirma hängt von der Artikelnummer ab, die Lieferfirmen-Anschrift aber von der Lieferfirma
(ArtikelNr  Lieferfirma  AnschriftLieferfirma).
3.3.3
Der Normalisierungsprozess
Beim Normalisierungsprozess werden die Daten einer Relation auf mehrere Relationen verteilt. Die
einzelnen Stufen des Normalisierungsprozesses werden als erste bis fünfte Normalform bezeichnet. Oft
ist es sinnvoll, die Normalisierung nur bis zur dritten Normalform durchzuführen. Die weiteren
Normalformen verkomplizieren danach die Verwaltung der Datenbank zu sehr, da viele kleine Relationen
entstehen.
Mirco De Roni
- 21 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
Nicht normalisierte Datenstruktur
Eine Datenstruktur wird als nicht normalisiert bezeichnet, wenn in einem Datensatz für ein Attribut eine
Werteliste angegeben wird. Zum Beispiel arbeitet der Mitarbeiter Richter an den Projekten 1, 2, 3.
Diese Relation ist schwer auszuwerten, da einige Attribute mehrere Werte haben.
PersNr
0004
3.3.4
Name
Richter
Vorname
Hans
AbtNr
3
Projekttätigkeiten
ProjNr
Abtname
Verkauf
1, 2, 3
Projektname
Amazonas,
Colorado,
Buzibach
Tätigkeit
Sachbearbeiter,
Projektleiter,
Sachbearbeiter
1. Normalform (1NF)
Eine Relation befindet sich in der 1. Normalform, wenn
 sie zweidimensional ist, d.h. ein Gebilde aus Zeilen und Spalten
 sich in jedem Datensatz nur Daten befinden, die zu einem Objekt der realen Welt gehören und
jeder Datensatz nur einmal vorkommt
 sich in jeder Spalte nur Daten befinden, die in einem Attribut entsprechen und das Attribut nur
einmal in der Relation vorkommt
 für jedes Attribut nur ein Wert eingetragen ist
Vorgehen bei der Transformation einer nicht normalisierten Datenstruktur in die 1. Normalform:
 Alle Mehrfacheinträge in einem Attribut entfernen.
Jedem Attribut eines Datensatzes darf höchstens ein Wert zugewiesen sein.
PersNr
0004
0004
0004
Name
Richter
Richter
Richter
Vorname
Hans
Hans
Hans
Projekttätigkeiten
ProjNr
AbtNr
Abtname
3
Verkauf
1
3
Verkauf
2
3
Verkauf
3
Projektname
Amazonas
Colorado
Buzibach
Tätigkeit
Sachbearbeiter
Projektleiter
Sachbearbeiter
Probleme



3.3.5
Die Relation weist Redundanzen auf.
Die Relation enthält voneinander unabhängige Sachgebiete.
Daten können nicht eindeutig identifiziert werden.
2. Normalform (2NF)
Eine Relation befindet sich in der 2. Normalform, wenn jedes Nicht-Schlüsselfeld vom ganzen
Primärschlüssel abhängig ist. Wichtig hierbei ist, dass Datenfelder nicht nur von einem Teilschlüsselfeld,
sondern vom gesamten Schlüsselfeld abhängig sind.
Vorgehen bei der Transformation von der 1. Normalform in die 2. Normalform:
 Die Relation in kleinere Relationen zerlegen, sodass in jeder Relation alle Nicht-Schlüsselfelder
nur noch vom Primärschlüssel abhängen.
 Besteht ein Primärschlüssel aus mehreren Attributen, ist zu prüfen, ob es Attribute gibt, die
eigentlich nur von einem Teil des Primärschlüssels abhängen. Ist das der Fall, so sind dieser Teil
des Primärschlüssels und die zugehörigen Attribute in eine neue Relation zu bringen.
PersNr
0004
Name
Richter
ProjNr
1
2
3
Projekte
Projektname
Amazonas
Colorado
Buzibach
Mirco De Roni
Personen
Vorname
Hans
- 22 -
AbtNr
3
Abtname
Verkauf
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
Projekttätigkeiten
ProjNr
1
2
3
PersNr
0004
0004
0004
3.3.6
Tätigkeit
Sachbearbeiter
Projektleiter
Sachbearbeiter
3. Normalform (3NF)
Eine Tabelle befindet sich in der 3. Normalform, wenn alle Datenfelder nur vom gesamten Schlüssel
abhängig sind und untereinander keine Abhängigkeiten auftreten. Sobald ein Nicht-Schlüsselfeld nur über
ein anderes Nicht-Schlüsselfeld identifizierbar ist, wird von transitiver Abhängigkeit gesprochen.
Transitive Abhängigkeiten verursachen ebenfalls Datenredundanz und –inkonsistenz.
Vorgehen bei der Transformation von der 2. Normalform in die 3. Normalform:
 Entfernen Sie für die 3. Normalform alle transitiven Abhängigkeiten durch Teilen der Relation in
mehrere Relationen, in denen alle Nicht-Schlüsselfelder direkt vom gesamten Schlüsselfeld
abhängig sind.
AbtNr
3
Abteilungen
Abtname
Verkauf
PersNr
0004
Name
Richter
ProjNr
1
2
3
Projekte
Projektname
Amazonas
Colorado
Buzibach
Projekttätigkeiten
ProjNr
1
2
3
PersNr
0004
0004
0004
3.3.7
Personen
Vorname
Hans
AbtNr
3
Tätigkeit
Sachbearbeiter
Projektleiter
Sachbearbeiter
Weitere Normalformen
Boyce-Codd-Normalform (BCNF)
Die Abhängigkeiten von einzelnen Schlüsseln oder Schlüsselattributen untereinander werden bis zur 3NF
nicht berücksichtigt. In der Boyce-Codd-Normalform werden sie beseitigt.
Eine Relation befindet sich in der Boyce-Codd-Normalform, wenn kein Attribut funktional abhängig von
einer Attributgruppe ohne Schlüsseleigenschaft ist.
Das bedeutet, dass in einer Relation keine funktionalen Abhängigkeiten zwischen einem minimalen
Schlüssel (nicht zusammengesetzten Schlüssel) und den Attributen bestehen dürfen.
4. und 5. Normalform
In der 4. Normalform befinden sich Relationen, die sich in der 3NF befinden und die keine paarweise
auftretenden mehrwertigen Abhängigkeiten der Attribute enthalten. Eine mehrwertige Abhängigkeit
besteht, wenn mehrere Nicht-Schlüsselattribute direkt vom Schlüssel abhängig sind, aber nicht
voneinander abhängig sind.
Mirco De Roni
- 23 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Das relationale Datenmodell
_____________________________________________________________________________________________
Ist eine verlustlose Zerlegung in Einzelabhängigkeiten in der 4. Normalform nicht möglich, werden in der
5. Normalform weitere Primärschlüssel hinzugefügt. Kann eine Relation nicht durch einen Join aus
Einzelrelationen erstellt werden, befindet sie sich in der 5. Normalform.
3.4
Theorie relationaler Sprachen
Sprachen, die mit relationalen Datenbanken arbeiten, müssen in der Lage sein, folgende Operationen
auszuführen:
 Anlegen von neuen Relationen
 Verändern von Relationen
 Löschen von Relationen
 Erzeugen von Relationen aus vorhandenen Relationen mit ausgewählten Tupeln und
ausgewählten Attributen
Relationsalgebra
Als Algebra wird im Bereich der Mathematik ein System bezeichnet, welches aus nicht leeren Mengen
und Operationen auf diesen Mengen besteht. Die nicht leeren Mengen sind in der Relationsalgebra die
Relationen und die Operationen darauf sind die Datenbankoperationen, z.B. Datenbankanfragen.








Projektion:
Selektion:
Vereinigung:
Differenz:
Durchschnitt:
Umbenennen:
Kartesisches Produkt: x
Verbund (Join):
Relationskalkül
Während die Relationsalgebra prozedural aufgebaut ist, wird im Relationskalkül die Menge der
auszuwählenden Tupel deskriptiv, ohne Angabe der anzuwendenden Operation aufgeführt. Das
Relationskalkül wird in zwei Ausprägungen unterteilt, in das Tupelkalkül (tupelorientiertes
Relationskalkül) und das Domainkalkül (werteorientiertes Relationskalkül).


Ein relationales Tupelkalkül wird in Anlehnung an die Prädikatenlogik in der Form {t | P(t)}
angegeben.
Im Domainkalkül werden Wertebereiche eingesetzt. Das Domainkalkül wird in der Form
{[d1, d2,…, dn] | P(d1, d2,…, dn)} notiert.
Zeichen





Name, Bedeutung
Logisches Und (AND)
Logisches Oder (OR)
Negation (NOT)
Allquantor , „für alle …“
Existenzquantor, „es existiert …“
Mirco De Roni
Beispiel
a  b  Der Ausdruck ist wahr, wenn a und b wahr sind.
a  b  Der Ausdruck ist wahr, wenn a oder b wahr ist.
a  Der Ausdruck ist wahr, wenn a falsch ist.
(x)b  Für alle Werte x ist der Ausdruck b wahr.
(x)b  Es existiert ein Wert x, sodass der Ausdruck b
wahr ist.
- 24 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbanken
_____________________________________________________________________________________________
4
Datenbanken
4.1
Die Datenbankabfragesprache SQL
Die Datenbankabfragesprache SQL wurde aus der Abfragesprache SEQUEL (Structured English QUEry
Language) der Firma IBM entwickelt.
SQL ist eine interaktive Sprache und erlaubt Ad-hoc-Abfragen von Datenbanken (Abfragen, die sofort
ausgeführt werden). Über so genannte SQL-Skripts können Sie mehrere SQL-Anweisungen automatisiert
ausführen lassen.
Zum Sprachumfang von SQL gehören vier Befehlsgruppen:
DDL (Data Definition Language)
DQL (Data Query Language)
DML (Data Manipulation Language)
DCL (Data Control Language)
4.2
Erstellen von Datenbanken, Tabellen (Relationen) und Indizes
Abfragen von Daten
Anlegen, Ändern und Löschen von Datensätzen
Anlegen von Benutzern und Vergabe von Zugriffsrechten
Datenbank erstellen
1. CREATE DATABASE IF NOT EXISTS verwaltung;
Mit dieser Anweisung wird eine neue Datenbank mit dem Namen verwaltung erstellt, falls diese
noch nicht existiert.
2. USE verwaltung;
Die neue Datenbank wird ausgewählt, damit sie bearbeitet werden kann. Es kann immer nur eine
Datenbank ausgewählt sein.
Syntax
CREATE DATABASE [IF NOT EXISTS] datenbankname;


Mit der SQL-Anweisung CREATE werden neue Datenbank-Objekte erzeugt. Danach erfolgt die
Angabe, welches Objekt erzeugt werden soll, in diesem Fall eine neue Datenbank (DATABASE).
Zum Abschluss müssen Sie den gewünschten Namen der Datenbank angeben.
Falls die Datenbank bereits existiert, wird eine Fehlermeldung ausgegeben. Um dies zu
umgehen, kann die Anweisung IF NOT EXISTS hinzugefügt werden. In diesem Fall wird die
Datenbank nur dann erstellt, falls sie noch nicht existiert.
Für die Vergabe des Datenbanknamens unter MySQL gelten die folgenden Regeln:
 Der Name darf maximal 64 Zeichen umfassen.
 Es sind alle Zeichen erlaubt, die in einem Verzeichnisnamen des betreffenden Betriebssystem
verwendet werden dürfen. Nicht erlaubt ist grundsätzlich das Zeichen /.
4.3
Datenbank anzeigen und auswählen
4.3.1
Datenbank anzeigen
Wenn man den Namen einer bestimmten Datenbank nicht kennt, kann man in MySQL mit der Anweisung
SHOW DATABASES eine Liste der vorhandenen Datenbanken anzeigen.
Syntax
SHOW DATABASES;

Die Anweisung listet alle vorhandenen Datenbanken auf.
Mirco De Roni
- 25 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenbanken
_____________________________________________________________________________________________
4.3.2
Datenbank auswählen
Bevor man mit einer Datenbank und den darin befindlichen Datenbankobjekten arbeiten kann, muss man
diese mit der Anweisung USE (MySQL) oder CONNECT (InterBase) auswählen.
Syntax der Anweisung USE in MySQL
USE datenbankname;

Die Anweisung USE wählt die angegebene Datenbank aus. Alle weiteren Anweisungen beziehen
sich auf diese Datenbank.
Syntax der Anweisung CONNECT in InterBase
CONNECT ‘datenbankdateiname‘ [USER ‘benutzername‘ PASSWORD ‘passwort‘];

Die SQL-Anweisung CONNECT wählt die angegebene Datenbank aus. Als Parameter wird dabei
ein berechtigter Benutzer angegeben. Alle weiteren Anweisungen beziehen sich auf diese
Datenbank.
4.4
Datenbank löschen
Über die Anweisung DROP DATABASE wird eine Datenbank mit allen enthaltenen Daten gelöscht. Dabei
wird keine Warnmeldung ausgegeben.
Syntax
DROP DATABASE [IF EXISTS] datenbankname;



Mit der SQL-Anweisung DROP wird ein Datenbank-Objekt gelöscht. Zum Löschen einer
Datenbank wird DATABASE als Objekttyp angegeben.
Der Name der Datenbank folgt am Ende der Anweisung.
Die Anweisung IF EXISTS verhindert das Auftreten von Fehlermeldungen, falls die Datenbank
nicht existiert.
Mirco De Roni
- 26 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________
5
Tabellen erstellen und verwalten
5.1
Tabellen erstellen
Tabellen (Relationen) sind die einzigen Objekte einer Datenbank, in denen die Daten gespeichert
werden. Jeder Zugriff auf die Daten erfolgt über die Tabellen.
Eine Tabelle besteht aus einzelnen Feldern (Datenfeldern, Attributen, Spalten). Durch die Namen und
Datentypen der Felder wird die Struktur bzw. das Schema der Tabelle festgelegt.
Um eine Tabelle erstellen zu können, benötigt man das Ausführungsrecht für die Anweisung CREATE
TABLE. Der Administrator vergibt dieses Recht mit der Anweisung GRANT CREATE TABLE. Der
Benutzer, der die Tabelle erstellt, wird danach zu ihrem Eigentümer.
5.1.1
Einfache Tabellen erstellen
CREATE TABLE Mitarbeiter (
PersonalNr INTEGER NOT NULL,
Name VARCHAR (30),
Vorname VARCHAR (30),
Anschrift VARCHAR (30),
PRIMARY KEY (PersonalNr)
);
Syntax
CREATE TABLE tabellenname (
datenfeld1 datentyp1 [DEFAULT standardwert1 | NULL | NOT NULL ]
[AUTO_INCREMENT],
…
PRIMARY KEY (datenfeldname)
);



Mit der Anweisung CREATE TABLE wird eine neue, leere Tabelle erstellt. Danach folgt der
gewünschte Tabellenname.
In runden Klammern folgen die Definitionen der einzelnen Datenfelder. Für jedes Datenfeld
müssen dabei ein Name und ein Datentyp angegeben werden.
Mit der Angabe PRIMARY KEY kann ein Datenfeld als Primärschlüssel festgelegt werden. Der
Primärschlüssel ermöglicht es, einen Datensatz eindeutig zu identifizieren.
Folgende optionale Parameter sind bei der Definition von Datenfeldern möglich:
NOT NULL
NULL (MySQL)
DEFAULT NULL (InterBase)
DEFAULT standardwert
AUTO_INCREMENT
Mirco De Roni
Mit diesem Parameter wird die Eingabe eines Wertes für das
entsprechende Datenfeld erzwungen. Die Angabe NOT NULL ist für
Schlüsselfelder unbedingt anzugeben.
Mit diesem Parameter wird festgelegt, dass das Datenfeld
standardmässig keinen Wert (auch nicht 0 oder leere Zeichenkette)
enthält. In SQL entspricht dies dem Wert NULL.
Der Parameter DEFAULT definiert einen Standardwert für das
Datenfeld. Erhält dieses Datenfeld bei der Eingabe der Daten
keinen Wert, wird der Standardwert verwendet.
Der Wert dieses Datenfeldes wird automatisch beim Anlegen eines
neuen Datensatzes aus dem Wert des Datenfeldes des vorherigen
Datensatzes plus 1 errechnet. Dieser Wert kann vom Benutzer nicht
geändert werden. Diese Einstellung ist besonders für den
Primärschlüssel empfehlenswert, da dadurch automatisch ein
eindeutiger Schlüsselwert erzeugt wird.
- 27 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________
5.1.2
Datentypen
Beim Erstellen einer Tabelle muss für jedes Datenfeld ein Datentyp angegeben werden. Der verwendete
Datentyp entscheidet, ob in einem Feld Zahlen, Zeichenketten oder andere Daten gespeichert werden.
Numerische Datentypen für ganzzahlige Werte
In Felder dieses Datentyps werden ganzzahlige Werte (Integer-Zahlen) ohne Kommastellen gespeichert.
Datentyp
SMALLINT
INTEGER
Speicherbedarf
2 Byte
4 Byte
Wertebereich
-32768 bis + 32767
-2147483648 bis + 2147483647
Integer-Datentypen eignen sich besonders für eindeutige Identifikationsnummern, z.B. Primärschlüssel
einer Tabelle.
Numerische Datentypen für Fliesskommazahlen
Mit diesen Datentypen können Zahlenwerte mit Nachkommastellen gespeichert werden. Die Datentypen
unterscheiden sich dabei im Wertebereich.
Datentyp
FLOAT
DOUBLE PRECISION
Speicherbedarf
4 Byte
8 Byte
Wertebereich
7 signifikante Stellen
15 signifikante Stellen
Die Datentypen können einen Zahlenwert mit der angegebenen Anzahl signifikanter Stellen speichern.
Die Dezimalstelle kann an einer beliebigen Stelle liegen. Alle Ziffern nach der Anzahl der signifikanter
Stellen werden abgeschnitten.
Numerische Datentypen für Festkommazahlen
Diese Datentypen eignen sich für das Speichern formatierter Zahlen mit einer festen Anzahl von
Nachkommastellen.
Datentyp
NUMERIC (Präzision, Skalierung)
Erklärung
Der Parameter Präzision (1 – 15) legt die
Gesamtzahl der signifikanten Stellen der Zahl fest.
Der Parameter Skalierung (1 – 15) bestimmt die
Anzahl der Nachkommastellen, die kleiner oder
gleich der Gesamtzahl der Stellen sein muss. Der
Unterschied zwischen NUMERIC und DECIMAL
liegt darin, dass NUMERIC die exakte Anzahl und
DECIMAL die minimale Anzahl der signifikanten
Stellen angibt.
DECIMAL (Präzision, Skalierung)
Datentyp für Datumswerte
Für Datums- und Zeitwerte gibt es einen speziellen Datentyp. Im Datumstyp wird, wenn nicht angegeben,
automatisch auch die Zeit gespeichert.
Datentyp
DATE
Speicherbedarf
8 Byte
Wertebereich
1.1.100 bis 11.12.5941
Bei der Eingabe können Datumswerte in verschiedenen Formaten angegeben werden. Die Umwandlung
in das interne Format erfolgt automatisch. Zeitwerte gibt man in der Form hh:mm:ss an.
Eingabeformat
tt.mm.jj
tt-mmm-jj
mm-tt-jj
Mirco De Roni
Beispiel
24.02.09
24-FEB-09
02-24-09
- 28 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________
Datentypen für Zeichen und Texte
SQL sieht verschiedene Datentypen vor, um Textinformationen zu speichern. Es gibt dabei Datentypen
mit variabler und fester Länge.
Datentyp
CHAR (Länge)
Länge = 1..255
VARCHAR (Länge)
Länge = 1..255
BLOB
TEXT
Erklärung
Dieser Datentyp dient zum Speichern beliebiger Textinformationen. Die
maximale Länge wird dabei als Parameter übergeben.
Zum Speichern beliebiger Textinformationen wird auch dieser Typ verwendet.
Auch hier wird die maximale Länge als Parameter übergeben.
Dieser Datentyp (Binary Large Objects) wird zum Speichern grosser, auch
binärer Datenmenge eingesetzt, z.B. sehr grosser Textdateien, Grafiken, Bilder
oder Videos.
Wie auch in BLOB-Feldern können hier grössere Informationsmengen mit
variabler Länge gespeichert werden. Der Unterschied zu BLOB-Felder liegt in
der anderen Sortierreihenfolge, die bei TEXT-Feldern unabhängig von der
Gross- und Kleinschreibung ist.
Da der Datentyp VARCHAR zwei zusätzliche Bytes für die Längenspeicherung benötigt, sollte man ihn
nicht für die Definition sehr kurzer Datenfelder einsetzen.
Datentypumwandlung
Eine implizite Typumwandlung findet beispielsweise statt, wenn Sie eine Zahl vom Typ SMALLINT mit
einer INTEGER-Zahl vergleichen. Die Konvertierung erfolgt immer vom „niedrigen“ zum „höheren“
Datentyp, z.B. von SMALLINT zu INTEGER.
Explizit wird eine Typumwandlung über die Funktion CAST durchgeführt.
Syntax der CAST-Anweisung
CAST (Wert AS Datentyp)


Die Funktion wandelt den angegebenen Wert in den Datentyp um, der nach dem Schlüsselwort
AS aufgeführt ist.
Es können folgende Typen ineinander umgewandelt werden:
NUMERIC

CHAR, VARCHAR, DATE
CHAR, VARCHAR

NUMMERIC, DATE
DATE

CHAR, VARCHAR, DATE
BLOB, TEXT

nicht möglich
5.1.3
Integritätsregeln in Tabellen verwenden
Eine Gültigkeitsprüfung wird nach der Definition der Datenfelder mit dem Schlüsselwort CONSTRAINT
(engl. Zwang, Nebenbedingung) eingeleitet.
CREATE TABLE t_ma_abt (
ID INTEGER NOT NULL,
AbtName VARCHAR (15) DEFAULT “Produktion“,
MitarbeiterNr INTEGER,
CONSTRAINT mpruef CHECK (MitarbeiterNr > 1)
);
Syntax
CREATE TABLE tabellenname (
datenfeld1 datentyp1 [DEFAULT standardwert1 | NULL | NOT NULL ]
[AUTO_INCREMENT],
datenfeld2 COMPUTED BY (berechnung),
…
CONSTRAINT constraintname1 CHECK (gültigkeitsprüfung),
Mirco De Roni
- 29 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________
…
PRIMARY KEY (datenfeldname)
);



Die Tabellendefinition erfolgt mit der Anweisung CREATE TABLE. Danach werden in runden
Klammern die Datenfelder und Tabellenoptionen angegeben.
Für berechnete Datenfelder wird kein Datentyp angegeben. Nach dem Datenfeldnamen erfolgt
hier die Angabe von COMPUTED BY, gefolgt von der Berechnungsformel in runden Klammern.
Die Angabe einer Gültigkeitsbedingung wird mit dem Schlüsselwort CONSRAINT eingeleitet.
Danach wird der gewünschte Name der Bedingung angegeben. Nach dem Schlüsselwort CHECK
folgt in runden Klammern die Gültigkeitsbedingung.
Die Gültigkeitsbedingung muss erfüllt (wahr) sein, damit der Wert in der Tabelle gespeichert wird.
5.2
Domänen verwenden
5.2.1
Domänen definieren
Domänen (engl. Domains) sind benutzerdefinierte Datentypen, die Sie einmalig definieren und in
verschiedenen Tabellen zum Definieren von Feldtypen verwenden können. Im Falle einer Änderung
muss man nicht jede Tabelle einzeln bearbeiten, sondern nur die entsprechende Domäne verändern.
Domänen sind in der gesamten Datenbank verfügbar, in der sie definiert wurden.
Der MySQL-Server unterstützt die Verwendung von Domänen nicht.
CREATE DOMAIN d_benutzer AS VARCHAR (15) DEFAULT “Gast“;
Syntax
CREATE DOMAIN domänenname AS datentyp [DEFAULT standardwert];


Die Definition einer Domäne wird mit den Schlüsselwörtern CREATE DOMAIN eingeleitet. Danach
folgen der Name der Domain und nach der Angabe AS der gewünschte Datentyp.
Ein Standardwert wird mit dem Schlüsselwort DEFAULT angegeben.
Eine Domäne kann neben dem Datentyp auch mit verschiedenen Bedingungen und Prüfungen definiert
werden. Dafür wird das Schlüsselwort CHECK verwendet.
CREATE DOMAIN domänenname AS datentyp CHECK (gültigkeitsbedingung);

5.2.2
Mit dem Schlüsselwort CHECK kann eine Bedingung hinzugefügt werden. In Klammern folgt
danach ein Ausdruck, der einen Wahrheitswert (wahr oder falsch) liefert. Liefert der Ausdruck
den Wert Falsch, wird die entsprechende Operation nicht durchgeführt.
Domänen verwenden
Die Domänen in Tabellen können auf die gleiche Weise wie Standarddatentypen verwendet werden.
CREATE DOMAIN d_abt AS VARCHAR (15)
CHECK (VALUE IN (“Einkauf“,“Verkauf“,“Marketing“,“Verwaltung“);
CREATE TABLE t_ma_abt (
ID INTEGER,
AbtName d_abt
);
Mirco De Roni
- 30 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________
5.2.3
Domänen ändern
ALTER DOMAIN d_abt SET DEFAULT “Produktion“;
ALTER DOMAIN d_abt DROP CONSTRAINT;
Syntax
ALTER DOMAIN domänenname [SET DEFAULT standardwert]
[DROP DEFAULT]
[ADD CHECK (gültigkeitsbedingung)]
[DROP CONSTRAINT];


Über die Anweisung ALTER DOMAIN können Domänen bearbeitet werden. Als erster Parameter
wird dabei der Domänenname angegeben.
Mit dem danach folgenden Parameter wird angegeben, was geändert oder gelöscht werden soll.
5.2.4
Domänen löschen
Um eine Domäne zu löschen, darf sie in keiner Tabelle als Datentyp verwendet werden. Die
entsprechende Datenfelddefinition muss zuerst gelöscht werden.
Syntax
DROP DOMAIN domänenname;

Die Anweisung DROP DOMAIN löscht eine Domäne. Als Parameter muss ein gültiger
Domänenname angegeben werden.
5.3
Vorhandene Tabellen anzeigen, ändern und löschen
5.3.1
Vorhandene Tabellen anzeigen
Über die Anweisung SHOW TABLES können die in der Datenbank vorhandenen Tabellen angezeigt
werden.
Syntax
SHOW TABLES [FROM datenbankname] [LIKE “muster“];



Die Anweisung SHOW TABLES zeigt eine Liste der vorhandenen Tabellen in der aktuell
geöffneten Datenbank an.
Mit dem Schlüsselwort FROM kann eine andere Datenbank benannt werden.
Mithilfe von LIKE kann die Anzeige der Tabellen auf ein bestimmtes Muster im Tabellenname
beschränkt werden. Durch Verwendung des Musters m% werden beispielsweise nur die Tabellen
angezeigt, die mit dem Buchstaben m beginnen.
5.3.2
Tabellenstruktur ändern
Die Struktur einer Tabelle kann jederzeit über die Anweisung ALTER TABLE geändert werden.




Datenfelder hinzufügen oder löschen
Datenfelddefinitionen verändern
Gültigkeitsprüfungen hinzufügen oder löschen
Schlüssel und Indizes hinzufügen oder löschen
Mit dem Schlüsselwort ADD fügt man einer bestehenden Tabelle ein neues Datenfeld hinzu.
Syntax
ALTER TABLE tabellenname
[ADD datenfelddefinition]
[ADD indexdefinition]
[ADD CONSTRAINT constraintname CHECK (gültigkeitsbedingung)]
[DROP objektname];
Mirco De Roni
- 31 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Tabellen erstellen und verwalten
_____________________________________________________________________________________________




Für das Ändern einer Tabelle wird die Anweisung ALTER TABLE verwendet. Danach folgt der
Name der zu ändernden Tabelle.
Mit dem Schlüsselwort ADD wird das Hinzufügen eines Datenfelds, Indizes oder Schlüssels oder
einer Gültigkeitsbedingung eingeleitet.
Mit der Klausel DROP wird ein Datenfeld, Index, Schlüssel oder eine Gültigkeitsbedingung
gelöscht.
Gültigkeitsprüfungen gelten nur für die nach der Änderung neu hinzugefügten oder geänderten
Datensätze.
5.3.3
Tabellen löschen
Syntax
DROP TABLE tabellenname;

Mit der Anweisung DROP TABLE wird die angegebene Tabelle mit allen enthaltenen Daten
gelöscht.
Beim Löschen einer Tabelle müssen folgende Besonderheiten beachtet werden:
 Wenn andere Datenbankobjekte die zu löschende Tabelle verwenden oder referenzieren (VIEW)
oder eine gespeicherte Prozedur (STORED PROCEDURE), ist das Löschen nicht möglich. Es
müssen alle Referenzen entfernt werden.
 Man muss entweder Eigentümer der Tabelle sein oder über die notwendigen Rechte zum
Löschen der Tabelle verfügen.
 Es dürfen keine Transaktionen aktiv sein, die die betreffende Tabelle verwenden.
Mirco De Roni
- 32 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Daten einfügen, aktualisieren und löschen
_____________________________________________________________________________________________
6
Daten einfügen, aktualisieren und löschen
6.1
Daten einfügen
6.1.1
Einfügen eines Datensatzes
Um Datensätze in eine Tabelle einzufügen, verwendet man die Anweisung INSERT INTO.
Um Daten in eine Tabelle einzufügen, muss man Besitzer der Tabelle sein bzw. über die entsprechende
Rechte verfügen. Der Administrator vergibt diese Rechte mit der GRANT-INSERT-Anweisung.
Syntax
Wenn wir der INSERT-Anweisung sämtliche Attribute in der richtigen Reihenfolge übergeben, wird
folgende Form verwendet.
INSERT INTO tabellenname VALUES (‘wert1‘, ‘…‘, ‘wertX‘);
Falls wir aber nicht alle Attribute übergeben oder eine andere Reihenfolge verwenden, muss dies der
INSERT-Anweisung mitgeteilt werden.
INSERT INTO tabellenname (feld1, …, feldX) VALUES (‘wert1‘, ‘…‘, ‘wertX‘);




Die Anweisung wird mit den Schlüsselwörtern INSERT INTO eingeleitet. Danach folgt der Name
der gewünschten Tabelle.
In runden Klammern werden, durch Kommata getrennt, die Namen der Datenfelder angegeben,
in die Werte eingefügt werden sollen.
Nach dem Schlüsselwort VALUES folgt in runden Klammern die Angabe der einzelnen Werte.
Diese müssen in der gleichen Reihenfolge angegeben werden, wie die zugehörigen Datenfelder
in der Liste davor. Dadurch ist es möglich, eine beliebige Reihenfolge für die Datenfelder zu
wählen.
Textinformationen, Datums- und Zeitwerte sind in Apostrophe (‘ ‘) oder Anführungszeichen
(“ “) einzuschliessen. Nicht alle Datenbanksysteme akzeptieren Anführungszeichen.
Abfrage der eingefügten Daten
SELECT * FROM tabellenname;
6.1.2
Einfügen mehrerer Datensätze
Syntax
INSERT INTO tabellenname (feld1, …, feldX) SELECT [*|datenfelder] FROM
tabellenname [WHERE bedingung];



6.2
Die Anweisung wird mit den Schlüsselwörtern INSERT INTO eingeleitet. Danach folgt der Name
der gewünschten Tabelle.
In runden Klammern folgen, durch Kommata getrennt, die Namen der Datenfelder, in die Werte
eingetragen werden sollen. Die Reihenfolge muss nicht der Reihenfolge der Datenfelder bei der
Definition der Tabelle entsprechen.
Danach wird eine gültige SELECT-Anweisung angegeben, die als Abfrage einen oder mehrere
Datensätze aus der Tabelle liefert.
Daten aktualisieren
Beim Ausführen der INSERT INTO-Anweisung wird stets ein neuer Datensatz erzeugt und in der Tabelle
gespeichert. Sie können jedoch auch die gezielt existierende Datensätze bearbeiten und verändern. Zu
diesem Zweck stellt SQL die UPDATE-Anweisung zur Verfügung.
Mit der UPDATE-Anweisung kann einen oder mehrere Datensätze gleichzeitig aktualisiert werden. Die
Auswahl der betreffenden Datensätze erfolgt dabei über eine WHERE-Bedingung. Wird keine Bedingung
angegeben, werden alle Datensätze aktualisiert.
Mirco De Roni
- 33 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Daten einfügen, aktualisieren und löschen
_____________________________________________________________________________________________
Syntax
UPDATE tabellenname SET feld1 = wert1, …, feldX = wertX [WHERE bedingung];




Die Anweisung beginnt mit dem Schlüsselwort UPDATE. Danach wird der Name der gewünschten
Tabelle angegeben.
Mit dem Schlüsselwort SET wird die Wertezuweisung eingeleitet. Sie erfolgt stets nach dem
Muster datenfeldname = wert. Der Wert kann dabei eine Zahl, ein Text, ein berechneter
Ausdruck oder eine Unterabfrage sein, unabhängig vom Datentyp des Datenfeldes.
Nach der Wertezuweisung kann mithilfe der Anweisung WHERE eine Bedingung angegeben
werden. Die Aktualisierung erfolgt dann nur bei den Datensätzen, die diese Bedingung erfüllen.
Wird keine Bedingung angegeben, erfolgt die Wertezuweisung bei allen Datensätzen.
6.3
Daten löschen
Mithilfe der DELETE-Anweisung kann einen oder mehrere Datensätze einer Tabelle gelöscht werden. Die
Auswahl der Datensätze kann dabei wie bei der UPDATE-Anweisung mit einer WHERE-Bedingung
eingegrenzt werden.
Syntax
DELETE FROM tabellenname [WHERE bedingung];


Die Anweisung wird mit den Schlüsselwörtern DELETE FROM eingeleitet. Danach folgt der
gewünschte Tabellenname.
Um den Löschvorgang auf einen oder mehrere bestimmte Datensätze einzugrenzen, kann eine
WHERE-Bedingung angegeben werden.
Mirco De Roni
- 34 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Einfache Datenabfragen
_____________________________________________________________________________________________
7
Einfache Datenabfragen
7.1
Daten abfragen
7.1.1
Einführung
Das gezielte Abfragen der gespeicherten Informationen und Daten kann eine schwierige Aufgabe beim
Arbeiten mit einer Datenbank sein. In SQL wird dazu die SELECT-Anweisung verwendet. Sie ist die
komplexeste SQL-Anweisung, besitzt viele optionale Erweiterungen und wird in der Praxis am häufigsten
verwendet.
Die SELECT-Anweisung ähnelt einer Frage bzw. Aufforderung an das Datenbanksystem, die
gewünschten Daten zu liefern. Die Frage kann dabei sehr einfach oder komplex formuliert werden. Je
nach Qualität der Anfrage erhält man danach Daten, die schlecht oder sehr gut zu den Erfordernissen
passen.
SELECT * FROM tabellenname;
7.1.2
SELECT-Anweisung verwenden
Mithilfe der SELECT-Anweisung können alle oder ausgewählte Datenfelder von Tabellen abgefragt
werden. Die SELECT-Anweisung muss die gewünschten Daten dabei nicht nur aus einer einzigen Tabelle
ermitteln. Es sind auch verknüpfte Abfragen über zwei oder mehr Tabellen möglich.
Die einfachste SELECT-Anweisung lautet SELECT * FROM Tabellenname. Damit werden alle
Datensätze einer gewünschten Tabelle angezeigt.
Syntax einer einfachen Datenabfrage
SELECT [DISTINCT] * | Datenfelder FROM Tabellenname
[WHERE Bedingung]
[GROUP BY Datenfelder [HAVING Bedingung] ]
[ORDER BY Datenfelder [ASC|DESC] ]
[LIMIT [Start, ] Anzahl];




Die Anweisung wird mit dem Schlüsselwort SELECT eingeleitet.
Um doppelte (identische) Datensätze zu vermeiden, kann nach dem Schlüsselwort SELECT die
Angabe DISTINCT hinzugefügt werden.
Danach folgt die Angabe der Namen der gewünschten Datenfelder. Die Datenfeldnamen müssen
den bei der Tabellendefinition angegebenen Namen entsprechen. Die Feldnamen werden durch
Kommata getrennt. Das Zeichen * steht für alle Datenfelder der Tabelle.
Nach dem Schlüsselwort FROM folgt die Angabe der gewünschten Tabelle.
Alle folgenden Angaben sind optional und können entfallen.
7.1.3
Besondere Möglichkeit bei der Datenausgabe
Spalten umbenennen
Als Spaltenüberschrift in der Ausgabe der Daten wird stets der Name des Datenfeldes verwendet. Um die
Datenausgabe durch aussagekräftige Feldnamen benutzerfreundlicher zu gestalten oder die Feldnamen
einfach umzubenennen, können Sie mit dem Schlüsselwort AS für jedes Datenfeld der Abfrage einen
Ersatznamen (Alias) definieren.
SELECT Name AS Familienname FROM Mitarbeiter;
Anzahl der Datensätze beschränken
Die SELECT-Abfrage liefert standardmässig alle Datensätze einer Tabelle bzw. alle Datensätze, auf die
die angegebene Bedingung zutrifft. Bei sehr vielen Datensätzen kann dies lange dauern und es werden
meist auch nicht sofort alle Datensätze als Ergebnis benötigt. Mit dem Schlüsselwort LIMIT können Sie
die Anzahl der zurückgelieferten Datensätze begrenzen.
Mirco De Roni
- 35 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Einfache Datenabfragen
_____________________________________________________________________________________________
Beispiel:
Die Abfrage liefert die Vornamen und Familiennamen aller Mitarbeiter, bei denen die Postleitzahl mit 04
beginnt. Die Ergebnismenge wird mit der Angabe LIMIT 10 auf die ersten 10 Datensätze beschränkt.
SELECT Vorname, Name FROM Mitarbeiter WHERE PLZ LIKE “04%“ LIMIT 10;
Doppelte Datensätze vermeiden
Um doppelte Datensätze zu vermeiden, kann nach dem Schlüsselwort SELECT die Angabe DISTINCT
hinzugefügt werden.
Berechnungen ausführen
In einer SELECT-Abfrage können verschiedene Berechnungen durchgeführt werden. Die Ergebnisse
werden wie der Inhalt eines Datenfeldes behandelt. Für Berechnungen kann man alle numerischen
Datenfelder der Tabelle sowie konstante Werte verwenden.
SELECT ID, Preis, Stueck, Preis * Stueck AS Lagerwert FROM Lager LIMIT 10;
7.2
Bedingungen definieren
7.2.1
Einführung
Mithilfe der WHERE-Bedingung können Sie die mit einer SELECT-Abfrage zurückgelieferten Daten
einschränken bzw. filtern.
7.2.2
Vergleichsoperatoren
Beim Vergleich werden zwei Ausdrücke über einen Operator miteinander verglichen.
SQL besitzt die in der folgenden Tabelle aufgelisteten Operatoren.
Operator
<
>
<>
=
>=
<=
Erklärung
kleiner als
grösser als
ungleich
ist gleich
grösser oder gleich
kleiner oder gleich
Für den Vergleich von Textwerten sind nur die Operatoren = und < >, die auf Gleichheit oder Ungleichheit
überprüfen, erlaubt.
7.2.3
Bereichsprüfung
Die Operatoren BETWEEN und IN erleichtern das Definieren von Wertebereichen oder Wertelisten, indem
Sie mehrere verbundene Vergleichsausdrücke ersetzen. Mit dem Operator BETWEEN prüfen Sie, ob der
Wert eines Datenfelds in einem bestimmten Wertebereich liegt.
Syntax
SELECT … WHERE Datenfeld BETWEEN Untergrenze AND Obergrenze;
7.2.4
Elementprüfung
Mithilfe des IN-Operators testen Sie in einer Bedingung, ob der Wert in der Liste enthalten ist.
Syntax
SELECT … WHERE Datenfeld IN (Werteliste);
Mirco De Roni
- 36 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Einfache Datenabfragen
_____________________________________________________________________________________________
7.2.5
Mustervergleich
Speziell für Textwerte existiert der LIKE-Operator, der einen flexiblen Vergleich mit einem vorgegebenen
Muster ermöglicht.
Syntax
SELECT … WHERE Datenfeld LIKE “Muster“ [ESCAPE “Zeichen “];



Zuerst erfolgt die Angabe des gewünschten Datenfelds. Danach folgen das Schlüsselwort LIKE
und das anzuwendende Muster in Anführungszeichen oder Apostrophen.
Falls im Muster eines der Zeichen % oder _ verwendet werden muss, wird mit dem Schlüsselwort
ESCAPE ein Fluchtzeichen definiert. Dieses Zeichen steht, gefolgt von einem Leerzeichen, in
Anführungszeichen oder Apostrophen.
Im Muster wird das Fluchtzeichen dem gewünschten Zeichen, durch ein Leerzeichen getrennt,
vorangestellt.
7.2.6
Logische Operatoren
Mithilfe von logischen Operatoren können Sie mehrere Bedingungen miteinander verbinden. Auf diese
Weise erhalten Sie sehr komplexe Suchkriterien.
SQL ermöglicht den Einsatz der folgenden logischen Operatoren:
AND
OR
UND-Verknüpfung: Beide Bedingungen müssen erfüllt sein.
ODER-Verknüpfung: Mindestens eine der Bedingung muss erfüllt sein.
NICHT-Operator: Die nachfolgende Bedingung wird negiert (aus wahr wird falsch und aus
falsch wird wahr).
NOT
7.3
Abfrageergebnisse gruppieren
Das Gruppieren ermöglicht das Kombinieren von normalen Datenfeldern und Aggregatfunktionen in einer
SELECT-Abfrage, was sonst eine Fehlermeldung erzeugen würde.
Syntax
SELECT … GROUP BY Datenfeld [,Datenfeld, …] [HAVING Bedingung];



Mithilfe der GROUP-BY-Klausel lassen sich Abfragen nach einem oder mehreren Datenfeldern
gruppieren. Dabei wird erst nach dem ersten Datenfeld gruppiert, innerhalb der ersten
Gruppierung nach dem zweiten Datenfeld usw.
Mit der HAVING-Klausel kann die Ergebnismenge in einer gruppierten Abfrage eingeschränkt
werden. In der Bedingung können Aggregatfunktionen angegeben werden, was bei der WHEREKlausel nicht zulässig ist.
Die HAVING-Klausel kann nur in Verbindung mit GROUP BY angegeben werden.
7.4
Sortieren von Abfrageergebnissen
Die SELECT-Anweisung liefert die Datensätze in keiner Reihenfolge. Um das Abfrageergebnis nach
einem oder mehreren Datenfeldern zu sortieren, können Sie die ORDER-BY-Klausel verwenden.
Syntax
SELECT … ORDER BY Datenfeld [, Datenfeld, …] [ASC|DESC];


Das Abfrageergebnis wird nach dem angegebenen Datenfeld geordnet. Sind mehrere
Datenfelder angegeben, wird erst nach dem ersten, dann nach dem zweiten usw. sortiert.
Standardmässig wird in aufsteigender Reihenfolge sortiert, ASC (ascending) braucht somit nicht
angegeben zu werden. Um eine absteigende Sortierreihenfolge zu erhalten, geben Sie DESC
(descending) an.
Mirco De Roni
- 37 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Schlüsselfelder und Indizes
_____________________________________________________________________________________________
8
Schlüsselfelder und Indizes
8.1
Einführung
Schlüssel
Indizes
8.2
Durch einen Schlüssel wird jeder Datensatz einer Tabelle eindeutig identifiziert. Ein
Schlüssel wird aus einem Datenfeld oder einer Kombination von Datenfeldern der
Tabelle gebildet. Wie auch im relationalen Datenmodell können Schlüssel benutzt
werden, um Beziehungen zwischen logisch zusammengehörenden Tabellen
herzustellen.
Ein Index wird für ein bestimmtes Datenfeld oder auch mehrere Datenfelder angelegt,
nach denen häufig sortiert oder in denen häufig gesucht wird. Er ähnelt dem
Inhaltsverzeichnis eines Buches und ist in Form eines B*-Baumes aufgebaut. Für einen
Schlüssel wird vom DBMS meist automatisch ein Index erstellt. Für eine Tabelle können
mehrere Indizes definiert werden.
Primärschlüssel
Der Primärschlüssel ist ein Schlüssel, der einen Datensatz eindeutig kennzeichnet. Häufig handelt es
sich dabei um eine fortlaufende Nummer.
Jede Tabelle kann nur einen Primärschlüssel enthalten. Alle weiteren Schlüssel sind Sekundärschlüssel.
Im relationalen Datenmodell muss für jede Tabelle zwingend ein Primärschlüssel definiert werden. Dieses
Schlüsselfeld darf niemals leer sein.
8.3
UNIQUE (Sekundärschlüssel)
Sie dienen dazu, Redundanzen in den gespeicherten Daten zu vermeiden, da in einem Schlüsselfeld ein
Wert nicht mehrfach vorkommen darf.
Jede Tabelle kann mehrere Sekundärschlüssel enthalten. Diese Schlüsselfelder dürfen niemals leer sein
und sie müssen sich in jedem Datensatz unterscheiden.
CREATE TABLE Mitarbeiter (
PersonalNr INTEGER NOT NULL,
Name VARCHAR (30),
Vorname VARCHAR (30),
PRIMARY KEY (PersonalNr),
CONSTRAINT uq_name UNIQUE (Name, Vorname)
);
8.4
FOREIGN KEY (Fremdschlüssel)
Ein Fremdschlüssel bezeichnet die Übereinstimmung eines Datenfeldes in einer Tabelle mit dem
Primärschlüssel einer anderen Tabelle. Im relationalen Datenmodell werden häufig so genannte LookupTabellen verwendet, die zwei Tabellen miteinander verbinden.
SQL definiert eine Syntax für Regeln, die bei schreibenden Zugriffen auf referenzierte
Primärschlüsselwerte die Integrität gewährleisten.
Syntax für das Erstellen von Fremdschlüsseln
CREATE TABLE tabellenname (
datenfeld1 datentyp1,
…
FOREIGN KEY (datenfeldname) REFERENCES tabellenname (datenfeldname)
[ON UPDATE referenzoption] [ON DELETE referenzoption]
);
Mirco De Roni
- 38 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Schlüsselfelder und Indizes
_____________________________________________________________________________________________




Die Fremdschlüssel werden am Ende der CREATE TABLE-Anweisung deklariert.
Nach der Angabe FOREIGN KEY folgt in runden Klammern der Name des Datenfeldes, das auf
einen Primärschlüssel einer anderen Tabelle verweist.
Danach folgen das Schlüsselwort REFERENCES und der Name der Tabelle, auf die verwiesen
wird. In runden Klammern folgt dann der Name des Primärschlüssels dieser Tabelle.
Wenn benötigt, können danach verschiedene Optionen angegeben werden, die das Verhalten
bei Fremdschlüsselverletzungen steuern.
Folgende Optionen sind dabei möglich:
NO ACTION
Die Ausführung der Anweisung wird abgebrochen.
Beim Löschen werden alle Datensätze in anderen Tabellen, die auf diesen
Datensatz verweisen, ebenfalls gelöscht.
CASCADE
SET DEFAULT
SET NULL
Beim Aktualisieren werden alle referenzierten Datensätze in anderen Tabellen
ebenfalls geändert.
Alle referenzierten Datenfelder werden auf den DEFAULT-Wert (Standardwert)
zurückgesetzt.
Alle referenzierten Datenfelder werden auf den Wert NULL gesetzt.
Beispiel:
CREATE TABLE Abteilung (
AbteilungNr INTEGER NOT NULL IDENTITY(1,1),
Bezeichnung VARCHAR(30) NOT NULL,
PRIMARY KEY (AbteilungNr)
);
CREATE TABLE Mitarbeiter (
PersonalNr INTEGER NOT NULL IDENTITY(1,1),
fk_AbteilungNr INTEGER NOT NULL,
Nachname VARCHAR(30) NOT NULL,
Vorname VARCHAR(30),
Anschrift VARCHAR(30),
PRIMARY KEY (PersonalNr),
CONSTRAINT fk_Abteilung FOREIGN KEY (fk_AbteilungNr)
REFERENCES Abteilung (AbteilungNr)
);
8.5
Indizes
Indizes erleichtern die Suche nach Datensätzen, insbesondere bei sehr grossen Datenmengen.
 Ein Index bringt vor allem dann grosse Geschwindigkeitsvorteile, wenn die Datensätze sehr viele
Daten enthalten oder die Tabelle sehr gross ist.
 Beachten Sie, dass beim Einfügen, Löschen und Ändern von Datensätzen alle definierten Indizes
aktualisiert werden müssen. Dies kann beim Füllen von Tabellen sehr viel Zeit in Anspruch
nehmen.
Erzeugen Sie die Indizes für umfangreiche Tabellen erst nach dem Einfügen der Datensätze, da diese
Operation sonst länger dauern kann.
CREATE TABLE produkt
(id INTEGER NOT NULL, name VARCHAR(50), datum DATE, PRIMARY KEY(id));
INSERT INTO produkt ...;
CREATE INDEX i_produkt_name ON produkt (name);
SELECT id, name FROM produkt WHERE name LIKE "S%" ORDER BY name;
Mirco De Roni
- 39 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Funktionen in Abfragen
_____________________________________________________________________________________________
9
Funktionen in Abfragen
9.1
Standard- und Nichtstandard-Funktionen
Syntax
DECLARE EXTERNAL FUNCTION funktionsname parameterliste
RETURNS datentyp [BY VALUE] [FREE_IT]
ENTRY_POINT „udf_funktionsname“
MODULE_NAME „udfbibliothek“;





Die Deklaration beginnt mit den Schlüsselwörtern DECLARE EXTERNAL FUNCTION. Danach
folgt der gewünschte Name der Funktion.
Danach folgt die Liste der an die Funktionen zu übergebenden Parameter. Dazu werden, durch
Kommata getrennt, die entsprechenden Datentypen angegeben.
Nach dem Schlüsselwort RETURNS wird der von der Funktion zurückgelieferte Datentyp
angegeben. Optional folgen die zusätzlichen Bedingungen BY VALUE und FREE_IT. Durch BY
VALUE übergebene Parameter können in der UDF dauerhaft geändert werden. Durch die Angabe
von FREE_IT wird der Speicher für den Rückgabewert der UDF freigegeben.
Danach folgen das Schlüsselwort ENTRY_POINT und in Anführungszeichen der Name der
Funktion in der Bibliothek. In der IB_UDF-Bibliothek beginnen die Funktionsnamen stets mit
IB_UDF_.
Schliesslich wird mit dem Schlüsselwort MODULE_NAME der Name der Bibliothekdatei in
Anführungszeichen angegeben, die die betreffende Funktion enthält.
UDF (User Defined Functions)
Benutzerdefinierte Funktionen, die den Funktionsumfang der Datenbank erweitern und in externen
Bibliotheken vorliegen.
Beispiel:
DECLARE EXTERNAL FUNCTION strlen cstring (32767)
RETURNS integer BY VALUE
ENTRY_POINT ‘IB_UDF_strlen‘
MODULE_NAME ‘IB_UDF‘;
SELECT strlen (name) FROM Mitarbeiter;
9.2
Standard-SQL-Funktionen
9.2.1
Aggregatfunktionen
Die folgenden Aggregatfunktionen stehen zur Verfügung:
Funktion
COUNT()
COUNT(DISTINCT)
AVG()
MIN()
MAX()
SUM()
Erklärung
Liefert die Anzahl der Werte in der Ergebnismenge einer SELECT-Abfrage
bzw. einer Gruppierung
Liefert die Anzahl der unterschiedlichen Werte in einer Abfrage oder
Gruppierung
Liefert den Durchschnittswert eines Datenfeldes der Abfrage oder Gruppierung
Liefert den kleinsten bzw. grössten Wert eines Datenfeldes der Abfrage oder
Gruppierung
Liefert die Summe der Werte eines Datenfeldes in der Abfrage oder
Gruppierung
Beispiel:
SELECT SUM(Preis) FROM Lager WHERE Stueck > 10;
Mirco De Roni
- 40 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Funktionen in Abfragen
_____________________________________________________________________________________________
9.2.2
Aggregatfunktionen mit Gruppierung verwenden
SELECT Modell, COUNT(*) AS AnzahlAutos
FROM Fahrzeuge
WHERE AnzVermietungen > 60
GROUP BY Modell
HAVING AnzVermietungen > 1
ORDER BY AnzahlAutos ASC;
9.3
Nicht standardisierte Funktionen
9.3.1
Mathematische Funktionen
Funktion
abs(zahl)
Erklärung
Gibt den absoluten Wert einer Zahl wieder, d.h. den Wert ohne Vorzeichen
ceiling(zahl)
floor(zahl)
round(zahl)
Rundet den angegebenen Wert auf die nächste grössere ganze Zahl
Rundet den angegebenen Wert auf die nächste kleinere ganze Zahl
Rundet die angegebene Dezimalzahl nach den üblichen mathematischen
Regeln auf eine ganze Zahl
Rundet die angegebene Dezimalzahl nach den üblichen mathematischen
Regeln auf die angegebene Anzahl Dezimalstellen
Ermittelt den natürlichen Logarithmus
Liefert den Rest der Ganzzahldivision von zahl1 durch zahl2
Liefert den Wert von Pi
Liefert eine zufällige Zahl im Bereich Null bis Eins
Ermittelt das Vorzeichen einer Zahl und liefert daraufhin den Wert -1 bzw. 0
oder 1
Berechnet die entsprechenden Winkelfunktionen für den angegebenen
Wert
round(zahl,stellen)
log(zahl)
mod(zahl1,zahl2)
pi()
rand()
sign(zahl)
sin(zahl)
cos(zahl)
tan(zahl)
sqrt(zahl)
9.3.2
Ermittelt die Quadratwurzel für die übergebene Zahl
Funktionen für Zeichenketten
Funktion
ascii(string)
char(wert)
Erklärung
Liefert den ASCII-Wert des ersten Zeichens der Zeichenkette
Wandelt den angegebenen ASCII-Wert in das entsprechende Zeichen um
length(string)
lower(string)
upper(string)
ltrim(string)
rtrim(string)
substring(string,
anfang,länge)
substr(string,
anfang,ende)
Ermittelt die Länge der Zeichenkette
Wandelt die angegebene Zeichenkette in Klein- bzw. Grossbuchstaben um
Mirco De Roni
Entfernt alle führenden bzw. alle abschliessenden Leerzeichen in der
Zeichenkette
Liefert ein Teilstück der angegebenen Zeichenkette, definiert durch
Anfangsposition und Länge bzw. Endposition
- 41 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenabfrage über mehrere Tabellen
_____________________________________________________________________________________________
10 Datenabfrage über mehrere Tabellen
10.1
Tabellen verknüpfen
10.1.1 Datenbestand in mehreren Tabellen
Bei relationalen Datenbanken werden die Daten in der Regel auf mehrere, logisch zusammengehörige
Tabellen verteilt. In einer Abfrage müssen diese Daten so zusammengefügt werden, dass eine
brauchbare Ergebnismenge entsteht.
Die SELECT-Abfrage kann auf verschiedene Weise erweitert werden, um den Zugriff auf mehrere
Tabellen gleichzeitig zu ermöglichen. Die Abfragen können sich auf zwei oder mehr Tabellen beziehen.
10.1.2 Verknüpfung von Tabellen über Mengenoperationen



Vereinigungsmenge
OR-Verknüpfung: Verbindung von zwei oder mehr Tabellen zu einem Datenbestand.
Schnittmenge
AND-Verknüpfung: Aus zwei oder mehr Mengen werden nur die Datensätze herausgesucht, die
in allen Mengen gleich sind.
Differenzmenge
AND- und NOT-Verknüpfung: Aus zwei oder mehr Mengen werden alle die Datensätze ermittelt,
die zwar in der einen Menge, jedoch nicht in der anderen Menge enthalten sind.
10.1.3 Verbund von Tabellen (Joins)









Cross-Join
Mit diesem Verbund wird das kartesische Produkt beider Tabellen gebildet. Das heisst, jeder
Datensatz der einen Tabelle wird mit jedem Datensatz der anderen Tabelle kombiniert.
Theta-Join
Es werden bestimmte Datensätze aus dem kartesischen Produkt zweier Tabellen durch eine
Bedingung ausgewählt. In dieser Bedingung wird eine Spalte aus der einen und eine Spalte aus
der anderen Tabelle über eine logische Operation verglichen.
Inner-Join (Equi-Join)
Die Datensätze aus beiden Tabellen werden verbunden, wenn ein oder mehrere gemeinsame
Felder den gleichen Wert haben.
Natural-Join
Der Natural-Join arbeitet wie der Inner-Join - mit dem Unterschied, dass in der Ergebnistabelle
keine identischen Spalten enthalten sind.
Left-Outer-Join
Von der ersten (linken) Tabelle werden alle Datensätze in die Ergebnismenge aufgenommen.
Von der zweiten (rechten) Tabelle werden nur die dazugehörigen Datensätze übernommen. Die
Felder der ersten Tabelle bleiben leer, wenn kein passender Datensatz vorhanden ist.
Right-Outer-Join
Von der zweiten (rechten) Tabelle werden alle Datensätze in die Ergebnismenge aufgenommen.
Von der ersten (linken) Tabelle werden nur die dazugehörigen Datensätze übernommen. Die
Felder der ersten Tabelle bleiben leer, wenn kein passender Datensatz vorhanden ist.
Full-Outer-Join (Full-Join)
Der Full-Join ist eine Kombination aus dem Left-Outer-Join und dem Right-Outer-Join. Alle
Datensätze beider Tabellen werden in die Ergebnismenge übernommen. Passen alle Datensätze
aus beiden Tabellen laut Vergleichsoperation zusammen, so werden sie verbunden.
Semi-Join
Um einen Semi-Join zu erhalten, werden zwei Tabellen über einen Natural-Join verbunden.
Anschliessend erfolgt eine Projektion auf die Spalten der ersten Tabelle.
Self-Join
Verbindet eine Tabelle mit sich selber.
Mirco De Roni
- 42 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenabfrage über mehrere Tabellen
_____________________________________________________________________________________________
10.2
Einfaches Verknüpfen von Tabellen
Syntax der SELECT-Anweisung für einen Equi-Join
SELECT datenfeldliste FROM tabelle1, tabelle2, …
WHERE tabelle1.datenfeld = tabelle2.datenfeld [AND …];



Die Verknüpfung der Tabelle erfolgt in einer SELECT-Anweisung. In der Datenfeldliste werden die
gewünschten Datenfelder bzw. der Platzhalter * angegeben. Falls die Namen der Felder nicht
eindeutig sind, muss der Tabellenname mit einem Punkt vorangestellt werden.
Nach dem Schlüsselwort FROM werden durch Kommata getrennt die Namen der Tabellen
angegeben, die miteinander verknüpft werden sollen.
In der WHERE-Bedingung müssen die übereinstimmenden Datenfelder der Tabellen angegeben
werden.
Ersatznamen für Tabellen definieren
SELECT m.Vorname, m.Name, m.AbtNr, a.* FROM Mitarbeiter AS m, Abteilung AS a
WHERE m.AbtNr = a.ID;


Wenn Sie Ersatznamen für Tabellen definiert haben, müssen Sie diese Namen in der
Datenfeldliste, der WHERE-Bedingung und in weiteren Klauseln zwingend verwenden. Die
richtigen Tabellennamen sind in dieser Abfrage ungültig.
In der Datenfeldliste können Sie ebenfalls Ersatznamen für einzelne Felder mit der ASAnweisung definieren.
10.3
Tabellen verknüpfen mit JOIN
SELECT g.Bezeichnung, COUNT(fk_Artikel) AS [Anzahl verkaufte Artikel]
FROM Gruppen g LEFT JOIN Artikel a ON g.ID = a.fk_Gruppe
LEFT JOIN kauft k ON a.ID = k.fk_Artikel
GROUP BY g.Bezeichnung;
10.3.1 Cross-Join
Syntax
SELECT datenfelder FROM tabelle1 CROSS JOIN tabelle2 [WHERE bedingung];



Die Verknüpfung erfolgt in einer SELECT-Anweisung. Die Datenfelder, die in der Ergebnismenge
enthalten sein sollen, werden in der Datenbankliste angegeben. Auch der Platzhalter * kann
angegeben werden.
Nach dem Schlüsselwort FROM folgt der Name der ersten Tabelle. Nach der Angabe CROSS
JOIN wird der Name der zweiten Tabelle angegeben.
Zusätzlich können eine WHERE-Klausel und weitere Klauseln der SELECT-Anweisung verwendet
werden (z.B. ORDER BY, GROUP BY).
10.3.2 Inner-Join (Equi-Join)
Syntax
SELECT datenfeldliste FROM tabelle1 INNER JOIN tabelle2
ON tabelle1.datenfeld = tabelle2.datenfeld [WHERE …];



Die Verknüpfung erfolgt in einer SELECT-Anweisung. Die Datenfelder, die in der Ergebnismenge
enthalten sein sollen, werden in der Datenfeldliste angegeben. Auch der Platzhalter * kann
verwendet werden.
Nach dem Schlüsselwort FROM folgt der Name der ersten Tabelle. Nach den Schlüsselwörtern
INNER JOIN folgt der Name der zweiten Tabelle.
Die zu vergleichenden Datenfelder beider Tabelle werden nach dem Schlüsselwort ON
angegeben.
Mirco De Roni
- 43 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenabfrage über mehrere Tabellen
_____________________________________________________________________________________________

Zusätzlich können eine WHERE-Klausel und weitere Klauseln der SELECT-Anweisung verwendet
werden (z.B. ORDER BY, GROUP BY).
10.3.3 Natural-Join
Ein Inner-Join wird zum Natural-Join, wenn gleiche Spalten entfernt werden.
Syntax
SELECT DISTINCT datenfeldliste FROM tabelle1 INNER JOIN tabelle2
ON tabelle1.datenfeld = tabelle2.datenfeld [WHERE …];
10.3.4 Theta-Join
Ein Theta-Join wird wie ein Equi-Join bzw. Inner-Join erstellt, es wird aber in der ON-Klausel nicht auf
Gleichheit geprüft, sondern ein anderer logischer Operator eingesetzt. Als logische Operatoren sind die
Zeichen >, <, >=, <=, < > erlaubt.
Syntax
SELECT datenfeldliste FROM tabelle1 INNER JOIN tabelle2
ON tabelle1.datenfeld > tabelle2.datenfeld [WHERE …];
10.3.5 Outer-Join
Beim Outer-Join wird zwischen einem Verknüpfen von links und von rechts unterschieden. Damit können
sie festlegen, ob die Tabelle links oder rechts des Schlüsselworts JOIN vollständig übernommen wird.
Die entsprechenden Join-Typen werden mit LEFT OUTER JOIN für das Verknüpfen von links und RIGHT
OUTER JOIN für das Verknüpfen von rechts bezeichnet.
Syntax
SELECT datenfeldliste FROM tabelle1 LEFT|RIGHT OUTER JOIN tabelle2
ON bedingung …;



Der Outer-Join wird ähnlich dem Inner-Join gebildet. Nach dem Schlüsselwort FROM folgt der
Name der ersten Tabelle. Über die Angabe von LEFT OUTER JOIN bzw. RIGHT OUTER JOIN
wird diese mit der zweiten Tabelle verknüpft.
Nach dem Schlüsselwort ON wird die Bezeichnung zwischen den Join-Feldern angegeben.
Die Tabelle vor dem OUTER JOIN wird als linke Tabelle, die andere als rechte Tabelle
bezeichnet. Je nachdem, ob LEFT oder RIGHT OUTER JOIN angegeben ist, wird die linke oder
rechte Tabelle vollständig in das Abfrageergebnis übernommen.
10.3.6 Eine Tabelle mit sich selber verknüpfen (Self-Join)
Syntax
SELECT datenfeldliste FROM tabelle AS ersatznamen1
INNER JOIN tabelle AS ersatznamen2
ON tabelle.datenfeld = tabelle.datenfeld [WHERE …];
10.4
Zwei Tabellen vereinigen
Mit Joins verknüpfen Sie zwei oder mehr Tabellen so, dass bestimmte Datensätze aus den
verschiedenen Tabellen miteinander kombiniert werden. Zwei oder mehr Datensätze werden jeweils in
einen Datensatz der Ergebnismenge aufgenommen. Meist ist die Verknüpfung von einem Vergleich
bestimmter Felder der Tabellen abhängig.
Neben dieser Möglichkeit können Sie auch zwei Abfragen vereinigen, sodass eine Ergebnismenge
entsteht, die sowohl Datensätze der ersten als auch der zweiten Abfrage enthält.
Vom Datenbanksystem MySQL werden Vereinigungsmengen nicht unterstützt.
Mirco De Roni
- 44 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Datenabfrage über mehrere Tabellen
_____________________________________________________________________________________________
Beispiel:
SELECT Name, Ort FROM t_ma WHERE Ort = ‘Littau‘
UNION SELECT Name, Ort FROM t_ma_luzern;
10.5
Schnitt- und Differenzmengen
Auf die gleiche Weise wie die Vereinigungsmenge lassen sich Schnitt- und Differenzmengen erzeugen.
Zwei Abfragen werden dazu über die Schlüsselwörter INTERSECT bzw. MINUS verbunden.
Beispiel:
SELECT Name, Ort FROM t_ma
INTERSECT SELECT Name, Ort FROM t_ma_ch;
SELECT Name, Ort FROM t_ma
MINUS SELECT Name, Ort FROM t_ma_ch;
Mirco De Roni
- 45 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Sichten
_____________________________________________________________________________________________
11 Sichten
11.1
Vordefinierte Abfragen
Eine wichtige Eigenschaft der Tabellen eines Datenbanksystems ist deren physikalische Existenz als
strukturierte Sammlung von Daten auf einem Speichermedium.
Abfragen sind eine Möglichkeit, die benötigten Daten bereitzustellen. Sie müssen aber immer wieder
eingegeben werden. Um diese Arbeit einzusparen, können Sie vordefinierte Abfragen, so genannte
Sichten (engl. views), verwenden. Sichten sind gespeicherte SELECT-Anweisungen, die bis auf ihre
Definition keinen zusätzlichen Speicherplatz benötigen. Sie verwenden automatisch die aktuellen
Datensätze der zugrunde liegenden Tabellen.
Durch das Verwenden von Sichten kann der Zugriff auf die Daten ausschliesslich auf die Benutzer
beschränkt werden, für die sie relevant sind.
11.2
Sichten erstellen
Sichten werden mit der SQL-Anweisung CREATE VIEW erstellt.
Syntax
CREATE VIEW viewname AS SELECT datenfeldliste
FROM tabellenname
WHERE bedingung;
Abfragen für Sichten
In der SELECT-Anweisung, die einer Sicht zugrunde liegen soll, sind beliebige WHERE-Klauseln gestattet.
Auch Abfragen über mehrere Tabellen (Joins) sind möglich.
Nicht zulässig sind dagegen folgende Klauseln:
 GROUP BY und HAVING
 ORDER BY
 UNION
In folgenden Fällen ist die Angabe von Ersatznamen für Datenfelder zwingend notwendig:
 Wenn die Namen der Datenfelder bei Abfragen über mehrere Tabellen nicht eindeutig sind.
 Wenn in der Abfrage Ausdrücke oder Aggregatfunktionen verwendet werden.
Sichten über mehrere Tabellen
CREATE VIEW v_ma_proj
(MitarbeiterNr, Mitarbeitername, ProjektNr, Projektname) AS
SELECT m.ID, m.Name, p.ID, p.Name FROM t_ma_proj mp
INNER JOIN t_ma m ON mp.ma_ID = m.ID
INNER JOIN t_proj p ON mp.proj_ID = p.ID;
SELECT * FROM v_ma_proj WHERE ProjektNr = 1;
Syntax
CREATE VIEW viewname [(datenfeldliste)] AS SELECT …;




Die Anweisung wird von den Schlüsselwörtern CREATE VIEW eingeleitet. Danach folgt der Name
der Sicht.
In runden Klammern erfolgt die Angabe der Datenfeldnamen der Sicht. Die Reihenfolge
entspricht den Datenfeldern in der SELECT-Anweisung.
Falls die Namen der Datenfelder in der Abfrage eindeutig sind, kann die Datenfeldliste entfallen.
In diesem Fall werden die Namen aus der Abfrage verwendet.
Nach dem Schlüsselwort AS folgt die Angabe der SELECT-Anweisung. Diese kann eine WHEREKlausel enthalten und mehrere Tabellen verknüpfen.
Mirco De Roni
- 46 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Sichten
_____________________________________________________________________________________________

In der Abfrage dürfen die Klauseln GROUP BY, HAVING, ORDER BY und UNION nicht verwendet
werden.
Um eine Sicht zu erstellen, müssen Sie über das entsprechende Recht verfügen. Dieses Recht wird mit
der Anweisung GRANT CREATE VIEW gewährt. Zusätzlich benötigen Sie Leserechte für alle an der
Abfrage beteiligten Tabellen.
11.3
Sichten löschen
Sichten werden mit der Anweisung DROP VIEW gelöscht.
Syntax
DROP VIEW viewname;



Die Anweisung beginnt mit den Schlüsselwörtern DROP VIEW. Danach folgt der Name der Sicht.
Falls die Sicht zu diesem Zeitpunkt durch andere SQL-Anweisungen, z.B. eine SELECTAnweisung, verwendet wird, kann sie nicht gelöscht werden.
Falls Sichten existieren, die auf der gelöschten Sicht basieren, werden diese ebenfalls gelöscht.
11.4
Daten über Sichten einfügen und ändern
Unter bestimmten Voraussetzungen können Sichten auch zum Eingeben und Ändern von Daten
verwendet werden. Die INSERT-, UPDATE- und DELETE-Anweisungen sind jedoch nur in folgenden
Fällen erlaubt:



In SELECT-Anweisungen der Sicht wird nicht das Schlüsselfeld DISTINCT verwendet.
Die Sicht bezieht sich nur auf eine Tabelle. Joins sind beim Ändern von Daten nicht gestattet.
Die Abfrage verwendet keine Unterabfragen in der Bedingung.
Syntax
INSERT INTO viewname (feld1, …, feldX) VALUES (‘wert1‘, ‘…‘, ‘wertX‘);
Daten beim Verändern überprüfen
Wird in der SELECT-Anweisung, die der Sicht zugrunde liegt, eine WHERE-Klausel angegeben, wird die
Situation beim Einfügen, Ändern oder Löschen von Daten der Sicht undurchsichtiger. Sie können zwar
auch jetzt diese Operationen ausführen, die Sicht enthält jedoch nur die Datensätze, auf die die
angegebene Bedingung zutrifft.
Wollen Sie erreichen, dass nur Datensätze eingefügt, gelöscht oder geändert werden können, die in der
Sicht auch angezeigt werden, fügen Sie der Definition der Sicht die Klausel WITH CHECK OPTION hinzu.
CREATE VIEW viewname AS SELECT … WITH CHECK OPTION;

Nach der Abfrage wird die Klausel WITH CHECK OPTION angegeben, damit eine Überprüfung
der Datensätze, die geändert, eingefügt oder gelöscht werden sollen, mit der WHERE-Klausel der
Abfrage erfolgt.
Mirco De Roni
- 47 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
12 Transaktionsverwaltung
12.1
Konsistente Datenbestände und Transaktionen
Datenbanksysteme erlauben den gleichzeitigen Datenzugriff mehrerer Benutzer. Bei lesendem Zugriff auf
die Daten ist dies kein Problem. Wenn jedoch mehrere Benutzer zur selben Zeit die gleichen Datensätze
bearbeiten, muss das Datenbanksystem für die Konsistenz der Daten sorgen.
Die Datenkonsistenz muss jedoch auch bei Fehlern gewährleistet werden, die z.B. durch Programmfehler
oder Hardwareausfälle auftreten können. Das Datenbanksystem muss daher in der Lage sein, die
betroffenen Daten in jedem Fall in den letzten konsistenten Zustand zu überführen. Zu diesem Zweck
verwenden die meisten Systeme die so genannte Transaktionsverwaltung.
12.1.1 Transaktionen
Transaktionen sind eine Gruppe von logisch zusammenhängenden Datenbankoperationen (SQLAnweisungen), die nur gemeinsam ausgeführt werden sollen. Kann auf Grund eines Fehlers, einer
Zugriffsverletzung oder Ähnlichem eine der Operationen nicht ausgeführt werden, dann wird keine der
Operationen in der Transaktion ausgeführt und der Datenbestand wird in den Ausgangszustand versetzt.
Eigenschaften einer Transaktion
Das Datenbanksystem garantiert bei der Ausführung einer Transaktion die Einhaltung der vier
grundlegenden Eigenschaften, die auch als ACID-Eigenschaften bezeichnet werden:
Atomicity – Atomarität
‘Alles oder Nichts‘
Consistency – Konsistenz
Isolation – Isolation
Durability – Dauerhaftigkeit
Mirco De Roni
Die Transaktionen, die aus einer oder mehreren Operationen
bestehen kann, wird entweder vollständig ausgeführt oder gar nicht.
Tritt während der Transaktion ein Fehler auf (z.B. Programmfehler,
Hardwarefehler oder Betriebssystemabsturz), werden alle bisherigen
Operationen der Transaktion rückgängig gemacht.
Ist die Transaktion abgeschlossen, befindet sich die Datenbank in
einem konsistenten Zustand. Dazu tragen die definierten
Integritätsbedingungen (Wertebereiche, Schlüsseleigenschaften,
Fremdschlüssel usw.) bei, welche die logische Konsistenz sichern.
Verletzungen dieser Integritätsbedingungen führen zum
Zurücksetzen der Transaktion. Während einer Transaktion können
aber zwischenzeitlich inkonsistente Zustände auftreten, die mit einer
weiteren Operation wiederhergestellt werden.
Transaktionen laufen isoliert ab, mehrere gleichzeitig ablaufende
Transaktionen stören und beeinträchtigen sich nicht gegenseitig. Das
wird seitens des DBMS durch geeignete
Synchronisationsmassnahmen erreicht. Dies ist eine wichtige
Voraussetzung zur Sicherung der Konsistenz der Datenbank.
Das Ergebnis einer erfolgreichen Transaktion ist dauerhaft
(persistent). Das bedeutet, dass vom DBMS sichergestellt wird, dass
auch beim Auftreten von Fehlern bei der Übertragung der
Transaktionsergebnisse in die Datenbank die Änderungen vollständig
durchgeführt werden.
- 48 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
12.1.2 Isolationsebenen (Transaction Isolation Level)
Durch den Transaction Isolation Level wird der Grad der Parallelität von Transaktionen gesteuert.
 Je höher Sie den Level wählen, desto sicherer können Benutzer sein, dass sie bei einer
Leseaktion die aktuellen Daten erhalten und umso weniger Probleme bezüglich der Konsistenz
können auftreten.
 Je höher Sie aber die Isolationsebenen wählen, desto geringer ist der Durchsatz bei einer
grossen Zahl gleichzeitiger Zugriffe, was durch die notwendigen zeitweiligen Sperrungen der
Daten hervorgerufen wird.
Isolationsebene 0:
READ UNCOMMITTED
Auf Daten, die von einer Transaktion geschrieben werden, kann
mittels einer anderen Transaktion lesend zugegriffen werden. Dabei
können zum Teil neue und veraltete Daten gelesen werden =
unsauberes Lesen (Dirty Read). Von der Transaktion werden keine
Sperren auf die Datensätze gesetzt.
Datensätze, die von der Transaktion modifiziert werden, sind
gesperrt, Datensätze, die nur gelesen wurden, aber nicht. Dadurch
können die Datensätze, die nur gelesen wurden, zwischenzeitlich
geändert werden. Das Problem des inkonsistenten Lesens und das
so genannte Phantome-Problem können auftreten.
Die Transaktion sperrt alle Datensätze, die von ihr gelesen und
geschrieben werden. Nur das Phantome-Problem kann hier noch
auftreten.
Damit wird sichergestellt, dass in einer Transaktion gelesene Daten
bis zum Ende der Transaktion gültig sind. Das Lesen von so
genannten Phantome wird verhindert. Diese Ebene bietet volle
Serialisierbarkeit.
Isolationsebene 1:
READ COMMITTED
Isolationsebene 2:
REPEATABLE READ
Isolationsebene 3:
SERIALIZABLE
12.1.3 Das Transaktionsprotokoll
Das Transaktionsprotokoll ist eine interne Tabelle, die das Datenbanksystem genau wie alle anderen
Tabellen verwaltet. Kommt es zu einem Fehler oder wird ein ROLLBACK-Befehl an die Datenbank
abgesetzt, so werden die im Transaktionsprotokoll vorhandenen Informationen dazu genutzt, den
Zustand vor der Transaktion wiederherzustellen.
TID
TNUM
PREV
NEXT
OPERATION
TABELLE
ATTRIBUT
…
WERT
VORHER
…
WERT
NACHHER
…
…
2487
2488
2489
2490
…
…
125
125
125
125
…
…
NULL
2487
2488
2489
…
…
2488
2489
2490
NULL
…
…
START
UPDATE
UPDATE
COMMIT
…
…
NULL
KONTEN
KONTEN
NULL
…
Kontostand
Kontostand
1000
1000
500
2000
…
…
…
Für jede Transaktion wird ein Starteintrag, ein Eintrag für jede Veränderung an der Datenbank und ein
Endeintrag in das Transaktionsprotokoll geschrieben. Anhand dieser Informationen kann jederzeit
nachvollzogen werden, welche Befehle während der Transaktion durchgeführt wurden und welche
Änderungen diese Befehle in der Datenbank zur Folge hatten.
 Wird die Transaktion erfolgreich durchgeführt, so werden die Änderungen in die Datenbank
übernommen
 Schlägt die Transaktion fehl, so werden die Änderungen, die anhand des Transaktionsprotokolls
ermittelt wurden, wieder rückgängig gemacht.
Achtung
Das Transaktionsprotokoll ist eine der kritischsten Komponenten des ganzen Datenbanksystems. Wird
das Transaktionsprotokoll zerstört oder beschädigt, so kann dies dazu führen, dass die ganze Datenbank
nicht mehr verwendet werden kann. Aus Geschwindigkeitsgründen lagern manche Datenbanksysteme
das Transaktionsprotokoll in den Hauptspeicher des Rechners aus, was das ganze System extrem
empfindlich gegen Stromunterbrechungen macht. Ein Datenbankserver sollte daher stets an einer
unterbrechungsfreien Stromversorgung betrieben werden.
Mirco De Roni
- 49 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
12.2
Transaktionen erstellen
Transaktionen werden mit der SET TRANSACTION-Anweisung gestartet. Dabei können Sie mit
verschiedenen Klauseln steuern, wie sich das DBMS während der Transaktion in Bezug auf Zugriffe
anderer Transaktionen auf die gleichen Tabellen verhalten soll. Zusätzlich ist es möglich, nur lesende
Zugriffe oder lesende und schreibende Zugriffe für die Anweisungen der Transaktion zuzulassen.
Syntax der SET TRANSACTION-Anweisung
SET TRANSACTION [transaktionsname] [READ WRITE|READ ONLY] [WAIT|NO WAIT]
[ISOLATION LEVEL SNAPSHOT|READ COMMITTED|SNAPSHOT TABLE STABILITY];




Die Anweisung beginnt mit den Schlüsselwörtern SET TRANSACTION. Danach kann ein
Transaktionsname angegeben werden.
Über die Schlüsselwörter READ WRITE oder READ ONLY können Sie steuern, für welche Zugriffe
die Sperrung der Tabellen für die Operationen während der Transaktion erfolgen soll.
Dann kann über die Klausel WAIT bzw. NO WAIT das Warteverhalten der Transaktion in Bezug
auf andere Prozesse beeinflusst werden.
Optional kann durch die Klausel ISOLATION LEVEL, gefolgt von den entsprechenden
Schlüsselwörtern, angegeben werden, welche Isolationsebene für die Transaktion eingestellt
werden soll.
Zugriffsart für Tabellen festlegen
Mit den Optionen READ WRITE und READ ONLY können Sie festlegen, ob während der Transaktion alle
Zugriffsarten oder nur lesende Zugriffe auf die Daten ausgeführt werden sollen.
READ WRITE
READ ONLY
Die Operationen der Transaktion können Daten aus den betreffenden Tabellen
lesen und Datensätze in den Tabellen ändern, löschen und neu einfügen.
Die Operationen der Transaktion dürfen nur Daten aus den Tabellen mit der
SELECT-Anweisung lesen.
Die READ WRITE-Option ist die Standard-Einstellung. Diese Angabe kann daher auch weggelassen
werden.
Das Datenbanksystem MySQL unterstützt die Optionen READ WRITE und READ ONLY nicht. Dafür
kann durch die Anweisung LOCK TABLES das Lese- bzw. Schreibrecht für den aktuellen Thread
eingeräumt werden. Beispielsweise kann auf die Tabelle lager nur noch lesend zugegriffen werden, wenn
sie durch die Anweisung
LOCK TABLES lager READ;
gesperrt wird. Durch den Aufruf von UNLOCK TABLES wird diese Sperrung wieder aufgehoben.
Warten auf andere Prozesse
Mit den Optionen WAIT und NO WAIT steuern Sie das Verhalten der Transaktionen, wenn andere
Transaktionen gerade auf die gleichen Daten zugreifen.
WAIT
NO WAIT
Wird festgestellt, dass eine andere Transaktion auf die gleichen Tabellen
zugreift, wird mit den Operationen der Transaktion gewartet, bis alle anderen
Zugriffe beendet wurden. Dadurch werden Zugriffskonflikte vermieden.
Beim gleichzeitigen Zugriff anderer Transaktionen auf die an der Transaktion
beteiligten Tabellen wird sofort eine Fehlermeldung erzeugt und die Transaktion
wird abgebrochen.
Die Option WAIT ist Standard-Einstellung. Sie kann daher auch weggelassen werden.
Die Option NO WAIT ist sinnvoll, wenn Sie z.B. bei Lesezugriffen auf eine Tabelle sofort erfahren
möchten, dass die Abfrage möglicherweise ungültige und nicht mehr aktuelle Daten liefert.
Unter MySQL sind die Optionen WAIT und NO WAIT nicht verfügbar.
Mirco De Roni
- 50 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Isolation Level
Mit der Option ISOLATION LEVEL können Sie beim Erstellen einer Transaktion steuern, wie diese von
anderen Transaktionen isoliert werden soll. Die Isolation der Daten bei konkurrierenden Transaktionen
auf den gleichen Datenbestand ist ein wichtiges Merkmal vieler relationaler Datenbanksysteme.
Bei der Isolation der Daten entsteht das Problem, dass einerseits der parallele Zugriff mehrerer Benutzer
unbedingt erwünscht ist, andererseits jedoch die Konsistenz der Daten durch isolierte Transaktionen
bewahrt werden soll. Durch eine zu starke Isolation verliert ein Datenbanksystem seine Tauglichkeit für
die Nutzung durch sehr viele parallele Benutzerzugriffe. Die meisten Datenbanksysteme verfügen daher
über unterschiedliche Implementierungen der Klausel ISOLATION LEVEL. Mehr Informationen darüber
finden Sie im Hilfesystem der Datenbank.
Besonderheiten bei MySQL


Wenn Transaktionen durchgeführt werden sollen, muss als SQL-Server mysqld-max verwendet
werden.
Transaktionen sind nur für Tabellen möglich, die bei der Deklaration mit dem Typ BDB versehen
wurden.
CREATE TABLE T_MA_BDB
(ID INTEGER NOT NULL, … PRIMARY KEY (ID))
TYPE = BDB;

12.3
Auch die Erstellung der Tabellen, die für die Transaktion verwendet werden sollen, muss unter
dem Server mysqld-max erfolgen.
MySQL verwendet für das Starten einer Transaktion die Anweisung BEGIN ohne weitere
Parameter.
Transaktionen abschliessen
Mir der Anweisung COMMIT schliessen Sie eine Transaktion ab. Alle Änderungen an den Daten werden
daraufhin endgültig durchgeführt.



Alle Änderungen werden fest in die Datenbank geschrieben.
Die neuen Daten werden für andere Prozesse sichtbar gemacht.
Alle offenen Cursor werden geschlossen.
Auch wenn in der Transaktion nur SELECT-Abfragen verwendet wurden, sollten Sie die Transaktion mit
COMMIT beenden, da eventuell andere Prozesse auf den Zugriff warten.
Syntax der COMMIT-Anweisung
SET TRANSACTION …;
…
COMMIT [TRANSACTION transaktionsname];



12.4
Die Anweisung beginnt mit dem Schlüsselwort COMMIT.
Einige Datenbanksysteme erwarten danach das Schlüsselwort TRANSACTION.
Wurde beim Erstellen einer Transaktion ein Name angegeben, so kann gezielt diese Transaktion
beendet werden. Standardmässig wird die aktuelle Transaktion abgeschlossen.
Transaktionen zurücksetzen
Transaktionen erlauben das Zurücknehmen aller Änderungen an den Daten bis zum Zustand vor der
Transaktion. Dies erreichen Sie mit der ROLLBACK-Anweisung. Die Anweisung nimmt stets alle
Anweisungen in ihrer Gesamtheit zurück. Es ist nicht möglich, einzelne Änderungen zu verwerfen. Wie
mit der COMMIT-Anweisung wird auch mit ROLLBACK die Transaktion beendet.
Mirco De Roni
- 51 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Falls das Datenbanksystem aufgrund eines Fehlers abstürzt, wird beim Neustart in der Regel
automatisch ein ROLLBACK ausgeführt und alle noch offenen Transaktionen werden verworfen.
Syntax der ROLLBACK-Anweisung
SET TRANSACTION …;
…
ROLLBACK [TRANSACTION transaktionsname];


12.5
Die Anweisung beginnt mit dem Schlüsselwort ROLLBACK.
Falls beim Erstellen einer Transaktion ein Name angegeben wurde, kann mithilfe des
Schlüsselworts TRANSACTION, gefolgt vom gewünschten Namen, eine Transaktion gezielt
zurückgenommen werden.
Konkurrierende Zugriffe
Transaktionen sollen dabei helfen, Datenbanken beim gleichzeitigen, konkurrierenden Zugriff konsistent
zu halten. Es können folgende Probleme beim gleichzeitigen, konkurrierenden Zugriff entstehen:
 Lost Updates
 Dirty Reads
 Nonrepeatable Reads
 Phantome
12.5.1 Lost Updates
Das Lost Update-Problem tritt auf, wenn zwei Benutzer in engen zeitlichen Abständen auf die Datenbank
zugreifen und dort Änderungen vornehmen.
Mirco De Roni
- 52 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
12.5.2 Dirty Reads
Das Dirty Read-Problem tritt dann auf, wenn auch unbestätigte Transaktionen berücksichtigt werden und
zwischenzeitlich ein Rollback (z.B. durch einen Rechnerabsturz) durchgeführt werden.
Das Dirty Read-Problem kann nur dann umgangen werden, wenn das Datenbanksystem beim
Zurückliefern von Werten niemals unbestätigte Transaktionen berücksichtigt.
12.5.3 Nonrepeatable Reads
Wird innerhalb einer Transaktion ein Wert mehrfach aus der Datenbank ausgelesen, so muss dieser Wert
gleich sein, auch wenn er inzwischen von anderen Benutzern verändert wurde.
Mirco De Roni
- 53 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Das Nonrepeatable-Read-Problem bekommt man nur dann in den Griff, wenn jeder Benutzer der
Datenbank den Datenbestand über die gesamte Zeitdauer der Transaktion hinweg genau so sieht, wie
dieser zum Start der Transaktion vorlag. Somit muss ein relationales Datenbankmanagement-System für
jeden Benutzer eine eigene Sicht auf die Daten zur Verfügung stellen. Nur dann kann gewährleistet
werden, dass ein Benutzer immer dieselben Daten innerhalb einer Transaktion aus der Datenbank
auslesen kann.
12.5.4 Phantome
Das Problem der Phantome tritt auf, wen nacheinander Werte eingelesen werden, die verrechnet werden
und wenn zwischenzeitlich einer dieser Werte von einem anderen Benutzer geändert wurde.
12.6
Sperrmechanismen
Sperren (engl. Locks) garantieren einer Transaktion den exklusiven Zugriff auf einen bestimmten Teil der
Datenbank, das heisst, wenn ein Teil der Datenbank durch eine Transaktion gesperrt ist, so kann keine
andere Transaktion auf diesen Teil der Datenbank zugreifen.
Bevor eine Transaktion auf Daten aus der Datenbank zugreift, wird zunächst Zugriff auf diese Daten
angefordert. Kann dieser Zugriff gewährleistet werden, so richtet die Transaktion, der den Zugriff gewährt
wurde, eine Sperre ein, um damit zu signalisieren, dass die gesperrten Daten nun bearbeitet werden und
um anderen Transaktionen den Zugriff auf diese Daten zu verwehren. Nachdem die Transaktion ihre
Aufgaben durchgeführt hat und die Daten entweder erfolgreich in der Datenbank geändert werden
konnten oder die Änderungen bei Misserfolg zurückgenommen worden sind, wird die Sperre wieder
freigegeben und andere Transaktionen können wieder auf die Daten zugreifen.
12.6.1 Granularität
Unter der Granularität von Sperren versteht man, auf welcher Ebene eine Sperre die Datenbank sperrt.
Es ist möglich, dass eine Sperre die gesamte Datenbank, einzelne Tabellen, einzelne Seiten von
Tabellen, Datensätze oder sogar nur Felder sperrt.
Mirco De Roni
- 54 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Sperren auf Datenbankebene
Wird eine Sperre auf Datenbankebene errichtet, so ist die gesamte Datenbank gesperrt, das heisst, eine
andere Transaktion kann gar nicht auf die Datenbank zugreifen, selbst wenn sie ganz andere Daten
bearbeiten möchte als die Transaktion, die die Datenbank gesperrt hat.
Sperren, die die komplette Datenbank sperren, kommen in der Praxis nur dann zum Einsatz, wenn
extrem kritische Operationen durchgeführt werden sollen, die viele Tabellen der Datenbank betreffen und
man sicherstellen möchte, dass kein anderer Anwender in dieser Zeit Änderungen vornehmen darf.
Sperren auf Tabellenebene
Bei der Sperrung auf Tabellenebene wird nur eine komplette Tabelle gesperrt. Der Zugriff auf
verschiedene Tabellen ist problemlos möglich. Greift eine Transaktion auf mehrere Tabellen zu, so
werden alle benötigten Tabellen gesperrt.
Ein solcher Sperrmechanismus ist natürlich besonders bei Tabellen kritisch, die ständig von
verschiedenen Benutzern aktualisiert werden müssen, wie beispielsweise Tabellen, in denen
Bestellungen verwaltet werden.
Mirco De Roni
- 55 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Sperren auf Seitenebene
Bei der Sperrung auf Seitenebene wird eine Sperre für eine einzige Seite angefordert, das heisst,
mehrere Transaktionen können gleichzeitig Datensätze in derselben Tabelle verändern, solange diese
auf verschiedenen Seiten liegen.
Sperren auf Datensatzebene
Bei der Sperrung auf Datensatzebene kommen sich die Transaktionen nur noch dann in die Quere, wenn
sie gleichzeitig auf denselben Datensatz zugreifen möchten.
Sperren auf Feldebene
Flexibelste Sperrung. Hier stören sich gleichzeitige Transaktionen nur noch dann, wenn sie gleichzeitig
auf dasselbe Feld desselben Datensatzes zugreifen möchten. Unterschiedliche Felder desselben
Datensatzes können von verschiedenen Transaktionen gleichzeitig bearbeitet werden. Der Nachteil und
auch der Grund, warum Sperren auf Feldebene keine grosse Bedeutung bei professionellen
Datenbanksystemen besitzen, ist der, dass hier für jedes Feld jedes Datensatzes jeder Tabelle eine
Sperre verwaltet werden muss.
Mirco De Roni
- 56 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
12.6.2 Sperrtypen
Über den Sperrtyp wird festgelegt, was eine andere Transaktion mit einem gesperrten Teil der Datenbank
machen darf. Man unterscheidet folgende Typen:
 Binäre Sperren
 Exklusive / Nicht-exklusive Sperren
Binäre Sperren
Unter einer binären Sperre versteht man eine Sperre, die zwei Zustände haben kann: gesperrt oder offen.
Werden binäre Sperre verwendet, so kann ein gesperrtes Objekt von einer anderen Transaktion gar nicht
verwendet werden.
Bei der Verwendung von binären Sperren wird das zu sperrende Objekt von der Transaktion gesperrt, die
dieses Objekt verwendet. Nachdem die Transaktion beendet wurde, wird das gesperrte Objekt wieder
freigegeben und eine andere Transaktion kann das Objekt sperren und selbst Änderungen vornehmen.
Während eine binäre Sperre aktiv ist, kann eine andere Transaktion nicht auf das Datenbankobjekt
zugreifen.
Exklusive / Nicht-exklusive Sperren
Eine nicht-exklusive Sperre kann immer dann gewährt werden, wenn das Datenbankobjekt, das gesperrt
werden soll, nicht-exklusiv gesperrt ist, das heisst, es muss entweder nicht gesperrt oder mit einer
anderen nicht-exklusiven Sperre gesperrt worden sein. Wurde ein Datenbankobjekt mit einer exklusiven
Sperre gesperrt, so kann vorübergehend keine nicht-exklusive Sperre eingerichtet werden. Nichtexklusive Sperren werden immer dann verwendet, wenn eine Transaktion lesend auf Objekte der
Datenbank zugreifen will.
Möchte eine Transaktion schreibend auf ein Datenbankobjekt zugreifen, das heisst, es wurden die
Befehle UPDATE, DELETE oder INSERT an die Datenbank abgesetzt, so muss eine exklusive Sperre
eingerichtet werden.
Probleme:
 Unter Umständen kann es passieren, dass die Transaktionen, die diese Sperren verwenden,
nicht mehr serialisierbar sind.
 Wenn Transaktionen Sperren auf mehreren Tabellen einrichten, so können Deadlocks auftreten.
Zwei-Phasen-Locking
Um zu verhindern, dass Transaktionen nicht mehr serialisierbar sind, wurde das Zwei-Phasen-LockingProtokoll entwickelt.
Hierbei gibt es eine Wachstumsphase, in der alle notwendigen Sperren errichtet werden und eine
Schrumpfphase, in der diese Sperren wieder gelöscht werden. In der Wachstumsphase können keine
Sperren freigegeben werden, während in der Schrumpfphase keine neuen Sperren errichtet werden
können.
Der Vorteil des Zwei-PhasenLocking-Protokolls besteht darin,
dass zwei verschiedene
Transaktionen keine Sperren
besitzen können, die in Konflikt
zueinander stehen und dass
Sperren nicht freigegeben werden
können, bevor sie eingerichtet
wurden.
Mirco De Roni
- 57 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Transaktionsverwaltung
_____________________________________________________________________________________________
Deadlocks
Unter einem Deadlock versteht man eine Situation, die auftritt, wenn zwei Transaktionen dieselben
Ressourcen benötigen, diese aber in verschiedener Reihenfolge belegen und somit jede der beiden
Transaktionen darauf wartet, dass die jeweils andere Transaktion die belegte Ressource wieder freigibt.
12.6.3 single-point-of-failure
Unter einem single-point-of-failure versteht man diejenigen Komponenten eines Systems, die nach einem
Ausfall den Komplettausfall eines Systems nach sich ziehen.
Mirco De Roni
- 58 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Trigger
_____________________________________________________________________________________________
13 Trigger
13.1
Prozeduren automatisch ausführen
Ein Trigger ist eine besondere Form der Stored Procedures, bei der die Prozedur nicht durch den
Anwender, sondern durch das Datenbanksystem selbst gestartet wird. Auf diese Weise können Sie einen
Datenbestand überwachen und automatisch Aktionen ausführen, wenn Datensätze in Tabellen eingefügt,
geändert oder gelöscht werden. Trigger bestehen aus drei wesentlichen Bestandteilen:
 Name des Triggers
 Bedingung, die besagt, wann der Trigger aktiv wird
 Ausführungsteil, ähnlich dem der Stored Procedures
In der Bedingung eines Triggers kann festgelegt werden, ob die Anweisungen im Ausführungsteil bei
einer INSERT-, einer UPDATE- oder einer DELETE-Anweisung aktiv werden. Der Ausführungsteil umfasst
in der Regel mehrere SQL-Anweisungen, bei denen, wie bei Stored Procedures auch, Variablen und
Kontrollstrukturen (WHILE, IF usw.) verwendet werden können.
Ein Trigger bezieht sich stets auf eine bestimmte Tabelle oder eine bestimmte Sicht. Es ist nicht möglich,
Trigger zu definieren, die gleichzeitig Änderungen in verschiedenen Tabellen überwachen. Sie können
jedoch für eine Tabelle mehrere Trigger erstellen, die verschiedene Ereignisse überwachen.
Nicht alle Integritätsregeln lassen sich deklarativ in der Datendefinition der Tabelle definieren. Mithilfe von
Triggern ist es möglich, Integritätsregeln prozedural zu überprüfen und somit einen weiteren Beitrag zur
Sicherung der referenziellen Integrität zu leisten. Beispielsweise kann das Einfügen ungültiger
Datensätze bezüglich bestimmter Werte verhindert werden.
Trigger werden in den folgenden Fällen angewendet:
 zur Wahrung der Datenintegrität, die über die einfache Aktualisierung von Referenzen hinausgeht
 zur Aktualisierung von Summen
 zur Aktualisierung von Spalten, die Rechenergebnisse beinhalten
 zur Pflege von Revisionsdatensätzen
 zur Durchführung von referenziellen Operationen, wie kaskadiertes Löschen
 zur Auslösung externer Aktionen
13.2
Trigger erstellen
Trigger werden mit der Anweisung CREATE TRIGGER erstellt. Die Syntax ist dabei dem Definieren einer
Stored Procedure ähnlich.
Syntax
CREATE TRIGGER triggername ON tabellenname
FOR INSERT, UPDATE
AS
BEGIN
…
END
Mirco De Roni
- 59 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Fragen und Antworten
_____________________________________________________________________________________________
14 Fragen und Antworten
Was sind die Vor- und Nachteile verteilter Datenbanksysteme?
Die Vorteile verteilter Datenbanksysteme liegen darin, dass die Gesamtmenge der Daten auf
verschiedene Standorte verteilt werden kann und hierdurch Datenzugriffszeiten erheblich reduziert
werden können. Des Weiteren bietet ein verteiltes Datenbanksystem im Gegensatz zum zentralen
System keinen single-point-of-failure aus. Die Nachteile des verteilten Datenbanksystems liegen
hauptsächlich in der erheblich komplexeren Struktur.
Was ist der Unterschied zwischen verteilter Datenverarbeitung und verteilten
Datenbanken?
Bei der verteilten Datenverarbeitung wird lediglich die Verarbeitung der Daten auf andere Systeme
ausgelagert, wie Sie das ja bereits von der Client-ServerArchitektur her kennen. Bei verteilten
Datenbanken geht es wirklich darum, dass sich die Datenhaltung über verschiedene physikalische
Standorte verteilt.
Was sind die Komponenten eines verteilten Datenbanksystems?
Ein verteiltes Datenbanksystem wird von einem DDBMS kontrolliert. Auf den Clients befindet sich ein
Transaktionsmanager, der sich darum kümmert dass die Daten auf den einzelnen Standorten richtig
angesprochen und die Datenmenge, die von verschiedenen Standorten zurückgeliefert wurde, wieder
richtig zusammengesetzt wird. Auf den Datenbankservern befinden sich Datenmanager, die auf die
verteilten Datenbankabfragen der einzelnen Clients antworten.
Was bedeutet Transparenz beim Datenzugriff?
Transparenz beim Datenzugriff bedeutet, dass es für den Benutzer nicht erkennbar sein soll, dass er statt
mit einem zentralen Datenbanksystem mit einer verteilten Datenbank arbeitet. Das DDBMS muss alle
Funktionen anbieten, die ein zentrales Datenbanksystem auch anbietet, darf aber die zusätzliche
Komplexität den Benutzer nicht spüren lassen.
Welche Arten von Transparenz beim Datenzugriff gibt es?
Beim Datenzugriff gibt es die totale Transparenz, bei der verteilte Tabellen genau so angesprochen
werden wie zentrale Tabellen auf einem zentralen Datenbankserver. Des Weiteren gibt es die
Ortstransparenz, das heißt, der Anwender muss wissen, dass die Tabelle, die er abfragen möchte, aus
mehreren Teilen besteht, er muss aber nicht wissen, wo sich diese Teile befinden. Zuletzt gibt es noch
Systeme ohne Ortstransparenz, das heißt, hier müssen die Anwender sowohl wissen, dass die
Datenbank in mehrere Teile aufgeteilt ist als auch, wo sich diese Teile befinden.
Warum ist ein transparentes Transaktionsmanagement notwendig?
Transparentes Transaktionsmanagement ist notwendig, da ein SQL-Befehl in einer verteilten Umgebung
Daten an mehr als einem Standort ändern kann. Kommt es nun an einem Standort zu Problemen, so
müssen die Änderungen an allen anderen Standorten auch wieder rückgängig gemacht werden. Daher
ist hier ein verteiltes, transparentes Transaktionsmanagement notwendig.
Wie funktionieren verteilte Transaktionen?
Bei einer verteilten Transaktion wird das Zwei-Phasen-Commit-Protokoll eingesetzt. Ein
Transaktionskoordinator sendet an alle an der Transaktion beteiligten Stationen den Befehl READY TO
COMMIT. Liefert eine Station eine negative Antwort zurück, so wird die verteilte Transaktion
abgebrochen. Haben alle Stationen bestätigt, so wird nun ein COMMIT an diese gesendet. Teilt eine
Station dem Transaktionskoordinator mit, dass sie das COMMIT nicht durchführen konnte, so wird die
gesamte Transaktion abgebrochen und der Ursprungszustand auf allen beteiligten Systemen wieder
hergestellt.
Was versteht man unter Datenfragmentierung?
Unter Datenfragmentierung versteht man die Aufteilung logisch zusammenhängender Daten, also
beispielsweise einer Tabelle, in mehrere physikalische Einheiten.
Mirco De Roni
- 60 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Fragen und Antworten
_____________________________________________________________________________________________
Welche Arten der Datenfragmentierung gibt es?
Es gibt die horizontale Fragmentierung, bei der die Tabellen Datensatzweise fragmentiert werden, die
vertikale Fragmentierung, bei der die Tabellen feldweise fragmentiert werden, und die gemischte
Fragmentierung, bei der die Datensätze sowohl feldweise als auch tabellenweise fragmentiert werden.
Was versteht man unter Replikation?
Bei der Replikation werden Datenbestände physikalisch an andere Standorte kopiert. Hiermit kann ein
schnellerer Datenzugriff gewährleistet werden. Diesen Geschwindigkeitsvorteil erkauft man sich aber
durch einen erhöhten Verwaltungsaufwand.
Mirco De Roni
- 61 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Glossar
_____________________________________________________________________________________________
15 Glossar
15.1
Transaktionen, konkurrierende Zugriffe, Sperrmechanismen
Binäre Sperre
Eine binäre Sperre ist eine Sperre, die genau 2 Zustände haben kann: gesperrt oder offen. Werden
binäre Sperren verwendet, so können andere Transaktionen das gesperrte Objekt gar nicht verwenden.
COMMIT
Befehl für die Transaktionssteuerung.
Alle Änderungen der Transaktion werden bestätigt und in der Datenbank festgeschrieben.
Deadlock
Situation, die entsteht, wenn zwei Transaktionen dieselben Ressourcen benötigen, diese aber in
verschiedener Reihenfolge belegen und somit jede der beiden Transaktionen darauf wartet, dass die
jeweils andere Transaktion die belegte Ressource wieder freigibt.
Dirty Reads
Dieses Problem tritt dann auf, wenn auch unbestätigte Transaktionen berücksichtigt werden und
zwischenzeitlich ein Rollback (z.B. durch einen Rechnerabsturz) durchgeführt wurde.
Exklusive Sperre
Nur die Transaktion, welche die exklusive Sperre errichtet hat, hat auch Lese- & Schreibrechte darauf.
Alle anderen Transaktionen müssen warten.
Konkurrierende Zugriffe
Lost Updates, Dirty Reads, Nonrepeatable Reads und Phantome
Lost Updates
Das Lost Update-Problem tritt auf, wenn zwei Benutzer in engen zeitlichen Abständen auf die Datenbank
zugreifen und dort Änderungen vornehmen.
Nicht-exklusive Sperre
Nicht-exklusive Sperren werden immer dann verwendet, wenn eine Transaktion lesend auf Objekte der
Datenbank zugreifen will.
Nonrepeatable Reads
Wird innerhalb einer Transaktion ein Wert mehrfach aus der Datenbank ausgelesen, so muss dieser Wert
gleich sein, auch wenn er inzwischen von anderen Benutzern verändert wurde.
Phantome
Das Problem der Phantome tritt auf, wenn nacheinander Werte eingelesen werden, die verrechnet
werden, und wenn zwischenzeitlich einer dieser Werte von einem anderen Benutzer geändert wurde.
ROLLBACK
Zurücksetzen einer Transaktion. Der Ursprungszustand wird somit wiederhergestellt.
Sperre (Lock)
Unter Locking (engl. für Sperren) versteht man in der Informatik das Sperren des Zugriffs auf eine
Ressource. Eine solche Sperre ermöglicht den exklusiven Zugriff eines Prozesses auf eine Ressource
d.h. mit der Garantie dass kein anderer Prozess diese Ressource liest oder verändert solange die Sperre
besteht.
Locking wird häufig bei Prozesssynchronisation sowie in Datei- und Datenbanksystemen verwendet um
atomare und konsistente Lese- und Schreibanforderungen zu gewährleisten.
Sperren auf Datenbankebene
Wird eine Sperre auf Datenbankebene errichtet, so ist die gesamte Datenbank gesperrt, das heisst, eine
andere Transaktion kann gar nicht auf die Datenbank zugreifen, selbst wenn sie ganz andere Daten
bearbeiten möchte als die Transaktion, die die Datenbank gesperrt hat.
Mirco De Roni
- 62 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Glossar
_____________________________________________________________________________________________
Sperren auf Datensatzebene
Bei der Sperrung auf Datensatzebene kommen sich die Transaktionen nur noch dann in die Quere, wenn
sie gleichzeitig auf denselben Datensatz zugreifen möchten.
Sperren auf Feldebene
Flexibelste Sperrung. Hier stören sich gleichzeitige Transaktionen nur noch dann, wenn sie gleichzeitig
auf dasselbe Feld desselben Datensatzes zugreifen möchten. Unterschiedliche Felder desselben
Datensatzes können von verschiedenen Transaktionen gleichzeitig bearbeitet werden.
Sperren auf Seitenebene
Bei der Sperrung auf Seitenebene wird eine Sperre für eine einzige Seite angefordert, das heisst,
mehrere Transaktionen können gleichzeitig Datensätze in derselben Tabelle verändern, solange diese
auf verschiedenen Seiten liegen.
Sperren auf Tabellenebene
Bei der Sperrung auf Tabellenebene wird nur eine komplette Tabelle gesperrt. Der Zugriff auf
verschiedene Tabellen ist problemlos möglich. Greift eine Transaktion auf mehrere Tabellen zu, so
werden alle benötigten Tabellen gesperrt.
Transaktionen
Transaktionen sind eine Gruppe von logisch zusammenhängenden Datenbankoperationen (SQLAnweisungen), die nur gemeinsam ausgeführt werden sollen. Kann auf Grund eines Fehlers, einer
Zugriffsverletzung oder Ähnlichem eine der Operationen nicht ausgeführt werden, dann wird keine der
Operationen in der Transaktion ausgeführt und der Datenbestand wird in den Ausgangszustand versetzt.
Transaktionsprotokoll
Das Transaktionsprotokoll ist eine interne Tabelle, die das Datenbanksystem genau wie alle anderen
Tabellen verwaltet. Kommt es zu einem Fehler oder wird ein ROLLBACK-Befehl an die Datenbank
abgesetzt, so werden die im Transaktionsprotokoll vorhandenen Informationen dazu genutzt, den
Zustand vor der Transaktion wiederherzustellen.
15.2
Verteilte DBS
Datenfragment
Unter einem Datenfragment versteht man einen Teil einer Tabelle oder einer Datenbank, der durch
Fragmentierung der gesamten Tabelle entstanden ist und an einem bestimmten Standort gespeichert
wird.
Datenfragmentierung
Wird eine einzelne Tabellen über mehrere Standorte verteilt, so spricht man von Datenfragmentierung.
Datenmanager
Der Datenmanager ist eine Software-Komponente eines verteilten Datenbanksystems, der auf den
einzelnen Datenbankservern läuft und den Zugriff der Transaktionsmanager auf die Datenbank steuert,
die auf den Clientrechnern des Datenbanksystems ausgeführt werden.
Datenreplikation
Bei der Datenreplikation werden Kopien der Daten an verschiedenen Standorten gehalten, um den Zugriff
auf diese Daten zu beschleunigen.
Distributed Database Management System (DDBMS)
Das DDBMS ist das Datenbankmanagement-System der verteilten Datenbank. Es kümmert sich darum,
dass die verteilte Umgebung alle Funktionen unterstützt, die bei einem zentralen Datenbanksystem
implementiert sind.
Mirco De Roni
- 63 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Glossar
_____________________________________________________________________________________________
DO
Der Befehl DO schreibt eine Datenänderung in das Transaktionsprotokoll. Hierbei wird sowohl der neue
als auch der alte Werte des Datenfeldes gespeichert, damit die Änderung gegebenenfalls wieder
rückgängig gemacht werden kann.
Gemischte Fragmentierung
Bei der gemischten Fragmentierung werden Tabellen sowohl horizontal als auch vertikal fragmentiert.
heterogenes verteiltes Datenbanksystem
Bei einem heterogenen verteilten Datenbanksystem sind die DBMS verschiedener Hersteller an der
verteilten Datenbank beteiligt.
homogenes verteiltes Datenbanksystem
Bei einem homogenen verteilten Datenbanksystem sind die auf den verschiedenen Servern installierten
DBMS vom selben Hersteller.
Horizontale Fragmentierung
Bei der horizontalen Fragmentierung wird eine Tabelle Datensatzweise fragmentiert, das heißt, jedes
Tabellenfragment enthält dieselben Felder, es ist nur die Anzahl der gespeicherten Datensätze
unterschiedlich.
Ortstransparenz
Unter Ortstransparenz versteht man, dass der Anwender, der auf ein Tabellenfragment zugreifen will,
nicht wissen muss, an welchem Ort sich dieses Tabellenfragment befindet.
REDO
REDO führt eine mittels UNDO zurückgenommene Änderung erneut aus.
Transaktionsmanager
Der Transaktionsmanager ist ein Programm, das auf jedem Computer ausgeführt wird, der auf das
verteilte Datenbanksystem zugreifen muss. Er kümmert sich darum, dass die Datenbankabfragen des
Clients an die richtigen Datenbankserver verteilt werden und fügt die von verschiedenen Servern
erhaltenen Daten auf dem Client lokal zusammen.
Transparenz
Unter Transparenz versteht man, dass die physikalische Verteilung des Datenbanksystems für den
Anwender nicht sichtbar ist.
UNDO
Mit Hilfe des Befehls UNDO kann man die durch eine Transaktion an der Datenbank vorgenommenen
Änderungen wieder zurücknehmen.
Verteilte Datenbank
Bei einer verteilten Datenbank ist die Datenhaltung über mehrere Standorte verteilt.
Verteilte Datenverarbeitung
Bei einer verteilten Datenverarbeitung ist die Verarbeitung der Daten über mehrere Standorte verteilt, so
wie das z.B. bei der Client-Server-Architektur üblich ist. Die verteilte Datenverarbeitung impliziert nicht,
dass die Datenhaltung auch verteilt ist. Verteilte Datenverarbeitung kann auch mit einer zentralen
Datenbank stattfinden.
Verteilte Transaktion
Eine verteilte Transaktion ändert Daten an mehreren Standorten einer verteilten Datenbank. Es muss bei
verteilten Transaktionen sichergestellt sein, dass die verteilte Transaktion nur dann erfolgreich ausgeführt
werden kann, wenn alle Teilaktionen an allen Standorten erfolgreich beendet werden konnten.
Verteiltes Datenbank Dictionary
Das Verteilte Datenbank Dictionary verwaltet, welche Daten sich an welchem Standort befinden. Es ist
selbst eine verteilte Datenbank, die auf jeden Standort vollständig repliziert wird.
Mirco De Roni
- 64 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Glossar
_____________________________________________________________________________________________
Vertikale Fragmentierung
Bei der vertikalen Fragmentierung werden Tabellen entsprechend ihrer Felder fragmentiert, das heißt, die
Struktur der Tabellen der einzelnen Tabellenfragmente ist unterschiedlich. Wichtig ist allerdings, das s die
Anzahl der Datensätze in beiden Tabellen gleich sein muss.
Vollständig verteiltes Datenbanksystem
Ein vollständig verteiltes Datenbanksystem besitzt eine verteilte Datenverarbeitung und eine verteilte
Datenhaltung.
Vollständige Transparenz
Besitzt eine verteilte Datenbank vollständige Transparenz, so stellt sich dieses System dem Benutzer
gegenüber wie ein zentrales Datenbanksystem dar.
Write-ahead-Modus
Beim Write-ahead-Modus wird das Transaktionsprotokoll auf die Festplatte geschrieben, bevor
Änderungen an der Datenbank selbst durchgeführt werden.
Zwei-Phasen-Commit-Protokoll
Das Zwei-Phasen-Commit-Protokoll wird dazu verwendet, verteilte Transaktionen zu steuern und um zu
garantieren, dass die Daten entweder an allen Standorten geändert werden konnten oder dass alle
Änderungen zurückgenommen werden.
Mirco De Roni
- 65 -
Zusammenfassung
SQL – Grundlagen und Datenbankdesign
Quellenverzeichnis
_____________________________________________________________________________________________
16 Quellenverzeichnis
Böttcher Ulrike / Teich Peter, SQL – Grundlagen und Datenbankdesign, 2006
Sandra Geisler / Frank Geisler, Datenbanken – Grundlagen und Design, 2009
Mirco De Roni
- 66 -
Zusammenfassung