vorheriges KapitelInhaltsverzeichnisIndexInfoseitenächstes Kapitel



3


Ausdrücke, Bedingungen und Operatoren

Ziele

Ausdrücke

Bedingungen

Operatoren

Zusammenfassung

Fragen und Antworten

Workshop



Ziele

Am zweiten Tag haben Sie mit SELECT und FROM die Daten in interessanter (und nützlicher) Weise manipuliert. Heute erfahren Sie mehr über SELECT und FROM und erweitern die grundlegende Abfrage mit neuen Elementen für Abfragen, Tabellen und Zeilen. Außerdem lernen Sie eine neue Klausel und die sogenannten Operatoren kennen. Am Ende des dritten Tages ...


Die heutigen Beispiele arbeiten mit Personal Oracle8. Andere Implementierungen von SQL können in der Art der Befehlseingabe oder der Anzeige der Ausgaben etwas abweichen, wobei aber die Ergebnisse bei allen Implementierungen, die mit dem ANSI-Standard konform gehen, grundsätzlich die gleichen sind.


Ausdrücke

Ein Ausdruck gibt einen Wert zurück. Die Palette der Ausdruckstypen ist breit gefächert und umfaßt verschiedene Datentypen wie String, Numeric und Boolean. Praktisch ist nahezu alles, was einer Klausel (wie zum Beispiel SELECT und FROM) folgt, ein Ausdruck. Im folgenden Beispiel stellt betrag einen Ausdruck dar, der den Wert in der Spalte BETRAG zurückgibt.


SELECT betrag FROM schecks;


In der folgenden Anweisung sind NAME, ADRESSE, TELEFON und ADRESSBUCH Ausdrücke:


SELECT NAME, ADRESSE, TELEFON
FROM ADRESSBUCH;


Sehen Sie sich nun den folgenden Ausdruck an:


WHERE NAME = 'BROWN'


Die Bedingung NAME = 'BROWN' ergibt einen Booleschen Ausdruck. Wenn die Gleich-Bedingung erfüllt ist, liefert NAME = 'BROWN' den Wert TRUE (wahr), andernfalls den Wert FALSE (falsch) zurück.



Bedingungen

Wenn man ein bestimmtes Element oder eine Gruppe von Elementen in einer Datenbank suchen möchte, braucht man eine oder mehrere Bedingungen. Diese Bedingungen stehen in der WHERE-Klausel. Im obigen Beispiel lautet die Bedingung:


NAME = 'BROWN'


Um alle Personen in der Firma zu finden, die letzten Monat mehr als 100 Stunden gearbeitet haben, schreibt man zum Beispiel folgende Anweisung:


ANZAHL_STUNDEN > 100


Mit Bedingungen lassen sich selektive Abfragen realisieren. Die einfachste Form einer Bedingung besteht aus einer Variablen, einer Konstanten und einem Vergleichsoperator. Im ersten Beispiel ist NAME die Variable, 'BROWN' die Konstante und = der Vergleichsoperator. Im zweiten Beispiel stellt ANZAHL_STUNDEN die Variable, 100 die Konstante und > den Vergleichsoperator dar. Bevor man bedingte Abfragen erstellen kann, muß man die WHERE-Klausel und die Operatoren kennen.



Die WHERE-Klausel

Die Syntax der WHERE-Klausel lautet:


Mit SELECT, FROM und WHERE kennen Sie bereits die drei am häufigsten gebrauchten Klauseln in SQL. Mit der WHERE-Klausel lassen sich Abfragen selektiver gestalten. Ohne die WHERE-Klausel könnte man mit einer Abfrage lediglich alle Datensätze in der/den ausgewählten Tabelle(n) anzeigen. Zum Beispiel listet


SQL> SELECT * FROM BIKES;


alle Datenzeilen der Tabelle BIKES auf.


NAME RAHMEN MATERIAL KM_STAND TYP
--------------- ---------- --------------- ---------- ---------------
TREK 2300 23 KOHLEFASER 3500 RACING
BURLEY 22 STAHL 2000 TANDEM
GIANT 19 STAHL 1500 COMMUTER
FUJI 20 STAHL 500 TOURING
SPECIALIZED 16 STAHL 100 MOUNTAIN
CANNONDALE 23 ALUMINIUM 3000 RACING

6 Zeilen ausgewählt.


Möchten Sie ein bestimmtes Fahrrad auswählen, geben Sie zum Beispiel die folgende Anweisung ein:


SQL> SELECT *
2 FROM BIKES
3 WHERE NAME = 'BURLEY';


Diese Anweisung liefert nur einen Datensatz:


NAME RAHMEN MATERIAL KM_STAND TYP
--------------- ---------- --------------- ---------- ---------------
BURLEY 22 STAHL 2000 TANDEM


Dieses einfache Beispiel zeigt, wie man die abzurufenden Daten gemäß einer Bedingung auswählen kann.


Operatoren

Mit Operatoren gibt man innerhalb eines Ausdrucks an, wie die Daten entsprechend der spezifizierten Bedingungen abzurufen sind. In SQL unterscheidet man sechs Gruppen von Operatoren: arithmetische, Vergleichs-, Zeichen-, logische, Mengen- und verschiedene Operatoren.



Arithmetische Operatoren

Zu den arithmetischen Operatoren gehören Plus (+), Minus (-), Division (/), Multiplikation (*) und Modulo-Operation (%). Die ersten vier sind selbsterklärend. Die Modulo-Operation liefert den Rest einer ganzzahligen Division zurück. Dazu zwei Beispiele:


5 % 2 = 1
6 % 2 = 0


Der Modulo-Operator läßt sich nicht auf Datentypen mit Dezimalstellen wie Real oder Number anwenden.


Wenn in einem Ausdruck mehrere Operatoren ohne Klammern vorkommen, findet die Auswertung der Ausdrücke in der folgenden Reihenfolge statt: Multiplikation, Division, Modulo, Addition und Subtraktion. Zum Beispiel wird der Ausdruck


2 * 6 + 9 / 3


zu


12 + 3 = 15


ausgewertet. Der Ausdruck


2 * (6 + 9) / 3


liefert dagegen


2 * 15 / 3 = 10


als Ergebnis. Achten Sie genau auf die Stellung der Klammern. Bei einfachen Ausdrücken läßt sich die Auswertungsreihenfolge noch leicht überblicken. In komplizierten Ausdrücken kann es Ihnen aber passieren, daß die tatsächliche Auswertungsreihenfolge gar nicht Ihren Absichten entspricht.


Die folgenden Abschnitte erläutern die arithmetischen Operatoren im Detail und zeigen Beispiele für den Einsatz in Abfragen.



Plus (+)

Das Pluszeichen läßt sich auf verschiedene Weise einsetzen. Geben Sie zunächst die folgende Anweisung ein, um die Tabelle PREIS anzuzeigen:


SQL> SELECT * FROM PREIS;


ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23

6 Zeilen ausgewählt.


Geben Sie nun folgende Anweisung ein:


SQL> SELECT ARTIKEL, GROSSHANDEL, GROSSHANDEL + 0.15
2 FROM PREIS;


Diese Anweisung addiert 15 Pfennige zu allen Großhandelspreisen und liefert das folgende Ergebnis:


ARTIKEL GROSSHANDEL GROSSHANDEL+0.15
--------------- ----------- ----------------
TOMATEN ,34 ,49
KARTOFFELN ,51 ,66
BANANEN ,67 ,82
RUEBEN ,45 ,60
KAESE ,89 1,04
AEPFEL ,23 ,38

6 Zeilen ausgewählt.


Auch wenn Sie mit der deutschen Version von Oracle arbeiten, müssen Sie bei der Eingabe von Zahlenwerten den Punkt als Dezimalzeichen verwenden. In der Ausgabe erscheint das Dezimalzeichen entsprechend den Ländereinstellungen auf Ihrem System (im Beispiel also als Komma). In der obigen Anweisung würde das Komma jedoch als Trennzeichen zwischen zwei Spalten interpretiert. Das folgende Beispiel zeigt diesen Effekt:

SQL> SELECT ARTIKEL, GROSSHANDEL, GROSSHANDEL + 0,15
2 FROM PREIS;

ARTIKEL GROSSHANDEL GROSSHANDEL+0 15
--------------- ----------- ------------- ----------
TOMATEN ,34 ,34 15
KARTOFFELN ,51 ,51 15
BANANEN ,67 ,67 15
RUEBEN ,45 ,45 15
KAESE ,89 ,89 15
AEPFEL ,23 ,23 15

6 Zeilen ausgewählt.


Worum handelt es sich bei der letzten Spalte mit der etwas ungewöhnlichen Spaltenüberschrift GROSSHANDEL+0.15? Diese Spalte ist in der Originaltabelle nicht vorhanden. (Weiter oben haben Sie ja mit dem Sternchen in der SELECT-Klausel alle Spalten angezeigt.) SQL erlaubt das Erstellen einer virtuellen oder abgeleiteten Spalte durch Kombination oder Modifikation existierender Spalten.

Geben Sie noch einmal die erste Anweisung ein:


SQL> SELECT * FROM PREIS;


Als Ergebnis erscheint die folgende Tabelle:


ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23

6 Zeilen ausgewählt.


Die Ausgabe bestätigt, daß sich die Originaldaten nicht geändert haben und daß die Spaltenüberschrift GROSSHANDEL+0.15 kein fester Bestandteil dieser Tabelle ist. Allerdings könnte man die Überschrift etwas aussagekräftiger gestalten.

Tippen Sie die folgende Anweisung ein:


SQL> SELECT ARTIKEL, GROSSHANDEL, (GROSSHANDEL + 0.15) EINZELHANDEL
2 FROM PREIS;


Das Ergebnis sieht nun folgendermaßen aus:


ARTIKEL GROSSHANDEL EINZELHANDEL
--------------- ----------- ------------
TOMATEN ,34 ,49
KARTOFFELN ,51 ,66
BANANEN ,67 ,82
RUEBEN ,45 ,60
KAESE ,89 1,04
AEPFEL ,23 ,38

6 Zeilen ausgewählt.


Eine feine Sache! Man kann nicht nur neue Spalten erzeugen, sondern sie auch im Vorübergehen umbenennen. Mit der Syntax Spaltenname Alias (beachten Sie das Leerzeichen zwischen Spaltenname und Alias) läßt sich jede beliebige Spalte umbenennen.

Beispielsweise benennt die Abfrage


SQL> SELECT ARTIKEL PRODUKTE, GROSSHANDEL, GROSSHANDEL + 0.25 EINZELHANDEL
2 FROM PREIS;


die Spalten wie folgt um:


PRODUKTE GROSSHANDEL EINZELHANDEL
--------------- ----------- ------------
TOMATEN ,34 ,59
KARTOFFELN ,51 ,76
BANANEN ,67 ,92
RUEBEN ,45 ,70
KAESE ,89 1,14
AEPFEL ,23 ,48

6 Zeilen ausgewählt.


Einige Implementierungen von SQL verwenden die Syntax <Spaltenname = Alias>. Das obige Beispiel ist dann wie folgt zu schreiben:

SQL> SELECT ARTIKEL = PRODUKTE,
GROSSHANDEL,
GROSSHANDEL + 0.25 = EINZELHANDEL,
FROM PREIS;


Die Syntax der jeweiligen Implementierung ist aus der zugehörigen Dokumentation ersichtlich.


Vielleicht taucht bei Ihnen die Frage auf, welchen Nutzen Aliasnamen bringen, wenn man nicht mit befehlszeilenorientiertem SQL arbeitet. Die Frage ist zwar berechtigt, aber wissen Sie auch, wie Berichtsgeneratoren arbeiten? Falls Sie irgendwann einmal einen Berichtsgenerator schreiben sollen, werden Sie sich der Aliasnamen erinnern und nicht alles neu erfinden, worüber sich Dr. Codd und IBM bereits den Kopf zerbrochen haben.


Bisher haben Sie zwei Einsatzfälle für das Pluszeichen kennengelernt. Im ersten Fall haben Sie in der SELECT-Klausel eine Berechnung mit den Daten ausgeführt und die Berechnung angezeigt. Dem zweiten Einsatzfall begegnen wir in der WHERE-Klausel. Die Verwendung von Operatoren in der WHERE-Klausel bietet mehr Flexibilität, wenn man Bedingungen für das Abrufen von Daten spezifiziert.


Im bestimmten Implementierungen von SQL dient das Pluszeichen gleichzeitig als Operator zur Zeichenverkettung. Auf diesen Einsatzfall gehen wir später ein.



Minus (-)

Das Minuszeichen hat ebenfalls mehrere Bedeutungen. Als erstes kann man damit das Vorzeichen einer Zahl ändern. Diese Funktion demonstrieren wir an der Tabelle HOCHTIEF.


SQL> SELECT * FROM HOCHTIEF;


STAAT HOCHTEMP TIEFTEMP
---------- ---------- ----------
CA -50 120
FL 20 110
LA 15 99
ND -70 101
NE -60 100


Die Daten kann man zum Beispiel wie folgt manipulieren:


SQL> SELECT STAAT, -HOCHTEMP TIEFST, -TIEFTEMP HOECHST
2 FROM HOCHTIEF;

STAAT TIEFST HOECHST
---------- ---------- ----------
CA 50 -120
FL -20 -110
LA -15 -99
ND 70 -101
NE 60 -100


Die zweite (und naheliegende) Verwendung des Minuszeichens ist die Subtraktion einer Spalte von einer anderen. Zum Beispiel:


SQL> SELECT STAAT,
2 HOCHTEMP TIEFST,
3 TIEFTEMP HOECHST,
4 (TIEFTEMP - HOCHTEMP) DIFFERENZ
5 FROM HOCHTIEF;

STAAT TIEFST HOECHST DIFFERENZ
---------- ---------- ---------- ----------
CA -50 120 170
FL 20 110 90
LA 15 99 84
ND -70 101 171
NE -60 100 160


Beachten Sie die Verwendung von Aliasnamen, um die falsch eingegebenen Daten zu korrigieren. Auf diese Weise nimmt man nur temporäre Korrekturen und keine ständigen Änderungen vor. Die Ausgabe soll lediglich darauf hinweisen, daß die Daten korrigiert wurden und in Zukunft korrekt einzugeben sind. Tag 21 erläutert, wie man falsche Daten in Ordnung bringt.

Diese Abfrage hat nicht nur die falschen Daten korrigiert (zumindest visuell), sondern auch eine neue Spalte mit den Abweichungen zwischen Höchst- und Tiefsttemperaturen jedes Staates erzeugt.


Wenn man versehentlich das Minuszeichen auf ein Zeichenfeld anwendet, erhält man folgenden Fehler:


SQL> SELECT -STAAT FROM HOCHTIEF;
SELECT -STAAT FROM HOCHTIEF
*
FEHLER in Zeile 1:
ORA-01722: Ungültige Zahl


Die genaue Fehlermeldung hängt von der konkreten Implementierung ab. Das Ergebnis ist aber das gleiche.



Division (/)

Der Divisionsoperator hat nur die allgemein bekannte Bedeutung. Geben Sie die folgende Anweisung für die Tabelle PREIS ein:


SQL> SELECT * FROM PREIS;


ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23

6 Zeilen ausgewählt.


Geht man mit dem Preis bei einem Ausverkauf auf die Hälfte herunter, läßt sich das Ergebnis mit der folgenden Anweisung anzeigen:


SQL> SELECT ARTIKEL, GROSSHANDEL, (GROSSHANDEL/2) SONDERPREIS
2 FROM PREIS;
ARTIKEL GROSSHANDEL SONDERPREIS
--------------- ----------- -----------
TOMATEN ,34 ,17
KARTOFFELN ,51 ,255
BANANEN ,67 ,335
RUEBEN ,45 ,225
KAESE ,89 ,445
AEPFEL ,23 ,115

6 Zeilen ausgewählt.


Die Division in der obigen SELECT-Anweisung ist unkompliziert (außer daß im Ergebnis halbe Pfennige entstehen).



Multiplikation (*)

Der Multiplikationsoperator bereitet ebenfalls keine Schwierigkeiten. Verwenden Sie wieder die Tabelle PRICE, und geben Sie die folgende Anweisung ein:


SQL> SELECT * FROM PREIS;


ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23

6 Zeilen ausgewählt.


Die nächste Abfrage ändert die Tabelle, um einen durchgängigen Preisnachlaß von 10 Prozent widerzuspiegeln:


SQL> SELECT ARTIKEL, GROSSHANDEL, GROSSHANDEL * 0.9 PREIS_NEU
2 FROM PREIS;

ARTIKEL GROSSHANDEL PREIS_NEU
--------------- ----------- ----------
TOMATEN ,34 ,306
KARTOFFELN ,51 ,459
BANANEN ,67 ,603
RUEBEN ,45 ,405
KAESE ,89 ,801
AEPFEL ,23 ,207

6 Zeilen ausgewählt.


Mit diesen Operatoren lassen sich in einer SELECT-Anweisung leistungsfähige Berechnungen ausführen.



Modulo (%)

Der Modulo-Operator gibt den ganzzahligen Rest einer Divisionsoperation zurück. Geben Sie die folgende Anweisung für die Tabelle REST ein:


SQL> SELECT * FROM REST;


ZAEHLER NENNER
---------- ----------
10 5
8 3
23 9
40 17
1024 16
85 34

6 Zeilen ausgewählt.


Man kann auch eine neue Spalte - REST - erzeugen, um die Werte des Ausdrucks ZAEHLER % NENNER aufzunehmen.


SQL> SELECT ZAEHLER,
NENNER,
ZAEHLER % NENNER REST
FROM REST;

ZAEHLER NENNER REST
---------- ---------- ----------
10 5 0
8 3 2
23 9 5
40 17 6
1024 16 0
85 34 17

6 Zeilen ausgewählt.


Einige Implementierungen von SQL (unter anderem auch Personal Oracle8) implementieren Modulo als Funktion namens MOD (siehe dazu Tag 4). Die folgende Anweisung liefert dann die gleichen Ergebnisse wie mit der obigen Anweisung:


SQL> SELECT ZAEHLER,
2 NENNER,
3 MOD(ZAEHLER, NENNER) REST
4 FROM REST;



Operatorvorrang

Dieser Abschnitt geht auf den Vorrang der Operatoren in einer SELECT-Anweisung ein. Geben Sie für die Tabelle VORRANG die folgende Anweisung ein:


SQL> SELECT * FROM VORRANG;

N1 N2 N3 N4
---------- ---------- ---------- ----------
1 2 3 4
13 24 35 46
9 3 23 5
63 2 45 3
7 2 1 4

5 Zeilen ausgewählt.


Testen Sie den Vorrang mit dem folgenden Codesegment:


SQL> SELECT
2 N1+N2*N3/N4,
3 (N1+N2)*N3/N4,
4 N1+(N2*N3)/N4
5 FROM VORRANG;

N1+N2*N3/N4 (N1+N2)*N3/N4 N1+(N2*N3)/N4
----------- ------------- -------------
2,5 2,25 2,5
31,2608696 28,1521739 31,2608696
22,8 55,2 22,8
93 975 93
7,5 2,25 7,5

5 Zeilen ausgewählt.


Beachten Sie, daß die erste und letzte Spalte identisch sind. Eine vierte Spalte N1+N2*(N3/N4) würde ebenfalls die gleichen Werte wie in der ersten und letzten Spalte enthalten.



Vergleichsoperatoren

Wie bereits aus dem Namen hervorgeht, vergleichen diese Operatoren Ausdrükke und geben einen von drei Werten zurück: TRUE, FALSE oder UNKNOWN (Unbekannt). Moment mal! Unbekannt? TRUE und FALSE sind selbsterklärend, aber was ist UNKNOWN?


Um zu verstehen, wie man ein UNKNOWN erhalten kann, muß man etwas über das Konzept von NULL wissen. In bezug auf Datenbanken bezeichnet NULL das Fehlen von Daten in einem Feld. Das heißt nicht, daß eine Spalte eine 0 oder ein Leerzeichen enthält. Die 0 oder das Leerzeichen sind echte Werte. NULL bedeutet, daß tatsächlich nichts in diesem Feld enthalten ist. Führt man einen Vergleich wie Feld = 9 aus und der einzige Wert für Feld ist NULL, liefert der Vergleich das Ergebnis UNKNOWN. Da die Bedingung UNKNOWN etwas aus dem Rahmen fällt (verglichen mit anderen Programmiersprachen), ändern die meisten Versionen von SQL den Wert UNKNOWN in FALSE und stellen den speziellen Operator IS NULL für den Test auf eine NULL-Bedingung bereit.


Das folgende Beispiel demonstriert den Wert NULL. Nehmen wir einen Eintrag in der Tabelle PREIS an, der keinen Wert für GROSSHANDEL enthält. Das Ergebnis einer Abfrage könnte dann wie folgt aussehen:


SQL> SELECT * FROM PREIS;


ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23
ORANGEN

7 Zeilen ausgewählt.


Beachten Sie, daß im Feld GROSSHANDEL auf der Zeile für Orangen keine Ausgaben erfolgen. Der Wert für das Feld GROSSHANDEL bei Orangen lautet NULL.


Versuchen Sie, den NULL-Wert aufzuspüren:


SQL> SELECT *
2 FROM PREIS
3 WHERE GROSSHANDEL IS NULL;

ARTIKEL GROSSHANDEL
--------------- -----------
ORANGEN

1 Zeile wurde ausgewählt.


Wie Sie der Ausgabe entnehmen können, sind ORANGEN der einzige Artikel, dessen Wert für GROSSHANDEL gleich NULL ist oder keinen Wert enthält. Wenn man dagegen das Gleichheitszeichen (=) im Test verwendet, erhält man folgendes Ergebnis:

SQL> SELECT *
2 FROM PREIS
3 WHERE GROSSHANDEL = NULL;

Es wurden keine Zeilen ausgewählt


Man findet keine Einträge, da der Vergleich GROSSHANDEL = NULL den Wert FALSE zurückgibt - das Ergebnis war unbekannt. Es ist besser, ein IS NULL anstelle eines Gleichheitszeichens zu verwenden und die WHERE-Anweisung in WHERE GROSSHANDEL IS NULL zu ändern. In diesem Fall erhält man alle Zeilen, in denen eine NULL vorkommt.

Dieses Beispiel zeigt sowohl den am häufigsten eingesetzten Vergleichsoperator - das Gleichheitszeichen (=) - als auch den Schauplatz für alle Vergleichsoperatoren - die WHERE-Klausel. Die WHERE-Klausel ist Ihnen bereits bekannt, sehen wir uns also kurz das Gleichheitszeichen an.



Gleichheit (=)

Weiter vorn in diesem Kapitel haben Sie gesehen, wie bestimmte Implementierungen von SQL das Gleichheitszeichen in der SELECT-Klausel verwenden, um einen Alias zuzuweisen. In der WHERE-Klausel dient das Gleichheitszeichen in der Regel als Vergleichsoperator. In dieser Funktion läßt sich mit dem Gleichheitszeichen ein bestimmter Wert aus vielen auswählen. Probieren Sie das folgende Beispiel aus:


SQL> SELECT * FROM FREUNDE;


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

5 Zeilen ausgewählt.


Suchen wir die Zeile von JD. (In einer kurzen Liste erscheint diese Aufgabe trivial, vielleicht haben Sie aber mehr Freunde als wir - oder Ihre Liste enthält Tausende von Datensätzen.)


SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORNAME = 'JD';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MAST JD 381 555-6767 LA 23456

1 Zeile wurde ausgewählt.


Wir erhalten das erwartete Ergebnis. Geben Sie nun folgende Anweisung ein:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORNAME = 'AL';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK

2 Zeilen ausgewählt.


Dieses Beispiel zeigt, daß das Gleichheitszeichen auch mehrere Datensätze liefern kann. Beachten Sie, daß ZIP im zweiten Datensatz leer ist. ZIP ist ein Zeichenfeld. (Wie man Tabellen erzeugt und füllt, lernen Sie in Tag 8.) Das Beispiel zeigt, daß man in der Ausgabe einen NULL-Wert nicht von einem leeren Feld unterscheiden kann.

Den Einfluß der Groß-/Kleinschreibung betont noch einmal das folgende Beispiel:


SQL> SELECT * FROM FREUNDE
2 WHERE VORNAME = 'BUD';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212

1 Zeile wurde ausgewählt.


Probieren Sie nun folgende Anweisung aus:


SQL> select * from freunde
2 where vorname = 'Bud';

Es wurden keine Zeilen ausgewählt


Auch wenn die SQL-Syntax selbst nicht von der Groß-/Kleinschreibung abhängig ist, wird bei den Daten streng auf die Schreibweise geachtet. Die meisten Firmen speichern die Daten vorzugsweise in Großbuchstaben, um einheitliche Datenbestände zu gewährleisten. Man sollte die Daten immer entweder durchgängig in Groß- oder in Kleinbuchstaben ablegen. Die gemischte Schreibweise kann zu Problemen beim Abrufen der Daten führen, wenn man die Konventionen der Dateneingabe nicht genau kennt.


Größer als (>) und Größer als oder gleich (>=)

Der Operator Größer als (>) funktioniert wie folgt:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORWAHL > 300;


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

2 Zeilen ausgewählt.


Dieses Beispiel hat alle Vorwahlen gefunden, die größer als (aber nicht gleich) 300 sind. Um 300 einzuschließen, gibt man folgende Anweisung ein:

SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORWAHL >= 300;

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

3 Zeilen ausgewählt.


Mit dieser Änderung erhält man alle Vorwahlnummern beginnend bei 300 aufwärts. Das gleiche Ergebnis läßt sich mit der Bedingung VORWAHL > 299 erreichen.

Beachten Sie, daß der Wert 300 in dieser SQL-Anweisung nicht von Apostrophen eingeschlossen ist. Numerische Felder erfordern keine Apostrophe.


Kleiner als (<) und Kleiner oder gleich (<=)

Wie man leicht errät, arbeiten diese Vergleichsoperatoren in der gleichen Weise wie > und >=, nur umgekehrt:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT < 'LA';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MERRICK BUD 300 555-6666 CO 80212
BULHER FERRIS 345 555-3223 IL 23332

3 Zeilen ausgewählt.


Wieso hat sich STAAT in ST geändert? Weil die Spalte nur für eine Länge von zwei Zeichen definiert ist, wird der Spaltenname in den zurückgegebenen Zeilen auf zwei Zeichen abgeschnitten. Ein Spaltenname wie KUNDENNUMMER erscheint dann nur als KU. Die Felder VORWAHL und TELEFON sind breiter als ihre Spaltennamen und werden daher nicht abgeschnitten.

Moment mal! Haben Sie nicht gerade den Operator < auf ein Zeichenfeld angewandt? Diese Vergleichsoperatoren lassen sich für jeden Datentyp einsetzen. Die Ergebnisse hängen vom jeweiligen Datentyp ab. Formulieren Sie beispielsweise die Suchbedingung nach dem Staat mit Kleinbuchstaben:

SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT < 'la';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

5 Zeilen ausgewählt.


Großbuchstaben stehen in der Sortierreihenfolge normalerweise vor den Kleinbuchstaben. Die zurückgegebenen Staatencodes sind damit alle kleiner als 'la'. Auch in diesem Fall sollten Sie sich in der Dokumentation zu Ihrer Datenbank sachkundig machen.

Die genaue Funktion dieser Operatoren hängt von den jeweiligen Ländereinstellungen ab, zu denen auch die Sortierreihenfolge gehört. Die meisten PC-Implementierungen verwenden ASCII-Tabellen. Es gibt aber auch Plattformen, die mit der EBCDIC-Tabelle arbeiten.

Mit der folgenden Anweisung nehmen Sie den Staat Louisiana in die ursprüngliche Suche auf:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT <= 'LA';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

4 Zeilen ausgewählt.



Ungleichheit (< > und !=)

Mit dem Symbol für Ungleichheit lassen sich alle Datensätze, außer denjenigen mit den spezifizierten Werten zurückgeben. Die verschiedenen SQL-Implementierungen stellen diesen Operator durch < > oder != dar. Mit der folgenden Anweisung findet man zum Beispiel alle Freunde, die nicht mit Vornamen AL heißen:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORNAME <> 'AL';


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

3 Zeilen ausgewählt.


Alle Freunde, die nicht in Kalifornien (CA) wohnen, lassen sich mit der folgenden Anweisung heraussuchen:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT != 'CA';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332

5 Zeilen ausgewählt.


Beachten Sie, daß man mit beiden Symbolen < > und != die Ungleichheit ausdrücken kann.


Zeichenoperatoren

Mit Zeichenoperatoren kann man die Art und Weise der String-Darstellung beeinflussen. Das gilt sowohl für die Ausgabedaten als auch für das Formulieren der Bedingungen von abzurufenden Daten. Der vorliegende Abschnitt erläutert zwei Operatoren: den Operator LIKE und den Operator ||, der eine Zeichenverkettung erlaubt.



Der Operator LIKE

Möchte man Daten abrufen, die einem bestimmten Muster entsprechen, aber keine genauen Übereinstimmungen liefern, kann man mit dem Gleichheitszeichen arbeiten und alle möglichen Fälle durchgehen. Diese Methode ist umständlich und zeitaufwendig. Der Operator LIKE bietet eine elegante Alternative. Sehen Sie sich dazu folgendes Beispiel an.


SQL> SELECT * FROM TEILE;


NAME ORT NUMMER
--------------- --------------- ----------
BLINDDARM MITTELBAUCH 1
ADAMSAPFEL KEHLKOPF 2
HERZ BRUST 3
WIRBELSÄULE RÜCKEN 4
AMBOSS OHR 5
NIERE MITTELRÜCKEN 6

6 Zeilen ausgewählt.


Wie kann man nun alle Teile finden, die zum Rücken gehören? Ein schneller Blick auf diese einfache Tabelle zeigt, daß es zwei Teile sind. Allerdings sind die Bezeichnungen nicht identisch. Probieren Sie die folgende Anweisung aus:


SQL> SELECT *
2 FROM TEILE
3 WHERE ORT LIKE '%RÜCKEN%';

NAME ORT NUMMER
--------------- --------------- ----------
WIRBELSÄULE RÜCKEN 4
NIERE MITTELRÜCKEN 6

2 Zeilen ausgewählt.


Das Prozentzeichen dient im LIKE-Ausdruck als Platzhalter für eine beliebige Anzahl von Zeichen. Wir haben damit alle Datensätze gesucht, bei denen in der Spalte ORT ein RÜCKEN vorkommt. Mit der Abfrage

SQL> SELECT *
2 FROM TEILE
3 WHERE ORT LIKE 'RÜCKEN%';


erhält man alle Werte zurück, die mit RÜCKEN beginnen:


NAME ORT NUMMER
--------------- --------------- ----------
WIRBELSÄULE RÜCKEN 4

1 Zeile wurde ausgewählt.


Die folgende Anweisung sucht alle Teile, die mit A beginnen:


SQL> SELECT *
2 FROM TEILE
3 WHERE NAME LIKE 'A%';

NAME ORT NUMMER
--------------- --------------- ----------
ADAMSAPFEL KEHLKOPF 2
AMBOSS OHR 5

2 Zeilen ausgewählt.


Untersuchen wir schließlich noch die Abhängigkeit des Operators LIKE von der Groß-/Kleinschreibung:


SQL> SELECT *
2 FROM TEILE
3 WHERE NAME LIKE 'a%';

Es wurden keine Zeilen ausgewählt


Der Operator LIKE berücksichtigt die Groß-/Kleinschreibung. Bezüge auf Daten sind immer von der Schreibweise abhängig.

Wenn man Daten finden möchte, die nach einem bestimmten Muster in allen Zeichen bis auf eines übereinstimmen, kann mit dem Platzhalterzeichen Unterstrich arbeiten.



Unterstrich (_)

Der Unterstrich dient als Platzhalter für genau ein Zeichen. Die folgenden Beispiele arbeiten mit einer modifizierten Version der Tabelle FREUNDE:


SQL> SELECT * FROM FREUNDE;


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332
PERKINS ALTON 911 555-3116 CA 95633
BOSS SIR 204 555-2345 CT 95633

7 Zeilen ausgewählt.


Mit der folgenden Anweisung findet man alle Datensätze, in denen der Staat mit C beginnt:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT LIKE 'C_';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
PERKINS ALTON 911 555-3116 CA 95633
BOSS SIR 204 555-2345 CT 95633

3 Zeilen ausgewählt.


In einer Anweisung können auch mehrere Unterstriche stehen:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE TELEFON LIKE '555-6_6_';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456

2 Zeilen ausgewählt.


Die obige Anweisung läßt sich auch folgendermaßen formulieren:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE TELEFON LIKE '555-6%';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456

2 Zeilen ausgewählt.


Die Ergebnisse sind identisch. Man kann beide Platzhalterzeichen kombinieren. Das nächste Beispiel sucht alle Datensätze, bei denen in der Spalte VORNAME ein L als zweites Zeichen steht:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORNAME LIKE '_L%';

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
PERKINS ALTON 911 555-3116 CA 95633

3 Zeilen ausgewählt.



Zeichenverkettung (||)

Zwei Strings lassen sich mit dem doppelten Pipe-Symbol (||) verbinden. Probieren Sie die folgende Anweisung aus:


SQL> SELECT VORNAME || NACHNAME GESAMTNAME
2 FROM FREUNDE;


GESAMTNAME
------------------------------
AL BUNDY
AL MEZA
BUD MERRICK
JD MAST
FERRIS BULHER
ALTON PERKINS
SIR BOSS

7 Zeilen ausgewählt.


Die Verkettung ist mit dem Operator || und nicht mit einem Pluszeichen durchzuführen. Wenn man versucht, zwei Strings mit dem Pluszeichen zu verbinden, liefert der im Beispiel verwendete SQL-Interpreter von Personal Oracle8 den folgenden Fehler zurück:

SQL> SELECT VORNAME + NACHNAME GESAMTNAME
2 FROM FREUNDE;
SELECT VORNAME + NACHNAME GESAMTNAME
*
FEHLER in Zeile 1:
ORA-01722: Ungültige Zahl


In Personal Oracle8 ist der Operator + für die Addition zweier Zahlen vorgesehen. Ein String ergibt aber keine gültige Zahl, so daß der oben gezeigte Fehler auftritt.


Einige Implementierungen von SQL verwenden das Pluszeichen zur Verbindung von Strings. Sehen Sie bitte in Ihrer Dokumentation nach, welche Operatoren für die Stringverkettung vorgesehen sind.

Die folgende Anweisung fügt ein Komma zwischen Nachname und Vorname ein:


SQL> SELECT NACHNAME || ', ' || VORNAME NAME
2 FROM FREUNDE;

NAME
--------------------------------
BUNDY , AL
MEZA , AL
MERRICK , BUD
MAST , JD
BULHER , FERRIS
PERKINS , ALTON
BOSS , SIR

7 Zeilen ausgewählt.


Die obige Anweisung hat die zurückgegebenen Spaltenwerte mit einer literalen Zeichenkette (dem Komma) verkettet.

Beachten Sie in den obigen Beispielen die Leerzeichen zwischen den einzelnen Namensbestandteilen. Diese Leerzeichen sind Teil der eigentlichen Daten. Sind die Werte bei bestimmten Datentypen kürzer als die spezifizierte Feldlänge, werden die fehlenden Zeichen durch Leerzeichen aufgefüllt. Auf Datentypen geht Lektion 9 näher ein.

Die bisherigen Beispiele haben immer nur einen einzigen Vergleich durchgeführt. Die nächsten Abschnitte zeigen Operatoren, mit denen sich mehrere Vergleiche verbinden lassen. Beispielsweise kann man dann alle Datensätze für Mitarbeiter heraussuchen, deren Nachname mit P beginnt und die mehr als drei Tage Urlaub genommen haben.



Logische Operatoren

Mit logischen Operatoren lassen sich mehrere Bedingungen in der WHERE-Klausel einer SQL-Anweisung kombinieren.


Die Urlaubszeit ist immer ein heißes Thema am Arbeitsplatz. Nehmen wir an, daß Sie eine Tabelle namens URLAUB für die Buchhaltung erstellt haben:


SQL> SELECT * FROM URLAUB;


NACHNAME PERSONALNR JAHRE URL_GENOMMEN
--------------- ---------- ---------- ------------
ABLE 101 2 4
BAKER 104 5 23
BLEDSOE 107 8 45
BOLIVAR 233 4 80
BOLD 210 15 100
COSTALES 211 10 78

6 Zeilen ausgewählt.


Nehmen wir an, daß Ihre Firma allen Mitarbeitern 12 Tage Urlaub im Jahr gewährt. Mit den bisher eingeführten Operatoren und einem logischen Operator lassen sich nun alle Mitarbeiter finden, deren Name mit B beginnt und die noch mehr als 50 Tage Urlaub übrig haben.


SQL> SELECT NACHNAME,
2 JAHRE * 12 - URL_GENOMMEN REST
3 FROM URLAUB
4 WHERE NACHNAME LIKE 'B%'
5 AND
6 JAHRE * 12 - URL_GENOMMEN > 50;

NACHNAME REST
--------------- ----------
BLEDSOE 51
BOLD 80

2 Zeilen ausgewählt.


Diese Abfrage ist etwas komplizierter als die bisherigen. Die SELECT-Klausel (in den Zeilen 1 und 2) ermittelt mit arithmetischen Operatoren, wie viele Urlaubstage jeder Mitarbeiter noch übrig hat. Nach der normalen Operatorrangfolge wird JAHRE * 12 - URL_GENOMMEN berechnet. Gegebenenfalls kann man die Reihenfolge der Auswertung auch mit Klammern hervorheben: (JAHRE * 12) - URL_GENOMMEN.

Der Operator LIKE in Zeile 4 sucht in Verbindung mit dem Platzhalterzeichen % alle mit einem B beginnenden Namen heraus. Mit dem Operator Größer als (>) in Zeile 6 werden alle Datensätze mit einem Resturlaub von mehr als 50 Tagen ermittelt.


Das neue Element steht in Zeile 5. Mit dem logischen Operator AND stellt man sicher, daß die gefundenen Datensätze beiden Kriterien - in den Zeilen 4 und 6 - genügen.



AND

Der Operator AND liefert das Ergebnis TRUE zurück, wenn beide Seiten (die Operanden) TRUE sind. Ist wenigstens ein Operand FALSE, liefert AND das Ergebnis FALSE. Mit der folgenden Anweisung sucht man zum Beispiel alle Mitarbeiter, die in der Firma seit maximal 5 Jahren arbeiten und bereits mehr als 20 Tage Urlaub genommen haben:


SQL> SELECT NACHNAME
2 FROM URLAUB
3 WHERE JAHRE <= 5
4 AND
5 URL_GENOMMEN > 20;


NACHNAME
---------------
BAKER
BOLIVAR

2 Zeilen ausgewählt.


Möchten Sie wissen, welche Mitarbeiter mindestens 5 Jahre in der Firma arbeiten und weniger als die Hälfte Ihres Urlaubs genommen haben, schreiben Sie die folgende Anweisung:


SQL> SELECT NACHNAME WORKAHOLICS
2 FROM URLAUB
3 WHERE JAHRE >= 5
4 AND
5 URL_GENOMMEN / (JAHRE * 12) < 0.5;

WORKAHOLICS
---------------
BAKER
BLEDSOE

2 Zeilen ausgewählt.


Man sollte diese Mitarbeiter auf Überarbeitung untersuchen. Sehen Sie sich aber auch an, wie die beiden Bedingungen mit dem Operator AND verbunden wurden.



OR

Mit dem Operator OR kann man eine Reihe von Bedingungen zusammenfassen. Wenn mindestens eine der Bedingungen TRUE ergibt, liefert der Operator OR das Ergebnis TRUE. Um den Unterschied zu zeigen, führen wir die letzte Abfrage mit dem Operator OR anstelle von AND aus:


SQL> SELECT NACHNAME WORKAHOLICS
2 FROM URLAUB
3 WHERE JAHRE >= 5
4 OR
5 URL_GENOMMEN / (JAHRE * 12) < 0.5;


WORKAHOLICS
---------------
ABLE
BAKER
BLEDSOE
BOLD
COSTALES

5 Zeilen ausgewählt.


Die bisherigen Namen finden sich immer noch in der Liste, es sind aber drei neue Mitarbeiter hinzugekommen (die es wahrscheinlich übelnehmen, wenn man sie als Workaholics bezeichnet). Die neuen Einträge stehen deshalb in der Liste, weil sie mindestens eine der spezifizierten Bedingungen erfüllen. Der Operator OR fordert, daß wenigstens eine der Bedingungen TRUE ist, damit die Daten zurückgegeben werden.


NOT

NOT bedeutet wortwörtlich Nicht. Wenn die entsprechende Bedingung TRUE zurückgibt, wandelt NOT das Ergebnis in FALSE um. Liefert die Bedingung nach dem Operator NOT den Wert FALSE, heißt das Ergebnis TRUE. Zum Beispiel gibt die folgende SELECT-Anweisung die beiden einzigen Namen aus der Tabelle zurück, die nicht mit B beginnen:


SQL> SELECT *
2 FROM URLAUB
3 WHERE NACHNAME NOT LIKE 'B%';


NACHNAME PERSONALNR JAHRE URL_GENOMMEN
--------------- ---------- ---------- ------------
ABLE 101 2 4
COSTALES 211 10 78

2 Zeilen ausgewählt.


In Verbindung mit dem Operator IS kann man NOT auch auf den Wert NULL anwenden. Weiter vorn haben wir in die Tabelle PREIS einen NULL-Wert in der Spalte GROSSHANDEL für den Artikel ORANGEN eingetragen.


SQL> SELECT * FROM PREIS;

ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23
ORANGEN

7 Zeilen ausgewählt.


Mit der folgenden Anweisung lassen sich alle Einträge finden, die keine NULL-Werte enthalten:


SQL> SELECT *
2 FROM PREIS
3 WHERE GROSSHANDEL IS NOT NULL;

ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45
KAESE ,89
AEPFEL ,23

6 Zeilen ausgewählt.



Mengenoperatoren

Tag 1 hat erläutert, daß SQL auf der Mengentheorie basiert. Die folgenden Abschnitte erläutern die Mengenoperatoren.



UNION und UNION ALL

Der Operator UNION gibt die Ergebnisse zweier Abfragen abzüglich der doppelt vorkommenden Zeilen zurück. Die folgenden beiden Tabellen zeigen zwei Mannschaftslisten:


SQL> SELECT * FROM FOOTBALL;


NAME
---------------
ABLE
BRAVO
CHARLIE
DECON
EXITOR
FUBAR
GOOBER

7 Zeilen ausgewählt.


SQL> SELECT * FROM SOFTBALL;

NAME
---------------
ABLE
BAKER
CHARLIE
DEAN
EXITOR
FALCONER
GOOBER

7 Zeilen ausgewählt.


Mit der folgenden Anweisung läßt sich die Frage beantworten, wie viele verschiedene Spieler in dem einen oder dem anderen Team spielen:


SQL> SELECT NAME FROM SOFTBALL
2 UNION
3 SELECT NAME FROM FOOTBALL;

NAME
---------------
ABLE
BAKER
BRAVO
CHARLIE
DEAN
DECON
EXITOR
FALCONER
FUBAR
GOOBER

10 Zeilen ausgewählt.


Der Operator UNION liefert 10 verschiedene Namen aus beiden Listen. Wie viele Namen gibt es nun - einschließlich der Duplikate - in beiden Listen?


SQL> SELECT NAME FROM SOFTBALL
2 UNION ALL
3 SELECT NAME FROM FOOTBALL;

NAME
---------------
ABLE
BAKER
CHARLIE
DEAN
EXITOR
FALCONER
GOOBER
ABLE
BRAVO
CHARLIE
DECON
EXITOR
FUBAR
GOOBER

14 Zeilen ausgewählt.


Dank UNION ALL enthält die kombinierte Liste 14 Namen. Der Operator UNION ALL funktioniert wie UNION, eliminiert aber keine Duplikate. Eine Liste der Spieler, die in beiden Teams spielen, kann man mit UNION nicht erzeugen. Dafür steht aber der Operator INTERSECT bereit.


INTERSECT

Der Operator INTERSECT (Schnittmenge) gibt nur die Zeilen zurück, die aus beiden Abfragen stammen. Die nächste SELECT-Anweisung zeigt die Liste der Spieler, die in beiden Teams spielen:


SQL> SELECT * FROM FOOTBALL
2 INTERSECT
3 SELECT * FROM SOFTBALL;


NAME
---------------
ABLE
CHARLIE
EXITOR
GOOBER

4 Zeilen ausgewählt.


In diesem Beispiel erzeugt INTERSECT durch Kombination der Ergebnisse aus beiden SELECT-Anweisungen die kurze Liste der Spieler, die in beiden Teams spielen.



MINUS

Der Operator MINUS (Differenz) liefert die Zeilen aus der ersten Abfrage, die nicht in der zweiten enthalten sind. Dazu ein Beispiel:


SQL> SELECT * FROM FOOTBALL
2 MINUS
3 SELECT * FROM SOFTBALL;


NAME
---------------
BRAVO
DECON
FUBAR

3 Zeilen ausgewählt.


Die obige Abfrage zeigt die drei Football-Spieler an, die nicht im Softball-Team spielen. Wenn man die Reihenfolge der Teams ändert, erhält man die drei Softball-Spieler, die nicht im Football-Team spielen:


SQL> SELECT * FROM SOFTBALL
2 MINUS
3 SELECT * FROM FOOTBALL;

NAME
---------------
BAKER
DEAN
FALCONER

3 Zeilen ausgewählt.



Verschiedene Operatoren: IN und BETWEEN

Mit den beiden Operatoren IN und BEETWEEN stehen Kurzversionen für Funktionen bereit, die Sie bereits realisieren können. Wenn Sie zum Beispiel Freunde in Colorado, Kalifornien und Lousiana suchen möchten, können Sie folgende Anweisung verwenden:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT = 'CA'
4 OR
5 STAAT = 'CO'
6 OR
7 STAAT = 'LA';


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
PERKINS ALTON 911 555-3116 CA 95633

3 Zeilen ausgewählt.


Übersichtlicher und eleganter läßt sich die obige Anweisung wie folgt formulieren:


SQL> SELECT *
2 FROM FREUNDE
3 WHERE STAAT IN('CA','CO','LA');

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
PERKINS ALTON 911 555-3116 CA 95633

3 Zeilen ausgewählt.


Das zweite Beispiel ist kürzer und leichter zu erfassen. Man kann nie im voraus wissen, wann man wieder ein Projekt überarbeiten muß, das bereits Monate zurückliegt. Der Operator IN läßt sich auch bei Zahlen einsetzen. Sehen Sie sich dazu das folgende Beispiel an, in dem VORWAHL eine numerische Spalte ist:

SQL> SELECT *
2 FROM FREUNDE
3 WHERE VORWAHL IN (100, 381, 204);

NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MAST JD 381 555-6767 LA 23456
BOSS SIR 204 555-2345 CT 95633

3 Zeilen ausgewählt.


Benötigt man einen Bereich von Artikeln aus der Tabelle PREIS, kann man folgende Anweisung ausführen:


SQL> SELECT *
2 FROM PREIS
3 WHERE GROSSHANDEL > 0.25
4 AND
5 GROSSHANDEL < 0.75;

ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45

4 Zeilen ausgewählt.


Auch hier gibt es eine elegante Alternative mit dem Operator BETWEEN:


SQL> SELECT *
2 FROM PREIS
3 WHERE GROSSHANDEL BETWEEN 0.25 AND 0.75;

ARTIKEL GROSSHANDEL
--------------- -----------
TOMATEN ,34
KARTOFFELN ,51
BANANEN ,67
RUEBEN ,45

4 Zeilen ausgewählt.


Die Anweisung im zweiten Beispiel ist wieder einfacher und besser zu lesen als die erste.


Wenn ein Wert 0.25 in der Spalte GROSSHANDEL der Tabelle PREIS vorkommt, erhält man den zugehörigen Datensatz ebenfalls zurück. Die im Operator BETWEEN angegebenen Parameter schließen die betreffenden Grenzwerte mit ein.


Zusammenfassung

Am Beginn der dritten Lektion waren Sie lediglich mit den grundlegenden Klauseln SELECT und FROM vertraut. Jetzt wissen Sie, wie man eine Abfrage an die Datenbank mit Operatoren schärfer formulieren kann. Der heutige Tag hat die arithmetischen, Vergleichs-, logischen und Mengenoperatoren eingeführt. Diese Hilfsmittel bilden einen Grundpfeiler Ihrer SQL-Kenntnisse.



Fragen und Antworten

Frage:

Wie kann ich die heute behandelten Elemente einsetzen, wenn ich nicht von der Befehlszeile - wie in den Beispielen dargestellt - arbeite?

Antwort:

Ob Sie nun SQL in COBOL als eingebettetes SQL oder in ODBC von Microsoft verwenden - die grundlegenden Konstruktionen sind gleich. Bei Ihrer Arbeit mit SQL kommen immer wieder die gestern und heute behandelten Elemente zum Einsatz.

Frage:

Warum wird ständig darauf hingewiesen, die jeweilige Implementierung hinsichtlich eines bestimmten Elements zu überprüfen? Eigentlich habe ich angenommen, daß alles standardisiert ist.

Antwort:

Der ANSI-Standard (in der neuesten Version von 1992) zeigt zwar die Richtung, allerdings nehmen alle Datenbankhersteller kleinere Anpassungen an ihre Produkte vor. Die grundlegenden Anweisungen sind ähnlich oder sogar identisch, und jede Implementierung verfügt über Erweiterungen, die andere Hersteller übernehmen oder in verbesserter Form realisieren. Wir haben ANSI als Ausgangspunkt gewählt, stellen aber im Verlauf dieses Kurses auch Unterschiede heraus.


Workshop


Kontrollfragen

Beantworten Sie die folgenden Fragen unter Verwendung der Tabelle FREUNDE:


NACHNAME VORNAME VORWAHL TELEFON ST ZIP
--------------- --------------- ---------- -------- -- -----
BUNDY AL 100 555-1111 IL 22333
MEZA AL 200 555-2222 UK
MERRICK BUD 300 555-6666 CO 80212
MAST JD 381 555-6767 LA 23456
BULHER FERRIS 345 555-3223 IL 23332
PERKINS ALTON 911 555-3116 CA 95633
BOSS SIR 204 555-2345 CT 95633


1. Schreiben Sie eine Abfrage, die alle Personennamen mit dem Anfangsbuchstaben M zurückgibt.


2. Schreiben Sie eine Abfrage, die alle in Illinois lebenden Personen mit dem Vornamen AL zurückgibt.


3. Gegeben seien zwei Tabellen TEIL1 und TEIL2, die über die Spalten TEILNR verfügen. Wie läßt sich herausfinden, welche Teilnummern in beiden Tabellen vorkommen? Formulieren Sie die Abfrage.


4. Wie läßt sich die Bedingung WHERE a >= 10 AND a <= 30 kürzer und eleganter formulieren?


5. Was liefert die folgende Abfrage zurück?


SQL> SELECT VORNAME
2 FROM FREUNDE
3 WHERE VORNAME = 'AL'
4 AND NACHNAME = 'BULHER';



Übung

1. Schreiben Sie für die Tabelle FREUNDE eine Abfrage, die folgende Ergebnismenge liefert:


NAME ST
------------------ --
AL AUS IL

1 Zeile wurde ausgewählt.


2. Schreiben Sie für die Tabelle FREUNDE eine Abfrage, die folgendes Ergebnis zurückgibt:


NAME TELEFON
-------------------------------- -------------
MERRICK, BUD 300-555-6666
MAST, JD 381-555-6767
BULHER, FERRIS 345-555-3223

3 Zeilen ausgewählt.



Ein Imprint des Markt&Technik Buch- und Software-Verlag GmbH.
Elektronische Fassung des Titels: SQL in 21 Tagen, ISBN: 3-8272-2020-3


vorheriges KapitelTop Of PageInhaltsverzeichnisIndexInfoseitenächstes Kapitel