Skip navigation links
12.5 Datums- und Zeitfunktionen »
Section Navigation      [Toggle]

12.4.2. Mathematische Funktionen

Alle mathematischen Funktionen geben im Fehlerfall NULL zurück.

  • ABS(X)

    Gibt den absoluten Wert von X zurück. 

    mysql> SELECT ABS(2);
        -> 2
mysql> SELECT ABS(-32);
        -> 32

    Diese Funktion kann sicher mit BIGINT-Werten eingesetzt werden.

  • ACOS(X)

    Gibt den Arkuskosinus von X zurück, d. h. den Wert, dessen Kosinus X ist. Gibt NULL zurück, wenn X nicht im Bereich zwischen -1 und 1 liegt. 

    mysql> SELECT ACOS(1);
        -> 0
mysql> SELECT ACOS(1.0001);
        -> NULL
mysql> SELECT ACOS(0);
        -> 1.5707963267949

  • ASIN(X)

    Gibt den Arkussinus von X zurück, d. h. den Wert, dessen Sinus X ist. Gibt NULL zurück, wenn X nicht im Bereich zwischen -1 und 1 liegt. 

    mysql> SELECT ASIN(0.2);
        -> 0.20135792079033
mysql> SELECT ASIN('foo');

+-------------+
| ASIN('foo') |
+-------------+
|           0 |
+-------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+-----------------------------------------+
| Level   | Code | Message                                 |
+---------+------+-----------------------------------------+
| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |
+---------+------+-----------------------------------------+

  • ATAN(X)

    Gibt den Arkustangens von X zurück, d. h. den Wert, dessen Tangens X ist. 

    mysql> SELECT ATAN(2);
        -> 1.1071487177941
mysql> SELECT ATAN(-2);
        -> -1.1071487177941

  • ATAN(Y,X), ATAN2(Y,X)

    Gibt den Arkustangens der beiden Variablen X und Y zurück. Dies ähnelt der Berechnung des Arkustangens von Y / X; der einzige Unterschied besteht darin, dass die Vorzeichen beider Argumente zur Bestimmung des Quadranten des Ergebnisses verwendet werden. 

    mysql> SELECT ATAN(-2,2);
        -> -0.78539816339745
mysql> SELECT ATAN2(PI(),0);
        -> 1.5707963267949

  • CEILING(X), CEIL(X)

    Gibt den kleinsten Integer-Wert zurück, der nicht kleiner als X ist. 

    mysql> SELECT CEILING(1.23);
        -> 2
mysql> SELECT CEIL(-1.23);
        -> -1

    Diese beiden Funktionen sind synonym. Beachten Sie, dass der Rückgabewert in ein BIGINT konvertiert wird.

  • COS(X)

    Gibt den Kosinus von X zurück, wobei X in rad angegeben wird. 

    mysql> SELECT COS(PI());
        -> -1

  • COT(X)

    Gibt den Kotangens von X zurück. 

    mysql> SELECT COT(12);
        -> -1.5726734063977
mysql> SELECT COT(0);
        -> NULL

  • CRC32(expr)

    Berechnet einen Prüfsummenwert (CRC, Cyclic Redundancy Check) und gibt einen vorzeichenlosen 32-Bit-Wert zurück. Das Ergebnis ist NULL, wenn das Argument NULL ist. Als Argument wird ein String erwartet, der dann (sofern möglich) so behandelt wird, als wäre er keiner. 

    mysql> SELECT CRC32('MySQL');
        -> 3259397556
mysql> SELECT CRC32('mysql');
        -> 2501908538

  • DEGREES(X)

    Gibt das Argument X umgewandelt von rad in Grad zurück. 

    mysql> SELECT DEGREES(PI());
        -> 180
mysql> SELECT DEGREES(PI() / 2);
        -> 90

  • EXP(X)

    Gibt den Wert von e (Basis natürlicher Logarithmen) zur Potenz X zurück. 

    mysql> SELECT EXP(2);
        -> 7.3890560989307
mysql> SELECT EXP(-2);
        -> 0.13533528323661
mysql> SELECT EXP(0);
        -> 1

  • FLOOR(X)

    Gibt den größten Integer-Wert zurück, der nicht größer als X ist. 

    mysql> SELECT FLOOR(1.23);
        -> 1
mysql> SELECT FLOOR(-1.23);
        -> -2

    Beachten Sie, dass der Rückgabewert in ein BIGINT konvertiert wird.

  • FORMAT(X,D)

    Formatiert die Zahl X in ein Format wie '#,###,###.##', gerundet auf D Dezimalstellen, und gibt das Ergebnis als String zurück. Detaillierte Informationen finden Sie in Abschnitt 12.3, „String-Funktionen“.

  • LN(X)

    Gibt den natürlichen Logarithmus von X zurück, d. h. den Logarithmus von X zur Basis e. 

    mysql> SELECT LN(2);
        -> 0.69314718055995
mysql> SELECT LN(-2);
        -> NULL

    Diese Funktion ist synonym zu LOG(X).

  • LOG(X), LOG(B,X)

    Sofern mit einem Parameter aufgerufen, gibt diese Funktion den natürlichen Logarithmus von X zurück. 

    mysql> SELECT LOG(2);
        -> 0.69314718055995
mysql> SELECT LOG(-2);
        -> NULL

    Wenn der Aufruf mit zwei Parametern erfolgt, gibt die Funktion den Logarithmus von X zur (beliebig anzugebenden) Basis B zurück. 

    mysql> SELECT LOG(2,65536);
        -> 16
mysql> SELECT LOG(10,100);
        -> 2

    LOG(B,X) ist äquivalent mit LOG(X) / LOG(B).

  • LOG2(X)

    Gibt den Logarithmus von X zur Basis 2 zurück. 

    mysql> SELECT LOG2(65536);
        -> 16
mysql> SELECT LOG2(-100);
        -> NULL

    LOG2() ist praktisch, um zu ermitteln, wie viele Bits eine Zahl zur Speicherung benötigt. Die Funktion ist äquivalent zu dem Ausdruck LOG(X) / LOG(2).

  • LOG10(X)

    Gibt den Logarithmus von X zur Basis 10 zurück. 

    mysql> SELECT LOG10(2);
        -> 0.30102999566398
mysql> SELECT LOG10(100);
        -> 2
mysql> SELECT LOG10(-100);
        -> NULL

    LOG10(X) ist äquivalent mit LOG(10,X).

  • MOD(N,M), N % M, N MOD M

    Modulooperation. Gibt den Rest von N geteilt durch M zurück. 

    mysql> SELECT MOD(234, 10);
        -> 4
mysql> SELECT 253 % 7;
        -> 1
mysql> SELECT MOD(29,9);
        -> 2
mysql> SELECT 29 MOD 9;
        -> 2

    Diese Funktion kann mit BIGINT-Werten sicher eingesetzt werden.

    MOD() funktioniert auch bei Werten mit Nachkommastellen und gibt den exakten Rest nach der Division zurück: 

    mysql> SELECT MOD(34.5,3);
        -> 1.5

  • PI()

    Gibt den Wert von π (Pi) zurück. Standardmäßig werden sieben Dezimalstellen angezeigt, MySQL verwendet intern jedoch den vollständigen Wert doppelter Genauigkeit. 

    mysql> SELECT PI();
        -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
        -> 3.141592653589793116

  • POW(X,Y), POWER(X,Y)

    Gibt den Wert von X potenziert zu Y an. 

    mysql> SELECT POW(2,2);
        -> 4
mysql> SELECT POW(2,-2);
        -> 0.25

  • RADIANS(X)

    Gibt das Argument X umgewandelt von Grad in rad zurück. (Beachten Sie, dass π rad 180 Grad entspricht.) 

    mysql> SELECT RADIANS(90);
        -> 1.5707963267949

  • RAND(), RAND(N)

    Gibt einen zufälligen Fließkommawert v zwischen 0 und 1 inklusive (d. h. im Bereich 0 <= v <= 1.0) zurück. Wenn ein Integer-Argument N angegeben ist, wird es als Ausgangswert verwendet, der eine wiederholbare Sequenz erzeugt. 

    mysql> SELECT RAND();
        -> 0.9233482386203
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND(20);
        -> 0.15888261251047
mysql> SELECT RAND();
        -> 0.63553050033332
mysql> SELECT RAND();
        -> 0.70100469486881
mysql> SELECT RAND(20);
        -> 0.15888261251047

    Um einen zufälligen Integer R im Bereich i <= R <= j zu erhalten, verwenden Sie den Ausdruck FLOOR(i+ RAND() * (j– i+ 1)). Um beispielsweise einen ganzzahligen Zufallswert im Bereich zwischen 7 und 12 (einschließlich) zu erhalten, können Sie die folgende Anweisung verwenden: 

    SELECT FLOOR(7 + (RAND() * 6));

    Sie können eine Spalte mit RAND()-Werten nicht in einer ORDER BY-Klausel angeben, weil ORDER BY die Spalte mehrfach auswerten würde. Allerdings können Sie Datensätze in zufälliger Folge abrufen. Das funktioniert wie folgt: 

    mysql> SELECT * FROM tbl_name ORDER BY RAND();

    ORDER BY RAND() in Kombination mit LIMIT ist nützlich zur Auswahl eines Zufallswerts aus einer Datensatzmenge: 

    mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d -> ORDER BY RAND() LIMIT 1000;

    Beachten Sie, dass RAND() in einer WHERE-Klausel jedes Mal, wenn WHERE ausgeführt wird, neu ausgewertet wird.

    RAND() ist nicht als perfekter Zufallsgenerator gedacht, sondern stellt eine gute Möglichkeit da, ad hoc Zufallszahlen zu erzeugen, die innerhalb derselben MySQL-Version plattformübergreifend funktioniert.

  • ROUND(X), ROUND(X,D)

    Gibt das Argument X gerundet auf den nächstgelegenen Integer zurück. Bei zwei übergebenen Argumenten wird X gerundet auf D Dezimalstellen zurückgegeben. D kann negativ sein; in diesem Fall werden D Stellen links des Dezimalpunkts des Werts X null. 

    mysql> SELECT ROUND(-1.23);
        -> -1
mysql> SELECT ROUND(-1.58);
        -> -2
mysql> SELECT ROUND(1.58);
        -> 2
mysql> SELECT ROUND(1.298, 1);
        -> 1.3
mysql> SELECT ROUND(1.298, 0);
        -> 1
mysql> SELECT ROUND(23.298, -1);
        -> 20

    Der Rückgabetyp ist derselbe wie der des ersten Arguments (vorausgesetzt, dies ist ein Integer, eine Fließkommazahl oder eine Dezimalzahl). Das bedeutet, dass bei einem Integer-Argument das Ergebnis ein Integer ist (der keine Dezimalstellen aufweist).

    ROUND() verwendet für genaue Zahlen die Precision-Math-Bibliothek, wenn das erste Argument ein Dezimalwert ist:

    • Bei genauen Zahlen verwendet ROUND() die gängigen Rundungsregeln: Ein Wert mit einem Wert von 5 oder größer nach dem Komma wird auf den nächsten Integer aufgerundet bzw. (bei negativen Werten) abgerundet. (Anders gesagt: Die Rundung erfolgt von Null weg.) Ein Wert mit einem Wert von weniger als 5 nach dem Komma wird auf den nächsten Integer abgerundet bzw. (bei negativen Werten) aufgerundet.

    • Bei Näherungswerten hängt das Ergebnis von der C-Bibliothek ab. Auf vielen Systemen bedeutet dies, dass ROUND() die Regel „auf nächste gerade Zahl aufrunden“ einsetzt: Ein Wert mit Nachkommastellen wird auf den nächsten geraden Integer gerundet.

    Das folgende Beispiel zeigt, wie die Rundung sich bei exakten und bei Näherungswerten voneinander unterscheidet: 

    mysql> SELECT ROUND(2.5), ROUND(25E-1);
+------------+--------------+
| ROUND(2.5) | ROUND(25E-1) |
+------------+--------------+
| 3          |            2 |
+------------+--------------+

    Weitere Informationen finden Sie unter Kapitel 23, Präzisionsberechnungen.

  • SIGN(X)

    Gibt das Vorzeichen des Arguments als -1, 0 oder 1 abhängig davon zurück, ob X negativ, null oder positiv ist. 

    mysql> SELECT SIGN(-32);
        -> -1
mysql> SELECT SIGN(0);
        -> 0
mysql> SELECT SIGN(234);
        -> 1

  • SIN(X)

    Gibt den Sinus von X zurück, wobei X in rad angegeben wird. 

    mysql> SELECT SIN(PI());
        -> 1.2246063538224e-16
mysql> SELECT ROUND(SIN(PI()));
        -> 0

  • SQRT(X)

    Gibt die Quadratwurzel einer nichtnegativen Zahl X zurück. 

    mysql> SELECT SQRT(4);
        -> 2
mysql> SELECT SQRT(20);
        -> 4.4721359549996
mysql> SELECT SQRT(-16);
        -> NULL

  • TAN(X)

    Gibt den Tangens von X zurück, wobei X in rad angegeben wird. 

    mysql> SELECT TAN(PI());
        -> -1.2246063538224e-16
mysql> SELECT TAN(PI()+1);
        -> 1.5574077246549

  • TRUNCATE(X,D)

    Gibt die Zahl X auf D Dezimalstellen beschnitten zurück. Wenn D 0 ist, hat das Ergebnis keinen Dezimalpunkt und keine Nachkommastellen. D kann auch negativ sein. In diesem Fall werden D Stellen links vom Dezimalpunkt des Werts X null. 

    mysql> SELECT TRUNCATE(1.223,1);
        -> 1.2
mysql> SELECT TRUNCATE(1.999,1);
        -> 1.9
mysql> SELECT TRUNCATE(1.999,0);
        -> 1
mysql> SELECT TRUNCATE(-1.999,1);
        -> -1.9
mysql> SELECT TRUNCATE(122,-2);
       -> 100
mysql> SELECT TRUNCATE(10.28*100,0);
       -> 1028

    Alle Zahlen werden nach null hin gerundet.

Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.