![]() |
|
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
SELECT
and WHERE
Clauses A select_expression
or where_definition
in an SQL statement
can consist of any expression using the functions described below.
An expression that contains NULL
always produces a NULL
value
unless otherwise indicated in the documentation for the operators and
functions involved in the expression.
Note: there must be no whitespace between a function name and the parentheses following it. This helps the MySQL parser distinguish between function calls and references to tables or columns that happen to have the same name as a function. Spaces around arguments are permitted, though.
You can force MySQL to accept spaces after the function name by
starting mysqld
with --ansi
or using the
CLIENT_IGNORE_SPACE
to mysql_connect()
, but in this case all
function names will become reserved words. See section Running MySQL in ANSI Mode.
For the sake of brevity, examples display the output from the mysql
program in abbreviated form. So this:
mysql> SELECT MOD(29,9); 1 rows in set (0.00 sec) +-----------+ | mod(29,9) | +-----------+ | 2 | +-----------+ |
is displayed like this:
mysql> SELECT MOD(29,9); -> 2 |
6.3.1.1 Parentheses | ||
6.3.1.2 Comparison Operators | ||
6.3.1.3 Logical Operators | ||
6.3.1.4 Control Flow Functions |
( ... ) |
Use parentheses to force the order of evaluation in an expression. For example:
mysql> SELECT 1+2*3; -> 7 mysql> SELECT (1+2)*3; -> 9 |
Comparison operations result in a value of 1
(TRUE), 0
(FALSE),
or NULL
. These functions work for both numbers and strings. Strings
are automatically converted to numbers and numbers to strings as needed (as
in Perl).
MySQL performs comparisons using the following rules:
NULL
, the result of the comparison
is NULL
, except for the <=>
operator.
TIMESTAMP
or DATETIME
column and
the other argument is a constant, the constant is converted
to a timestamp before the comparison is performed. This is done to be more
ODBC-friendly.
By default, string comparisons are done in case-independent fashion using the current character set (ISO-8859-1 Latin1 by default, which also works excellently for English).
If you are comparing case-insensitive strings with any of the standard
operators (=
, <>
..., but not LIKE
) trailing whitespace
(spaces, tabs and newlines) will be ignored.
mysql> SELECT "a" ="A \n"; -> 1 |
The following examples illustrate conversion of strings to numbers for comparison operations:
mysql> SELECT 1 > '6x'; -> 0 mysql> SELECT 7 > '6x'; -> 1 mysql> SELECT 0 > 'x6'; -> 0 mysql> SELECT 0 = 'x6'; -> 1 |
=
Equal:
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 |
<>
!=
Not equal:
mysql> SELECT '.01' <> '0.01'; -> 1 mysql> SELECT .01 <> '0.01'; -> 0 mysql> SELECT 'zapp' <> 'zappp'; -> 1 |
<=
Less than or equal:
mysql> SELECT 0.1 <= 2; -> 1 |
<
Less than:
mysql> SELECT 2 < 2; -> 0 |
>=
Greater than or equal:
mysql> SELECT 2 >= 2; -> 1 |
>
Greater than:
mysql> SELECT 2 > 2; -> 0 |
<=>
NULL
-safe equal:
mysql> SELECT 1 <=> 1, NULL <=> NULL, 1 <=> NULL; -> 1 1 0 |
IS NULL
IS NOT NULL
Test whether a value is or is not 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 |
To be able to work well with other programs, MySQL supports the following
extra features when using IS NULL
:
SELECT * FROM tbl_name WHERE auto_col IS NULL |
This can be disabled by setting SQL_AUTO_IS_NULL=0
. See section SET
Syntax.
NOT NULL
DATE
and DATETIME
columns you can find
the special date 0000-00-00
by using:
SELECT * FROM tbl_name WHERE date_column IS NULL |
This is needed to get some ODBC applications to work (as ODBC doesn't
support a 0000-00-00
date)
expr BETWEEN min AND max
If expr
is greater than or equal to min
and expr
is
less than or equal to max
, BETWEEN
returns 1
,
otherwise it returns 0
. This is equivalent to the expression
(min <= expr AND expr <= max)
if all the arguments are of the
same type. Otherwise type conversion takes place, according to the rules
above, but applied to all the three arguments. Note that before
4.0.5 arguments were converted to the type of expr
instead.
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 NOT BETWEEN min AND max
Same as NOT (expr BETWEEN min AND max)
.
expr IN (value,...)
Returns 1
if expr
is any of the values in the IN
list,
else returns 0
. If all values are constants, then all values are
evaluated according to the type of expr
and sorted. The search for the
item is then done using a binary search. This means IN
is very quick
if the IN
value list consists entirely of constants. If expr
is a case-sensitive string expression, the string comparison is performed in
case-sensitive fashion:
mysql> SELECT 2 IN (0,3,5,'wefwf'); -> 0 mysql> SELECT 'wefwf' IN (0,3,5,'wefwf'); -> 1 |
The number of values in the IN
list is only limited by the
max_allowed_packet
value.
From 4.1 (to comply with the SQL-99 standard), IN
returns NULL
not only if the expression on the left hand side is NULL
, but also if
no match is found in the list and one of the expressions in the list is
NULL
.
expr NOT IN (value,...)
Same as NOT (expr IN (value,...))
.
ISNULL(expr)
If expr
is NULL
, ISNULL()
returns 1
, otherwise
it returns 0
:
mysql> SELECT ISNULL(1+1); -> 0 mysql> SELECT ISNULL(1/0); -> 1 |
Note that a comparison of NULL
values using =
will always be
false!
COALESCE(list)
Returns first non-NULL
element in list:
mysql> SELECT COALESCE(NULL,1); -> 1 mysql> SELECT COALESCE(NULL,NULL,NULL); -> NULL |
INTERVAL(N,N1,N2,N3,...)
Returns 0
if N
< N1
, 1
if N
< N2
and so on or -1
if N
is NULL
. All arguments are treated
as integers. It is required that N1
< N2
< N3
<
...
< Nn
for this function to work correctly. This is because
a binary search is used (very fast):
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 |
In SQL, all logical operators evaluate to TRUE, FALSE or NULL (UNKNOWN).
In MySQL, this is implemented as 1
(TRUE), 0
(FALSE),
and NULL
. Most of this is common between different SQL databases,
however some may return any non-zero value for TRUE.
NOT
!
Logical NOT.
Evaluates to 1
if the operand is 0
,
to 0
if the operand is non-zero,
and NOT NULL
returns NULL
.
mysql> SELECT NOT 10; -> 0 mysql> SELECT NOT 0; -> 1 mysql> SELECT NOT NULL; -> NULL mysql> SELECT ! (1+1); -> 0 mysql> SELECT ! 1+1; -> 1 |
The last example produces 1
because the expression evaluates
the same way as (!1)+1
.
AND
&&
Logical AND.
Evaluates to 1
if all operands are non-zero and not NULL
,
to 0
if one or more operands are 0
,
otherwise NULL
is returned.
mysql> SELECT 1 && 1; -> 1 mysql> SELECT 1 && 0; -> 0 mysql> SELECT 1 && NULL; -> NULL mysql> SELECT 0 && NULL; -> 0 mysql> SELECT NULL && 0; -> 0 |
Please note that MySQL versions prior to 4.0.5 stop evaluation when
a NULL
is encountered, rather than continuing the process to
check for possible 0
s. This means that in these versions,
SELECT (NULL AND 0)
returns NULL
instead of 0
.
In 4.0.5 the code has been re-engineered so that the result will
always be as prescribed by the SQL standards while still using the
optimisation wherever possible.
OR
||
Logical OR.
Evaluates to 1
if any operand is non-zero,
to NULL
if any operand is NULL
,
otherwise 0
is returned.
mysql> SELECT 1 || 1; -> 1 mysql> SELECT 1 || 0; -> 1 mysql> SELECT 0 || 0; -> 0 mysql> SELECT 0 || NULL; -> NULL mysql> SELECT 1 || NULL; -> 1 |
XOR
Logical XOR.
Returns NULL
if either operand is NULL
.
For non-NULL
operands, evaluates to 1
if an odd number
of operands is non-zero,
otherwise 0
is returned.
example_for_help_topic XOR mysql> SELECT 1 XOR 1; -> 0 mysql> SELECT 1 XOR 0; -> 1 mysql> SELECT 1 XOR NULL; -> NULL mysql> SELECT 1 XOR 1 XOR 1; -> 1 |
a XOR b
is mathematically equal to
(a AND (NOT b)) OR ((NOT a) and b)
.
XOR
was added in version 4.0.2.
IFNULL(expr1,expr2)
If expr1
is not NULL
, IFNULL()
returns expr1
,
else it returns expr2
. IFNULL()
returns a numeric or string
value, depending on the context in which it is used:
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' |
In 4.0.6 and above the default result value of
IFNULL(expr1,expr2)
is the more 'general' of the two expressions,
in the order STRING
, REAL
or INTEGER
.The difference
to earlier MySQL versions are mostly notable when you create a table
based on expressions or MySQL has to internally store a value from
IFNULL()
in a temporary table.
CREATE TABLE foo SELECT IFNULL(1,"test") as test; |
In MySQL 4.0.6 the type for column 'test' is CHAR(4)
while in
earlier versions you would get BIGINT
.
NULLIF(expr1,expr2)
If expr1 = expr2
is true, return NULL
else return expr1
.
This is the same as CASE WHEN x = y THEN NULL ELSE x END
:
mysql> SELECT NULLIF(1,1); -> NULL mysql> SELECT NULLIF(1,2); -> 1 |
Note that expr1
is evaluated twice in MySQL if the arguments
are not equal.
IF(expr1,expr2,expr3)
If expr1
is TRUE (expr1 <> 0
and expr1 <> NULL
) then
IF()
returns expr2
, else it returns expr3
.
IF()
returns a numeric or string value, depending on the context
in which it is used:
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' |
If expr2
or expr3
is explicitely NULL
then the
result type of the IF()
function is the type of the not
NULL
column. (This behaviour is new in MySQL 4.0.3).
expr1
is evaluated as an integer value, which means that if you are
testing floating-point or string values, you should do so using a comparison
operation:
mysql> SELECT IF(0.1,1,0); -> 0 mysql> SELECT IF(0.1<>0,1,0); -> 1 |
In the first case above, IF(0.1)
returns 0
because 0.1
is converted to an integer value, resulting in a test of IF(0)
. This
may not be what you expect. In the second case, the comparison tests the
original floating-point value to see whether it is non-zero. The result
of the comparison is used as an integer.
The default return type of IF()
(which may matter when it is
stored into a temporary table) is calculated in MySQL Version
3.23 as follows:
Expression | Return value |
expr2 or expr3 returns string | string |
expr2 or expr3 returns a floating-point value | floating-point |
expr2 or expr3 returns an integer | integer |
If expr2 and expr3 are strings, then the result is case-insensitive if both strings are case-insensitive. (Starting from 3.23.51)
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
The first version returns the result
where
value=compare-value
. The second version returns the result for
the first condition, which is true. If there was no matching result
value, then the result after ELSE
is returned. If there is no
ELSE
part then NULL
is returned:
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 |
The type of the return value (INTEGER
, DOUBLE
or
STRING
) is the same as the type of the first returned value (the
expression after the first THEN
).
String-valued functions return NULL
if the length of the result would
be greater than the max_allowed_packet
server parameter. See section Tuning Server Parameters.
For functions that operate on string positions, the first position is numbered 1.
ASCII(str)
Returns the ASCII code value of the leftmost character of the string
str
. Returns 0
if str
is the empty string. Returns
NULL
if str
is NULL
:
mysql> SELECT ASCII('2'); -> 50 mysql> SELECT ASCII(2); -> 50 mysql> SELECT ASCII('dx'); -> 100 |
See also the ORD()
function.
ORD(str)
If the leftmost character of the string str
is a multi-byte character,
returns the code for that character, calculated from the ASCII code values
of its constituent characters using this formula:
((first byte ASCII code)*256+(second byte ASCII code))[*256+third byte ASCII code...]
.
If the leftmost character is not a multi-byte character, returns the same
value that the ASCII()
function does:
mysql> SELECT ORD('2'); -> 50 |
CONV(N,from_base,to_base)
Converts numbers between different number bases. Returns a string
representation of the number N
, converted from base from_base
to base to_base
. Returns NULL
if any argument is NULL
.
The argument N
is interpreted as an integer, but may be specified as
an integer or a string. The minimum base is 2
and the maximum base is
36
. If to_base
is a negative number, N
is regarded as a
signed number. Otherwise, N
is treated as unsigned. CONV
works
with 64-bit precision:
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)
Returns a string representation of the binary value of N
, where
N
is a longlong (BIGINT
) number. This is equivalent to
CONV(N,10,2)
. Returns NULL
if N
is NULL
:
mysql> SELECT BIN(12); -> '1100' |
OCT(N)
Returns a string representation of the octal value of N
, where
N
is a longlong number. This is equivalent to CONV(N,10,8)
.
Returns NULL
if N
is NULL
:
mysql> SELECT OCT(12); -> '14' |
HEX(N_or_S)
If N_OR_S is a number, returns a string representation of the hexadecimal
value of N
, where N
is a longlong (BIGINT
) number.
This is equivalent to CONV(N,10,16)
.
If N_OR_S is a string, returns a hexadecimal string of N_OR_S where each
character in N_OR_S is converted to 2 hexadecimal digits. This is the
invers of the 0xff
strings.
mysql> SELECT HEX(255); -> 'FF' mysql> SELECT HEX("abc"); -> 616263 mysql> SELECT 0x616263; -> "abc" |
CHAR(N,...)
CHAR()
interprets the arguments as integers and returns a string
consisting of the characters given by the ASCII code values of those
integers. NULL
values are skipped:
mysql> SELECT CHAR(77,121,83,81,'76'); -> 'MySQL' mysql> SELECT CHAR(77,77.3,'77.3'); -> 'MMM' |
CONCAT(str1,str2,...)
Returns the string that results from concatenating the arguments. Returns
NULL
if any argument is NULL
. May have more than 2 arguments.
A numeric argument is converted to the equivalent string form:
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()
stands for CONCAT With Separator and is a special form of
CONCAT()
. The first argument is the separator for the rest of the
arguments. The separator can be a string as well as the rest of the
arguments. If the separator is NULL
, the result will be NULL
.
The function will skip any NULL
values after the
separator argument. The separator will be added between the strings to be
concatenated:
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' |
Before MySQL 4.1.1, CONCAT_WS()
skips empty strings as well as
NULL
values.
LENGTH(str)
OCTET_LENGTH(str)
CHAR_LENGTH(str)
CHARACTER_LENGTH(str)
Returns the length of the string str
:
mysql> SELECT LENGTH('text'); -> 4 mysql> SELECT OCTET_LENGTH('text'); -> 4 |
LENGTH()
and OCTET_LENGTH()
are synonyms, and measure string
length in bytes (octets). A multi-byte character counts as multiple bytes.
CHAR_LENGTH()
and CHARACTER_LENGTH()
are synonyms, and measure
string length in characters. A multiple-byte character counts as a single
character.
This means that for a string containing five two-byte characters,
LENGTH()
returns 10
, whereas CHAR_LENGTH()
returns
5
.
BIT_LENGTH(str)
Returns the length of the string str
in bits:
mysql> SELECT BIT_LENGTH('text'); -> 32 |
LOCATE(substr,str)
POSITION(substr IN str)
Returns the position of the first occurrence of substring substr
in string str
. Returns 0
if substr
is not in str
:
mysql> SELECT LOCATE('bar', 'foobarbar'); -> 4 mysql> SELECT LOCATE('xbar', 'foobar'); -> 0 |
This function is multi-byte safe. In MySQL 3.23 this function is case sensitive, while in 4.0 it's only case-sensitive if either argument is a binary string.
LOCATE(substr,str,pos)
Returns the position of the first occurrence of substring substr
in
string str
, starting at position pos
.
Returns 0
if substr
is not in str
:
mysql> SELECT LOCATE('bar', 'foobarbar',5); -> 7 |
This function is multi-byte safe. In MySQL 3.23 this function is case sensitive, while in 4.0 it's only case-sensitive if either argument is a binary string.
INSTR(str,substr)
Returns the position of the first occurrence of substring substr
in
string str
. This is the same as the two-argument form of
LOCATE()
, except that the arguments are swapped:
mysql> SELECT INSTR('foobarbar', 'bar'); -> 4 mysql> SELECT INSTR('xbar', 'foobar'); -> 0 |
This function is multi-byte safe. In MySQL 3.23 this function is case sensitive, while in 4.0 it's only case-sensitive if either argument is a binary string.
LPAD(str,len,padstr)
Returns the string str
, left-padded with the string padstr
until str
is len
characters long. If str
is longer
than len'
then it will be shortened to len
characters.
mysql> SELECT LPAD('hi',4,'??'); -> '??hi' |
RPAD(str,len,padstr)
Returns the string str
, right-padded with the string
padstr
until str
is len
characters long. If
str
is longer than len'
then it will be shortened to
len
characters.
mysql> SELECT RPAD('hi',5,'?'); -> 'hi???' |
LEFT(str,len)
Returns the leftmost len
characters from the string str
:
mysql> SELECT LEFT('foobarbar', 5); -> 'fooba' |
This function is multi-byte safe.
RIGHT(str,len)
Returns the rightmost len
characters from the string str
:
mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar' |
This function is multi-byte safe.
SUBSTRING(str,pos,len)
SUBSTRING(str FROM pos FOR len)
MID(str,pos,len)
Returns a substring len
characters long from string str
,
starting at position pos
.
The variant form that uses FROM
is SQL-92 syntax:
mysql> SELECT SUBSTRING('Quadratically',5,6); -> 'ratica' |
This function is multi-byte safe.
SUBSTRING(str,pos)
SUBSTRING(str FROM pos)
Returns a substring from string str
starting at position pos
:
mysql> SELECT SUBSTRING('Quadratically',5); -> 'ratically' mysql> SELECT SUBSTRING('foobarbar' FROM 4); -> 'barbar' |
This function is multi-byte safe.
SUBSTRING_INDEX(str,delim,count)
Returns the substring from string str
before count
occurrences of the delimiter delim
.
If count
is positive, everything to the left of the final delimiter
(counting from the left) is returned.
If count
is negative, everything to the right of the final delimiter
(counting from the right) is returned:
mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', 2); -> 'www.mysql' mysql> SELECT SUBSTRING_INDEX('www.mysql.com', '.', -2); -> 'mysql.com' |
This function is multi-byte safe.
LTRIM(str)
Returns the string str
with leading space characters removed:
mysql> SELECT LTRIM(' barbar'); -> 'barbar' |
RTRIM(str)
Returns the string str
with trailing space characters removed:
mysql> SELECT RTRIM('barbar '); -> 'barbar' |
This function is multi-byte safe.
TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)
Returns the string str
with all remstr
prefixes and/or suffixes
removed. If none of the specifiers BOTH
, LEADING
or
TRAILING
are given, BOTH
is assumed. If remstr
is not
specified, spaces are removed:
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' |
This function is multi-byte safe.
SOUNDEX(str)
Returns a soundex string from str
. Two strings that sound almost the
same should have identical soundex strings. A standard soundex string
is 4 characters long, but the SOUNDEX()
function returns an
arbitrarily long string. You can use SUBSTRING()
on the result to get
a standard soundex string. All non-alphanumeric characters are ignored
in the given string. All international alpha characters outside the A-Z range
are treated as vowels:
mysql> SELECT SOUNDEX('Hello'); -> 'H400' mysql> SELECT SOUNDEX('Quadratically'); -> 'Q36324' |
SPACE(N)
Returns a string consisting of N
space characters:
mysql> SELECT SPACE(6); -> ' ' |
REPLACE(str,from_str,to_str)
Returns the string str
with all occurrences of the string
from_str
replaced by the string to_str
:
mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); -> 'WwWwWw.mysql.com' |
This function is multi-byte safe.
REPEAT(str,count)
Returns a string consisting of the string str
repeated count
times. If count <= 0
, returns an empty string. Returns NULL
if
str
or count
are NULL
:
mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL' |
REVERSE(str)
Returns the string str
with the order of the characters reversed:
mysql> SELECT REVERSE('abc'); -> 'cba' |
This function is multi-byte safe.
INSERT(str,pos,len,newstr)
Returns the string str
, with the substring beginning at position
pos
and len
characters long replaced by the string
newstr
:
mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic' |
This function is multi-byte safe.
ELT(N,str1,str2,str3,...)
Returns str1
if N
= 1
, str2
if N
=
2
, and so on. Returns NULL
if N
is less than 1
or greater than the number of arguments. ELT()
is the complement of
FIELD()
:
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo'); -> 'ej' mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo'); -> 'foo' |
FIELD(str,str1,str2,str3,...)
Returns the index of str
in the str1
, str2
,
str3
, ...
list.
Returns 0
if str
is not found.
FIELD()
is the complement of 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)
Returns a value 1
to N
if the string str
is in the list
strlist
consisting of N
substrings. A string list is a string
composed of substrings separated by `,' characters. If the first
argument is a constant string and the second is a column of type SET
,
the FIND_IN_SET()
function is optimised to use bit arithmetic!
Returns 0
if str
is not in strlist
or if strlist
is the empty string. Returns NULL
if either argument is NULL
.
This function will not work properly if the first argument contains a
`,':
mysql> SELECT FIND_IN_SET('b','a,b,c,d'); -> 2 |
MAKE_SET(bits,str1,str2,...)
Returns a set (a string containing substrings separated by `,'
characters) consisting of the strings that have the corresponding bit in
bits
set. str1
corresponds to bit 0, str2
to bit 1,
etc. NULL
strings in str1
, str2
, ...
are not appended to the result:
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]])
Returns a string where for every bit set in 'bit', you get an 'on' string and for every reset bit you get an 'off' string. Each string is separated with 'separator' (default ',') and only 'number_of_bits' (default 64) of 'bits' is used:
mysql> SELECT EXPORT_SET(5,'Y','N',',',4) -> Y,N,Y,N |
LCASE(str)
LOWER(str)
Returns the string str
with all characters changed to lowercase
according to the current character set mapping (the default is ISO-8859-1
Latin1):
mysql> SELECT LCASE('QUADRATICALLY'); -> 'quadratically' |
This function is multi-byte safe.
UCASE(str)
UPPER(str)
Returns the string str
with all characters changed to uppercase
according to the current character set mapping (the default is ISO-8859-1
Latin1):
mysql> SELECT UCASE('Hej'); -> 'HEJ' |
This function is multi-byte safe.
LOAD_FILE(file_name)
Reads the file and returns the file contents as a string. The file
must be on the server, you must specify the full pathname to the
file, and you must have the FILE
privilege. The file must
be readable by all and be smaller than max_allowed_packet
.
If the file doesn't exist or can't be read due to one of the above reasons,
the function returns NULL
:
mysql> UPDATE tbl_name SET blob_column=LOAD_FILE("/tmp/picture") WHERE id=1; |
If you are not using MySQL Version 3.23, you have to do the reading
of the file inside your application and create an INSERT
statement
to update the database with the file information. One way to do this, if
you are using the MySQL++ library, can be found at
http://www.mysql.com/documentation/mysql++/mysql++-examples.html.
QUOTE(str)
Quotes a string to produce a result that can be used as a properly escaped
data value in an SQL statement. The string is returned surrounded by single
quotes and with each instance of single quote (`''), backslash (`\'),
ASCII NUL, and Control-Z preceded by a backslash. If the argument is
NULL
, the return value is the word "NULL" without surrounding
single quotes.
The QUOTE
function was added in MySQL version 4.0.3.
mysql> SELECT QUOTE("Don't"); -> 'Don\'t!' mysql> SELECT QUOTE(NULL); -> NULL |
6.3.2.1 String Comparison Functions | ||
6.3.2.2 Case-Sensitivity |
MySQL automatically converts numbers to strings as necessary, and vice-versa:
mysql> SELECT 1+"1"; -> 2 mysql> SELECT CONCAT(2,' test'); -> '2 test' |
If you want to convert a number to a string explicitly, pass it as the
argument to CONCAT()
.
If a string function is given a binary string as an argument, the resulting string is also a binary string. A number converted to a string is treated as a binary string. This only affects comparisons.
Normally, if any expression in a string comparison is case-sensitive, the comparison is performed in case-sensitive fashion.
expr LIKE pat [ESCAPE 'escape-char']
Pattern matching using
SQL simple regular expression comparison. Returns 1
(TRUE) or 0
(FALSE). With LIKE
you can use the following two wildcard characters
in the pattern:
Char | Description |
| Matches any number of characters, even zero characters |
| Matches exactly one character |
mysql> SELECT 'David!' LIKE 'David_'; -> 1 mysql> SELECT 'David!' LIKE '%D%v%'; -> 1 |
To test for literal instances of a wildcard character, precede the character
with the escape character. If you don't specify the ESCAPE
character,
`\' is assumed:
String | Description |
| Matches one |
| Matches one |
mysql> SELECT 'David!' LIKE 'David\_'; -> 0 mysql> SELECT 'David_' LIKE 'David\_'; -> 1 |
To specify a different escape character, use the ESCAPE
clause:
mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|'; -> 1 |
The following two statements illustrate that string comparisons are case-insensitive unless one of the operands is a binary string:
mysql> SELECT 'abc' LIKE 'ABC'; -> 1 mysql> SELECT 'abc' LIKE BINARY 'ABC'; -> 0 |
LIKE
is allowed on numeric expressions! (This is a MySQL
extension to the SQL-99 LIKE
.)
mysql> SELECT 10 LIKE '1%'; -> 1 |
Note: Because MySQL uses the C escape syntax in strings (for example,
`\n'), you must double any `\' that you use in your LIKE
strings. For example, to search for `\n', specify it as `\\n'. To
search for `\', specify it as `\\\\' (the backslashes are stripped
once by the parser and another time when the pattern match is done, leaving
a single backslash to be matched).
Note: Currently LIKE
is not multi-byte character
safe.
Comparison is done character by character.
expr NOT LIKE pat [ESCAPE 'escape-char']
Same as NOT (expr LIKE pat [ESCAPE 'escape-char'])
.
expr SOUNDS LIKE expr
Same as SOUNDEX(expr)=SOUNDEX(expr)
(available only in version 4.1 or later).
expr REGEXP pat
expr RLIKE pat
Performs a pattern match of a string expression expr
against a pattern
pat
. The pattern can be an extended regular expression.
See section MySQL Regular Expressions. Returns 1
if expr
matches pat
, otherwise
returns 0
. RLIKE
is a synonym for REGEXP
, provided for
mSQL
compatibility. Note: Because MySQL uses the C escape
syntax in strings (for example, `\n'), you must double any `\' that
you use in your REGEXP
strings. As of MySQL Version 3.23.4,
REGEXP
is case-insensitive for normal (not binary) strings:
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
and RLIKE
use the current character set (ISO-8859-1
Latin1 by default) when deciding the type of a character.
expr NOT REGEXP pat
expr NOT RLIKE pat
Same as NOT (expr REGEXP pat)
.
STRCMP(expr1,expr2)
STRCMP()
returns 0
if the strings are the same, -1
if the first
argument is smaller than the second according to the current sort order,
and 1
otherwise:
mysql> SELECT STRCMP('text', 'text2'); -> -1 mysql> SELECT STRCMP('text2', 'text'); -> 1 mysql> SELECT STRCMP('text', 'text'); -> 0 |
MATCH (col1,col2,...) AGAINST (expr)
MATCH (col1,col2,...) AGAINST (expr IN BOOLEAN MODE)
MATCH ... AGAINST()
is used for full-text search and returns
relevance - similarity measure between the text in columns
(col1,col2,...)
and the query expr
. Relevance is a
positive floating-point number. Zero relevance means no similarity.
MATCH ... AGAINST()
is available in MySQL version
3.23.23 or later. IN BOOLEAN MODE
extension was added in version
4.0.1. For details and usage examples, see MySQL Full-text Search.
BINARY
The BINARY
operator casts the string following it to a binary string.
This is an easy way to force a column comparison to be case-sensitive even
if the column isn't defined as BINARY
or BLOB
:
mysql> SELECT "a" = "A"; -> 1 mysql> SELECT BINARY "a" = "A"; -> 0 |
BINARY string
is a shorthand for CAST(string AS BINARY)
.
See section Cast Functions.
BINARY
was introduced in MySQL Version 3.23.0.
Note that in some context MySQL will not be able to use the
index efficiently when you cast an indexed column to BINARY
.
If you want to compare a blob case-insensitively you can always convert the blob to upper case before doing the comparison:
SELECT 'A' LIKE UPPER(blob_col) FROM table_name; |
We plan to soon introduce casting between different character sets to make string comparison even more flexible.
6.3.3.1 Arithmetic Operations | ||
6.3.3.2 Mathematical Functions |
The usual arithmetic operators are available. Note that in the case of
`-', `+', and `*', the result is calculated with
BIGINT
(64-bit) precision if both arguments are integers!
If one of the argument is an unsigned integer, and the other argument
is also an integer, the result will be an unsigned integer.
See section Cast Functions.
+
Addition:
mysql> SELECT 3+5; -> 8 |
-
Subtraction:
mysql> SELECT 3-5; -> -2 |
*
Multiplication:
mysql> SELECT 3*5; -> 15 mysql> SELECT 18014398509481984*18014398509481984.0; -> 324518553658426726783156020576256.0 mysql> SELECT 18014398509481984*18014398509481984; -> 0 |
The result of the last expression is incorrect because the result of the
integer multiplication exceeds the 64-bit range of BIGINT
calculations.
/
Division:
mysql> SELECT 3/5; -> 0.60 |
Division by zero produces a NULL
result:
mysql> SELECT 102/(1-1); -> NULL |
A division will be calculated with BIGINT
arithmetic only if performed
in a context where its result is converted to an integer!
All mathematical functions return NULL
in case of an error.
-
Unary minus. Changes the sign of the argument:
mysql> SELECT - 2; -> -2 |
Note that if this operator is used with a BIGINT
, the return value is a
BIGINT
! This means that you should avoid using -
on integers that
may have the value of -2^63
!
ABS(X)
Returns the absolute value of X
:
mysql> SELECT ABS(2); -> 2 mysql> SELECT ABS(-32); -> 32 |
This function is safe to use with BIGINT
values.
SIGN(X)
Returns the sign of the argument as -1
, 0
, or 1
, depending
on whether X
is negative, zero, or positive:
mysql> SELECT SIGN(-32); -> -1 mysql> SELECT SIGN(0); -> 0 mysql> SELECT SIGN(234); -> 1 |
MOD(N,M)
%
Modulo (like the %
operator in C).
Returns the remainder of N
divided by M
:
mysql> SELECT MOD(234, 10); -> 4 mysql> SELECT 253 % 7; -> 1 mysql> SELECT MOD(29,9); -> 2 mysql> SELECT 29 MOD 9; -> 2 |
This function is safe to use with BIGINT
values.
The last example only works in MySQL 4.1
FLOOR(X)
Returns the largest integer value not greater than X
:
mysql> SELECT FLOOR(1.23); -> 1 mysql> SELECT FLOOR(-1.23); -> -2 |
Note that the return value is converted to a BIGINT
!
CEILING(X)
CEIL(X)
Returns the smallest integer value not less than X
:
mysql> SELECT CEILING(1.23); -> 2 mysql> SELECT CEIL(-1.23); -> -1 |
The CEIL()
alias was added in version 4.0.6.
Note that the return value is converted to a BIGINT
!
ROUND(X)
ROUND(X,D)
Returns the argument X
, rounded to the nearest integer.
With two arguments rounded to a number to D
decimals.
mysql> SELECT ROUND(-1.23); -> -1 mysql> SELECT ROUND(-1.58); -> -2 mysql> SELECT ROUND(1.58); -> 2 mysql> SELECT ROUND(1.298, 1); -> 1.3 mysql> SELECT ROUND(1.298, 0); -> 1 mysql> SELECT ROUND(23.298, -1); -> 20 |
Note that the behaviour of ROUND()
when the argument
is half way between two integers depends on the C library
implementation. Some round to the nearest even number,
always up, always down, or always toward zero. If you need
one kind of rounding, you should use a well-defined function
like TRUNCATE()
or FLOOR()
instead.
DIV
Integer division.
Similar to FLOOR()
but safe with BIGINT
values.
mysql> SELECT 5 DIV 2 -> 2 |
DIV
is new in MySQL 4.1.0.
EXP(X)
Returns the value of e
(the base of natural logarithms) raised to
the power of X
:
mysql> SELECT EXP(2); -> 7.389056 mysql> SELECT EXP(-2); -> 0.135335 |
LN(X)
Returns the natural logarithm of X
:
mysql> SELECT LN(2); -> 0.693147 mysql> SELECT LN(-2); -> NULL |
This function was added in MySQL version 4.0.3.
It is synonymous with LOG(X)
in MySQL.
LOG(X)
LOG(B,X)
If called with one parameter, this function returns the natural logarithm
of X
:
mysql> SELECT LOG(2); -> 0.693147 mysql> SELECT LOG(-2); -> NULL |
If called with two parameters, this function returns the logarithm of
X
for an arbitary base B
:
mysql> SELECT LOG(2,65536); -> 16.000000 mysql> SELECT LOG(1,100); -> NULL |
The arbitrary base option was added in MySQL version 4.0.3.
LOG(B,X)
is equivalent to LOG(X)/LOG(B)
.
LOG2(X)
Returns the base-2 logarithm of X
:
mysql> SELECT LOG2(65536); -> 16.000000 mysql> SELECT LOG2(-100); -> NULL |
LOG2()
is useful for finding out how many bits a number would
require for storage.
This function was added in MySQL version 4.0.3.
In earlier versions, you can use LOG(X)/LOG(2)
instead.
LOG10(X)
Returns the base-10 logarithm of X
:
mysql> SELECT LOG10(2); -> 0.301030 mysql> SELECT LOG10(100); -> 2.000000 mysql> SELECT LOG10(-100); -> NULL |
POW(X,Y)
POWER(X,Y)
Returns the value of X
raised to the power of Y
:
mysql> SELECT POW(2,2); -> 4.000000 mysql> SELECT POW(2,-2); -> 0.250000 |
SQRT(X)
Returns the non-negative square root of X
:
mysql> SELECT SQRT(4); -> 2.000000 mysql> SELECT SQRT(20); -> 4.472136 |
PI()
Returns the value of PI. The default shown number of decimals is 5, but MySQL internally uses the full double precession for PI.
mysql> SELECT PI(); -> 3.141593 mysql> SELECT PI()+0.000000000000000000; -> 3.141592653589793116 |
COS(X)
Returns the cosine of X
, where X
is given in radians:
mysql> SELECT COS(PI()); -> -1.000000 |
SIN(X)
Returns the sine of X
, where X
is given in radians:
mysql> SELECT SIN(PI()); -> 0.000000 |
TAN(X)
Returns the tangent of X
, where X
is given in radians:
mysql> SELECT TAN(PI()+1); -> 1.557408 |
ACOS(X)
Returns the arc cosine of X
, that is, the value whose cosine is
X
. Returns NULL
if X
is not in the range -1
to
1
:
mysql> SELECT ACOS(1); -> 0.000000 mysql> SELECT ACOS(1.0001); -> NULL mysql> SELECT ACOS(0); -> 1.570796 |
ASIN(X)
Returns the arc sine of X
, that is, the value whose sine is
X
. Returns NULL
if X
is not in the range -1
to
1
:
mysql> SELECT ASIN(0.2); -> 0.201358 mysql> SELECT ASIN('foo'); -> 0.000000 |
ATAN(X)
Returns the arc tangent of X
, that is, the value whose tangent is
X
:
mysql> SELECT ATAN(2); -> 1.107149 mysql> SELECT ATAN(-2); -> -1.107149 |
ATAN(Y,X)
ATAN2(Y,X)
Returns the arc tangent of the two variables X
and Y
. It is
similar to calculating the arc tangent of Y / X
, except that the
signs of both arguments are used to determine the quadrant of the
result:
mysql> SELECT ATAN(-2,2); -> -0.785398 mysql> SELECT ATAN2(PI(),0); -> 1.570796 |
COT(X)
Returns the cotangent of X
:
mysql> SELECT COT(12); -> -1.57267341 mysql> SELECT COT(0); -> NULL |
CRC32(expr)
Computes a cyclic redundancy check value and returns a 32-bit unsigned value.
The result is NULL
if the argument is NULL
.
The argument is expected be a string and will be treated as one if it is not.
mysql> SELECT CRC32('MySQL'); -> 3259397556 |
CRC32()
is available as of MySQL 4.1.0.
RAND()
RAND(N)
Returns a random floating-point value in the range 0
to 1.0
.
If an integer argument N
is specified, it is used as the seed value
(producing a repeatable sequence):
mysql> SELECT RAND(); -> 0.9233482386203 mysql> SELECT RAND(20); -> 0.15888261251047 mysql> SELECT RAND(20); -> 0.15888261251047 mysql> SELECT RAND(); -> 0.63553050033332 mysql> SELECT RAND(); -> 0.70100469486881 |
You can't use a column with RAND()
values in an ORDER BY
clause, because ORDER BY
would evaluate the column multiple times.
From version 3.23 you can do:
SELECT * FROM table_name ORDER BY RAND()
This is useful to get a random sample of a set SELECT * FROM
table1,table2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000
.
Note that a RAND()
in a WHERE
clause will be re-evaluated
every time the WHERE
is executed.
RAND()
is not meant to be a perfect random generator, but instead a
fast way to generate ad hoc random numbers that will be portable between
platforms for the same MySQL version.
LEAST(X,Y,...)
With two or more arguments, returns the smallest (minimum-valued) argument. The arguments are compared using the following rules:
INTEGER
context, or all arguments
are integer-valued, they are compared as integers.
REAL
context, or all arguments are
real-valued, they are compared as reals.
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" |
In MySQL versions prior to Version 3.22.5, you can use MIN()
instead of LEAST
.
GREATEST(X,Y,...)
Returns the largest (maximum-valued) argument.
The arguments are compared using the same rules as for 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" |
In MySQL versions prior to Version 3.22.5, you can use MAX()
instead of GREATEST
.
DEGREES(X)
Returns the argument X
, converted from radians to degrees:
mysql> SELECT DEGREES(PI()); -> 180.000000 |
RADIANS(X)
Returns the argument X
, converted from degrees to radians:
mysql> SELECT RADIANS(90); -> 1.570796 |
TRUNCATE(X,D)
Returns the number X
, truncated to D
decimals. If D
is 0
, the result will have no decimal point or fractional part:
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(-1.999,1); -> -1.9 |
Starting from MySQL 3.23.51, all numbers are rounded toward zero.
If D
is negative, then the whole part of the number is zeroed out:
mysql> SELECT TRUNCATE(122,-2); -> 100 |
Note that as decimal numbers are normally not stored as exact numbers in computers, but as double-precision values, you may be fooled by the following result:
mysql> SELECT TRUNCATE(10.28*100,0); -> 1027 |
The above happens because 10.28 is actually stored as something like 10.2799999999999999.
This section describes the functions that can be used to manipulate temporal values. See Date and Time Types for a description of the range of values each date and time type has and the valid formats in which values may be specified.
Here is an example that uses date functions. The following query selects
all records with a date_col
value from within the last 30 days:
mysql> SELECT something FROM tbl_name WHERE TO_DAYS(NOW()) - TO_DAYS(date_col) <= 30; |
(Note that the query will also select records with dates that lie in the future.)
Functions that expect date values usually will accept datetime values and ignore the time part. Functions that expect time values usually will accept datetime values and ignore the date part.
Functions that return the current date or time each are evaluated only once
per query at the start of query execution. This means that multiple references
to a function such as NOW()
within a single query will always produce
the same result. This principle also applies to CURDATE()
,
CURTIME()
, UTC_DATE()
, UTC_TIME()
, UTC_TIMESTAMP()
,
and any of their synonyms.
The return value ranges in the following function descriptions apply for
complete dates. If a date is a "zero" value or an incomplete date such
as '2001-11-00'
, functions that extract a part of a date may return
0
. For example, DAYOFMONTH('2001-11-00')
returns 0
.
DATE(expr)
Extracts the date part of the date or datetime expression expr
.
mysql> SELECT DATE('2003-12-31 01:02:03'); -> '2003-12-31' |
DATE()
is available as of MySQL 4.1.1.
TIME(expr)
Extracts the time part of the time or datetime expression expr
.
mysql> SELECT TIME('2003-12-31 01:02:03'); -> '01:02:03' mysql> SELECT TIME('2003-12-31 01:02:03.000123'); -> '01:02:03.000123' |
TIME()
is available as of MySQL 4.1.1.
TIMESTAMP(expr)
TIMESTAMP(expr,expr2)
With one argument, returns the date or datetime expression expr
as a datetime value.
With two arguments, adds the time expression expr2
to the
date or datetime expression expr
and returns a datetime value.
mysql> SELECT TIMESTAMP('2003-12-31'); -> '2003-12-31 00:00:00' mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00'); -> '2004-01-01 00:00:00' |
TIMESTAMP()
is available as of MySQL 4.1.1.
DAYOFWEEK(date)
Returns the weekday index
for date
(1
= Sunday, 2
= Monday, ... 7
=
Saturday). These index values correspond to the ODBC standard.
mysql> SELECT DAYOFWEEK('1998-02-03'); -> 3 |
WEEKDAY(date)
Returns the weekday index for
date
(0
= Monday, 1
= Tuesday, ... 6
= Sunday):
mysql> SELECT WEEKDAY('1998-02-03 22:23:00'); -> 1 mysql> SELECT WEEKDAY('1997-11-05'); -> 2 |
DAYOFMONTH(date)
Returns the day of the month for date
, in the range 1
to
31
:
mysql> SELECT DAYOFMONTH('1998-02-03'); -> 3 |
DAY(date)
DAY()
is a synonym for DAYOFMONTH()
.
It is available as of MySQL 4.1.1.
DAYOFYEAR(date)
Returns the day of the year for date
, in the range 1
to
366
:
mysql> SELECT DAYOFYEAR('1998-02-03'); -> 34 |
MONTH(date)
Returns the month for date
, in the range 1
to 12
:
mysql> SELECT MONTH('1998-02-03'); -> 2 |
DAYNAME(date)
Returns the name of the weekday for date
:
mysql> SELECT DAYNAME('1998-02-05'); -> 'Thursday' |
MONTHNAME(date)
Returns the name of the month for date
:
mysql> SELECT MONTHNAME('1998-02-05'); -> 'February' |
QUARTER(date)
Returns the quarter of the year for date
, in the range 1
to 4
:
mysql> SELECT QUARTER('98-04-01'); -> 2 |
WEEK(date)
WEEK(date,start)
With a single argument, returns the week for date
, in the range
0
to 53
(yes, there may be the beginnings of a week 53),
for locations where Sunday is the first day of the week. The
two-argument form of WEEK()
allows you to specify whether the
week starts on Sunday or Monday and whether the return value should be in
the range 0-53
or 1-52
.
The following table demonstrates how the start
argument works:
Value | Meaning |
| Week starts on Sunday; return value range is |
| Week starts on Monday; return value range is |
| Week starts on Sunday; return value range is |
| Week starts on Monday; return value range is |
The start
value of 3
can be used as of MySQL 4.0.5.
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 |
For MySQL 3.23 and 4.0, the default value for the start
argument is 0.
In MySQL 4.1, you can control the default value of the start
argument
by using the default_week_format
variable. The syntax for setting default_week_format
is:
SET [SESSION | GLOBAL] default_week_format = {0|1|2|3}; |
Note: In Version 4.0, WEEK(date,0)
was changed to match the
calendar in the USA. Before that, WEEK()
was calculated incorrectly
for dates in USA. (In effect, WEEK(date)
and WEEK(date,0)
was
incorrect for all cases.)
Note that if a date falls in the last week of the previous year, MySQL will
return 0
if you don't use 2
or 3
as the optional
start
argument:
mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0); -> 2000, 0 |
One might argue that MySQL should return 52
for the WEEK()
function, because the given date actually occurs in the 52nd week of 1999. We
decided to return 0
instead as we want the function to return "the week
number in the given year." This makes the usage of the WEEK()
function reliable when combined with other functions that extract a
date part from a date.
If you would prefer the result to be evaluated with respect to the year
that contains the first day of the week for the given date, you should use
2
or 3
as the optional start
argument.
mysql> SELECT WEEK('2000-01-01',2); -> 52 |
Alternatively, use the YEARWEEK()
function:
mysql> SELECT YEARWEEK('2000-01-01'); -> 199952 mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2); -> '52' |
WEEKOFYEAR(date)
Returns the calendar week of the date as a number in the
range from 1
to 53
.
mysql> SELECT WEEKOFYEAR('1998-02-20'); -> 8 |
WEEKOFYEAR()
is available as of MySQL 4.1.1.
YEAR(date)
Returns the year for date
, in the range 1000
to 9999
:
mysql> SELECT YEAR('98-02-03'); -> 1998 |
YEARWEEK(date)
YEARWEEK(date,start)
Returns year and week for a date. The start
argument works exactly
like the start
argument to WEEK()
. Note that the year in the
result may be
different from the year in the date argument for the first and the last
week of the year:
mysql> SELECT YEARWEEK('1987-01-01'); -> 198653 |
Note that the week number is different from what the WEEK()
function would return (0
) for optional arguments 0
or 1
,
as WEEK()
then returns the week in the context of the given year.
HOUR(time)
Returns the hour for time
. The range of the return value will be
0
to 23
for time-of-day values:
mysql> SELECT HOUR('10:05:03'); -> 10 |
However, the range of TIME
values actually is much larger, so
HOUR
can return values greater than 23
:
mysql> SELECT HOUR('272:59:59'); -> 272 |
MINUTE(time)
Returns the minute for time
, in the range 0
to 59
:
mysql> SELECT MINUTE('98-02-03 10:05:03'); -> 5 |
SECOND(time)
Returns the second for time
, in the range 0
to 59
:
mysql> SELECT SECOND('10:05:03'); -> 3 |
MICROSECOND(expr)
Returns the microseconds from the time or datetime expression expr
as a
number in the range from 0
to 999999
.
mysql> SELECT MICROSECOND('12:00:00.123456'); -> 123456 mysql> SELECT MICROSECOND('1997-12-31 23:59:59.000010'); -> 10 |
MICROSECOND()
is available as of MySQL 4.1.1.
PERIOD_ADD(P,N)
Adds N
months to period P
(in the format YYMM
or
YYYYMM
). Returns a value in the format YYYYMM
.
Note that the period argument P
is not a date value:
mysql> SELECT PERIOD_ADD(9801,2); -> 199803 |
PERIOD_DIFF(P1,P2)
Returns the number of months between periods P1
and P2
.
P1
and P2
should be in the format YYMM
or YYYYMM
.
Note that the period arguments P1
and P2
are not
date values:
mysql> SELECT PERIOD_DIFF(9802,199703); -> 11 |
DATE_ADD(date,INTERVAL expr type)
DATE_SUB(date,INTERVAL expr type)
These functions perform date arithmetic.
As of MySQL Version 3.23, INTERVAL expr type
is allowed on either
side of the +
operator if the expression on the other side is a
date or datetime value.
For the -
operator, INTERVAL expr type
is allowed only on
the right side, because
it makes no sense to subtract a date or datetime value from an interval.
(See examples below.)
date
is a DATETIME
or DATE
value specifying the starting
date. expr
is an expression specifying the interval value to be added
or subtracted from the starting date. expr
is a string; it may start
with a `-' for negative intervals. type
is a keyword indicating
how the expression should be interpreted.
The following table shows how the type
and expr
arguments
are related:
| Expected |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
The type
values DAY_MICROSECOND
, HOUR_MICROSECOND
,
MINUTE_MICROSECOND
, SECOND_MICROSECOND
,
and MICROSECOND
are allowed as of MySQL 4.1.1.
MySQL allows any punctuation delimiter in the expr
format.
Those shown in the table are the suggested delimiters. If the date
argument is a DATE
value and your calculations involve only
YEAR
, MONTH
, and DAY
parts (that is, no time parts), the
result is a DATE
value. Otherwise, the result is a DATETIME
value:
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' mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002', -> INTERVAL '1.999999' SECOND_MICROSECOND); -> '1993-01-01 00:00:01.000001' |
If you specify an interval value that is too short (does not include all the
interval parts that would be expected from the type
keyword),
MySQL assumes you have left out the leftmost parts of the interval
value. For example, if you specify a type
of DAY_SECOND
, the
value of expr
is expected to have days, hours, minutes, and seconds
parts. If you specify a value like '1:10'
, MySQL assumes
that the days and hours parts are missing and the value represents minutes
and seconds. In other words, '1:10' DAY_SECOND
is interpreted in such
a way that it is equivalent to '1:10' MINUTE_SECOND
. This is
analogous to the way that MySQL interprets TIME
values
as representing elapsed time rather than as time of day.
Note that if you add to or subtract from a date value something that contains a time part, the result is automatically converted to a datetime value:
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' |
If you use really malformed dates, the result is NULL
. If you add
MONTH
, YEAR_MONTH
, or YEAR
and the resulting date
has a day that is larger than the maximum day for the new month, the day is
adjusted to the maximum days in the new month:
mysql> SELECT DATE_ADD('1998-01-30', interval 1 month); -> '1998-02-28' |
Note from the preceding example that the keyword INTERVAL
and the
type
specifier are not case-sensitive.
ADDDATE(date,INTERVAL expr type)
SUBDATE(date,INTERVAL expr type)
ADDDATE(expr,days)
SUBDATE(expr,days)
When invoked with the INTERVAL
form of the second argument,
ADDDATE()
and SUBDATE()
are synonyms for DATE_ADD()
and
DATE_SUB()
.
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY); -> '1998-02-02' mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY); -> '1998-02-02' mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY); -> '1997-12-02' mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY); -> '1997-12-02' |
As of MySQL 4.1.1, the second syntax is allowed, where expr
is a date
or datetime expression and days
is the number of days to be added to or
subtracted from expr
.
mysql> SELECT ADDDATE('1998-01-02', 31); -> '1998-02-02' mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31); -> '1997-12-02 12:00:00' |
ADDTIME(expr,expr2)
SUBTIME(expr,expr2)
expr
is a date or datetime expression, and expr2
is a time
expression.
[Rest of description to be added here]
NEED EXAMPLE |
ADDTIME()
and SUBTIME()
were added in MySQL 4.1.1.
EXTRACT(type FROM date)
The EXTRACT()
function uses the same kinds of interval type
specifiers as DATE_ADD()
or DATE_SUB()
, but extracts parts
from the date rather than performing date arithmetic.
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 mysql> SELECT EXTRACT(MICROSECOND FROM "2003-01-02 10:30:00.00123"); -> 123 |
DATEDIFF(ARGUMENTS)
TIMEDIFF(ARGUMENTS)
[Rest of description to be added here]
NEED EXAMPLE |
DATEDIFF()
and TIMEDIFF()
were added in MySQL 4.1.1.
TO_DAYS(date)
Given a date date
, returns a daynumber (the number of days since year
0):
mysql> SELECT TO_DAYS(950501); -> 728779 mysql> SELECT TO_DAYS('1997-10-07'); -> 729669 |
TO_DAYS()
is not intended for use with values that precede the advent
of the Gregorian calendar (1582), because it doesn't take into account the
days that were lost when the calendar was changed.
FROM_DAYS(N)
Given a daynumber N
, returns a DATE
value:
mysql> SELECT FROM_DAYS(729669); -> '1997-10-07' |
FROM_DAYS()
is not intended for use with values that precede the
advent of the Gregorian calendar (1582), because it doesn't take into account
the days that were lost when the calendar was changed.
DATE_FORMAT(date,format)
Formats the date
value according to the format
string. The
following specifiers may be used in the format
string:
Specifier | Description |
| Month name ( |
| Weekday name ( |
| Day of the month with English suffix ( |
| Year, numeric, 4 digits |
| Year, numeric, 2 digits |
| Year for the week where Sunday is the first day of the week, numeric, 4 digits; used with |
| Year for the week, where Monday is the first day of the week, numeric, 4 digits; used with |
| Abbreviated weekday name ( |
| Day of the month, numeric ( |
| Day of the month, numeric ( |
| Month, numeric ( |
| Month, numeric ( |
| Abbreviated month name ( |
| Day of year ( |
| Hour ( |
| Hour ( |
| Hour ( |
| Hour ( |
| Hour ( |
| Minutes, numeric ( |
| Time, 12-hour ( |
| Time, 24-hour ( |
| Seconds ( |
| Seconds ( |
| Microseconds ( |
| |
| Day of the week ( |
| Week ( |
| Week ( |
| Week ( |
| Week ( |
| A literal `%'. |
All other characters are just copied to the result without interpretation.
The %f
format specifier is available as of MySQL 4.1.1.
As of MySQL Version 3.23, the `%' character is required before format specifier characters. In earlier versions of MySQL, `%' was optional.
The reason the ranges for the month and day specifiers begin with zero
is that MySQL allows incomplete dates such as '2004-00-00'
to be
stored as of MySQL 3.23.
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' |
TIME_FORMAT(time,format)
This is used like the DATE_FORMAT()
function above, but the
format
string may contain only those format specifiers that handle
hours, minutes, and seconds. Other specifiers produce a NULL
value or
0
.
If the time
value contains an hour part that is greater than
23
, the %H
and %k
hour format specifiers produce a
value larger than the usual range of 0..23
. The other hour format
specifiers produce the hour value modulo 12:
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l'); -> '100 100 04 04 4' |
MAKEDATE(year,dayofyear)
Returns a date, given year and day-of-year values.
dayofyear
must be greater than 0 or the result will NULL
.
mysql> SELECT MAKEDATE(2001,31), MAKEDATE(2001,32); -> '2001-01-31', '2001-02-01' mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365); -> '2001-12-31', '2004-12-30' mysql> SELECT MAKEDATE(2001,0); -> NULL |
MAKEDATE()
is available as of MySQL 4.1.1.
MAKETIME(hour,minute,second)
Returns a time value calculated from the hour
, minute
, and
second
arguments.
mysql> SELECT MAKETIME(12,15,30); -> '12:15:30' |
MAKETIME()
is available as of MySQL 4.1.1.
CURDATE()
CURRENT_DATE
Returns the current date as a value in 'YYYY-MM-DD'
or YYYYMMDD
format, depending on whether the function is used in a string or numeric
context:
mysql> SELECT CURDATE(); -> '1997-12-15' mysql> SELECT CURDATE() + 0; -> 19971215 |
CURTIME()
CURRENT_TIME
Returns the current time as a value in 'HH:MM:SS'
or HHMMSS
format, depending on whether the function is used in a string or numeric
context:
mysql> SELECT CURTIME(); -> '23:50:26' mysql> SELECT CURTIME() + 0; -> 235026 |
NOW()
SYSDATE()
CURRENT_TIMESTAMP
Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS'
or YYYYMMDDHHMMSS
format, depending on whether the function is used in
a string or numeric context:
mysql> SELECT NOW(); -> '1997-12-15 23:50:26' mysql> SELECT NOW() + 0; -> 19971215235026 |
UNIX_TIMESTAMP()
UNIX_TIMESTAMP(date)
If called with no argument, returns a Unix timestamp (seconds since
'1970-01-01 00:00:00'
GMT) as an unsigned integer. If
UNIX_TIMESTAMP()
is called with a date
argument, it
returns the value of the argument as seconds since '1970-01-01
00:00:00'
GMT. date
may be a DATE
string, a
DATETIME
string, a TIMESTAMP
, or a number in the format
YYMMDD
or YYYYMMDD
in local time:
mysql> SELECT UNIX_TIMESTAMP(); -> 882226357 mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00'); -> 875996580 |
When UNIX_TIMESTAMP
is used on a TIMESTAMP
column, the function
returns the internal timestamp value directly, with no implicit
"string-to-Unix-timestamp" conversion.
If you pass an out-of-range date to UNIX_TIMESTAMP()
it
returns 0
, but please note that only basic checking is performed
(year 1970-2037, month 01-12, day 01-31).
If you want to subtract UNIX_TIMESTAMP()
columns, you may want to
cast the result to signed integers. See section Cast Functions.
FROM_UNIXTIME(unix_timestamp)
FROM_UNIXTIME(unix_timestamp,format)
Returns a representation of the unix_timestamp
argument as a value in
'YYYY-MM-DD HH:MM:SS'
or YYYYMMDDHHMMSS
format, depending on
whether the function is used in a string or numeric context:
mysql> SELECT FROM_UNIXTIME(875996580); -> '1997-10-04 22:23:00' mysql> SELECT FROM_UNIXTIME(875996580) + 0; -> 19971004222300 |
If format
is given, the result is formatted according to the
format
string. format
may contain the same specifiers as
those listed in the entry for the DATE_FORMAT()
function:
mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(), -> '%Y %D %M %h:%i:%s %x'); -> '2003 6th August 06:22:58 2003' |
SEC_TO_TIME(seconds)
Returns the seconds
argument, converted to hours, minutes, and seconds,
as a value in 'HH:MM:SS'
or HHMMSS
format, depending on whether
the function is used in a string or numeric context:
mysql> SELECT SEC_TO_TIME(2378); -> '00:39:38' mysql> SELECT SEC_TO_TIME(2378) + 0; -> 3938 |
TIME_TO_SEC(time)
Returns the time
argument, converted to seconds:
mysql> SELECT TIME_TO_SEC('22:23:00'); -> 80580 mysql> SELECT TIME_TO_SEC('00:39:38'); -> 2378 |
UTC_DATE()
Returns the current UTC date as a value in 'YYYY-MM-DD'
or
YYYYMMDD
format, depending on whether the function is used in a
string or numeric context:
mysql> SELECT UTC_DATE(), UTC_DATE() + 0; -> '2003-08-14', 20030814 |
UTC_DATE()
is available as of MySQL 4.1.1.
UTC_TIME()
Returns the current UTC time as a value in 'HH:MM:SS'
or HHMMSS
format, depending on whether the function is used in a string or numeric
context:
mysql> SELECT UTC_TIME(), UTC_TIME() + 0; -> '18:07:53', 180753 |
UTC_TIME()
is available as of MySQL 4.1.1.
UTC_TIMESTAMP()
Returns the current UTC date and time as a value in 'YYYY-MM-DD HH:MM:SS'
or YYYYMMDDHHMMSS
format, depending on whether the function is used in
a string or numeric context:
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0; -> '2003-08-14 18:08:04', 20030814180804 |
UTC_TIMESTAMP()
is available as of MySQL 4.1.1.
The CAST()
and CONVERT()
functions may be used to take a
value of one type and produce a value of another type. Their syntax is:
CAST(expression AS type) CONVERT(expression,type) CONVERT(expr USING transcoding_name) |
The type
value can be one of the following:
BINARY
CHAR
DATE
DATETIME
SIGNED {INTEGER}
TIME
UNSIGNED {INTEGER}
CAST()
and CONVERT()
are available as of MySQL 4.0.2.
The CHAR
conversion type is available as of 4.0.6.
The USING
form of CONVERT()
is available as of 4.1.0.
CAST()
and CONVERT(... USING ...)
are SQL-99 syntax.
The non-USING
form of CONVERT()
is ODBC syntax.
The cast functions are useful when you want to create a column with
a specific type in a CREATE ... SELECT
statement:
CREATE TABLE new_table SELECT CAST('2000-01-01' AS DATE); |
The functions also can be useful for sorting ENUM
columns in lexical
order. Normally sorting of ENUM
columns occurs using the internal
numeric values. Casting the values to CHAR
results in a lexical
sort:
SELECT enum_col FROM tbl_name ORDER BY CAST(enum_col AS CHAR); |
CAST(string AS BINARY)
is the same thing as BINARY string
.
CAST(expr AS CHAR)
treats the expression as a string with the
default character set.
NOTE: In MysQL 4.0 the CAST()
to DATE
,
DATETIME
, or TIME
only marks the column to be a specific
type but doesn't change the value of the column.
In MySQL 4.1.0 the value is converted to the correct column type when it's sent to the user (this is a feature of how the new protocol in 4.1 sends date information to the client):
mysql> SELECT CAST(NOW() AS DATE); -> 2003-05-26 |
In later MySQL versions (probably 4.1.2 or 5.0) we will fix that CAST
also changes the result if you use it as part of a more complex expression,
like CONCAT("Date: ",CAST(NOW() AS DATE))
.
You should not use CAST()
to extract data in different formats but
instead use string functions like LEFT
or
EXTRACT()
. See section Date and Time Functions.
To cast a string to a numeric value, you don't normally have to do anything; just use the string value as it would be a number:
mysql> SELECT 1+'1'; -> 2 |
If you use a number in string context, the number will automatically be
converted to a BINARY
string.
mysql> SELECT CONCAT("hello you ",2); -> "hello you 2" |
MySQL supports arithmetic with both signed and unsigned 64-bit values.
If you are using numerical operations (like +
) and one of the
operands is unsigned integer
, the result will be unsigned.
You can override this by using the SIGNED
and UNSIGNED
cast operators to cast the operation to a signed or
unsigned 64-bit integer, respectively.
mysql> SELECT CAST(1-2 AS UNSIGNED) -> 18446744073709551615 mysql> SELECT CAST(CAST(1-2 AS UNSIGNED) AS SIGNED); -> -1 |
Note that if either operand is a floating-point value, the result is
a floating-point value and is not affected by the above rule.
(In this context, DECIMAL
values are regarded as floating-point values.)
mysql> SELECT CAST(1 AS UNSIGNED) - 2.0; -> -1.0 |
If you are using a string in an arithmetic operation, this is converted to a floating-point number.
The handing of unsigned values was changed in MySQL 4.0 to be able to
support BIGINT
values properly. If you have some code that you
want to run in both MySQL 4.0 and 3.23 (in which case you probably can't
use the CAST()
function), you can use the following technique to get
a signed result when subtracting two unsigned integer columns:
SELECT (unsigned_column_1+0.0)-(unsigned_column_2+0.0); |
The idea is that the columns are converted to floating-point values before the subtraction occurs.
If you get a problem with UNSIGNED
columns in your old MySQL
application when porting to MySQL 4.0, you can use the
--sql-mode=NO_UNSIGNED_SUBTRACTION
option when starting
mysqld
. Note however that as long as you use this, you will not
be able to make efficient use of the BIGINT UNSIGNED
column type.
CONVERT()
with USING
is used to convert data between different
character sets. In MySQL, transcoding names are the same as the
corresponding character set names. For example, this statement converts
the string 'abc'
in the server's default character set to the
corresponding string in the utf8
character set:
SELECT CONVERT('abc' USING utf8); |
6.3.6.1 Bit Functions | ||
6.3.6.2 Miscellaneous Functions |
MySQL uses BIGINT
(64-bit) arithmetic for bit operations, so
these operators have a maximum range of 64 bits.
|
Bitwise OR
mysql> SELECT 29 | 15; -> 31 |
The result is an unsigned 64-bit integer.
&
Bitwise AND
mysql> SELECT 29 & 15; -> 13 |
The result is an unsigned 64-bit integer.
^
Bitwise XOR
mysql> SELECT 1 ^ 1; -> 0 mysql> SELECT 1 ^ 0; -> 1 mysql> SELECT 11 ^ 3; -> 8 |
The result is an unsigned 64-bit integer.
XOR
was added in version 4.0.2.
<<
Shifts a longlong (BIGINT
) number to the left:
mysql> SELECT 1 << 2; -> 4 |
The result is an unsigned 64-bit integer.
>>
Shifts a longlong (BIGINT
) number to the right:
mysql> SELECT 4 >> 2; -> 1 |
The result is an unsigned 64-bit integer.
~
Invert all bits:
mysql> SELECT 5 & ~1; -> 4 |
The result is an unsigned 64-bit integer.
BIT_COUNT(N)
Returns the number of bits that are set in the argument N
:
mysql> SELECT BIT_COUNT(29); -> 4 |
DATABASE()
Returns the current database name:
mysql> SELECT DATABASE(); -> 'test' |
If there is no current database, DATABASE()
returns the empty string.
USER()
SYSTEM_USER()
SESSION_USER()
Returns the current MySQL username and hostname:
mysql> SELECT USER(); -> 'davida@localhost' |
The value indicates the username you specified when connecting to the server, and the client host from which you connected. (Prior to MySQL Version 3.22.11, the function value does not include the client hostname.)
You can extract just the username part, regardless of whether the value includes a hostname part, like this:
mysql> SELECT SUBSTRING_INDEX(USER(),"@",1); -> 'davida' |
CURRENT_USER()
Returns the username and hostname that the current session was authenticated
as. This value corresponds to the account that is used for assessing your
access privileges. It may be different than the value of USER()
.
mysql> SELECT USER(); -> 'davida@localhost' mysql> SELECT * FROM mysql.user; -> ERROR 1044: Access denied for user: '@localhost' to database 'mysql' mysql> SELECT CURRENT_USER(); -> '@localhost' |
The example illustrates that although the client specified a username of
davida
(as indicated by the value of the USER()
function),
the server authenticated the client using an anonymous user account (as seen by
the empty username part of the CURRENT_USER()
value). One way this might
occur is that there is no account listed in the grant tables for
davida
.
PASSWORD(str)
OLD_PASSWORD(str)
Calculates a password string from the plaintext password str
. This is
the function that is used for encrypting MySQL passwords for storage
in the Password
column of the user
grant table:
mysql> SELECT PASSWORD('badpwd'); -> '7f84554057dd964b' |
PASSWORD()
encryption is non-reversible.
PASSWORD()
does not perform password encryption in the same way that
Unix passwords are encrypted. See ENCRYPT()
.
Note:
The PASSWORD()
function is used by the authentication system in
MySQL Server, you should NOT use it in your own applications.
For that purpose, use MD5()
or SHA1()
instead.
Also see RFC-2195
for more information about handling passwords
and authentication securely in your application.
ENCRYPT(str[,salt])
Encrypt str
using the Unix crypt()
system call. The
salt
argument should be a string with two characters.
(As of MySQL Version 3.22.16, salt
may be longer than two characters.)
mysql> SELECT ENCRYPT("hello"); -> 'VxuFAJXVARROc' |
ENCRYPT()
ignores all but the first 8 characters of str
, at
least on some systems. This behaviour is determined by the implementation
of the underlying crypt()
system call.
If crypt()
is not available on your system, ENCRYPT()
always
returns NULL
. Because of this we recommend that you use MD5()
or SHA1()
instead; these two functions exist on all platforms.
ENCODE(str,pass_str)
Encrypt str
using pass_str
as the password.
To decrypt the result, use DECODE()
.
The results is a binary string of the same length as string
.
If you want to save it in a column, use a BLOB
column type.
DECODE(crypt_str,pass_str)
Descrypts the encrypted string crypt_str
using pass_str
as the
password. crypt_str
should be a string returned from
ENCODE()
.
MD5(string)
Calculates an MD5 128-bit checksum for the string. The value is returned as a 32-digit hex number that may, for example, be used as a hash key:
mysql> SELECT MD5("testing"); -> 'ae2b1fca515949e5d54fb22b8ed95575' |
This is the "RSA Data Security, Inc. MD5 Message-Digest Algorithm".
SHA1(string)
SHA(string)
Calculates an SHA1 160-bit checksum for the string, as described in
RFC 3174 (Secure Hash Algorithm). The value is returned as a 40-digit
hex number, or NULL
in case the input argument was NULL
.
One of the possible uses for this function is as a hash key. You can
also use it as cryptographically safe function for storing passwords.
mysql> SELECT SHA1("abc"); -> 'a9993e364706816aba3e25717850c26c9cd0d89d' |
SHA1()
was added in version 4.0.2, and can be considered
a cryptographically more secure equivalent of MD5()
.
SHA()
is synonym for SHA1()
.
AES_ENCRYPT(string,key_string)
AES_DECRYPT(string,key_string)
These functions allow encryption/decryption of data using the official AES (Advanced Encryption Standard) algorithm, previously known as Rijndael. Encoding with a 128-bit key length is used, but you can extend it up to 256 bits by modifying the source. We chose 128 bits because it is much faster and it is usually secure enough.
The input arguments may be any length. If either argument is NULL
,
the result of this function is also NULL
.
As AES is a block-level algorithm, padding is used to encode uneven length strings and so the result string length may be calculated as 16*(trunc(string_length/16)+1).
If AES_DECRYPT()
detects invalid data or incorrect padding, it
returns NULL
. However, it is possible for AES_DECRYPT()
to return a non-NULL
value (possibly garbage) if the input data or
the key are invalid.
You can use the AES functions to store data in an encrypted form by modifying your queries:
INSERT INTO t VALUES (1,AES_ENCRYPT("text","password")); |
You can get even more security by not transferring the key over the connection for each query, which can be accomplished by storing it in a server side variable at connection time:
SELECT @password:="my password"; INSERT INTO t VALUES (1,AES_ENCRYPT("text",@password)); |
AES_ENCRYPT()
and AES_DECRYPT()
were added in version 4.0.2,
and can be considered the most cryptographically secure encryption
functions currently available in MySQL.
DES_ENCRYPT(string_to_encrypt [, (key_number | key_string) ] )
Encrypts the string with the given key using the Triple-DES algorithm.
Note that this function only works if you have configured MySQL with SSL support. See section Using Secure Connections.
The encryption key to use is chosen the following way:
Argument | Description |
Only one argument |
The first key from |
key number |
The given key (0-9) from the |
string |
The given |
The return string will be a binary string where the first character
will be CHAR(128 | key_number)
.
The 128 is added to make it easier to recognise an encrypted key.
If you use a string key, key_number
will be 127.
On error, this function returns NULL
.
The string length for the result will be
new_length= org_length + (8-(org_length % 8))+1
.
The des-key-file
has the following format:
key_number des_key_string key_number des_key_string |
Each key_number
must be a number in the range from 0 to 9. Lines in
the file may be in any order. des_key_string
is the string that
will be used to encrypt the message. Between the number and the key there
should be at least one space. The first key is the default key that will
be used if you don't specify any key argument to DES_ENCRYPT()
You can tell MySQL to read new key values from the key file with the
FLUSH DES_KEY_FILE
command. This requires the Reload_priv
privilege.
One benefit of having a set of default keys is that it gives applications a way to check for the existence of encrypted column values, without giving the end user the right to decrypt those values.
mysql> SELECT customer_address FROM customer_table WHERE crypted_credit_card = DES_ENCRYPT("credit_card_number"); |
DES_DECRYPT(string_to_decrypt [, key_string])
Decrypts a string encrypted with DES_ENCRYPT()
.
Note that this function only works if you have configured MySQL with SSL support. See section Using Secure Connections.
If no key_string
argument is given, DES_DECRYPT()
examines
the first byte of the encrypted string to determine the DES key number
that was used to encrypt the original string, then reads the key
from the des-key-file
to decrypt the message. For this to work
the user must have the SUPER
privilege.
If you pass this function a key_string
argument, that string
is used as the key for decrypting the message.
If the string_to_decrypt
doesn't look like an encrypted string, MySQL
will return the given string_to_decrypt
.
On error, this function returns NULL
.
COMPRESS(string_to_compress)
Compresses a string.
mysql> SELECT LENGTH(COMPRESS(REPEAT("a",1000))); -> 21 mysql> SELECT LENGTH(COMPRESS("")); -> 0 mysql> SELECT LENGTH(COMPRESS("a")); -> 13 mysql> SELECT LENGTH(COMPRESS(REPEAT("a",16))); -> 15 |
COMPRESS()
was added in MySQL version 4.1.1.
If requires MySQL to have been compiled with a compression library such as
zlib
. Otherwise, the return value is always NULL
.
UNCOMPRESS(string_to_uncompress)
Uncompresses a string compressed by the COMPRESS()
function.
mysql> SELECT UNCOMPRESS(COMPRESS("any string")); -> 'any string' |
UNCOMPRESS()
was added in MySQL version 4.1.1.
If requires MySQL to have been compiled with a compression library such as
zlib
. Otherwise, the return value is always NULL
.
UNCOMPRESSED_LENGTH(compressed_string)
Returns the length of a compressed string before compressing.
mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT("a",30))); -> 30 |
UNCOMPRESSED_LENGTH()
was added in MySQL version 4.1.1.
LAST_INSERT_ID([expr])
Returns the last automatically generated value that was inserted into an
AUTO_INCREMENT
column.
mysql> SELECT LAST_INSERT_ID(); -> 195 |
The last ID that was generated is maintained in the server on a
per-connection basis. This means the value the function returns to a given
client is the most recent AUTO_INCREMENT
value generated by that
client. The value cannot be affected by other clients, even if they generate
AUTO_INCREMENT
values of their own. This behaviour ensures that you can
retrieve your own ID without concern for the activity of other clients, and
without the need for locks or transactions.
The value of LAST_INSERT_ID()
is not changed if you
update the AUTO_INCREMENT
column of a row with a
non-magic value (that is, a value that is not NULL
and not 0
).
If you insert many rows at the same time with an insert statement,
LAST_INSERT_ID()
returns the value for the first inserted row.
The reason for this is to make it possible to easily reproduce
the same INSERT
statement against some other server.
If expr
is given as an argument to LAST_INSERT_ID()
, then
the value of the argument is returned by the function, and is set as the
next value to be returned by LAST_INSERT_ID()
. This can be used
to simulate sequences:
First create the table:
mysql> CREATE TABLE sequence (id INT NOT NULL); mysql> INSERT INTO sequence VALUES (0); |
Then the table can be used to generate sequence numbers like this:
mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1); |
You can generate sequences without calling LAST_INSERT_ID()
, but the
utility of using the function this way is that the ID value is maintained in
the server as the last automatically generated value (multi-user safe).
You can retrieve the new ID as you would read any normal
AUTO_INCREMENT
value in MySQL. For example, LAST_INSERT_ID()
(without an argument) will return the new ID. The C API function
mysql_insert_id()
can also be used to get the value.
Note that as mysql_insert_id()
is only updated after INSERT
and UPDATE
statements, so you can't use the C API function to
retrieve the value for LAST_INSERT_ID(expr)
after executing other
SQL statements like SELECT
or SET
.
See section mysql_insert_id()
.
FORMAT(X,D)
Formats the number X
to a format like '#,###,###.##'
, rounded
to D
decimals, and returns the result as a string.
If D
is 0
, the result will have no
decimal point or fractional part:
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()
Returns a string indicating the MySQL server version:
mysql> SELECT VERSION(); -> '3.23.13-log' |
Note that if your version ends with -log
this means that logging is
enabled.
CONNECTION_ID()
Returns the connection ID (thread ID) for the connection. Every connection has its own unique ID:
mysql> SELECT CONNECTION_ID(); -> 23786 |
GET_LOCK(str,timeout)
Tries to obtain a lock with a name given by the string str
, with a
timeout of timeout
seconds. Returns 1
if the lock was obtained
successfully, 0
if the attempt timed out (for example, because another
client has already locked the name), or NULL
if an error
occurred (such as running out of memory or the thread was killed with
mysqladmin kill
). A lock is released when you execute
RELEASE_LOCK()
, execute a new GET_LOCK()
, or the thread
terminates (either normally or abnormally).
This function can be used to implement application locks or to
simulate record locks. Names are locked on a server-wide basis.
If a name has been locked by one client, GET_LOCK()
blocks
any request by another client for a lock with the same name. This
allows clients that agree on a given lock name to use the name to
perform cooperative advisory locking:
mysql> SELECT GET_LOCK("lock1",10); -> 1 mysql> SELECT IS_FREE_LOCK("lock2"); -> 1 mysql> SELECT GET_LOCK("lock2",10); -> 1 mysql> SELECT RELEASE_LOCK("lock2"); -> 1 mysql> SELECT RELEASE_LOCK("lock1"); -> NULL |
Note that the second RELEASE_LOCK()
call returns NULL
because
the lock "lock1"
was automatically released by the second
GET_LOCK()
call.
RELEASE_LOCK(str)
Releases the lock named by the string str
that was obtained with
GET_LOCK()
. Returns 1
if the lock was released, 0
if the
lock wasn't locked by this thread (in which case the lock is not released),
and NULL
if the named lock didn't exist. (The lock will not exist if
it was never obtained by a call to GET_LOCK()
or if it already has
been released.)
The DO
statement is convinient to use with RELEASE_LOCK()
.
See section DO
Syntax.
IS_FREE_LOCK(str)
Checks if the lock named str
is free to use (that is, not locked).
Returns 1
if the lock is free (no one is using the lock),
0
if the lock is in use, and
NULL
on errors (such as incorrect arguments).
BENCHMARK(count,expr)
The BENCHMARK()
function executes the expression expr
repeatedly count
times. It may be used to time how fast MySQL
processes the expression. The result value is always 0
. The intended
use is in the mysql
client, which reports query execution times:
mysql> SELECT BENCHMARK(1000000,ENCODE("hello","goodbye")); +----------------------------------------------+ | BENCHMARK(1000000,ENCODE("hello","goodbye")) | +----------------------------------------------+ | 0 | +----------------------------------------------+ 1 row in set (4.74 sec) |
The time reported is elapsed time on the client end, not CPU time on the
server end. It may be advisable to execute BENCHMARK()
several
times, and interpret the result with regard to how heavily loaded the
server machine is.
INET_NTOA(expr)
Given a numeric network address (4 or 8 byte), returns the dotted-quad representation of the address as a string:
mysql> SELECT INET_NTOA(3520061480); -> "209.207.224.40" |
INET_ATON(expr)
Given the dotted-quad representation of a network address as a string, returns an integer that represents the numeric value of the address. Addresses may be 4 or 8 byte addresses:
mysql> SELECT INET_ATON("209.207.224.40"); -> 3520061480 |
The generated number is always in network byte order; for example the
above number is calculated as 209*256^3 + 207*256^2 + 224*256 +40
.
MASTER_POS_WAIT(log_name, log_pos [, timeout])
Blocks until the slave reaches (that is, has read and applied all updates up
to) the specified position in the master log. If master information is
not initialised, or if the arguments are incorrect, returns
NULL
. If the slave is not running, will block and wait until it
is started and goes to or past the specified position. If the slave is
already past the specified position, returns immediately.
If timeout
(new in 4.0.10) is specified, will give up waiting
when timeout
seconds have elapsed. timeout
must be greater
than 0; a zero or negative timeout
means no timeout. The return
value is the number of log events it had to wait to get to the specified
position, or NULL
in case of error, or -1
if the timeout
has been exceeded.
This command is useful for control of master-slave synchronisation.
FOUND_ROWS()
A SELECT
statement may include a LIMIT
clause to restrict the
number of rows the server returns to the client.
In some cases, it is desirable to know how many rows the statement would have
returned without the LIMIT
, but without running the statement again.
To get this row count, include a SQL_CALC_FOUND_ROWS
option in the
SELECT
statement, then invoke FOUND_ROWS()
afterward:
mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name WHERE id > 100 LIMIT 10; mysql> SELECT FOUND_ROWS(); |
The second SELECT
will return a number indicating how many rows the
first SELECT
would have returned had it been written without the
LIMIT
clause.
(If the preceding SELECT
statement does not include the
SQL_CALC_FOUND_ROWS
option, then FOUND_ROWS()
may return
a different result when LIMIT
is used than when it is not.)
Note that if you are using SELECT SQL_CALC_FOUND_ROWS ...
MySQL has
to calculate how many rows are in the full result set. However, this is
faster than running the query again without LIMIT
, because the result
set need not be sent to the client.
SQL_CALC_FOUND_ROWS
and FOUND_ROWS()
can be useful in situations
when you want to restrict the number of rows that a query returns, but also
determine the number of rows in the full result set without running the query
again. An example is a web script that presents a paged display containing
links to the pages that show other sections of a search result. Using
FOUND_ROWS()
allows you to determine how many other pages are needed
for the rest of the result.
The use of SQL_CALC_FOUND_ROWS
and FOUND_ROWS()
is more complex
for UNION
queries than for simple SELECT
statements, because
LIMIT
may occur at multiple places in a UNION
. It may be applied
to individual SELECT
statements in the UNION
, or global to the
UNION
result as a whole.
The intent of SQL_CALC_FOUND_ROWS
for UNION
is that it should
return the row count that would be returned without a global LIMIT
.
The conditions for use of SQL_CALC_FOUND_ROWS
with UNION
are:
SQL_CALC_FOUND_ROWS
keyword must appear in the first SELECT
of the UNION
.
FOUND_ROWS()
is exact only if UNION ALL
is used.
If UNION
without ALL
is used, duplicate removal occurs and the
value of FOUND_ROWS()
is only approximate.
LIMIT
is present in the UNION
, SQL_CALC_FOUND_ROWS
is ignored and returns the number of rows in the temporary table that is
created to process the UNION
.
SQL_CALC_FOUND_ROWS
and FOUND_ROWS()
are available starting at MySQL version 4.0.0.
GROUP BY
Clauses 6.3.7.1 GROUP BY Functions | ||
6.3.7.2 GROUP BY Modifiers | ||
6.3.7.3 GROUP BY with Hidden Fields |
GROUP BY
Functions If you use a group function in a statement containing no GROUP BY
clause, it is equivalent to grouping on all rows.
COUNT(expr)
Returns a count of the number of non-NULL
values in the rows
retrieved by a SELECT
statement:
mysql> SELECT student.student_name,COUNT(*) -> FROM student,course -> WHERE student.student_id=course.student_id -> GROUP BY student_name; |
COUNT(*)
is somewhat different in that it returns a count of
the number of rows retrieved, whether or not they contain NULL
values.
COUNT(*)
is optimised to
return very quickly if the SELECT
retrieves from one table, no
other columns are retrieved, and there is no WHERE
clause.
For example:
mysql> SELECT COUNT(*) FROM student; |
This optimisation applies only to MyISAM
and ISAM
tables
only, because an exact record count is stored for these table types and
can be accessed very quickly. For transactional storage engines
(InnodB
, BDB
), storing an exact row count is more problematic
because multiple transactions may be occurring, each of which may affect the
count.
COUNT(DISTINCT expr,[expr...])
Returns a count of the number of different non-NULL
values:
mysql> SELECT COUNT(DISTINCT results) FROM student; |
In MySQL you can get the number of distinct expression
combinations that don't contain NULL by giving a list of expressions.
In SQL-99 you would have to do a concatenation of all expressions
inside COUNT(DISTINCT ...)
.
AVG(expr)
Returns the average value of expr
:
mysql> SELECT student_name, AVG(test_score) -> FROM student -> GROUP BY student_name; |
MIN(expr)
MAX(expr)
Returns the minimum or maximum value of expr
. MIN()
and
MAX()
may take a string argument; in such cases they return the
minimum or maximum string value. See section How MySQL Uses Indexes.
mysql> SELECT student_name, MIN(test_score), MAX(test_score) -> FROM student -> GROUP BY student_name; |
In MIN()
, MAX()
and other aggregate functions, MySQL
currently compares ENUM
and SET
columns by their string
value rather than by the string's relative position in the set.
This will be rectified.
SUM(expr)
Returns the sum of expr
. Note that if the return set has no rows,
it returns NULL!
GROUP_CONCAT(expr)
Full syntax:
GROUP_CONCAT([DISTINCT] expr [,expr ...] [ORDER BY {unsigned_integer | col_name | formula} [ASC | DESC] [,col ...]] [SEPARATOR str_val]) |
This function was added in MySQL version 4.1. It returns a string result with the concatenated values from a group:
mysql> SELECT student_name, -> GROUP_CONCAT(test_score) -> FROM student -> GROUP BY student_name; or mysql> SELECT student_name, -> GROUP_CONCAT(DISTINCT test_score -> ORDER BY test_score DESC SEPARATOR " ") -> FROM student -> GROUP BY student_name; |
In MySQL you can get the concatenated values of expression combinations.
You can eliminate duplicate values by using DISTINCT
.
If you want to sort values in the result you should use ORDER BY
clause.
To sort in reverse order, add the DESC
(descending) keyword to the
name of the column you are sorting by in the ORDER BY
clause. The
default is ascending order; this may be specified explicitly using the
ASC
keyword.
SEPARATOR
is the string value which should be inserted between
values of result. The default is a comma (`","'). You can remove
the separator altogether by specifying SEPARATOR ""
.
You can set a maximum allowed length with the variable
group_concat_max_len
in your configuration.
The syntax to do this at runtime is:
SET [SESSION | GLOBAL] group_concat_max_len = unsigned_integer; |
If a maximum length has been set, the result is truncated to this maximum length.
The GROUP_CONCAT()
function is an enhanced implementation of
the basic LIST()
function supported by Sybase SQL Anywhere.
GROUP_CONCAT()
is backward compatible with the extremely limited
functionality of LIST()
, if only one column and no other options
are specified. LIST()
does have a default sorting order.
VARIANCE(expr)
Returns the standard variance of expr
. This is an extension to
SQL-99 (available only in version 4.1 or later).
STD(expr)
STDDEV(expr)
Returns the standard deviation of expr
. This is an extension to
SQL-99. The STDDEV()
form of this function is provided for Oracle
compatibility.
BIT_OR(expr)
Returns the bitwise OR
of all bits in expr
. The calculation is
performed with 64-bit (BIGINT
) precision.
Function returns 0 if there was no matching rows.
BIT_AND(expr)
Returns the bitwise AND
of all bits in expr
. The calculation is
performed with 64-bit (BIGINT
) precision.
Function returns -1 if there was no matching rows.
GROUP BY
Modifiers As of MySQL 4.1.1, the GROUP BY
clause allows a WITH
ROLLUP
modifier that causes extra rows to be added to the summary
output. These rows represent higher-level (or super-aggregate) summary
operations. ROLLUP
thus allows you to answer questions at multiple
levels of analysis with a single query. It can be used, for example,
to provide support for OLAP (Online Analytical Processing) operations.
As an illustration, suppose that a table named sales
has year
,
country
,
product
, and profit
columns for recording sales profitability:
CREATE TABLE sales ( year INT NOT NULL, country VARCHAR(20) NOT NULL, product VARCHAR(32) NOT NULL, profit INT ); |
The table's contents can be summarized per year with a simple GROUP BY
like this:
mysql> SELECT year, SUM(profit) FROM sales GROUP BY year; +------+-------------+ | year | SUM(profit) | +------+-------------+ | 2000 | 4525 | | 2001 | 3010 | +------+-------------+ |
This output shows the total profit for each year, but if you also want to determine the total profit summed over all years, you must add up the individual values yourself or run an additional query.
Or you can use ROLLUP
, which provides both levels of analysis with a
single query.
Adding a WITH ROLLUP
modifier to the GROUP BY
clause causes the query
to produce another row that shows the grand total over all year values:
mysql> SELECT year, SUM(profit) FROM sales GROUP BY year WITH ROLLUP; +------+-------------+ | year | SUM(profit) | +------+-------------+ | 2000 | 4525 | | 2001 | 3010 | | NULL | 7535 | +------+-------------+ |
The grand total super-aggregate line is identified by the value NULL
in
the year
column.
ROLLUP
has a more complex effect when there are multiple GROUP BY
columns. In this case, each time there is a "break" (change in value)
in any but the last grouping column, the query produces an extra
super-aggregate summary row.
For example, without ROLLUP
, a summary on the sales
table based
on year
,
country
, and product
might look like this:
mysql> SELECT year, country, product, SUM(profit) -> FROM sales -> GROUP BY year, country, product; +------+---------+------------+-------------+ | year | country | product | SUM(profit) | +------+---------+------------+-------------+ | 2000 | Finland | Computer | 1500 | | 2000 | Finland | Phone | 100 | | 2000 | India | Calculator | 150 | | 2000 | India | Computer | 1200 | | 2000 | USA | Calculator | 75 | | 2000 | USA | Computer | 1500 | | 2001 | Finland | Phone | 10 | | 2001 | USA | Calculator | 50 | | 2001 | USA | Computer | 2700 | | 2001 | USA | TV | 250 | +------+---------+------------+-------------+ |
The output indicates summary values only at the year/country/product level of
analysis. When ROLLUP
is added, the query produces several extra rows:
mysql> SELECT year, country, product, SUM(profit) -> FROM sales -> GROUP BY year, country, product WITH ROLLUP; +------+---------+------------+-------------+ | year | country | product | SUM(profit) | +------+---------+------------+-------------+ | 2000 | Finland | Computer | 1500 | | 2000 | Finland | Phone | 100 | | 2000 | Finland | NULL | 1600 | | 2000 | India | Calculator | 150 | | 2000 | India | Computer | 1200 | | 2000 | India | NULL | 1350 | | 2000 | USA | Calculator | 75 | | 2000 | USA | Computer | 1500 | | 2000 | USA | NULL | 1575 | | 2000 | NULL | NULL | 4525 | | 2001 | Finland | Phone | 10 | | 2001 | Finland | NULL | 10 | | 2001 | USA | Calculator | 50 | | 2001 | USA | Computer | 2700 | | 2001 | USA | TV | 250 | | 2001 | USA | NULL | 3000 | | 2001 | NULL | NULL | 3010 | | NULL | NULL | NULL | 7535 | +------+---------+------------+-------------+ |
For this query, adding ROLLUP
causes the output to include summary
information at four levels of analysis, not just one. Here's how to
interpret the ROLLUP
output:
product
column set to NULL
.
country
and products
columns set to NULL
.
year
, country
, and products
columns set to
NULL
.
Other Considerations When using ROLLUP
The following items list some behaviours specific to the MySQL implementation
of ROLLUP
:
When you use ROLLUP
, you cannot also use an ORDER BY
clause to
sort the results. (In other words, ROLLUP
and ORDER BY
are mutually
exclusive.) However, you still have some control over sort order.
GROUP BY
in MySQL sorts results, and you can use explicit ASC
and DESC
keywords
with columns named in the GROUP BY
list to specify sort order for
individual columns. (The higher-level summary rows added by ROLLUP
still appear after the rows from which they are calculated, regardless
of the sort order.)
LIMIT
can be used to restrict the number of rows returned to the
client. LIMIT
is applied after ROLLUP
, so the limit applies
against the extra rows added by ROLLUP
. For example:
mysql> SELECT year, country, product, SUM(profit) -> FROM sales -> GROUP BY year, country, product WITH ROLLUP -> LIMIT 5; +------+---------+------------+-------------+ | year | country | product | SUM(profit) | +------+---------+------------+-------------+ | 2000 | Finland | Computer | 1500 | | 2000 | Finland | Phone | 100 | | 2000 | Finland | NULL | 1600 | | 2000 | India | Calculator | 150 | | 2000 | India | Computer | 1200 | +------+---------+------------+-------------+ |
Note that using LIMIT
with ROLLUP
may produce results
that are more difficult to interpret, because you have less context
for understanding the super-aggregate rows.
The NULL
indicators in each super-aggregate row are produced when the
row is sent to the client. The server looks at the columns named in
the GROUP BY
clause following the leftmost one that has changed value.
For any column in the result set with a name that is a lexical match to
any of those names, its value is set to NULL
. (If you specify grouping
columns by column number, the server identifies which columns to set to
NULL
by number.)
Because the NULL
values in the super-aggregate rows are placed into the
result set at such a late stage in query processing, you cannot test them
as NULL
values within the query itself. For example, you cannot add
HAVING product IS NULL
to the query to eliminate from the output all
but the super-aggregate rows.
On the other hand, the NULL
values do appear as NULL
on the client side and can be tested as such using any MySQL client
programming interface.
GROUP BY
with Hidden Fields MySQL has extended the use of GROUP BY
. You can use columns or
calculations in the SELECT
expressions that don't appear in
the GROUP BY
part. This stands for any possible value for this
group. You can use this to get better performance by avoiding sorting and
grouping on unnecessary items. For example, you don't need to group on
customer.name
in the following query:
mysql> SELECT order.custid,customer.name,MAX(payments) -> FROM order,customer -> WHERE order.custid = customer.custid -> GROUP BY order.custid; |
In standard SQL, you would have to add customer.name
to the
GROUP BY
clause. In MySQL, the name is redundant if you don't run in
ANSI mode.
Don't use this feature if the columns you omit from the
GROUP BY
part aren't unique in the group! You will get
unpredictable results.
In some cases, you can use MIN()
and MAX()
to obtain a specific
column value even if it isn't unique. The following gives the value of
column
from the row containing the smallest value in the sort
column:
SUBSTR(MIN(CONCAT(RPAD(sort,6,' '),column)),7) |
See section The Rows Holding the Group-wise Maximum of a Certain Field.
Note that if you are using MySQL Version 3.22 (or earlier) or if
you are trying to follow SQL-99, you can't use expressions in GROUP
BY
or ORDER BY
clauses. You can work around this limitation by
using an alias for the expression:
mysql> SELECT id,FLOOR(value/100) AS val FROM tbl_name -> GROUP BY id,val ORDER BY val; |
In MySQL Version 3.23 you can do:
mysql> SELECT id,FLOOR(value/100) FROM tbl_name ORDER BY RAND(); |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] |
Hosting by: Hurra Communications Ltd.
Generated: 2007-01-26 17:58:45