ASCII(str)

Возвращает числовое значение самого левого символа строки str. Возвращает 0, если str является пустой строкой. Возвращает NULL, если str является NULL. ASCII() работает для 8-битных символов.

mysql> SELECT ASCII('2');
        -> 50
mysql> SELECT ASCII(2);
        -> 50
mysql> SELECT ASCII('dx');
        -> 100

См. также функцию ORD().

BIN(N)

Возвращает строковое представление двоичного значения N, где N — целое число типа longlong (BIGINT). Это эквивалентно CONV(N,10,2). Возвращает NULL, если N является NULL.

mysql> SELECT BIN(12);
        -> '1100'

BIT_LENGTH(str)

Возвращает длину строки str в битах. Возвращает NULL, если str является NULL.

mysql> SELECT BIT_LENGTH('text');
        -> 32

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

CHAR() интерпретирует каждый аргумент N как целое число и возвращает строку, состоящую из символов, заданных кодовыми значениями этих целых чисел. Значения NULL пропускаются.

mysql> SELECT CHAR(77,121,83,81,'76');
+--------------------------------------------------+
| CHAR(77,121,83,81,'76')                          |
+--------------------------------------------------+
| 0x4D7953514C                                     |
+--------------------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CHAR(77,77.3,'77.3');
+--------------------------------------------+
| CHAR(77,77.3,'77.3')                       |
+--------------------------------------------+
| 0x4D4D4D                                   |
+--------------------------------------------+
1 row in set (0.00 sec)

По умолчанию CHAR() возвращает двоичную строку. Для создания строки в заданной кодировке используйте дополнительную клаузу USING:

mysql> SELECT CHAR(77,121,83,81,'76' USING utf8mb4);
+---------------------------------------+
| CHAR(77,121,83,81,'76' USING utf8mb4) |
+---------------------------------------+
| MySQL                                 |
+---------------------------------------+
1 row in set (0.00 sec)

mysql> SELECT CHAR(77,77.3,'77.3' USING utf8mb4);
+------------------------------------+
| CHAR(77,77.3,'77.3' USING utf8mb4) |
+------------------------------------+
| MMM                                |
+------------------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+-------------------------------------------+
| Level   | Code | Message                                   |
+---------+------+-------------------------------------------+
| Warning | 1292 | Truncated incorrect INTEGER value: '77.3' |
+---------+------+-------------------------------------------+
1 row in set (0.00 sec)

Если USING задана и результирующая строка недопустима для данной кодировки, выдаётся предупреждение. Также, если включён строгий режим SQL, результат от CHAR() становится NULL.

Если CHAR() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате, в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».

Аргументы CHAR() больше 255 преобразуются в несколько байтов результата. Например, CHAR(256) эквивалентно CHAR(1,0), а CHAR(256*256) эквивалентно CHAR(1,0,0):

mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));
+----------------+----------------+
| HEX(CHAR(1,0)) | HEX(CHAR(256)) |
+----------------+----------------+
| 0100           | 0100           |
+----------------+----------------+
1 row in set (0.00 sec)

mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+
1 row in set (0.00 sec)

CHAR_LENGTH(str)

Возвращает длину строки str, измеренную в кодовых точках. Многобайтовый символ учитывается как одна кодовая точка. Это означает, что для строки, содержащей два символа по 3 байта, LENGTH() возвращает 6, а CHAR_LENGTH() возвращает 2, как показано ниже:

mysql> SET @dolphin:='海豚';
Query OK, 0 rows affected (0.01 sec)

mysql> SELECT LENGTH(@dolphin), CHAR_LENGTH(@dolphin);
+------------------+-----------------------+
| LENGTH(@dolphin) | CHAR_LENGTH(@dolphin) |
+------------------+-----------------------+
|                6 |                     2 |
+------------------+-----------------------+
1 row in set (0.00 sec)

CHAR_LENGTH() возвращает NULL, если str является NULL.

CHARACTER_LENGTH(str)

CHARACTER_LENGTH() — синоним для CHAR_LENGTH().

CONCAT(str1,str2,...)

Возвращает строку, полученную путём конкатенации аргументов. Может иметь один или несколько аргументов. Если все аргументы — строки без бинарного представления, результат — строка без бинарного представления. Если аргументы включают бинарные строки, результат — бинарная строка. Числовой аргумент преобразуется в эквивалентную строку без бинарного представления.

CONCAT() возвращает NULL, если любой из аргументов является NULL.

mysql> SELECT CONCAT('My', 'S', 'QL');
        -> 'MySQL'
mysql> SELECT CONCAT('My', NULL, 'QL');
        -> NULL
mysql> SELECT CONCAT(14.3);
        -> '14.3'

Для строковых литералов конкатенация может быть выполнена путём размещения строк рядом друг с другом:

mysql> SELECT 'My' 'S' 'QL';
        -> 'MySQL'

Если CONCAT() вызывается из клиента mysql, результаты бинарных строк отображаются в шестнадцатеричном формате в зависимости от значения --binary-as-hex. Для получения дополнительной информации об этом параметре см. Раздел 6.5.1, «mysql — The MySQL Command-Line Client».

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

CONCAT_WS() означает «Конкатенация со сепаратором» и является специальной формой CONCAT(). Первый аргумент — разделитель для остальных аргументов. Разделитель добавляется между конкатенируемыми строками. Разделитель может быть строкой, как и остальные аргументы. Если разделитель — NULL, результат — 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() не пропускает пустые строки. Однако он пропускает любые NULL значения после аргумента разделителя.

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

ELT() возвращает N-й элемент списка строк: str1, если N = 1, str2, если N = 2, и так далее. Возвращает NULL, если N меньше 1, больше, чем количество аргументов, или NULL. ELT() — дополнение к FIELD().

mysql> SELECT ELT(1, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Aa'
mysql> SELECT ELT(4, 'Aa', 'Bb', 'Cc', 'Dd');
        -> 'Dd'

EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

Возвращает строку, такую что для каждого установленного бита в значении bits вы получите строку on, а для каждого не установленного бита — строку off. Биты в bits рассматриваются справа налево (от младшего к старшему биту). Строки добавляются в результат слева направо, разделённые строкой separator (по умолчанию — запятая ,). Количество рассматриваемых битов задаётся number_of_bits, которое по умолчанию равно 64, если не указано другое значение. number_of_bits неявно обрезается до 64, если больше. Оно обрабатывается как беззнаковое целое число, поэтому значение −1 фактически равно 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,...)

Возвращает индекс (позицию) str в списке str1, str2, str3, .... Возвращает 0, если str не найдено.

Если все аргументы для FIELD() — строки, все аргументы сравниваются как строки. Если все аргументы — числа, они сравниваются как числа. В противном случае аргументы сравниваются как числа с плавающей точкой.

Если str является NULL, возвращаемое значение — 0, так как NULL не проходит сравнение на равенство ни с каким значением. FIELD() — дополнение к ELT().

mysql> SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 2
mysql> SELECT FIELD('Gg', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');
        -> 0

FIND_IN_SET(str,strlist)

Возвращает значение в диапазоне от 1 до N, если строка str содержится в списке строк strlist, состоящем из N подстрок. Список строк — это строка, состоящая из подстрок, разделённых символами ,. Если первый аргумент является константной строкой, а второй — столбцом типа SET, функция FIND_IN_SET() оптимизирована для использования битовых операций. Возвращает 0, если str не содержится в strlist или если strlist является пустой строкой. Возвращает NULL, если любой из аргументов является NULL. Эта функция может работать некорректно, если первый аргумент содержит запятую (,).

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

FORMAT(X,D[,locale])

Форматирует число X в формате, подобном '#,###,###.##', округляя его до D десятичных знаков, и возвращает результат в виде строки. Если D равно 0, результат не содержит десятичной точки или дробной части. Если X или D равно NULL, функция возвращает NULL.

Необязательный третий параметр позволяет указать локаль, которая будет использоваться для десятичной точки, разделителя тысяч и группировки разделителей в результирующем числе. Допустимые значения локали совпадают с допустимыми значениями системной переменной lc_time_names (см. Раздел 12.16, «Поддержка локали в MySQL Server»). Если локаль равна NULL или не указана, используется локаль по умолчанию — 'en_US'.

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'
mysql> SELECT FORMAT(12332.2,2,'de_DE');
        -> '12.332,20'

FROM_BASE64(str)

Принимает строку, закодированную с использованием правил кодирования base-64, применяемых функцией TO_BASE64(), и возвращает декодированный результат в виде двоичной строки. Результатом является NULL, если аргумент равен NULL или не является корректной строкой base-64. Подробности о правилах кодирования и декодирования см. в описании функции TO_BASE64().

mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'

Если функция FROM_BASE64() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате. Вы можете отключить это поведение, установив значение системной переменной --binary-as-hex на значение 0 при запуске клиента mysql. Дополнительную информацию об этом параметре см. в Разделе 6.5.1, «mysql — Клиентская утилита командной строки MySQL».

HEX(str), HEX(N)

Для строкового аргумента str, функция HEX() возвращает шестнадцатеричное строковое представление str, где каждый байт каждого символа в str преобразуется в две шестнадцатеричные цифры. (Многобайтовые символы, следовательно, занимают более двух цифр.) Обратной операцией является функция UNHEX().

Для числового аргумента N, функция HEX() возвращает шестнадцатеричное строковое представление значения N, интерпретируемого как целое число типа longlong (BIGINT). Это эквивалентно CONV(N,10,16). Обратная операция выполняется функцией CONV(HEX(N),16,10).

Для аргумента типа NULL функция возвращает NULL.

mysql> SELECT X'616263', HEX('abc'), UNHEX(HEX('abc'));
        -> 'abc', 616263, 'abc'
mysql> SELECT HEX(255), CONV(HEX(255),16,10);
        -> 'FF', 255

INSERT(str,pos,len,newstr)

Возвращает строку str, в которой подстрока, начинающаяся с позиции pos и имеющая длину len символов, заменяется строкой newstr. Возвращает исходную строку, если pos не находится внутри длины строки. Заменяет остальную часть строки с позиции pos, если len не находится внутри длины оставшейся части строки. Возвращает NULL, если любой из аргументов является NULL.

mysql> SELECT INSERT('Quadratic', 3, 4, 'What');
        -> 'QuWhattic'
mysql> SELECT INSERT('Quadratic', -1, 4, 'What');
        -> 'Quadratic'
mysql> SELECT INSERT('Quadratic', 3, 100, 'What');
        -> 'QuWhat'

Функция безопасна для многобайтовых строк.

INSTR(str,substr)

Возвращает позицию первого вхождения подстроки substr в строке str. Это то же самое, что и двухаргументная форма функции LOCATE(), за исключением того, что порядок аргументов изменён.

mysql> SELECT INSTR('foobarbar', 'bar');
        -> 4
mysql> SELECT INSTR('xbar', 'foobar');
        -> 0

Функция безопасна для многобайтовых строк и регистрозависима только если хотя бы один из аргументов является двоичной строкой. Если любой из аргументов равен NULL, функция возвращает NULL.

LCASE(str)

LCASE() является синонимом для LOWER().

LCASE(), используемое в представлении, переписывается как LOWER() при сохранении определения представления. (Ошибка #12844279)

LEFT(str,len)

Возвращает левые len символов из строки str или NULL, если любой из аргументов равен NULL.

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

Функция безопасна для многобайтовых строк.

LENGTH(str)

Возвращает длину строки str, измеряемую в байтах. Многобайтовый символ считается несколькими байтами. Это означает, что для строки, содержащей пять 2-байтовых символов, функция LENGTH() возвращает 10, в то время как CHAR_LENGTH() возвращает 5. Возвращает NULL, если str равно NULL.

mysql> SELECT LENGTH('text');
        -> 4

LOAD_FILE(file_name)

Читает файл и возвращает содержимое файла в виде строки. Для использования этой функции файл должен находиться на серверном хосте, необходимо указать полный путь к файлу, и у вас должны быть привилегии FILE. Файл должен быть доступен для чтения сервером, и его размер должен быть меньше, чем max_allowed_packet байт. Если системная переменная secure_file_priv установлена на непустое имя директории, файл, который нужно загрузить, должен находиться в этой директории.

Если файла не существует или он не может быть прочитан из-за нарушения одного из вышеперечисленных условий, функция возвращает NULL.

Системная переменная character_set_filesystem управляет интерпретацией имён файлов, заданных в виде литералов.

mysql> UPDATE t
            SET blob_col=LOAD_FILE('/tmp/picture')
            WHERE id=1;

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

Первый синтаксис возвращает позицию первого вхождения подстроки substr в строке str. Второй синтаксис возвращает позицию первого вхождения подстроки substr в строке str, начиная с позиции pos. Возвращает 0, если substr не находится в str. Возвращает NULL, если любой аргумент является NULL.

mysql> SELECT LOCATE('bar', 'foobarbar');
        -> 4
mysql> SELECT LOCATE('xbar', 'foobar');
        -> 0
mysql> SELECT LOCATE('bar', 'foobarbar', 5);
        -> 7

Эта функция безопасна для многобайтовых символов и чувствительна к регистру только в том случае, если хотя бы один аргумент является бинарной строкой.

LOWER(str)

Возвращает строку str со всеми символами, переведенными в нижний регистр в соответствии с текущим сопоставлением символов, или NULL, если str является NULL. Кодировка по умолчанию — utf8mb4.

mysql> SELECT LOWER('QUADRATICALLY');
        -> 'quadratically'

LOWER() (и UPPER()) неэффективны при применении к бинарным строкам (BINARY, VARBINARY, BLOB). Чтобы выполнить преобразование регистра бинарной строки, сначала преобразуйте её в небинарную строку, используя кодировку, подходящую для данных, хранящихся в строке:

mysql> SET @str = BINARY 'New York';
mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING utf8mb4));
+-------------+------------------------------------+
| LOWER(@str) | LOWER(CONVERT(@str USING utf8mb4)) |
+-------------+------------------------------------+
| New York    | new york                           |
+-------------+------------------------------------+

Для сортировок наборов символов Unicode, LOWER() и UPPER() работают в соответствии с версией алгоритма сортировки Unicode (UCA) в имени сортировки, если таковая имеется, и UCA 4.0.0, если версия не указана. Например, utf8mb4_0900_ai_ci и utf8mb3_unicode_520_ci работают в соответствии с UCA 9.0.0 и 5.2.0 соответственно, тогда как utf8mb3_unicode_ci работает в соответствии с UCA 4.0.0. См. Раздел 12.10.1, «Наборы символов Unicode».

Эта функция безопасна для многобайтовых символов.

LCASE(), используемый в представлениях, переписывается как LOWER().

LPAD(str,len,padstr)

Возвращает строку str, дополненную слева строкой padstr до длины len символов. Если str длиннее, чем len, возвращаемое значение сокращается до len символов.

mysql> SELECT LPAD('hi',4,'??');
        -> '??hi'
mysql> SELECT LPAD('hi',1,'??');
        -> 'h'

Возвращает NULL, если любой из его аргументов является NULL.

LTRIM(str)

Возвращает строку str с удаленными ведущими пробелами. Возвращает NULL, если str является NULL.

mysql> SELECT LTRIM('  barbar');
        -> 'barbar'

Эта функция безопасна для многобайтовых символов.

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

Возвращает значение множества (строку, содержащую подстроки, разделенные символами ,), состоящее из строк, у которых соответствующий бит в bits установлен. str1 соответствует биту 0, str2 — биту 1 и так далее. NULL значения в str1, str2, ... не добавляются к результату.

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), MID(str FROM pos), MID(str,pos,len), MID(str FROM pos FOR len)

MID(str,pos,len) является синонимом для SUBSTRING(str,pos,len).

OCT(N)

Возвращает строковое представление восьмеричного значения N, где N — число типа longlong (BIGINT). Это эквивалентно CONV(N,10,8). Возвращает NULL, если N является 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 * 256^2) ...

Если самый левый символ не является многобайтовым символом, ORD() возвращает то же значение, что и функция ASCII(). Функция возвращает NULL, если str является NULL.

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

Для сравнения см. правила кавычек для литеральных строк и в C API в Разделе 11.1.1, «Литеральные строки», и .

REPEAT(str,count)

Возвращает строку, состоящую из строки str, повторенной count раз. Если count меньше 1, возвращает пустую строку. Возвращает NULL, если str или count является NULL.

mysql> SELECT REPEAT('MySQL', 3);
        -> 'MySQLMySQLMySQL'

REPLACE(str,from_str,to_str)

Возвращает строку str со всеми вхождениями строки from_str, замененными строкой to_str. REPLACE() выполняет поиск from_str с учетом регистра.

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

Эта функция безопасна для многобайтовых символов. Она возвращает NULL, если любой из её аргументов является NULL.

REVERSE(str)

Возвращает строку str с обратным порядком символов или NULL, если str является NULL.

mysql> SELECT REVERSE('abc');
        -> 'cba'

Эта функция безопасна для многобайтовых символов.

RIGHT(str,len)

Возвращает самые правые len символов из строки str или NULL, если любой аргумент является NULL.

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

Эта функция безопасна для многобайтовых символов.

RPAD(str,len,padstr)

Возвращает строку str, дополненную справа строкой padstr до длины len символов. Если str длиннее len, возвращаемое значение укорачивается до len символов. Если str, padstr или len имеют значение NULL, функция возвращает NULL.

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

Эта функция безопасна для многобайтовых символов.

RTRIM(str)

Возвращает строку str со всеми символами пробела в конце удалёнными.

mysql> SELECT RTRIM('barbar   ');
        -> 'barbar'

Эта функция безопасна для многобайтовых символов и возвращает NULL, если str имеет значение NULL.

SOUNDEX(str)

Возвращает строку Soundex для str или NULL, если str имеет значение NULL. Две похожие по звучанию строки должны иметь идентичные строки Soundex. Стандартная строка Soundex имеет длину четыре символа, но функция SOUNDEX() возвращает строку произвольной длины. Для получения стандартной строки Soundex можно использовать функцию SUBSTRING() над результатом. Все неалфавитные символы в str игнорируются. Все международные алфавитные символы вне диапазона A-Z обрабатываются как гласные.

mysql> SELECT SOUNDEX('Hello');
        -> 'H400'
mysql> SELECT SOUNDEX('Quadratically');
        -> 'Q36324'

expr1 SOUNDS LIKE expr2

Это то же самое, что и SOUNDEX(expr1) = SOUNDEX(expr2).

SPACE(N)

Возвращает строку, состоящую из N символов пробела, или NULL, если N имеет значение NULL.

mysql> SELECT SPACE(6);
        -> '      '

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

SUBSTR() является синонимом для SUBSTRING().

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

Формы без аргумента len возвращают подстроку из строки str, начиная с позиции pos. Формы с аргументом len возвращают подстроку длиной len символов из строки str, начиная с позиции pos. Формы, использующие FROM, соответствуют стандартной синтаксической конструкции SQL. Также можно использовать отрицательное значение для pos. В этом случае начало подстроки определяется pos символами с конца строки, а не с начала. Отрицательное значение может быть использовано для pos в любой форме этой функции. Значение 0 для pos возвращает пустую строку.

Для всех форм SUBSTRING() позиция первого символа строки, из которой должна быть извлечена подстрока, считается 1.

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'

Эта функция безопасна для многобайтовых символов. Она возвращает NULL, если любой из её аргументов имеет значение NULL.

Если len меньше 1, результатом является пустая строка.

SUBSTRING_INDEX(str,delim,count)

Возвращает подстроку из строки str до count вхождений разделителя delim. Если count положительно, возвращается всё слева от последнего разделителя (считая слева). Если count отрицательно, возвращается всё справа от последнего разделителя (считая справа). SUBSTRING_INDEX() выполняет поиск delim с учётом регистра.

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

Эта функция безопасна для многобайтовых символов.

SUBSTRING_INDEX() возвращает NULL, если любой из аргументов имеет значение NULL.

TO_BASE64(str)

Преобразует строковый аргумент в базу-64 кодировку и возвращает результат как строку символов с набором кодировки соединения и сортировкой. Если аргумент не является строкой, он преобразуется в строку перед преобразованием. Результатом будет NULL, если аргумент имеет значение NULL. Базы-64 кодированные строки могут быть декодированы с помощью функции FROM_BASE64().

mysql> SELECT TO_BASE64('abc'), FROM_BASE64(TO_BASE64('abc'));
        -> 'JWJj', 'abc'

Существуют различные схемы кодирования Base-64. Вот правила кодирования и декодирования, используемые TO_BASE64() и FROM_BASE64():

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

Возвращает строку str со всеми префиксами или суффиксами remstr удаленными. Если ни один из спецификаторов BOTH, LEADING или TRAILING не задан, предполагается BOTH. remstr является необязательным и, если не указан, удаляются пробелы.

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'

Эта функция безопасна для многобайтовых символов. Она возвращает NULL, если любой из аргументов имеет значение NULL.

UCASE(str)

UCASE() является синонимом для UPPER().

UCASE(), используемое внутри представлений, переписывается как UPPER().

UNHEX(str)

Для строкового аргумента str, UNHEX(str) интерпретирует каждую пару символов в аргументе как шестнадцатеричное число и преобразует его в байт, представленный этим числом. Возвращаемое значение — двоичная строка.

mysql> SELECT UNHEX('4D7953514C');
        -> 'MySQL'
mysql> SELECT X'4D7953514C';
        -> 'MySQL'
mysql> SELECT UNHEX(HEX('string'));
        -> 'string'
mysql> SELECT HEX(UNHEX('1267'));
        -> '1267'

Символы в строковом аргументе должны быть допустимыми шестнадцатеричными цифрами: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. Если аргумент содержит любые недопустимые шестнадцатеричные цифры или является NULL, результатом будет NULL:

mysql> SELECT UNHEX('GG');
+-------------+
| UNHEX('GG') |
+-------------+
| NULL        |
+-------------+

mysql> SELECT UNHEX(NULL);
+-------------+
| UNHEX(NULL) |
+-------------+
| NULL        |
+-------------+

Результат NULL также может возникнуть, если аргумент функции UNHEX() является столбцом типа BINARY, потому что значения заполняются 0x00 байтами при хранении, но эти байты не удаляются при извлечении. Например, '41' хранится в столбце типа CHAR(3) как '41 ' и извлекается как '41' (с удаленным trailing-пробелом), поэтому UNHEX() для значения столбца возвращает X'41'. В противоположность этому, '41' хранится в столбце типа BINARY(3) как '41\0' и извлекается как '41\0' (с trailing-пробелом 0x00 байтом, не удалённым). '\0' не является допустимой шестнадцатеричной цифрой, поэтому UNHEX() для значения столбца возвращает NULL.

Для числового аргумента N обратная функция HEX(N) не выполняется функцией UNHEX(). Используйте функцию CONV(HEX(N),16,10) вместо этого. См. описание HEX().

Если UNHEX() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате, в зависимости от значения параметра --binary-as-hex. Дополнительную информацию об этом параметре см. в разделе 6.5.1, «mysql — Клиентская утилита командной строки MySQL».

UPPER(str)

Возвращает строку str со всеми символами, преобразованными в верхний регистр в соответствии с текущим отображением набора символов, или NULL, если str является NULL. По умолчанию набор символов — utf8mb4.

mysql> SELECT UPPER('Hej');
        -> 'HEJ'

См. описание LOWER() для информации, которая также относится к UPPER(). Включая информацию о том, как выполнять преобразование регистра двоичных строк (BINARY, VARBINARY, BLOB), для которых эти функции неэффективны, и информация о свертке регистра для наборов символов Unicode.

Эта функция безопасна для многобайтовых символов.

UCASE(), используемый внутри представлений, переписывается как UPPER().

WEIGHT_STRING(str [AS {CHAR|BINARY}(N)] [flags])

Эта функция возвращает строку весов для входной строки. Возвращаемое значение — двоичная строка, представляющая значение сравнения и сортировки строки, или NULL, если аргумент является NULL. Имеет следующие свойства:

WEIGHT_STRING() — функция отладки, предназначенная для внутреннего использования. Её поведение может меняться без предварительного уведомления между версиями MySQL. Она может использоваться для тестирования и отладки сортировок, особенно при добавлении нового типа сортировки. См. раздел 12.14, «Добавление сортировки к набору символов».

Данный список кратко обобщает аргументы. Более подробные сведения приведены в обсуждении, следующем за списком.

Входная строка str — это строковое выражение. Если вход — строка без типа байтов (символьная), например, значение типа CHAR, VARCHAR или TEXT, возвращаемое значение содержит веса сортировки для строки. Если вход — двоичная строка (байтовая), например, значение типа BINARY, VARBINARY или BLOB, возвращаемое значение такое же, как входное (вес каждого байта в двоичной строке — это значение байта). Если вход — NULL, WEIGHT_STRING() возвращает NULL.

Примеры:

mysql> SET @s = _utf8mb4 'AB' COLLATE utf8mb4_0900_ai_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 1C471C60               |
+------+---------+------------------------+

mysql> SET @s = _utf8mb4 'ab' COLLATE utf8mb4_0900_ai_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 1C471C60               |
+------+---------+------------------------+

mysql> SET @s = CAST('AB' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+

mysql> SET @s = CAST('ab' AS BINARY);
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 6162                   |
+------+---------+------------------------+

В предыдущих примерах используется функция HEX() для отображения результата WEIGHT_STRING(). Поскольку результат — двоичное значение, HEX() может быть особенно полезным, когда результат содержит непечатные символы, для отображения в печатном формате:

mysql> SET @s = CONVERT(X'C39F' USING utf8mb4) COLLATE utf8mb4_czech_ci;
mysql> SELECT HEX(WEIGHT_STRING(@s));
+------------------------+
| HEX(WEIGHT_STRING(@s)) |
+------------------------+
| 0FEA0FEA               |
+------------------------+

Для значений, отличных от NULL, тип данных значения — VARBINARY, если его длина находится в пределах максимальной длины для VARBINARY, в противном случае тип данных — BLOB.

Предложение AS может быть использовано для преобразования входной строки в строку без типа байтов или строку типа байтов и для принудительного указания заданной длины:

mysql> SET NAMES 'latin1';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 41422020                            |
+-------------------------------------+
mysql> SET NAMES 'utf8mb4';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 1C471C60                            |
+-------------------------------------+

mysql> SELECT HEX(WEIGHT_STRING('ab' AS BINARY(4)));
+---------------------------------------+
| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |
+---------------------------------------+
| 61620000                              |
+---------------------------------------+

Предложение flags в настоящее время не используется.

Если WEIGHT_STRING() вызывается из клиента mysql, двоичные строки отображаются в шестнадцатеричном формате, в зависимости от значения параметра --binary-as-hex. Дополнительную информацию об этом параметре см. в разделе 6.5.1, «mysql — Клиентская утилита командной строки MySQL».