Wenn eines der Argumente (oder beide) NULL ist, dann ist das Vergleichsergebnis NULL. Eine Ausnahme ist der NULL-sichere Gleichheitsoperator <=>. Bei NULL <=> NULL ist das Ergebnis wahr.

Wenn beide Argumente in einer Vergleichsoperation Strings sind, werden sie als Strings verglichen.

Sind beide Argumente Integers, dann werden sie als Integers verglichen.

Hexadezimalwerte werden als binäre Strings behandelt, wenn sie nicht mit einer Zahl verglichen werden.

Wenn eines der Argumente eine TIMESTAMP- oder DATETIME-Spalte und das andere Argument eine Konstante ist, dann wird die Konstante vor Durchführung des Vergleichs in einen Zeitstempel umgewandelt. Dies erhöht die ODBC-Kompatibilität. Beachten Sie jedoch, dass dies nicht bei Argumenten für IN() gemacht wird! Um ganz sicher zu sein, sollten Sie bei Vergleichen immer vollständige Strings für Datum und/oder Uhrzeit verwenden.

In allen anderen Fällen werden die Argumente als Fließkommazahlen (reale Zahlen) verglichen.

=

Gleich:

mysql> SELECT 1 = 0;
        -> 0
mysql> SELECT '0' = 0;
        -> 1
mysql> SELECT '0.0' = 0;
        -> 1
mysql> SELECT '0.01' = 0;
        -> 0
mysql> SELECT '.01' = 0.01;
        -> 1

<=>

NULL-sicheres Gleich. Dieser Operator führt ebenso wie = eine Vergleichsoperation durch, gibt aber 1 statt NULL zurück, wenn beide Operanden NULL sind, und 0 statt NULL, wenn einer der Operanden NULL ist.

mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
        -> 1, 1, 0
mysql> SELECT 1 = 1, NULL = NULL, 1 = NULL;
        -> 1, NULL, NULL

<>, !=

Ungleich:

mysql> SELECT '.01' <> '0.01';
        -> 1
mysql> SELECT .01 <> '0.01';
        -> 0
mysql> SELECT 'zapp' <> 'zappp';
        -> 1

<=

Kleiner oder gleich:

mysql> SELECT 0.1 <= 2;
        -> 1

<

Kleiner als:

mysql> SELECT 2 < 2;
        -> 0

>=

Größer oder gleich:

mysql> SELECT 2 >= 2;
        -> 1

>

Größer als:

mysql> SELECT 2 > 2;
        -> 0

IS boolean_value, IS NOT boolean_value

Vergleicht einen Wert mit einem booleschen Wert, wobei boolean_value TRUE, FALSE oder UNKNOWN sein kann.

mysql> SELECT 1 IS TRUE, 0 IS FALSE, NULL IS UNKNOWN;
        -> 1, 1, 1
mysql> SELECT 1 IS NOT UNKNOWN, 0 IS NOT UNKNOWN, NULL IS NOT UNKNOWN;
        -> 1, 1, 0

IS NULL, IS NOT NULL

Prüft, ob ein Wert NULL ist oder nicht.

mysql> SELECT 1 IS NULL, 0 IS NULL, NULL IS NULL;
        -> 0, 0, 1
mysql> SELECT 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
        -> 1, 1, 0

Zum Zwecke der Kompatibilität mit ODBC-Programmen unterstützt MySQL die folgenden Zusatzfunktionen bei der Verwendung von IS NULL:

expr BETWEEN min AND max

Wenn expr größer oder gleich min und expr kleiner oder gleich max ist, gibt BETWEEN 1 zurück, andernfalls 0. Dies ist äquivalent zu dem Ausdruck (min<= expr AND expr<= max), sofern alle Argumente vom selben Typ sind. Andernfalls findet die Typenkonvertierung entsprechend den in Abschnitt 12.1.2, „Typumwandlung bei der Auswertung von Ausdrücken“, beschriebenen Regeln statt, wird aber auf alle drei Argumente angewendet.

mysql> SELECT 1 BETWEEN 2 AND 3;
        -> 0
mysql> SELECT 'b' BETWEEN 'a' AND 'c';
        -> 1
mysql> SELECT 2 BETWEEN 2 AND '3';
        -> 1
mysql> SELECT 2 BETWEEN 2 AND 'x-3';
        -> 0

expr NOT BETWEEN min AND max

Dies ist das Gleiche wie NOT (expr BETWEEN min AND max).

COALESCE(value,...)

Gibt den ersten Nicht-NULL-Wert in der Liste oder aber NULL zurück, sofern keine Nicht-NULL-Werte vorhanden sind.

mysql> SELECT COALESCE(NULL,1);
        -> 1
mysql> SELECT COALESCE(NULL,NULL,NULL);
        -> NULL

GREATEST(value1,value2,...)

Gibt von zwei oder mehr Argumenten das größte (d. h. das mit dem höchsten Wert) zurück. Die Argumente werden nach denselben Regeln wie bei LEAST() verglichen.

mysql> SELECT GREATEST(2,0);
        -> 2
mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
        -> 767.0
mysql> SELECT GREATEST('B','A','C');
        -> 'C'

GREATEST() gibt NULL zurück, sofern ein Argument NULL ist.

expr IN (value,...)

Gibt 1 zurück, wenn expr gleich einem der Werte in der IN-Liste ist, andernfalls wird 0 zurückgegeben. Wenn alle Werte Konstanten sind, werden sie entsprechend dem Typ von expr ausgewertet und sortiert. Nachfolgend erfolgt die Suche nach dem Element unter Verwendung einer binären Suche. Das heißt auch, dass IN sehr schnell ist, wenn die IN-Werteliste ausschließlich aus Konstanten besteht. Andernfalls findet die Typenkonvertierung entsprechend den in Abschnitt 12.1.2, „Typumwandlung bei der Auswertung von Ausdrücken“, beschriebenen Regeln statt, wird aber auf alle Argumente angewendet.

mysql> SELECT 2 IN (0,3,5,'wefwf');
        -> 0
mysql> SELECT 'wefwf' IN (0,3,5,'wefwf');
        -> 1

Die Anzahl der Werte in der IN-Liste wird nur durch den Wert von max_allowed_packet beschränkt.

Um mit dem SQL-Standard konform zu gehen, gibt IN NULL nicht nur dann zurück, wenn der Ausdruck auf der linken Seite NULL ist, sondern auch dann, wenn keine Übereinstimmung in der Liste gefunden wird und einer der Ausdrücke in der Liste NULL ist.

Die IN()-Syntax kann auch zum Schreiben verschiedener Arten von Unterabfragen verwendet werden. Siehe auch Abschnitt 13.2.8.3, „Unterabfragen mit ANY, IN und SOME“.

expr NOT IN (value,...)

Dies ist das Gleiche wie NOT (expr IN (value,...)).

ISNULL(expr)

Wenn expr NULL ist, gibt ISNULL() 1 zurück, andernfalls 0.

mysql> SELECT ISNULL(1+1);
        -> 0
mysql> SELECT ISNULL(1/0);
        -> 1

ISNULL() kann anstelle von = verwendet werden, um zu überprüfen, ob ein Wert NULL ist. (Der Vergleich eines Werts mit NULL unter Verwendung von = gibt immer FALSE aus.)

Die Funktion ISNULL() weist einige spezielle Eigenschaften des Vergleichsoperators IS NULL auf. Siehe auch die Beschreibung zu IS NULL.

INTERVAL(N,N1,N2,N3,...)

Gibt 0 zurück, wenn N < N1 ist, 1, wenn N < N2 usw., oder -1, wenn N NULL ist. Alle Argumente werden als Integers behandelt. Es ist erforderlich, dass N1 < N2 < N3 < ... < Nn ist, damit diese Funktion einwandfrei arbeitet. Das liegt daran, dass eine binäre (und damit sehr schnelle) Suche verwendet wird.

mysql> SELECT INTERVAL(23, 1, 15, 17, 30, 44, 200);
        -> 3
mysql> SELECT INTERVAL(10, 1, 10, 100, 1000);
        -> 2
mysql> SELECT INTERVAL(22, 23, 30, 44, 200);
        -> 0

LEAST(value1,value2,...)

Gibt von zwei oder mehr Argumenten das kleinste (d. h. das mit dem niedrigsten Wert) zurück. Die Argumente werden unter Anwendung der folgenden Regeln verglichen:

LEAST() gibt NULL zurück, sofern ein Argument NULL ist.

mysql> SELECT LEAST(2,0);
        -> 0
mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
        -> 3.0
mysql> SELECT LEAST('B','A','C');
        -> 'A'

Beachten Sie, dass die oben beschriebenen Konvertierungsregeln in einigen Grenzfällen fragwürdige Ergebnisse erzeugen können:

mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);
        -> -9223372036854775808

Dies passiert, weil MySQL 9223372036854775808.0 in einem Integer-Kontext liest. Das Integer-Format ist aber nicht geeignet, den Wert darzustellen, d. h., er wird in einen vorzeichenbehafteten Integer umgewandelt.

NOT, !

Logisches NOT (NICHT). Wird zu 1, wenn der Operand 0 ist, und zu 0, wenn der Operand nicht null ist. NOT NULL gibt NULL zurück.

mysql> SELECT NOT 10;
        -> 0
mysql> SELECT NOT 0;
        -> 1
mysql> SELECT NOT NULL;
        -> NULL
mysql> SELECT ! (1+1);
        -> 0
mysql> SELECT ! 1+1;
        -> 1

Das letzte Beispiel erzeugt 1, weil der Ausdruck auf die gleiche Weise ausgewertet wird wie (!1)+1.

AND, &&

Logisches AND (UND). Gibt 1 zurück, wenn alle Operanden weder null noch NULL sind; wenn ein oder mehr Operanden 0 sind, wird 0 zurückgegeben, andernfalls NULL.

mysql> SELECT 1 && 1;
        -> 1
mysql> SELECT 1 && 0;
        -> 0
mysql> SELECT 1 && NULL;
        -> NULL
mysql> SELECT 0 && NULL;
        -> 0
mysql> SELECT NULL && 0;
        -> 0

OR, ||

Logisches OR (ODER). Wenn beide Operanten nicht NULL sind, ist das Ergebnis 1, sofern ein beliebiger Operand nicht null ist, andernfalls 0. Bei einem NULL-Operanden ist das Ergebnis 1, wenn der andere Operand nicht null ist, andernfalls ist es NULL. Sind beide Operanden NULL, dann ist das Ergebnis NULL.

mysql> SELECT 1 || 1;
        -> 1
mysql> SELECT 1 || 0;
        -> 1
mysql> SELECT 0 || 0;
        -> 0
mysql> SELECT 0 || NULL;
        -> NULL
mysql> SELECT 1 || NULL;
        -> 1

XOR

Logisches XOR (exklusives ODER). Gibt NULL zurück, wenn ein Operand NULL ist. Bei Nicht-NULL-Operanden wird 1 zurückgegeben, wenn eine ungerade Anzahl von Operanden nicht null ist, andernfalls wird 0 zurückgegeben.

mysql> SELECT 1 XOR 1;
        -> 0
mysql> SELECT 1 XOR 0;
        -> 1
mysql> SELECT 1 XOR NULL;
        -> NULL
mysql> SELECT 1 XOR 1 XOR 1;
        -> 1

a XOR b ist mathematisch identisch mit (a AND (NOT b)) OR ((NOT a) and b).

expr LIKE pat [ESCAPE 'escape_char']

Mustervergleich unter Verwendung eines einfachen SQL-Vergleichs mit regulären Ausdrücken. Gibt 1 (TRUE) oder 0 (FALSE) zurück. Wenn entweder expr oder pat NULL sind, ist das Ergebnis NULL.

Das Muster muss kein literaler String sein. Es kann beispielsweise auch als String-Ausdruck oder als Tabellenspalte angegeben werden.

Gemäß dem SQL-Standard führt LIKE die Überprüfung auf Zeichenbasis durch, kann also Ergebnisse erzeugen, die sich von denen des Vergleichsoperators = unterscheiden:

mysql> SELECT 'ä' LIKE 'ae' COLLATE latin1_german2_ci;
+-----------------------------------------+
| 'ä' LIKE 'ae' COLLATE latin1_german2_ci |
+-----------------------------------------+
|                                       0 |
+-----------------------------------------+
mysql> SELECT 'ä' = 'ae' COLLATE latin1_german2_ci;
+--------------------------------------+
| 'ä' = 'ae' COLLATE latin1_german2_ci |
+--------------------------------------+
|                                    1 |
+--------------------------------------+

Bei LIKE können Sie die folgenden beiden Jokerzeichen im Muster verwenden:

mysql> SELECT 'David!' LIKE 'David_';
        -> 1
mysql> SELECT 'David!' LIKE '%D%v%';
        -> 1

Um auf literale Instanzen eines Jokerzeichens zu prüfen, stellen Sie ihm ein Escape-Zeichen voran. Wenn Sie das Escape-Zeichen nicht angeben, wird ‘\’ angenommen.

mysql> SELECT 'David!' LIKE 'David\_';
        -> 0
mysql> SELECT 'David_' LIKE 'David\_';
        -> 1

Um ein anderes Escape-Zeichen anzugeben, verwenden Sie die ESCAPE-Klausel:

mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|';
        -> 1

Die Escape-Sequenz sollte leer oder genau ein Zeichen lang sein. Ab MySQL 5.1.2 darf die Sequenz nicht leer sein, wenn der SQL-Modus NO_BACKSLASH_ESCAPES aktiviert wurde.

Die folgenden beiden Anweisungen veranschaulichen, dass die Groß-/Kleinschreibung bei String-Vergleichen nicht unterschieden wird, sofern nicht einer der Operanden ein Binär-String ist:

mysql> SELECT 'abc' LIKE 'ABC';
        -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
        -> 0

In MySQL ist LIKE für numerische Ausdrücke zulässig. (Dies stellt eine Erweiterung zu LIKE nach SQL-Standard dar.)

mysql> SELECT 10 LIKE '1%';
        -> 1

Hinweis: Weil MySQL die C-Escape-Syntax in Strings verwendet (z. B. ‘\n’ zur Darstellung eines Zeilenwechsels), müssen Sie jedes ‘\’, das Sie in LIKE-Strings verwenden, verdoppeln. Um beispielsweise nach ‘\n’ zu suchen, geben Sie es als ‘\\n’ an. Um nach ‘\’ zu suchen, geben Sie es als ‘\\\\’ an; dies ist erforderlich, weil Backslashs einmal vom Parser und dann noch einmal bei Durchführung des Mustervergleichs umgewandelt werden – so bleibt für den Vergleich ein einzelner Backslash übrig.

expr NOT LIKE pat [ESCAPE 'escape_char']

Dies ist das Gleiche wie NOT (expr LIKE pat [ESCAPE 'escape_char']).

expr NOT REGEXP pat, expr NOT RLIKE pat

Dies ist das Gleiche wie NOT (expr REGEXP pat).

expr REGEXP pat expr RLIKE pat

Führt einen Mustervergleich eines String-Ausdrucks expr mit einem Muster pat durch. Das Muster kann ein erweiterter regulärer Ausdruck sein. Die Syntax für reguläre Ausdrücke wird in Anhang G, Beschreibung der MySQL-Syntax für reguläre Ausdrücke, beschrieben. Gibt 1 zurück, wenn expr mit pat übereinstimmt; andernfalls wird 0 zurückgegeben. Wenn entweder expr oder pat NULL sind, ist das Ergebnis auch NULL. RLIKE ist ein Synonym für REGEXP, welches aus Gründen der mSQL-Kompatibilität vorhanden ist.

Das Muster muss kein literaler String sein. Es kann beispielsweise auch als String-Ausdruck oder als Tabellenspalte angegeben werden.

Hinweis: Weil MySQL die C-Escape-Syntax in Strings verwendet (z. B. ‘\n’ zur Darstellung eines Zeilenwechsels), müssen Sie jedes ‘\’, das Sie in REGEXP-Strings verwenden, verdoppeln.

REGEXP unterscheidet die Groß-/Kleinschreibung nur dann, wenn sie mit Binär-Strings verwendet wird.

mysql> SELECT 'Monty!' REGEXP 'm%y%%';
        -> 0
mysql> SELECT 'Monty!' REGEXP '.*';
        -> 1
mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
        -> 1
mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';
        -> 1  0
mysql> SELECT 'a' REGEXP '^[a-d]';
        -> 1

REGEXP und RLIKE verwenden zur Erkennung des Typs eines Zeichens den aktuellen Zeichensatz. Der Standardzeichensatz ist latin1 (cp1252 West European). Warnung: Diese Operatoren sind nicht multibytesicher.

STRCMP(expr1,expr2)

STRCMP() gibt 0 zurück, wenn die Strings identisch sind, -1, wenn das erste Argument entsprechend der aktuellen Sortierreihenfolge kleiner ist als das zweite, und 1 in jedem anderen Fall.

mysql> SELECT STRCMP('text', 'text2');
        -> -1
mysql> SELECT STRCMP('text2', 'text');
        -> 1
mysql> SELECT STRCMP('text', 'text');
        -> 0

STRCMP() verwendet zur Durchführung von Vergleichsoperationen den aktuellen Zeichensatz. Insofern wird die Groß-/Kleinschreibung bei Vergleichen standardmäßig nicht unterschieden, sofern nicht mindestens einer der Operanden ein Binär-String ist.

+

Addition:

mysql> SELECT 3+5;
        -> 8

-

Subtraktion:

mysql> SELECT 3-5;
        -> -2

-

Monadisches Minus. Dieser Operator ändert das Vorzeichen des Arguments.

mysql> SELECT - 2;
        -> -2

Hinweis: Wenn der Operator mit einem BIGINT verwendet wird, ist der Rückgabewert ebenfalls ein BIGINT. Das bedeutet, dass Sie die Verwendung von – bei Integers vermeiden sollten, die den Wert –2⁶³ annehmen könnten.

*

Multiplikation:

mysql> SELECT 3*5;
        -> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
        -> 0

Das Ergebnis des letzten Ausdrucks ist falsch, weil das Ergebnis der Integer-Multiplikation den 64-Bit-Bereich von BIGINT-Berechnungen überschreitet. (Siehe auch Abschnitt 11.2, „Numerische Datentypen“.)

/

Division:

mysql> SELECT 3/5;
        -> 0.60

Die Division durch null erzeugt das Ergebnis NULL:

mysql> SELECT 102/(1-1);
        -> NULL

Eine Division wird nur dann mit BIGINT-Arithmetik berechnet, wenn sie in einem Kontext durchgeführt wird, in dem das Ergebnis in einen Integer konvertiert wird.

DIV

Integer-Division. Ähnlich wie FLOOR(), aber sicher bei BIGINT-Werten.

mysql> SELECT 5 DIV 2;
        -> 2

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:

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.

Sie verwendet die 50-Prozent-Marke nicht.

Datensätze werden nicht automatisch nach absteigender Relevanz sortiert. Dies erkennen Sie am obigen Abfrageergebnis: Der Datensatz mit der höchsten Relevanz ist derjenige, der „MySQL“ zweimal enthält. Er wird aber nicht als Erster, sondern als Letzter aufgeführt.

Sie funktioniert auch ohne FULLTEXT-Index, auch wenn eine derart ausgeführte Suche recht lange dauert.

Die Volltextparameter für minimale und maximale Wortlängen werden angewendet.

Die Stoppwortliste wird angewendet.

+

Ein führendes Pluszeichen gibt an, dass das betreffende Wort in jedem zurückgegebenen Datensatz vorhanden sein muss.

-

Ein führendes Minuszeichen gibt an, dass dieses Wort nicht in einem Datensatz vorhanden sein darf, der zurückgegeben wird.

Hinweis: Der Operator - schließt nur solche Datensätze aus, die andernfalls Bestandteil des Ergebnisses wären. Aufgrund dessen gibt eine boolesche Suche, die nur mit Minuszeichen gekennzeichnete Begriffe enthält, ein leeres Ergebnis zurück, nicht jedoch „alle Datensätze mit Ausnahme derer, die einen der ausgeschlossenen Begriffe enthalten“.

(kein Operator)

Standardmäßig (also wenn weder + noch - angegeben sind) ist das Wort optional, aber Datensätze, die es enthalten, werden weiter oben einsortiert. Dies ahmt das Verhalten von MATCH() ... AGAINST() ohne den Modifizierer IN BOOLEAN MODE nach.

> <

Diese beiden Operatoren werden verwendet, um den Anteil eines Worts am Relevanzwert zu ändern, der einem Datensatz zugewiesen wird. Der Operator > erhöht den Anteil, der Operator < verringert ihn. Ein Beispiel finden Sie nach dieser Liste.

( )

Mit Klammern werden Wörter zu Unterausdrücken zusammengefasst. Gruppen in Klammern können verschachtelt werden.

~

Eine führende Tilde fungiert als Negationsoperator, d. h., der Anteil des Wortes an der Relevanz des Datensatzes wird negativ gewertet. Dies ist nützlich, um „Störungswörter“ zu kennzeichnen. Ein Datensatz, der ein solches Wort enthält, erhält eine geringere Relevanz als andere, wird aber – anders als bei - – nicht vollständig aus dem Ergebnis ausgeschlossen.

*

Das Sternchen dient als Kürzungs- oder Jokeroperator. Anders als andere Operatoren wird es an das betreffende Wort angehängt. Eine Übereinstimmung liegt bei Wörtern vor, die mit dem vor dem Operator * stehenden Wort beginnen.

"

Eine Phrase, die in doppelte Anführungszeichen (‘"’) gesetzt ist, entspricht nur solchen Datensätzen, in denen diese Phrase wortwörtlich (d. h. wie eingegeben) vorkommt. Die Volltextsuche unterteilt die Phrase in Wörter und führt dann eine Suche nach ihnen im FULLTEXT-Index durch. Bei Zeichen, die nicht zum Wort gehören, muss keine exakte Übereinstimmung vorliegen: Die Phrasensuche erfordert lediglich, dass bei passenden Datensätzen dieselben Wörter in genau der in der Phrase angegebenen Reihenfolge vorhanden sind. So entspricht beispielsweise "test phrase" "test, phrase".

Wenn die Phrase keine Wörter enthält, die im Index vorhanden sind, ist das Ergebnis leer. Wenn beispielsweise alle Wörter Stoppwörter oder kürzer sind als die Mindestlänge für indizierte Wörter, dann ist das Ergebnis leer.

'apple banana'

Findet Datensätze, die mindestens eines der beiden Wörter enthalten.

'+apple +juice'

Findet Datensätze, die beide Wörter enthalten.

'+apple macintosh'

Findet Datensätze, die das Wort „apple“ enthalten, stuft aber solche Datensätze höher ein, die auch „macintosh“ enthalten.

'+apple -macintosh'

Findet Datensätze, die das Wort „apple“, aber nicht das Wort „macintosh“ enthalten.

'+apple ~macintosh'

Findet Datensätze, die das Wort „apple“ enthalten. Datensätze, die außerdem das Wort „macintosh“ enthalten, werden niedriger eingestuft als solche, die es nicht enthalten. Dies ist „sanfter“ als eine Suche nach '+apple -macintosh', bei der ein Datensatz bei Vorhandensein von „macintosh“ überhaupt nicht zurückgegeben wird.

'+apple +(>turnover <strudel)'

Findet Datensätze, die die Wörter „apple“ und „turnover“ oder „apple“ und „strudel“ (in beliebiger Reihenfolge) enthalten, aber stuft „apple turnover“ höher ein als „apple strudel“.

'apple*'

Findet Datensätze, die Wörter wie „apple“, „apples“, „applesauce“ oder „applet“ enthalten.

'"some words"'

Findet Datensätze, die die exakte Phrase „some words“ enthalten. Dies wäre etwa „some words of wisdom“, nicht aber „some noise words“. Beachten Sie, dass die ‘"’-Anführungszeichen, die die Phrase umschließen, Operatorzeichen sind, die der Trennung der Phrase dienen. Es handelt sich hierbei nicht um Anführungszeichen, die den Such-String selbst umfassen.

Die Volltextsuche wird nur für MyISAM-Tabellen unterstützt.

Sie kann mit den meisten Multibytezeichensätzen benutzt werden. Eine Ausnahme ist Unicode: Der Zeichensatz utf8 kann verwendet werden, nicht aber der Zeichensatz ucs2.

Ideografische Sprachen wie das Chinesische und das Japanische kennen keine Worttrennzeichen. Aus diesem Grund kann der FULLTEXT-Parser bei diesen und anderen Sprachen nicht bestimmen, wo ein Wort anfängt oder endet. Die entsprechenden Auswirkungen und einige Workarounds für das Problem sind in Abschnitt 12.7, „MySQL-Volltextsuche“ beschrieben.

Zwar wird die Verwendung mehrerer Zeichensätze innerhalb einer Tabelle unterstützt, aber alle Spalten in einem FULLTEXT-Index müssen denselben Zeichensatz und dieselbe Sortierung haben.

Die MATCH()-Spaltenliste muss exakt mit der Spaltenliste in einer FULLTEXT-Indexdefinition der Tabelle übereinstimmen, sofern für MATCH() nicht der Modus IN BOOLEAN MODE aktiviert ist. Die boolesche Suche kann auch in nichtindizierten Spalten erfolgen, ist dann allerdings recht langsam.

Das Argument AGAINST() muss eine String-Konstante sein.

Die minimalen und maximalen Längen von zu indizierenden Wörtern werden mit den Systemvariablen ft_min_word_len und ft_max_word_len definiert. (Siehe auch Abschnitt 5.2.2, „Server-Systemvariablen“.) Die standardmäßige Mindestlänge beträgt vier Zeichen, die vorgabeseitige Höchstlänge hängt von der Version ab. Wenn Sie einen der Werte ändern, müssen Sie ihre FULLTEXT-Indizes neu erstellen. Wünschen Sie beispielsweise, dass Wörter mit drei Zeichen durchsucht werden können sollen, dann können Sie die Variable ft_min_word_len umstellen, indem Sie die folgenden Zeilen in eine Optionsdatei schreiben:

[mysqld]
ft_min_word_len=3

Danach müssen Sie den Server neu starten und die FULLTEXT-Indizes neu erstellen. Beachten Sie insbesondere die Anmerkungen zu myisamchk in der Anleitung, die auf diese Liste folgt.

Um die standardmäßige Stoppwortliste außer Kraft zu setzen, müssen Sie die Systemvariable ft_stopword_file einstellen. (Siehe auch Abschnitt 5.2.2, „Server-Systemvariablen“.) Der Variablenwert sollte der Pfadname zu der Datei, die die Stoppwortliste enthält, oder der Leer-String sein (in diesem Fall wird die Stoppwortfilterung deaktiviert). Nachdem Sie den Wert dieser Variablen oder den Inhalt der Stoppwortdatei geändert haben, starten Sie den Server neu und erstellen Ihre FULLTEXT-Indizes dann neu.

Die Stoppwortliste hat eine freie Form, d. h., Sie können beliebige nichtalphanumerische Zeichen wie den Zeilenwechsel, das Leerzeichen oder das Komma verwenden, um Stoppwörter zu trennen. Ausnahmen sind der Unterstrich (_) und ein einzelnes Apostroph ('), die als Teil eines Wortes behandelt werden. Der Zeichensatz der Stoppwortliste ist der Standardzeichensatz des Servers (siehe auch Abschnitt 10.3.1, „Serverzeichensatz und -sortierfolge“).

Die 50-Prozent-Marke für natursprachliche Suchvorgänge wird vom jeweiligen Gewichtungsschema bestimmt. Um sie zu deaktivieren, suchen Sie in myisam/ftdefs.h nach der folgenden Zeile:

#define GWS_IN_USE GWS_PROB

Ändern Sie sie wie folgt ab:

#define GWS_IN_USE GWS_FREQ

Dann kompilieren Sie MySQL neu. In diesem Fall ist es nicht notwendig, die Indizes neu zu erstellen. Hinweis: Durch diese Änderung beeinträchtigen Sie die Fähigkeit von MySQL zur Bereitstellung passender Relevanzwerte für die Funktion MATCH() erheblich. Wenn Sie tatsächlich nach solchen gängigen Wörtern suchen müssen, sollten Sie stattdessen im Modus IN BOOLEAN MODE suchen, denn bei diesem wird die 50-Prozent-Marke ignoriert.

Um die für die boolesche Volltextsuche verwendeten Operatoren zu ändern, stellen Sie die Systemvariable ft_boolean_syntax ein. Diese Variable kann zur Laufzeit des Servers geändert werden, allerdings benötigen Sie hierfür die Berechtigung SUPER. Eine Neuerstellung der Indizes ist in diesem Fall nicht notwendig. Weitere Informationen finden Sie in Abschnitt 5.2.2, „Server-Systemvariablen“, wo auch die Regeln für die Einstellung dieser Variablen beschrieben werden.

|

Bit-OR:

mysql> SELECT 29 | 15;
        -> 31

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

&

Bit-AND:

mysql> SELECT 29 & 15;
        -> 13

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

^

Bit-XOR:

mysql> SELECT 1 ^ 1;
        -> 0
mysql> SELECT 1 ^ 0;
        -> 1
mysql> SELECT 11 ^ 3;
        -> 8

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

<<

Verschiebt eine Longlong-Zahl (BIGINT) nach links.

mysql> SELECT 1 << 2;
        -> 4

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

>>

Verschiebt eine Longlong-Zahl (BIGINT) nach rechts.

mysql> SELECT 4 >> 2;
        -> 1

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

~

Invertiert alle Bits.

mysql> SELECT 5 & ~1;
        -> 4

Das Ergebnis ist ein vorzeichenloser 64-Bit-Integer.

BIT_COUNT(N)

Gibt die Anzahl der Bits zurück, die im Argument N gesetzt sind.

mysql> SELECT BIT_COUNT(29), BIT_COUNT(b'101010');
        -> 4, 3

AES_ENCRYPT(str,key_str), AES_DECRYPT(crypt_str,key_str)

Diese Funktionen gestatten die Ver- und Entschlüsselung von Daten mithilfe des offiziellen AES-Algorithmus (Advanced Encryption Standard; dieser war früher als „Rijndael“ bekannt). Die Verschlüsselung erfolgt mit einem 128-Bit-Schlüssel, den Sie aber durch Modifizierung des Quellcodes auf 256 Bits erweitern können. Wir haben uns für eine Schlüsselbreite von 128 Bits entschieden, da diese bei hoher Verarbeitungsgeschwindigkeit für die meisten Zwecke ausreichend sicher ist.

AES_ENCRYPT() verschlüsselt einen String und gibt einen Binär-String zurück. AES_DESCRIPT() entschlüsselt den verschlüsselten String und gibt den Original-String zurück. Die Eingabeargumente dürfen eine beliebige Länge haben. Wenn eines der Argumente NULL ist, ist das Ergebnis dieser Funktion ebenfalls NULL.

Da AES als Algorithmus auf Blockebene arbeitet, werden Strings unterschiedlicher Länge bei der Verschlüsselung mit Füllzeichen erweitert. Die Länge des Ergebnis-Strings lässt sich mit folgender Formel berechnen:

16 × (trunc(string_length / 16) + 1)

Wenn AES_DECRYPT() ungültige Daten oder ein inkorrektes Auffüllen erkennt, gibt es NULL zurück. Es ist allerdings möglich, dass AES_DECRYPT() einen Nicht-NULL-Wert zurückgibt, wenn Eingabedaten oder Schlüssel ungültig sind. (Der Rückgabewert ist dann in aller Regel unsinnig).

Sie können die AES-Funktionen zur Speicherung von Daten in verschlüsselter Form verwenden, indem Sie Ihre Abfragen abändern:

INSERT INTO t VALUES (1,AES_ENCRYPT('text','password'));

AES_ENCRYPT() und AES_DECRYPT() können als die aus kryptografischer Sicht sichersten Verschlüsselungsfunktionen gelten, die derzeit in MySQL zur Verfügung stehen.

COMPRESS(string_to_compress)

Komprimiert einen String und gibt das Ergebnis als Binär-String zurück. Diese Funktion erfordert es, dass MySQL mit einer Komprimierungsbibliothek wie etwa zlib kompiliert wurde. Andernfalls ist der Rückgabewert immer NULL. Der komprimierte String kann mit UNCOMPRESS() wieder dekomprimiert werden.

mysql> SELECT LENGTH(COMPRESS(REPEAT('a',1000)));
        -> 21
mysql> SELECT LENGTH(COMPRESS(''));
        -> 0
mysql> SELECT LENGTH(COMPRESS('a'));
        -> 13
mysql> SELECT LENGTH(COMPRESS(REPEAT('a',16)));
        -> 15

Der Inhalt des komprimierten Strings wird wie folgt gespeichert:

DECODE(crypt_str,pass_str)

Entschlüsselt den verschlüsselten String crypt_str mit pass_str als Passwort. crypt_str sollte ein String sein, der von ENCODE() zurückgegeben wurde.

ENCODE(str,pass_str)

Verschlüsselt str unter Verwendung von pass_str als Passwort. Zur Entschlüsselung des Ergebnisses verwenden Sie DECODE().

Das Ergebnis ist ein Binär-String derselben Länge wie str.

DES_DECRYPT(crypt_str[,key_str])

Entschlüsselt einen String, der mit DES_ENCRYPT() verschlüsselt wurde. Wenn ein Fehler auftritt, gibt die Funktion NULL zurück.

Beachten Sie, dass diese Funktion nur funktioniert, wenn MySQL mit SSL-Unterstützung konfiguriert wurde. Siehe auch Abschnitt 5.9.7, „Verwendung sicherer Verbindungen“.

Wird kein Argument key_str angegeben, dann untersucht DES_DECRYPT() das erste Byte des verschlüsselten Strings, um die DES-Schlüsselnummer zu ermitteln, die zur Verschlüsselung des ursprünglichen Strings verwendet wurde, und liest den Schlüssel dann aus der DES-Schlüsseldatei aus, um die Nachricht zu entschlüsseln. Damit dies klappt, benötigt der Benutzer die Berechtigung SUPER. Die Schlüsseldatei kann mit der Serveroption --des-key-file angegeben werden.

Wenn Sie der Funktion ein Argument key_str übergeben, wird dieser String als Schlüssel zur Entschlüsselung der Nachricht verwendet.

Wenn das Argument crypt_str kein verschlüsselter String zu sein scheint, gibt MySQL den übergebenen String crypt_str zurück.

DES_ENCRYPT(str[,(key_num|key_str)])

Verschlüsselt den String mit dem angegebenen Schlüssel unter Verwendung des Triple-DES-Algorithmus.

Beachten Sie, dass diese Funktion nur funktioniert, wenn MySQL mit SSL-Unterstützung konfiguriert wurde. Siehe auch Abschnitt 5.9.7, „Verwendung sicherer Verbindungen“.

Der für die Verschlüsselung zu verwendende Schlüssel wird basierend auf dem zweiten Argument zu DES_ENCRYPT() (sofern vorhanden) ausgewählt:

Die Schlüsseldatei kann mit der Serveroption --des-key-file angegeben werden.

Der Rückgabe-String ist ein Binär-String, bei dem das erste Zeichen CHAR(128 | key_num) ist. Wenn ein Fehler auftritt, gibt DES_ENCRYPT() NULL zurück.

Die 128 wird hinzugefügt, um die Erkennung eines verschlüsselten Schlüssels zu erleichtern. Wenn Sie einen String-Schlüssel verwenden, ist key_num 127.

Die String-Länge des Ergebnisses wird mit dieser Formel angegeben:

new_len = orig_len + (8 - (orig_len % 8)) + 1

Jede Zeile in der DES-Schlüsseldatei hat das folgende Format:

key_num des_key_str

Jeder key_num-Wert muss eine Zahl zwischen 0 und 9 sein. Die Zeilen können in der Datei beliebig sortiert sein. des_key_str ist der String, der zur Verschlüsselung der Nachricht verwendet wird. Es sollte mindestens ein Leerzeichen zwischen der Zahl und dem Schlüssel stehen. Der erste Schlüssel ist der Standardschlüssel: Er wird benutzt, wenn kein Schlüsselargument für DES_ENCRYPT() angegeben wurde.

Sie können MySQL mit der Anweisung FLUSH DES_KEY_FILE anweisen, neue Schlüsselwerte aus der Schlüsseldatei einzulesen. Dies erfordert die Berechtigung RELOAD.

Ein Vorteil der Verwendung eines Satzes mit Standardschlüsseln besteht darin, dass dies Anwendungen eine Möglichkeit bietet, auf das Vorhandensein verschlüsselter Spaltenwerte zu prüfen, ohne dem Endbenutzer das Recht zur Verschlüsselung dieser Werte zu geben.

mysql> SELECT customer_address FROM customer_table 
     > WHERE crypted_credit_card = DES_ENCRYPT('credit_card_number');

ENCRYPT(str[,salt])

Verschlüsselt str unter Verwendung des Unix-Systemaufrufs crypt() und gibt einen Binär-String zurück. Das Argument salt sollte ein String mit mindestens zwei Zeichen sein. Wird kein salt-Argument angegeben, dann wird ein zufälliger Wert verwendet.

mysql> SELECT ENCRYPT('hello');
        -> 'VxuFAJXVARROc'

ENCRYPT() ignoriert zumindest auf einigen Systemen alle bis auf die ersten acht Zeichen von str. Dieses Verhalten wird von der Implementierung des zugrunde liegenden crypt()-Systemaufrufs bestimmt.

Wenn crypt() nicht auf Ihrem System verfügbar ist (wie es bei Windows der Fall ist), gibt ENCRYPT() immer NULL zurück.

MD5(str)

Berechnet eine MD5-Prüfsumme mit 128 Bits für den String. Der Wert wird als 32 Hexadezimalstellen umfassender Binär-String zurückgegeben. Ist das Argument NULL, so wird auch NULL zurückgegeben. Der Rückgabewert kann z. B. als Hash-Schlüssel verwendet werden.

mysql> SELECT MD5('testing');
        -> 'ae2b1fca515949e5d54fb22b8ed95575'

Dies ist der „MD5-Message-Digest-Algorithmus“ von RSA Data Security, Inc.

Wenn Sie den Wert in Großbuchstaben konvertieren wollen, lesen Sie die Beschreibung zur Konvertierung von Binär-Strings im Abschnitt zum Operator BINARY (Abschnitt 12.8, „Cast-Funktionen und Operatoren“).

Beachten Sie auch die Anmerkung zum MD5-Algorithmus am Anfang dieses Abschnitts.

OLD_PASSWORD(str)

OLD_PASSWORD() wurde zu MySQL hinzugefügt, als die Implementierung von PASSWORD() geändert wurde, um die Sicherheit zu verbessern. OLD_PASSWORD() gibt den Wert der alten (d. h. vor Version 4.1 verwendeten) Implementierung von PASSWORD() als Binär-String zurück und soll Ihnen das Zurücksetzen von Passwörtern auf Clients vor Version 4.1 gestatten, die mit Ihrem MySQL Server unter Version 5.1 eine Verbindung herstellen können sollen, ohne ausgesperrt zu werden. Siehe auch Abschnitt 5.8.9, „Kennwort-Hashing ab MySQL 4.1“.

PASSWORD(str)

Berechnet einen Passwort-String aus dem Klartextpasswort str und gibt diesen zurück. Der Rückgabewert ist ein Binär-String oder aber NULL, sofern das Argument NULL war. Diese Funktion wird zur Verschlüsselung von MySQL-Passwörtern zur Speicherung in der Spalte Password der Grant-Tabelle user benutzt.

mysql> SELECT PASSWORD('badpwd');
        -> '*AAB3E285149C0135D51A520E1940DD3263DC008C'

Die PASSWORD()-Verschlüsselung ist unidirektional (d. h. unumkehrbar).

PASSWORD() führt keine Passwortverschlüsselung in der Art der Verschlüsselung von Unix-Passwörtern durch. Siehe auch ENCRYPT().

Hinweis: Die Funktion PASSWORD() wird in MySQL Server vom Authentifizierungssystem verwendet. Sie sollten Sie nicht in Ihren eigenen Anwendungen einsetzen. Ziehen Sie zu diesem Zweck eher MD5() oder SHA1() in Betracht. Ferner können Sie RFC 2195 weitere Informationen zum sicheren Umgang mit Passwörtern und Authentifizierung in Ihren Anwendungen entnehmen.

SHA1(str), SHA(str)

Berechnet eine 160 Bits umfassende SHA-1-Prüfsumme für den String. (Siehe auch RFC 3174 mit dem Titel „Secure Hash Algorithm“). Der Wert wird als 40 Hexadezimalstellen umfassender Binär-String zurückgegeben. Ist das Argument NULL, so wird auch NULL zurückgegeben. Diese Funktion lässt sich etwa für die Erstellung eines Hash-Schlüssels verwenden. Sie können sie auch als Kryptografiefunktion zur Speicherung von Passwörtern verwenden. SHA() ist synonym zu SHA1().

mysql> SELECT SHA1('abc');
        -> 'a9993e364706816aba3e25717850c26c9cd0d89d'

SHA1() kann als aus kryptografischer Sicht sichereres Äquivalent zu MD5() betrachtet werden. Allerdings sollten Sie auch die Anmerkung zu den MD5- und SHA-1-Algorithmen am Anfang dieses Abschnitts beachten.

UNCOMPRESS(string_to_uncompress)

Entkomprimiert einen String, der mit der Funktion COMPRESS() komprimiert wurde. Wenn dieses Argument kein komprimierter Wert ist, ist das Ergebnis NULL. Diese Funktion erfordert es, dass MySQL mit einer Komprimierungsbibliothek wie etwa zlib kompiliert wurde. Andernfalls ist der Rückgabewert immer NULL.

mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
        -> 'any string'
mysql> SELECT UNCOMPRESS('any string');
        -> NULL

UNCOMPRESSED_LENGTH(compressed_string)

Gibt die Länge zurück, die der komprimierte String vor der Länge hatte.

mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
        -> 30

BENCHMARK(count,expr)

Die Funktion BENCHMARK() wiederholt die Ausführung des Ausdrucks expr mit der mit count angegebenen Häufigkeit. Sie kann verwendet werden, um zu ermitteln, wie schnell MySQL den Ausdruck verarbeitet. Der Ergebniswert ist immer 0. Vorgesehen ist die Verwendung dieser Funktion aus dem Client mysql heraus. Dieser gibt dann die Ausführungszeiten der Abfrage an:

mysql> SELECT BENCHMARK(1000000,ENCODE('hello','goodbye'));
+----------------------------------------------+
| BENCHMARK(1000000,ENCODE('hello','goodbye')) |
+----------------------------------------------+
|                                            0 |
+----------------------------------------------+
1 row in set (4.74 sec)

Die gemeldete Zeit ist die auf der Clientseite verstrichene Zeit und nicht die Prozessorzeit auf der Serverseite. Wir empfehlen die mehrfache Ausführung von BENCHMARK() und die Interpretation des Ergebnisses im Hinblick darauf, wie hoch die Belastung des Servercomputers ist.

CHARSET(str)

Gibt den Zeichensatz des String-Arguments zurück.

mysql> SELECT CHARSET('abc');
        -> 'latin1'
mysql> SELECT CHARSET(CONVERT('abc' USING utf8));
        -> 'utf8'
mysql> SELECT CHARSET(USER());
        -> 'utf8'

COERCIBILITY(str)

Gibt den Sortierfolgenvorrangswert des String-Arguments zurück.

mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
        -> 0
mysql> SELECT COERCIBILITY(USER());
        -> 3
mysql> SELECT COERCIBILITY('abc');
        -> 4

Die Rückgabewerte haben die in der folgenden Tabelle aufgeführten Bedeutungen. Niedrigere Werte haben dabei eine höhere Rangstufe.

COLLATION(str)

Gibt die Sortierung des String-Arguments zurück.

mysql> SELECT COLLATION('abc');
        -> 'latin1_swedish_ci'
mysql> SELECT COLLATION(_utf8'abc');
        -> 'utf8_general_ci'

CONNECTION_ID()

Gibt die Verbindungskennung (Thread-ID) der Verbindung zurück. Jede Verbindung hat eine Kennung, die in der Gesamtzahl der aktuell verbundenen Clients eindeutig ist.

mysql> SELECT CONNECTION_ID();
        -> 23786

CURRENT_USER, CURRENT_USER()

Gibt die Kombination aus Benutzer- und Hostnamen für das MySQL-Konto zurück, das der Server zur Authentifizierung des aktuellen Clients verwendet hat. Dieses Konto bestimmt Ihre Zugriffsberechtigungen. Innerhalb einer gespeicherten Routine, die mit dem Merkmal SQL SECURITY DEFINER definiert wurde, gibt CURRENT_USER() den Ersteller der Routine zurück. Der Rückgabewert ist ein String im Zeichensatz utf8.

Der Wert von CURRENT_USER() kann sich vom Wert von USER() unterscheiden.

mysql> SELECT USER();
        -> 'davida@localhost'
mysql> SELECT * FROM mysql.user;
ERROR 1044: Access denied for user ''@'localhost' to
database 'mysql'
mysql> SELECT CURRENT_USER();
        -> '@localhost'

Das Beispiel veranschaulicht, dass, obwohl der Client den Benutzernamen davida (gemäß dem Wert der Funktion USER()) angegeben hat, der Server den Client unter Verwendung eines anonymen Benutzerkontos authentifiziert hat. Dies geht aus dem leeren Benutzernamensteil des CURRENT_USER()-Werts hervor. Eine mögliche Ursache hierfür besteht darin, dass in den Grant-Tabellen kein Konto davida aufgeführt ist.

DATABASE()

Gibt den Namen der Standarddatenbank (d. h. der aktuellen Datenbank) als String im Zeichensatz utf8 zurück. Ist keine Standarddatenbank vorhanden, dann gibt DATABASE() NULL zurück. Innerhalb einer gespeicherten Routine ist die Standarddatenbank diejenige, mit der die Routine assoziiert ist. Dies muss nicht unbedingt die gleiche Datenbank sein, die als Standarddatenbank im aufrufenden Kontext verwendet wird.

mysql> SELECT DATABASE();
        -> 'test'

Ist keine Standarddatenbank vorhanden, dann gibt DATABASE() NULL zurück.

FOUND_ROWS()

Eine SELECT-Anweisung kann eine LIMIT-Klausel enthalten, die die Anzahl der Datensätze beschränkt, die der Server an den Client zurückgibt. In manchen Fällen kann es wünschenswert sein, zu wissen, wie viele Datensätze die Anweisung ohne LIMIT-Klausel zurückgegeben hätte, ohne dass man die Anweisung hierzu erneut ausführen müsste. Um diese Anzahl zu ermitteln, fügen Sie die Option SQL_CALC_FOUND_ROWS in die SELECT-Anweisung ein und rufen danach FOUND_ROWS() auf:

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
    -> WHERE id > 100 LIMIT 10;
mysql> SELECT FOUND_ROWS();

Die zweite SELECT-Anweisung gibt eine Zahl zurück, die angibt, wie viele Datensätze die erste SELECT-Anweisung zurückgegeben hätte, wenn die LIMIT-Klausel nicht enthalten gewesen wäre. (Wenn die vorangegangene SELECT-Anweisung die Option SQL_CALC_FOUND_ROWS nicht enthält, dann gibt FOUND_ROWS() mit LIMIT unter Umständen ein anderes Ergebnis als ohne.)

Die mit FOUND_ROWS() ermittelte Anzahl der Datensätze ist flüchtig und sollte nicht über die der SELECT SQL_CALC_FOUND_ROWS-Anweisung nachfolgende Anweisung hinaus verfügbar bleiben. Wenn Sie den Wert später noch einmal benötigen sollten, dann sollten Sie ihn speichern:

mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
mysql> SET @rows = FOUND_ROWS();

Wenn Sie SELECT SQL_CALC_FOUND_ROWS verwenden, muss MySQL berechnen, wie viele Datensätze in der vollständigen Ergebnismenge enthalten sind. Allerdings ist dies schneller, als die Abfrage ohne LIMIT erneut auszuführen, weil die Ergebnismenge nicht an den Client gesendet werden muss.

SQL_CALC_FOUND_ROWS und FOUND_ROWS() können in Situationen nützlich sein, in denen Sie die Anzahl der von einer Abfrage zurückgegebenen Datensätze beschränken, aber auch die Anzahl der Datensätze im vollständigen Ergebnis ermitteln wollen, ohne die Abfrage erneut auszuführen. Ein Beispiel hierfür wäre ein Webskript, das seitenweise eine Darstellung mit Links auf Seiten anzeigt, die auf andere Bereiche eines Suchergebnisses verweisen. Mithilfe von FOUND_ROWS() können Sie bestimmen, wie viele andere Seiten für den Rest des Ergebnisses benötigt werden.

Die Verwendung von SQL_CALC_FOUND_ROWS und FOUND_ROWS() ist bei UNION-Anweisungen komplexer als bei einfachen SELECT-Anweisungen, weil LIMIT an mehreren Stellen in einer UNION auftreten kann. Es kann auf einzelne SELECT-Anweisungen in der UNION oder aber global auf das Ergebnis der UNION als Ganzes angewendet werden.

Der Zweck von SQL_CALC_FOUND_ROWS bei UNION besteht in der Rückgabe der Anzahl von Datensätzen, die ohne globale LIMIT-Klausel zurückgegeben worden wäre. Die Benutzung von SQL_CALC_FOUND_ROWS mit UNION ist folgenden Bedingungen unterworfen:

LAST_INSERT_ID(), LAST_INSERT_ID(expr)

Gibt den ersten automatisch erzeugten Wert zurück, der für eine AUTO_INCREMENT-Spalte durch die aktuelle INSERT- oder UPDATE-Anweisung eingestellt wurde, die eine solche Spalte modifiziert hat.

mysql> SELECT LAST_INSERT_ID();
        -> 195

Die erzeugte Kennung wird auf dem Server verbindungsspezifisch gehandhabt: Der von der Funktion an einen bestimmten Client zurückgegebene Wert ist der erste AUTO_INCREMENT-Wert, der für die zuletzt abgesetzte Anweisung, die eine AUTO_INCREMENT-Spalte betraf, von diesem Client erzeugt wurde. Dieser Wert darf nicht von anderen Clients bearbeitet werden, auch wenn diese selbst AUTO_INCREMENT-Werte erzeugen. Dieses Verhalten gewährleistet, dass jeder Client seine eigene Kennung abrufen kann, ohne die Aktivitäten anderer Clients berücksichtigen oder Sperren setzen bzw. Transaktionen verwenden zu müssen.

Der Wert von LAST_INSERT_ID() wird nicht geändert, wenn Sie die AUTO_INCREMENT-Spalte eines Datensatzes auf einen „nichtmagischen“ Wert (d. h. einen Wert, der nicht NULL und nicht 0 ist) setzen.

Wichtig: Wenn Sie mehrere Datensätze mithilfe einer einzelnen INSERT-Anweisung einfügen, gibt LAST_INSERT_ID() nur denjenigen Wert zurück, der für den ersten eingefügten Datensatz erzeugt wurde. Grund hierfür ist, dass es möglich sein soll, dieselbe INSERT-Anweisung problemlos auf einem anderen Server zu reproduzieren.

Zum Beispiel:

mysql> USE test;
Database changed
mysql> CREATE TABLE t (
    ->   id INT AUTO_INCREMENT NOT NULL PRIMARY KEY,
    ->   name VARCHAR(10) NOT NULL
    -> );
Query OK, 0 rows affected (0.09 sec)

mysql> INSERT INTO t VALUES (NULL, 'Bob');
Query OK, 1 row affected (0.01 sec)

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
+----+------+
1 row in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                1 |
+------------------+
1 row in set (0.00 sec)

mysql> INSERT INTO t VALUES
    -> (NULL, 'Mary'), (NULL, 'Jane'), (NULL, 'Lisa');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM t;
+----+------+
| id | name |
+----+------+
|  1 | Bob  |
|  2 | Mary |
|  3 | Jane |
|  4 | Lisa |
+----+------+
4 rows in set (0.01 sec)

mysql> SELECT LAST_INSERT_ID();
+------------------+
| LAST_INSERT_ID() |
+------------------+
|                2 |
+------------------+
1 row in set (0.00 sec)

Obwohl die zweite INSERT-Anweisung drei neue Datensätze in t eingefügt hat, war die für den ersten dieser Datensätze erzeugte Kennung 2, und diesen Wert hat LAST_INSERT_ID() auch für die folgende SELECT-Anweisung zurückgegeben.

Wenn Sie INSERT IGNORE verwenden und der Datensatz ignoriert wird, wird der AUTO_INCREMENT-Zähler nicht erhöht, und LAST_INSERT_ID() gibt 0 zurück, um anzuzeigen, dass kein Datensatz eingefügt wurde.

Wenn expr als Argument für LAST_INSERT_ID() angegeben wird, wird der Wert des Arguments von der Funktion zurückgegeben und als nächster Wert von LAST_INSERT_ID() zurückzugebender Wert vermerkt. Dies kann zur Simulierung von Sequenzen verwendet werden:

Sie können Sequenzen zwar auch ohne Aufruf von LAST_INSERT_ID() erzeugen, aber die Funktion auf diese Weise zu verwenden hat den Vorteil, dass der Kennungswert am Server als letzter automatisch erzeugter Wert vermerkt wird. Dies ist im Multiuser-Betrieb sicher, weil mehrere Clients die Anweisung UPDATE absetzen und jeweils einen eigenen Sequenzwert mit der SELECT-Anweisung (oder mysql_insert_id()) erhalten, ohne andere Clients, die eigene Sequenzwerte erstellen, zu beeinträchtigen bzw. von ihnen beeinträchtigt zu werden.

Beachten Sie, dass mysql_insert_id() erst nach den INSERT- und UPDATE-Anweisungen aktualisiert wird, d. h., Sie können die C-API-Funktion nicht zum Abrufen des Werts von LAST_INSERT_ID(expr) verwenden, nachdem andere SQL-Anweisungen wie SELECT oder SET ausgeführt wurden.

ROW_COUNT()

ROW_COUNT() gibt die Anzahl der von der vorherigen Anweisung aktualisierten, eingefügten oder gelöschten Datensätze zurück. Dies entspricht der Datensatzanzahl, die vom Client mysql angezeigt wird, und dem Wert der C-API-Funktion mysql_affected_rows().

mysql> INSERT INTO t VALUES(1),(2),(3);
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           3 |
+-------------+
1 row in set (0.00 sec)

mysql> DELETE FROM t WHERE i IN(1,2);
Query OK, 2 rows affected (0.00 sec)

mysql> SELECT ROW_COUNT();
+-------------+
| ROW_COUNT() |
+-------------+
|           2 |
+-------------+
1 row in set (0.00 sec)

SCHEMA()

Diese Funktion ist synonym zu DATABASE().

SESSION_USER()

SESSION_USER() ist ein Synonym für USER().

SYSTEM_USER()

SYSTEM_USER() ist ein Synonym für USER().

USER()

Gibt den aktuellen MySQL-Benutzer- und Hostnamen als String im Zeichensatz utf8 zurück.

mysql> SELECT USER();
        -> 'davida@localhost'

Der Wert gibt den Benutzernamen, den Sie beim Herstellen der Verbindung zum Server eingegeben haben, und den Clienthost an, über den die Verbindung hergestellt wurde. Der Wert kann sich von dem von CURRENT_USER() unterscheiden.

Sie können den Benutzernamensanteil wie folgt extrahieren:

mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
        -> 'davida'

VERSION()

Gibt einen String zurück, der die MySQL Server-Version angibt. Der String verwendet den Zeichensatz utf8.

mysql> SELECT VERSION();
        -> '5.1.5-alpha-standard'

Beachten Sie, dass, wenn Ihr Versions-String mit -log endet, dies bedeutet, dass das Loggen aktiviert ist.

DEFAULT(col_name)

Gibt den Standardwert einer Tabellenspalte zurück. Wenn die Spalte keinen Standardwert hat, wird ein Fehler erzeugt.

mysql> UPDATE t SET i = DEFAULT(i)+1 WHERE id < 100;

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“.

GET_LOCK(str,timeout)

Versucht eine Sperre mit dem String str als Namen zu erwirken. Hierbei wird ein Zeitüberschreitungswert von timeout Sekunden angewendet. Gibt 1 zurück, wenn die Sperrung erfolgreich war, 0, wenn es zu einer Zeitüberschreitung kam (etwa weil zuvor ein anderer Client den Namen gesperrt hatte), oder NULL, wenn ein Fehler aufgetreten ist (z. B. aufgrund von Speichermangel oder einer Terminierung des Threads mit mysqladmin kill). Wurde eine Sperre mit GET_LOCK() erwirkt, so wird diese wieder aufgehoben, wenn Sie RELEASE_LOCK() oder noch einmal GET_LOCK() ausführen oder Ihre Verbindung – gewünscht oder unvorhergesehen – endet.

Diese Funktion kann zur Implementierung von Anwendungssperren oder zur Simulation von Datensatzsperren verwendet werden. Die Namen werden serverweit gesperrt. Wenn ein Name von einem Client gesperrt wird, blockiert GET_LOCK() alle weiteren Anforderungen von gleichnamigen Sperren durch andere Clients. So wiederum können Clients, die einem gegebenen Sperrennamen zustimmen, diesen Namen zur Durchführung kooperativer beratender Sperrungen verwenden. Sie müssen allerdings beachten, dass auf diese Weise auch Clients, die nicht zu den kooperierenden Clients gehören, unbeabsichtigt oder gezielt einen Namen sperren und so verhindern können, dass ein kooperierender Client den Namen sperren kann. Sie können die Wahrscheinlichkeit hierfür verringern, indem Sie Sperrnamen verwenden, die datenbank- oder anwendungsspezifisch sind. Verwenden Sie beispielsweise Sperrnamen der Form db_name.str oder app_name.str.

mysql> SELECT GET_LOCK('lock1',10);
        -> 1
mysql> SELECT IS_FREE_LOCK('lock2');
        -> 1
mysql> SELECT GET_LOCK('lock2',10);
        -> 1
mysql> SELECT RELEASE_LOCK('lock2');
        -> 1
mysql> SELECT RELEASE_LOCK('lock1');
        -> NULL

Der zweite RELEASE_LOCK()-Aufruf gibt NULL zurück, weil die Sperre 'lock1' automatisch durch den zweiten GET_LOCK()-Aufruf aufgehoben wurde.

Hinweis: Wenn ein Client versucht, eine Sperre zu erwirken, die bereits von einem anderen Client gehalten wird, dann erfolgt die Sperrung gemäß dem Argument timeout. Wird der blockierte Client beendet, dann wird der Thread erst terminiert, wenn eine Zeitüberschreitung der Sperranforderung erfolgt. Dieser Bug ist bekannt.

INET_ATON(expr)

Wird eine Netzwerkadresse als String in der üblichen Schreibweise (vier punktgetrennte Oktette) übergeben, dann gibt die Funktion einen Integer zurück, der den numerischen Wert der Adresse angibt. Adressen können 4 oder 8 Byte umfassen.

mysql> SELECT INET_ATON('209.207.224.40');
        -> 3520061480

Die Zahl wird immer in der Reihenfolge der Netzwerkbytes erzeugt. Beim obigen Beispiel wird sie als 209×256³ + 207×256² + 224×256 + 40 berechnet.

INET_ATON() versteht auch IP-Adressen in der Kurzform:

mysql> SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1');
        -> 2130706433, 2130706433

Hinweis: Wenn Sie Werte speichern, die von INET_ATON() erzeugt wurden, empfehlen wir die Verwendung einer INT UNSIGNED-Spalte. Wenn Sie eine (vorzeichenbehaftete) INT-Spalte verwenden, können Werte, die IP-Adressen entsprechen, deren erstes Oktett größer als 127 ist, nicht korrekt gespeichert werden. Siehe auch Abschnitt 11.2, „Numerische Datentypen“.

INET_NTOA(expr)

Wenn eine numerische Netzwerkadresse mit einer Länge von 4 oder 8 Byte übergeben wird, gibt die Funktion die punktgetrennte Darstellung der Adresse als String zurück.

mysql> SELECT INET_NTOA(3520061480);
        -> '209.207.224.40'

IS_FREE_LOCK(str)

Überprüft, ob die Sperre mit dem Namen str frei (d. h. nicht gesperrt) ist und verwendet werden kann. Gibt 1 zurück, wenn die Sperre verfügbar ist (also von niemandem benutzt wird), 0, wenn die Sperre aktiv ist, und NULL, wenn ein Fehler aufgetreten ist (z. B. bei einem falschen Argument).

IS_USED_LOCK(str)

Überprüft, ob die Sperre mit dem Namen str verwendet wird (d. h. nicht gesperrt ist). Ist dies der Fall, dann wird die Verbindungskennung des Clients zurückgegeben, der die Sperre hält. Andernfalls wird NULL zurückgegeben.

MASTER_POS_WAIT(log_name,log_pos[,timeout])

Diese Funktion ist praktisch zur Steuerung der Master/Slave-Synchronisation. Sie blockiert, bis der Slave alle Änderungen bis zur im Master-Log angegebenen Position gelesen und übernommen hat. Der Rückgabewert ist die Anzahl der Logereignisse, auf die der Slave warten musste, um bis zur angegebenen Position fortschreiten zu können. Die Funktion gibt NULL zurück, wenn der SQL-Slave-Thread nicht gestartet wurde, die Master-Daten des Slaves nicht initialisiert wurden, die Argumente inkorrekt sind oder ein Fehler auftritt. -1 wird bei einer Zeitüberschreitung zurückgegeben. Wenn der SQL-Slave-Thread endet, während MASTER_POS_WAIT() wartet, gibt die Funktion NULL zurück. Befindet sich der Slave bereits jenseits der angegebenen Position, dann erfolgt die Rückgabe durch die Funktion unmittelbar.

Wenn ein timeout-Wert angegeben wird, beendet MASTER_POS_WAIT() den Wartevorgang, sobald timeout Sekunden verstrichen sind. timeout muss größer als 0 sein; ein Nullwert oder ein negativer timeout-Wert haben die Bedeutung „kein timeout-Wert“.

NAME_CONST(name,value)

Gibt den angegebenen Wert zurück. Wenn NAME_CONST() zur Erzeugung einer Ergebnismengenspalte verwendet wird, erhält die Spalte den angegebenen Namen.

mysql> SELECT NAME_CONST('myname', 14);
+--------+
| myname |
+--------+
|     14 |
+--------+