Tabellendaten wählen
Hinweis: Um die Tutorials und Beispiele in diesem Abschnitt abzuschließen, müssen Sie über SQL Developer als Benutzer HR mit Oracle Database verbunden sein. Anweisungen finden Sie unter "Verbindung zu Oracle Database als Benutzer-HR aus SQL Developer herstellen".
Info zu Abfragen
Mit einer Abfrage oder einer SQL SELECT-Anweisung werden Daten aus einer oder mehreren Tabellen oder Ansichten gewählt.
Die einfachste Abfrageform hat die folgende Syntax:
SELECT select_list FROM source_listMit dem Wert select_list werden die Spalten angegeben, aus denen die Daten ausgewählt werden. Mit source_list werden die Tabellen oder Views ausgewählt, die diese Spalten enthalten.
Eine Abfrage, die in einer anderen SQL-Anweisung verschachtelt ist, wird als eine Unterabfrage bezeichnet.
In der SQL*Plus-Umgebung können Sie nach der SQL>-Eingabeaufforderung eine Abfrage (oder eine andere SQL-Anweisung) eingeben.
In der SQL Developer-Umgebung können Sie Abfragen (oder eine andere SQL-Anweisung) in das Arbeitsblatt eingeben.
Hinweis: Wenn das Ergebnis einer Abfrage angezeigt wird, können die Datensätze in beliebiger Reihenfolge dargestellt werden, es sei denn, Sie haben mit der Klausel ORDER BY die Reihenfolge angegeben. Weitere Informationen erhalten Sie unter "Ausgewählte Daten sortieren".
Siehe:
-
Oracle Database SQL Language Reference für weitere Informationen zu Abfragen und Unterabfragen
-
Weitere Informationen zur SELECT-Anweisung finden Sie in Oracle Database SQL Language Reference.
-
SQL*Plus User's Guide and Reference für weitere Informationen zur SQL*Plus-Befehlszeilenschnittstelle
-
Oracle SQL Developer - Benutzerdokumentation für Informationen zur Verwendung des Arbeitsblatts in SQL Developer
Abfragen in SQL Developer ausführen
In diesem Abschnitt wird erläutert, wie Sie Abfragen mit dem Arbeitsblatt in SQL Developer ausführen.
Hinweis: Das Arbeitsblatt ist nicht auf Abfragen beschränkt. Sie können es zum Ausführen jeder SQL-Anweisung verwenden.
Schritte zum Ausführen von Abfragen in SQL Developer:
-
Wenn im rechten Schritt von SQL Developer der Bereich hr_conn angezeigt wird:
-
Wenn der Unterbereich "Arbeitsblatt" nicht angezeigt wird, wählen Sie die Registerkarte Arbeitsblatt.
-
Gehen Sie zu Schritt 4
-
-
Wählen Sie das Symbol SQL-Arbeitsblatt.
-
Bei geöffnetem Fenster "Verbindung auswählen":
-
Wenn das Feld "Verbindung" nicht den Wert
hr_connenthält, wählen Sie diesen Wert aus dem Menü. -
Wählen Sie OK.
Ein Bereich wird mit der Registerkarte hr_conn und den beiden Unterbereichen "Worksheet" und "Query Builder" angezeigt. Im Arbeitsblatt können Sie eine SQL-Anweisung eingeben.
-
-
Geben Sie im Arbeitsblatt eine Abfrage (eine SELECT-Anweisung) ein.
-
Klicken Sie auf das Symbol Anweisung ausführen.
Die Abfrage wird ausgeführt. Unter dem Arbeitsblatt wird der Bereich "Abfrageergebnis" mit dem Abfrageergebnis angezeigt.
-
Klicken Sie auf der Registerkarte "hr_conn" auf das Symbol Löschen.
Die Abfrage wird nicht mehr angezeigt, und Sie können eine weitere SQL-Anweisung in das Arbeitsblatt eingeben. Wenn Sie eine weitere SQL-Anweisung ausführen, wird das Ergebnis im Bereich "Abfrageergebnis" angezeigt. Dadurch wird das Ergebnis der zuvor ausgeführten SQL-Anweisung ersetzt.
Siehe auch: Oracle SQL Developer - Benutzerdokumentation für Informationen zur Verwendung des Arbeitsblatts in SQL Developer
Tutorial: Alle Spalten einer Tabelle auswählen
In diesem Tutorial lernen Sie, wie Sie alle Spalten der Tabelle EMPLOYEES auswählen.
Schritte zur Auswahl aller Spalten der Tabelle EMPLOYEES:
-
Wenn ein Bereich mit der Registerkarte hr_conn angezeigt wird, wählen Sie ihn aus. Klicken Sie andernfalls auf das Symbol SQL-Arbeitsblatt, wie unter "Abfragen in SQL Developer ausführen".
-
Geben Sie im Arbeitsblatt die folgende Abfrage ein:
SELECT * FROM EMPLOYEES; -
Klicken Sie auf das Symbol Run Statement.
Die Abfrage wird ausgeführt. Im Fenster {\b Worksheet} wird der Bereich {\b Query Result} mit allen Spalten der Tabelle EMPLOYEES angezeigt.
Achtung: Seien Sie sehr vorsichtig bei der Verwendung von SELECT * in Tabellen mit Spalten, in denen sensible Daten gespeichert werden, wie Passwörter oder Kreditkarteninformationen.
Siehe auch: "Tutorial: EMPLOYEES-Tabelleneigenschaften und -Daten mit SQL Developer anzeigen" für Informationen zu einer anderen Möglichkeit zum Anzeigen von Tabellendaten mit SQL Developer
Tutorial: Bestimmte Spalten einer Tabelle auswählen
In diesem Tutorial erfahren Sie, wie Sie nur die Spalten FIRST_NAME, LAST_NAME und DEPARTMENT_ID der Tabelle EMPLOYEES auswählen.
Schritte zur Auswahl nur FIRST_NAME, LAST_NAME und DEPARTMENT_ID:
-
Wenn ein Bereich mit der Registerkarte hr_conn angezeigt wird, wählen Sie ihn aus. Klicken Sie andernfalls auf das Symbol "SQL-Arbeitsblatt", wie unter Abfragen in SQL Developer ausführen beschrieben.
-
Wenn der Arbeitsblattbereich eine Abfrage enthält, löschen Sie die Abfrage, indem Sie das Symbol Löschen auswählen.
-
Geben Sie im Arbeitsblatt die folgende Abfrage ein:
SELECT FIRST_NAME, LAST_NAME, DEPARTMENT_ID FROM EMPLOYEES; -
Klicken Sie auf das Symbol Run Statement.
Die Abfrage wird ausgeführt. Unter dem Arbeitsblatt wird der Bereich "Abfrageergebnis" angezeigt, in dem die Ergebnisse der Abfrage angezeigt werden, die dem folgenden Text ähneln.
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Donald OConnell 50
Douglas Grant 50
Jennifer Whalen 10
Michael Hartstein 20
Pat Fay 20
Susan Mavris 40
Hermann Baer 70
Shelley Higgins 110
William Gietz 110
Steven King 90
Neena Kochhar 90
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Lex De Haan 90
...
Kevin Feeney 50
107 rows selected.Ausgewählte Spalten unter neuen Überschriften anzeigen
In den angezeigten Abfrageergebnissen sind Standardspaltenüberschriften Spaltennamen. Um eine Spalte unter einer neuen Überschrift anzuzeigen, geben Sie die neue Überschrift (alias) direkt nach dem Spaltennamen an. Mit dem Aliasnamen wird die Spalte für die Dauer der Abfrage umbenannt. In der Datenbank wird der Name jedoch nicht geändert.
Bei dieser Abfrage in Beispiel 2-5 werden dieselben Spalten ausgewählt wie bei der Abfrage in Tutorial: Bestimmte Spalten einer Tabelle auswählen, doch werden dort zudem Aliasnamen für die Spalten festgelegt. Da die Aliasnamen nicht in Anführungszeichen gesetzt werden, sind sie hier in Großbuchstaben dargestellt.
Wenn Spaltenaliase in doppelte Anführungszeichen gesetzt wird, wird die Kleinschreibung beibehalten, und Aliase können Leerzeichen enthalten, wie in Beispiel 2-6 dargestellt.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über die SELECT-Anweisung, einschließlich der Spaltenalias (c_alias)
Beispiel 2-5: Ausgewählte Spalten unter neuen Überschriften anzeigen
SELECT FIRST_NAME First, LAST_NAME last, DEPARTMENT_ID DepT
FROM EMPLOYEES;Das Ergebnis sieht etwa folgendermaßen aus:
FIRST LAST DEPT
-------------------- ------------------------- ----------
Donald OConnell 50
Douglas Grant 50
Jennifer Whalen 10
Michael Hartstein 20
Pat Fay 20
Susan Mavris 40
Hermann Baer 70
Shelley Higgins 110
William Gietz 110
Steven King 90
Neena Kochhar 90
FIRST LAST DEPT
-------------------- ------------------------- ----------
Lex De Haan 90
...
Kevin Feeney 50
107 rows selected.Beispiel 2-6: Groß-/Kleinschreibung beibehalten und Leerzeichen in Spaltenaliasen einfügen
SELECT FIRST_NAME "Given Name", LAST_NAME "Family Name"
FROM EMPLOYEES;Das Ergebnis sieht etwa folgendermaßen aus:
Given Name Family Name
-------------------- -------------------------
Donald OConnell
Douglas Grant
Jennifer Whalen
Michael Hartstein
Pat Fay
Susan Mavris
Hermann Baer
Shelley Higgins
William Gietz
Steven King
Neena Kochhar
Given Name Family Name
-------------------- -------------------------
Lex De Haan
...
Kevin Feeney
107 rows selected.Daten auswählen, die bestimmte Bedingungen erfüllen
Wenn Sie nur Daten auswählen möchten, die eine bestimmte Bedingung erfüllen, nehmen sie die WHERE-Klausel in die SELECT-Anweisung auf.
Die Bedingung in der WHERE-Klausel kann eine beliebige SQL-Bedingung sein (Informationen über SQL-Bedingungen finden Sie in der Oracle Database SQL Language Reference).
Die Abfrage in Beispiel 2-7 wählt nur Daten für Mitarbeiter in Abteilung 90 aus.
Um nur Daten für Mitarbeiter der Abteilungen 100, 110 und 120 auszuwählen, verwenden Sie die folgende WHERE-Klausel:
WHERE DEPARTMENT_ID IN (100, 110, 120);Die Abfrage in Beispiel 2-8 wählt nur Daten für Mitarbeiter aus, deren Nachname mit "Ma" beginnt.
Um nur Daten für Mitarbeiter auszuwählen, deren Nachname "ma" enthält, verwenden Sie die folgende WHERE-Klausel:
WHERE LAST_NAME LIKE '%ma%';Die Abfrage in Beispiel 2-9 testet zwei Bedingungen: ob das Gehalt mindestens 11000 beträgt und ob der Prozentsatz für Kommissionen ungleich Null ist.
Siehe:
-
Oracle Database SQL Language Reference für weitere Informationen über die SELECT-Anweisung, einschließlich der Klausel WHERE
-
Oracle Database SQL Language Reference für weitere Informationen über SQL-Bedingungen
Beispiel 2-7: Daten aus einer einzelnen Abteilung auswählen
SELECT FIRST_NAME, LAST_NAME, DEPARTMENT_ID
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90;Das Ergebnis sieht etwa folgendermaßen aus:
FIRST_NAME LAST_NAME DEPARTMENT_ID
-------------------- ------------------------- -------------
Steven King 90
Neena Kochhar 90
Lex De Haan 90
3 rows selected.Beispiel 2-8: Daten für Nachnamen auswählen, die mit derselben Teilzeichenfolge beginnen
SELECT FIRST_NAME, LAST_NAME
FROM EMPLOYEES
WHERE LAST_NAME LIKE 'Ma%';Das Ergebnis sieht etwa folgendermaßen aus:
FIRST_NAME LAST_NAME
-------------------- -------------------------
Jason Mallin
Steven Markle
James Marlow
Mattea Marvins
Randall Matos
Susan Mavris
6 rows selected.Beispiel 2-9: Daten auswählen, die zwei Bedingungen erfüllen
SELECT FIRST_NAME, LAST_NAME, SALARY, COMMISSION_PCT "%"
FROM EMPLOYEES
WHERE (SALARY >= 11000) AND (COMMISSION_PCT IS NOT NULL);Das Ergebnis sieht etwa folgendermaßen aus:
FIRST_NAME LAST_NAME SALARY %
-------------------- ------------------------- ---------- ----------
John Russell 14000 .4
Karen Partners 13500 .3
Alberto Errazuriz 12000 .3
Gerald Cambrault 11000 .3
Lisa Ozer 11500 .25
Ellen Abel 11000 .3
6 rows selected.Ausgewählte Daten sortieren
Wenn die Ergebnisse der Abfrage angezeigt werden, können Sie die Datensätze in beliebiger Reihenfolge sehen, es sei denn, Sie haben ihre Reihenfolge mithilfe der Klausel ORDER BY angegeben.
Die Abfrageergebnisse in Beispiel 2-10 werden nach LAST_NAME in aufsteigender Reihenfolge (Standard) sortiert.
Alternativ können Sie in SQL Developer die Klausel ORDER BY auslassen und zum Sortieren auf den Namen der zu sortierenden Spalte doppelklicken.
Das Sortierkriterium muss nicht in die Auswahlliste aufgenommen werden, wie Beispiel 2-11 zeigt.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über die SELECT-Anweisung, einschließlich der Klausel ORDER BY
Beispiel 2-10: Ausgewählte Daten nach LAST_NAME sortieren
SELECT FIRST_NAME, LAST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Ergebnis:
FIRST_NAME LAST_NAME HIRE_DATE
-------------------- ------------------------- ---------
Ellen Abel 11-MAY-04
Sundar Ande 24-MAR-08
Mozhe Atkinson 30-OCT-05
David Austin 25-JUN-05
Hermann Baer 07-JUN-02
Shelli Baida 24-DEC-05
Amit Banda 21-APR-08
Elizabeth Bates 24-MAR-07
...
FIRST_NAME LAST_NAME HIRE_DATE
-------------------- ------------------------- ---------
Jose Manuel Urman 07-MAR-06
Peter Vargas 09-JUL-06
Clara Vishney 11-NOV-05
Shanta Vollman 10-OCT-05
Alana Walsh 24-APR-06
Matthew Weiss 18-JUL-04
Jennifer Whalen 17-SEP-03
Eleni Zlotkey 29-JAN-08
107 rows selectedBeispiel 2-11: Ausgewählte Daten nach einer nicht ausgewählten Spalte sortieren
SELECT FIRST_NAME, HIRE_DATE
FROM EMPLOYEES
ORDER BY LAST_NAME;Ergebnis:
FIRST_NAME HIRE_DATE
-------------------- ---------
Ellen 11-MAY-04
Sundar 24-MAR-08
Mozhe 30-OCT-05
David 25-JUN-05
Hermann 07-JUN-02
Shelli 24-DEC-05
Amit 21-APR-08
Elizabeth 24-MAR-07
...
FIRST_NAME HIRE_DATE
-------------------- ---------
Jose Manuel 07-MAR-06
Peter 09-JUL-06
Clara 11-NOV-05
Shanta 10-OCT-05
Alana 24-APR-06
Matthew 18-JUL-04
Jennifer 17-SEP-03
Eleni 29-JAN-08
107 rows selected.Daten aus mehreren Tabellen auswählen
Um Daten aus mehreren Tabellen auszuwählen, verwenden Sie eine Abfrage, die als Join bezeichnet wird. Die Tabellen in einem Join müssen mindestens einen Spaltennamen gemeinsam verwenden.
Beispiel: Sie möchten FIRST_NAME, LAST_NAME und DEPARTMENT_NAME für jeden Mitarbeiter auswählen. FIRST_NAME und LAST_NAME befinden sich in der Tabelle EMPLOYEES, und DEPARTMENT_NAME befindet sich in der Tabelle DEPARTMENTS. Beide Tabellen haben DEPARTMENT_ID. Sie können die Abfrage in Beispiel 2-12 verwenden.
Bezeichner für Tabellennamen sind für Spaltennamen, die nur in einer Tabelle eines Joins enthalten sind, optional, aber erforderlich für Spaltennamen, die in beiden Tabellen enthalten sind. Die folgende Abfrage ist äquivalent zu der Abfrage in Beispiel 2-12:
SELECT FIRST_NAME "First",
LAST_NAME "Last",
DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES, DEPARTMENTS
WHERE EMPLOYEES.DEPARTMENT_ID = DEPARTMENTS.DEPARTMENT_ID
ORDER BY DEPARTMENT_NAME, LAST_NAME;Um Abfragen, für die qualifizierte Spaltennamen verwendet werden, besser lesbar zu machen, verwenden Sie Tabellenaliasnamen, wie in folgendem Beispiel dargestellt:
SELECT FIRST_NAME "First",
LAST_NAME "Last",
DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES e, DEPARTMENTS d
WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID
ORDER BY d.DEPARTMENT_NAME, e.LAST_NAME;Auch wenn Sie die Aliase in der FROM-Klausel erstellen, können Sie sie früher in der Abfrage verwenden, wie im folgenden Beispiel dargestellt:
SELECT e.FIRST_NAME "First",
e.LAST_NAME "Last",
d.DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES e, DEPARTMENTS d
WHERE e.DEPARTMENT_ID = d.DEPARTMENT_ID
ORDER BY d.DEPARTMENT_NAME, e.LAST_NAME;Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über Joins
Beispiel 2-12 Daten aus zwei Tabellen auswählen (zwei Tabellen zusammenschließen)
SELECT EMPLOYEES.FIRST_NAME "First",
EMPLOYEES.LAST_NAME "Last",
DEPARTMENTS.DEPARTMENT_NAME "Dept. Name"
FROM EMPLOYEES, DEPARTMENTS
WHERE EMPLOYEES.DEPARTMENT_ID = DEPARTMENTS.DEPARTMENT_ID
ORDER BY DEPARTMENTS.DEPARTMENT_NAME, EMPLOYEES.LAST_NAME;Ergebnis:
First Last Dept. Name
-------------------- ------------------------- ------------------------------
William Gietz Accounting
Shelley Higgins Accounting
Jennifer Whalen Administration
Lex De Haan Executive
Steven King Executive
Neena Kochhar Executive
John Chen Finance
...
Jose Manuel Urman Finance
Susan Mavris Human Resources
David Austin IT
...
Valli Pataballa IT
Pat Fay Marketing
Michael Hartstein Marketing
Hermann Baer Public Relations
Shelli Baida Purchasing
...
Sigal Tobias Purchasing
Ellen Abel Sales
...
Eleni Zlotkey Sales
Mozhe Atkinson Shipping
...
Matthew Weiss Shipping
106 rows selected.Operatoren und Funktionen in Anfragen verwenden
Die select_list einer Abfrage kann SQL-Ausdrücke enthalten, die wiederum SQL-Operatoren und SQL-Funktionen enthalten können. Diese Operatoren und Funktionen können Tabellendaten als Operanden und Argumente verwenden. Die SQL-Ausdrücke werden ausgewertet, und ihre Werte werden in den Abfrageergebnissen angezeigt.
Siehe:
-
Oracle Database SQL Language Reference für weitere Informationen zu SQL-Operatoren
-
Oracle Database SQL Language Reference für weitere Informationen zu SQL-Funktionen
Arithmetische Operatoren in Abfragen verwenden
Die einfachen arithmetischen Operatoren -+ (Hinzufügen), - (Subtraktion), \* (Multiplikation) und / (Division) - arbeiten an Spaltenwerten.
Mit der Abfrage in Beispiel 2-13 werden LAST_NAME, SALARY (Monatsgehalt) und Jahresgehalt jedes Mitarbeiters in Abteilung 90 zurückgegeben, wobei die Person in absteigender Reihenfolge gemäß Spalte SALARY sortiert wird.
Beispiel 2-13: Arithmetischen Ausdruck in einer Abfrage verwenden
SELECT LAST_NAME,
SALARY "Monthly Pay",
SALARY * 12 "Annual Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 90
ORDER BY SALARY DESC;Ergebnis:
LAST_NAME Monthly Pay Annual Pay
------------------------- ----------- ----------
King 24000 288000
De Haan 17000 204000
Kochhar 17000 204000Numerische Funktionen in Abfragen verwenden
Numerische Funktionen akzeptieren numerische Eingaben und geben numerische Werte zurück. Jede numerische Funktion gibt für jede ausgewertete Zeile einen einzelnen Wert zurück.
Die numerischen Funktionen, die SQL unterstützt, werden in der Oracle Database SQL Language Reference aufgeführt und beschrieben.
Die Abfrage in Beispiel 2-14 verwendet die numerische Funktion ROUND, um auf den nächsten Cent gerundet das Tagesentgelt jedes Mitarbeiters in Abteilung 100 anzuzeigen.
Die Abfrage in Beispiel 2-15 verwendet die numerische Funktion TRUNC, um auf den nächsten Dollar gekürzt das Tagesentgelt jedes Mitarbeiters in Abteilung 100 anzuzeigen.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über SQL-Numerikfunktionen
Beispiel 2-14: Numerische Daten runden
SELECT LAST_NAME,
ROUND (((SALARY * 12)/365), 2) "Daily Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME Daily Pay
------------------------- ----------
Chen 269.59
Faviet 295.89
Greenberg 394.52
Popp 226.85
Sciarra 253.15
Urman 256.44
6 rows selected.Beispiel 2-15: Numerische Daten abschneiden
SELECT LAST_NAME,
TRUNC ((SALARY * 12)/365) "Daily Pay"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME Daily Pay
------------------------- ----------
Chen 269
Faviet 295
Greenberg 394
Popp 226
Sciarra 253
Urman 256
6 rows selected.Verkettungoperator in Abfragen verwenden
Der Verkettungsoperator (||) kombiniert zwei Zeichenfolgen in einer Zeichenfolge, indem er die zweite Zeichenfolge an die erste anfügt. Beispiel: 'a'||'b'='ab'. Mit diesem Operator können Sie Informationen aus zwei Spalten oder Ausdrücken in derselben Spalte eines Abfrageergebnisses zusammenfassen.
Die Abfrage in Beispiel 2-16 verkettet den Vornamen, ein Leerzeichen und den Nachnamen jedes ausgewählten Mitarbeiters.
Weitere Informationen zum Verkettungsoperator finden Sie in Oracle Database SQL Language Reference.
Beispiel 2-16: Zeichendaten verketten
SELECT FIRST_NAME || ' ' || LAST_NAME "Name"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Ergebnis:
Name
----------------------------------------------
John Chen
Daniel Faviet
Nancy Greenberg
Luis Popp
Ismael Sciarra
Jose Manuel Urman
6 rows selected.Zeichenfunktionen in Abfragen verwenden
Zeichenfunktionen akzeptieren Zeicheneingaben. Der Großteil der Funktionen gibt Zeichenwerte zurück, ein Teil jedoch numerische Werte. Jede Zeichenfunktion gibt für jede bewertete Zeile genau einen Wert zurück.
Die von SQL unterstützten Zeichenfunktionen sind in der Oracle Database SQL Language Reference aufgeführt und beschrieben.
Mit den Funktionen UPPER, INITCAP und LOWER zeigen Sie Zeichenargumente in Großbuchstaben, Groß-/Kleinschreibung bzw. Kleinschreibung an.
Die Abfrage in Beispiel 2-17 zeigt LAST_NAME in Großbuchstaben, FIRST_NAME mit dem ersten Zeichen in Großbuchstaben und alle anderen Zeichen in Kleinbuchstaben und EMAIL in Kleinbuchstaben an.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über SQL-Zeichenfunktionen
Beispiel 2-17: Groß-/Kleinschreibung von Zeichendaten
SELECT UPPER(LAST_NAME) "Last",
INITCAP(FIRST_NAME) "First",
LOWER(EMAIL) "E-Mail"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY EMAIL;Ergebnis:
Last First E-Mail
------------------------- -------------------- -------------------------
FAVIET Daniel dfaviet
SCIARRA Ismael isciarra
CHEN John jchen
URMAN Jose Manuel jmurman
POPP Luis lpopp
GREENBERG Nancy ngreenbe
6 rows selected.Datetime-Funktionen in Abfragen verwenden
Datetime-Funktionen arbeiten mit DATE-, Zeitstempel- und Intervallwerten. Datetime-Funktionen geben für jede ausgewertete Zeile einen einzelnen Wert zurück.
Die von SQL unterstützte Datetime-Funktionen werden in Oracle Database SQL Language Reference aufgeführt und beschrieben.
Für jeden DATE- und Zeitstempelwert speichert Oracle Database die folgenden Informationen:
-
Jahr
-
Monat
-
Date (Datumsdatentyp)
-
Hour
-
Minute
-
Zweiter
Für jeden Zeitstempelwert speichert Oracle Database auch den Bruchteil der Sekunde, dessen Genauigkeit Sie angeben können. Um die Zeitzone auch zu speichern, verwenden Sie den Datentyp TIMESTAMP WITH TIME ZONE oder TIMESTAMP WITH LOCAL TIME ZONE.
Weitere Informationen zum Datentyp DATE finden Sie in der Oracle Database SQL Language Reference.
Weitere Informationen zum Datentyp TIMESTAMP finden Sie in der Oracle Database SQL Language Reference.
Informationen zu den anderen Zeitstempeldatentypen und den Intervalldatentypen finden Sie in der Oracle Database SQL Language Reference.
Die Abfrage in Beispiel 2-18 verwendet die Funktionen EXTRACT und SYSDATE, um zu zeigen, wie viele Jahre der einzelne Mitarbeiter der Abteilung 100 bereits angestellt sind. Die Funktion SYSDATE gibt das aktuelle Datum der Systemuhr als DATE-Wert zurück. Weitere Informationen zur Funktion SYSDATE finden Sie in der Oracle Database SQL Language Reference. Weitere Informationen zur Funktion EXTRACT finden Sie in Oracle Database SQL Language Reference.
Die Abfrage in Beispiel 2-19 verwendet die Funktion SYSTIMESTAMP, um das aktuelle Systemdatum und die aktuelle Systemuhrzeit anzuzeigen. Die Funktion SYSTIMESTAMP gibt einen TIMESTAMP-Wert zurück. Weitere Informationen zur Funktion SYSTIMESTAMP finden Sie in Oracle Database SQL Language Reference.
Die Tabelle in der FROM-Klausel der Abfrage, DUAL, ist eine einzeilige Tabelle, die Oracle Database automatisch zusammen mit dem Data Dictionary erstellt. Treffen Sie eine Option aus DUAL, wenn Sie einen konstanten Ausdruck mit der Anweisung SELECT berechnen möchten. Da DUAL nur eine einzige Zeile enthält, wird die Konstante nur ein einziges Mal zurückgegeben. Weitere Informationen zur Auswahl aus DUAL finden Sie in Oracle Database SQL Language Reference.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über SQL-Datetime-Funktionen
Beispiel 2-18: Anzahl der Jahre zwischen Datumsangaben anzeigen
SELECT LAST_NAME,
(EXTRACT(YEAR FROM SYSDATE) - EXTRACT(YEAR FROM HIRE_DATE)) "Years Employed"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY "Years Employed";Ergebnis:
LAST_NAME Years Employed
------------------------- --------------
Popp 5
Urman 6
Chen 7
Sciarra 7
Greenberg 10
Faviet 10
6 rows selected.Beispiel 2-19: Systemdatum und -zeit anzeigen
SELECT EXTRACT(HOUR FROM SYSTIMESTAMP) || ':' ||
EXTRACT(MINUTE FROM SYSTIMESTAMP) || ':' ||
ROUND(EXTRACT(SECOND FROM SYSTIMESTAMP), 0) || ', ' ||
EXTRACT(MONTH FROM SYSTIMESTAMP) || '/' ||
EXTRACT(DAY FROM SYSTIMESTAMP) || '/' ||
EXTRACT(YEAR FROM SYSTIMESTAMP) "System Time and Date"
FROM DUAL;Das Ergebnis hängt vom jeweils aktuellen Wert von SYSTIMESTAMP ab, hat jedoch das folgende Format:
System Time and Date
-------------------------------------------------------------------
18:17:53, 12/27/2012Konvertierungsfunktionen in Abfragen verwenden
Konvertierungsfunktionen wandeln einen Datentyp zu einem anderen um.
Die von SQL unterstützten Konvertierungsfunktionen werden in Oracle Database SQL Language Reference aufgelistet und beschrieben.
Die Abfrage in Beispiel 2-20 verwendet die Funktion TO_CHAR, um HIRE_DATE-Werte (die das Format DATE aufweisen) in Zeichenwerte zu konvertieren, die das Format FMMonth DD YYYY aufweisen. Mit FM werden Leerstellen am Ende und am Anfang des Monatsnamens entfernt. FMMonth DD YYYY ist ein Beispiel für ein Datetime-Formatmodell. Informationen zu Datetime-Formatmodellen finden Sie in der Oracle Database SQL Language Reference.
Die Abfrage in Beispiel 2-21 verwendet die TO_NUMBER-Funktion, um POSTAL_CODE-Werte (die zum Datentyp VARCHAR2 gehören) in Werte des Typs NUMBER zu konvertieren, die in Berechnungen verwendet werden.
Siehe:
-
Oracle Database SQL Language Reference für weitere Informationen zu SQL-Konvertierungsfunktionen
Beispiel 2-20: Datumsangaben mittels einer Formatvorlage in Zeichen konvertieren
SELECT LAST_NAME,
HIRE_DATE,
TO_CHAR(HIRE_DATE, 'FMMonth DD YYYY') "Date Started"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME HIRE_DATE Date Started
------------------------- --------- -----------------
Chen 28-SEP-05 September 28 2005
Faviet 16-AUG-02 August 16 2002
Greenberg 17-AUG-02 August 17 2002
Popp 07-DEC-07 December 7 2007
Sciarra 30-SEP-05 September 30 2005
Urman 07-MAR-06 March 7 2006
6 rows selected.Beispiel 2-21: Zeichen in Zahlen konvertieren
SELECT CITY,
POSTAL_CODE "Old Code",
TO_NUMBER(POSTAL_CODE) + 1 "New Code"
FROM LOCATIONS
WHERE COUNTRY_ID = 'US'
ORDER BY POSTAL_CODE;Ergebnis:
CITY Old Code New Code
------------------------------ ------------ ----------
Southlake 26192 26193
South Brunswick 50090 50091
Seattle 98199 98200
South San Francisco 99236 99237
4 rows selected.Aggregat-Funktionen in Abfragen verwenden
Eine Aggregatfunktion nimmt eine Gruppe von Zeilen an und gibt eine einzelne Ergebniszeile zurück. Die Zeilengruppe kann eine vollständige Tabelle oder View sein.
Die Aggregatfunktionen, die SQL unterstützt, werden in Oracle Database SQL Language Reference aufgeführt und beschrieben.
Aggregatfunktionen sind besonders leistungsfähig, wenn sie mit der GROUP BY-Klausel verwendet werden, die Abfrageergebnisse nach einer oder mehreren Spalten gruppiert, mit einem Ergebnis für jede Gruppe.
Die Abfrage in Beispiel 2-22 verwendet die Funktion COUNT und die GROUP BY-Klausel, um anzuzeigen, wie viele Personen jedem Manager unterstellt sind. Das Platzhalterzeichen * stellt einen vollständigen Datensatz dar. Beispiel 2-22 zeigt, dass ein Mitarbeiter keinem Mitarbeiter unterstellt ist. Mit der folgenden Abfrage werden der Vor- und Nachname sowie die Position des Mitarbeiters gewählt.
COLUMN FIRST_NAME FORMAT A10;
COLUMN LAST_NAME FORMAT A10;
COLUMN JOB_TITLE FORMAT A10;
SELECT e.FIRST_NAME,
e.LAST_NAME,
j.JOB_TITLE
FROM EMPLOYEES e, JOBS j
WHERE e.JOB_ID = j.JOB_ID
AND MANAGER_ID IS NULL;Ergebnis:
FIRST_NAME LAST_NAME JOB_TITLE
---------- ---------- ----------
Steven King PresidentDamit die Abfrage nur Zeilen zurückgibt, bei denen Aggregatwerte die bestimmten Bedingungen erfüllen, verwenden Sie eine Aggregatfunktion in der Klausel HAVING der Abfrage.
Die Abfrage in Beispiel 2-23 zeigt, wie viel jede Abteilung jährlich für Gehälter ausgibt, jedoch nur für Abteilungen, deren Betrag $1.000.000 überschreitet.
In der Abfrage in Beispiel 2-24 werden mehrere Aggregatfunktionen verwendet, um Statistiken für die Gehälter jeder JOB_ID anzuzeigen.
Siehe auch: Oracle Database SQL Language Reference für weitere Informationen über SQL-Aggregatfunktionen
Beispiel 2-22: Zeilen in jeder Gruppe zählen
SELECT MANAGER_ID "Manager",
COUNT(*) "Number of Reports"
FROM EMPLOYEES
GROUP BY MANAGER_ID
ORDER BY MANAGER_ID;Ergebnis:
Manager Number of Reports
---------- -----------------
100 14
101 5
102 1
103 4
108 5
114 5
120 8
121 8
122 8
123 8
124 8
145 6
146 6
147 6
148 6
149 6
201 1
205 1
1
19 rows selected.Beispiel 2-23: Aggregatfunktionen auf Zeilen beschränken, die eine Bedingung erfüllen
SELECT DEPARTMENT_ID "Department",
SUM(SALARY*12) "All Salaries"
FROM EMPLOYEES
HAVING SUM(SALARY * 12) >= 1000000
GROUP BY DEPARTMENT_ID;Ergebnis:
Department All Salaries
---------- ------------
50 1876800
80 3654000Beispiel 2-24: Aggregatfunktionen für statistische Informationen verwenden
SELECT JOB_ID,
COUNT(*) "#",
MIN(SALARY) "Minimum",
ROUND(AVG(SALARY), 0) "Average",
MEDIAN(SALARY) "Median",
MAX(SALARY) "Maximum",
ROUND(STDDEV(SALARY)) "Std Dev"
FROM EMPLOYEES
GROUP BY JOB_ID
ORDER BY JOB_ID;Ergebnis:
JOB_ID # Minimum Average Median Maximum Std Dev
---------- ---------- ---------- ---------- ---------- ---------- ----------
AC_ACCOUNT 1 8300 8300 8300 8300 0
AC_MGR 1 12008 12008 12008 12008 0
AD_ASST 1 4400 4400 4400 4400 0
AD_PRES 1 24000 24000 24000 24000 0
AD_VP 2 17000 17000 17000 17000 0
FI_ACCOUNT 5 6900 7920 7800 9000 766
FI_MGR 1 12008 12008 12008 12008 0
HR_REP 1 6500 6500 6500 6500 0
IT_PROG 5 4200 5760 4800 9000 1926
MK_MAN 1 13000 13000 13000 13000 0
MK_REP 1 6000 6000 6000 6000 0
PR_REP 1 10000 10000 10000 10000 0
PU_CLERK 5 2500 2780 2800 3100 239
PU_MAN 1 11000 11000 11000 11000 0
SA_MAN 5 10500 12200 12000 14000 1525
SA_REP 30 6100 8350 8200 11500 1524
SH_CLERK 20 2500 3215 3100 4200 548
ST_CLERK 20 2100 2785 2700 3600 453
ST_MAN 5 5800 7280 7900 8200 1066
19 rows selected.Funktionen mit NULL-Beziehung in Abfragen verwenden
Mit NULL verwandte Funktionen erleichtern das Handling von NULL-Werten.
Die von SQL unterstützten NULL-bezogenen Funktionen werden in der Oracle Database SQL-Sprachreferenz näher beschrieben.
Die Abfrage in Beispiel 2-25 gibt den Nachnamen und die Provision der Mitarbeiter zurück, deren Nachnamen mit "B" beginnen. Erhält ein Mitarbeiter keine Provision (d.h. wenn COMMISSION_PCT den Wert NULL hat), ersetzt die NVL-Funktion "Nicht anwendbar" durch NULL.
Die Abfrage in Beispiel 2-26 gibt den Nachnamen, das Gehalt und das Einkommen der Mitarbeiter zurück, deren Nachnamen mit "B" beginnen. Verwenden Sie dazu die NVL2-Funktion: Wenn COMMISSION_PCT nicht NULL ist, ist das Einkommen das Gehalt plus die Provision. Wenn COMMISSION_PCT NULL ist, ist das Einkommen nur das Gehalt.
Siehe:
-
Oracle Database SQL Language Reference, um weitere Informationen zur NVL-Funktion zu erhalten
-
Oracle Database SQL Language Reference, um weitere Informationen zur Funktion NVL2 zu erhalten
Beispiel 2-25: Zeichenketten durch NULL-Werte ersetzen
SELECT LAST_NAME,
NVL(TO_CHAR(COMMISSION_PCT), 'Not Applicable') "COMMISSION"
FROM EMPLOYEES
WHERE LAST_NAME LIKE 'B%'
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME COMMISSION
------------------------- ----------------------------------------
Baer Not Applicable
Baida Not Applicable
Banda .1
Bates .15
Bell Not Applicable
Bernstein .25
Bissot Not Applicable
Bloom .2
Bull Not Applicable
9 rows selected.Beispiel 2-26: Verschiedene Ausdrücke für NULL- und Nicht-NULL-Werte angeben
SELECT LAST_NAME, SALARY,
NVL2(COMMISSION_PCT, SALARY + (SALARY * COMMISSION_PCT), SALARY) INCOME
FROM EMPLOYEES WHERE LAST_NAME LIKE 'B%'
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME SALARY INCOME
------------------------- ---------- ----------
Baer 10000 10000
Baida 2900 2900
Banda 6200 6820
Bates 7300 8395
Bell 4000 4000
Bernstein 9500 11875
Bissot 3300 3300
Bloom 10000 12000
Bull 4100 4100
9 rows selected.CASE-Ausdrücke in Abfragen verwenden
Mit einem CASE-Ausdruck können Sie die Logik IF … THEN … ELSE in SQL-Anweisungen verwenden, ohne Unterprogramme aufzurufen. Es gibt zwei Arten von CASE-Ausdrücken, einfach und durchsucht.
Die Abfrage in Beispiel 2-27 verwendet einen einfachen CASE-Ausdruck, um den Ländernamen für jeden Ländercode anzuzeigen.
Die Abfrage in Beispiel 2-28 verwendet einen gesuchten CASE-Ausdruck, um vorgeschlagene Gehaltserhöhungen (15%, 10%, 5% oder 0%) basierend auf Datumsbereichen anzuzeigen, die der Beschäftigungsdauer zugeordnet sind.
Siehe:
-
Oracle Database SQL-Sprachreferenz, um weitere Informationen zu CASE-Ausdrücken zu erhalten
-
Oracle Database PL/SQL-Sprachreferenz, um weitere Informationen zu CASE-Ausdrücken zu erhalten
Beispiel 2-27: Einfache CASE-Ausdrücke in einer Abfrage verwenden
SELECT UNIQUE COUNTRY_ID ID,
CASE COUNTRY_ID
WHEN 'AU' THEN 'Australia'
WHEN 'BR' THEN 'Brazil'
WHEN 'CA' THEN 'Canada'
WHEN 'CH' THEN 'Switzerland'
WHEN 'CN' THEN 'China'
WHEN 'DE' THEN 'Germany'
WHEN 'IN' THEN 'India'
WHEN 'IT' THEN 'Italy'
WHEN 'JP' THEN 'Japan'
WHEN 'MX' THEN 'Mexico'
WHEN 'NL' THEN 'Netherlands'
WHEN 'SG' THEN 'Singapore'
WHEN 'UK' THEN 'United Kingdom'
WHEN 'US' THEN 'United States'
ELSE 'Unknown'
END COUNTRY
FROM LOCATIONS
ORDER BY COUNTRY_ID;Ergebnis:
ID COUNTRY
-- --------------
AU Australia
BR Brazil
CA Canada
CH Switzerland
CN China
DE Germany
IN India
IT Italy
JP Japan
MX Mexico
NL Netherlands
SG Singapore
UK United Kingdom
US United States
14 rows selected.Beispiel 2-28: Durchsuchten CASE-Ausdruck in einer Abfrage verwenden
SELECT LAST_NAME "Name",
HIRE_DATE "Started",
SALARY "Salary",
CASE
WHEN HIRE_DATE < TO_DATE('01-Jan-03', 'dd-mon-yy')
THEN TRUNC(SALARY*1.15, 0)
WHEN HIRE_DATE >= TO_DATE('01-Jan-03', 'dd-mon-yy') AND
HIRE_DATE < TO_DATE('01-Jan-06', 'dd-mon-yy')
THEN TRUNC(SALARY*1.10, 0)
WHEN HIRE_DATE >= TO_DATE('01-Jan-06', 'dd-mon-yy') AND
HIRE_DATE < TO_DATE('01-Jan-07', 'dd-mon-yy')
THEN TRUNC(SALARY*1.05, 0)
ELSE SALARY
END "Proposed Salary"
FROM EMPLOYEES
WHERE DEPARTMENT_ID = 100
ORDER BY HIRE_DATE;Ergebnis:
Name Started Salary Proposed Salary
------------------------- --------- ---------- ---------------
Faviet 16-AUG-02 9000 10350
Greenberg 17-AUG-02 12008 13809
Chen 28-SEP-05 8200 9020
Sciarra 30-SEP-05 7700 8470
Urman 07-MAR-06 7800 8190
Popp 07-DEC-07 6900 6900
6 rows selected.DECODE-Funktion in Abfragen verwenden
Die Funktion DECODE vergleicht einen Ausdruck mit mehreren Suchwerten. Wenn der Wert des Ausdrucks mit einem Suchwert übereinstimmt, gibt DECODE das Ergebnis zurück, das mit diesem Suchwert verknüpft ist. Wenn DECODE keine Übereinstimmung findet, gibt es den Standardwert (wenn angegeben) oder NULL (wenn kein Standardwert angegeben wurde) zurück.
Die Abfrage in Beispiel 2-29 verwendet die Funktion DECODE, um geplante Gehaltserhöhungen für drei verschiedene Tätigkeiten anzuzeigen. Der Ausdruck ist JOB_ID, die Suchwerte sind "PU_CLERK", "SH_CLERK" und "ST_CLERK". Der Standardwert ist SALARY.
Hinweis: Bei den Argumenten der Funktion DECODE kann es sich um einen beliebigen numerischen SQL- oder Zeichentyp handeln. Oracle konvertiert den Ausdruck und jeden Suchwert vor dem Vergleich automatisch in den Datentyp des ersten Suchwerts. Oracle konvertiert den Rückgabewert automatisch in denselben Datentyp wie das erste Ergebnis. Wenn das erste Ergebnis den Datentyp CHAR hat oder wenn das erste Ergebnis NULL ist, konvertiert Oracle den Rückgabewert in den Datentyp VARCHAR2.
Siehe:
-
Oracle Database SQL Language Reference für Informationen zur DECODE-Funktion
Beispiel 2-29: Verwendung der Funktion DECODE in einer Abfrage
SELECT LAST_NAME, JOB_ID, SALARY,
DECODE(JOB_ID,
'PU_CLERK', SALARY * 1.10,
'SH_CLERK', SALARY * 1.15,
'ST_CLERK', SALARY * 1.20,
SALARY) "Proposed Salary"
FROM EMPLOYEES
WHERE JOB_ID LIKE '%_CLERK'
AND LAST_NAME < 'E'
ORDER BY LAST_NAME;Ergebnis:
LAST_NAME JOB_ID SALARY Proposed Salary
------------------------- ---------- ---------- ---------------
Atkinson ST_CLERK 2800 3360
Baida PU_CLERK 2900 3190
Bell SH_CLERK 4000 4600
Bissot ST_CLERK 3300 3960
Bull SH_CLERK 4100 4715
Cabrio SH_CLERK 3000 3450
Chung SH_CLERK 3800 4370
Colmenares PU_CLERK 2500 2750
Davies ST_CLERK 3100 3720
Dellinger SH_CLERK 3400 3910
Dilly SH_CLERK 3600 4140
11 rows selected.