Quelltext der Seite Einführung in SQL: Funktionen (2)

<noinclude><div class="noprint">{{Navigation Buch | Einführung in SQL: Inhaltsverzeichnis#Abfragen für Fortgeschrittene| Inhaltsverzeichnis: Abfragen für Fortgeschrittene |Einführung in SQL: Ausführliche SELECT-Struktur| Zurück zu: Ausführliche SELECT-Struktur | Einführung in SQL: WHERE-Klausel im Detail|Weiter zu: WHERE-Klausel im Detail }}</div>{{Displaytitle|Funktionen (2)}}<br />{{TOCright}}</noinclude>

Dieses Kapitel behandelt weitere '''Skalarfunktionen''' in Ergänzung zu den grundlegenden [[Einführung in SQL: Funktionen| Funktionen]].

==Allgemeine Hinweise==
Auch hier gelten die dort aufgeführten Hinweise:
* Jedes DBMS bietet eigene Funktionen sowie Varianten.
* Die Klammern werden in den Beschreibungen der Funktionen oft nicht angegeben.
* Die Beispiele werden durch eine verkürzte Schreibweise dargestellt, wobei der Zusatz <tt>"from fiktiv"</tt> als optional gekennzeichnet ist und für Firebird/Interbase durch <tt>"from rdb$database"</tt> bzw. für Oracle durch <tt>"from dual"</tt> zu ersetzen ist.
 SELECT 2 * 3 [from fiktiv];

== Funktionen für Zahlen ==
Auch bei diesen weiteren Funktionen müssen Sie auf den Typ achten.

===POWER und SQRT &ndash; Potenzen und Wurzeln===
Mit '''POWER''' wird eine beliebige Potenz oder Wurzel berechnet:
 POWER( <basis>, <exponent> )
Sowohl für <basis> als auch für <exponent> sind nicht nur ganze positive Zahlen, sondern alle Zahlen zulässig. Mit Dezimalzahlen als <exponent> werden (genau nach mathematischen Regeln) beliebige Wurzeln berechnet; in diesem Fall sind als <basis> negative Zahlen unzulässig. Beispiele:
 SELECT POWER(  5,    3  )  [from fiktiv];   /* Ergebnis:  125,000 */
 SELECT POWER(  5,    2.5)  [from fiktiv];   /* Ergebnis:   55,902 */
 SELECT POWER(  5,    0.5)  [from fiktiv];   /* Ergebnis:    2,236 also Wurzel  aus 5 */
 SELECT POWER(  0.5, -3  )  [from fiktiv];   /* Ergebnis:    8,000 also 3.Potenz zu 2 */
 SELECT POWER( 12.35, 1.5)  [from fiktiv];   /* Ergebnis:   43,401 */
 SELECT POWER(-12.35, 1.5)  [from fiktiv];   /* expression evaluation not supported. */
 SELECT POWER( 12.35,-1.5)  [from fiktiv];   /* Ergebnis:    0,023 */
 SELECT POWER(-12.35,-1.5)  [from fiktiv];   /* expression evaluation not supported */
Mit '''SQRT''' (= Square Root) gibt es für die Quadratwurzel eine kürzere Schreibweise anstelle von POWER(x,0.5):
 SELECT  SQRT(12.25)        [from fiktiv];   /* Ergebnis:    3,500 */

===EXP und LOG &ndash; Exponentialfunktion und Logarithmen===
Mit '''EXP''' wird die Exponentialfunktion im engeren Sinne bezeichnet, also mit der Eulerschen Zahl e als Basis.
 SELECT EXP(1)           [from fiktiv];   /* Ergebnis: 2,71828182845905 */
Mit '''LOG'''(<wert>, <basis>) wird umgekehrt ein Logarithmus bestimmt, mit '''LN''' der natürliche und mit '''LOG10''' der dekadische Logarithmus.
 SELECT LOG(10, EXP(1))  [from fiktiv];   /* Ergebnis: 2,30258509299405 */
 SELECT LOG(10, 10)      [from fiktiv];   /* Ergebnis: 1,000            */
 SELECT LN(10)           [from fiktiv];   /* Ergebnis: 2,30258509299405 */

===Winkelfunktionen===
Die trigonometrischen Funktionen arbeiten mit dem Bogenmaß (nicht mit einer Grad-Angabe).
 SIN    Sinus
 COS    Cosinus
 TAN    Tangens
 COT    Cotangens
 ASIN   Arcussinus   als Umkehrfunktion des Sinus
 ACOS   Arcuscosinus als Umkehrfunktion des Cosinus
 ATAN   Arcustangens als Umkehrfunktion des Tangens

Mit '''DEGREES''' wird ein Bogenmaß in Grad umgerechnet, mit '''RADIANS''' ein Gradmaß in das Bogenmaß.

'''PI''' liefert die entsprechende Zahl und kann auch für die trigonometrischen Funktionen verwendet werden:
 SELECT SIN( PI()/6 )  [from fiktiv];   /* <math>\pi / 6 </math> sind 30°, also Ergebnis 0,5 */

===ABS, RAND, SIGN &ndash; verschiedene Funktionen===
Mit '''ABS''' wird der absolute Betrag der gegebenen Zahl zurückgegeben.

'''SIGN''' liefert als Hinweis auf das Vorzeichen der gegebenen Zahl einen der Werte 1, 0, -1 &ndash; je nachdem, ob die gegebene Zahl positiv, 0 oder negativ ist.
 SELECT SIGN(12.34), SIGN(0), SIGN(-5.67)  [from fiktiv];
 /* Ergebnis:   1         0        -1     */

'''RAND''' liefert eine Zufallszahl im Bereich zwischen 0 und 1 (jeweils einschließlich). Bitte beachten Sie, dass dies keine echten Zufallszahlen sind, sondern Pseudozufallszahlen.

Mit RAND(<vorgabewert>) wird innerhalb einer Sitzung immer dieselbe Zufallszahl erzeugt.

Mit einer Kombination von RAND und FLOOR erhält man eine „zufällige“ Folge ganzer Zahlen:
 FLOOR( <startwert> + ( RAND() * ( <zielwert> - <startwert> + 1 )) )
Beispielsweise liefert die mehrfache Wiederholung der folgenden Abfrage diese Zahlen zwischen 7 und 12:
 SELECT FLOOR(7 + (RAND() * 6)) [from fiktiv];   
 /* Ergebnisse:  10  9  9  7  8  7  9  9  10  12  usw. */

Diese Funktion ist geeignet, um Datensätze mit SELECT in beliebiger Reihenfolge oder einen zufällig ausgewählten Datensatz abzurufen:
 SELECT * FROM <tabelle> ORDER BY RAND();
 SELECT FIRST 1 * FROM <tabelle> ORDER BY RAND();

== Funktionen für Zeichenketten ==
Auch zur Bearbeitung und Prüfung von Zeichenketten (Strings) gibt es weitere Funktionen.

===Verknüpfen von Strings===
Zu den Standardverfahren <code>|| + CONCAT</code> gibt es Ergänzungen.

MySQL bietet mit '''CONCAT_WS''' eine nützliche Erweiterung, bei der zwischen den Teiltexten ein Trennzeichen gesetzt wird.

'''SPACE'''(n) &ndash; für MS-SQL und MySQL &ndash; erzeugt einen String, der aus n Leerzeichen besteht.

'''REPEAT'''( <text>, <n> ) &ndash; für MySQL &ndash; und '''REPLICATE'''( <text>, <n> ) &ndash; für MS-SQL &ndash; erzeugen eine neue Zeichenkette, in der der <text> n-mal wiederholt wird.

Mit '''LPAD''' wird <text1>, sofern erforderlich, auf die gewünschte <länge> gebracht und dabei von links mit <text2> bzw. Leerzeichen aufgefüllt. Mit '''RPAD''' wird von rechts aufgefüllt. ''MS-SQL kennt diese Funktionen nur für Access.''
 LPAD ( <text1>, <länge> [ , <text2> ] )
 RPAD ( <text1>, <länge> [ , <text2> ] )
Wenn der dadurch erzeugte Text zu lang wird, wird zuerst <text2> und notfalls auch <text1> abgeschnitten. Beispiele:
 SELECT LPAD( CAST(12345 AS CHAR(8)), 10, '0')  [from fiktiv];  -- Ergebnis: '0012345   '
Nanu, das sind doch nur 7 statt 10 Ziffern? Achso, zuerst wird mit CAST ein 8 Zeichen langer String erzeugt; dann ist nur noch Platz für 2 Nullen. Also muss es mit einer dieser Varianten gehen:
 SELECT LPAD( CAST(12345 AS CHAR(5)), 10, '0')  [from fiktiv];  -- Ergebnis: '0000012345'
 SELECT LPAD( 12345,   10, '0'  )               [from fiktiv];  -- Ergebnis: '0000012345'
 SELECT LPAD( 'Hilfe', 10, '-_/')               [from fiktiv];  -- Ergebnis: '-_/-_Hilfe'
 SELECT LPAD( 'Ich brauche Hilfe', 10, '-_/')   [from fiktiv];  -- Ergebnis: 'Ich brauch'
 SELECT RPAD( 'Hilfe', 10, '-_/')               [from fiktiv];  -- Ergebnis: 'Hilfe-_/-_'
 SELECT RPAD( 'Ich brauche Hilfe', 10, '-_/')   [from fiktiv];  -- Ergebnis: 'Ich brauch'

===LEFT, RIGHT &ndash; Teile von Zeichenketten===
Als Ergänzung zu SUBSTRING wird mit '''LEFT'''( <text>, <anzahl> ) der linke Teil, also der Anfang eines Textes mit der gewünschten Länge <anzahl> ausgegeben. Ebenso erhält man mit '''RIGHT'''( <text>, <anzahl> ) den rechten Teil, also das Ende eines Textes.
 SELECT LEFT ('Abc Def Ghi', 5)  [from fiktiv];   /* Ergebnis: 'Abc D'  */
 SELECT RIGHT('Abc Def Ghi', 5)  [from fiktiv];   /* Ergebnis: 'f Ghi'  */

===TRIM, LTRIM, RTRIM &ndash; Leerzeichen u.&#8239;a. entfernen===
Mit der '''TRIM'''-Funktion werden bestimmte Zeichen &ndash; meistens Leerzeichen &ndash; am Anfang und/oder am Ende eines Textes entfernt:
 TRIM( [ [ LEADING | TRAILING | BOTH ] [ <zeichen> ] FROM ] <text> )
Die Parameter werden wie folgt benutzt:
* Es soll <zeichen> entfernt werden. Es kann sich um ein einzelnes Zeichen, aber auch um einen Text handeln.
* Wenn dieser Parameter fehlt, wird nach führenden bzw. abschließenden Leerzeichen gesucht.
* Wenn LEADING angegeben ist, werden nur führende Zeichen geprüft, bei TRAILING nachfolgende und bei BOTH sowohl als auch. Wenn nichts davon angegeben wird, wird BOTH angenommen.
Beispiele:
 SELECT TRIM( '   Dies ist ein Text.   ' )  [from fiktiv];    /* Ergebnis: 'Dies ist ein Text.' */
 SELECT TRIM( LEADING  'a' FROM 'abcde'  )  [from fiktiv];    /* Ergebnis: 'bcde'  */
 SELECT TRIM( TRAILING 'e' FROM 'abcde'  )  [from fiktiv];    /* Ergebnis: 'abcd'  */
 SELECT TRIM( 'Test' FROM 'Test als Test')  [from fiktiv];    /* Ergebnis: ' als ' */
'''LTRIM''' (= Left-Trim) und '''RTRIM''' (= Right-Trim) sind Kurzfassungen, bei denen Leerzeichen am Anfang bzw. am Ende entfernt werden; MS-SQL kennt nur diese beiden Kurzfassungen.

===Suchen und Ersetzen===
Mit '''POSITION''' wird der Anfang eines Textes innerhalb eines anderen gesucht.
 POSITION( <text1> IN <text2> )              SQL-Standard
 POSITION( <text1>, <text2> [, <start>] )    nicht bei MySQL
 LOCATE  ( <text1>, <text2> [, <start>] )    bei MySQL
Bei MS-SQL gibt es diese Funktionen nicht; stattdessen kann (mit abweichender Bedeutung) '''PATINDEX''' verwendet werden. Oracle bietet zusätzlich '''INSTR''' (= "in string") an.

Die Bedeutung der Parameter dürfte offensichtlich sein:
* <text2> ist der Text, in dem gesucht werden soll.
* <text1> ist ein Teiltext, der in <text2> gesucht wird.
* Sofern <start> angegeben ist, wird erst ab dieser Position innerhalb <text2> gesucht. Wenn <start> fehlt, wird ab Position 1 gesucht.
* Die Funktion gibt die Startposition von <text1> innerhalb von <text2> an. Wenn <text1> nicht gefunden wird, lautet das Ergebnis 0. 
Beispiele:
 SELECT POSITION( 'ch', 'Ich suche Text' )     [from fiktiv];   /* Ergebnis:  2 */
 SELECT POSITION( 'ch', 'Ich suche Text', 3 )  [from fiktiv];   /* Ergebnis:  7 */
 SELECT POSITION('sch', 'Ich suche Text' )     [from fiktiv];   /* Ergebnis:  0 */

'''REPLACE''' dient zum Ersetzen eines Teiltextes durch einen anderen innerhalb eines Gesamttextes:
 REPLACE( <quelltext>, <suche>, <ersetze> )
Die verschiedenen SQL-Dialekte verhalten sich unterschiedlich, ob NULL-Werte oder leere Zeichenketten zulässig sind.
 SELECT REPLACE('Ich suche Text', 'ch', 'sch') [from fiktiv];   /* Ergebnis: 'Isch susche Text' */
 SELECT REPLACE('Die liebe Seele', 'e', ’’)    [from fiktiv];   /* Ergebnis: 'Di lib Sl' */

'''REVERSE''' passt zwar nicht zu dem, was man in diesem Zusammenhang erwartet; aber auch diese Funktion ändert einen vorhandenen String, und zwar dadurch, dass die Reihenfolge aller Zeichen umgekehrt wird:
 SELECT REVERSE( 'Hilfe' )                     [from fiktiv];   /* Ergebnis: 'efliH' */

== Funktionen für Datums- und Zeitwerte ==
Bitte beachten Sie wiederum die Besonderheiten der Datentypen je nach DBMS.

===Differenzen bei Datum oder Uhrzeit===
Dafür gibt es vorzugsweise die '''DATEDIFF'''-Funktion in unterschiedlicher Version:
 DATEDIFF ( <part>, <start>, <end> )   /* bei MS-SQL oder Firebird */
 DATEDIFF ( <start>, <end> )           /* bei MySQL nur die Anzahl der Tage */
Das Ergebnis ist vom gleichen Typ wie die gesuchte Differenz (also meistens ein ganzzahliger Wert). Als <part> gibt es die gleichen Varianten wie bei den wichtigsten Funktionen:
 YEAR | MONTH | DAY | HOUR | MINUTE | SECOND | MILLISECOND

Beim Vergleich von Start- und Enddatum gilt: 
* Das Ergebnis ist positiv, wenn der zweite Wert größer ist als der erste.
* Das Ergebnis ist 0, wenn beide Werte gleich sind.
* Das Ergebnis ist negativ, wenn der zweite Wert kleiner ist als der erste.
'''Bitte beachten Sie:''' Die DBMS verhalten sich unterschiedlich, ob die Datumsangaben verglichen werden oder der jeweilige Bestandteil. Beispielsweise kann das Ergebnis für beide der folgenden Prüfungen 1 lauten, obwohl die „echte“ Differenz im einen Fall ein Tag, im anderen fast zwei Jahre sind:
 DATEDIFF( YEAR, '31.12.2008', '01.01.2009' )
 DATEDIFF( YEAR, '01.01.2008', '31.12.2009' )
[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Bestimme die Anzahl der Tage seit dem letzten gemeldeten Schadensfall.
 SELECT DATEDIFF(DAY, MAX(Datum), CURRENT_DATE) 
   FROM Schadensfall;         /* Ergebnis: 49 */
[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Bestimme die Anzahl der Minuten seit Tagesbeginn.
 SELECT DATEDIFF(MINUTE, CAST('00:00' AS TIME), CURRENT_TIME) [from fiktiv];   /* Ergebnis: 967 */
Datumsangaben können grundsätzlich auch per Subtraktion verglichen werden, weil „intern“ häufig ein Tag gleich 1 ist. Darauf kann man sich aber nicht immer verlassen; und es ist schwierig, die Bruchteile eines Tages zu berücksichtigen. Beispiel:
 SELECT (CURRENT_DATE - MAX(Datum)) FROM Schadensfall;         /* Ergebnis: 49 */

===Werte für Datum oder Uhrzeit ändern===
Sehr häufig muss aus einem vorhandenen Datum oder Uhrzeit ein neuer Wert berechnet werden. Der SQL-Standard sieht dazu die direkte '''Addition und Subtraktion''' vor:
 <datetime> + <value>
 <datetime> - <value>
 <value>    + <datetime>
<datetime> steht für den gegebenen Wert, <value> für den Zeitraum, der addiert oder subtrahiert werden soll.

[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Aus dem aktuellen Zeitwert '19.09.2009 16:10' wird ein neuer Wert bestimmt, der einen halben Tag in der Zukunft liegt:
 SELECT CURRENT_TIMESTAMP + 0.5   [from fiktiv];       /* Ergebnis: '20.09.2009 04:10:39' */
MySQL akzeptiert nur ganze Zahlen; deshalb ist explizit die Art des Intervalls anzugeben (siehe Dokumentation).

Da das Umrechnen von Zahlen in Datums- und Zeitwerte und umgekehrt für den Anwender umständlich ist, werden viele zusätzliche Funktionen bereitgestellt. Sehr verbreitet ist '''DATEADD''':
 DATEADD( <part>, <value>, <datetime> )                      /* Firebird, MS-SQL */
 DATE_ADD( <datetime> , INTERVAL <value> <part> )            /* MySQL */
[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Welche Versicherungsverträge laufen schon mehr als 10 Jahre?
 SELECT ID, Vertragsnummer, Abschlussdatum  FROM Versicherungsvertrag
  WHERE DATEADD(YEAR, 10, Abschlussdatum) <= CURRENT_DATE;   /* Ergebnis: 18 Datensätze */
Als Ergänzung oder Alternative gibt es weitere Funktionen, beispielsweise DATE_SUB als Subtraktion, ADDDATE oder ADD_MONTHS.

== Funktionen für logische und NULL-Werte ==
Neben den Standardprüfungen vor allem bei der WHERE-Klausel (siehe nächstes Kapitel) und den Operatoren AND, OR, NOT gibt es weitere Prüfungen.

===COALESCE &ndash; Suche Wert ungleich NULL===
Die '''COALESCE'''-Funktion sucht in einer Liste von Werten (bzw. Ausdrücken) den ersten, der nicht NULL ist. Wenn alle Werte NULL sind, ist der Rückgabewert (zwangsläufig) NULL.

[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Nenne zu jedem Mitarbeiter eine Kontaktmöglichkeit: vorzugsweise Mobilnummer, dann Telefonnummer, dann Email-Adresse.
 SELECT Name, Vorname, COALESCE(Mobil, Telefon, Email) AS Kontakt FROM Mitarbeiter;
Das Ergebnis überrascht zunächst, denn einige Mitarbeiter hätten danach keine Kontaktmöglichkeit. Bei der Abfrage nach IS NULL zur WHERE-Klausel wird aber erläutert, dass eine leere Zeichenkette ungleich NULL ist; bei diesen Mitarbeitern wird also ein leerer Eintrag, aber nicht "nichts" angezeigt.

: Bitte nehmen Sie diesen Hinweis als Empfehlung, lieber NULL zu speichern als den leeren String ’’.

===NULLIF===
Die Funktion '''NULLIF''' vergleicht zwei Werte und liefert NULL zurück, wenn beide Werte gleich sind; andernfalls liefert der erste Wert das Ergebnis.

[[Image:Gtk-media-play-ltr.svg|left|20px|Aufgabe]] Suche alle Versicherungsnehmer, die im Alter von 18 Jahren ihren Führerschein gemacht haben.
{{Regal:Programmierung: Vorlage:SingleCode ||lang=sql
|code=
select Name, Vorname, EXTRACT(YEAR from Geburtsdatum) + 18 as Jahr
  from Versicherungsnehmer
 where Geburtsdatum is not null
   and NULLIF( EXTRACT(YEAR from Geburtsdatum) + 18, EXTRACT(YEAR from Fuehrerschein) ) is null;
|output=
NAME          VORNAME    JAHR
------------  ---------  ----
Liebermann    Maria      1988
}}

<u>Hinweis:</u> Sowohl COALESCE als auch NULLIF sind Kurzfassungen für spezielle Fallunterscheidungen mit CASE WHEN, in denen zusätzlich IS NULL eingebunden wird &ndash; siehe dazu [[Einführung in SQL: Nützliche Erweiterungen| Nützliche Erweiterungen]].

== Verschiedene Funktionen ==
Auch wenn die Funktionen in diesem Abschnitt beim SQL-Standard vorgesehen sind, sind sie nicht immer vorhanden. Wir verzichten deshalb wiederum auf nähere Erläuterungen und verweisen auf die jeweilige Dokumentation.

===ROW_NUMBER &ndash; Zeilen nummerieren===
Mit der '''ROW_NUMBER'''-Funktion werden die Zeilen im Ergebnis einer Abfrage nach der betreffenden Sortierung durchnummeriert. MS-SQL verwendet die folgende Syntax:
 ROW_NUMBER()  OVER ( [ <partition_by_clause> ] <order_by_clause> )

===CURRENT_USER &ndash; der aktuelle Benutzer===
Mit '''CURRENT_USER''' (in der Regel ohne Klammer) wird der aktuelle Benutzername abgefragt. Dieser kann auch per DEFAULT bei Neuaufnahmen automatisch in einer Spalte einer Tabelle eingetragen werden.
 SELECT CURRENT_USER   [from fiktiv];    /* Ergebnis: SYSDBA */

==Zusammenfassung==
In diesem Kapitel lernten Sie weitere eingebaute Funktionen kennen:
* Für Zahlen gibt es viele mathematische Funktionen wie Potenzen, Wurzeln, Exponential- oder Winkelfunktionen.
* Zeichenketten können auf vielfache Weise verknüpft oder zum Erstellen neuer Strings bearbeitet werden.
* Datums- und Zeitwerte können im Detail verglichen und verrechnet werden.

==Übungen==
{{Übung4|1|Funktionen für Zahlen}}
Geben Sie mit SQL-Funktionen die Formeln für die folgenden Aufgaben an. ''Es geht nur um die Formeln, nicht um einen passenden SELECT-Befehl. Bei den Aufgaben 1 bis 3 sind jeweils zwei Lösungen möglich.''
# Gegeben seien zwei Zahlen a, b. Berechnen Sie a² + 2ab + b².
# Berechnen Sie die Quadratwurzel von 216,09.
# Ein Auftragsverwaltungsprogramm speichert in der Spalte ''Bestellung'' die Bestellwerte und in der Spalte ''Zahlung'' die Einzahlungen. Bestimmen Sie mit einem einzigen Ausdruck die Prüfung, ob der Kunde Guthaben oder Schulden (Zahlungsverpflichtung) hat.
# Bestimmen Sie den Betrag von Aufgabe 3 (unabhängig davon, ob es sich um Guthaben oder Schulden handelt).

{{Übung4|2|Zufallszahlen}}
Bestimmen Sie mit SQL-Funktionen die folgenden Zufallszahlen.
# eine beliebige Zufallszahl zwischen 0 und 1
# eine beliebige Zufallszahl zwischen 0 und 4
# eine beliebige Zufallszahl zwischen 1 und 5
# eine Zufallszahl als ganze Zahl zwischen 1 und 5
# eine Zufallszahl als ganze Zahl zwischen 1 und 26
# einen zufällig ausgewählten Buchstaben aus der Liste ''letters'' der Großbuchstaben 'ABC...XYZ'

{{Übung4|3|Zeichenketten bearbeiten}}
Aus der Tabelle ''Mitarbeiter'' sollen die Werte ''ID'' und ''Abteilung_ID'' zusammengesetzt werden. Dabei soll die ''ID'' immer 4-stellig und die ''Abteilung_ID'' immer 2-stellig geschrieben werden, bei Bedarf sollen die Teile mit '0' aufgefüllt werden.

{{Übung4|4|Zeichenketten bearbeiten}}
Geben Sie für die Tabelle ''Mitarbeiter'' eine der vorhandenen Telefonnummern an &ndash; vorrangig die Mobilnummer; berücksichtigen Sie dabei auch, ob überhaupt eine Nummer gespeichert ist.

{{Übung4|5|Zeichenketten bearbeiten}}
Zeigen Sie für die Spalte ''Kennzeichen'' der Tabelle ''Fahrzeug'' den zugehörigen Kreis an.

{{Übung4|6|Zeichenketten bearbeiten}}
In der ''Beschreibung'' für den ''Schadensfall'' mit der ID 6 ist das Kennzeichen 'RE-LM 903' durch 'RE-LM 902' zu berichtigen.

{{Übung4|7|Datum und Zeit bearbeiten}}
Die folgenden Teilaufgaben werden benutzt, um im Kapitel [[Einführung in SQL: Testdaten erzeugen| Testdaten erzeugen]] Geburtsdatum, Führerschein-Erwerb oder Abschluss des Versicherungsvertrags zufällig zu bestimmen.
# Bestimmen Sie aus dem ''Geburtsdatum'' das Datum des 18.&#8239;Geburtstags.
# Bestimmen Sie (ausgehend vom 01.01.1950) Datumsangaben bis zum 31.12.1990, bei denen der Monat und das Jahr per Zufallsfunktion bestimmt werden.
# Bestimmen Sie ebenso Datumsangaben, bei denen auch der Tag zufällig festgelegt wird und immer ein gültiges Datum erzeugt wird.
# Prüfen Sie, ob ein neuer Kunde seinen Führerschein bei Vertragsabschluss bereits drei Jahre besitzt. Sie können annehmen, dass sowohl ''Fuehrerschein'' als auch ''Abschlussdatum'' in derselben Tabelle liegen; Schaltjahre können ignoriert werden.
 
{{Überschriftensimulation 3|Lösungen}}
{{Übung4 Lösung|1|Funktionen für Zahlen}}
# a. <code>POWER(a, 2) + 2*a*b + POWER(b, 2)</code><br />b. <code>POWER(a + b, 2)</code> ''als einfachste Binomische Formel''
# a. <code>SQRT(216.09)</code><br />b. <code>POWER(216.09, 0.5)</code>
# a. <code>IF ( SUM(Bestellung) > SUM(Zahlung) )</code><br />b. <code>IF( SIGN( SUM(Bestellung) &ndash; SUM(Zahlung) ) = 1)</code>
# <code>ABS( SUM(Bestellung) &ndash; SUM(Zahlung) )</code>

{{Übung4 Lösung|2|Zufallszahlen}}
<code>
# RAND()
# RAND() * 4
# 1 + RAND() * 4
# FLOOR( 1 + RAND() *  4 )
# FLOOR( 1 + RAND() * 25 )
# SUBSTRING( letters FROM FLOOR( 1 + RAND() * 25 ) FOR 1 )
</code>

{{Übung4 Lösung|3|Zeichenketten bearbeiten}}
 SELECT LPAD( ID, 4, '0') + LPAD( Abteilung_ID, 2, '0') FROM Mitarbeiter;

{{Übung4 Lösung|4|Zeichenketten bearbeiten}}
 SELECT COALESCE( NULLIF(Mobil, ’’), Telefon) AS Tel FROM Mitarbeiter;
Erklärung: Wenn ''Mobil'' einen Wert enthält, kommt bei NULLIF dieser Wert heraus; andernfalls wird immer NULL geliefert &ndash; entweder als Feldinhalt oder als Ergebnis des Vergleichs mit der leeren Zeichenkette.

{{Übung4 Lösung|5|Zeichenketten bearbeiten}}
 SELECT SUBSTRING( Kennzeichen FROM 1 FOR Position('-', Kennzeichen) - 1) FROM Fahrzeug;

{{Übung4 Lösung|6|Zeichenketten bearbeiten}}
 UPDATE Schadensfall 
    SET Beschreibung = REPLACE( Beschreibung, 'RE-LM 903', 'RE-LM 902' )
  WHERE ID = 6;

{{Übung4 Lösung|7|Datum und Zeit bearbeiten}}
Die Teilaufgaben liefern diese Einzellösungen.
# <code>DATEADD( YEAR, 18, Geburtsdatum )</code>
# <code>DATEADD( MONTH, FLOOR(RAND()*11), DATEADD( YEAR, FLOOR(RAND()*40), '1950-01-01'))</code><br />Es handelt sich um eine verschachtelte Funktion: Zuerst wird das Jahr neu bestimmt, es wird maximal ein Wert von 40 addiert. Zu diesem Ergebnis wird der Monat neu bestimmt, es wird maximal 11 addiert. In manchen Fällen sind einzelne Angaben per CAST genauer zu definieren.
# <code>DATEADD( DAY, FLOOR(RAND()*(41*365+10)), '1950-01-01')</code><br />Es handelt sich um 41 Jahre zu je 365 Tagen, dazu 10 Schalttage.
# <code>SELECT Fuehrerschein, Abschlussdatum FROM (Vertrag/Kunde)<br />WHERE DATEDIFF( DAY, Fuehrerschein, Abschlussdatum) < 3*365</code><br />Hinweis: <code>DATEDIFF(YEAR...)</code> ist nicht unbedingt geeignet, weil ein DBMS nicht die Termine, sondern die Jahreszahlen vergleichen könnte. 

== Siehe auch ==
Bei Wikipedia gibt es fachliche Erläuterungen:
* [[w:Potenz (Mathematik)|Potenzen]]
* [[w:Exponentialfunktion|Exponentialfunktion]]
* [[w:Trigonometrische Funktionen|Trigonometrische Funktionen]] und [[w:Bogenmaß|Bogenmaß]]
* [[w:Betragsfunktion|Betragsfunktion]] &ndash; der absolute Betrag
* [[w:Zufallszahl|Zufallszahl]] gibt auch Hinweise zu „Pseudozufallszahlen“.
* [[w:Binomische Formel|Binomische Formeln]]

<noinclude><br /><div class="noprint">{{Navigation Buch | Einführung in SQL: Inhaltsverzeichnis#Abfragen für Fortgeschrittene| Inhaltsverzeichnis: Abfragen für Fortgeschrittene |Einführung in SQL: Ausführliche SELECT-Struktur| Zurück zu: Ausführliche SELECT-Struktur | Einführung in SQL: WHERE-Klausel im Detail|Weiter zu: WHERE-Klausel im Detail }}</div></noinclude>