SELECT и WHEREselect_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
( ... )
Используйте круглую скобку, чтобы принудительно задать порядок оценки в вычисляемом выражении. Например:
mysql> select 1+2*3;
-> 7
mysql> select (1+2)*3;
-> 9
Операторы сравнения возвращают значения 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
<=>
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
Все логические функции возвращают 1 (TRUE), 0
(FALSE) или NULL (неизвестное, которое находится в большинстве
случаев также, как FALSE):
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
||
1, если любой параметр не
0 и не NULL:
mysql> select 1 || 0;
-> 1
mysql> select 0 || 0;
-> 0
mysql> select 1 || NULL;
-> 1
AND
&&
0, если параметр 0
или NULL, иначе возвращается 1:
mysql> select 1 && NULL;
-> 0
mysql> select 1 && 0;
-> 0
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).
Строковые функции возвращают NULL, если длина результата
большая, чем параметр сервера max_allowed_packet.
Для функций, которые оперируют позициями в строке, первая позиция всегда пронумерована как 1, а не 0.
ASCII(str)str. Вернет
0, если str пустая. Вернет NULL, если
str равна NULL:
mysql> select ASCII('2');
-> 50
mysql> select ASCII(2);
-> 50
mysql> select ASCII('dx');
-> 100
См. также описание функции ORD().
ORD(str)
((первый байт 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)
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]])
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)
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().
Если строковая функция получает двоичную строку как параметр, возникающая в результате строка также будет двоичной. Числа, преобразованные в строку, также обрабатываются как двоичные строки. Это важно только для сравнений.
Обычно, если любое выражение при сравнении строк чувствительно к регистру, сравнение выполняется в режиме чувствительности к регистру символов.
expr LIKE pat [ESCAPE 'escape-char']
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".
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;
Обычные арифметические операторы доступны. Обратите внимание, что в случае
`-', `+' и `*', результат вычислен с
точностью 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 только, если
выполняется в контексте, где результат преобразован в целое число!Все математические функции возвращают 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)
%
% в языке 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()
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.
Обратитесь к разделу "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)
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)
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"
|
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)
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
MySQL использует BIGINT (64-bit) арифметику для битовых
операций, так что эти операторы имеют максимальный диапазон в 64 бита.
|
mysql> select 29 | 15;
-> 31
&
mysql> select 29 & 15;
-> 13
<<
BIGINT) влево:
mysql> select 1 << 2;
-> 4
>>
BIGINT) вправо:
mysql> select 4 >> 2;
-> 1
~
mysql> select 5 & ~1;
-> 4
BIT_COUNT(N)
N:
mysql> select BIT_COUNT(29);
-> 4
DATABASE()
mysql> select DATABASE();
-> 'test'
Если не имеется никакой текущей базы данных, DATABASE()
возвращает пустую строку.
USER()
SYSTEM_USER()
SESSION_USER()
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)
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> 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)
mysql> select INET_NTOA(3520061480);
-> "209.207.224.40"
INET_ATON(expr)
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)
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();
Регулярные выражения (они же 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
.
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}
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 | xdigit |
ctype(3). Регион или язык может обеспечивать другие. Символьный
класс не может использоваться как край диапазона.
mysql> select "justalnums" REGEXP "[[:alnum:]]+"; -> 1 mysql> select "!!" REGEXP "[[:alnum:]]+"; -> 0
[[:<:]]
[[:>:]]
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