MySQL-String-Funktionen

Wenn die Länge des Ergebnisses größer als der Maximalwert der Systemvariablen max_allowed_packet ist, ist der Rückgabewert der String-Wert-Funktion NULL.

Bei Funktionen, die mit String-Positionen arbeiten, ist die erste Position mit 1 nummeriert.

ASCII(str)

Der Rückgabewert ist der numerische Wert des Zeichens ganz links in der Zeichenfolge str. Wenn str ein leerer String ist, ist der Rückgabewert 0. Wenn str NULL ist, ist der Rückgabewert NULL. ASCII() wird für Zeichen mit numerischen Werten von 0 bis 255 verwendet.

mysql> SELECT ASCII('2');

-> 50

SELECT ASCII(2);

->

mysql> SELECT ASCII('dx');

-> 100

Siehe ORD()-Funktion.

BIN(N)

Gibt die Zeichenfolgendarstellung des Binärwerts von N zurück, wobei N eine Longlong-Zahl (BIGINT) ist. Dies entspricht CONV(N,10,2). Wenn N NULL ist, ist der Rückgabewert NULL.

mysql> SELECT BIN(12);

-> '1100'

BIT_LENGTH(str)

Der Rückgabewert ist ein binärer String str Länge.

mysql> SELECT BIT_LENGTH('text');

-> 32

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

CHAR() interpretiert jedes Argument N als Ganzzahl und gibt eine Zeichenfolge zurück, die die durch die Codewerte dieser Ganzzahlen gegebenen Zeichen enthält. NULL-Werte werden weggelassen.

mysql> SELECT CHAR(77,121,83,81,'76');

-> 'MySQL'

mysql> 77.3');

-> 'MMM'

CHAR()-Parameter größer als 255 werden in mehrere Ergebniszeichen umgewandelt. Beispielsweise entspricht CHAR(256) CHAR(1,0) und CHAR(256*256) entspricht CHAR(1,0,0):

mysql> ,0 )), HEX(CHAR(256));

---------------- --------------- -

|. HEX(CHAR(1,0)) |

------------- - -----------

|. 0100 |

------------ ----- ---- -------

mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));

-- ---- ------------ --------------------------------

|. HEX(CHAR(1,0 ,0)) |. HEX(CHAR(256*256)) |

---- --- ------- ----------

| 010000 |

---------------- -- ------ ----------------

Der Rückgabewert von CHAR() ist eine binäre Zeichenfolge. Sie können optional die USING-Anweisung verwenden, um eine Zeichenfolge im angegebenen Zeichensatz zu generieren:

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

Wenn USING generiert wurde und die resultierende Zeichenfolge nicht dem angegebenen Zeichensatz entspricht, wird eine Warnung ausgegeben. Wenn der strikte SQL-Modus aktiviert ist, ist das Ergebnis von CHAR() ebenfalls NULL.

CHAR_LENGTH(str)

Der Rückgabewert ist die Länge der Zeichenfolge str und die Längeneinheit sind Zeichen. Ein Multibyte-Zeichen zählt als einzelnes Zeichen. Für einen Satz von fünf Zwei-Byte-Zeichen gibt LENGTH() 10 zurück, während CHAR_LENGTH() 5 zurückgibt.

CHARACTER_LENGTH(str)

CHARACTER_LENGTH() ist ein Synonym für CHAR_LENGTH().

COMPRESS(string_to_compress)

Komprimiert einen String. Diese Funktion erfordert, dass MySQL mit einer Komprimierungsbibliothek wie zlib komprimiert wurde. Ansonsten ist der Rückgabewert immer NULL. UNCOMPRESS() kann die komprimierte Zeichenfolge dekomprimieren.

mysql> SELECT LENGTH(COMPRESS('a',1000)));

-> 21

MYSql> SELECT LENGTH('') );

-> 0

MYSQL> LENGTH(COMPRESS(REPEAT('a',16)));

-> 15

Der Inhalt der komprimierten Zeichenfolge wird auf folgende Weise gespeichert:

leere Strings werden als leere Strings gespeichert.

Nicht leere Zeichenfolge Die Länge von vier Bytes der unkomprimierten Zeichenfolge wird gespeichert (niedriges Byte zuerst), gefolgt von der komprimierten Zeichenfolge. Wenn die Zeichenfolge mit einem Leerzeichen endet, wird am Ende ein „.“ hinzugefügt, um zu verhindern, dass das nachgestellte Leerzeichen automatisch entfernt wird, wenn der Ergebniswert in einer Feldspalte vom Typ CHAR oder VARCHAR gespeichert wird. (Es wird nicht empfohlen, CHAR oder VARCHAR zum Speichern komprimierter Zeichenfolgen zu verwenden. Es ist besser, stattdessen eine BLOB-Spalte zu verwenden.)

CONCAT(str1,str2,...)

Das Rückgabeergebnis ist die durch die Verbindungsparameter generierte Zeichenfolge. Wenn ein Parameter NULL ist, ist der Rückgabewert NULL. Es kann einen oder mehrere Parameter geben. Wenn alle Argumente nicht-binäre Zeichenfolgen sind, ist das Ergebnis eine nicht-binäre Zeichenfolge. Wenn das Argument eine Binärzeichenfolge enthält, ist das Ergebnis eine Binärzeichenfolge. Ein numerisches Argument wird in sein entsprechendes binäres Zeichenfolgenformat konvertiert. Um dies zu vermeiden, verwenden Sie eine explizite Typumwandlung, zum Beispiel: SELECT CONCAT(CAST(int_col AS CHAR), char_col)

mysql> ; ', 'S', 'QL');

-> 'MySQL'

mysql> CONCAT(14.3);

-> '14.3'

CONCAT_WS(separator,str1,str2,...)

CONCAT_WS() stellt CONCAT mit Trennzeichen dar, ja Sonderform von CONCAT(). Der erste Parameter ist das Trennzeichen für andere Parameter. Die Position des Trennzeichens wird zwischen den beiden zu verkettenden Zeichenfolgen platziert. Das Trennzeichen kann eine Zeichenfolge oder ein anderer Parameter sein. Wenn das Trennzeichen NULL ist, ist das Ergebnis NULL. Die Funktion ignoriert NULL-Werte nach jedem Trennzeichenargument.

mysql> SELECT CONCAT_WS(',','Vorname','Zweitname','Nachname');

->

mysql> SELECT CONCAT_WS(',','Vorname',NULL,'Nachname');

-> 'Vorname,Nachname'

CONCAT_WS() ignoriert keine leeren Zeichenfolgen. (Allerdings werden alle NULL-Werte ignoriert).

CONV(N,from_base,to_base)

Zahlen zwischen verschiedenen Basen konvertieren. Der Rückgabewert ist eine N-String-Darstellung einer Zahl, konvertiert von der from_base-Basis in die to_base-Basis. Wenn ein Parameter NULL ist, ist der Rückgabewert NULL. Das Argument N wird als Ganzzahl verstanden, kann aber als Ganzzahl oder String angegeben werden. Die minimale Basis beträgt 2 und die maximale Basis 36. Wenn to_base eine negative Zahl ist, wird N als vorzeichenbehaftete Zahl behandelt. Andernfalls wird N als vorzeichenlose Zahl behandelt. CONV() arbeitet mit 64-Bit-Präzision.

mysql> SELECT CONV('a',16,2);

-> '1010'

mysql> SELECT CONV('6E',18,8 );

-> '172'

mysql>

mysql> SELECT CONV(10 '10' '10' 0xa,10,10);

-> '40'

ELT(N,str1,str2,str3, ...)

Wenn N = 1, ist der Rückgabewert str1, wenn N = 2, ist der Rückgabewert str2 und so weiter. Wenn N kleiner als 1 oder größer als die Anzahl der Parameter ist, ist der Rückgabewert NULL. ELT() ist das Komplement von 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]])

Der Rückgabewert ist ein String, wobei Sie für jede Bitgruppe im Bitwert einen On-String und für jedes gelöschte Bit einen Off-String erhalten können. Die Bitwerte in Bits werden in der Reihenfolge von rechts nach links getestet (niederwertige Bits zu höherwertigen Bits). Durch eine Trennzeichenfolge (Standardkomma „,“) getrennte Zeichenfolgen werden in der Reihenfolge von links nach rechts zum Ergebnis hinzugefügt. number_of_bits gibt die Anzahl der getesteten Bits an (Standard ist 64).

mysql> SELECT EXPORT_SET(5,'Y','N',',',4);

-> 'Y,N,Y,N'

mysql> SELECT EXPORT_SET(6,'1','0',',10);

-> 0,0'

FIELD(str,str1,str2,str3,...)

Der Rückgabewert ist der str-Index in der Liste von str1, str2, str3,... Wenn str nicht gefunden wird, ist der Rückgabewert 0.

Wenn alle Parameter von FIELD() Zeichenfolgen sind, werden alle Parameter als Zeichenfolgen verglichen. Wenn alle Parameter numerisch sind, erfolgt der Vergleich numerisch. Andernfalls werden Parameter als doppelt verglichen.

Wenn str NULL ist, ist der Rückgabewert 0, da NULL mit keinem Wert gleichermaßen verglichen werden kann. FIELD() ist das Komplement von ELT().

mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');

-> 🎜>mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');

-> 0

FIND_IN_SET( str,strlist)

Wenn sich der String str in der Stringliste strlist befindet, die aus N Unterketten besteht, liegt der Rückgabewert zwischen 1 und N. Eine String-Liste ist eine Kette von Strings, die durch „,“-Zeichen getrennt sind. Wenn das erste Argument eine konstante Zeichenfolge und das zweite eine Spalte vom Typ SET ist, ist die Funktion FIND_IN_SET() für die Verwendung von Bitberechnungen optimiert. Wenn str nicht in strlist enthalten ist oder strlist ein leerer String ist, ist der Rückgabewert 0. Wenn ein Parameter NULL ist, ist der Rückgabewert NULL. Diese Funktion funktioniert nicht ordnungsgemäß, wenn das erste Argument ein Komma („,“) enthält.

mysql> SELECT FIND_IN_SET('b','a,b,c,d');

-> 2

FORMAT(X,D)

Nummer festlegen

HEX(N_or_S)

Wenn N_OR_S eine Zahl ist, wird eine Zeichenfolgendarstellung des Hexadezimalwerts N zurückgegeben, wobei N eine Longlong-Zahl (BIGINT) ist. Dies entspricht CONV(N,10,16).

Wenn N_OR_S eine Zeichenfolge ist, ist der Rückgabewert eine hexadezimale Zeichenfolgendarstellung von N_OR_S, wobei jedes Zeichen in jedem N_OR_S in zwei hexadezimale Ziffern umgewandelt wird.

mysql> SELECT HEX(255);

-> 'FF'

mysql> SELECT 0x616263;

-> 'abc'

mysql> SELECT HEX('abc');

-> 616263

INSERT(str,pos,len,newstr)

Return string str , dessen Teilzeichenfolge an der Position pos beginnt und durch das len-Zeichen der Zeichenfolge newstr ersetzt wird. Wenn pos die Stringlänge überschreitet, ist der Rückgabewert der Originalstring. Wenn die Länge von len größer ist als die Länge anderer Zeichenfolgen, beginnt die Ersetzung ab Position pos. Wenn ein Parameter null ist, ist der Rückgabewert NULL.

mysql> SELECT INSERT('Quadratic', 3, 4, 'What');

-> 'QuWhattic'

MYSQL> , -1, 4, 'Was');

-> 'Quadratisch'

mysql> SELECT INSERT('Quadratisch', 3, 100, 'Was');

-> 'QuWhat'

Diese Funktion unterstützt Multibyte-Zeichen.

INSTR(str,substr)

Gibt die erste Vorkommensposition des Teilstrings im String str zurück. Dies ist dasselbe wie die Zwei-Argument-Form von LOCATE(), außer dass die Reihenfolge der Argumente umgekehrt ist.

mysql> SELECT INSTR('foobar', 'bar');

-> 4

SELECT INSTR('xbar', 'foobar');

-> 0

Diese Funktion unterstützt Multibyte-Zeichen und unterscheidet nur dann zwischen Groß- und Kleinschreibung, wenn mindestens ein Argument eine Binärzeichenfolge ist.

LCASE(str)

LCASE() ist ein Synonym für LOWER().

LEFT(str,len)

Gibt das am weitesten links stehende Zeichen von len zurück, beginnend mit der Zeichenfolge str.

mysql> SELECT LEFT('foobarbar', 5);

-> 'fooba'

LENGTH(str)

Der Rückgabewert ist Zeichen Die Länge der Zeichenfolge str in Bytes. Ein Multibyte-Zeichen zählt als Multibyte. Das bedeutet, dass für eine Zeichenfolge mit fünf 2-Byte-Zeichen LENGTH() 10 zurückgibt, während CHAR_LENGTH() 5 zurückgibt.

mysql> SELECT LENGTH('text');

-> 4

LOAD_FILE(file_name)

Lies die Datei und lege diese Datei zurück im String-Format. Der Speicherort der Datei muss auf dem Server liegen, Sie müssen der Datei einen vollständigen Pfadnamen geben und Sie müssen über die Berechtigung FILE verfügen. Die Datei muss lesbar sein und die Dateigröße muss kleiner als max_allowed_packet Bytes sein.

Wenn die Datei nicht existiert oder nicht gelesen werden kann, weil sie die oben genannten Bedingungen nicht erfüllt, ist der Rückgabewert der Funktion NULL.

mysql> UPDATE tbl_name

SET blob_column=LOAD_FILE('/tmp/picture')

WHERE id=1;

LOCATE(substr,str ), LOCATE(substr,str,pos)

Die erste Syntax gibt die erste Vorkommensposition des Teilstrings substr im String str zurück. Die zweite Syntax gibt die erste Vorkommensposition des Teilstrings substr im String str zurück, beginnend bei pos. Wenn substr nicht in str ist, ist der Rückgabewert 0.

mysql> SELECT LOCATE('bar', 'foobar');

-> 4

mysql>

-> 0

mysql> Multibyte-Zeichen werden unterstützt und die Groß-/Kleinschreibung wird nur dann beachtet, wenn mindestens ein Argument eine Binärzeichenfolge ist.

LOWER(str)

Gibt die Zeichenfolge str und alle Zeichen zurück, die gemäß der neuesten Zeichensatzzuordnungstabelle in Kleinbuchstaben geändert wurden (Standard ist cp1252 Latin1).

mysql> SELECT LOWER('QUADRATICALLY');

-> 'quadratically'

Diese Funktion unterstützt Multibyte-Zeichen.

LPAD(str,len,padstr)

Gibt die Zeichenfolge str zurück, wobei die linke Seite mit der Zeichenfolge padstr auf die Länge von len-Zeichen aufgefüllt wird. Wenn die Länge von str größer 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 die Zeichenfolge str ohne führende Leerzeichen zurück.

mysql> SELECT LTRIM('barbar');

-> 'barbar'

Diese Funktion unterstützt Multibyte-Zeichen.

MAKE_SET(bits,str1,str2,...)

返回一个设定值 (一个包含被‘,’号分开的字字符串的字符串) ，由在bits 组中具有相应的比特的字符串组成。str1 对应比特 0,str2 对应比特1,以此类推。str1, str2, ...中的 NULL值不会被添加到结果中。

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) 是 SUBSTRING(str,pos,len)的同义词。

OCT(N)

返回一个 N的八进制值的字符串表示，其中 N 是一个longlong (BIGINT)数。这等同于CONV(N,10,8)。若N 为 NULL ，则返回值为NULL。

mysql> SELECT OCT(12);

-> '14'

OCTET_LENGTH(str)

OCTET_LENGTH() 是 LENGTH()的同义词。

ORD(str)

若字符串str 的最左字符是一个多字节字符，则返回该字符的代码， 代码的计算通过使用以下公式计算其组成字节的数值而得出:

   (1st byte code)
+ (2nd byte code × 256)
+ (3rd byte code × 2562) ...

假如最左字符不是一个多字节字符，那么 ORD()和函数ASCII()返回相同的值。

mysql> SELECT ORD('2');

-> 50

POSITION(substr IN str)

POSITION(substr IN str)是 LOCATE(substr,str)同义词。

QUOTE(str)

引证一个字符串，由此产生一个在SQL语句中可用作完全转义数据值的结果。  返回的字符串由单引号标注，每例都带有单引号 (‘'’)、 反斜线符号 (‘\’)、 ASCII NUL以及前面有反斜线符号的Control-Z 。如果自变量的值为NULL, 则返回不带单引号的单词 “NULL”。

mysql> SELECT QUOTE('Don\'t!');

-> 'Don\'t!'

mysql> SELECT QUOTE(NULL);

-> NULL

REPEAT(str,count)

返回一个由重复的字符串str 组成的字符串，字符串str的数目等于count 。 若 count aa9166a2c05d262cc43406462b632926 SELECT REPEAT('MySQL', 3);

-> 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str)

返回字符串str 以及所有被字符串to_str替代的字符串from_str 。

mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww');

-> 'WwWwWw.mysql.com'

这个函数支持多字节字元。

REVERSE(str)

返回字符串 str ，顺序和字符顺序相反。

mysql> SELECT REVERSE('abc');

-> 'cba'

这个函数支持多字节字元。

RIGHT(str,len)

从字符串str 开始，返回最右len 字符。

mysql> SELECT RIGHT('foobarbar', 4);

-> 'rbar'

这个函数支持多字节字元。

RPAD(str,len,padstr)

返回字符串str, 其右边被字符串 padstr填补至len 字符长度。假如字符串str 的长度大于 len,则返回值被缩短到与 len 字符相同长度。

mysql> SELECT RPAD('hi',5,'?');

-> 'hi???'

mysql> SELECT RPAD('hi',1,'?');

-> 'h'

这个函数支持多字节字元。

RTRIM(str)

返回字符串 str ，结尾空格字符被删去。

mysql> SELECT RTRIM('barbar   ');

-> 'barbar'

这个函数支持多字节字元。

SOUNDEX(str)

从str返回一个soundex字符串。 两个具有几乎同样探测的字符串应该具有同样的 soundex 字符串。一个标准的soundex字符串的长度为4个字符，然而SOUNDEX() 函数会返回一个人以长度的字符串。 可使用结果中的SUBSTRING() 来得到一个标准 soundex 字符串。在str中，会忽略所有未按照字母顺序排列的字符。 所有不在A-Z范围之内的国际字母符号被视为元音字母。

mysql> SELECT SOUNDEX('Hello');

-> 'H400'

mysql> SELECT SOUNDEX('Quadratically');

-> 'Q36324'

Hinweis: Diese Funktion implementiert den ursprünglichen Soundex-Algorithmus, nicht die populärere erweiterte Version (wie von D. Knuth beschrieben). Der Unterschied besteht darin, dass in der Originalversion zuerst die Vokale und dann die Wiederholungen entfernt werden, während in der erweiterten Version zuerst die Wiederholungen und dann die Vokale entfernt werden.

expr1 KLINGT WIE expr2

Dies entspricht SOUNDEX(expr1) = SOUNDEX(expr2).

SPACE(N)

Gibt eine Zeichenfolge zurück, die aus N Leerzeichen besteht.

mysql> SELECT SPACE(6);

-> ' '

SUBSTRING(str,pos) , SUBSTRING(str,pos, len) , SUBSTRING(str FROM pos FOR len)

Format ohne len-Parameter gibt einen Teilstring aus dem String str zurück, beginnend an Position pos. Das Format mit dem Parameter len gibt einen Teilstring mit der gleichen Länge wie len-Zeichen aus dem String str zurück, beginnend an Position pos. Das Format, das FROM verwendet, ist die Standard-SQL-Syntax. Es ist auch möglich, für pos einen negativen Wert zu verwenden. Wenn dies der Fall ist, beginnt die Position der Teilzeichenfolge beim Zeichen „pos“ am Ende der Zeichenfolge und nicht am Anfang der Zeichenfolge. Sie können einen negativen Wert für pos in Funktionen des folgenden Formats verwenden.

mysql> SELECT SUBSTRING('Quadratically',5);

-> 'ratically'

mysql> SELECT SUBSTRING('foobarbar' FROM 4);

-> 'barbar'

mysql> SELECT SUBSTRING('Sakila', -3);

-> 'ila'

mysql> SELECT SUBSTRING('Sakila', -5, 3);

-> 'aki'

mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2);

-> 'ki'

Diese Funktion unterstützt mehrere Wörter Abschnittszeichen.

Beachten Sie, dass das Ergebnis immer eine leere Zeichenfolge ist, wenn für len ein Wert kleiner als 1 verwendet wird.

SUBSTR() ist ein Synonym für SUBSTRING().

SUBSTRING_INDEX(str,delim,count)

Gibt den Self-String aus dem String str zurück, bevor die Trennzeichen delim und count erscheinen. Wenn count ein positiver Wert ist, wird alles zurückgegeben, was sich links vom letzten Trennzeichen befindet (von links beginnend). Wenn count negativ ist, wird alles rechts vom Trennzeichen (von rechts beginnend) zurückgegeben.

MySQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);

-> 'www.MySQL'

MYSQL> ('www.mysql.com', '.', -2);

-> 'mysql.com'

Diese Funktion unterstützt Multibyte-Zeichen.

TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str) TRIM(remstr FROM] str)

Gibt die Zeichenfolge str zurück, in der sich alle Remstr-Präfixe und/oder Suffixe befinden gelöscht worden. Wenn keiner der Klassifikatoren BOTH, LEADIN oder TRAILING angegeben ist, wird BOTH angenommen. remstr ist optional und kann Leerzeichen entfernen, wenn nicht angegeben.

mysql> SELECT TRIM(' bar ');

-> 'bar'

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 unterstützt Multibyte-Zeichen.

UCASE(str)

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

UNCOMPRESS(string_to_uncompress)

Dekomprimieren Sie die durch die Funktion COMPRESS() komprimierte Zeichenfolge. Wenn das Argument ein komprimierter Wert ist, ist das Ergebnis NULL. Diese Funktion erfordert, dass MySQL mit einer Komprimierungsbibliothek wie zlib kompiliert wurde. Andernfalls ist der Rückgabewert immer NULL.

mysql> SELECT UNCOMPRESS('any string'));

-> 'any string'

SELECT UNCOMPRESS('any string');

-> NULL

UNCOMPRESSED_LENGTH(compressed_string)

Gibt die Länge der komprimierten Zeichenfolge vor der Komprimierung zurück.

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

-> 30

UNHEX(str)

Führt die umgekehrte Operation von HEX(str) aus. Das heißt, es versteht jedes Paar hexadezimaler Ziffern im Parameter als Zahl und wandelt es in das durch diese Zahl dargestellte Zeichen um. Die resultierenden Zeichen werden als Binärzeichenfolge zurückgegeben.

mysql> SELECT UNHEX('4D7953514C');

-> 'MySQL'

mysql> 'string'));

-> 'string'

mysql> 🎜>

UPPER(str)

Gibt die Zeichenfolge str und die in Großbuchstaben konvertierten Zeichen gemäß der neuesten Zeichensatzzuordnung zurück (Standard ist cp1252 Latin1).

mysql> UPPER('Hej');

-> 'HEJ'

Diese Funktion unterstützt Multibyte-Zeichen.

1. Gemäß der String-Vergleichsfunktion

wandelt MySQL Zahlen automatisch in Strings um und umgekehrt.

mysql> SELECT 1 '1';

-> 2

SELECT CONCAT(2,' test');

-> ; '2 test'

Wenn Sie die Zahl explizit in eine Zeichenfolge konvertieren möchten, können Sie die Funktion CAST() oder CONCAT() verwenden:

mysql> AS CHAR );

-> 38.8, '38.8'

mysql> SELECT 38.8, CONCAT(38.8);

-> 38.8, '38.8'

CAST() ist vorzuziehen. .

Wenn einer String-Funktion ein Binärstring als Parameter übergeben wurde, ist der resultierende String ebenfalls ein Binärstring. Eine in eine Zeichenfolge umgewandelte Zahl wird als binäre Zeichenfolge behandelt. Dies wirkt sich nur auf die Vergleichsergebnisse aus.

Im Allgemeinen gilt: Wenn bei einem Ausdruck in einem Zeichenfolgenvergleich die Groß-/Kleinschreibung beachtet wird, wird beim Vergleich auch die Groß-/Kleinschreibung beachtet.

expr LIKE pat [ESCAPE 'escape-char']

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

Das Muster muss keine Literalzeichenfolge sein. Es kann beispielsweise als Zeichenfolgenausdruck oder Tabellenspalte angegeben werden.

kann die folgenden zwei Platzhalter mit LIKE im Muster verwenden:

Zeichen Beschreibung

% Entspricht einer beliebigen Anzahl von Zeichen, sogar null Zeichen

_ Kann nur ein Zeichen

SELECT 'David!';

-> SELECT 'David!' v%';

-> 1

Um Literalinstanzen von Platzhalterzeichen zu testen, platzieren Sie das Escape-Zeichen vor dem Zeichen. Wenn das ESCAPE-Zeichen nicht angegeben ist, wird ' ' angenommen.

String Beschreibung

% Entspricht einem „%“-Zeichen

_ Entspricht einem „_“-Zeichen

mysql> SELECT 'David!' ';

-> 0

mysql> SELECT 'David_' LIKE 'David_';

-> Escape-Zeichen können Sie mit der ESCAPE-Anweisung verwenden:

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

-> Die Bedeutungssequenz kann leer oder ein Zeichen lang sein. Ab MySQL 5.1.2 darf die Sequenz nicht leer sein, wenn der SQL-Modus NO_BACKSLASH_ESCAPES aktiviert ist.

Die folgenden zwei Anweisungen veranschaulichen, dass bei Zeichenfolgenvergleichen die Groß-/Kleinschreibung nicht beachtet wird, es sei denn, einer der Operanden ist eine Binärzeichenfolge:

mysql>

-> 1

mysql> SELECT 'abc' LIKE 'ABC';

-> 0

In MySQL darf LIKE in numerischer Form erscheinen Ausdrücke. (Dies ist eine Erweiterung des Standard-SQL-LIKE).

mysql> SELECT 10 LIKE '1%';

-> ein Zeilenumbruchzeichen darstellt), muss im LIKE-String das verwendete '' doppelt geschrieben werden. Um beispielsweise „n“ zu finden, müssen Sie es als „\n“ schreiben. Wenn Sie '' finden möchten, müssen Sie es als '\\' schreiben. Der Grund dafür ist, dass das Backslash-Symbol vom Syntaxparser einmal entfernt wird und beim Durchführen des Mustervergleichs erneut entfernt wird Für den Abgleich werden Backslash-Symbole akzeptiert.

expr NOT LIKE pat [ESCAPE 'escape-char']

Dies ist äquivalent zu NOT (expr LIKE pat [ESCAPE 'escape-char']).

expr NOT REGEXP pat expr NOT RLIKE pat

Dies entspricht NOT (expr REGEXP pat).

expr REGEXP pat expr RLIKE pat

Führt einen Mustervergleich zwischen dem Zeichenfolgenausdruck expr und dem Muster pat durch. Das Muster kann zu einem regulären Ausdruck erweitert werden. Wenn expr mit pat übereinstimmt, wird 1 zurückgegeben; andernfalls wird 0 zurückgegeben. Wenn entweder expr oder pat NULL ist, ist das Ergebnis NULL. RLIKE ist ein Synonym für REGEXP und dient der Kompatibilität mit mSQL.

Das Muster muss keine Literalzeichenfolge sein. Es kann beispielsweise als Zeichenfolgenausdruck oder Tabellenspalte angegeben werden.

Hinweis: Da MySQL in Zeichenfolgen die C-Escape-Syntax verwendet (z. B. „n“ zur Darstellung von Zeilenumbruchzeichen), muss das in der REGEXP-Zeichenfolge verwendete „“ verdoppelt werden.

REGEXP unterscheidet nicht zwischen Groß- und Kleinschreibung, es sei denn, es wird mit einer Binärzeichenfolge verwendet.

mysql> SELECT 'Monty!' ;

-> 1

mysql> SELECT 'new*n*line' REGEXP 'new\*.\*line';

-> mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A';

-> SELECT 'a' REGEXP '^[a-d]' ;

-> 1

Bei der Bestimmung des Zeichentyps verwenden REGEXP und RLIKE den aktuellen Zeichensatz (standardmäßig cp1252 Latin1). Warnung: Diese Operatoren unterstützen keine Multibyte-Zeichen.

STRCMP(expr1,expr2)

Wenn alle Zeichenfolgen gleich sind, wird STRCMP() zurückgegeben. Wenn der erste Parameter gemäß der aktuellen Klassifizierungsreihenfolge kleiner als der zweite Parameter ist, dann -. 1. In anderen Fällen wird 1 zurückgegeben.

mysql> SELECT STRCMP('text', 'text2');

-> -1

mysql> ;

-> 1

mysql> SELECT STRCMP('text', 'text');

-> 0

, STRCMP() verwendet den aktuellen Zeichensatz. Dadurch wird beim Standardvergleich die Groß-/Kleinschreibung beachtet, es sei denn, einer oder beide Operanden sind Binärzeichenfolgen.