Functions for Use in `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.
to have the same name as a function. Spaces around arguments are
permitted, though.
reserved words. *Note 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
Non-Type-Specific Operators and Functions
-----------------------------------------
Parentheses
...........
( ... )
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 Operators
....................
as needed (as
in Perl).
MySQL performs comparisons using the following rules:
* If one or both arguments are `NULL', the result of the comparison
is `NULL', except for the `<=>' operator.
* If both arguments in a comparison operation are strings, they are
compared as strings.
* If both arguments are integers, they are compared as integers.
* Hexadecimal values are treated as binary strings if not compared
to a number.
to be
more ODBC-friendly.
* In all other cases, the arguments are compared as floating-point
(real) numbers.
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
Note that when you are comparing a string column with a number, MySQL
can't use index to quickly look up the value:
SELECT * FROM table_name WHERE string_key=1
The reason for this is that there is many different strings that may
return the value `1': `"1"', `" 1"', `"1a"' ...
`='
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':
* You can find the last inserted row with:
SELECT * FROM tbl_name WHERE auto_col IS NULL
This can be disabled by setting `SQL_AUTO_IS_NULL=0'. *Note
SET OPTION::.
* For `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)
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)'.
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.
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
Logical Operators
.................
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
`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.
Control Flow Functions
......................
`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:
floating-point value
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'
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 Functions
----------------
String-valued functions return `NULL' if the length of the result would
be greater than the `max_allowed_packet' server parameter. *Note
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.
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'
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'
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.
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.
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.
`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.
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.
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()' 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.
complement of `FIELD()':
mysql> SELECT ELT(1, 'ej', 'Heja', 'hej', 'foo');
-> 'ej'
mysql> SELECT ELT(4, 'ej', 'Heja', 'hej', 'foo');
-> 'foo'
mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 2
mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo');
-> 0
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
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');
-> ''
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
String Comparison Functions
...........................
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 `%' character
`\_' Matches one `_' character
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
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.
*Note Regexp::. 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)'.
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 *Note Fulltext Search::.
Case-Sensitivity
................
``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)'.
*Note 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.
Numeric Functions
-----------------
Arithmetic Operations
.....................
is an
unsigned integer, and the other argument is also an integer, the result
will be an unsigned integer. *Note 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!
Mathematical Functions
......................
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
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
`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
ORDER BY RAND()'
This is useful to get a random sample of a set `SELECT * FROM
table1,table2 WHERE a=b AND cna("Источник: Документация\n C2E9E5FEFC848B9BB3B1F3ABCCD9CF8DC6D5C6CBC99F9FCA86EFF5BDF08CD4C2DEC0D283D687D3C2D6D8ECEFA1F7C4CD85D9DDDDC7CD918FD3D1C9838FE6B79B9D88DFC8D4CEC6DDC696829AF2FAFDFE81C4DBD387DED2C4DCDDC6CED5EFE1F9B6C1DA9D85CFD383DEC7CCC2D6D6AFF6EEBCC5C1D1D69DDEC5DFCE83DCD790E4A2E7FCB7B48D97818B80C992D6C5C1D6F9FDABE9C3CBD7D583C29AD7D9D8DFC8C9FBF4F5AC87D7C88EDAD9C589D4C4C7C68183E7CFC3E585D6C5CEDEC8CBCECCA0B3B28C")`LEAST(X,Y,...)'
With two or more arguments, returns the smallest (minimum-valued)
argument. The arguments are compared using the following rules:
* If the return value is used in an `INTEGER' context, or all
arguments are integer-valued, they are compared as integers.
* If the return value is used in a `REAL' context, or all
arguments are real-valued, they are compared as reals.
* If any argument is a case-sensitive string, the arguments are
compared as case-sensitive strings.
* In other cases, the arguments are compared as
case-insensitive strings:
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.
Date and Time Functions
-----------------------
This section describes the functions that can be used to manipulate
temporal values. See *Note 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*
`0' Week starts on Sunday; return value range is
`0' to `53'
`1' Week starts on Monday; return value range is
`0' to `53'
`2' Week starts on Sunday; return value range is
`1' to `53'
`3' Week starts on Monday; return value range is
`1' to `53' (ISO 8601)
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
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
`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.
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:
`type' *Value* *Expected* `expr' *Format*
`SECOND' `SECONDS'
`MINUTE' `MINUTES'
`HOUR' `HOURS'
`DAY' `DAYS'
`MONTH' `MONTHS'
`YEAR' `YEARS'
`MINUTE_SECOND' `'MINUTES:SECONDS''
`HOUR_MINUTE' `'HOURS:MINUTES''
`DAY_HOUR' `'DAYS HOURS''
`YEAR_MONTH' `'YEARS-MONTHS''
`HOUR_SECOND' `'HOURS:MINUTES:SECONDS''
`DAY_MINUTE' `'DAYS HOURS:MINUTES''
`DAY_SECOND' `'DAYS HOURS:MINUTES:SECONDS''
`DAY_MICROSECOND' `'DAYS.MICROSECONDS''
`HOUR_MICROSECOND' `'HOURS.MICROSECONDS''
`MINUTE_MICROSECOND' `'MINUTES.MICROSECONDS''
`SECOND_MICROSECOND' `'SECONDS.MICROSECONDS''
`MICROSECOND' `'MICROSECONDS''
The `type' values `DAY_MICROSECOND', `HOUR_MICROSECOND',
`MINUTE_MICROSECOND', `SECOND_MICROSECOND', and `MICROSECOND' are
allowed as of MySQL 4.1.1.
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'
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.
`ADDTIME()' adds `expr2' to `expr' and returns the result.
`SUBTIME()' subtracts `expr2' from `expr' and returns the result.
mysql> SELECT ADDTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002");
-> '1998-01-02 01:01:01.000001'
mysql> SELECT SUBTIME("1997-12-31 23:59:59.999999", "1 1:1:1.000002");
-> '1997-12-30 22:58:58.999997'
mysql> SELECT ADDTIME("01:00:00.999999", "02:00:00.999998");
-> '03:00:01.999997'
mysql> SELECT SUBTIME("01:00:00.999999", "02:00:00.999998");
-> '-00:59:59.999999'
`ADDTIME()' and `SUBTIME()' were added in MySQL 4.1.1.
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(expr,expr2)'
`TIMEDIFF(expr,expr2)'
`DATEDIFF()' returns the number of days between the start date
`expr' and the end date `expr2'. `expr' and `expr2' are date or
date-and-time expressions. Only the date parts of the values are
used in the calculation.
`TIMEDIFF()' returns the time between the start time `expr' and
the end time `expr2'. `expr' and `expr2' are time or
date-and-time expressions, but both must be of the same type.
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
-> 1
mysql> SELECT DATEDIFF('1997-11-31 23:59:59','1997-12-31');
-> -30
mysql> SELECT TIMEDIFF('2000:01:01 00:00:00', '2000:01:01 00:00:00.000001');
-> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001','1997-12-30 01:01:01.000002');
-> '46:58:57.999999'
`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
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*
`%M' Month name (`January'..`December')
`%W' Weekday name (`Sunday'..`Saturday')
`%D' Day of the month with English suffix
(`0th', `1st', `2nd', `3rd', etc.)
`%Y' Year, numeric, 4 digits
`%y' Year, numeric, 2 digits
`%X' Year for the week where Sunday is the first
day of the week, numeric, 4 digits; used
with `%V'
`%x' Year for the week, where Monday is the
first day of the week, numeric, 4 digits;
used with `%v'
`%a' Abbreviated weekday name (`Sun'..`Sat')
`%d' Day of the month, numeric (`00'..`31')
`%e' Day of the month, numeric (`0'..`31')
`%m' Month, numeric (`00'..`12')
`%c' Month, numeric (`0'..`12')
`%b' Abbreviated month name (`Jan'..`Dec')
`%j' Day of year (`001'..`366')
`%H' Hour (`00'..`23')
`%k' Hour (`0'..`23')
`%h' Hour (`01'..`12')
`%I' Hour (`01'..`12')
`%l' Hour (`1'..`12')
`%i' Minutes, numeric (`00'..`59')
`%r' Time, 12-hour (`hh:mm:ss' followed by `AM'
or `PM')
`%T' Time, 24-hour (`hh:mm:ss')
`%S' Seconds (`00'..`59')
`%s' Seconds (`00'..`59')
`%f' Microseconds (`000000'..`999999')
`%p' `AM' or `PM'
`%w' Day of the week (`0'=Sunday..`6'=Saturday)
`%U' Week (`00'..`53'), where Sunday is the
first day of the week
`%u' Week (`00'..`53'), where Monday is the
first day of the week
`%V' Week (`01'..`53'), where Sunday is the
first day of the week; used with `%X'
`%v' Week (`01'..`53'), where Monday is the
first day of the week; used with `%x'
`%%' 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'
Other specifiers produce a
`NULL' value or `0'.
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'
`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
context:
mysql> SELECT CURTIME();
-> '23:50:26'
mysql> SELECT CURTIME() + 0;
-> 235026
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
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. *Note 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
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
mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
-> '2003-08-14', 20030814
`UTC_DATE()' is available as of MySQL 4.1.1.
`UTC_TIME'
`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'
`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.
Cast Functions
--------------
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
You should not use `CAST()' to extract data in different formats but
instead use string functions like `LEFT' or `EXTRACT()'. *Note 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"
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);
Other Functions
---------------
Bit 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
Miscellaneous Functions
.......................
`DATABASE()'
Returns the current database name:
mysql> SELECT DATABASE();
-> 'test'
If there is no current database, `DATABASE()' returns `NULL' as of
MySQL 4.1.1, and the empty string before that.
`USER()'
`SYSTEM_USER()'
`SESSION_USER()'
Returns the current MySQL username and hostname:
mysql> SELECT USER();
-> 'davida@localhost'
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'
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'
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' 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. *Note Secure connections::.
The encryption key to use is chosen the following way:
*Argument* *Description*
Only one The first key from `des-key-file' is used.
argument
key number The given key (0-9) from the
`des-key-file' is used.
string The given `key_string' will be used to
crypt `string_to_encrypt'.
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
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. *Note 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
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').
the
same `INSERT' statement against some other server.
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);
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'. *Note `mysql_insert_id()':
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()'.
*Note DO::.
`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'.
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.
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:
* The `SQL_CALC_FOUND_ROWS' keyword must appear in the first
`SELECT' of the `UNION'.
* The value of `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.
* If no `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.
Functions and Modifiers for Use with `GROUP BY' Clauses
-------------------------------------------------------
`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;
*Note MySQL 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' (considering rows as the
whole population, not as a sample; so it has the number of rows as
denominator). 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' (the square root of
`VARIANCE()'. 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_XOR(expr)'
Returns the bitwise `XOR' of all bits in `expr'. The calculation is
performed with 64-bit (`BIGINT') precision.
Function returns 0 if there was no matching rows.
This function is available as of MySQL 4.1.1.
`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
->
| 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:
* Following each set of rows for a given year, an extra summary row
is produced showing the total for all countries and products.
These rows have the `country' and `products' columns set to `NULL'.
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.)
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
.............................
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.
column:
SUBSTR(MIN(CONCAT(RPAD(sort,6,' '),column)),7)
*Note example-Maximum-column-group-row::.
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();
[Назад] [Содержание] [Вперед]
| Главная |