SQL – Строковые функции

Строковые функции в SQL используются в основном для работы со строками. В следующей таблице приведены важные функции строки:

ASCII(строка)

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

SQL> SELECT ASCII('2');
+---------------------------------------------------------+
| ASCII('2')                                              |
+---------------------------------------------------------+
| 50                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT ASCII('dx');
+---------------------------------------------------------+
| ASCII('dx')                                             |
+---------------------------------------------------------+
| 100                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

BIN(N)

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

SQL> SELECT BIN(12);
+---------------------------------------------------------+
| BIN(12)                                                 |
+---------------------------------------------------------+
| 1100                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

BIT_LENGTH(str)

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

SQL> SELECT BIT_LENGTH('text');
+---------------------------------------------------------+
| BIT_LENGTH('text')                                      |
+---------------------------------------------------------+
| 32                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CHAR(N,… [USING charset_name])

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

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

CHAR_LENGTH(str)

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

SQL> SELECT CHAR_LENGTH("text");
+---------------------------------------------------------+
| CHAR_LENGTH("text")                                     |
+---------------------------------------------------------+
| 4                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CHARACTER_LENGTH(str)

CHARACTER_LENGTH() является синонимом char_length() .

CONCAT (str1, str2, …)

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

SQL> SELECT CONCAT('My', 'S', 'QL');
+---------------------------------------------------------+
| CONCAT('My', 'S', 'QL')                                 |
+---------------------------------------------------------+
| MySQL                                 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONCAT_WS(separator,str1,str2,…)

CONCAT_WS() означает объединить с сепаратором и особую форму CONCAT(). Первый аргумент является разделителем для остальных аргументов. Разделитель добавляется между строками, которые объединяются. Сепаратор может быть строкой, как и остальные аргументы. Если разделитель равен NULL, то результат будет NULL.

SQL> SELECT CONCAT_WS(',','First name','Last Name' );
+---------------------------------------------------------+
| CONCAT_WS(',','First name','Last Name' )                |
+---------------------------------------------------------+
| First name,Last Name                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

CONV(N, N from_base, to_base)

Преобразование числа между различными системами счисления. Возвращает строковое представление числа N, преобразованное из базового from_base в to_base. Возвращает NULL, если любой параметр NULL. Аргумент N интерпретируется как целое, но может быть указан в виде целого числа или строки. Минимальная база 2, а максимальная база 36. Если to_base отрицательное число, N рассматривается как число со знаком. В противном случае, N трактуется как беззнаковое. CONV() работает с 64-битной точностью.

SQL> SELECT CONV('a',16,2);
+---------------------------------------------------------+
| CONV('a',16,2)                                          |
+---------------------------------------------------------+
| 1010                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

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

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

SQL> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| ELT(1, 'ej', 'Heja', 'hej', 'foo')                      |
+---------------------------------------------------------+
| ej                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

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

Возвращает строку, что для каждого бита, установленного в значении бит, вы получаете на строку и для каждого бита не установлен в значении, вы не получите строку. Биты в битах рассматриваются справа налево (от низкого до бита высокого порядка). Строки добавляются к результату слева направо, отделены друг от друга разделительной полосой (по умолчанию является символ запятой.,.). Число битов задается NUMBER_OF_BITS (по умолчанию 64).

SQL> SELECT EXPORT_SET(5,'Y','N',',',4);
+---------------------------------------------------------+
| EXPORT_SET(5,'Y','N',',',4)                             |
+---------------------------------------------------------+
| Y,N,Y,N                                                 |
+---------------------------------------------------------+
1 row in set (0.00 sec)

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

Возвращает индекс (положение, начиная с 1) str в str1, str2, str3, … список. Возвращает 0, если строка не найдена.

SQL> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
+---------------------------------------------------------+
| FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo')          |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FIND_IN_SET(str, strlist)

Возвращает значение в диапазоне от 1 до N, если строка str находится в списке строки strlist, состоящем из N подстрок.

SQL> SELECT FIND_IN_SET('b','a,b,c,d');
+---------------------------------------------------------+
| SELECT FIND_IN_SET('b','a,b,c,d')                       |
+---------------------------------------------------------+
| 2                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

FORMAT(X,D)

Формат числа X, как «#, ###, ###. ##» с округлением до D знаков после запятой, и возвращает результат в виде строки. Если D равно 0, результат не имеет десятичной точки или дробной части.

SQL> SELECT FORMAT(12332.123456, 4);
+---------------------------------------------------------+
| FORMAT(12332.123456, 4)                                 |
+---------------------------------------------------------+
| 12,332.1235                                             |
+---------------------------------------------------------+
1 row in set (0.00 sec)

HEX(N_OR_S)

Если N_OR_S это число, возвращает строковое представление шестнадцатеричного значения N, где N представляет собой длинное целое (BIGINT) число. Это эквивалентно CONV (N, 10,16).

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

SQL> SELECT HEX(255);
+---------------------------------------------------------+
| HEX(255)                                                |
+---------------------------------------------------------+
| FF                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT 0x616263;
+---------------------------------------------------------+
| 0x616263                                                |
+---------------------------------------------------------+
| abc                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

INSERT(str,pos,len,newstr)

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

SQL> SELECT INSERT('Quadratic', 3, 4, 'What');
+---------------------------------------------------------+
| INSERT('Quadratic', 3, 4, 'What')                       |
+---------------------------------------------------------+
| QuWhattic                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

INSTR(str,substr)

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

SQL> SELECT INSTR('foobarbar', 'bar');
+---------------------------------------------------------+
| INSTR('foobarbar', 'bar')                               |
+---------------------------------------------------------+
| 4                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LCASE(str)

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

LEFT(str,len)

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

SQL> SELECT LEFT('foobarbar', 5);
+---------------------------------------------------------+
| LEFT('foobarbar', 5)                                    |
+---------------------------------------------------------+
| fooba                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LENGTH(str)

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

SQL> SELECT LENGTH('text');
+---------------------------------------------------------+
| LENGTH('text')                                          |
+---------------------------------------------------------+
| 4                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOAD_FILE(file_name)

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

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

По состоянию SQL 5.0.19, интерпретации переменных управления системой character_set_filesystem имен файлов, которые даны в виде текстовых строк.

SQL> UPDATE table_test
   -> 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.

SQL> SELECT LOCATE('bar', 'foobarbar');
+---------------------------------------------------------+
| LOCATE('bar', 'foobarbar')                              |
+---------------------------------------------------------+
| 4                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LOWER(str)

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

SQL> SELECT LOWER('QUADRATICALLY');
+---------------------------------------------------------+
| LOWER('QUADRATICALLY')                                  |
+---------------------------------------------------------+
| quadratically                                           |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LPAD(str,len,padstr)

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

SQL> SELECT LPAD('hi',4,'??');
+---------------------------------------------------------+
| LPAD('hi',4,'??')                                       |
+---------------------------------------------------------+
| ??hi                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

LTRIM(str)

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

SQL> SELECT LTRIM('  barbar');
+---------------------------------------------------------+
| LTRIM('  barbar')                                       |
+---------------------------------------------------------+
| barbar                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MAKE_SET(bits,str1,str2,…)

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

SQL> SELECT MAKE_SET(1,'a','b','c');
+---------------------------------------------------------+
| MAKE_SET(1,'a','b','c')                                 |
+---------------------------------------------------------+
| a                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

MID(str,pos,len)

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

OCT(N)

Возвращает строковое представление восьмеричного значения N, где N представляет собой длинное целое (BIGINT) число. Это эквивалентно CONV (N, 10,8). Возвращает NULL, если N является NULL.

SQL> SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12)                                                 |
+---------------------------------------------------------+
| 14                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

OCTET_LENGTH(str)

OCTET_LENGTH() является синонимом LENGTH() .

ORD(str)

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

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

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

SQL> SELECT ORD('2');
+---------------------------------------------------------+
| ORD('2')                                                |
+---------------------------------------------------------+
| 50                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

POSITION(substr IN str)

POSITION(substr IN str) является синонимом LOCATE(substr,str).

QUOTE(str)

Котировки строки для получения результата, который может быть использован как правильно отображения значение данных в операторе SQL. Возвращается строка заключена в одинарные кавычки, и с каждым экземпляром одинарные кавычки ( «), обратной косой черты (» \ ‘), ASCII NUL и Control-Z предшествует обратный слэш. Если аргумент NULL, то возвращаемое значение слово «NULL» без ограждающих одиночных кавычек.

SQL> SELECT QUOTE('Don\'t!');
+---------------------------------------------------------+
| QUOTE('Don\'t!')                                        |
+---------------------------------------------------------+
| 'Don\'t!'                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Примечание – Пожалуйста , проверьте , если ваша установка имеет какую – либо ошибку с этой функцией не используйте эту функцию.

expr REGEXP pattern

Эта функция выполняет соответствовать образцу выражение в отношении pattern. Возвращает 1, Если выражение соответствует pattern; в противном случае возвращает 0. Если какое-либо выражение или pattern имеет значение NULL, результатом будет NULL. Регулярное выражение не чувствительно к регистру, за исключением, когда используется с двоичными строками.

SQL> SELECT 'ABCDEF' REGEXP 'A%C%%';
+---------------------------------------------------------+
| 'ABCDEF' REGEXP 'A%C%%'                                 |
+---------------------------------------------------------+
| 0                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Другой пример:

SQL> SELECT 'ABCDE' REGEXP '.*';
+---------------------------------------------------------+
|  'ABCDE' REGEXP '.*'                                    |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Давайте посмотрим еще один пример:

SQL> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line';
+---------------------------------------------------------+
| 'new*\n*line' REGEXP 'new\\*.\\*line'                   |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

REPEAT(str,count)

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

SQL> SELECT REPEAT('SQL', 3);
+---------------------------------------------------------+
| REPEAT('SQL', 3)                                      |
+---------------------------------------------------------+
| SQLSQLSQL                                         |
+---------------------------------------------------------+
1 row in set (0.00 sec)

REPLACE (str, from_str, to_str)

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

SQL> SELECT REPLACE('www.mysql.com', 'w', 'Ww');
+---------------------------------------------------------+
| REPLACE('www.mysql.com', 'w', 'Ww')                     |
+---------------------------------------------------------+
| WwWwWw.mysql.com                                        |
+---------------------------------------------------------+
1 row in set (0.00 sec)

REVERSE(str)

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

SQL> SELECT REVERSE('abcd');
+---------------------------------------------------------+
| REVERSE('abcd')                                         |
+---------------------------------------------------------+
| dcba                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RIGHT(str,len)

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

SQL> SELECT RIGHT('foobarbar', 4);
+---------------------------------------------------------+
| RIGHT('foobarbar', 4)                                   |
+---------------------------------------------------------+
| rbar                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RPAD(str,len,padstr)

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

SQL> SELECT RPAD('hi',5,'?');
+---------------------------------------------------------+
| RPAD('hi',5,'?')                                        |
+---------------------------------------------------------+
| hi???                                                   |
+---------------------------------------------------------+
1 row in set (0.00 sec)

RTRIM(str)

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

SQL> SELECT RTRIM('barbar   ');
+---------------------------------------------------------+
| RTRIM('barbar   ')                                      |
+---------------------------------------------------------+
| barbar                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SOUNDEX(str)

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

SQL> SELECT SOUNDEX('Hello');
+---------------------------------------------------------+
| SOUNDEX('Hello')                                        |
+---------------------------------------------------------+
| H400                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

expr1 SOUNDS LIKE expr2

Это то же самое, как SOUNDEX (Expr1) = SOUNDEX (expr2).

SPACE(N)

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

SQL> SELECT SPACE(6);
+---------------------------------------------------------+
| SELECT SPACE(6)                                         |
+---------------------------------------------------------+
| '      '                                                |
+---------------------------------------------------------+
1 row in set (0.00 sec)

STRCMP (str1, str2)

Сравнивает две строки и возвращает 0, если обе строки равны, и возвращается -1, если первый аргумент меньше второго согласно текущему порядку сортировки в противном случае она возвращает 1.

SQL> SELECT STRCMP('MOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'MOHD')                                  |
+---------------------------------------------------------+
| 0                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Другой пример:

SQL> SELECT STRCMP('AMOHD', 'MOHD');
+---------------------------------------------------------+
| STRCMP('AMOHD', 'MOHD')                                 |
+---------------------------------------------------------+
| -1                                                      |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Давайте посмотрим еще один пример:

SQL> SELECT STRCMP('MOHD', 'AMOHD');
+---------------------------------------------------------+
| STRCMP('MOHD', 'AMOHD')                                 |
+---------------------------------------------------------+
| 1                                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

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. В этом случае, начало подстроки len символов от конца строки, а не c началf. Отрицательное значение может быть использовано для pos в любом из форм этой функции.

SQL> SELECT SUBSTRING('Quadratically',5);
+---------------------------------------------------------+
| SSUBSTRING('Quadratically',5)                           |
+---------------------------------------------------------+
| ratically                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT SUBSTRING('foobarbar' FROM 4);
+---------------------------------------------------------+
| SUBSTRING('foobarbar' FROM 4)                           |
+---------------------------------------------------------+
| barbar                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT SUBSTRING('Quadratically',5,6);
+---------------------------------------------------------+
| SUBSTRING('Quadratically',5,6)                          |
+---------------------------------------------------------+
| ratica                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SUBSTRING_INDEX(str,delim,count)

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

SQL> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2);
+---------------------------------------------------------+
| SUBSTRING_INDEX('www.mysql.com', '.', 2)                |
+---------------------------------------------------------+
| www.mysql                                               |
+---------------------------------------------------------+
1 row in set (0.00 sec)

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

TRIM([remstr FROM] str)

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

SQL> SELECT TRIM('  bar   ');
+---------------------------------------------------------+
| TRIM('  bar   ')                                        |
+---------------------------------------------------------+
| bar                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT TRIM(LEADING 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(LEADING 'x' FROM 'xxxbarxxx')                      |
+---------------------------------------------------------+
| barxxx                                                  |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT TRIM(BOTH 'x' FROM 'xxxbarxxx');
+---------------------------------------------------------+
| TRIM(BOTH 'x' FROM 'xxxbarxxx')                         |
+---------------------------------------------------------+
| bar                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

SQL> SELECT TRIM(TRAILING 'xyz' FROM 'barxxyz');
+---------------------------------------------------------+
| TRIM(TRAILING 'xyz' FROM 'barxxyz')                     |
+---------------------------------------------------------+
| barx                                                    |
+---------------------------------------------------------+
1 row in set (0.00 sec)

UCASE(str)

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

UNHEX(str)

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

SQL> SELECT UNHEX('4D7953514C');
+---------------------------------------------------------+
| UNHEX('4D7953514C')                                     |
+---------------------------------------------------------+
| SQL                                                     |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Символы в строке аргумента должны быть шестнадцатеричные цифры: ‘0’ .. ‘9’, ‘A’ .. ‘F’, ‘а’ .. ‘е’. Если UNHEX() встречает любые не шестнадцатеричные цифры в аргументе, она возвращает NULL.

UPPER(str)

Возвращает строку, все символы переведены в верхний регистр в соответствии с текущим набором символов.

SQL> SELECT UPPER('AndreyEx-the-best');
+---------------------------------------------------------+
| UPPER('AndreyEx-the-best')                              |
+---------------------------------------------------------+
| ANDREYEX-THE-BEST                                       |
+---------------------------------------------------------+
1 row in set (0.00 sec)

Читайте также

Мастер-класс SQL: 10 популярных запросов для эффективной работы с базами данных

1 год назад

Как переименовать имя столбца в SQL

11 месяцев назад

Сравнение Django и SQLAlchemy

4 года назад

0 0 голоса

Рейтинг статьи

Подписаться

авторизуйтесь

Уведомить о

новых последующих комментарияхновых ответах на мои комментарии

Я разрешаю использовать свой email и отправлять уведомления о новых комментариях и ответах (вы cможете отказаться от подписки в любое время).

Label

{} [+]

Имя*

Email*

Веб-сайт

**ссылки nofollow

Δ

Label

{} [+]

Имя*

Email*

Веб-сайт

**ссылки nofollow

Δ

0 комментариев

Старые

Новые Популярные

Межтекстовые Отзывы

Посмотреть все комментарии