Каталог документации / Раздел "Базы данных, SQL" / Оглавление документа

6 Функции для использования в `SELECT` и `WHERE`

select_expression или where_definition в инструкции SQL может состоять из любого выражения, использующего функции, описанные ниже.

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

ОБРАТИТЕ ВНИМАНИЕ: не должно быть никаких пробелов между именем функции и круглой скобкой после него. Это помогает синтаксическому анализатору MySQL различать обращения к функции и ссылки к таблицам или столбцам, которые, случается, имеют то же самое имя, что и функция. Пробелы вокруг параметров разрешаются.

Вы можете заставить MySQL принимать пробелы после имени функции, запуская mysqld с опцией --ansi или используя параметр CLIENT_IGNORE_SPACE в mysql_connect(), но в этом случае все имена функции станут зарезервированными словами. Подробности в разделе "1.4.3 Запуск MySQL в режиме ANSI ".

Ради краткости, примеры отображают вывод из программы mysql в сокращенной форме. Например:

mysql> select MOD(29,9);
1 rows in set (0.00 sec)
  +-----------+
  | mod(29,9) |
  +-----------+
  |         2 |
  +-----------+

Отображается подобно этому:

mysql> select MOD(29,9);
-> 2

6.1 Нетипизированные операторы и функции

6.1.1 Скобки

( ... )

Используйте круглую скобку, чтобы принудительно задать порядок оценки в вычисляемом выражении. Например:

mysql> select 1+2*3;
    -> 7
mysql> select (1+2)*3;
    -> 9

6.1.2 Операторы сравнения

Операторы сравнения возвращают значения 1 (TRUE), 0 (FALSE) или NULL. Эти функции работают для чисел и строк. Строки автоматически будут преобразованы в числа, а числа в строки, как необходимо (как в языке Perl).

MySQL выполняет все сравнения, использующие следующие правила:

Если одни или оба параметра равны NULL, результат сравнения также равен NULL, кроме операторов <=>.
Если оба параметра в операции сравнения представляют собой строки, они сравниваются как строки.
Если оба параметра представляют собой числа, они сравниваются как числа.
Шестнадцатеричные значения обрабатываются как двоичные строки, если не сравниваются с числом.
Если один из параметров представляет собой столбец типа TIMESTAMP или DATETIME, а другой параметр является константой, то она будет преобразована в timestamp прежде, чем сравнение выполняется. Это выполнено, чтобы быть более дружественным к ODBC.
Во всех других случаях параметры сравниваются как числа с плавающей запятой (реальные).

По умолчанию, сравнения строк выполнены независимо от регистра, используя текущий набор символов (по умолчанию это ISO-8859-1 Latin1, который работает превосходно для английского языка).

Примеры ниже иллюстрируют преобразование строк в соответствующие числа для выполнения операций сравнения:

mysql> SELECT 1 > '6x';
     -> 0
mysql> SELECT 7 > '6x';
     -> 1
mysql> SELECT 0 > 'x6';
     -> 0
mysql> SELECT 0 = 'x6';
-> 1

=

Равны:

mysql> select 1 = 0;
    -> 0
mysql> select '0' = 0;
    -> 1
mysql> select '0.0' = 0;
    -> 1
mysql> select '0.01' = 0;
    -> 0
mysql> select '.01' = 0.01;
    -> 1

<>

!=

Не равны:

mysql> select '.01' <> '0.01';
    -> 1
mysql> select .01 <> '0.01';
    -> 0
mysql> select 'zapp' <> 'zappp';
    -> 1

<=

Меньше, чем или равны:

mysql> select 0.1 <= 2;
    -> 1

<

Строго мньше, чем:

mysql> select 2 < 2;
    -> 0

>=

Больше, чем или равны:

mysql> select 2 >= 2;
    -> 1

>

Строго больше, чем:

mysql> select 2 > 2;
    -> 0

<=>

Null равен:

mysql> select 1 <=> 1, NULL <=> NULL, 1 <=> NULL;
    -> 1 1 0

IS NULL

IS NOT NULL

Проверяет, является или нет значение NULL:

mysql> select 1 IS NULL, 0 IS NULL, NULL IS NULL;
    -> 0 0 1
mysql> select 1 IS NOT NULL, 0 IS NOT NULL, NULL IS NOT NULL;
    -> 1 1 0

expr BETWEEN min AND max

Если expr больше или равно min, и expr меньше или равно max, то BETWEEN вернет 1, иначе это возвращает 0. Это эквивалентно выражению (min <= expr AND expr <= max), если все параметры имеют тот же самый тип. Первый параметр (expr) определяет, как выполняется сравнение следующим образом:

Если expr представляет собой столбец типа TIMESTAMP, DATE или DATETIME, то MIN() и MAX() приводятся к тому же самому формату, если они константы.
Если expr представляет собой строку, нечувствительную к регистру, то сравнение выполняется без учета регистра.
Если expr представляет собой строку, чувствительную к регистру, то сравнение выполняется с учетом регистра символов.
Если expr представляет собой целочисленное выражение, будет выполнено целочисленное сравнение.
Иначе, будет выполнено сравнение чисел с плавающей запятой.

mysql> select 1 BETWEEN 2 AND 3;
    -> 0
mysql> select 'b' BETWEEN 'a' AND 'c';
    -> 1
mysql> select 2 BETWEEN 2 AND '3';
    -> 1
mysql> select 2 BETWEEN 2 AND 'x-3';
    -> 0

expr IN (value,...)

Возвращается 1, если expr представляет собой любое из значений в списке IN, иначе возвращается 0. Если все значения константы, то все значения оценены согласно типу expr и отсортированы. Поиск элемента затем будет выполнен, используя двоичный поиск. Это означает, что IN очень быстр, если список значений IN состоит полностью из констант. Если expr чувствительное к регистру строковое выражение, сравнение строк выполняется с учетом регистра:

mysql> select 2 IN (0,3,5,'wefwf');
    -> 0
mysql> select 'wefwf' IN (0,3,5,'wefwf');
    -> 1

expr NOT IN (value,...)

Аналогично NOT (expr IN (value,...)).

ISNULL(expr)

Если expr равен NULL, ISNULL() возвращает 1, иначе это возвращает 0:

mysql> select ISNULL(1+1);
    -> 0
mysql> select ISNULL(1/0);
    -> 1

Обратите внимание, что сравнение значений NULL, использующих = всегда будет равно false!

COALESCE(list)

Возвращает первый не-NULL элемент в списке:

mysql> select COALESCE(NULL,1);
    -> 1
mysql> select COALESCE(NULL,NULL,NULL);
    -> NULL

INTERVAL(N,N1,N2,N3,...)

Возвращает 0, если N < N1, 1, если N < N2 и так далее. Все параметры обрабатываются как целые числа. Это требует, чтобы выполнялось N1 < N2 < N3 < ... < Nn для этой функции, чтобы она могла работать правильно. Это потому, что при работе функции используется двоичный поиск (очень быстрый):

mysql> select INTERVAL(23, 1, 15, 17, 30, 44, 200);
    -> 3
mysql> select INTERVAL(10, 1, 10, 100, 1000);
    -> 2
mysql> select INTERVAL(22, 23, 30, 44, 200);
    -> 0

Если Вы сравниваете чувствительную к регистру строку любым из стандартных операторов (=, <>..., но не LIKE), конечный пробел будет игнорироваться.

mysql> select "a" ="A ";
    -> 1

6.1.3 Логические операторы

Все логические функции возвращают 1 (TRUE), 0 (FALSE) или NULL (неизвестное, которое находится в большинстве случаев также, как FALSE):

NOT

!

Логический NOT. Возвращает 1, если параметр 0, иначе возвращает 0. Исключительная ситуация:

NOT
NULL

возвращает NULL:

mysql> select NOT 1;
    -> 0
mysql> select NOT NULL;
    -> NULL
mysql> select ! (1+1);
    -> 0
mysql> select ! 1+1;
    -> 1

Последний пример возвращает 1 потому, что выражение оценивается так же, как (!1)+1.

OR

||

Логический OR. Возвращает 1, если любой параметр не 0 и не NULL:

mysql> select 1 || 0;
    -> 1
mysql> select 0 || 0;
    -> 0
mysql> select 1 || NULL;
    -> 1

AND

&&

Логический AND. Возвращается 0, если параметр 0 или NULL, иначе возвращается 1:

mysql> select 1 && NULL;
    -> 0
mysql> select 1 && 0;
    -> 0

6.1.4 Функции ветвления

IFNULL(expr1,expr2)

Если expr1 не NULL, IFNULL() вернет expr1, иначе expr2. IFNULL() возвращает числовое или строковое значение в зависимости от контекста, в котором это используется:

mysql> select IFNULL(1,0);
    -> 1
mysql> select IFNULL(NULL,10);
    -> 10
mysql> select IFNULL(1/0,10);
    -> 10
mysql> select IFNULL(1/0,'yes');
    -> 'yes'

NULLIF(expr1,expr2)

Если expr1=expr2, вернет NULL, иначе возвращает expr1. Это работает также, как

CASE WHEN x=y THEN
NULL ELSE x END

mysql> select NULLIF(1,1);
    -> NULL
mysql> select NULLIF(1,2);
    -> 1

Обратите внимание, что expr1 будет оценен дважды в MySQL, если параметры равны.

IF(expr1,expr2,expr3)

Если expr1 равно TRUE (expr1 <> 0 и expr1 <> NULL), то IF() вернет expr2, иначе вернет expr3. IF() возвращает числовое или строковое значение в зависимости от контекста, в котором это используется:

mysql> select IF(1>2,2,3);
    -> 3
mysql> select IF(1<2,'yes','no');
    -> 'yes'
mysql> select IF(strcmp('test','test1'),'no','yes');
    -> 'no'

expr1 будет оценен как целочисленное значение, это означает, что, если Вы проверяете выражение с плавающей запятой или строку, Вы должны сделать следующее для корректного использования операции сравнения:

mysql> select IF(0.1,1,0);
    -> 0
mysql> select IF(0.1<>0,1,0);
    -> 1

В первом случае выше IF(0.1) вернет 0 потому, что 0.1 преобразован в целочисленное значение, возникающее в результате в IF(0). Это не может быть тем, что Вы ожидаете. Во втором случае сравнение проверяет первоначальное значение с плавающей запятой, чтобы видеть,является ли это отличным от нуля. Результат сравнения используется как целое число. Заданный по умолчанию тип возврата IF() (который может иметь значение, когда это значение будет сохранено во временной таблице) вычислен в MySQL 3.23 следующим образом:

Выражение	Возвращаемое значение
expr2 или expr3 возвращает строку	Строка
expr2 или expr3 возвращает значение с плавающей запятой	Число с плавающей запятой
expr2 или expr3 возвращает целое число	Целое число

CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END

CASE WHEN [condition] THEN result [WHEN [condition] THEN result ...] [ELSE result] END

Первая версия возвращает result, где value=compare-value. Вторая версия возвращает результат для первого условия, которое является истинным. Если не имелось никакого значения результата соответствия, то будет возвращен результат после ELSE. Если не имеется части ELSE, вернется NULL:

mysql> SELECT CASE 1 WHEN 1 THEN "one" WHEN 2 THEN "two"
           ELSE "more" END;
   -> "one"
mysql> SELECT CASE WHEN 1>0 THEN "true" ELSE "false" END;
   -> "true"
mysql> SELECT CASE BINARY "B" when "a" then 1 when "b" then 2 END;
   -> NULL

Тип значения возврата (INTEGER, DOUBLE или STRING) такое же, как и тип первого возвращенного значения (выражение после первого THEN).

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

Строковые функции возвращают NULL, если длина результата большая, чем параметр сервера max_allowed_packet.

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

ASCII(str)

Возвращает ASCII-код крайнего левого символа строки str. Вернет 0, если str пустая. Вернет NULL, если str равна NULL:

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

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

ORD(str)

Если крайний левый символ строки str представляет собой многобайтный символ, возвращает код символа, возвращая ASCII-значение кода символа в формате:

((первый байт ASCII-кода)*256+(второй байт ASCII-кода))[*256+
третий байт ASCII-кода...]

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

mysql> select ORD('2');
    -> 50

CONV(N,from_base,to_base)

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

mysql> select CONV("a",16,2);
    -> '1010'
mysql> select CONV("6E",18,8);
    -> '172'
mysql> select CONV(-17,10,-18);
    -> '-H'
mysql> select CONV(10+"10"+'10'+0xa,10,10);
    -> '40'

BIN(N)

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

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

OCT(N)

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

mysql> select OCT(12);
    -> '14'

HEX(N)

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

mysql> select HEX(255);
    -> 'FF'

CHAR(N,...)

CHAR() интерпретируют параметры как целые числа и возвращает строку состоящую из символов, заданных значениями ASCII-кодов из тех целых чисел. Значения NULL будут пропущены:

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

CONCAT(str1,str2,...)

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

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

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

CONCAT_WS() расшифровывается как CONCAT With Separator и представляет собой специальную форму функции 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'

LENGTH(str)

OCTET_LENGTH(str)

CHAR_LENGTH(str)

CHARACTER_LENGTH(str)

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

mysql> select LENGTH('text');
    -> 4
mysql> select OCTET_LENGTH('text');
    -> 4

Обратите внимание, что для CHAR_LENGTH() любой многобайтный символ считается одним.

LOCATE(substr,str)

POSITION(substr IN str)

Возвращает позицию первого местонахождения подстроки substr в строке str. Если не нашла substr в str, вернет 0:

mysql> select LOCATE('bar', 'foobarbar');
    -> 4
mysql> select LOCATE('xbar', 'foobar');
    -> 0

Поддерживаются многобайтные символы.

LOCATE(substr,str,pos)

Возвращает позицию первого местонахождения подстроки substr в строке str, после позиции pos. Если не нашла substr в str, вернет 0:

mysql> select LOCATE('bar', 'foobarbar',5);
    -> 7

Поддерживаются многобайтные символы.

INSTR(str,substr)

Аналог LOCATE(), но с переставленными параметрами:

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

Поддерживаются многобайтные символы.

LPAD(str,len,padstr)

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

mysql> select LPAD('hi',4,'??');
    -> '??hi'

RPAD(str,len,padstr)

Аналогично LPAD(str,len,padstr), но строка padstr приписывается справа.

mysql> select RPAD('hi',5,'?');
    -> 'hi???'

LEFT(str,len)

Возвращает len крайних левых символов из строки str:

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

Поддерживаются многобайтные символы.

RIGHT(str,len)

Возвращает len крайних правых символов из строки str:

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

Поддерживаются многобайтные символы.

SUBSTRING(str,pos,len)

SUBSTRING(str FROM pos FOR len)

MID(str,pos,len)

Возвращает подстроку длиной в len символов из строки str, начиная с позиции pos. Иная форма, которая использует синтаксис FROM из ANSI SQL92:

mysql> select SUBSTRING('Quadratically',5,6);
    -> 'ratica'

Поддерживаются многобайтные символы.

SUBSTRING(str,pos)

SUBSTRING(str FROM pos)

Возвращает подстроку из строки str. начиная с позиции pos:

mysql> select SUBSTRING('Quadratically',5);
    -> 'ratically'
mysql> select SUBSTRING('foobarbar' FROM 4);
    -> 'barbar'

Поддерживаются многобайтные символы.

SUBSTRING_INDEX(str,delim,count)

Возвращает подстроку из строки str, отступив count символов от разделителя delim. Если count положителен, вернется все левее разделителя. Если count отрицателен, вернется все правее заданного разделителя:

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

Поддерживаются многобайтные символы.

LTRIM(str)

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

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

RTRIM(str)

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

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

Поддерживаются многобайтные символы.

TRIM([[BOTH|LEADING|TRAILING] [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'

Поддерживаются многобайтные символы.

SOUNDEX(str)

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

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

SPACE(N)

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

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

REPLACE(str,from_str,to_str)

Возвращает строку str, где все вхождения подстроки from_str заменены на подстроку to_str:

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

Поддерживаются многобайтные символы.

REPEAT(str,count)

Возвращает строку, состоящую из вводной строки str повторенной count раз. Если count <=0, возвращает пустую строку. Если str или count равны NULL, вернет NULL:

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

REVERSE(str)

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

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

Поддерживаются многобайтные символы.

INSERT(str,pos,len,newstr)

Возвращает строку str с подстрокой, начинающейся в позиции pos и длиной в len символов, замененной на строку newstr:

mysql> select INSERT('Quadratic', 3, 4, 'What');
    -> 'QuWhattic'

Поддерживаются многобайтные символы.

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

Возвращает 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'

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

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

mysql> select FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
    -> 2
mysql> 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

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(0,'a','b','c');
    -> ''

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

Возвращает строку, где для каждого бита, установленного в наборе 'bit', Вы получите строку 'on', а для каждого неустановленного строку 'off'. Каждая отделяется от других разделителем (separator, по умолчанию запятая) и используется только 'number_of_bits' бит (по умолчанию 64):

mysql> select EXPORT_SET(5,'Y','N',',',4)
    -> Y,N,Y,N

LCASE(str)

LOWER(str)

Возвращает строку str со всеми символами, измененными на нижний регистр согласно текущему отображению набора символов (значение по умолчанию: ISO-8859-1 Latin1):

mysql> select LCASE('QUADRATICALLY');
    -> 'quadratically'

Поддерживаются многобайтные символы.

UCASE(str)

UPPER(str)

Возвращает строку str со всеми символами, измененными на верхний регистр согласно текущему отображению набора символов (значение по умолчанию: ISO-8859-1 Latin1):

mysql> select UCASE('Hej');
    -> 'HEJ'

Поддерживаются многобайтные символы.

LOAD_FILE(file_name)

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

mysql> UPDATE table_name
           SET blob_column=LOAD_FILE("/tmp/picture")
           WHERE id=1;

Если Вы не используете MySQL Version 3.23, Вы должны делать чтение файла внутри Вашей прикладной программы и создавать инструкцию INSERT, чтобы модифицировать базу данных с информацией из файла. Один способ сделать это, если Вы используете библиотеку MySQL++, есть на страничке http://www.mysql.com/documentation/mysql++/mysql++-examples.html.

MySQL по мере необходимости автоматически преобразует числа в строки и наоборот (как в Perl):

mysql> SELECT 1+"1";
    -> 2
mysql> SELECT CONCAT(2,' test');
    -> '2 test'

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

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

6.2.1 Функции сравнения строк

Обычно, если любое выражение при сравнении строк чувствительно к регистру, сравнение выполняется в режиме чувствительности к регистру символов.

expr LIKE pat [ESCAPE 'escape-char']

Соответствие, использующее простое регулярное сравнение выражения SQL. Возвращает 1 (TRUE) или 0 (FALSE). С LIKE Вы можете использовать следующие два групповых символа в задаваемом образце:

`%`	Соответствует любому числу символов.
`_`	Соответствует строго одному символу.

mysql> select 'David!' LIKE 'David_';
    -> 1
mysql> select 'David!' LIKE '%D%v%';
    -> 1

Чтобы проверять для литеральных образцов группового символа, экранируйте его символом escape. Если Вы не определяете символ ESCAPE, будет принято значение \:

`\%`	Соответствует одному символу `%`.
`\_`	Соответствует одному символу `_`.

mysql> select 'David!' LIKE 'David\_';
    -> 0
mysql> select 'David_' LIKE 'David\_';
    -> 1

Чтобы определять иной символ escape, используйте предложение ESCAPE:

mysql> select 'David_' LIKE 'David|_' ESCAPE '|';
    -> 1

Следующие две инструкции иллюстрируют сравнения нечувствительных к регистру строк, если один из операндов не двоичная строка:

mysql> select 'abc' LIKE 'ABC';
    -> 1
mysql> SELECT 'abc' LIKE BINARY 'ABC';
    -> 0

LIKE позволяется на числовых выражениях! Это MySQL-расширение ANSI SQL LIKE.

mysql> select 10 LIKE '1%';
    -> 1

Обратите внимание: поскольку MySQL использует C-escape синтаксис в строках (например, \n), Вы должны удвоить любой символ \, который Вы используете в Вашем выражении LIKE. Например, чтобы искать \n, определите это как \\n. Чтобы искать \, определите это как \\\\ (наклонные черты влево будут удалены синтаксическим анализатором и повторно, когда соответствие образца выполнено, оставляя одиночную наклонную черту влево, которая будет согласована в данном выражении).

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

Это аналогично вызову

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

expr REGEXP pat

expr RLIKE pat

Выполняет соответствие образца выражения строки expr для образца pat. Образец может быть расширенным регулярным выражением. Подробности в разделе "6.7 Описание синтаксиса регулярных выражений MySQL". Возвращает 1, если expr соответствует pat, иначе вернется 0. RLIKE представляет собой синоним для REGEXP, предусмотренный для совместимости с mSQL. Обратите внимание: поскольку MySQL использует C-escape синтаксис в строках (например, \n), Вы должны удвоить любой символ \, который Вы используете в Вашем выражении REGEXP. Например, чтобы искать \n, определите это как \\n. Начиная с MySQL Version 3.23.4, REGEXP нечувствителен к регистру для нормальных (не двоичных) строк:

mysql> select 'Monty!' REGEXP 'm%y%%';
    -> 0
mysql> select 'Monty!' REGEXP '.*';
    -> 1
mysql> select 'new*\n*line' REGEXP 'new\\*.\\*line';
    -> 1
mysql> select "a" REGEXP "A", "a" REGEXP BINARY "A";
    -> 1  0
mysql> select "a" REGEXP "^[a-d]";
    -> 1

REGEXP и RLIKE используют текущий набор символов (по умолчанию задан ISO-8859-1 Latin1).

expr NOT REGEXP pat

expr NOT RLIKE pat

Это аналогично вызову NOT (expr REGEXP pat).

STRCMP(expr1,expr2)

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

mysql> select STRCMP('text', 'text2');
    -> -1
mysql> select STRCMP('text2', 'text');
    -> 1
mysql> select STRCMP('text', 'text');
    -> 0

MATCH (col1,col2,...) AGAINST (expr)

MATCH ... AGAINST() используется для полнотекстового поиска и возвращает релевантность (она же уместность), меру подобия между текстом в столбцах (col1,col2,...) и запросе expr. Релевантность представляет собой положительное число с плавающей запятой. Нулевое значение данной величины означает отсутствие схожести. Для работы MATCH ... AGAINST() сначала должен быть создан индекс FULLTEXT. Подробности в разделе "7.3 Синтаксис CREATE TABLE ". MATCH ... AGAINST() доступен в MySQL Version 3.23.23 или более поздних. Подробности в разделе "9.4 Полнотекстовый поиск в MySQL".

6.2.2 Чувствительность к регистру символов

BINARY

Оператор BINARY приводит строку к двоичной форме. Это простой способ вынудить сравнение столбца быть чувствительным к регистру, даже если столбец не определен как BINARY или BLOB:

mysql> select "a" = "A";
    -> 1
mysql> select BINARY "a" = "A";
    -> 0

BINARY появился в MySQL Version 3.23.0. Обратите внимание, что в некотором контексте MySQL не будет способен использовать индекс эффективно, когда Вы приводите индексированный столбец к BINARY.

Если Вы хотите сравнивать нечувствительные к регистру объекты blob, Вы можете всегда преобразовывать blob в верхний регистр перед сравнением:

SELECT 'A' LIKE UPPER(blob_col) FROM table_name;

6.3 Числовые функции

6.3.1 Арифметические операторы

Обычные арифметические операторы доступны. Обратите внимание, что в случае `-', `+' и `*', результат вычислен с точностью BIGINT (64-bit), если оба параметра целые числа!

+

Сложение:

mysql> select 3+5;
    -> 8

-

Вычитание:

mysql> select 3-5;
    -> -2

*

Умножение:

mysql> select 3*5;
    -> 15
mysql> select 18014398509481984*18014398509481984.0;
    -> 324518553658426726783156020576256.0
mysql> select 18014398509481984*18014398509481984;
    -> 0

Результат последнего выражения ошибочен потому, что результат целочисленного умножения превышает 64-разрядный диапазон вычислений BIGINT.

/

Деление:

mysql> select 3/5;
    -> 0.60

Деление на ноль вернет NULL:

mysql> select 102/(1-1);
    -> NULL

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

6.3.2 Математические функции

Все математические функции возвращают NULL в случае ошибки.

-

Унарный минус. Меняет знак аргумента:

mysql> select - 2;
    -> -2

Обратите внимание, что, если этот оператор используется с BIGINT, значение возврата будет типа BIGINT! Это означает, что Вы должны избегать использования - на целых числах, которые могут иметь значение -2^63!

ABS(X)

Возвращает абсолютное значение X:

mysql> select ABS(2);
    -> 2
mysql> select ABS(-32);
    -> 32

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

SIGN(X)

Возвращает знак параметра как -1, 0 или 1, в зависимости от того, является ли X отрицательным, нулевым или положительным:

mysql> select SIGN(-32);
    -> -1
mysql> select SIGN(0);
    -> 0
mysql> select SIGN(234);
    -> 1

MOD(N,M)

%

MOD (подобно оператору % в языке C). Возвращает остаток от деления N на M:

mysql> select MOD(234, 10);
    -> 4
mysql> select 253 % 7;
    -> 1
mysql> select MOD(29,9);
    -> 2

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

FLOOR(X)

Возвращает самое большое целочисленное значение не большее, чем X:

mysql> select FLOOR(1.23);
    -> 1
mysql> select FLOOR(-1.23);
    -> -2

Обратите внимание, что значение возврата преобразовано в BIGINT!

CEILING(X)

Возвращает самое маленькое целочисленное значение не меньше, чем X:

mysql> select CEILING(1.23);
    -> 2
mysql> select CEILING(-1.23);
    -> -1

Обратите внимание, что значение возврата преобразовано в BIGINT!

ROUND(X)

Возвращает параметр X, округленный к самому близкому целому:

mysql> select ROUND(-1.23);
    -> -1
mysql> select ROUND(-1.58);
    -> -2
mysql> select ROUND(1.58);
    -> 2

Обратите внимание, что поведение ROUND(), когда параметр расположен точно между двумя целыми числами, зависит от реализации библиотеки C. Некоторые версии всегда округляют к самому близкому четному числу, другие всегда к самому большому, самому меньшему или вообще возвращают ноль. Если Вы нуждаетесь в одном виде округления, Вы должны использовать четкую функцию, подобно TRUNCATE() или FLOOR().

ROUND(X,D)

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

mysql> select ROUND(1.298, 1);
    -> 1.3
mysql> select ROUND(1.298, 0);
    -> 1

EXP(X)

Возвращает значение e (основание натуральных логарифмов), предварительно возведенное в степень X:

mysql> select EXP(2);
    -> 7.389056
mysql> select EXP(-2);
    -> 0.135335

LOG(X)

Возвращает натуральный логарифм X:

mysql> select LOG(2);
    -> 0.693147
mysql> select LOG(-2);
    -> NULL

Для других логарифмов пользуйтесь формулой LOG(X)/LOG(B).

LOG10(X)

Возвращает десятичный логарифм X:

mysql> select LOG10(2);
    -> 0.301030
mysql> select LOG10(100);
    -> 2.000000
mysql> select LOG10(-100);
    -> NULL

POW(X,Y)

POWER(X,Y)

Возвращает значение X в степени Y:

mysql> select POW(2,2);
    -> 4.000000
mysql> select POW(2,-2);
    -> 0.250000

SQRT(X)

Возвращает неотрицательный квадратный корень X:

mysql> select SQRT(4);
    -> 2.000000
mysql> select SQRT(20);
    -> 4.472136

PI()

Возвращает значение PI. По умолчанию, показывается 5 десятичных чисел, но MySQL внутренне использует полный алгоритм расчета PI.

mysql> select PI();
    -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
    -> 3.141592653589793116

COS(X)

Возвращает косинус X, где X задан в радианах:

mysql> select COS(PI());
    -> -1.000000

SIN(X)

Возвращает синус X, где X задан в радианах:

mysql> select SIN(PI());
    -> 0.000000

TAN(X)

Возвращает тангенс X, где X задан в радианах:

mysql> select TAN(PI()+1);
    -> 1.557408

ACOS(X)

Возвращает арккосинус X, то есть значение, чей косинус равен X. Вернет NULL, если X не в диапазоне от -1 до 1:

mysql> select ACOS(1);
    -> 0.000000
mysql> select ACOS(1.0001);
    -> NULL
mysql> select ACOS(0);
    -> 1.570796

ASIN(X)

Возвращает арксинус X, то есть значение, чей синус равен X. Вернет NULL, если X не в диапазоне от -1 до 1:

mysql> select ASIN(0.2);
    -> 0.201358
mysql> select ASIN('foo');
    -> 0.000000

ATAN(X)

Возвращает арктангенс X, то есть значение, чей тангенс равен X:

mysql> select ATAN(2);
    -> 1.107149
mysql> select ATAN(-2);
    -> -1.107149

ATAN2(Y,X)

Возвращает тангенс дуги из двух переменных X и Y. Это подобно вычислению тангенса дуги Y/X, за исключением того, что знаки обоих параметров используются, чтобы определить quadrant результата:

mysql> select ATAN(-2,2);
    -> -0.785398
mysql> select ATAN(PI(),0);
    -> 1.570796

COT(X)

Возвращает котангенс X:

mysql> select COT(12);
    -> -1.57267341
mysql> select COT(0);
    -> NULL

RAND()

RAND(N)

Возвращает произвольное значение с плавающей запятой в диапазоне от 0 до 1.0. Если целочисленный параметр N определен, он используется как значение инициализации:

mysql> select RAND();
    -> 0.5925
mysql> select RAND(20);
    -> 0.1811
mysql> select RAND(20);
    -> 0.1811
mysql> select RAND();
    -> 0.2079
mysql> select RAND();
    -> 0.7888

Вы не можете использовать столбец со значением RAND() в предложении ORDER BY потому, что ORDER BY вычисляется несколько раз. В MySQL Version 3.23, Вы, однако, это можете: SELECT * FROM table_name ORDER BY RAND() Это полезно, чтобы получить произвольную выборку

SELECT * FROM
table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000

. Обратите внимание, что RAND() в предложенииi WHERE будет переоценен каждый раз, когда выполняется WHERE.

LEAST(X,Y,...)

С двумя или больше параметрами, возвращает самый маленький параметр. Параметры сравниваются по следующим правилам:

Если значение возврата используется в контексте INTEGER, или все параметры целые числа, они сравниваются как целые числа.
Если значение возврата применяется в контексте REAL, или все параметры представляют собой числа real, они сравниваются как real.
Если любой параметр является чувствительной к регистру строкой, все параметры сравниваются именно как чувствительные к регистру строки.
Во всех других случаях параметры всегда сравниваются как нечувствительные к регистру обычные строки.

mysql> select LEAST(2,0);
    -> 0
mysql> select LEAST(34.0,3.0,5.0,767.0);
    -> 3.0
mysql> select LEAST("B","A","C");
    -> "A"

В MySQL до Version 3.22.5 Вы можете использовать MIN() вместо LEAST.

GREATEST(X,Y,...)

Возвращает самый большой параметр. Параметры сравниваются, используя те же самые правила, что касаются и вызова LEAST:

mysql> select GREATEST(2,0);
    -> 2
mysql> select GREATEST(34.0,3.0,5.0,767.0);
    -> 767.0
mysql> select GREATEST("B","A","C");
    -> "C"

В MySQL до Version 3.22.5 Вы можете использовать MAX() вместо GREATEST.

DEGREES(X)

Возвращает параметр X, преобразованный из радиан в градусы:

mysql> select DEGREES(PI());
    -> 180.000000

RADIANS(X)

Обратно вызову DEGREES(X):

mysql> select RADIANS(90);
    -> 1.570796

TRUNCATE(X,D)

Возвращает число X, усеченное до D десятичных чисел. Если D равно 0, результат не будет иметь никакой десятичной отметки или дробной части:

mysql> select TRUNCATE(1.223,1);
    -> 1.2
mysql> select TRUNCATE(1.999,1);
    -> 1.9
mysql> select TRUNCATE(1.999,0);
    -> 1

Обратите внимание, что, поскольку десятичные числа обычно сохраняются в компьютерах не как точные числа, а как двоичные значения, Вы можете быть введены в заблуждение следующим результатом:

mysql> select TRUNCATE(10.28*100,0);
   -> 1027

Вышеупомянутое случается потому, что число 10.28 фактически будет сохранено как нечто вроде 10.2799999999999999.

6.4 Функции для времени и даты

Обратитесь к разделу "5.2 Типы Date и Time" для описания диапазона значений, которые имеет каждый тип, и форматов, в которых значения даты и времени могут быть определены.

Имеется пример, который использует функции даты. Запрос ниже выбирает все записи со значением date_col в пределах последних 30 дней:

mysql> SELECT something FROM table
           WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30;

DAYOFWEEK(date)

Возвращает номер дня недели для date (1=воскресенье, 2=понедельник, ..., 7=суббота). Эти индексные значения соответствуют стандарту ODBC:

mysql> select DAYOFWEEK('1998-02-03');
    -> 3

WEEKDAY(date)

Возвращает номер дня недели для date (0=понедельник, 1=вторник, ..., 6=воскресенье):

mysql> select WEEKDAY('1997-10-04 22:23:00');
    -> 5
mysql> select WEEKDAY('1997-11-05');
    -> 2

DAYOFMONTH(date)

Возвращает день месяца для date, в диапазоне от 1 до 31:

mysql> select DAYOFMONTH('1998-02-03');
    -> 3

DAYOFYEAR(date)

Возвращает день года для date, в диапазоне от 1 до 366:

mysql> select DAYOFYEAR('1998-02-03');
    -> 34

MONTH(date)

Возвращает месяц для date, в диапазоне от 1 до 12:

mysql> select MONTH('1998-02-03');
    -> 2

DAYNAME(date)

Возвращает имя дня недели для date:

mysql> select DAYNAME("1998-02-05");
    -> 'Thursday'

MONTHNAME(date)

Возвращает имя месяца для date:

mysql> select MONTHNAME("1998-02-05");
    -> 'February'

QUARTER(date)

Возвращает четверть года для date, в диапазоне от 1 до 4:

mysql> select QUARTER('98-04-01');
    -> 2

WEEK(date)

WEEK(date,first)

С одиночным параметром возвращает неделю для date, в диапазоне от 0 до 53 (да, могут иметься начала недели 53), для расположений, где воскресенье считается первым днем недели. Форма с двумя параметрами WEEK() позволяет Вам определять, начинается ли неделя в воскресенье или в понедельник. Неделя начинается в воскресенье, если второй параметр равен 0, или в понедельник, если он равен 1:

mysql> select WEEK('1998-02-20');
    -> 7
mysql> select WEEK('1998-02-20',0);
    -> 7
mysql> select WEEK('1998-02-20',1);
    -> 8
mysql> select WEEK('1998-12-31',1);
    -> 53

YEAR(date)

Возвращает год для date, в диапазоне от 1000 до 9999:

mysql> select YEAR('98-02-03');
    -> 1998

YEARWEEK(date)

YEARWEEK(date,first)

Возвращает год и неделю для date. Вторые параметры работают точно так же, как и второй параметр в вызове WEEK(). Обратите внимание, что год может отличаться от года в параметре для первой и последней недель:

mysql> select YEARWEEK('1987-01-01');
    -> 198653

HOUR(time)

Возвращает час для time, в диапазоне от 0 до 23:

mysql> select HOUR('10:05:03');
    -> 10

MINUTE(time)

Возвращает минуту для time, в диапазоне от 0 до 59:

mysql> select MINUTE('98-02-03 10:05:03');
    -> 5

SECOND(time)

Возвращает секунды для time, в диапазоне от 0 до 59:

mysql> select SECOND('10:05:03');
    -> 3

PERIOD_ADD(P,N)

Добавляет N месяцев к периоду P (в формате YYMM или YYYYMM). Возвращает значение в формате YYYYMM. Обратите внимание, что параметр P НЕ является датой:

mysql> select PERIOD_ADD(9801,2);
    -> 199803

PERIOD_DIFF(P1,P2)

Возвращает число месяцев между периодами P1 и P2. P1 и P2 должны быть в формате YYMM или YYYYMM. Обратите внимание, что параметры P1 и P2 НЕ являются датами:

mysql> select PERIOD_DIFF(9802,199703);
    -> 11

DATE_ADD(date,INTERVAL expr type)

DATE_SUB(date,INTERVAL expr type)

ADDDATE(date,INTERVAL expr type)

SUBDATE(date,INTERVAL expr type)

Эти функции выполняют арифметику даты. Они новы для MySQL Version 3.22. ADDDATE() и SUBDATE() представляют собой синонимы DATE_ADD() и DATE_SUB(). В MySQL Version 3.23 Вы можете использовать + и - вместо DATE_ADD() и DATE_SUB(), если выражение справа является столбом типа datetime или датой (пример ниже). date значение типа DATETIME или DATE, определяющее стартовую дату. expr задает выражение, определяющее значение интервала, которое будет добавлено или вычтено из стартовой даты. expr является строкой, оно может начинаться с `-' для отрицательных интервалов. type представляет собой ключевое слово, указывающее, как данное выражение должно интерпретироваться. Связанная функция EXTRACT(type FROM date) возвращает интервал 'type' даты. Следующая таблица показывает, как параметры type и expr связаны:

`type`значение	ожидаемый формат `expr`
`SECOND`	`SECONDS`
`MINUTE`	`MINUTES`
`HOUR`	`HOURS`
`DAY`	`DAYS`
`MONTH`	`MONTHS`
`YEAR`	`YEARS`
`MINUTE_SECOND`	`"MINUTES:SECONDS"`
`HOUR_MINUTE`	`"HOURS:MINUTES"`
`DAY_HOUR`	`"DAYS HOURS"`
`YEAR_MONTH`	`"YEARS-MONTHS"`
`HOUR_SECOND`	`"HOURS:MINUTES:SECONDS"`
`DAY_MINUTE`	`"DAYS HOURS:MINUTES"`
`DAY_SECOND`	`"DAYS HOURS:MINUTES:SECONDS"`

MySQL позволяет любой разделитель в формате expr. Показанные в таблице представляют собой предложенные разделители. Если параметр date значение типа DATE, и Ваши вычисления включают только части YEAR, MONTH и DAY, (то есть никаких частей времени), результат будет значением типа DATE. Иначе будет установлен тип DATETIME:

mysql> SELECT "1997-12-31 23:59:59" + INTERVAL 1 SECOND;
    -> 1998-01-01 00:00:00
mysql> SELECT INTERVAL 1 DAY + "1997-12-31";
    -> 1998-01-01
mysql> SELECT "1998-01-01" - INTERVAL 1 SECOND;
   -> 1997-12-31 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL 1 SECOND);
    -> 1998-01-01 00:00:00
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL 1 DAY);
    -> 1998-01-01 23:59:59
mysql> SELECT DATE_ADD("1997-12-31 23:59:59",
                       INTERVAL "1:1" MINUTE_SECOND);
    -> 1998-01-01 00:01:00
mysql> SELECT DATE_SUB("1998-01-01 00:00:00",
                       INTERVAL "1 1:1:1" DAY_SECOND);
    -> 1997-12-30 22:58:59
mysql> SELECT DATE_ADD("1998-01-01 00:00:00",
                       INTERVAL "-1 10" DAY_HOUR);
    -> 1997-12-30 14:00:00
mysql> SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);
    -> 1997-12-02

Если Вы определяете значение интервала, которое является слишком коротким (не включает все части интервала, которые ожидались бы из ключевого слова type), MySQL считает, что Вы не учли крайние левые части значения интервала. Например, если Вы определяете type как DAY_SECOND, значение expr, как ожидается, будет иметь дни, часы, минуты и секунды. Если Вы определяете, что значение выглядит как "1:10", MySQL считает, что части дней и часов отсутствуют, а значение представляет минуты и секунды. Другими словами,

"1:10"
DAY_SECOND

интерпретируется таким способом, которым это является эквивалентным "1:10" MINUTE_SECOND. Это аналогично пути, которым MySQL интерпретирует значения TIME как представление прошедшего времени, а не время дня. Обратите внимание, что, если Вы добавляете или вычитаете значение date, работая с частями времени, оно будет автоматически преобразовано в значение time:

mysql> select date_add("1999-01-01", interval 1 day);
    -> 1999-01-02
mysql> select date_add("1999-01-01", interval 1 hour);
    -> 1999-01-01 01:00:00

Если Вы используете, действительно, неправильные даты, результатом будет NULL. Если Вы добавляете MONTH, YEAR_MONTH или YEAR, и возникающая в результате дата имеет день, который является большим, чем максимальный день нового месяца, день откорректирован к максимальному дню в новом месяце:

mysql> select DATE_ADD('1998-01-30', Interval 1 month);
    -> 1998-02-28

Обратите внимание, что слово INTERVAL и ключевое слово type не чувствительны к регистру.

EXTRACT(type FROM date)

Функция EXTRACT() использует те же самые виды спецификаторов типа интервала, что и DATE_ADD() или DATE_SUB(), но извлекает части даты, а не проводит выполнение арифметики даты.

mysql> SELECT EXTRACT(YEAR FROM "1999-07-02");
    -> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
    -> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
    -> 20102

TO_DAYS(date)

Берет дату date, возвращает порядковый номер дня, считая с самого первого года:

mysql> select TO_DAYS(950501);
    -> 728779
mysql> select TO_DAYS('1997-10-07');
    -> 729669

TO_DAYS() не предназначена для использования со значениями, которые предшествуют появлению Грегорианского календаря (1582) потому, что эта функция не принимает во внимание дни, которые были потеряны, когда календарь был изменен.

FROM_DAYS(N)

Берет номер дня N, возвращает значение DATE:

mysql> select FROM_DAYS(729669);
    -> '1997-10-07'

FROM_DAYS() не предназначена для использования со значениями, которые предшествуют появлению Грегорианского календаря (1582) потому, что эта функция не принимает во внимание дни, которые были потеряны, когда календарь был изменен.

DATE_FORMAT(date,format)

Форматирует значение date согласно строке format. Следующие спецификаторы могут использоваться в формате:

`%M`	Имя месяца (`январь`..`декабрь`).
`%W`	День недели (`воскресенье`..`суббота`).
`%D`	День месяца с английским суффиксом (`1st`, `2nd`, `3rd`, ...).
`%Y`	Год, числовое представление, 4 цифры.
`%y`	Год, числовое представление, 2 цифры.
`%X`	Год для недель, где воскресенье первый день недели, числовое представление, 4 цифры, используемые с '%V'.
`%x`	Год для недель, где понедельник первый день недели, числовое представление, 4 цифры, используемые с '%v'.
`%a`	Краткая форма названия дня (`Sun`..`Sat`).
`%d`	День месяца, числовой (`00`..`31`).
`%e`	День месяца, числовой (`0`..`31`).
`%m`	Месяц, числовой (`01`..`12`).
`%c`	Месяц, числовой (`1`..`12`).
`%b`	Краткая форма названия месяца (`Jan`..`Dec`).
`%j`	День года (`001`..`366`).
`%H`	Час (`00`..`23`).
`%k`	Час (`0`..`23`).
`%h`	Час (`01`..`12`).
`%I`	Час (`01`..`12`).
`%l`	Час (`1`..`12`).
`%i`	Минуты, числовая форма (`00`..`59`).
`%r`	Время, 12-часовой формат (`hh:mm:ss [AP]M`).
`%T`	Время, 24-часовой формат (`hh:mm:ss`).
`%S`	Секунды (`00`..`59`).
`%s`	Секунды (`00`..`59`).
`%p`	`AM` или `PM`.
`%w`	День недели (`0`=воскресенье..`6`=суббота).
`%U`	Неделя (`0`..`53`), где воскресенье первый день недели.
`%u`	Неделя (`0`..`53`), где понедельник первый день недели.
`%V`	Неделя (`1`..`53`), где воскресенье первый день недели. Использован с '%X'.
`%v`	Неделя (`1`..`53`), где понедельник первый день недели. Использован с '%x'.
`%%`	Знак процента (`%`).

Все другие символы будут только скопированы в результат без интерпретации:

mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
    -> 'Saturday October 1997'
mysql> select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
    -> '22:23:00'
mysql> select DATE_FORMAT('1997-10-04 22:23:00',
                              '%D %y %a %d %m %b %j');
    -> '4th 97 Sat 04 10 Oct 277'
mysql> select DATE_FORMAT('1997-10-04 22:23:00',
                              '%H %k %I %r %T %S %w');
    -> '22 22 10 10:23:00 PM 22:23:00 00 6'
mysql> select DATE_FORMAT('1999-01-01', '%X %V');
    -> '1998 52'

Начиная с MySQL Version 3.23, символ % обязательно требуется указывать перед символами спецификатора формата. В более ранних версиях MySQL символ % был факультативным.

TIME_FORMAT(time,format)

Это используется подобно функции DATE_FORMAT(), но строка format может содержать только те спецификаторы формата, которые обрабатывают часы, минуты и секунды. Другие спецификаторы производят значения NULL или 0.

CURDATE()

CURRENT_DATE

Возвращает сегодняшнюю дату как значение в формате YYYY-MM-DD или YYYYMMDD, в зависимости от того, используется ли функция в контексте строки или числа:

mysql> select CURDATE();
    -> '1997-12-15'
mysql> select CURDATE() + 0;
    -> 19971215

CURTIME()

CURRENT_TIME

Возвращает текущее время как значение в формате HH:MM:SS или HHMMSS, в зависимости от того, используется ли функция в контексте строки или числа:

mysql> select CURTIME();
    -> '23:50:26'
mysql> select CURTIME() + 0;
    -> 235026

NOW()

SYSDATE()

CURRENT_TIMESTAMP

Возвращает текущую дату и время как значение в формате YYYY-MM-DD HH:MM:SS или YYYYMMDDHHMMSS в зависимости от того, используется ли функция в контексте строки или числа:

mysql> select NOW();
    -> '1997-12-15 23:50:26'
mysql> select NOW() + 0;
    -> 19971215235026

UNIX_TIMESTAMP()

UNIX_TIMESTAMP(date)

Если вызвано без параметра, возвращает Unix timestamp (секунды с момента 1970-01-01 00:00:00 GMT). Если UNIX_TIMESTAMP() вызван с параметром date, это возвращает значение параметра как секунды с момента 1970-01-01 00:00:00 GMT. date может быть строками типов DATE, DATETIME, TIMESTAMP или числом в форматах YYMMDD или YYYYMMDD в местном времени:

mysql> select UNIX_TIMESTAMP();
    -> 882226357
mysql> select UNIX_TIMESTAMP('1997-10-04 22:23:00');
    -> 875996580

Когда UNIX_TIMESTAMP используется на столбце типа TIMESTAMP, функция получит значение непосредственно, без неявного преобразования ``string-to-unix-timestamp''. Если Вы задаете UNIX_TIMESTAMP() неправильно, вернется 0.

FROM_UNIXTIME(unix_timestamp)

Возвращает представление параметра unix_timestamp как значение в формате YYYY-MM-DD HH:MM:SS или YYYYMMDDHHMMSS в зависимости от того, используется ли функция в контексте строки или числа:

mysql> select FROM_UNIXTIME(875996580);
    -> '1997-10-04 22:23:00'
mysql> select FROM_UNIXTIME(875996580) + 0;
    -> 19971004222300

FROM_UNIXTIME(unix_timestamp,format)

Возвращает представление параметра unix_timestamp как строку, форматируемую согласно строке format. Строка format может содержать те же самые спецификаторы, что и для функции DATE_FORMAT():

mysql> select FROM_UNIXTIME(UNIX_TIMESTAMP(),
                            '%Y %D %M %h:%i:%s %x');
    -> '1997 23rd December 03:43:30 x'

SEC_TO_TIME(seconds)

Возвращает параметр seconds, преобразованный в часы, минуты и секунды, как значение в формате HH:MM:SS или HHMMSS в зависимости от того, используется ли функция в контексте строки или числа:

mysql> select SEC_TO_TIME(2378);
    -> '00:39:38'
mysql> select SEC_TO_TIME(2378) + 0;
    -> 3938

TIME_TO_SEC(time)

Возвращает параметр time, преобразованный в секунды:

mysql> select TIME_TO_SEC('22:23:00');
    -> 80580
mysql> select TIME_TO_SEC('00:39:38');
    -> 2378

6.5 Прочие функции

6.5.1 Битовые функции

MySQL использует BIGINT (64-bit) арифметику для битовых операций, так что эти операторы имеют максимальный диапазон в 64 бита.

|

Побитовое OR:

mysql> select 29 | 15;
    -> 31

&

Побитовое AND:

mysql> select 29 & 15;
    -> 13

<<

Сдвигает число типа longlong (BIGINT) влево:

mysql> select 1 << 2;
    -> 4

>>

Сдвигает число типа longlong (BIGINT) вправо:

mysql> select 4 >> 2;
    -> 1

~

Инвертирует все биты:

mysql> select 5 & ~1;
    -> 4

BIT_COUNT(N)

Возвращает число битов, которые установлены в параметре N:

mysql> select BIT_COUNT(29);
    -> 4

6.5.2 Дополнительные функции

DATABASE()

Возвращает текущее имя базы данных:

mysql> select DATABASE();
    -> 'test'

Если не имеется никакой текущей базы данных, DATABASE() возвращает пустую строку.

USER()

SYSTEM_USER()

SESSION_USER()

Возвращает текущее имя пользователя MySQL:

mysql> select USER();
    -> 'davida@localhost'

В MySQL Version 3.22.11 и более поздних версиях это включает hostname пользователя, а не только имя пользователя. Вы можете извлекать только часть имени пользователя подобно этому:

mysql> select substring_index(USER(),"@",1);
    -> 'davida'

PASSWORD(str)

Вычисляет строку пароля из открытого текста str. Это функция, которая используется для шифрования паролей MySQL для хранения в столбце Password таблицы привилегий user:

mysql> select PASSWORD('badpwd');
    -> '7f84554057dd964b'

Шифрование PASSWORD() необратимо. PASSWORD() не выполняет шифрование пароля таким же образом, что и Unix. Вы не должны считать, что, если Ваши пароли для Unix и MySQL одинаковы, PASSWORD() выдаст то же самое шифрованное значение, какое сохранено в файле паролей Unix. См. функцию ENCRYPT().

ENCRYPT(str[,salt])

Шифрует str, используя системный вызов Unix crypt(). Параметр salt должен быть строкой с двумя символами. Начиная с MySQL Version 3.22.16, salt может быть длиннее, чем два символа:

mysql> select ENCRYPT("hello");
    -> 'VxuFAJXVARROc'

Если crypt() недоступен на Вашей системе, ENCRYPT() всегда возвращает NULL. ENCRYPT() игнорирует все, кроме первых 8 символов str, по крайней мере на некоторых системах. Это определено поведением системного вызова crypt().

ENCODE(str,pass_str)

Шифрует str, используя pass_str как пароль. Для дешифрования примените вызов DECODE(). Результат: двоичная строка string той же самой длины. Если Вы хотите сохранять это в столбце, используйте тип столбца BLOB.

DECODE(crypt_str,pass_str)

Дешифрует зашифрованную строку crypt_str, используя pass_str как пароль. crypt_str должна быть строкой, возвращенной из ENCODE().

MD5(string)

Вычисляет контрольную сумму MD5 для строки. Значение возвращено как 32 разрядное шестнадцатеричное число, которое может, например, использоваться как ключ хэширования:

mysql> select MD5("testing");
    -> 'ae2b1fca515949e5d54fb22b8ed95575'

Это "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

LAST_INSERT_ID([expr])

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

mysql> select LAST_INSERT_ID();
    -> 195

Последний ID, который был сгенерирован, поддерживается сервером на основании подключения. Это не будет изменено другим пользователем. Это не будет даже изменено, если Вы модифицируете другой столбец AUTO_INCREMENT с нормальным значением (то есть значением, которое не NULL и не 0). Если Вы вставляете много строк в то же самое время с инструкцией insert, LAST_INSERT_ID() возвращает значение для первой вставленной строки. Причина для этого в том, чтобы сделать возможным легкое воспроизведение той же самой инструкции на другом сервере. Если expr дан как параметр LAST_INSERT_ID(), то значение параметра возвращенного функцией, будет установлено в следующее значение, которое будет возвращено LAST_INSERT_ID() и будет использоваться как следующее значение auto_increment. Это может применяться, чтобы моделировать последовательности. Сначала создайте таблицу:

mysql> create table sequence (id int not null);
mysql> insert into sequence values (0);

Затем таблица может использоваться, чтобы генерировать числа последовательности подобно этому:

mysql> update sequence set id=LAST_INSERT_ID(id+1);

Вы можете генерировать последовательности без того, чтобы вызвать LAST_INSERT_ID(), но полезность использования функции состоит в том, что значение ID поддерживается сервером как последнее автоматически сгенерированное значение. Вы можете получить новый ID чтением любого нормального значения AUTO_INCREMENT в MySQL. Например, LAST_INSERT_ID() (без параметра) возвратит новый ID. Функция C API mysql_insert_id() может также использоваться, чтобы получить значение. Обратите внимание, что поскольку mysql_insert_id() модифицируется только после инструкций INSERT и UPDATE, Вы не можете использовать эту функцию, чтобы получать значение для LAST_INSERT_ID(expr) после выполнения других инструкций SQL подобно SELECT или SET.

FORMAT(X,D)

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

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'

VERSION()

Возвращает строку, указывающую версию MySQL:

mysql> select VERSION();
    -> '3.23.13-log'

Обратите внимание, что, если Ваша версия заканчивается словом -log, это означает, что регистрация допускается.

CONNECTION_ID()

Возвращает идентификатор подключения (thread_id) для соединения. Каждое подключение имеет собственный уникальный идентификатор:

mysql> select CONNECTION_ID();
    -> 1

GET_LOCK(str,timeout)

Пробует получать блокировку с именем, заданным строкой str, со временем ожидания timeout секунд. Возвратит 1, если блокировка была получена успешно, 0 если попытка провалилась по тайм-ауту, или NULL если произошла ошибка (типа исчерпания памяти или уничтожения процесса командой

mysqladmin
kill

). Блокировка будет снята, когда Вы выполняете RELEASE_LOCK(), новый вызов GET_LOCK() или процесс завершается. Эта функция может использоваться, чтобы выполнить блокировки прикладной программы или моделировать блокировки записи. Это блокирует запросы другой клиентуры для блокировок с тем же самым именем: клиентура, которая договаривается о данном имени блокировки, может использовать строку, чтобы выполнить совместную (кооперативную) консультативную блокировку:

mysql> select GET_LOCK("lock1",10);
    -> 1
mysql> select GET_LOCK("lock2",10);
    -> 1
mysql> select RELEASE_LOCK("lock2");
    -> 1
mysql> select RELEASE_LOCK("lock1");
    -> NULL

Обратите внимание, что второй вызов RELEASE_LOCK() вернет NULL потому, что блокировка lock1 была автоматически снята вторым вызовом GET_LOCK().

RELEASE_LOCK(str)

Снимает блокировку, именованную строкой str, которая была получена с GET_LOCK(). Возвратит 1, если блокировка была нормально снята, 0, если блокировка не была блокирована этим потоком (когда блокировка не снята), или NULL, если поименованная блокировка не существует. Блокировка не существует, если она никогда не была получена обращением к GET_LOCK() или уже снята.

BENCHMARK(count,expr)

Функция BENCHMARK() выполняет вычисление выражения expr count раз. Это может использоваться для измерения того, как быстро MySQL обрабатывает выражение. Значение результата всегда 0. Предназначено для использования клиентом mysql, который сообщает времена выполнения запроса:

mysql> select BENCHMARK(1000000,encode("hello","goodbye"));
  +----------------------------------------------+
  | BENCHMARK(1000000,encode("hello","goodbye")) |
  +----------------------------------------------+
  |                                            0 |
  +----------------------------------------------+
1 row in set (4.74 sec)

Сообщенное время представляет собой время, прошедшее на стороне клиента, а не CPU time на сервере! Может быть, желательно выполнить BENCHMARK() несколько раз, и интерпретировать результат с отношением к тому, как тяжело был загружен сервер.

INET_NTOA(expr)

Возвращает сетевой адрес (4 или 8 байт) для числового выражения:

mysql> select INET_NTOA(3520061480);
    -> "209.207.224.40"

INET_ATON(expr)

Возвращает целое число, которое представляет числовое значение для сетевого адреса. Адреса могут быть длиной в 4 или 8 байт:

mysql> select INET_ATON("209.207.224.40");
    -> 3520061480

Сгенерированное число всегда в порядке сетевых байт. Например, вышеупомянутое число вычислено как 209*255^3+207*255^2+224*255+40.

MASTER_POS_WAIT(log_name, log_pos)

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

6.6 Функции для применения в предложении `GROUP BY`

Если Вы используете функцию в инструкции, не содержащей предложение GROUP BY, это эквивалентно группировке на всех строках.

COUNT(expr)

Возвращает количество не-NULL (возможно, одинаковых) значений в строках, найденных SELECT:

mysql> select student.student_name,COUNT(*) from student,course
                  where student.student_id=course.student_id
                  GROUP BY student_name;

COUNT(*) оптимизирован, чтобы возвратить данные очень быстро, если SELECT получает данные из одной таблицы, никакие другие столбцы не задействованы, и в запросе не имеется никакого предложения WHERE. Например:

mysql> select COUNT(*) from student;

COUNT(DISTINCT expr,[expr...])

Возвращает число различных значений не-NULL:

mysql> select COUNT(DISTINCT results) from student;

В MySQL Вы можете получить число различных комбинаций выражений, которые не содержат NULL, задавая список выражений. В ANSI SQL Вы были бы должны сделать конкатенацию всех выражений внутри CODE(DISTINCT...).

AVG(expr)

Возвращает среднее значение expr:

mysql> select student_name, AVG(test_score)
                  from student
                  GROUP BY student_name;

MIN(expr)

MAX(expr)

Возвращает минимальное или максимальное значение expr. MIN() и MAX() может брать строковый параметр. В таких случаях они возвращают минимальное или максимальное значение строки.

mysql> select student_name, MIN(test_score), MAX(test_score)
                  from student
                  GROUP BY student_name;

SUM(expr)

Возвращает сумму expr. Обратите внимание, что, если набор возвратов не имеет никаких строк, это возвращает NULL!

STD(expr)

STDDEV(expr)

Возвращает стандартное отклонение expr. Это расширение ANSI SQL. Форма STDDEV() этой функции предусмотрена для совместимости с Oracle.

BIT_OR(expr)

Возвращается поразрядный OR всех битов в expr. Вычисление выполняется с 64-разрядной точностью (BIGINT).

BIT_AND(expr)

Возвращается поразрядный AND всех битов в expr. Вычисление выполняется с 64-разрядной точностью (BIGINT).

MySQL расширил использование GROUP BY. Вы можете использовать столбцы или вычисления в выражениях SELECT, которые не появляются в части GROUP BY. Это соответствует любому возможному значению для этой группы. Вы можете использовать это, чтобы получить лучшую эффективность, избегая сортировки и группировки на ненужных элементах. Например, Вы не должны группировать на customer.name в следующем запросе:

mysql> select order.custid,customer.name,max(payments)
                  from order,customer where order.custid=customer.custid
                  GROUP BY order.custid;

В ANSI SQL Вы были бы должны добавить customer.name к предложению GROUP BY. В MySQL имя избыточно, если Вы не выполняетесь в ANSI режиме.

Не используйте это свойство, если столбцы, которые Вы получаете из предложения GROUP BY не уникальны в группе! Вы получите непредсказуемые результаты.

В некоторых случаях Вы можете использовать MIN() и MAX() чтобы получить специфическое значение столбца, даже если оно неуникально. Следующее выдает значение column из строки, содержащей самое маленькое значение в столбце sort:

substr(MIN(concat(rpad(sort,6,' '),column)),7)

Подробности в разделе "3.5.4 В какой строке максимум по группе".

Обратите внимание, что, если Вы используете MySQL Version 3.22 (или ранее), или если Вы пробуете следовать ANSI SQL, Вы не можете использовать выражения в предложениях GROUP BY или ORDER BY. Вы можете обойти это ограничение, используя псевдоним для выражения:

mysql> SELECT id,FLOOR(value/100) AS val
                  FROM tbl_name
                  GROUP BY id,val ORDER BY val;

В MySQL Version 3.23 Вы можете сделать:

mysql> SELECT id,FLOOR(value/100) FROM tbl_name ORDER BY RAND();

6.7 Описание синтаксиса регулярных выражений MySQL

Регулярные выражения (они же regular expression или regex) представляют собой мощный путь для определения сложного поиска.

MySQL использует реализацию Henry Spencer's, которая нацелена на соответствие POSIX 1003.2. MySQL использует ее расширенную версию.

Это упрощенное описание, которое опускает ряд деталей. За подробной информацией отсылаю Вас к man-странице Henry Spencer's regex(7), которая включена в дистрибутив исходного кода.

Регулярное выражение описывает набор строк. Самый простой regexp такой, который не имеет никаких специальных символов. Например, regexp hello соответствует hello и ничему другому.

Нетривиальные регулярные выражения используют некоторые специальные конструкции так, чтобы они могли соответствовать больше, чем одной строке. Например, regexp hello|word соответствует строке hello или word.

Как более сложный пример, regexp B[an]*s соответствует любой из строк Bananas, Baaaaas, Bs и любой другой строке, начинающейся с B, заканчивающейся на s и содержащей любое число символов в диапазоне от a до n между ними.

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

^

Соответствует началу строки.

mysql> select "fo\nfo" REGEXP "^fo$"; -> 0
mysql> select "fofo" REGEXP "^fo";    -> 1

$

Соответствует концу строки.

mysql> select "fo\no" REGEXP "^fo\no$"; -> 1
mysql> select "fo\no" REGEXP "^fo$";    -> 0

.

Соответствует любому символу (включая newline).

mysql> select "fofo" REGEXP "^f.*";   -> 1
mysql> select "fo\nfo" REGEXP "^f.*"; -> 1

a*

Соответствует любой последовательности из ноля или больше символов. a.

mysql> select "Ban" REGEXP "^Ba*n";   -> 1
mysql> select "Baaan" REGEXP "^Ba*n"; -> 1
mysql> select "Bn" REGEXP "^Ba*n";    -> 1

a+

Соответствует любой последовательности из одного или больше символов. a.

mysql> select "Ban" REGEXP "^Ba+n"; -> 1
mysql> select "Bn" REGEXP "^Ba+n";  -> 0

a?

Соответствует нолю или одному символу a.

mysql> select "Bn" REGEXP "^Ba?n";   -> 1
mysql> select "Ban" REGEXP "^Ba?n";  -> 1
mysql> select "Baan" REGEXP "^Ba?n"; -> 0

de|abc

Соответствует последовательностям de или abc.

mysql> select "pi" REGEXP "pi|apa";  -> 1
mysql> select "axe" REGEXP "pi|apa"; -> 0
mysql> select "apa" REGEXP "pi|apa"; -> 1
mysql> select "apa" REGEXP "^(pi|apa)$"; -> 1
mysql> select "pi" REGEXP "^(pi|apa)$";  -> 1
mysql> select "pix" REGEXP "^(pi|apa)$"; -> 0

(abc)*

Соответствует нолю или большему количеству образцов последовательности abc.

mysql> select "pi" REGEXP "^(pi)*$";   -> 1
mysql> select "pip" REGEXP "^(pi)*$";  -> 0
mysql> select "pipi" REGEXP "^(pi)*$"; -> 1

{1}

{2,3}

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

a*: Может быть написан как a{0,}.
a+: Может быть написан как a{1,}.
a?: Может быть написан как a{0,1}.

Чтобы быть более точным, атом, сопровождаемый одним целым числом i без запятой соответствует последовательности точно i вхождений атома. Атом, сопровождаемый одним числом с запятой, соответствует последовательности из одного или большего числа вхождений i. Атом, сопровождаемый двумя целыми числами i и j соответствует последовательности, включающей от i до j копий атома (границы диапазона входят в число). Оба аргумента должны быть в диапазоне от 0 до RE_DUP_MAX (по умолчанию 255), включая границы. Если заданы два аргумента, второй должен быть больше или равен первому, но не меньше его.

[a-dX]

[^a-dX]

Соответствует любому символу, который является (или не является, если используется ^) одним из: a, b, c, d или X. Чтобы включить литеральный символ ], он должен следовать сразу за открывающейся скобкой [. Чтобы включить символ -, он должен быть написан первым или последним. Так [0-9] соответствует любой десятичной цифре. Любой символ, который не имеет определенного значения внутри [], не имеет никакого специального значения.

mysql> select "aXbc" REGEXP "[a-dXYZ]";    -> 1
mysql> select "aXbc" REGEXP "^[a-dXYZ]$";  -> 0
mysql> select "aXbc" REGEXP "^[a-dXYZ]+$"; -> 1
mysql> select "aXbc" REGEXP "^[^a-dXYZ]+$";   -> 0
mysql> select "gheis" REGEXP "^[^a-dXYZ]+$";  -> 1
mysql> select "gheisa" REGEXP "^[^a-dXYZ]+$"; -> 0

[[.characters.]]

Последовательность символов. Последовательность представляет собой одиночный элемент из списка выражений в скобках. Выражение, содержащее много символов, может таким образом соответствовать больше, чем одному символу, например, если последовательность сопоставления включает элемент ch, то регулярное выражение [[.ch.]]*c соответствует первым пяти символам chchcc.

[=character_class=]

Класс эквивалентности, состоящий из последовательностей символов, включая себя. Например, если o и (+) члены класса эквивалентности, то [[=o=]], [[=(+)=]] и [o(+)] синонимы. Класс эквивалентности не может быть краем диапазона.

[:character_class:]

В выражении в скобках имя символьного класса, включенного в [: и :], представляет список всех символов, принадлежащих к классу. Стандартные символьные имена:

alnum	digit	punct
alpha	graph	space
blank	lower	upper
cntrl	print	xdigit

Это указано для символьных классов, определенных на man-странице ctype(3). Регион или язык может обеспечивать другие. Символьный класс не может использоваться как край диапазона.

mysql> select "justalnums" REGEXP "[[:alnum:]]+"; -> 1
mysql> select "!!" REGEXP "[[:alnum:]]+";         -> 0

[[:<:]]

[[:>:]]

Соответствуют нулевой (пустой) строке в начале и в конце слова соответственно. Слово определено как последовательность символов alnum (как определено в ctype(3)) или символов подчеркивания (_).

mysql> select "a word a" REGEXP "[[:<:]]word[[:>:]]";  -> 1
mysql> select "a xword a" REGEXP "[[:<:]]word[[:>:]]"; -> 0

mysql> select "weeknights" REGEXP "^(wee|week)(knights|nights)$"; -> 1

Партнёры:

Хостинг:

Закладки на сайте
Проследить за страницей

Created 1996-2024 by Maxim Chirkov
Добавить, Поддержать, Вебмастеру