12.5. Строковые функции

12.5.1. Функции Сравнения строк
12.5.2. Регулярные выражения

Таблица 12.7. Строковые Операторы

Имя	Описание
`ASCII()`	Возвратите числовое значение крайнего левого символа
`BIN()`	Возвратите строку, содержащую двоичное представление числа
`BIT_LENGTH()`	Возвратите длину параметра в битах
`CHAR_LENGTH()`	Возвратите число символов в параметре
`CHAR()`	Возвратите символ для каждого целого числа, которое передают
`CHARACTER_LENGTH()`	Синоним для CHAR_LENGTH ()
`CONCAT_WS()`	Возврат конкатенирует с разделителем
`CONCAT()`	Возвратите связанную строку
`ELT()`	Возвратите строку в индексе
`EXPORT_SET()`	Возвратите строку так, что для каждого набора битов в битах значения, Вы добираетесь на строке и для каждого бита сброса, Вы добираетесь от строки
`FIELD()`	Возвратитесь индексировать (позиция) первого параметра в последующих параметрах
`FIND_IN_SET()`	Возвратите индексировать позицию первого параметра в пределах второго параметра
`FORMAT()`	Возвратите число, отформатированное конкретному количеству десятичных разрядов
`FROM_BASE64()`	Декодируйте к основе 64 строки и результат возврата
`HEX()`	Возвратите шестнадцатеричное представление десятичного числа или представьте значение в виде строки
`INSERT()`	Вставьте подстроку в указанной позиции до конкретного количества символов
`INSTR()`	Возвратите индексирование первого возникновения подстроки
`LCASE()`	Синоним для НИЖЕ ()
`LEFT()`	Возвратите крайнее левое число символов как определено
`LENGTH()`	Возвратите длину строки в байтах
`LIKE`	Простое сопоставление с образцом
`LOAD_FILE()`	Загрузите именованный файл
`LOCATE()`	Возвратите позицию первого возникновения подстроки
`LOWER()`	Возвратите параметр в нижнем регистре
`LPAD()`	Возвратите строковый параметр, лево-дополненный указанной строкой
`LTRIM()`	Удалите ведущие пробелы
`MAKE_SET()`	Возвратите ряд разделенных от запятой строк, у которых есть соответствующий бит в наборе битов
`MATCH`	Выполните полнотекстовый поиск
`MID()`	Возвратите подстроку, запускающуюся с указанной позиции
`NOT LIKE`	Отрицание простого сопоставления с образцом
`NOT REGEXP`	Отрицание REGEXP
`OCT()`	Возвратите строку, содержащую восьмеричное представление числа
`OCTET_LENGTH()`	Синоним для ДЛИНЫ ()
`ORD()`	Возвратите символьный код для крайнего левого символа параметра
`POSITION()`	Синоним для РАСПОЛАГАЕТСЯ ()
`QUOTE()`	Выйдите из параметра за использование в SQL-операторе
`REGEXP`	Сопоставление с образцом используя регулярные выражения
`REPEAT()`	Повторите строку конкретное количество времен
`REPLACE()`	Возникновения замены указанной строки
`REVERSE()`	Инвертируйте символы в строке
`RIGHT()`	Возвратите указанное самое правое число символов
`RLIKE`	Синоним для REGEXP
`RPAD()`	Добавьте строку конкретное количество времен
`RTRIM()`	Удалите конечные пробелы
`SOUNDEX()`	Возвратите строку soundex
`SOUNDS LIKE`	Сравните звуки
`SPACE()`	Возвратите строку конкретного количества пробелов
`STRCMP()`	Сравните две строки
`SUBSTR()`	Возвратите подстроку как определено
`SUBSTRING_INDEX()`	Возвратите подстроку из строки перед конкретным количеством возникновений разделителя
`SUBSTRING()`	Возвратите подстроку как определено
`TO_BASE64()`	Возвратите параметр, преобразованный в основу 64 строки
`TRIM()`	Удалите продвижение и конечные пробелы
`UCASE()`	Синоним для ВЕРХНЕГО ()
`UNHEX()`	Возвратите строку, содержащую шестнадцатеричное представление числа
`UPPER()`	Преобразуйте в верхний регистр
`WEIGHT_STRING()`	Возвратите строку веса для строки

Оцененный строке возврат функций NULL если бы длина результата была бы больше чем значение max_allowed_packet системная переменная. См. Раздел 8.11.2, "Настраивая Параметры Сервера".

Для функций, которые работают на строковых позициях, первая позиция нумеруется 1.

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

ASCII(str)

Возвращает числовое значение крайнего левого символа строки str. Возвраты 0 если str пустая строка. Возвраты NULL если str NULL. ASCII() работы для 8-разрядных символов.
```
mysql> SELECT ASCII('2');        -> 50mysql> SELECT ASCII(2);        -> 50mysql> 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(0x65)),
                    CHARSET(CHAR(0x65 USING utf8));+---------------------+--------------------------------+| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |+---------------------+--------------------------------+| binary              | utf8                           |+---------------------+--------------------------------+
```
Если USING дается и строка результата недопустима для данного набора символов, предупреждение выпускается. Кроме того, если строгий режим SQL включается, следствие CHAR() становится NULL.
CHAR_LENGTH(str)

Возвращает длину строки str, измеренный в символах. Многобайтовый символ рассчитывает как единственный символ. Это означает это для строки, содержащей пять 2-байтовых символов, LENGTH() возвраты 10, тогда как CHAR_LENGTH() возвраты 5.
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');        -> NULLmysql> SELECT CONCAT(14.3);        -> '14.3'
```
Для заключенных в кавычки строк связь может быть выполнена, помещая строки друг рядом с другом:
```
mysql> SELECT 'My' 'S'
                    'QL';        -> '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элемент th списка строк: str1 если N = 1, str2 если N = 2, и так далее. Возвраты NULL если N меньше чем 1 или больше чем число параметров. ELT() дополнение FIELD().
```
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej',
                    'foo');        -> 'ej'mysql> SELECT ELT(4,
                    'ej', 'Heja', 'hej', 'foo');        -> 'foo'
```
EXPORT_SET(bits,on,off[,separator[,number_of_bits]])

Возвращает строку так, что для каждого набора битов в значении bits, Вы добираетесь on строка и для каждого бита не набор в значении, Вы добираетесь off строка. Биты в bits исследуются справа налево (от младшего разряда до битов старшего разряда). Строки добавляются к следствию слева направо, разделяются separator строка (значение по умолчанию, являющееся символом запятой","). Числом исследованных битов дают number_of_bits, у которого есть значение по умолчанию 64 если не определенный. number_of_bits тихо отсекается к 64 если больше чем 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('ej', 'Hej', 'ej',
                    'Heja', 'hej', 'foo');        -> 2mysql> SELECT
                    FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');        -> 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, у результата нет никакой десятичной точки или дробной части.

Дополнительный третий параметр позволяет локали быть определенной, чтобы использоваться для десятичной точки числа результата, тысячи разделителя, и группирующийся между разделителями. Допустимые значения локали являются тем же самым как юридическими значениями для lc_time_names системная переменная (см. Раздел 10.7, "MySQL Server Locale Support"). Если никакая локаль не определяется, значение по умолчанию '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)

Берет строку, закодированную с основой 64 закодированных правила, используемые TO_BASE64() и возвращает декодируемый результат как двоичную строку. Результат NULL если параметр NULL или не допустимая основа 64 строки. См. описание TO_BASE64() для деталей о кодировании и декодировании правил.
```
mysql> SELECT TO_BASE64('abc'),
                    FROM_BASE64(TO_BASE64('abc'));        -> 'JWJj', 'abc'
```
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 0x616263, 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');        -> 4mysql> SELECT INSTR('xbar',
                    'foobar');        -> 0
```
Эта функция является многобайтовым сейфом, и является чувствительной к регистру, только если по крайней мере одним параметром является двоичная строка.
LCASE(str)

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

В MySQL 5.7, 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.
```
mysql> SELECT LOCATE('bar',
                    'foobarbar');        -> 4mysql> SELECT
                    LOCATE('xbar', 'foobar');        -> 0mysql> SELECT
                    LOCATE('bar', 'foobarbar', 5);        -> 7
```
Эта функция является многобайтовым сейфом, и является чувствительной к регистру, только если по крайней мере одним параметром является двоичная строка.
LOWER(str)

Возвращает строку str со всеми символами, измененными на нижний регистр согласно текущему отображению наборов символов. Значение по умолчанию latin1 (cp1252 западноевропеец).
```
mysql> SELECT
                    LOWER('QUADRATICALLY');        -> 'quadratically'
```
LOWER() (и UPPER()) неэффективны, когда применялся к двоичным строкам (BINARY, VARBINARY, BLOB). Чтобы выполнить lettercase преобразование, преобразуйте строку в недвоичную строку:
```
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                          |+-------------+-----------------------------------+
```
Для наборов символов Unicode, LOWER() и UPPER() работа, считающая к Алгоритму сопоставления Unicode (UCA) 5.2.0 для xxx_unicode_520_ci сопоставления и для специфичных для языка сопоставлений, которые получаются от них. Для других сопоставлений Unicode, LOWER() и UPPER() работа, считающая к Алгоритму сопоставления Unicode (UCA) 4.0.0. См. Раздел 10.1.14.1, "Наборы символов Unicode".

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

В предыдущих версиях 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,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²) ...
```
Если крайний левый символ не является многобайтовым символом, 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, возвращаемое значение является словом "НУЛЬ", не включая единственные кавычки.
```
mysql> SELECT
                    QUOTE('Don\'t!');        -> 'Don\'t!'mysql> SELECT
                    QUOTE(NULL);        -> NULL
```
Для сравнения см. правила заключения в кавычки для литеральных строк и в пределах API C в Разделе 9.1.1, "Строковых литералах", и Разделе 21.8.7.54,"mysql_real_escape_string()".
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 обрабатываются как гласные.

Важный

При использовании SOUNDEX(), следует знать о следующих ограничениях:
- Эта функция, как в настоящий момент реализовано, предназначается, чтобы работать хорошо со строками, которые находятся на английском языке только. Строки на других языках, возможно, не приводят к надежным результатам.
- Эта функция, как гарантируют, не предоставит непротиворечивым результатам строки, которые используют многобайтовые наборы символов, включая utf-8.
  
  Мы надеемся удалить эти ограничения в будущем выпуске. См. Ошибку #22638 для получения дополнительной информации.
```
mysql> SELECT
                    SOUNDEX('Hello');        -> 'H400'mysql> SELECT
                    SOUNDEX('Quadratically');        -> 'Q36324'
```
Отметить

Эта функция реализует исходный алгоритм Soundex, не более популярную улучшенную версию (также описанный Д. Нутом). Различие - то, что оригинальная версия отбрасывает гласных сначала и копирует второй, тогда как улучшенные отбрасывания версии копируют сначала и вторые гласные.
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)

Формы без a len возврат параметра подстрока от строки str запуск в позиции pos. Формы с a len возврат параметра подстрока len символы долго от строки str, запуск в позиции pos. Формы то использование FROM стандартный синтаксис SQL. Также возможно использовать отрицательную величину для pos. В этом случае начало подстроки pos символы от конца строки, а не начало. Отрицательная величина может использоваться для 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'
```
Существуют различные схемы кодировки Base 64. Они - кодирование и декодирование правил, используемых TO_BASE64() и FROM_BASE64():
- Кодирование для алфавита оценивает 62, '+'.
- Кодирование для алфавита оценивает 63, '/'.
- Закодированный вывод состоит из групп 4 печатаемых символов. Каждый 3 байта входных данных кодируется, используя 4 символа. Если последняя группа является неполной, она дополняется '=' символы к длине 4.
- Новая строка добавляется после каждого 76 символов закодированного вывода, чтобы делиться долго выведенный на многократные строки.
- Декодирование распознает и игнорирует новую строку, возврат каретки, вкладку, и пространство.
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, UPPER() используемый в пределах представления был переписан как UCASE() храня определение представления. В MySQL 5.7, UPPER() никогда не переписывается в таких случаях, но UCASE() используемый в пределах представлений вместо этого переписывается как UPPER(). (Ошибка #12844279)

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

Для строкового параметра str, UNHEX(str) выполняет обратную работу HEX(str). Таким образом, это интерпретирует каждую пару символов в параметре как шестнадцатеричное число и преобразовывает это в символ, представленный числом. Возвращаемое значение является двоичной строкой.
```
mysql> SELECT UNHEX('4D7953514C');        -> 'MySQL'mysql> SELECT
                    0x4D7953514C;        -> '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        |+-------------+
```
A NULL результат может произойти если параметр UNHEX() a BINARY столбец, потому что значения дополняются 0x00 байтами когда сохраненный, но теми байтами, не разделяется на извлечении. Например, '41' сохранен в a CHAR(3) столбец как '41 ' и полученный как '41' (с запаздывающим разделенным пространством клавиатуры), таким образом, UNHEX() для возвратов значения столбца 'A'. В отличие от этого, '41' сохранен в a BINARY(3) столбец как '41\0' и полученный как '41\0' (с запаздывающей клавиатурой 0x00 байт, не разделенный). '\0' не юридическая шестнадцатеричная цифра, таким образом, UNHEX() для возвратов значения столбца NULL.

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

Возвращает строку str со всеми символами, измененными на верхний регистр согласно текущему отображению наборов символов. Значение по умолчанию latin1 (cp1252 западноевропеец).
```
mysql> SELECT
                    UPPER('Hej');        -> 'HEJ'
```
См. описание LOWER() для информации, которая также применяется к UPPER(). Эта включенная информация о том, как выполнить lettercase преобразование двоичных строк (BINARY, VARBINARY, BLOB) для которого эти функции неэффективны, и информация о случае, сворачивающемся для наборов символов Unicode.

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

В предыдущих версиях 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(str1) = WEIGHT_STRING(str2), тогда str1 = str2 (str1 и str2 считаются равными),
- Если WEIGHT_STRING(str1) < WEIGHT_STRING(str2), тогда str1 < str2 (str1 виды прежде str2)
WEIGHT_STRING() может использоваться для тестирования и отладки сопоставлений, особенно если Вы добавляете новое сопоставление. См. Раздел 10.4, "Добавляя Сопоставление к Набору символов".

Строка ввода, str, строковое выражение. Если ввод является недвоичной (символьной) строкой, такой как a CHAR, VARCHAR, или TEXT значение, возвращаемое значение содержит веса сопоставления для строки. Если ввод является двоичным файлом (байт) строка, такая как a 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(0xC39F USING
                    utf8) COLLATE utf8_czech_ci;mysql> SELECT
                    HEX(WEIGHT_STRING(@s));+------------------------+| HEX(WEIGHT_STRING(@s)) |+------------------------+| 0FEA0FEA               |+------------------------+
```
Для не -NULL возвращаемые значения, тип данных значения VARBINARY если его длина в пределах максимальной длины для VARBINARY, иначе тип данных BLOB.

AS пункт может быть дан, чтобы бросить строку ввода к недвоичной или двоичной строке и вызвать ее к данной длине:
- AS CHAR(N) бросает строку к недвоичной строке и дополняет это справа пробелами к длине N символы. N должен быть по крайней мере 1. Если N меньше чем длина строки ввода, строка является усеченной к N символы. Никакое предупреждение не происходит для усечения.
- AS BINARY(N) подобно, но бросает строку к двоичной строке, N измеряется в байтах (не символы), и дополняющее использование 0x00 байты (не пробелы).
```
mysql> SELECT HEX(WEIGHT_STRING('ab' AS
                    CHAR(4)));+-------------------------------------+| HEX(WEIGHT_STRING('ab' AS CHAR(4))) |+-------------------------------------+| 41422020                            |+-------------------------------------+
```
```
mysql> SELECT HEX(WEIGHT_STRING('ab' AS
                    BINARY(4)));+---------------------------------------+| HEX(WEIGHT_STRING('ab' AS BINARY(4))) |+---------------------------------------+| 61620000                              |+---------------------------------------+
```
LEVEL пункт может быть дан, чтобы определить, что возвращаемое значение должно содержать веса для определенных уровней сопоставления.

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

Примеры:
```
LEVEL 1LEVEL 2, 3, 5LEVEL 1-3
```
Любой уровень меньше чем 1 обрабатывается как 1. Любой уровень, больше чем максимум для сопоставления строки ввода, обрабатывается как максимум для сопоставления. Максимум изменяется на сопоставление, но никогда не больше чем 6.

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

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

Если LEVEL определяется, используя синтаксис списка (не, располагаются синтаксис), любое число уровня может сопровождаться этими модификаторами:
- ASC: Возвратите веса без модификации. Это - значение по умолчанию.
- DESC: Возвратите поразрядно инвертированные веса (например, 0x78f0 DESC = 0x870f).
- REVERSE: Возвратите веса в обратном порядке (то есть, веса для инвертированной строки, с первым последним символом и последнее первое).
Примеры:
```
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 пункт в настоящий момент неиспользован.