MySQL :: MySQL 5.1 Referenzhandbuch :: 12.3 String-Funktionen

MySQL 5.1 Referenzhandbuch :: 12 Funktionen für die Benutzung in SELECT- und WHERE-Klauseln :: 12.3 String-Funktionen

Section Navigation [Toggle]

12.3. String-Funktionen

12.3.1. String-Vergleichsfunktionen

String-Funktionen geben NULL zurück, wenn die Länge des Ergebnisses größer wäre als der Wert der Systemvariablen max_allowed_packet. Siehe auch Abschnitt 7.5.2, „Serverparameter feineinstellen“.

Bei Funktionen, die mit String-Positionen operieren, hat die erste Position die Nummer 1.

ASCII(str)

Gibt den numerischen Wert des Zeichens ganz links im String str zurück. Gibt 0 zurück, wenn str der Leer-String ist. Gibt NULL zurück, wenn str NULL ist. ASCII() funktioniert bei Zeichen mit numerischen Werten zwischen 0 und 255.
```
mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100
```
Siehe auch die Funktion ORD().
BIN(N)

Gibt eine String-Darstellung des Binärwerts N zurück, wobei N eine BIGINT-Zahl ist. Dies ist äquivalent mit CONV(N,10,2). Gibt NULL zurück, wenn N NULL ist.
```
mysql> SELECT BIN(12);
        -> '1100'
```
BIT_LENGTH(str)

Gibt die Länge des Strings str angegeben in Bit zurück.
```
mysql> SELECT BIT_LENGTH('text');
        -> 32
```

CHAR(N,... [USING charset_name])

CHAR() interpretiert jedes Argument N als Integer und gibt einen String zurück, der aus den Zeichen besteht, die durch die Codewerte dieser Integers beschrieben werden. NULL-Werte werden übersprungen.

mysql> SELECT CHAR(77,121,83,81,'76');
        -> 'MySQL'
mysql> SELECT CHAR(77,77.3,'77.3');
        -> 'MMM'

CHAR()-Argumente, die größer als 255 sind, werden in mehrere Ergebnisbytes konvertiert. So ist beispielsweise CHAR(256) äquivalent zu CHAR(1,0), und CHAR(256*256) ist äquivalent zu CHAR(1,0,0):

mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));
+----------------+----------------+
| HEX(CHAR(1,0)) | HEX(CHAR(256)) |
+----------------+----------------+
| 0100           | 0100           |
+----------------+----------------+
mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+

Standardmäßig gibt CHAR() einen Binär-String zurück. Um einen String in einem gegebenen Zeichensatz zu erzeugen, verwenden Sie die optionale Klausel USING:

mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));
+---------------------+--------------------------------+
| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |
+---------------------+--------------------------------+
| binary              | utf8                           |
+---------------------+--------------------------------+

Wenn USING angegeben wird und der Ergebnis-String für den angegebenen Zeichensatz unzulässig ist, wird eine Warnung ausgegeben. Ferner wird, wenn der strikte SQL-Modus aktiviert ist, das Ergebnis von CHAR() zu NULL.

CHAR_LENGTH(str)

Gibt die Länge des Strings str angegeben in Zeichen zurück. Ein Multibytezeichen wird als ein Zeichen gezählt. Das bedeutet, dass LENGTH() für einen aus fünf Zweibytezeichen bestehenden String 10 zurückgibt, CHAR_LENGTH() hingegen 5.
CHARACTER_LENGTH(str)

CHARACTER_LENGTH() ist ein Synonym für CHAR_LENGTH().
CONCAT(str1,str2,...)

Gibt den String zurück, der aus der Verkettung der Argumente entsteht. Kann ein oder mehrere Argumente haben. Sind alle Argumente nichtbinäre Strings, dann ist das Ergebnis ein nichtbinärer String. Enthalten die Argumente Binär-Strings, dann ist das Ergebnis ein Binär-String. Ein numerisches Argument wird in seinen äquivalenten Binär-String konvertiert. Wollen Sie dies vermeiden, dann können Sie wie im folgenden Beispiel eine explizite Typenumwandlung vornehmen:
```
SELECT CONCAT(CAST(int_col AS CHAR), char_col);
```
CONCAT() gibt NULL zurück, sofern ein Argument NULL ist.
```
mysql> SELECT CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
        -> NULL
mysql> SELECT CONCAT(14.3);
        -> '14.3'
```
CONCAT_WS(separator,str1,str2,...)

CONCAT_WS() (Concatenate With Separator) ist eine Sonderform von CONCAT(). Das erste Argument ist das Trennzeichen für die verbleibenden Argumente. Das Trennzeichen wird zwischen die zu verkettenden Strings gesetzt. Das Trennzeichen kann ein String wie auch die übrigen Argumente sein. Wenn das Trennzeichen NULL ist, ist das Ergebnis ebenfalls NULL.
```
mysql> SELECT CONCAT_WS(',','First name','Second name','Last Name');
        -> 'First name,Second name,Last Name'
mysql> SELECT CONCAT_WS(',','First name',NULL,'Last Name');
        -> 'First name,Last Name'
```
CONCAT_WS() überspringt Leer-Strings nicht. NULL-Werte nach dem Trennzeichenargument werden hingegen übersprungen.
CONV(N,from_base,to_base)

Wandelt Zahlen zwischen verschiedenen Zahlenbasen um. Gibt eine String-Darstellung der Zahl N zurück, die von der Basis from_base in die Basis to_base konvertiert wurde. Gibt NULL zurück, wenn eines der Argumente NULL ist. Das Argument N wird als Integer interpretiert, kann aber als Integer oder als String angegeben werden. Die kleinste Basis ist 2, die größte 36. Wenn to_base eine negative Zahl ist, wird N als vorzeichenbehaftete Zahl betrachtet. Andernfalls wird N als vorzeichenlos behandelt. CONV() arbeitet mit einer Genauigkeit von 64 Bit.
```
mysql> SELECT CONV('a',16,2);
        -> '1010'
mysql> SELECT CONV('6E',18,8);
        -> '172'
mysql> SELECT CONV(-17,10,-18);
        -> '-H'
mysql> SELECT CONV(10+'10'+'10'+0xa,10,10);
        -> '40'
```
ELT(N,str1,str2,str3,...)

Gibt str1 zurück, wenn N = 1 ist, str2, wenn N = 2 usw. Gibt NULL zurück, wenn N kleiner als 1 oder größer als die Anzahl der Argumente ist. ELT() ist die Ergänzung zu FIELD().
```
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
        -> 'ej'
mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
        -> 'foo'
```
EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

Gibt einen String zurück. Dabei erhalten Sie für jedes im Wert bits gesetzte Bit den String on und für jedes nicht gesetzte Bit den String off. Bits in bits werden von rechts nach links (d. h. von den niederwertigen zu den höherwertigen Bits) untersucht. Strings werden dem Ergebnis hingegen von links nach rechts hinzugefügt. Sie sind durch einen Trenn-String voneinander getrennt (standardmäßig ist dies das Kommazeichen ‘,’). Die Anzahl der zu untersuchenden Bits wird über number_of_bits angegeben (Standard: 64).
```
mysql> SELECT EXPORT_SET(5,'Y','N',',',4);
        -> 'Y,N,Y,N'
mysql> SELECT EXPORT_SET(6,'1','0',',',10);
        -> '0,1,1,0,0,0,0,0,0,0'
```
FIELD(str,str1,str2,str3,...)

Gibt den Index (d. h. die Position) von str in der Liste str1, str2, str3, ... zurück. Gibt 0 zurück, wenn str nicht gefunden wird.

Sind alle Argumente für FIELD() Strings, dann werden alle Argumente als Strings verglichen. Sind alle Argumente Zahlen, dann werden sie als Zahlen verglichen. Andernfalls werden die Argumente als Fließkommazahlen verglichen.

Wenn str NULL ist, ist der Rückgabewert 0, weil ein Vergleich von NULL mit einem beliebigen Wert fehlschlägt. FIELD() ist die Ergänzung zu ELT().
```
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
        -> 0
```
FIND_IN_SET(str,strlist)

Gibt einen Wert im Bereich zwischen 1 und N zurück, wenn der String str Bestandteil der String-Liste strlist ist, die aus N Teil-Strings besteht. Eine String-Liste ist ein String, der aus durch Kommata getrennten Teil-Strings besteht. Wenn das erste Argument ein konstanter String und das zweite eine Spalte des Typs SET ist, wird die Funktion FIND_IN_SET() so optimiert, dass sie eine Bitarithmetik verwendet. Gibt 0 zurück, wenn str nicht in strlist enthalten oder strlist der Leer-String ist. Gibt NULL zurück, wenn eines der Argumente NULL ist. Diese Funktion arbeitet nicht einwandfrei, wenn das erste Argument ein Komma (‘,’) enthält.
```
mysql> SELECT FIND_IN_SET('b','a,b,c,d');
        -> 2
```
FORMAT(X,D)

Formatiert die Zahl X in ein Format wie '#,###,###.##', gerundet auf D Dezimalstellen, und gibt das Ergebnis als String zurück. Wenn D 0 ist, hat das Ergebnis keinen Dezimalpunkt und keine Nachkommastellen.
```
mysql> SELECT FORMAT(12332.123456, 4);
        -> '12,332.1235'
mysql> SELECT FORMAT(12332.1,4);
        -> '12,332.1000'
mysql> SELECT FORMAT(12332.2,0);
        -> '12,332'
```
HEX(N_or_S)

Wenn N_or_S eine Zahl ist, wird eine String-Darstellung des Hexadezimalwerts von N zurückgegeben, wobei N eine Longlong-Zahl (BIGINT) ist. Dies ist äquivalent mit CONV(N,10,16).

Wenn N_or_S ein String ist, wird eine hexadezimale String-Darstellung von N_or_S zurückgegeben, wobei jedes Zeichen in N_or_S in zwei Hexadezimalstellen konvertiert wird.
```
mysql> SELECT HEX(255);
        -> 'FF'
mysql> SELECT 0x616263;
        -> 'abc'
mysql> SELECT HEX('abc');
        -> 616263
```
INSERT(str,pos,len,newstr)

Gibt den String str zurück. Hierbei wird der an der Position pos beginnende und len Zeichen lange Teil-String durch den String newstr ersetzt. Gibt den Ursprungs-String zurück, wenn pos größer als die Gesamtlänge des Strings ist. Ersetzt wird der Rest des an der Position pos beginnenden Strings, wenn len größer ist als der verbleibende String. Gibt NULL zurück, wenn eines der Argumente NULL ist.
```
mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'
mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
        -> 'Quadratic'
mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
        -> 'QuWhat'
```
Diese Funktion ist multibytesicher.
INSTR(str,substr)

Gibt die Position des ersten Auftretens des Teil-Strings substr im String str zurück. Dies ist weitgehend identisch mit der mit zwei Argumenten arbeitenden Form von LOCATE(); der einzige Unterschied besteht darin, dass die Reihenfolge der Argumente umgekehrt ist.
```
mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0
```
Diese Funktion ist multibytesicher. Die Groß-/Kleinschreibung wird nur dann unterschieden, wenn mindestens ein Argument ein Binär-String ist.
LCASE(str)

LCASE() ist ein Synonym für LOWER().
LEFT(str,len)

Gibt beginnend von links die durch len angegebene Anzahl von Zeichen des Strings str zurück.
```
mysql> SELECT LEFT('foobarbar', 5);
        -> 'fooba'
```
LENGTH(str)

Gibt die Länge des Strings str angegeben in Byte zurück. Ein Multibytezeichen wird als mehrere Bytes gezählt. Das bedeutet, dass LENGTH() für einen aus fünf Zweibytezeichen bestehenden String 10 zurückgibt, CHAR_LENGTH() hingegen 5.
```
mysql> SELECT LENGTH('text');
        -> 4
```
LOAD_FILE(file_name)

Liest die Datei und gibt den Dateiinhalt als String zurück. Damit diese Funktion verwendet werden kann, muss die Datei auf dem Serverhost liegen. Sie benötigen die Berechtigung FILE und müssen den vollständigen Pfadnamen der Datei angeben. Die Datei muss von allen lesbar und ihre Größe geringer als max_allowed_packet Bytes sein.

Wenn die Datei nicht vorhanden ist oder nicht gelesen werden kann, weil eine der vorherigen Bedingungen nicht erfüllt ist, gibt die Funktion NULL zurück.
```
mysql> UPDATE t
            SET blob_col=LOAD_FILE('/tmp/picture')
            WHERE id=1;
```
LOCATE(substr,str), LOCATE(substr,str,pos)

Die erste Syntax gibt die Position des ersten Auftretens des Teil-Strings substr im String str zurück. Die zweite Syntax gibt die Position des ersten Auftretens des Teil-Strings substr im String str beginnend bei der Position pos zurück. Gibt 0 zurück, wenn substr nicht in str enthalten ist.
```
mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7
```
Diese Funktion ist multibytesicher. Die Groß-/Kleinschreibung wird nur dann unterschieden, wenn mindestens ein Argument ein Binär-String ist.
LOWER(str)

Gibt den String str mit allen Zeichen zurück, die aufgrund der aktuellen Zeichensatzzuordnung in Kleinbuchstaben umgewandelt wurden. Der Standardzeichensatz ist latin1 (cp1252 West European).
```
mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'
```
Diese Funktion ist multibytesicher.
LPAD(str,len,padstr)

Gibt den String str zurück. Dieser wurde nach links mit dem String padstr auf eine Länge von len Zeichen aufgefüllt. Wenn str länger als len ist, wird der Rückgabewert auf len Zeichen gekürzt.
```
mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
mysql> SELECT LPAD('hi',1,'??');
        -> 'h'
```
LTRIM(str)

Gibt den String str zurück, bei dem alle Leerzeichen am Anfang entfernt wurden.
```
mysql> SELECT LTRIM('  barbar');
        -> 'barbar'
```
Diese Funktion ist multibytesicher.
MAKE_SET(bits,str1,str2,...)

Gibt einen Mengenwert (d. h. einen String, der aus mit Kommata getrennten Teil-Strings besteht) zurück. Dieser besteht aus den Strings, bei denen das entsprechende Bit in bits gesetzt ist. str1 entspricht Bit 0, str2 Bit 1 usw. NULL-Werte in str1, str2, ... werden nicht an das Ergebnis angehängt.
```
mysql> SELECT MAKE_SET(1,'a','b','c');
        -> 'a'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice','world');
        -> 'hello,world'
mysql> SELECT MAKE_SET(1 | 4,'hello','nice',NULL,'world');
        -> 'hello'
mysql> SELECT MAKE_SET(0,'a','b','c');
        -> ''
```
MID(str,pos,len)

MID(str,pos,len) ist ein Synonym für SUBSTRING(str,pos,len).
OCT(N)

Gibt eine String-Darstellung des Oktalwerts N zurück, wobei N eine BIGINT-Zahl ist. Dies ist äquivalent mit CONV(N,10,8). Gibt NULL zurück, wenn N NULL ist.
```
mysql> SELECT OCT(12);
        -> '14'
```
OCTET_LENGTH(str)

OCTET_LENGTH() ist ein Synonym für LENGTH().
ORD(str)

Wenn das Zeichen ganz links im String str ein Multibytezeichen ist, wird der Code dieses Zeichens zurückgegeben. Dieser wird aus den numerischen Werten der Bytes gebildet, aus denen das Zeichen besteht. Hierbei kommt folgende Formel zum Einsatz:
```
  (1st byte code)
+ (2nd byte code × 256)
+ (3rd byte code × 256²) ...
```
Wenn das Zeichen ganz links im String kein Multibytezeichen ist, gibt ORD() denselben Wert zurück wie die Funktion ASCII().
```
mysql> SELECT ORD('2');
        -> 50
```
POSITION(substr IN str)

POSITION(substr IN str) ist ein Synonym für LOCATE(substr,str).
QUOTE(str)

Setzt einen String in Anführungszeichen, um ein Ergebnis zu erzeugen, das als angemessen gekennzeichneter Datenwert in einer SQL-Anweisung verwendet werden kann. Der String wird in einfache Anführungszeichen gesetzt zurückgegeben. Jedem enthaltenen einzelnen Anführungszeichen (‘'’), Backslash (‘\’), ASCII-NUL und Strg+Z wird ein Backslash vorangestellt. Wenn das Argument NULL ist, ist der Rückgabewert das Wort „NULL“ ohne Anführungszeichen.
```
mysql> SELECT QUOTE('Don\'t!');
        -> 'Don\'t!'
mysql> SELECT QUOTE(NULL);
        -> NULL
```
REPEAT(str,count)

Gibt einen String zurück, der aus dem String str besteht, welcher count Mal wiederholt wird. Wenn count kleiner als 1 ist, wird ein leerer String zurückgegeben. Gibt NULL zurück, wenn str oder count NULL sind.
```
mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'
```
REPLACE(str,from_str,to_str)

Gibt den String str zurück, bei dem jedes Auftreten des Strings from_str durch den String to_str ersetzt wurde. REPLACE() führt bei der Suche nach from_str einen Vergleich unter Berücksichtigung der Groß-/Kleinschreibung durch.
```
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
        -> 'WwWwWw.mysql.com'
```
Diese Funktion ist multibytesicher.
REVERSE(str)

Gibt den String str zurück, bei dem die Reihenfolge der Zeichen umgekehrt wurde.
```
mysql> SELECT REVERSE('abc');
        -> 'cba'
```
Diese Funktion ist multibytesicher.
RIGHT(str,len)

Gibt beginnend von rechts die durch len angegebene Anzahl von Zeichen des Strings str zurück.
```
mysql> SELECT RIGHT('foobarbar', 4);
        -> 'rbar'
```
Diese Funktion ist multibytesicher.
RPAD(str,len,padstr)

Gibt den String str zurück. Dieser wurde nach rechts mit dem String padstr auf eine Länge von len Zeichen aufgefüllt. Wenn str länger als len ist, wird der Rückgabewert auf len Zeichen gekürzt.
```
mysql> SELECT RPAD('hi',5,'?');
        -> 'hi???'
mysql> SELECT RPAD('hi',1,'?');
        -> 'h'
```
Diese Funktion ist multibytesicher.
RTRIM(str)

Gibt den String str zurück, bei dem alle Leerzeichen am Ende entfernt wurden.
```
mysql> SELECT RTRIM('barbar   ');
        -> 'barbar'
```
Diese Funktion ist multibytesicher.
SOUNDEX(str)

Gibt einen Soundex-String aus str zurück. Zwei Strings, die fast identisch klingen, sollten identische Soundex-Strings haben. Ein Soundex-String ist standardmäßig vier Zeichen lang, die Funktion SOUNDEX() gibt aber einen beliebig langen String zurück. Sie können SUBSTRING() für das Ergebnis verwenden, um einen Standard-Soundex-String zu erhalten. Alle nicht alphabetischen Zeichen in str werden ignoriert. Alle internationalen alphabetischen Zeichen außerhalb des Bereichs A bis Z werden als Vokale behandelt.
```
mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'
```
Hinweis: Diese Funktion implementiert den Soundex-Originalalgorithmus und nicht die gängigere erweiterte Version, wie sie auch von D. Knuth beschrieben wird. Der Unterschied besteht darin, dass die Originalversion zuerst Vokale und dann Duplikate verwirft, während die erweiterte Version umgekehrt vorgeht.
expr1 SOUNDS LIKE expr2

Dies ist das Gleiche wie SOUNDEX(expr1) = SOUNDEX(expr2).
SPACE(N)

Gibt einen String zurück, der aus N Leerzeichen besteht.
```
mysql> SELECT SPACE(6);
        -> '      '
```
SUBSTRING(str,pos), SUBSTRING(str FROM pos), SUBSTRING(str,pos,len), SUBSTRING(str FROM pos FOR len)

Die Formen ohne len-Argument geben einen Teil-String des Strings str zurück, der an der Position pos beginnt. Die Formen mit len-Argument geben einen Teil-String des Strings str mit einer Länge von len Zeichen zurück, der an der Position pos beginnt. Die Formen, die FROM verwenden, sind SQL-Standardsyntax. Es ist auch möglich, einen negativen Wert für pos zu verwenden. In diesem Fall liegt der Anfang des Teil-Strings pos Zeichen vom Ende des Strings (statt von seinem Anfang) entfernt. Ein negativer Wert kann für pos in allen Formen dieser Funktion verwendet werden.
```
mysql> SELECT SUBSTRING('Quadratically',5);
        -> 'ratically'
mysql> SELECT SUBSTRING('foobarbar' FROM 4);
        -> 'barbar'
mysql> SELECT SUBSTRING('Quadratically',5,6);
        -> 'ratica'        
mysql> SELECT SUBSTRING('Sakila', -3);
        -> 'ila'        
mysql> SELECT SUBSTRING('Sakila', -5, 3);
        -> 'aki'
mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);
        -> 'ki'
```
Diese Funktion ist multibytesicher.

Wenn len kleiner als 1 ist, wird der Leer-String zurückgegeben.

SUBSTR() ist ein Synonym für SUBSTRING().
SUBSTRING_INDEX(str,delim,count)

Gibt einen Teil-String des Strings str zurück. Der Teil-String umfasst den Teil des Strings vom Anfang bis zum count-sten Auftreten des Trennzeichens delim. Wenn count positiv ist, wird alles links vom (von links gezählt) letzten Trennzeichen zurückgegeben. Wenn count negativ ist, wird alles rechts vom (von rechts gezählt) letzten Trennzeichen zurückgegeben. SUBSTRING_INDEX() führt bei der Suche nach delim einen Vergleich unter Berücksichtigung der Groß-/Kleinschreibung durch.
```
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
        -> 'www.mysql'
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2);
        -> 'mysql.com'
```
Diese Funktion ist multibytesicher.
TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM(remstr FROM] str)

Gibt den String str zurück, bei dem alle remstr-Präfixe oder -Suffixe entfernt wurden. Wenn keine der Konfigurationsangaben BOTH, LEADING oder TRAILING angegeben wurde, wird BOTH vorausgesetzt. remstr ist optional; sofern es nicht angegeben ist, werden Leerzeichen entfernt.
```
mysql> SELECT TRIM('  bar   ');
        -> 'bar'
mysql> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
        -> 'barxxx'
mysql> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
        -> 'bar'
mysql> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
        -> 'barx'
```
Diese Funktion ist multibytesicher.
UCASE(str)

UCASE() ist ein Synonym für UPPER().
UNHEX(str)

Führt die umgekehrte Operation von HEX(str) durch: Jedes Paar Hexadezimalziffern im Argument wird als Zahl interpretiert und in das Zeichen umgewandelt, das durch die Zahl dargestellt wird. Das Ergebnis wird als Binär-String zurückgegeben.
```
mysql> SELECT UNHEX('4D7953514C');
        -> 'MySQL'
mysql> SELECT 0x4D7953514C;
        -> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
        -> 'string'
mysql> SELECT HEX(UNHEX('1267'));
        -> '1267'
```
UPPER(str)

Gibt den String str mit allen Zeichen zurück, die aufgrund der aktuellen Zeichensatzzuordnung in Großbuchstaben umgewandelt wurden. Der Standardzeichensatz ist latin1 (cp1252 West European).
```
mysql> SELECT UPPER('Hej');
        -> 'HEJ'
```
Diese Funktion ist multibytesicher.

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.

Top / Previous / Next / Up / Table of Contents