home  |  suche  |  kontakt/johner  |  institut 
studierende  |  tech-docs  |  mindmailer 

Einführung

Die folgenden Abschnitte ersetzen keine vollständige Dokumentation, sondern sind nur als kurze Wiederholung der SQL-Syntax gedacht.

SQL, die Structured Query Language, ist eine standardisierte und datenbankunabhängige Sprache, um Datenbanken und Datenbankinhalte zu manipulieren. Sie besteht aus:

     

  • Data Definition Languae DDL: Erstellen von Datenbanken, Tabellen, Indizes
  • Data Manipulation Languge DML: Anlegen, Ändern und Löschen von Datensätzen
  • Data Query Language DQL: Abfragen von Daten
  • Data Control Language DCL: Anlegen von Benutzern, Vergabe von Zugriffsrechten

Zum Ausprobieren vieler dieser SQL-Befehle finden steht Ihnen ein Programm zur Verfügung.

Tabellen anlegen, ändern, löschen

Anlegen von Tabellen

Tabellen werden über folgenden Befehl angelegt:

CREATE TABLE <table_name> [<create_definition>],

mit <create_definition>

     

  • <column_name> <type> [NOT NULL | NULL] [PRIMARY KEY]
  • PRIMARY KEY (<column_name>)
  • [CONSTRAINT <symbol>] FOREIGN KEY (<column_name>, ...)
  • ..

wobei <type> für den SQL-Datentyp steht.

Beispiel

 

CREATE TABLE Students (
Id INTEGER NOT NULL,
PRIMARY KEY (Id),
Name VARCHAR (64),
Geburtsdatum Date
);

 

 

Ändern von Tabellen

Man kann auch zuerst die Tabelle anlegen und nachträglich den Primärschlüssel anlegen:

 

CREATE TABLE Students (
Id INTEGER,
Name VARCHAR (64),
Geburtsdatum Date
);

 

 

Dieser Tabelle kann ein Primärschlüssel hinzugefügt werden (Ändern der Tabelle):

 

ALTER TABLE Students ADD PRIMARY KEY Id;

 

 

Neben "ADD" gibt es weitere Befehle zum Ändern wie MODIFY, DROP, RENAME. Eine Übersicht findet sich beispielsweise hier.

 

Löschen von Tabellen

Syntax:

DROP TABLE <table_name>

Beispiel

 

DROP TABLE Students

 

 

Werte einfügen, ändern, löschen

Werte einfügen

Syntax:

INSERT INTO <table_name> [(<comma_separated_column_names)] VALUES (<comma_separted_values>);

Beispiele

 

INSERT INTO students VALUES (2, 'Gerda', '1997-12-23');
INSERT INTO students (Id, Name, Geburtsdatum) VALUES (2, 'Gerda', '1997-12-23');
INSERT INTO students (Id) VALUES (3);

 

Bitte beachten:

     

  • Die Spaltennamen müssen nur dann nicht angegeben werden, wenn in alle Spalten Werte eingetragen werden.
  • Zeichenketten und Datum sind in einfachen Hochkommata anzugeben

 

Werte ändern

UPDATE <table_name> SET <column_name> = <value> [<Bedingung>];

Beispiel (setzt in allen Datensätzen, bei denen die Spalte "Id" den Wert 2 hat, den Namen auf "Herbert"):

 

UPDATE students SET name = 'Herbert' WHERE id = 2;

 

Mehr zu den Bedingungen (<Bedingung>) findet sich im Abschnitt Werte abfragen.

 

Werte löschen

DELETE FROM <table_name> [<Bedingung>];

Beispiel (löscht alle Datensätze, bei denen in der Spalte "Name" der Wert "Gerd" ist):

 

DELETE FROM Students WHERE Name='Gerd';

 

Mehr zu den Bedingungen (<Bedingung>) findet sich im Abschnitt Werte abfragen.

Werte abfragen/Bedingungen

Syntax:

SELECT [ALL|DISTINCT] <select_item>

FROM <table_specification>

[WHERE <search_condition>]

[GROUP BY <grouping_condition>]

[HAVING ] <having_condition>]

[ORDER BY <sort_specification>]

[INTO TEMP <table_name2>]

 

wobei

     

  • WHERE: Beschränkt die Auswahl auf die Datensätze ein, für welche die Bedingung <search_condition> erfüllt ist
  • GROUP BY: Gruppiert die ausgewählten Datensätze nach den in <grouping_condition> angegebenen Spalten/Feldern
  • HAVING: Die mit GROUP BY gruppierten Datensätze können durch die Bedingung <having_condition> eingeschränkt werden. Auch Aggregatfunktionen (sum, avg usw.) können genutzt werden
  • ORDER BY: Sortiert die ausgewählten Datensätze nach der mit <sort_specification> bestimmten Reihenfolge
  • INTO TEMP: Die Ergebnisse können in die Tabelle <table_name2> geschrieben werden

<select_item> steht für die gewählten (durch Kommata getrennte) Spalten, * heißt alle Spalten der Tabelle(n). 

Beispiel

 

SELECT * FROM Students WHERE Name = 'Gerd';

 

 

WHERE

In der WHERE-Bedingung können Datensätze mit einer oder mehreren Bedinungen beschränkt werden. Die Bedingungen beziehen sich auf Werte in den angebenen Spalten und werden - falls mehrere Bedingungen angeben sind - mit den logischen Operatoren AND und OR verknüpft.

Als Bedinungen stehen zur Verfügung

     

  • Vergleichsoperatoren (<, >, <=, >=, <>, =):
    Id = 2
    Preis > 1000
    Name = 'Meier"
  • Bereichsprüfungen
    Preis BETWEEN 1000 AND 1010
  • Mustervergleich
    Name LIKE 'G%' (Inhalt der Spalte "Name" beginnt mit "G". Das Prozentzeichen steht als Platzhalter für kein, ein oder mehrere Zeichen. Genau ein Zeichen würde mit ? ausgedrückt)
  • Elementprüfung (prüft, ob Wert in Liste enthalten ist):
    Name IN (Maier', 'Mayer', 'Meier', 'Meyer')
  • Nullwertprüfung
    Name IS NULL
    Name IS NOT NULL

Mit NOT werden die Bedinungen negiert.

Beispiele:

 

SELECT Geburtsdatum FROM Students WHERE Name = 'Gerd' AND Id = 2;
SELECT * FROM Students WHERE Name LIKE 'Gerd%' AND Id <> 3;
SELECT * FROM Students WHERE Name NOT LIKE 'Gerd%';

 

 

Weiterhin erlaubt SQL, mit AS die Spaltennamen der Ergebnismenge zu modifizieren:

 

SELECT Name AS Vorname, Id AS Matrikelnummer FROM Students;

 

 

Gruppieren von Abfrageergebnissen (GROUP BY, HAVING)

Mit GROUP BY lassen sich Datensätze nach einem oder mehreren Kriterien zusammenfassen. Dabei kommen häufig Aggregationfunktionen zum Einsatz wie

     

  • COUNT(<spaltenname>): Anzahl der Attributwerte in der Spalte <spaltenname>
  • AVG(<spaltenname>): Durchschnitt der (numerischen) Attributwerte in der Spalte <spalten_name>
  • SUM(<spalten_name>)
  • MIN(<spalten_name>)
  • MAX(<spalten_name>)

Beispiel:

Gegeben sei eine Tabelle

 

Matrikel | Vorname | Nachname  | Semester | GebDatum   | Bafoeg
===============================================================
12345 | Anton | Kasper | WI3 | 01.03.1988 | 500
23456 | Gerda | Müller | IMUK5 | 22.04.1989 | 700
34567 | Albert | Schweizer | TI2 | 12.12.1990 | 120
45678 | Gerd | Müller | WI3 | 01.10.1978 | 87
56789 | Gerd | Schweizer | TI1 | 02.05.1980 | 250
67890 | Anton | Müller | WI3 | 12.06.1982 | 503
78901 | Otto | Radnik | IMUK1 | 23.09.1981 | 680

 

 

Die Anweisung

 

SELECT Nachname, AVG(Bafoeg)
FROM Student
GROUP BY Nachname;

 

wählt die Spalte Nachname aus und fügt eine Spalte mit dem Durchschnitt des Bafögs hinzu, wobei nach dem Nachnamen gruppiert wird:

 

Nachname  | AVG(Bafoeg)
=======================
Kasper | 500
Müller | 430
Radnik | 680
Schweizer | 185

 

Das bedeutet, dass die Studierenden mit dem Nachnamen Müller (Gerda, Gerd und Anton Müller) im Durchschnitt 430 (EUR) Bafoeg beziehen.

 

Mit der HAVING Klausel ließen sich nun noch weitere Bedingung an den gruppierten Wert stellen, beispielsweise könnten wir uns obigen Durchschnitt nur für die Nachnamen anzeigen lassen, die mehr als einmal vorkommen:

 

SELECT Nachname, AVG(Bafoeg) 
FROM Student
GROUP BY Nachname
HAVING COUNT(Nachname) > 1;

 

würde dann nur die beiden mehrfach vorkommenden Nachnamen (Müller und Schweizer) einschließen:

 

Nachname  | AVG(Bafoeg)
=======================
Müller | 430
Schweizer | 185

 

 

Gerne können Sie auch die GROUP BY Funktion mit einer eigenen oder bestehenden Datenbank und dem SQL-Explorer ausprobieren.

 

Sortieren der Ergebnisse

Mit ORDER BY lassen sich die Ergebnisse sortieren. Ohne weitere Angaben erhält man eine aufsteigende Sortierung, mit ORDER BY DESC eine absteigende.

Beispiel

 

SELECT * From Student ORDER BY Nachname DESC

 

sortiert die Tabelle in absteigender Reihenfolge der Nachnamen.

Tabellen verknüpfen

Da relationale Datenbanken die Daten in der Regel über mehrere Tabellen verteilen, besteht auch die Notwendigkeit, Abfragen über mehrere Tabellen erstrecken lassen zu können. Wir sehen uns dazu ein einfaches Beispiel mit zwei Tabellen an:

Tabelle 1 (Kunde):

 

Kundennr | Vorname | Nachname
=============================
2737     | Michael | Monger
2919     | Karin   | Schneider
9493     | Derya   | Gertam

 

Tabelle 2 (Konto):

 

Kontonr | Kundennr |  Kontostand
================================
213223  | 2737     |  1234,00
282222  | 2919     |  -987,23
838222  | 2919     | -2332,30

 

 

Wollten wir zu jedem Kunden seinen Kontostand anzeigen lassen, so könnten wir die beiden Tabellen durch die WHERE-Bedingung

Kunde.Kundennr = Konto.Kundennr erreichen:

 

SELECT Kunde.Kundennr, Kunde.Vorname, Kunde.Nachname, Konto.Betrag
FROM Konto, Kunde
WHERE  Konto.Kundennummer = Kunde.Kundennr;

 

 

 

Kundennr | Vorname | Nachname   | Kontostand
============================================
2737     | Michael | Monger     |  1234,00
2919     | Karin   | Schneider  | -2.332,30
2919     | Karin   | Schneider  |   -987,23

 

 

Wie Sie sehen, werden nur Kunden/Konten angezeigt, zu denen es in beiden Tabellen eine passende Kundennr gibt. Diese Art der Verknüpfung wird auch Inner-Join genannt und kann auch wie folgt ausgedrückt werden:

 

SELECT Kunde.Kundennr, Kunde.Vorname, Kunde.Nachname, Konto.Betrag
FROM Konto INNER JOIN Kunde
ON Konto.Kundennummer = Kunde.Kundennr;

 

 

Ließe man die Bedingung weg, würde man das karthesische Produkt beider Tabellen bekommen, den sogenannten Cross-Join:

 

 

Kundennr | Vorname  | Nachname     | Kontostand
===============================================
2737     | Michael  | Monger       |  1234,00
2737     | Michael  | Monger       | -2332,30
2737     | Michael  | Monger       |  -987,23
2919     | Karin    | Schneider    |  1234,00
2919     | Karin    | Schneider    | -2332,30
2919     | Karin    | Schneider    |  -987,23
9493     | Derya    | Gertam       |  1234,00
9493     | Derya    | Gertam       | -2332,30
9493     | Derya    | Gertam       |  -987,23

 

 

Möchte man alle Kunden in der Ergebnismenge sehen, unabhängig davon, ob sie ein Konto besitzen nutzt man einen LEFT-JOIN:

 

SELECT Kunde.Kundennr, Kunde.Vorname, Kunde.Nachname, Konto.Betrag
FROM Kunde LEFT JOIN Konto
ON Kunde.Kundennr = Konto.Kundennummer;

 

 

 

Kundennr | Vorname | Nachname  | Betrag
=========================================
2737     | Michael | Monger    |  1234,00
2919     | Karin   | Schneider | -2332,30
2919     | Karin   | Schneider |  -987,23
9493     | Derya   | Gertam    |

 

 

Der RIGHT-JOIN funktioniert analog, würde in unserem Beispiel aber zum gleichen Ergebnis wie der INNER-JOIN führen, da wir kein Konto ohne Kunden haben.

In MS-Access lassen sich diese Arten von JOINS (INNER, LEFT,  RIGHT) ebenfalls darstellen. Man verbindet die beteiligten Tabellen über die Primär- bzw. Fremdschlüssel (1. Bild) und kann dann auf dieser Beziehung (Doppelklick) die Art des JOINs definieren. Dabei steht im 2. Bild die 1. Option für INNER-JOIN, die zweite für LEFT-JOIN und die dritte für RIGHT-JOIN.