# 13 Functions and Operators

Expressions can be used at several points in SQL statements, such as in the `ORDER BY` or `HAVING` clauses of `SELECT` statements, in the `WHERE` clause of a `SELECT`, `DELETE`, or `UPDATE` statement, or in `SET` statements. Expressions can be written using literal values, column values, `NULL`, functions, and operators. This chapter describes the functions and operators that are allowed for writing expressions in MySQL.

An expression that contains `NULL` always produces a `NULL` value unless otherwise indicated in the documentation for a particular function or operator.

Note: By default, there must be no whitespace between a function name and the parenthesis 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 function arguments are permitted, though.

You can tell the MySQL server to accept spaces after function names by starting it with the `--sql-mode=IGNORE_SPACE` option. Individual client programs can request this behavior by using the `CLIENT_IGNORE_SPACE` option for `mysql_real_connect()`. In either case, all function names will become reserved words. See section 5.2.2 The Server SQL Mode.

For the sake of brevity, most examples in this chapter display the output from the `mysql` program in abbreviated form. Instead of showing examples in this format:

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

This format is used instead:

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

## 13.1 Operators

### 13.1.1 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

### 13.1.2 Comparison Operators

Comparison operations result in a value of `1` (TRUE), `0` (FALSE), or `NULL`. These operations work for both numbers and strings. Strings are automatically converted to numbers and numbers to strings as necessary.

MySQL performs comparisons using the following rules:

- If one or both arguments are `NULL`, the result of the comparison is `NULL`, except for the `NULL`-safe `<=>` equality comparison 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.
- If one of the arguments is a `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.
- In all other cases, the arguments are compared as floating-point (real) numbers.

By default, string comparisons are not case sensitive and use the current character set (ISO-8859-1 Latin1 by default, which also works excellently for English).

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 an index on the column to quickly look up the value. If `str_col` is an indexed string column, the index cannot be used when performing the lookup in the following statement:

    SELECT * FROM tbl_name WHERE str_col=1;

The reason for this is that there are many different strings that may convert to the value `1`: `'1'`, `' 1'`, `'1a'` ...

MySQL Inline-Help Reference - SQL Functions
`=`

`=`
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

MySQL Inline-Help Reference - SQL Functions
`<=>`

`<=>`
`NULL`-safe equal. This operator performs an equality comparison like the `=` operator, but returns `1` rather than `NULL` if both operands are `NULL`, and `0` rather than `NULL` if one operand is `NULL`.

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

MySQL Inline-Help Reference - SQL Functions
`<>`

`<>`
`!=`
  Not equal:

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

MySQL Inline-Help Reference - SQL Functions
`<=`

`<=`
  Less than or equal:

      mysql> SELECT 0.1 <= 2;
              -> 1

MySQL Inline-Help Reference - SQL Functions
`<`

`<`
  Less than:

      mysql> SELECT 2 < 2;
              -> 0

MySQL Inline-Help Reference - SQL Functions
`>=`

`>=`
  Greater than or equal:

      mysql> SELECT 2 >= 2;
              -> 1

MySQL Inline-Help Reference - SQL Functions
`>`

`>`
  Greater than:

      mysql> SELECT 2 > 2;
              -> 0

MySQL Inline-Help Reference - SQL Functions
`IS NULL`

`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 ODBC programs, MySQL supports the following extra features when using `IS NULL`:
  - You can find the row that contains the most recent `AUTO_INCREMENT` value by issuing a statement of the following form immediately after generating the value:

        SELECT * FROM tbl_name WHERE auto_col IS NULL

    This behavior can be disabled by setting `SQL_AUTO_IS_NULL=0`. See section 14.5.3.1 `SET` Syntax.
  - For `DATE` and `DATETIME` columns that are declared as `NOT NULL`, you can find the special date `'0000-00-00'` by using a statement like this:

        SELECT * FROM tbl_name WHERE date_column IS NULL

    This is needed to get some ODBC applications to work, because ODBC doesn't support a `'0000-00-00'` date.

MySQL Inline-Help Reference - SQL Functions
`expr BETWEEN min AND max`

`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 described at the beginning of this section, but applied to all the three arguments. Note: Before MySQL 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

MySQL Inline-Help Reference - SQL Functions
`expr NOT BETWEEN min AND max`

`expr NOT BETWEEN min AND max`
  This is the same as `NOT (expr BETWEEN min AND max)`.

MySQL Inline-Help Reference - SQL Functions
`GREATEST(X,Y,...)`

`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'

  Before MySQL 3.22.5, you can use `MAX()` instead of `GREATEST()`.

MySQL Inline-Help Reference - SQL Functions
`expr IN (value,...)`

`expr IN (value,...)`
  Returns `1` if `expr` is any of the values in the `IN` list, else returns `0`. If all values are constants, they are evaluated according to the type of `expr` and sorted. The search for the item then is 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. To comply with the SQL-99 standard, from MySQL 4.1 on `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`. From MySQL 4.1 on, `IN()` syntax also is used to write certain types of subqueries. See section 14.1.8.3 Subqueries with `ANY`, `IN`, and `SOME`.

MySQL Inline-Help Reference - SQL Functions
`expr NOT IN (value,...)`

`expr NOT IN (value,...)`
  This is the same as `NOT (expr IN (value,...))`.

MySQL Inline-Help Reference - SQL Functions
`ISNULL(expr)`

`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!

MySQL Inline-Help Reference - SQL Functions
`COALESCE(value,...)`

`COALESCE(value,...)`
  Returns the first non-`NULL` value in the list.

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

MySQL Inline-Help Reference - SQL Functions
`INTERVAL(N,N1,N2,N3,...)`

`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

MySQL Inline-Help Reference - SQL Functions
`LEAST(X,Y,...)`

`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'

  Before MySQL 3.22.5, you can use `MIN()` instead of `LEAST()`. Note that the preceding conversion rules can produce strange results in some borderline cases:

      mysql> SELECT CAST(LEAST(3600, 9223372036854775808.0) as SIGNED);
              -> -9223372036854775808

  This happens because MySQL reads `9223372036854775808.0` in an integer context. The integer representation is not good enough to hold the value, so it wraps to a signed integer.

### 13.1.3 Logical Operators

In SQL, all logical operators evaluate to TRUE, FALSE, or `NULL` (UNKNOWN). In MySQL, these are implemented as `1` (TRUE), `0` (FALSE), and `NULL`. Most of this is common to different SQL database servers, although some servers may return any non-zero value for TRUE.

MySQL Inline-Help Reference - SQL Functions
`NOT`

`NOT`

MySQL Inline-Help Reference - SQL Functions
`!`

`!`
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`.

MySQL Inline-Help Reference - SQL Functions
`AND`

`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` values. This means that in these versions, `SELECT (NULL AND 0)` returns `NULL` instead of `0`. As of MySQL 4.0.5, the code has been re-engineered so that the result is always as prescribed by the SQL standards while still using the optimization wherever possible.

MySQL Inline-Help Reference - SQL Functions
`OR`

`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

MySQL Inline-Help Reference - SQL Functions
`XOR`

`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.

      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 MySQL 4.0.2.

### 13.1.4 Case-sensitivity Operators

``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 str` is a shorthand for `CAST(str AS BINARY)`. See section 13.7 Cast Functions. `BINARY` was introduced in MySQL 3.23.0. Note that in some contexts, if you cast an indexed column to `BINARY`, MySQL will not be able to use the index efficiently.

If you want to compare a `BLOB` value in case-insensitive fashion, you can do so as follows:

- Before MySQL 4.1.1, use the `UPPER()` function to convert the `BLOB` value to uppercase before performing the comparison:

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

  If the comparison value is lowercase, convert the `BLOB` value using `LOWER()` instead.
- For MySQL 4.1.1 and up, `BLOB` columns have a character set of `binary`, which has no concept of lettercase. To perform a case-insensitive comparison, use the `CONVERT()` function to convert the `BLOB` value to a character set that is not case sensitive. The result is a non-binary string, so the `LIKE` operation is not case sensitive:

      SELECT 'A' LIKE CONVERT(blob_col USING latin1) FROM tbl_name;

  To use a different character set, substitute its name for `latin1` in the preceding statement.

`CONVERT()` can be used more generally for comparing strings that are represented in different character sets.

## 13.2 Control Flow Functions

MySQL Inline-Help Reference - SQL Functions
`CASE value WHEN [compare-value] THEN result [WHEN [compare-value] THEN result ...] [ELSE result] END`

`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 that is true. If there was no matching result value, the result after `ELSE` is returned, or `NULL` if there is no `ELSE` part.

      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`).

MySQL Inline-Help Reference - SQL Functions
`IF(expr1,expr2,expr3)`

`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 only one of `expr2` or `expr3` is explicitly `NULL`, the result type of the `IF()` function is the type of non-`NULL` expression. (This behavior 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 shown, `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 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, the result is case sensitive if either string is case sensitive (starting from MySQL 3.23.51).

MySQL Inline-Help Reference - SQL Functions
`IFNULL(expr1,expr2)`

`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 MySQL 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 from earlier MySQL versions is 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 tmp SELECT IFNULL(1,'test') AS test;

  As of MySQL 4.0.6, the type for the `test` column is `CHAR(4)`, whereas in earlier versions the type would be `BIGINT`.

MySQL Inline-Help Reference - SQL Functions
`NULLIF(expr1,expr2)`

`NULLIF(expr1,expr2)`
  Returns `NULL` if `expr1 = expr2` is true, else returns `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 MySQL evaluates `expr1` twice if the arguments are not equal.

## 13.3 String Functions

String-valued functions return `NULL` if the length of the result would be greater than the value of the `max_allowed_packet` system variable. See section 7.5.2 Tuning Server Parameters.

For functions that operate on string positions, the first position is numbered 1.

MySQL Inline-Help Reference - SQL Functions
`ASCII(str)`

`ASCII(str)`
Returns the numeric value of the leftmost character of the string `str`. Returns `0` if `str` is the empty string. Returns `NULL` if `str` is `NULL`. `ASCII()` works for characters with numeric values from `0` to `255`.

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

See also the `ORD()` function.

MySQL Inline-Help Reference - SQL Functions
`BIN(N)`

`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 Inline-Help Reference - SQL Functions
`BIT_LENGTH(str)`

`BIT_LENGTH(str)`
Returns the length of the string `str` in bits.

    mysql> SELECT BIT_LENGTH('text');
            -> 32

MySQL Inline-Help Reference - SQL Functions
`CHAR(N,...)`

`CHAR(N,...)`
`CHAR()` interprets the arguments as integers and returns a string consisting of the characters given by the 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'

MySQL Inline-Help Reference - SQL Functions
`CHAR_LENGTH(str)`

`CHAR_LENGTH(str)`
Returns the length of the string `str`, measured in characters. A multi-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`.

MySQL Inline-Help Reference - SQL Functions
`CHARACTER_LENGTH(str)`

`CHARACTER_LENGTH(str)`
`CHARACTER_LENGTH()` is a synonym for `CHAR_LENGTH()`.

MySQL Inline-Help Reference - SQL Functions
`COMPRESS(string_to_compress)`

`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 4.1.1. It requires MySQL to have been compiled with a compression library such as `zlib`. Otherwise, the return value is always `NULL`. The compressed string contents are stored the following way:

- Empty strings are stored as empty strings.
- Non-empty strings are stored as a 4-byte length of the uncompressed string (low byte first), followed by the string compressed with gzip. If the string ends with space, an extra ``.'` character is added to avoid problems with endspace trimming should the result be stored in a `CHAR` or `VARCHAR` column. (Use of `CHAR` or `VARCHAR` to store compressed strings is not recommended. It is better to use a `BLOB` column instead.)

MySQL Inline-Help Reference - SQL Functions
`CONCAT(str1,str2,...)`

`CONCAT(str1,str2,...)`
Returns the string that results from concatenating the arguments. Returns `NULL` if any argument is `NULL`. May have one or more arguments. A numeric argument is converted to its equivalent string form.

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

MySQL Inline-Help Reference - SQL Functions
`CONCAT_WS(separator, str1, str2,...)`

`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 is added between the strings to be concatenated. The separator can be a string as can the rest of the arguments. If the separator is `NULL`, the result is `NULL`. The function skips any `NULL` values after the separator argument.

    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.0.14, `CONCAT_WS()` skips empty strings as well as `NULL` values.

MySQL Inline-Help Reference - SQL Functions
`CONV(N,from_base,to_base)`

`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'

MySQL Inline-Help Reference - SQL Functions
`ELT(N,str1,str2,str3,...)`

`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'

MySQL Inline-Help Reference - SQL Functions
`EXPORT_SET(bits,on,off,[separator,[number_of_bits]])`

`EXPORT_SET(bits,on,off,[separator,[number_of_bits]])`
Returns a string in which for every bit set in `bits`, you get an `on` string and for every reset bit you get an `off` string. Each string is separated by `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

MySQL Inline-Help Reference - SQL Functions
`FIELD(str,str1,str2,str3,...)`

`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

MySQL Inline-Help Reference - SQL Functions
`FIND_IN_SET(str,strlist)`

`FIND_IN_SET(str,strlist)`
Returns a value `1` to `N` if the string `str` is in the string 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 optimized 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 comma (``,'`) character.

    mysql> SELECT FIND_IN_SET('b','a,b,c,d');
            -> 2

MySQL Inline-Help Reference - SQL Functions
`HEX(N_or_S)`

`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)`. From MySQL 4.0.1 and up, 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 two hexadecimal digits.

    mysql> SELECT HEX(255);
            -> 'FF'
    mysql> SELECT 0x616263;
            -> 'abc'
    mysql> SELECT HEX('abc');
            -> 616263

MySQL Inline-Help Reference - SQL Functions
`INSERT(str,pos,len,newstr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`INSTR(str,substr)`

`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. For 4.0 on, it is case sensitive only if either argument is a binary string.

MySQL Inline-Help Reference - SQL Functions
`LCASE(str)`

`LCASE(str)`
`LCASE()` is a synonym for `LOWER()`.

MySQL Inline-Help Reference - SQL Functions
`LEFT(str,len)`

`LEFT(str,len)`
Returns the leftmost `len` characters from the string `str`.

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

MySQL Inline-Help Reference - SQL Functions
`LENGTH(str)`

`LENGTH(str)`
Returns the length of the string `str`, measured in bytes. A multi-byte character counts as multiple bytes. This means that for a string containing five two-byte characters, `LENGTH()` returns `10`, whereas `CHAR_LENGTH()` returns `5`.

    mysql> SELECT LENGTH('text');
            -> 4

MySQL Inline-Help Reference - SQL Functions
`LOAD_FILE(file_name)`

`LOAD_FILE(file_name)`
Reads the file and returns the file contents as a string. The file must be located 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` bytes. If the file doesn't exist or can't be read because one of the preceding conditions is not satisfied, the function returns `NULL`.

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

Before MySQL 3.23, you must read the file inside your application and create an `INSERT` statement to update the database with the file contents. If you are using the MySQL++ library, one way to do this can be found at http://www.mysql.com/documentation/mysql++/mysql++-examples.html.

MySQL Inline-Help Reference - SQL Functions
`LOCATE(substr,str)`

`LOCATE(substr,str)`
`LOCATE(substr,str,pos)`
  The first syntax returns the position of the first occurrence of substring `substr` in string `str`. The second syntax 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');
              -> 4
      mysql> SELECT LOCATE('xbar', 'foobar');
              -> 0
      mysql> SELECT LOCATE('bar', 'foobarbar',5);
              -> 7

  This function is multi-byte safe. In MySQL 3.23, this function is case sensitive. For 4.0 on, it is case sensitive only if either argument is a binary string.

MySQL Inline-Help Reference - SQL Functions
`LOWER(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 LOWER('QUADRATICALLY');
              -> 'quadratically'

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`LPAD(str,len,padstr)`

`LPAD(str,len,padstr)`
  Returns the string `str`, left-padded with the string `padstr` to a length of `len` characters. If `str` is longer than `len`, the return value is shortened to `len` characters.

      mysql> SELECT LPAD('hi',4,'??');
              -> '??hi'
      mysql> SELECT LPAD('hi',1,'??');
              -> 'h'

MySQL Inline-Help Reference - SQL Functions
`LTRIM(str)`

`LTRIM(str)`
  Returns the string `str` with leading space characters removed.

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

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`MAKE_SET(bits,str1,str2,...)`

`MAKE_SET(bits,str1,str2,...)`
  Returns a set value (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, and so on. `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(1 | 4,'hello','nice',NULL,'world');
              -> 'hello'
      mysql> SELECT MAKE_SET(0,'a','b','c');
              -> ''

MySQL Inline-Help Reference - SQL Functions
`MID(str,pos,len)`

`MID(str,pos,len)`
  `MID(str,pos,len)` is a synonym for `SUBSTRING(str,pos,len)`.

MySQL Inline-Help Reference - SQL Functions
`OCT(N)`

`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'

MySQL Inline-Help Reference - SQL Functions
`OCTET_LENGTH(str)`

`OCTET_LENGTH(str)`
  `OCTET_LENGTH()` is a synonym for `LENGTH()`.

MySQL Inline-Help Reference - SQL Functions
`ORD(str)`

`ORD(str)`
  If the leftmost character of the string `str` is a multi-byte character, returns the code for that character, calculated from the numeric values of its constituent bytes using this formula:

        (1st byte code * 256)
      + (2nd byte code * 256^2)
      + (3rd byte code * 256^3) ...

  If the leftmost character is not a multi-byte character, `ORD()` returns the same value that the `ASCII()` function does.

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

MySQL Inline-Help Reference - SQL Functions
`POSITION(substr IN str)`

`POSITION(substr IN str)`
  `POSITION(substr IN str)` is a synonym for `LOCATE(substr,str)`.

MySQL Inline-Help Reference - SQL Functions
`QUOTE(str)`

`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 4.0.3.

      mysql> SELECT QUOTE('Don\'t');
              -> 'Don\'t!'
      mysql> SELECT QUOTE(NULL);
              -> NULL

MySQL Inline-Help Reference - SQL Functions
`REPEAT(str,count)`

`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'

MySQL Inline-Help Reference - SQL Functions
`REPLACE(str,from_str,to_str)`

`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.

MySQL Inline-Help Reference - SQL Functions
`REVERSE(str)`

`REVERSE(str)`
  Returns the string `str` with the order of the characters reversed.

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

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`RIGHT(str,len)`

`RIGHT(str,len)`
  Returns the rightmost `len` characters from the string `str`.

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

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`RPAD(str,len,padstr)`

`RPAD(str,len,padstr)`
  Returns the string `str`, right-padded with the string `padstr` to a length of `len` characters. If `str` is longer than `len`, the return value is shortened to `len` characters.

      mysql> SELECT RPAD('hi',5,'?');
              -> 'hi???'
      mysql> SELECT RPAD('hi',1,'?');
              -> 'h'

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`RTRIM(str)`

`RTRIM(str)`
  Returns the string `str` with trailing space characters removed.

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

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`SOUNDEX(str)`

`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-alphabetic characters are ignored in the given string. All international alphabetic characters outside the A-Z range are treated as vowels.

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

  Note: this function implements the original Soundex algorithm, not the more popular enhanced version (also described by D. Knuth). The difference is that original version discards vowels first and then duplicates, whereas the enhanced discards duplicates first and vowels.

MySQL Inline-Help Reference - SQL Functions
`expr1 SOUNDS LIKE expr2`

`expr1 SOUNDS LIKE expr2`
  This is the same as `SOUNDEX(expr1)=SOUNDEX(expr2)` (available only in MySQL 4.1 or later).

MySQL Inline-Help Reference - SQL Functions
`SPACE(N)`

`SPACE(N)`
  Returns a string consisting of `N` space characters.

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

MySQL Inline-Help Reference - SQL Functions
`SUBSTRING(str,pos)`

`SUBSTRING(str,pos)`
`SUBSTRING(str FROM pos)`
`SUBSTRING(str,pos,len)`
`SUBSTRING(str FROM pos FOR len)`
  The forms without a `len` argument return a substring from string `str` starting at position `pos`. The forms with a `len` argument return a substring `len` characters long from string `str`, starting at position `pos`. The forms that use `FROM` are SQL-92 syntax.

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

  This function is multi-byte safe.

MySQL Inline-Help Reference - SQL Functions
`SUBSTRING_INDEX(str,delim,count)`

`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.

MySQL Inline-Help Reference - SQL Functions
`TRIM([[BOTH | LEADING | TRAILING] [remstr] FROM] str)`

`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` is 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.

MySQL Inline-Help Reference - SQL Functions
`UCASE(str)`

`UCASE(str)`
  `UCASE()` is a synonym for `UPPER()`.

MySQL Inline-Help Reference - SQL Functions
`UNCOMPRESS(string_to_uncompress)`

`UNCOMPRESS(string_to_uncompress)`
  Uncompresses a string compressed by the `COMPRESS()` function. If the argument is not a compressed value, the result is `NULL`.

      mysql> SELECT UNCOMPRESS(COMPRESS('any string'));
              -> 'any string'
      mysql> SELECT UNCOMPRESS('any string');
              -> NULL

  `UNCOMPRESS()` was added in MySQL 4.1.1. It requires MySQL to have been compiled with a compression library such as `zlib`. Otherwise, the return value is always `NULL`.

MySQL Inline-Help Reference - SQL Functions
`UNCOMPRESSED_LENGTH(compressed_string)`

`UNCOMPRESSED_LENGTH(compressed_string)`
  Returns the length of a compressed string before compression.

      mysql> SELECT UNCOMPRESSED_LENGTH(COMPRESS(REPEAT('a',30)));
              -> 30

  `UNCOMPRESSED_LENGTH()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`UNHEX(str)`

`UNHEX(str)`
  Does the opposite of `HEX(string)`. That is, it interprets each pair of hexadecimal digits in the argument as a number and converts it to the character represented by the number. The resulting characters are returned as a binary string.

      mysql> SELECT UNHEX('4D7953514C');
              -> 'MySQL'
      mysql> SELECT 0x4D7953514C;
              -> 'MySQL'
      mysql> SELECT UNHEX(HEX('string'));
              -> 'string'
      mysql> SELECT HEX(UNHEX('1267'));
              -> '1267'

  `UNHEX()` was added in MySQL 4.1.2.

MySQL Inline-Help Reference - SQL Functions
`UPPER(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 UPPER('Hej');
              -> 'HEJ'

  This function is multi-byte safe.

### 13.3.1 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, use the `CAST()` or `CONCAT()` function:

    mysql> SELECT 38.8, CAST(38.8 AS CHAR);
            -> 38.8, '38.8'
    mysql> SELECT 38.8, CONCAT(38.8);
            -> 38.8, '38.8'

`CAST()` is preferable, but it is unavailable before MySQL 4.0.2.

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.

MySQL Inline-Help Reference - SQL Functions
`expr LIKE pat [ESCAPE 'escape-char']`

`expr LIKE pat [ESCAPE 'escape-char']`
Pattern matching using SQL simple regular expression comparison. Returns `1` (TRUE) or `0` (FALSE). If either `expr` or `pat` is `NULL`, the result is `NULL`. With `LIKE` you can use the following two wildcard characters in the pattern:

Character | 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 not case sensitive unless one of the operands is a binary string:

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

In MySQL, `LIKE` is allowed on numeric expressions. (This is an 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'` to represent newline), 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.

MySQL Inline-Help Reference - SQL Functions
`expr NOT LIKE pat [ESCAPE 'escape-char']`

`expr NOT LIKE pat [ESCAPE 'escape-char']`
This is the same as `NOT (expr LIKE pat [ESCAPE 'escape-char'])`.

MySQL Inline-Help Reference - SQL Functions
`expr NOT REGEXP pat`

`expr NOT REGEXP pat`
`expr NOT RLIKE pat`
  This is the same as `NOT (expr REGEXP pat)`.

MySQL Inline-Help Reference - SQL Functions
`expr REGEXP pat`

`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. The syntax for regular expressions is discussed in section F MySQL Regular Expressions. Returns `1` if `expr` matches `pat`, otherwise returns `0`. If either `expr` or `pat` is `NULL`, the result is `NULL`. `RLIKE` is a synonym for `REGEXP`, provided for `mSQL` compatibility. Note: Because MySQL uses the C escape syntax in strings (for example, ``\n'` to represent newline), you must double any ``\'` that you use in your `REGEXP` strings. As of MySQL 3.23.4, `REGEXP` is not case sensitive 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.

MySQL Inline-Help Reference - SQL Functions
`STRCMP(expr1,expr2)`

`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

  As of MySQL 4.0, `STRCMP()` uses the current character set when performing comparisons. This makes the default comparison behavior case insensitive unless one or both of the operands are binary strings. Before MySQL 4.0, `STRCMP()` is case sensitive.

## 13.4 Numeric Functions

### 13.4.1 Arithmetic Operators

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 13.7 Cast Functions.

MySQL Inline-Help Reference - SQL Functions
`+`

`+`
Addition:

    mysql> SELECT 3+5;
            -> 8

MySQL Inline-Help Reference - SQL Functions
`-`

`-`
Subtraction:

    mysql> SELECT 3-5;
            -> -2

MySQL Inline-Help Reference - SQL Functions
`-`

`-`
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`!

MySQL Inline-Help Reference - SQL Functions
`*`

`*`
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.

MySQL Inline-Help Reference - SQL Functions
`/`

`/`
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!

### 13.4.2 Mathematical Functions

All mathematical functions return `NULL` in case of an error.

MySQL Inline-Help Reference - SQL Functions
`ABS(X)`

`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.

MySQL Inline-Help Reference - SQL Functions
`ACOS(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`ASIN(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`ATAN(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`ATAN(Y,X)`

`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

MySQL Inline-Help Reference - SQL Functions
`CEILING(X)`

`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 MySQL 4.0.6. Note that the return value is converted to a `BIGINT`!

MySQL Inline-Help Reference - SQL Functions
`COS(X)`

`COS(X)`
  Returns the cosine of `X`, where `X` is given in radians.

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

MySQL Inline-Help Reference - SQL Functions
`COT(X)`

`COT(X)`
  Returns the cotangent of `X`.

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

MySQL Inline-Help Reference - SQL Functions
`CRC32(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`DEGREES(X)`

`DEGREES(X)`
  Returns the argument `X`, converted from radians to degrees.

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

MySQL Inline-Help Reference - SQL Functions
`DIV`

`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.

MySQL Inline-Help Reference - SQL Functions
`EXP(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`FLOOR(X)`

`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`!

MySQL Inline-Help Reference - SQL Functions
`LN(X)`

`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 4.0.3. It is synonymous with `LOG(X)` in MySQL.

MySQL Inline-Help Reference - SQL Functions
`LOG(X)`

`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 arbitrary base `B`.

      mysql> SELECT LOG(2,65536);
              -> 16.000000
      mysql> SELECT LOG(1,100);
              -> NULL

  The arbitrary base option was added in MySQL 4.0.3. `LOG(B,X)` is equivalent to `LOG(X)/LOG(B)`.

MySQL Inline-Help Reference - SQL Functions
`LOG2(X)`

`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 4.0.3. In earlier versions, you can use `LOG(X)/LOG(2)` instead.

MySQL Inline-Help Reference - SQL Functions
`LOG10(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`MOD(N,M)`

`MOD(N,M)`
`N % M`
`N MOD 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 `N MOD M` syntax works only as of MySQL 4.1

MySQL Inline-Help Reference - SQL Functions
`PI()`

`PI()`
  Returns the value of PI. The default number of decimals displayed is five, but MySQL internally uses the full double precession for PI.

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

MySQL Inline-Help Reference - SQL Functions
`POW(X,Y)`

`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

MySQL Inline-Help Reference - SQL Functions
`RADIANS(X)`

`RADIANS(X)`
  Returns the argument `X`, converted from degrees to radians.

      mysql> SELECT RADIANS(90);
              -> 1.570796

MySQL Inline-Help Reference - SQL Functions
`RAND()`

`RAND()`
`RAND(N)`
  Returns a random floating-point value in the range from `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. As of MySQL 3.23, you can retrieve rows in random order like this:

      mysql> SELECT * FROM tbl_name ORDER BY RAND();

  `ORDER BY RAND()` combined with `LIMIT` is useful for selecting a random sample of a set of rows::

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

  Note that `RAND()` in a `WHERE` clause is 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.

MySQL Inline-Help Reference - SQL Functions
`ROUND(X)`

`ROUND(X)`
`ROUND(X,D)`
  Returns the argument `X`, rounded to the nearest integer. With two arguments, returns `X` rounded 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 behavior of `ROUND()` when the argument is halfway between two integers depends on the C library implementation. Different implementations 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 such as `TRUNCATE()` or `FLOOR()` instead.

MySQL Inline-Help Reference - SQL Functions
`SIGN(X)`

`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

MySQL Inline-Help Reference - SQL Functions
`SIN(X)`

`SIN(X)`
  Returns the sine of `X`, where `X` is given in radians.

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

MySQL Inline-Help Reference - SQL Functions
`SQRT(X)`

`SQRT(X)`
  Returns the non-negative square root of `X`.

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

MySQL Inline-Help Reference - SQL Functions
`TAN(X)`

`TAN(X)`
  Returns the tangent of `X`, where `X` is given in radians.

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

MySQL Inline-Help Reference - SQL Functions
`TRUNCATE(X,D)`

`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, the whole part of the number is zeroed out:

      mysql> SELECT TRUNCATE(122,-2);
             -> 100

  Note that decimal numbers are normally not stored as exact numbers in computers, but as double-precision values, so you may be surprised by the following result:

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

  This happens because `10.28` is actually stored as something like `10.2799999999999999`.

## 13.5 Date and Time Functions

This section describes the functions that can be used to manipulate temporal values. See section 12.2 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 DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

Note that the query also will 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`.

MySQL Inline-Help Reference - SQL Functions
`ADDDATE(date,INTERVAL expr type)`

`ADDDATE(date,INTERVAL expr type)`
`ADDDATE(expr,days)`
  When invoked with the `INTERVAL` form of the second argument, `ADDDATE()` is a synonym for `DATE_ADD()`. The related function `SUBDATE()` is a synonym for `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'

  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 `expr`.

      mysql> SELECT ADDDATE('1998-01-02', 31);
              -> '1998-02-02'

MySQL Inline-Help Reference - SQL Functions
`ADDTIME(expr,expr2)`

`ADDTIME(expr,expr2)`
  `ADDTIME()` adds `expr2` to `expr` and returns the result. `expr` is a date or datetime expression, and `expr2` is a time expression.

      mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',
          ->                '1 1:1:1.000002');
              -> '1998-01-02 01:01:01.000001'
      mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
              -> '03:00:01.999997'

  `ADDTIME()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`CURDATE()`

`CURDATE()`
  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

MySQL Inline-Help Reference - SQL Functions
`CURRENT_DATE`

`CURRENT_DATE`
`CURRENT_DATE()`
  `CURRENT_DATE` and `CURRENT_DATE()` are synonyms for `CURDATE()`.

MySQL Inline-Help Reference - SQL Functions
`CURTIME()`

`CURTIME()`
  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

MySQL Inline-Help Reference - SQL Functions
`CURRENT_TIME`

`CURRENT_TIME`
`CURRENT_TIME()`
  `CURRENT_TIME` and `CURRENT_TIME()` are synonyms for `CURTIME()`.

MySQL Inline-Help Reference - SQL Functions
`CURRENT_TIMESTAMP`

`CURRENT_TIMESTAMP`
`CURRENT_TIMESTAMP()`
  `CURRENT_TIMESTAMP` and `CURRENT_TIMESTAMP()` are synonyms for `NOW()`.

MySQL Inline-Help Reference - SQL Functions
`DATE(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`DATEDIFF(expr,expr2)`

`DATEDIFF(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.

      mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
              -> 1
      mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');
              -> -31

  `DATEDIFF()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`DATE_ADD(date,INTERVAL expr type)`

`DATE_ADD(date,INTERVAL expr type)`
`DATE_SUB(date,INTERVAL expr type)`
  These functions perform date arithmetic. `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 `INTERVAL` keyword and the `type` specifier are not case sensitive. The following table shows how the `type` and `expr` arguments are related:

  `type` Value | Expected `expr` Format
  `MICROSECOND` | `MICROSECONDS`
  `SECOND` | `SECONDS`
  `MINUTE` | `MINUTES`
  `HOUR` | `HOURS`
  `DAY` | `DAYS`
  `WEEK` | `WEEKS`
  `MONTH` | `MONTHS`
  `QUARTER` | `QUARTERS`
  `YEAR` | `YEARS`
  `SECOND_MICROSECOND` | `'SECONDS.MICROSECONDS'`
  `MINUTE_MICROSECOND` | `'MINUTES.MICROSECONDS'`
  `MINUTE_SECOND` | `'MINUTES:SECONDS'`
  `HOUR_MICROSECOND` | `'HOURS.MICROSECONDS'`
  `HOUR_SECOND` | `'HOURS:MINUTES:SECONDS'`
  `HOUR_MINUTE` | `'HOURS:MINUTES'`
  `DAY_MICROSECOND` | `'DAYS.MICROSECONDS'`
  `DAY_SECOND` | `'DAYS HOURS:MINUTES:SECONDS'`
  `DAY_MINUTE` | `'DAYS HOURS:MINUTES'`
  `DAY_HOUR` | `'DAYS HOURS'`
  `YEAR_MONTH` | `'YEARS-MONTHS'`

  The `type` values `DAY_MICROSECOND`, `HOUR_MICROSECOND`, `MINUTE_MICROSECOND`, `SECOND_MICROSECOND`, and `MICROSECOND` are allowed as of MySQL 4.1.1. The values `QUARTER` and `WEEK` are allowed as of MySQL 5.0.0. 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. As of MySQL 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.)

      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. 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'

MySQL Inline-Help Reference - SQL Functions
`DATE_FORMAT(date,format)`

`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
  `%a` | Abbreviated weekday name (`Sun`..`Sat`)
  `%b` | Abbreviated month name (`Jan`..`Dec`)
  `%c` | Month, numeric (`0`..`12`)
  `%D` | Day of the month with English suffix (`0th`, `1st`, `2nd`, `3rd`, ...)
  `%d` | Day of the month, numeric (`00`..`31`)
  `%e` | Day of the month, numeric (`0`..`31`)
  `%f` | Microseconds (`000000`..`999999`)
  `%H` | Hour (`00`..`23`)
  `%h` | Hour (`01`..`12`)
  `%I` | Hour (`01`..`12`)
  `%i` | Minutes, numeric (`00`..`59`)
  `%j` | Day of year (`001`..`366`)
  `%k` | Hour (`0`..`23`)
  `%l` | Hour (`1`..`12`)
  `%M` | Month name (`January`..`December`)
  `%m` | Month, numeric (`00`..`12`)
  `%p` | `AM` or `PM`
  `%r` | Time, 12-hour (`hh:mm:ss` followed by `AM` or `PM`)
  `%S` | Seconds (`00`..`59`)
  `%s` | Seconds (`00`..`59`)
  `%T` | Time, 24-hour (`hh:mm:ss`)
  `%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`
  `%W` | Weekday name (`Sunday`..`Saturday`)
  `%w` | Day of the week (`0`=Sunday..`6`=Saturday)
  `%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`
  `%Y` | Year, numeric, 4 digits
  `%y` | Year, numeric, 2 digits
  `%%` | A literal ``%'`.

  All other characters are copied to the result without interpretation. The `%v`, `%V`, `%x`, and `%X` format specifiers are available as of MySQL 3.23.8. `%f` is available as of MySQL 4.1.1. As of MySQL 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'

MySQL Inline-Help Reference - SQL Functions
`DAY(date)`

`DAY(date)`
  `DAY()` is a synonym for `DAYOFMONTH()`. It is available as of MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`DAYNAME(date)`

`DAYNAME(date)`
  Returns the name of the weekday for `date`.

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

MySQL Inline-Help Reference - SQL Functions
`DAYOFMONTH(date)`

`DAYOFMONTH(date)`
  Returns the day of the month for `date`, in the range `1` to `31`.

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

MySQL Inline-Help Reference - SQL Functions
`DAYOFWEEK(date)`

`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

MySQL Inline-Help Reference - SQL Functions
`DAYOFYEAR(date)`

`DAYOFYEAR(date)`
  Returns the day of the year for `date`, in the range `1` to `366`.

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

MySQL Inline-Help Reference - SQL Functions
`EXTRACT(type FROM date)`

`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

MySQL Inline-Help Reference - SQL Functions
`FROM_DAYS(N)`

`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.

MySQL Inline-Help Reference - SQL Functions
`FROM_UNIXTIME(unix_timestamp)`

`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'

MySQL Inline-Help Reference - SQL Functions
`GET_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL')`

`GET_FORMAT(DATE | TIME | TIMESTAMP, 'EUR' | 'USA' | 'JIS' | 'ISO' | 'INTERNAL')`
  Returns a format string. This function is useful in combination with the `DATE_FORMAT()` and the `STR_TO_DATE()` functions. The three possible values for the first argument and the five possible values for the second argument result in 15 possible format strings (for the specifiers used, see the table in the `DATE_FORMAT()` function description).

  Function Call | Result
  `GET_FORMAT(DATE,'USA')` | `'%m.%d.%Y'`
  `GET_FORMAT(DATE,'JIS')` | `'%Y-%m-%d'`
  `GET_FORMAT(DATE,'ISO')` | `'%Y-%m-%d'`
  `GET_FORMAT(DATE,'EUR')` | `'%d.%m.%Y'`
  `GET_FORMAT(DATE,'INTERNAL')` | `'%Y%m%d'`
  `GET_FORMAT(TIMESTAMP,'USA')` | `'%Y-%m-%d-%H.%i.%s'`
  `GET_FORMAT(TIMESTAMP,'JIS')` | `'%Y-%m-%d %H:%i:%s'`
  `GET_FORMAT(TIMESTAMP,'ISO')` | `'%Y-%m-%d %H:%i:%s'`
  `GET_FORMAT(TIMESTAMP,'EUR')` | `'%Y-%m-%d-%H.%i.%s'`
  `GET_FORMAT(TIMESTAMP,'INTERNAL')` | `'%Y%m%d%H%i%s'`
  `GET_FORMAT(TIME,'USA')` | `'%h:%i:%s %p'`
  `GET_FORMAT(TIME,'JIS')` | `'%H:%i:%s'`
  `GET_FORMAT(TIME,'ISO')` | `'%H:%i:%s'`
  `GET_FORMAT(TIME,'EUR')` | `'%H.%i.%S'`
  `GET_FORMAT(TIME,'INTERNAL')` | `'%H%i%s'`

  ISO format is ISO 9075, not ISO 8601.

      mysql> SELECT DATE_FORMAT('2003-10-03',
          ->                    GET_FORMAT(DATE, 'EUR')
              -> '03.10.2003'
      mysql> SELECT STR_TO_DATE('10.31.2003',
          ->                    GET_FORMAT(DATE, 'USA'))
              -> 2003-10-31

  `GET_FORMAT()` is available as of MySQL 4.1.1. See See section 14.5.3.1 `SET` Syntax.

MySQL Inline-Help Reference - SQL Functions
`HOUR(time)`

`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

MySQL Inline-Help Reference - SQL Functions
`LAST_DAY(date)`

`LAST_DAY(date)`
  Takes a date or datetime value and returns the corresponding value for the last day of the month. Returns `NULL` if the argument is invalid.

      mysql> SELECT LAST_DAY('2003-02-05');
              -> '2003-02-28'
      mysql> SELECT LAST_DAY('2004-02-05');
              -> '2004-02-29'
      mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
              -> '2004-01-31'
      mysql> SELECT LAST_DAY('2003-03-32');
              -> NULL

  `LAST_DAY()` is available as of MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`LOCALTIME`

`LOCALTIME`
`LOCALTIME()`
  `LOCALTIME` and `LOCALTIME()` are synonyms for `NOW()`.

MySQL Inline-Help Reference - SQL Functions
`LOCALTIMESTAMP`

`LOCALTIMESTAMP`
`LOCALTIMESTAMP()`
  `LOCALTIMESTAMP` and `LOCALTIMESTAMP()` are synonyms for `NOW()`.

MySQL Inline-Help Reference - SQL Functions
`MAKEDATE(year,dayofyear)`

`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.

MySQL Inline-Help Reference - SQL Functions
`MAKETIME(hour,minute,second)`

`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.

MySQL Inline-Help Reference - SQL Functions
`MICROSECOND(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`MINUTE(time)`

`MINUTE(time)`
  Returns the minute for `time`, in the range `0` to `59`.

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

MySQL Inline-Help Reference - SQL Functions
`MONTH(date)`

`MONTH(date)`
  Returns the month for `date`, in the range `1` to `12`.

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

MySQL Inline-Help Reference - SQL Functions
`MONTHNAME(date)`

`MONTHNAME(date)`
  Returns the full name of the month for `date`.

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

MySQL Inline-Help Reference - SQL Functions
`NOW()`

`NOW()`
  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

MySQL Inline-Help Reference - SQL Functions
`PERIOD_ADD(P,N)`

`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

MySQL Inline-Help Reference - SQL Functions
`PERIOD_DIFF(P1,P2)`

`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

MySQL Inline-Help Reference - SQL Functions
`QUARTER(date)`

`QUARTER(date)`
  Returns the quarter of the year for `date`, in the range `1` to `4`.

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

MySQL Inline-Help Reference - SQL Functions
`SECOND(time)`

`SECOND(time)`
  Returns the second for `time`, in the range `0` to `59`.

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

MySQL Inline-Help Reference - SQL Functions
`SEC_TO_TIME(seconds)`

`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

MySQL Inline-Help Reference - SQL Functions
`STR_TO_DATE(str,format)`

`STR_TO_DATE(str,format)`
  This is the reverse function of the `DATE_FORMAT()` function. It takes a string `str`, and a format string `format`, and returns a `DATETIME` value. The date, time, or datetime values contained in `str` should be given in the format indicated by `format`. For the specifiers that can be used in `format`, see the table in the `DATE_FORMAT()` function description. All other characters are just taken verbatim, thus not being interpreted. If `str` contains an illegal date, time, or datetime value, `STR_TO_DATE()` returns `NULL`.

      mysql> SELECT STR_TO_DATE('03.10.2003 09.20',
          ->                    '%d.%m.%Y %H.%i');
              -> '2003-10-03 09:20:00'
      mysql> SELECT STR_TO_DATE('10arp', '%carp');
              -> '0000-10-00 00:00:00'
      mysql> SELECT STR_TO_DATE('2003-15-10 00:00:00',
          ->                    '%Y-%m-%d %H:%i:%s');
              -> NULL

  `STR_TO_DATE()` is available as of MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`SUBDATE(date,INTERVAL expr type)`

`SUBDATE(date,INTERVAL expr type)`
`SUBDATE(expr,days)`
  When invoked with the `INTERVAL` form of the second argument, `SUBDATE()` is a synonym for `DATE_SUB()`.

      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 subtracted from `expr`.

      mysql> SELECT SUBDATE('1998-01-02 12:00:00', 31);
              -> '1997-12-02 12:00:00'

MySQL Inline-Help Reference - SQL Functions
`SUBTIME(expr,expr2)`

`SUBTIME(expr,expr2)`
  `SUBTIME()` subtracts `expr2` from `expr` and returns the result. `expr` is a date or datetime expression, and `expr2` is a time expression.

      mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999',
          ->                '1 1:1:1.000002');
              -> '1997-12-30 22:58:58.999997'
      mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');
              -> '-00:59:59.999999'

  `SUBTIME()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`SYSDATE()`

`SYSDATE()`
  `SYSDATE()` is a synonym for `NOW()`.

MySQL Inline-Help Reference - SQL Functions
`TIME(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`TIMEDIFF(expr,expr2)`

`TIMEDIFF(expr,expr2)`
  `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 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'

  `TIMEDIFF()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`TIMESTAMP(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`TIMESTAMPADD(interval,int_expr,datetime_expr)`

`TIMESTAMPADD(interval,int_expr,datetime_expr)`
  Adds the integer expression `int_expr` to the date or datetime expression `datetime_expr`. The unit for `int_expr` is given by the `interval` argument, which should be one of the following values: `FRAC_SECOND`, `SECOND`, `MINUTE`, `HOUR`, `DAY`, `WEEK`, `MONTH`, `QUARTER`, or `YEAR`. The `interval` value may be specified using one of keywords as shown, or with a prefix of `SQL_TSI_`. For example, `DAY` or `SQL_TSI_DAY` both are legal.

      mysql> SELECT TIMESTAMPADD(MINUTE,1,'2003-01-02');
              -> '2003-01-02 00:01:00'
      mysql> SELECT TIMESTAMPADD(WEEK,1,'2003-01-02');
              -> '2003-01-09'

  `TIMESTAMPADD()` is available as of MySQL 5.0.0.

MySQL Inline-Help Reference - SQL Functions
`TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)`

`TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)`
  Returns the integer difference between the date or datetime expressions `datetime_expr1` and `datetime_expr2`. The unit for the result is given by the `interval` argument. The legal values for `interval` are the same as those described in the desription of the `TIMESTAMPADD()` function.

      mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
              -> 3
      mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
              -> -1

  `TIMESTAMPDIFF()` is available as of MySQL 5.0.0.

MySQL Inline-Help Reference - SQL Functions
`TIME_FORMAT(time,format)`

`TIME_FORMAT(time,format)`
  This is used like the `DATE_FORMAT()` function, 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'

MySQL Inline-Help Reference - SQL Functions
`TIME_TO_SEC(time)`

`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 Inline-Help Reference - SQL Functions
`TO_DAYS(date)`

`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. Take into account that MySQL converts two-digit year values in dates to four-digit form using the rules in section 12.2 Date and Time Types. For example, `'1997-10-07'` and `'97-10-07'` are seen as identical dates:

      mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');
              -> 729669, 729669

  For other dates before 1582, results from this function are undefined.

MySQL Inline-Help Reference - SQL Functions
`UNIX_TIMESTAMP()`

`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 range checking is performed (year from `1970` to `2037`, month from `01` to `12`, day from `01` from `31`). If you want to subtract `UNIX_TIMESTAMP()` columns, you might want to cast the result to signed integers. See section 13.7 Cast Functions.

MySQL Inline-Help Reference - SQL Functions
`UTC_DATE`

`UTC_DATE`
`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.

MySQL Inline-Help Reference - SQL Functions
`UTC_TIME`

`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.

MySQL Inline-Help Reference - SQL Functions
`UTC_TIMESTAMP`

`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.

MySQL Inline-Help Reference - SQL Functions
`WEEK(date [,mode])`

`WEEK(date [,mode])`
  The function returns the week number for `date`. 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 from `0` to `53` or from `1` to `52`. When the `mode` argument is omitted, the value of the `default_week_format` server variable is assumed (or `0` before MySQL 4.0.14). See section 5.2.3 Server System Variables. The following table demonstrates how the `mode` argument works:

  Value | Meaning
  `0` | Week starts on Sunday; return value range is `0` to `53`; week 1 is the first week that starts in this year
  `1` | Week starts on Monday; return value range is `0` to `53`; week 1 is the first week that has more than 3 days in this year
  `2` | Week starts on Sunday; return value range is `1` to `53`; week 1 is the first week that starts in this year
  `3` | Week starts on Monday; return value range is `1` to `53`; week 1 is the first week that has more than 3 days in this year
  `4` | Week starts on Sunday; return value range is `0` to `53`; week 1 is the first week that has more than 3 days in this year
  `5` | Week starts on Monday; return value range is `0` to `53`; week 1 is the first week that starts in this year
  `6` | Week starts on Sunday; return value range is `1` to `53`; week 1 is the first week that has more than 3 days in this year
  `7` | Week starts on Monday; return value range is `1` to `53`; week 1 is the first week that starts in this year

  The `mode` value of `3` can be used as of MySQL 4.0.5. The `mode` values of `4` and above can be used as of MySQL 4.0.17.

      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

  Note: In MySQL 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)` were incorrect for all cases.) Note that if a date falls in the last week of the previous year, MySQL returns `0` if you don't use `2`, `3`, `6`, or `7` as the optional `mode` 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`, `3`, `6`, or `7` as the optional `mode` 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'

MySQL Inline-Help Reference - SQL Functions
`WEEKDAY(date)`

`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

MySQL Inline-Help Reference - SQL Functions
`WEEKOFYEAR(date)`

`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.

MySQL Inline-Help Reference - SQL Functions
`YEAR(date)`

`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()`. 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.

## 13.6 Full-text Search Functions

MySQL Inline-Help Reference - SQL Functions
`MATCH (col1,col2,...) AGAINST (expr [IN BOOLEAN MODE | WITH QUERY EXPANSION] )`

`MATCH (col1,col2,...) AGAINST (expr [IN BOOLEAN MODE | WITH QUERY EXPANSION] )`
As of MySQL 3.23.23, MySQL has support for full-text indexing and searching. A full-text index in MySQL is an index of type `FULLTEXT`. `FULLTEXT` indexes are used with `MyISAM` tables only and can be created from `CHAR`, `VARCHAR`, or `TEXT` columns at `CREATE TABLE` time or added later with `ALTER TABLE` or `CREATE INDEX`. For large datasets, it will be much faster to load your data into a table that has no `FULLTEXT` index, then create the index with `ALTER TABLE` (or `CREATE INDEX`). Loading data into a table that already has a `FULLTEXT` index could be significantly slower. Constraints on full-text searching are listed in section 13.6.3 Full-text Restrictions.

Full-text searching is performed with the `MATCH()` function.

    mysql> CREATE TABLE articles (
        ->   id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
        ->   title VARCHAR(200),
        ->   body TEXT,
        ->   FULLTEXT (title,body)
        -> );
    Query OK, 0 rows affected (0.00 sec)

    mysql> INSERT INTO articles (title,body) VALUES
        -> ('MySQL Tutorial','DBMS stands for DataBase ...'),
        -> ('How To Use MySQL Efficiently','After you went through a ...'),
        -> ('Optimizing MySQL','In this tutorial we will show ...'),
        -> ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
        -> ('MySQL vs. YourSQL','In the following database comparison ...'),
        -> ('MySQL Security','When configured properly, MySQL ...');
    Query OK, 6 rows affected (0.00 sec)
    Records: 6  Duplicates: 0  Warnings: 0

    mysql> SELECT * FROM articles
        -> WHERE MATCH (title,body) AGAINST ('database');
    +----+-------------------+------------------------------------------+
    | id | title             | body                                     |
    +----+-------------------+------------------------------------------+
    |  5 | MySQL vs. YourSQL | In the following database comparison ... |
    |  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
    +----+-------------------+------------------------------------------+
    2 rows in set (0.00 sec)

The `MATCH()` function performs a natural language search for a string against a text collection. A collection is a set of one or more columns included in a `FULLTEXT` index. The search string is given as the argument to `AGAINST()`. The search is performed in case-insensitive fashion. For every row in the table, `MATCH()` returns a relevance value, that is, a similarity measure between the search string and the text in that row in the columns named in the `MATCH()` list.

When `MATCH()` is used in a `WHERE` clause, as in the preceding example, the rows returned are automatically sorted with the highest relevance first. Relevance values are non-negative floating-point numbers. Zero relevance means no similarity. Relevance is computed based on the number of words in the row, the number of unique words in that row, the total number of words in the collection, and the number of documents (rows) that contain a particular word.

For natural-language full-text searches, it is a requirement that the columns named in the `MATCH()` function be the same columns included in some `FULLTEXT` index in your table. For the preceding query, note that the columns named in the `MATCH()` function (`title` and `body`) are the same as those named in the definition of the `article` table's `FULLTEXT` index. If you wanted to search the `title` or `body` separately, you would need to create `FULLTEXT` indexes for each column.

It is also possible to perform a boolean search or a search with query expansion. These search types are described in section 13.6.1 Boolean Full-text Searches and section 13.6.2 Full-text Searches with Query Expansion.

The preceding example is a basic illustration showing how to use the `MATCH()` function where rows are returned in order of decreasing relevance. The next example shows how to retrieve the relevance values explicitly. Returned rows are not ordered because the `SELECT` statement includes neither `WHERE` nor `ORDER BY` clauses:

    mysql> SELECT id, MATCH (title,body) AGAINST ('Tutorial')
        -> FROM articles;
    +----+-----------------------------------------+
    | id | MATCH (title,body) AGAINST ('Tutorial') |
    +----+-----------------------------------------+
    |  1 |                        0.64840710366884 |
    |  2 |                                       0 |
    |  3 |                        0.66266459031789 |
    |  4 |                                       0 |
    |  5 |                                       0 |
    |  6 |                                       0 |
    +----+-----------------------------------------+
    6 rows in set (0.00 sec)

The following example is more complex. The query returns the relevance values and it also sorts the rows in order of decreasing relevance. To achieve this result, you should specify `MATCH()` twice, once in the `SELECT` list and once in the `WHERE` clause. This causes no additional overhead, because the MySQL optimizer notices that the two `MATCH()` calls are identical and invokes the full-text search code only once.

    mysql> SELECT id, body, MATCH (title,body) AGAINST
        -> ('Security implications of running MySQL as root') AS score
        -> FROM articles WHERE MATCH (title,body) AGAINST
        -> ('Security implications of running MySQL as root');
    +----+-------------------------------------+-----------------+
    | id | body                                | score           |
    +----+-------------------------------------+-----------------+
    |  4 | 1. Never run mysqld as root. 2. ... | 1.5055546709332 |
    |  6 | When configured properly, MySQL ... |   1.31140957288 |
    +----+-------------------------------------+-----------------+
    2 rows in set (0.00 sec)

MySQL uses a very simple parser to split text into words. A ``word'' is any sequence of characters consisting of letters, digits, ``''`, or ``_'`. Some words are ignored in full-text searches:

- Any word that is too short is ignored. The default minimum length of words that will be found by full-text searches is four characters.
- Words in the stopword list are ignored. A stopword is a word such as ``the'' or ``some'' that is so common that it is considered to have zero semantic value. There is a built-in stopword list.

The default minimum word length and stopword list can be changed as described in section 13.6.4 Fine-tuning MySQL Full-text Search.

Every correct word in the collection and in the query is weighted according to its significance in the collection or query. This way, a word that is present in many documents has a lower weight (and may even have a zero weight), because it has lower semantic value in this particular collection. Conversely, if the word is rare, it receives a higher weight. The weights of the words are then combined to compute the relevance of the row.

Such a technique works best with large collections (in fact, it was carefully tuned this way). For very small tables, word distribution does not adequately reflect their semantic value, and this model may sometimes produce bizarre results. For example, although the word ``MySQL'' is present in every row of the `articles` table, a search for the word produces no results:

    mysql> SELECT * FROM articles
        -> WHERE MATCH (title,body) AGAINST ('MySQL');
    Empty set (0.00 sec)

The search result is empty because the word ``MySQL'' is present in at least 50% of the rows. As such, it is effectively treated as a stopword. For large datasets, this is the most desirable behavior--a natural language query should not return every second row from a 1GB table. For small datasets, it may be less desirable.

A word that matches half of rows in a table is less likely to locate relevant documents. In fact, it will most likely find plenty of irrelevant documents. We all know this happens far too often when we are trying to find something on the Internet with a search engine. It is with this reasoning that rows containing the word are assigned a low semantic value for the particular dataset in which they occur. A given word may exceed the 50% threshold in one dataset but not another.

The 50% threshold has a significant implication when you first try full-text searching to see how it works: If you create a table and insert only one or two rows of text into it, every word in the text occurs in at least 50% of the rows. As a result, no searches return any results. Be sure to insert at least three rows, and preferably many more.

### 13.6.1 Boolean Full-text Searches

As of Version 4.0.1, MySQL can also perform boolean full-text searches using the `IN BOOLEAN MODE` modifier.

    mysql> SELECT * FROM articles WHERE MATCH (title,body)
        -> AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);
    +----+------------------------------+-------------------------------------+
    | id | title                        | body                                |
    +----+------------------------------+-------------------------------------+
    |  1 | MySQL Tutorial               | DBMS stands for DataBase ...        |
    |  2 | How To Use MySQL Efficiently | After you went through a ...        |
    |  3 | Optimizing MySQL             | In this tutorial we will show ...   |
    |  4 | 1001 MySQL Tricks            | 1. Never run mysqld as root. 2. ... |
    |  6 | MySQL Security               | When configured properly, MySQL ... |
    +----+------------------------------+-------------------------------------+

This query retrieves all the rows that contain the word ``MySQL'' but that do not contain the word ``YourSQL''.

Some characteristics of boolean full-text searches:

- They do not use the 50% threshold.
- They do not automatically sort rows in order of decreasing relevance. You can see this from the preceding query result: The row with the highest relevance is the one that contains ``MySQL'' twice, but it is listed last, not first.
- They can work even without a `FULLTEXT` index, although this would be slow.

The boolean full-text search capability supports the following operators:

`+`
  A leading plus sign indicates that this word must be present in every row returned.
`-`
  A leading minus sign indicates that this word must not be present in any row returned.
``
  By default (when neither plus nor minus is specified) the word is optional, but the rows that contain it will be rated higher. This mimicks the behavior of `MATCH() ... AGAINST()` without the `IN BOOLEAN MODE` modifier.
`> <`
  These two operators are used to change a word's contribution to the relevance value that is assigned to a row. The `>` operator increases the contribution and the `<` operator decreases it. See the example below.
`( )`
  Parentheses are used to group words into subexpressions. Parenthesized groups can be nested.
`~`
  A leading tilde acts as a negation operator, causing the word's contribution to the row relevance to be negative. It's useful for marking noise words. A row that contains such a word will be rated lower than others, but will not be excluded altogether, as it would be with the `-` operator.
`*`
  An asterisk is the truncation operator. Unlike the other operators, it should be appended to the word, not prepended.
`"`
  A phrase that is enclosed within double quote (``"'`) characters matches only rows that contain the phrase literally, as it was typed.

The following examples demonstrate some search strings that use boolean full-text operators:

`'apple banana'`
  Find rows that contain at least one of the two words.
`'+apple +juice'`
  Find rows that contain both words.
`'+apple macintosh'`
  Find rows that contain the word ``apple'', but rank rows higher if they also contain ``macintosh''.
`'+apple -macintosh'`
  Find rows that contain the word ``apple'' but not ``macintosh''.
`'+apple +(>turnover <strudel)'`
  Find rows that contain the words ``apple'' and ``turnover'', or ``apple'' and ``strudel'' (in any order), but rank ``apple turnover'' higher than ``apple strudel''.
`'apple*'`
  Find rows that contain words such as ``apple'', ``apples'', ``applesauce'', or ``applet''.
`'"some words"'`
  Find rows that contain the exact phrase ``some words'' (for example, rows that contain ``some words of wisdom'' but not ``some noise words''). Note that the ``"'` characters that surround the phrase are included within the search string. They are not the quotes that surround the search string itself.

### 13.6.2 Full-text Searches with Query Expansion

As of MySQL 4.1.1, full-text search supports query expansion (in particular, its variant ``blind query expansion''). This is generally useful when a search phrase is too short, which often means that the user is relying on implied knowledge that the full-text search engine usually lacks. For example, a user searching for ``database'' may really mean that ``MySQL'', ``Oracle'', ``DB2'', and ``RDBMS'' all are phrases that should match ``databases'' and should be returned, too. This is implied knowledge.

Blind query expansion (also known as automatic relevance feedback) is enabled by adding `WITH QUERY EXPANSION` following the search phrase. It works by performing the search twice, where the search phrase for the second search is the original search phrase concatenated with the few top found documents from the first search. Thus, if one of these documents contains the word ``databases'' and the word ``MySQL'', the second search will find the documents that contain the word ``MySQL'' even if they do not contain the word ``database''. The following example shows this difference:

    mysql> SELECT * FROM articles
        -> WHERE MATCH (title,body) AGAINST ('database');
    +----+-------------------+------------------------------------------+
    | id | title             | body                                     |
    +----+-------------------+------------------------------------------+
    |  5 | MySQL vs. YourSQL | In the following database comparison ... |
    |  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
    +----+-------------------+------------------------------------------+
    2 rows in set (0.00 sec)

    mysql> SELECT * FROM articles
        -> WHERE MATCH (title,body)
        -> AGAINST ('database' WITH QUERY EXPANSION);
    +----+-------------------+------------------------------------------+
    | id | title             | body                                     |
    +----+-------------------+------------------------------------------+
    |  1 | MySQL Tutorial    | DBMS stands for DataBase ...             |
    |  5 | MySQL vs. YourSQL | In the following database comparison ... |
    |  3 | Optimizing MySQL  | In this tutorial we will show ...        |
    +----+-------------------+------------------------------------------+
    3 rows in set (0.00 sec)

Another example could be searching for books by Georges Simenon about Maigret, when a user is not sure how to spell ``Maigret''. A search for ``Megre and the reluctant witnesses'' will find only ``Maigret and the Reluctant Witnesses'' without query expansion. A search with query expansion will find all books with the word ``Maigret'' on the second pass.

Note: Because blind query expansion tends to increase noise significantly, by returning non-relevant documents, it's only meaningful to use when a search phrase is rather short.

### 13.6.3 Full-text Restrictions

- Full-text searches are supported for `MyISAM` tables only.
- As of MySQL 4.1.1, full-text searches can be used with most multi-byte character sets. The exception is that for Unicode, the `utf8` character set can be used, but not the `ucs2` character set.
- All columns in a `FULLTEXT` index must have the same character set.
- The `MATCH()` column list must exactly match the column list in some `FULLTEXT` index definition for the table, unless this `MATCH()` is `IN BOOLEAN MODE`.
- The argument to `AGAINST()` must be a constant string.

### 13.6.4 Fine-tuning MySQL Full-text Search

The MySQL full-text search capability has few user-tunable parameters yet, although adding more is very high on the TODO. You can exert more control over full-text searching behavior if you have a MySQL source distribution because some changes require source code modfications. See section 2.3 MySQL Installation Using a Source Distribution.

Note that full-text search was carefully tuned for the best searching effectiveness. Modifying the default behavior will, in most cases, make the search results worse. Do not alter the MySQL sources unless you know what you are doing!

Most full-text variables described in the following items must be set at server startup time. For these variables, a server restart is required to change them and you cannot modify them dynamically while the server is running.

If you modify full-text variables that affect indexing (`ft_min_word_len`, `ft_max_word_len`, or `ft_stopword_file`), you must rebuild your `FULLTEXT` indexes after making the changes and restarting the server. To rebuild the indexes in this case, it's sufficent to do a `QUICK` repair operation:

    mysql> REPAIR TABLE tbl_name QUICK;

With regard specifically to using the `IN BOOLEAN MODE` capability, if you upgrade from MySQL 3.23 to 4.0 or later, it's necessary to replace the index header as well. To do this, do a `USE_FRM` repair operation:

    mysql> REPAIR TABLE tbl_name USE_FRM;

This is necessary because boolean full-text searches require a flag in the index header that was not present in MySQL 3.23, and that is not added if you do only a `QUICK` repair. If you attempt a boolean full-text search without rebuilding the indexes this way, the search will return incorrect results.

- The minimum and maximum length of words to be indexed is defined by the `ft_min_word_len` and `ft_max_word_len` system variables (available as of MySQL 4.0.0). See section 5.2.3 Server System Variables. The default minimum value is four characters. The default maximum depends on your version of MySQL. If you change either value, you must rebuild your `FULLTEXT` indexes. For example, if you want three-character words to be searchable, you can set the `ft_min_word_len` variable by putting the following lines in an option file:

      [mysqld]
      ft_min_word_len=3

  Then restart the server and rebuild your `FULLTEXT` indexes.
- To override the default stopword list, set the `ft_stopword_file` system variable (available as of MySQL 4.0.10). See section 5.2.3 Server System Variables. The variable value should be the pathname of the file containing the stopword list, or the empty string to disable stopword filtering. After changing the value, rebuild your `FULLTEXT` indexes.
- The 50% threshold for natural language searches is determined by the particular weighting scheme chosen. To disable it, look for the following line in ``myisam/ftdefs.h'`:

      #define GWS_IN_USE GWS_PROB

  Change the line to this:

      #define GWS_IN_USE GWS_FREQ

  Then recompile MySQL. There is no need to rebuild the indexes in this case. Note: By doing this you severely decrease MySQL's ability to provide adequate relevance values for the `MATCH()` function. If you really need to search for such common words, it would be better to search using `IN BOOLEAN MODE` instead, which does not observe the 50% threshold.
- To change the operators used for boolean full-text searches, set the `ft_boolean_syntax` system variable (available as of MySQL 4.0.1). The variable also can be changed while the server is running, but you must have the `SUPER` privilege to do so. No index rebuilding is necessary. section 5.2.3 Server System Variables describes the rules that define how to set this variable.

### 13.6.5 Full-text Search TODO

- Improved performance for all `FULLTEXT` operations.
- Proximity operators
- Support for ``always-index words.'' These could be any strings the user wants to treat as words, such as ``C++'', ``AS/400'', or ``TCP/IP''.
- Support for full-text search in `MERGE` tables.
- Support for UCS-2.
- Make the stopword list dependent on the language of the dataset.
- Stemming (dependent on the language of the dataset).
- Generic user-suppliable UDF preparser.
- Make the model more flexible (by adding some adjustable parameters to `FULLTEXT` in `CREATE TABLE` and `ALTER TABLE` statements).

## 13.7 Cast Functions

MySQL Inline-Help Reference - SQL Functions
`CAST(expr AS type)`

`CAST(expr AS type)`

MySQL Inline-Help Reference - SQL Functions
`CONVERT(expr,type)`

`CONVERT(expr,type)`
`CONVERT(expr USING transcoding_name)`
  The `CAST()` and `CONVERT()` functions may be used to take a value of one type and produce a value of another type. 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. `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);

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(str AS BINARY)` is the same thing as `BINARY str`. `CAST(expr AS CHAR)` treats the expression as a string with the default character set.

Note: In MysQL 4.0, a `CAST()` to `DATE`, `DATETIME`, or `TIME` only marks the column to be a specific type but doesn't change the value of the column.

As of 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 `CAST` so that it also changes the result if you use it as part of a more complex expression such as `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 13.5 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 were a number:

    mysql> SELECT 1+'1';
           -> 2

If you use a number in string context, the number automatically will 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 operators (like `+`) and one of the operands is an 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 preceding rule. (In this context, `DECIMAL` column 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, 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 `ucol1` and `ucol2`:

    mysql> SELECT (ucol1+0.0)-(ucol1+0.0);

The idea is that the columns are converted to floating-point values before the subtraction occurs.

If you have a problem with `UNSIGNED` columns in old MySQL applications when porting them to MySQL 4.0, you can use the `--sql-mode=NO_UNSIGNED_SUBTRACTION` option when starting `mysqld`. However, as long as you use this option, you will not be able to make efficient use of the `BIGINT UNSIGNED` column type.

## 13.8 Other Functions

### 13.8.1 Bit Functions

MySQL uses `BIGINT` (64-bit) arithmetic for bit operations, so these operators have a maximum range of 64 bits.

MySQL Inline-Help Reference - SQL Functions
`|`

`|`
Bitwise OR:

    mysql> SELECT 29 | 15;
            -> 31

The result is an unsigned 64-bit integer.

MySQL Inline-Help Reference - SQL Functions
`&`

`&`
Bitwise AND:

    mysql> SELECT 29 & 15;
            -> 13

The result is an unsigned 64-bit integer.

MySQL Inline-Help Reference - SQL Functions
`^`

`^`
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 MySQL 4.0.2.

MySQL Inline-Help Reference - SQL Functions
`<<`

`<<`
Shifts a longlong (`BIGINT`) number to the left.

    mysql> SELECT 1 << 2;
            -> 4

The result is an unsigned 64-bit integer.

MySQL Inline-Help Reference - SQL Functions
`>>`

`>>`
Shifts a longlong (`BIGINT`) number to the right.

    mysql> SELECT 4 >> 2;
            -> 1

The result is an unsigned 64-bit integer.

MySQL Inline-Help Reference - SQL Functions
`~`

`~`
Invert all bits.

    mysql> SELECT 5 & ~1;
            -> 4

The result is an unsigned 64-bit integer.

MySQL Inline-Help Reference - SQL Functions
`BIT_COUNT(N)`

`BIT_COUNT(N)`
Returns the number of bits that are set in the argument `N`.

    mysql> SELECT BIT_COUNT(29);
            -> 4

### 13.8.2 Encryption Functions

MySQL Inline-Help Reference - SQL Functions
`AES_ENCRYPT(str,key_str)`

`AES_ENCRYPT(str,key_str)`

MySQL Inline-Help Reference - SQL Functions
`AES_DECRYPT(str,key_str)`

`AES_DECRYPT(str,key_str)`
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`. Because 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 is 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. For example:

    SELECT @password:='my password';
    INSERT INTO t VALUES (1,AES_ENCRYPT('text',@password));

`AES_ENCRYPT()` and `AES_DECRYPT()` were added in MySQL 4.0.2, and can be considered the most cryptographically secure encryption functions currently available in MySQL.

MySQL Inline-Help Reference - SQL Functions
`DECODE(crypt_str,pass_str)`

`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()`.

MySQL Inline-Help Reference - SQL Functions
`ENCODE(str,pass_str)`

`ENCODE(str,pass_str)`
Encrypt `str` using `pass_str` as the password. To decrypt the result, use `DECODE()`. The result is a binary string of the same length as `string`. If you want to save it in a column, use a `BLOB` column type.

MySQL Inline-Help Reference - SQL Functions
`DES_DECRYPT(str_to_decrypt [, key_str])`

`DES_DECRYPT(str_to_decrypt [, key_str])`
Decrypts a string encrypted with `DES_ENCRYPT()`. On error, this function returns `NULL`. Note that this function works only if MySQL has been configured with SSL support. See section 5.5.8 Using Secure Connections. If no `key_str` 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, and then reads the key from the DES key file to decrypt the message. For this to work, the user must have the `SUPER` privilege. The key file can be specified with the `--des-key-file` server option. If you pass this function a `key_str` argument, that string is used as the key for decrypting the message. If the `str_to_decrypt` argument doesn't look like an encrypted string, MySQL will return the given `str_to_decrypt`.

MySQL Inline-Help Reference - SQL Functions
`DES_ENCRYPT(str_to_encrypt [, (key_num | key_str) ] )`

`DES_ENCRYPT(str_to_encrypt [, (key_num | key_str) ] )`
Encrypts the string with the given key using the Triple-DES algorithm. On error, this function returns `NULL`. Note that this function works only if MySQL has been configured with SSL support. See section 5.5.8 Using Secure Connections. The encryption key to use is chosen based on the second argument to `DES_ENCRYPT()`, if one was given:

Argument | Description
No argument | The first key from the DES key file is used.
`key_num` | The given key number (0-9) from the DES key file is used.
`key_str` | The given key string is used to encrypt `str_to_encrypt`.

The key file can be specified with the `--des-key-file` server option. The return string is a binary string where the first character is `CHAR(128 | key_num)`. The 128 is added to make it easier to recognize an encrypted key. If you use a string key, `key_num` will be 127. The string length for the result will be `new_len = orig_len + (8-(orig_len % 8))+1`. The DES key file has the following format:

    key_num des_key_str
    key_num des_key_str

Each `key_num` must be a number in the range from `0` to `9`. Lines in the file may be in any order. `des_key_str` 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 is 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` 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');

MySQL Inline-Help Reference - SQL Functions
`ENCRYPT(str[,salt])`

`ENCRYPT(str[,salt])`
Encrypt `str` using the Unix `crypt()` system call. The `salt` argument should be a string with two characters. (As of MySQL 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 behavior 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, because these two functions exist on all platforms.

MySQL Inline-Help Reference - SQL Functions
`MD5(str)`

`MD5(str)`
Calculates an MD5 128-bit checksum for the string. The value is returned as a string of 32 hex digits, or `NULL` if the argument was `NULL`. The return value can, for example, be used as a hash key.

    mysql> SELECT MD5('testing');
            -> 'ae2b1fca515949e5d54fb22b8ed95575'

This is the "RSA Data Security, Inc. MD5 Message-Digest Algorithm".

MySQL Inline-Help Reference - SQL Functions
`PASSWORD(str)`

`PASSWORD(str)`
`OLD_PASSWORD(str)`
  Calculates and returns a password string from the plaintext password `str`, or `NULL` if the argument was `NULL`. 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 one-way (not 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.

MySQL Inline-Help Reference - SQL Functions
`SHA1(str)`

`SHA1(str)`
`SHA(str)`
  Calculates an SHA1 160-bit checksum for the string, as described in RFC 3174 (Secure Hash Algorithm). The value is returned as a string of 40 hex digits, or `NULL` if the 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 MySQL 4.0.2, and can be considered a cryptographically more secure equivalent of `MD5()`. `SHA()` is synonym for `SHA1()`.

### 13.8.3 Information Functions

MySQL Inline-Help Reference - SQL Functions
`BENCHMARK(count,expr)`

`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 from within 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.

MySQL Inline-Help Reference - SQL Functions
`CHARSET(str)`

`CHARSET(str)`
Returns the character set of the string argument.

    mysql> SELECT CHARSET(_utf8'abc');
            -> 'utf8'

`CHARSET()` was added in MySQL 4.1.0.

MySQL Inline-Help Reference - SQL Functions
`COERCIBILITY(str)`

`COERCIBILITY(str)`
Returns the collation coercibility value of the string argument.

    mysql> SELECT COERCIBILITY('abc' COLLATE latin1_swedish_ci);
            -> 0
    mysql> SELECT COERCIBILITY('abc');
            -> 3
    mysql> SELECT COERCIBILITY(USER());
            -> 2

The return values have the following meanings:

Coercibility | Meaning
`0` | Explicit collation
`1` | No collation
`2` | Implicit collation
`3` | Coercible

Lower values have higher precedence. `COERCIBILITY()` was added in MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`COLLATION(str)`

`COLLATION(str)`
Returns the collation for the character set of the string argument.

    mysql> SELECT COLLATION('abc');
            -> 'latin1_swedish_ci'
    mysql> SELECT COLLATION(_utf8'abc');
            -> 'utf8_general_ci'

`COLLATION()` was added in MySQL 4.1.0.

MySQL Inline-Help Reference - SQL Functions
`CONNECTION_ID()`

`CONNECTION_ID()`
Returns the connection ID (thread ID) for the connection. Every connection has its own unique ID.

    mysql> SELECT CONNECTION_ID();
            -> 23786

MySQL Inline-Help Reference - SQL Functions
`CURRENT_USER()`

`CURRENT_USER()`
Returns the username and hostname combination 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`.

MySQL Inline-Help Reference - SQL Functions
`DATABASE()`

`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.

MySQL Inline-Help Reference - SQL Functions
`FOUND_ROWS()`

`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 must 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 4.0.0.

MySQL Inline-Help Reference - SQL Functions
`LAST_INSERT_ID()`

`LAST_INSERT_ID()`
`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 behavior 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:
  - Create a table to hold the sequence counter and initialize it:

        mysql> CREATE TABLE sequence (id INT NOT NULL);
        mysql> INSERT INTO sequence VALUES (0);

  - Use the table to generate sequence numbers like this:

        mysql> UPDATE sequence SET id=LAST_INSERT_ID(id+1);
        mysql> SELECT LAST_INSERT_ID();

    The `UPDATE` statement increments the sequence counter and causes the next call to `LAST_INSERT_ID()` to return the updated value. The `SELECT` statement retrieves that value. The C API function `mysql_insert_id()` can also be used to get the value. See section 20.2.3.32 `mysql_insert_id()`.
  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. It is multi-user safe because multiple clients can issue the `UPDATE` statement and get their own sequence value with the `SELECT` statement (or `mysql_insert_id()`), without affecting or being affected by other clients that generate their own sequence values. Note that `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`.

MySQL Inline-Help Reference - SQL Functions
`SESSION_USER()`

`SESSION_USER()`
  `SESSION_USER()` is a synonym for `USER()`.

MySQL Inline-Help Reference - SQL Functions
`SYSTEM_USER()`

`SYSTEM_USER()`
  `SYSTEM_USER()` is a synonym for `USER()`.

MySQL Inline-Help Reference - SQL Functions
`USER()`

`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. The value may be different than that of `CURRENT_USER()`. Prior to MySQL 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(),_utf8'@',1);
              -> 'davida'

  Before MySQL 4.1, it is not necessary to convert the character set of the literal string, so leave out the `_utf8`:

      mysql> SELECT SUBSTRING_INDEX(USER(),'@',1);
              -> 'davida'

MySQL Inline-Help Reference - SQL Functions
`VERSION()`

`VERSION()`
  Returns a string that indicates the MySQL server version.

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

  Note that if your version string ends with `-log` this means that logging is enabled.

### 13.8.4 Miscellaneous Functions

MySQL Inline-Help Reference - SQL Functions
`FORMAT(X,D)`

`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'

MySQL Inline-Help Reference - SQL Functions
`GET_LOCK(str,timeout)`

`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`). If you have a lock obtained with `GET_LOCK()`, it is released when you execute `RELEASE_LOCK()`, execute a new `GET_LOCK()`, or your connection 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.

MySQL Inline-Help Reference - SQL Functions
`INET_ATON(expr)`

`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; in the example just shown, the number is calculated as `209*256^3 + 207*256^2 + 224*256 + 40`. As of MySQL 4.1.2, `INET_ATON()` also understands short-form IP addresses:

    mysql> SELECT INET_ATON('127.0.0.1'), INET_ATON('127.1');
            -> 2130706433, 2130706433

`INET_ATON()` was added in MySQL 3.23.15.

MySQL Inline-Help Reference - SQL Functions
`INET_NTOA(expr)`

`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_NTOA()` was added in MySQL 3.23.15.

MySQL Inline-Help Reference - SQL Functions
`IS_FREE_LOCK(str)`

`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). `IS_FREE_LOCK()` was added in MySQL 4.0.2.

MySQL Inline-Help Reference - SQL Functions
`IS_USED_LOCK(str)`

`IS_USED_LOCK(str)`
Checks if the lock named `str` is in use (that is, locked). If so, it returns the connection identifier of the client that holds the lock. Otherwise, it returns `NULL`. `IS_USED_LOCK()` was added in MySQL 4.1.0.

MySQL Inline-Help Reference - SQL Functions
`MASTER_POS_WAIT(log_name, log_pos [, timeout])`

`MASTER_POS_WAIT(log_name, log_pos [, timeout])`
This function is useful for control of master/slave synchronization. It blocks until the slave has read and applied all updates up to the specified position in the master log. The return value is the number of log events it had to wait for to get to the specified position. The function returns `NULL` if the slave's master information is not initialized, the arguments are incorrect, or an error occurs. It returns `-1` if the timeout has been exceeded. If the slave thread is not running, this function will block and wait until the slave is started and goes to or past the specified position. If the slave is already past the specified position, the function returns immediately. @c end_description_for_help_topic If `timeout` (new in 4.0.10) is specified, `MASTER_POS_WAIT()` stops waiting when `timeout` seconds have elapsed. `timeout` must be greater than 0; a zero or negative `timeout` means no timeout.

MySQL Inline-Help Reference - SQL Functions
`RELEASE_LOCK(str)`

`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 convenient to use with `RELEASE_LOCK()`. See section 14.1.2 `DO` Syntax.

MySQL Inline-Help Reference - SQL Functions
`UUID()`

`UUID()`
Returns a Universal Unique Identifier (UUID) generated according to ``DCE 1.1: Remote Procedure Call'' (Appendix A) CAE (Common Applications Environment) Specifications published by the Open Group in October 1997 (Document Number C706). A UUID is designed as a number that is unique globally in space and time. Two calls to `UUID()` are expected to generate two different values, even if these calls were performed on two separate computers that are not connected to each other. A UUID is a 128-bit number represented by a string of 5 hexadecimal numbers in `aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee` format:

- The first three numbers are generated from a timestamp.
- The fourth number preserves temporal uniqueness in case the timestamp value loses monotonicity (for example, due to daylight savings time).
- The fifth number is an IEEE 802 node number that provides spatial uniqueness. A random number is substituted if the latter is not available (for example, because the host computer has no Ethernet card, or we do not know how to find the hardware address of an interface on your operating system). In this case, spatial uniqueness cannot be guaranteed. Nevertheless, a collision should have very low probability. Currently, the MAC address of an interface is taken into account only on FreeBSD and Linux. On other operating systems, MySQL uses a randomly generated 48-bit number.

    mysql> SELECT UUID();
            -> '6ccd780c-baba-1026-9564-0040f4311e29'

Note that `UUID()` does not work with replication yet. `UUID()` was added in MySQL 4.1.2.

## 13.9 Functions and Modifiers for Use with `GROUP BY` Clauses

### 13.9.1 `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.

MySQL Inline-Help Reference - SQL Functions
`AVG(expr)`

`AVG(expr)`
Returns the average value of `expr`.

    mysql> SELECT student_name, AVG(test_score)
        ->        FROM student
        ->        GROUP BY student_name;

MySQL Inline-Help Reference - SQL Functions
`BIT_AND(expr)`

`BIT_AND(expr)`
Returns the bitwise `AND` of all bits in `expr`. The calculation is performed with 64-bit (`BIGINT`) precision. As of MySQL 4.0.17, this function returns `18446744073709551615` if there were no matching rows. (This is an unsigned `BIGINT` value with all bits set to 1.) Before 4.0.17, the function returns `-1` if there were no matching rows.

MySQL Inline-Help Reference - SQL Functions
`BIT_OR(expr)`

`BIT_OR(expr)`
Returns the bitwise `OR` of all bits in `expr`. The calculation is performed with 64-bit (`BIGINT`) precision. This function returns `0` if there were no matching rows.

MySQL Inline-Help Reference - SQL Functions
`BIT_XOR(expr)`

`BIT_XOR(expr)`
Returns the bitwise `XOR` of all bits in `expr`. The calculation is performed with 64-bit (`BIGINT`) precision. This function returns `0` if there were no matching rows. This function is available as of MySQL 4.1.1.

MySQL Inline-Help Reference - SQL Functions
`COUNT(expr)`

`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 optimized 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 optimization 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.

MySQL Inline-Help Reference - SQL Functions
`COUNT(DISTINCT expr,[expr...])`

`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 ...)`. `COUNT(DISTINCT ...)` was added in MySQL 3.23.2.

MySQL Inline-Help Reference - SQL Functions
`GROUP_CONCAT(expr)`

`GROUP_CONCAT(expr)`
This function returns a string result with the concatenated values from a group. The full syntax is as follows:

    GROUP_CONCAT([DISTINCT] expr [,expr ...]
                 [ORDER BY {unsigned_integer | col_name | formula}
                     [ASC | DESC] [,col ...]]
                 [SEPARATOR str_val])

`GROUP_CONCAT()` was added in MySQL 4.1.

    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 followed by the string value that 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 `group_concat_max_len` system variable. The syntax to do this at runtime is as follows, where `val` is an unsigned integer:

    SET [SESSION | GLOBAL] group_concat_max_len = val;

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.

MySQL Inline-Help Reference - SQL Functions
`MIN(expr)`

`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 7.4.5 How MySQL Uses Indexes.

      mysql> SELECT student_name, MIN(test_score), MAX(test_score)
          ->        FROM student
          ->        GROUP BY student_name;

  For `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.

MySQL Inline-Help Reference - SQL Functions
`STD(expr)`

`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.

MySQL Inline-Help Reference - SQL Functions
`SUM(expr)`

`SUM(expr)`
  Returns the sum of `expr`. Note that if the return set has no rows, it returns `NULL`!

MySQL Inline-Help Reference - SQL Functions
`VARIANCE(expr)`

`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 MySQL 4.1 or later.

### 13.9.2 `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:

- Following each set of product rows for a given year and country, an extra summary row is produced showing the total for all products. These rows have the `product` column set to `NULL`.
- 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`.
- Finally, following all other rows, an extra summary row is produced showing the grand total for all years, countries, and products. This row has the `year`, `country`, and `products` columns set to `NULL`.

Other Considerations When using `ROLLUP`

The following items list some behaviors 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 |
    +------+---------+------------+-------------+

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.

### 13.9.3 `GROUP BY` with Hidden Fields

MySQL extends the use of `GROUP BY` so that you can use columns or calculations in the `SELECT` list that don't appear in the `GROUP BY` clause. 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.

Do not use this feature if the columns you omit from the `GROUP BY` part are not 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 3.6.4 The Rows Holding the Group-wise Maximum of a Certain Field.

Note that if you are using MySQL 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 3.23 and up, aliases are unnecessary. You can use expressions in `GROUP BY` and `ORDER BY` clauses. For example:

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