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 в битах.

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

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

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

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

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           |
+----------------+----------------+
mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));
+------------------+--------------------+
| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |
+------------------+--------------------+
| 010000           | 010000             |
+------------------+--------------------+

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

mysql> SELECT CHARSET(CHAR(X'65')), CHARSET(CHAR(X'65' USING utf8));
+----------------------+---------------------------------+
| CHARSET(CHAR(X'65')) | CHARSET(CHAR(X'65' USING utf8)) |
+----------------------+---------------------------------+
| binary               | utf8                            |
+----------------------+---------------------------------+

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

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

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)

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. Более подробную информацию об этой опции см. в разделе Раздел 4.5.1, «mysql — Клиентская командная строка MySQL».

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 или больше числа аргументов. ELT() является дополнением к FIELD().

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

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, результат не содержит десятичной точки или дробной части.

Необязательный третий параметр позволяет указать локаль, которая будет использована для десятичной точки, разделителя тысяч и группировки между разделителями в результирующем числе. Допустимые значения локали совпадают с допустимыми значениями для системной переменной lc_time_names (см. Раздел 10.16, «Поддержка локали в MySQL Server»). Если локаль не указана, используется значение по умолчанию — '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. Дополнительную информацию об этой опции см. в Разделе 4.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).

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

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

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.

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, если substr или str — NULL.

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

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

LOWER(str)

Возвращает строку str со всеми символами, изменёнными на строчные, в соответствии с текущим отображением набора символов. По умолчанию используется latin1 (cp1252 West European).

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

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

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

Для наборов символов Юникод, LOWER() и UPPER() работают в соответствии с алгоритмом сортировки Юникод (UCA) версии в имени сортировки, если она есть, и UCA 4.0.0, если версия не указана. Например, utf8_unicode_520_ci работает в соответствии с UCA 5.2.0, а utf8_unicode_ci работает в соответствии с UCA 4.0.0. См. Раздел 10.10.1, «Наборы символов Юникод».

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

В предыдущих версиях MySQL, LOWER(), используемый в представлении, был переписан как LCASE() при сохранении определения представления. В MySQL 5.7, LOWER() никогда не переписывается в таких случаях, но LCASE(), используемый в представлениях, вместо этого переписывается как LOWER(). (Ошибка #12844279)

LPAD(str,len,padstr)

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

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

LTRIM(str)

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

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().

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

Для сравнения см. правила приведения в кавычки строковых литералов и в API C в Разделе 9.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'

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

REVERSE(str)

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

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 символов.

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

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

RTRIM(str)

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

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

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

SOUNDEX(str)

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

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

expr1 SOUNDS LIKE expr2

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

SPACE(N)

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

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'

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

Если 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'

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

TO_BASE64(str)

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

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

Существуют различные схемы кодирования в базе-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'

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

UCASE(str)

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

В MySQL 5.7, UCASE(), используемый в представлении, переписывается как UPPER() при сохранении определения представления. (Bug #12844279)

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:

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

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

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

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

UPPER(str)

Возвращает строку str со всеми символами, преобразованными в верхний регистр в соответствии с текущим отображением набора символов. По умолчанию используется latin1 (cp1252 West European).

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

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

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

В предыдущих версиях MySQL, UPPER(), используемый внутри представления, переписывался как UCASE() при сохранении определения представления. В MySQL 5.7 UPPER() никогда не переписывается в таких случаях, но UCASE(), используемый внутри представлений, переписывается как UPPER(). (Ошибка #12844279)

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

levels: N [ASC|DESC|REVERSE] [, N [ASC|DESC|REVERSE]] ...

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

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

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

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

Примеры:

mysql> SET @s = _latin1 'AB' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| AB   | 4142    | 4142                   |
+------+---------+------------------------+

mysql> SET @s = _latin1 'ab' COLLATE latin1_swedish_ci;
mysql> SELECT @s, HEX(@s), HEX(WEIGHT_STRING(@s));
+------+---------+------------------------+
| @s   | HEX(@s) | HEX(WEIGHT_STRING(@s)) |
+------+---------+------------------------+
| ab   | 6162    | 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   | 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 utf8) COLLATE utf8_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 'utf8';
mysql> SELECT HEX(WEIGHT_STRING('ab' AS CHAR(4)));
+-------------------------------------+
| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |
+-------------------------------------+
| 0041004200200020                    |
+-------------------------------------+

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

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

Спецификатор levels после ключевого слова LEVEL может быть задан либо как список одного или нескольких целых чисел, разделенных запятыми, либо как диапазон двух целых чисел, разделенных тире. Пробелы вокруг знаков препинания не имеют значения.

Примеры:

LEVEL 1
LEVEL 2, 3, 5
LEVEL 1-3

Любой уровень меньше 1 обрабатывается как 1. Любой уровень больше максимального для сортировки входной строки обрабатывается как максимальный для сортировки. Максимальное значение варьируется в зависимости от сортировки, но никогда не превышает 6.

В списке уровней уровни должны быть указаны в порядке возрастания. В диапазоне уровней, если второе число меньше первого, оно обрабатывается как первое число (например, 4-2 эквивалентно 4-4).

Если предложение LEVEL опущено, MySQL предполагает LEVEL 1 - max, где max — максимальный уровень для сортировки.

Если LEVEL указано с использованием синтаксиса списка (а не синтаксиса диапазона), за любым номером уровня могут следовать эти модификаторы:

Примеры:

mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1));
+--------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1)) |
+--------------------------------------+
| 007FFF                               |
+--------------------------------------+

mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC));
+-------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC)) |
+-------------------------------------------+
| FF8000                                    |
+-------------------------------------------+

mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE));
+----------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 REVERSE)) |
+----------------------------------------------+
| FF7F00                                       |
+----------------------------------------------+

mysql> SELECT HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE));
+---------------------------------------------------+
| HEX(WEIGHT_STRING(0x007fff LEVEL 1 DESC REVERSE)) |
+---------------------------------------------------+
| 0080FF                                            |
+---------------------------------------------------+

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

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