| Table 12.7. String Operators | Name | Description |
|---|
| ASCII() | Return numeric value of left-most character | | BIN() | Return a string containing binary representation of a number | | BIT_LENGTH() | Return length of argument in bits | | CHAR_LENGTH() | Return number of characters in argument | | CHAR() | Return the character for each integer passed | | CHARACTER_LENGTH() | A synonym for CHAR_LENGTH() | | CONCAT_WS() | Return concatenate with separator | | CONCAT() | Return concatenated string | | ELT() | Return string at index number | | EXPORT_SET() | Return a string such that for every bit set in the value bits, you get an on string and for every unset bit, you get an off string | | FIELD() | Return the index (position) of the first argument in the subsequent arguments | | FIND_IN_SET() | Return the index position of the first argument within the second argument | | FORMAT() | Return a number formatted to specified number of decimal places | | HEX() | Return a hexadecimal representation of a decimal or string value | | INSERT() | Insert a substring at the specified position up to the specified number of characters | | INSTR() | Return the index of the first occurrence of substring | | LCASE() | Synonym for LOWER() | | LEFT() | Return the leftmost number of characters as specified | | LENGTH() | Return the length of a string in bytes | | LIKE | Simple pattern matching | | LOAD_FILE() | Load the named file | | LOCATE() | Return the position of the first occurrence of substring | | LOWER() | Return the argument in lowercase | | LPAD() | Return the string argument, left-padded with the specified string | | LTRIM() | Remove leading spaces | | MAKE_SET() | Return a set of comma-separated strings that have the corresponding bit in bits set | | MATCH | Perform full-text search | | MID() | Return a substring starting from the specified position | | NOT LIKE | Negation of simple pattern matching | | NOT REGEXP | Negation of REGEXP | | OCT() | Return a string containing octal representation of a number | | OCTET_LENGTH() | A synonym for LENGTH() | | ORD() | Return character code for leftmost character of the argument | | POSITION() | A synonym for LOCATE() | | QUOTE() | Escape the argument for use in an SQL statement | | REGEXP | Pattern matching using regular expressions | | REPEAT() | Repeat a string the specified number of times | | REPLACE() | Replace occurrences of a specified string | | REVERSE() | Reverse the characters in a string | | RIGHT() | Return the specified rightmost number of characters | | RLIKE | Synonym for REGEXP | | RPAD() | Append string the specified number of times | | RTRIM() | Remove trailing spaces | | SOUNDEX() | Return a soundex string | | SOUNDS LIKE | Compare sounds | | SPACE() | Return a string of the specified number of spaces | | STRCMP() | Compare two strings | | SUBSTR() | Return the substring as specified | | SUBSTRING_INDEX() | Return a substring from a string before the specified number of occurrences of the delimiter | | SUBSTRING() | Return the substring as specified | | TRIM() | Remove leading and trailing spaces | | UCASE() | Synonym for UPPER() | | UNHEX() | Return a string containing hex representation of a number | | UPPER() | Convert to uppercase |
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 8.11.2, "Tuning Server Parameters". For functions that operate on string positions, the first position is numbered 1. For functions that take length arguments, noninteger arguments are rounded to the nearest integer. 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 8-bit characters. mysql> SELECT ASCII('2'); -> 50mysql> SELECT ASCII(2); -> 50mysql> SELECT ASCII('dx'); -> 100 See also the ORD() function. 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' BIT_LENGTH(str) Returns the length of the string str in bits. mysql> SELECT BIT_LENGTH('text'); -> 32 CHAR(N,... [USING charset_name]) CHAR() interprets each argument N as an integer 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' CHAR() arguments larger than 255 are converted into multiple result bytes. For example, CHAR(256) is equivalent to CHAR(1,0), and CHAR(256*256) is equivalent to CHAR(1,0,0): mysql> SELECT HEX(CHAR(1,0)), HEX(CHAR(256));+----------------+----------------+| HEX(CHAR(1,0)) | HEX(CHAR(256)) |+----------------+----------------+| 0100 | 0100 |+----------------+----------------+mysql> SELECT HEX(CHAR(1,0,0)), HEX(CHAR(256*256));+------------------+--------------------+| HEX(CHAR(1,0,0)) | HEX(CHAR(256*256)) |+------------------+--------------------+| 010000 | 010000 |+------------------+--------------------+ By default, CHAR() returns a binary string. To produce a string in a given character set, use the optional USING clause: mysql> SELECT CHARSET(CHAR(0x65)), CHARSET(CHAR(0x65 USING utf8));+---------------------+--------------------------------+| CHARSET(CHAR(0x65)) | CHARSET(CHAR(0x65 USING utf8)) |+---------------------+--------------------------------+| binary | utf8 |+---------------------+--------------------------------+ If USING is given and the result string is illegal for the given character set, a warning is issued. Also, if strict SQL mode is enabled, the result from CHAR() becomes NULL. 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 2-byte characters, LENGTH() returns 10, whereas CHAR_LENGTH() returns 5. CHARACTER_LENGTH(str) CHARACTER_LENGTH() is a synonym for CHAR_LENGTH(). CONCAT(str1,str2,...) Returns the string that results from concatenating the arguments. May have one or more arguments. If all arguments are nonbinary strings, the result is a nonbinary string. If the arguments include any binary strings, the result is a binary string. A numeric argument is converted to its equivalent string form. This is a nonbinary string as of MySQL 5.5.3. Before 5.5.3, it is a binary string; to to avoid that and produce a nonbinary string, you can use an explicit type cast, as in this example: SELECT CONCAT(CAST(int_col AS CHAR), char_col); CONCAT() returns NULL if any argument is NULL. mysql> SELECT CONCAT('My', 'S', 'QL'); -> 'MySQL'mysql> SELECT CONCAT('My', NULL, 'QL'); -> NULLmysql> SELECT CONCAT(14.3); -> '14.3' For quoted strings, concatenation can be performed by placing the strings next to each other: mysql> SELECT 'My' 'S' 'QL'; -> 'MySQL' CONCAT_WS(separator,str1,str2,...) CONCAT_WS() stands for Concatenate 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. 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' CONCAT_WS() does not skip empty strings. However, it does skip any NULL values after the separator argument. 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' EXPORT_SET(bits,on,off[,separator[,number_of_bits]]) Returns a string such that for every bit set in the value bits, you get an on string and for every bit not set in the value, you get an off string. Bits in bits are examined from right to left (from low-order to high-order bits). Strings are added to the result from left to right, separated by the separator string (the default being the comma character ","). The number of bits examined is given by number_of_bits, which has a default of 64 if not specified. number_of_bits is silently clipped to 64 if larger than 64. It is treated as an unsigned integer, so a value of �1 is effectively the same as 64. mysql> SELECT EXPORT_SET(5,'Y','N',',',4); -> 'Y,N,Y,N'mysql> SELECT EXPORT_SET(6,'1','0',',',10); -> '0,1,1,0,0,0,0,0,0,0' FIELD(str,str1,str2,str3,...) Returns the index (position) of str in the str1, str2, str3, ... list. Returns 0 if str is not found. If all arguments to FIELD() are strings, all arguments are compared as strings. If all arguments are numbers, they are compared as numbers. Otherwise, the arguments are compared as double. If str is NULL, the return value is 0 because NULL fails equality comparison with any value. FIELD() is the complement of ELT(). mysql> SELECT FIELD('ej', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 2mysql> SELECT FIELD('fo', 'Hej', 'ej', 'Heja', 'hej', 'foo'); -> 0 FIND_IN_SET(str,strlist) Returns a value in the range of 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 does not work properly if the first argument contains a comma (",") character. mysql> SELECT FIND_IN_SET('b','a,b,c,d'); -> 2 FORMAT(X,D[,locale]) Formats the number X to a format like '#,###,###.##', rounded to D decimal places, and returns the result as a string. If D is 0, the result has no decimal point or fractional part. The optional third parameter enables a locale to be specified to be used for the result number's decimal point, thousands separator, and grouping between separators. Permissible locale values are the same as the legal values for the lc_time_names system variable (see Section 10.7, "MySQL Server Locale Support"). If no locale is specified, the default is 'en_US'. 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> SELECT FORMAT(12332.2,2,'de_DE'); -> '12.332,20' HEX(str), HEX(N) For a string argument str, HEX() returns a hexadecimal string representation of str where each character in str is converted to two hexadecimal digits. The inverse of this operation is performed by the UNHEX() function. For a numeric argument N, HEX() returns a hexadecimal string representation of the value of N treated as a longlong (BIGINT) number. This is equivalent to CONV(N,10,16). The inverse of this operation is performed by CONV(HEX(N),16,10). mysql> SELECT 0x616263, HEX('abc'), UNHEX(HEX('abc')); -> 'abc', 616263, 'abc'mysql> SELECT HEX(255), CONV(HEX(255),16,10); -> 'FF', 255 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. Returns the original string if pos is not within the length of the string. Replaces the rest of the string from position pos if len is not within the length of the rest of the string. Returns NULL if any argument is NULL. mysql> SELECT INSERT('Quadratic', 3, 4, 'What'); -> 'QuWhattic'mysql> SELECT INSERT('Quadratic', -1, 4, 'What'); -> 'Quadratic'mysql> SELECT INSERT('Quadratic', 3, 100, 'What'); -> 'QuWhat' This function is multi-byte safe. 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 order of the arguments is reversed. mysql> SELECT INSTR('foobarbar', 'bar'); -> 4mysql> SELECT INSTR('xbar', 'foobar'); -> 0 This function is multi-byte safe, and is case sensitive only if at least one argument is a binary string. LCASE(str) LCASE() is a synonym for LOWER(). LEFT(str,len) Returns the leftmost len characters from the string str, or NULL if any argument is NULL. mysql> SELECT LEFT('foobarbar', 5); -> 'fooba' This function is multi-byte safe. 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 2-byte characters, LENGTH() returns 10, whereas CHAR_LENGTH() returns 5. mysql> SELECT LENGTH('text'); -> 4 LOAD_FILE(file_name) Reads the file and returns the file contents as a string. To use this function, the file must be located on the server host, you must specify the full path name to the file, and you must have the FILE privilege. The file must be readable by all and its size less than max_allowed_packet bytes. If the secure_file_priv system variable is set to a nonempty directory name, the file to be loaded must be located in that directory. If the file does not exist or cannot be read because one of the preceding conditions is not satisfied, the function returns NULL. The character_set_filesystem system variable controls interpretation of file names that are given as literal strings. mysql> UPDATE t SET blob_col=LOAD_FILE('/tmp/picture') WHERE id=1; 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'); -> 4mysql> SELECT LOCATE('xbar', 'foobar'); -> 0mysql> SELECT LOCATE('bar', 'foobarbar', 5); -> 7 This function is multi-byte safe, and is case-sensitive only if at least one argument is a binary string. LOWER(str) Returns the string str with all characters changed to lowercase according to the current character set mapping. The default is latin1 (cp1252 West European). mysql> SELECT LOWER('QUADRATICALLY'); -> 'quadratically' LOWER() (and UPPER()) are ineffective when applied to binary strings (BINARY, VARBINARY, BLOB). To perform lettercase conversion, convert the string to a nonbinary string: mysql> SET @str = BINARY 'New York';mysql> SELECT LOWER(@str), LOWER(CONVERT(@str USING latin1));+-------------+-----------------------------------+| LOWER(@str) | LOWER(CONVERT(@str USING latin1)) |+-------------+-----------------------------------+| New York | new york |+-------------+-----------------------------------+ This function is multi-byte safe. 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' LTRIM(str) Returns the string str with leading space characters removed. mysql> SELECT LTRIM(' barbar'); -> 'barbar' This function is multi-byte safe. 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 values 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'); -> '' MID(str,pos,len) MID(str,pos,len) is a synonym for SUBSTRING(str,pos,len). OCT(N) Returns a string representation of the octal value of N, where N is a longlong (BIGINT) number. This is equivalent to CONV(N,10,8). Returns NULL if N is NULL. mysql> SELECT OCT(12); -> '14' OCTET_LENGTH(str) OCTET_LENGTH() is a synonym for LENGTH(). 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)+ (2nd byte code * 256)+ (3rd byte code * 2562) ... If the leftmost character is not a multi-byte character, ORD() returns the same value as the ASCII() function. mysql> SELECT ORD('2'); -> 50 POSITION(substr IN str) POSITION(substr IN str) is a synonym for LOCATE(substr,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 enclosed by single quotation marks and with each instance of backslash ("\"), single quote ("'"), ASCII NUL, and Control+Z preceded by a backslash. If the argument is NULL, the return value is the word "NULL" without enclosing single quotation marks. mysql> SELECT QUOTE('Don\'t!'); -> 'Don\'t!'mysql> SELECT QUOTE(NULL); -> NULL For comparison, see the quoting rules for literal strings and within the C API in Section 9.1.1, "String Literals", and Section 22.8.3.53, "mysql_real_escape_string()". REPEAT(str,count) Returns a string consisting of the string str repeated count times. If count is less than 1, returns an empty string. Returns NULL if str or count are NULL. mysql> SELECT REPEAT('MySQL', 3); -> 'MySQLMySQLMySQL' REPLACE(str,from_str,to_str) Returns the string str with all occurrences of the string from_str replaced by the string to_str. REPLACE() performs a case-sensitive match when searching for from_str. mysql> SELECT REPLACE('www.mysql.com', 'w', 'Ww'); -> 'WwWwWw.mysql.com' This function is multi-byte safe. REVERSE(str) Returns the string str with the order of the characters reversed. mysql> SELECT REVERSE('abc'); -> 'cba' This function is multi-byte safe. RIGHT(str,len) Returns the rightmost len characters from the string str, or NULL if any argument is NULL. mysql> SELECT RIGHT('foobarbar', 4); -> 'rbar' This function is multi-byte safe. 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. RTRIM(str) Returns the string str with trailing space characters removed. mysql> SELECT RTRIM('barbar '); -> 'barbar' This function is multi-byte safe. SOUNDEX(str) Returns a soundex string from str. Two strings that sound almost the same should have identical soundex strings. A standard soundex string is four 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 nonalphabetic characters in str are ignored. All international alphabetic characters outside the A-Z range are treated as vowels. Important When using SOUNDEX(), you should be aware of the following limitations: This function, as currently implemented, is intended to work well with strings that are in the English language only. Strings in other languages may not produce reliable results. This function is not guaranteed to provide consistent results with strings that use multi-byte character sets, including utf-8. We hope to remove these limitations in a future release. See Bug #22638 for more information.
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 duplicates second, whereas the enhanced version discards duplicates first and vowels second. expr1 SOUNDS LIKE expr2 This is the same as SOUNDEX(expr1) = SOUNDEX(expr2). SPACE(N) Returns a string consisting of N space characters. mysql> SELECT SPACE(6); -> ' ' SUBSTR(str,pos), SUBSTR(str FROM pos), SUBSTR(str,pos,len), SUBSTR(str FROM pos FOR len) SUBSTR() is a synonym for SUBSTRING(). 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 standard SQL syntax. It is also possible to use a negative value for pos. In this case, the beginning of the substring is pos characters from the end of the string, rather than the beginning. A negative value may be used for pos in any of the forms of this function. For all forms of SUBSTRING(), the position of the first character in the string from which the substring is to be extracted is reckoned as 1. mysql> SELECT SUBSTRING('Quadratically',5); -> 'ratically'mysql> SELECT SUBSTRING('foobarbar' FROM 4); -> 'barbar'mysql> SELECT SUBSTRING('Quadratically',5,6); -> 'ratica'mysql> SELECT SUBSTRING('Sakila', -3); -> 'ila'mysql> SELECT SUBSTRING('Sakila', -5, 3); -> 'aki'mysql> SELECT SUBSTRING('Sakila' FROM -4 FOR 2); -> 'ki' This function is multi-byte safe. If len is less than 1, the result is the empty string. 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. SUBSTRING_INDEX() performs a case-sensitive match when searching for delim. 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. TRIM([{BOTH | LEADING | TRAILING} [remstr] FROM] str), TRIM([remstr FROM] str) Returns the string str with all remstr prefixes or suffixes removed. If none of the specifiers BOTH, LEADING, or TRAILING is given, BOTH is assumed. remstr is optional and, if 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. UCASE(str) UCASE() is a synonym for UPPER(). UNHEX(str) For a string argument str, UNHEX(str) performs the inverse operation of HEX(str). That is, it interprets each pair of characters in the argument as a hexadecimal number and converts it to the character represented by the number. The return value is a binary string. mysql> SELECT UNHEX('4D7953514C'); -> 'MySQL'mysql> SELECT 0x4D7953514C; -> 'MySQL'mysql> SELECT UNHEX(HEX('string')); -> 'string'mysql> SELECT HEX(UNHEX('1267')); -> '1267' The characters in the argument string must be legal hexadecimal digits: '0' .. '9', 'A' .. 'F', 'a' .. 'f'. If the argument contains any nonhexadecimal digits, the result is NULL: mysql> SELECT UNHEX('GG');+-------------+| UNHEX('GG') |+-------------+| NULL |+-------------+ A NULL result can occur if the argument to UNHEX() is a BINARY column, because values are padded with 0x00 bytes when stored but those bytes are not stripped on retrieval. For example, '41' is stored into a CHAR(3) column as '41 ' and retrieved as '41' (with the trailing pad space stripped), so UNHEX() for the column value returns 'A'. By contrast '41' is stored into a BINARY(3) column as '41\0' and retrieved as '41\0' (with the trailing pad 0x00 byte not stripped). '\0' is not a legal hexadecimal digit, so UNHEX() for the column value returns NULL. For a numeric argument N, the inverse of HEX(N) is not performed by UNHEX(). Use CONV(HEX(N),16,10) instead. See the description of HEX(). UPPER(str) Returns the string str with all characters changed to uppercase according to the current character set mapping. The default is latin1 (cp1252 West European). mysql> SELECT UPPER('Hej'); -> 'HEJ' See the description of LOWER() for information that also applies to UPPER(), such as information about how to perform lettercase conversion of binary strings (BINARY, VARBINARY, BLOB) for which these functions are ineffective. This function is multi-byte safe.
12.5.1. String Comparison FunctionsTable 12.8. String Comparison Operators | Name | Description |
|---|
| LIKE | Simple pattern matching | | NOT LIKE | Negation of simple pattern matching | | STRCMP() | Compare two strings |
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 affects only comparisons. Normally, if any expression in a string comparison is case sensitive, the comparison is performed in case-sensitive fashion. expr LIKE pat [ESCAPE 'escape_char'] Pattern matching using SQL simple regular expression comparison. Returns 1 (TRUE) or 0 (FALSE). If either expr or pat is NULL, the result is NULL. The pattern need not be a literal string. For example, it can be specified as a string expression or table column. Per the SQL standard, LIKE performs matching on a per-character basis, thus it can produce results different from the = comparison operator: mysql> SELECT '�' LIKE 'ae' COLLATE latin1_german2_ci;+-----------------------------------------+| '�' LIKE 'ae' COLLATE latin1_german2_ci |+-----------------------------------------+| 0 |+-----------------------------------------+mysql> SELECT '�' = 'ae' COLLATE latin1_german2_ci;+--------------------------------------+| '�' = 'ae' COLLATE latin1_german2_ci |+--------------------------------------+| 1 |+--------------------------------------+ In particular, trailing spaces are significant, which is not true for CHAR or VARCHAR comparisons performed with the = operator: mysql> SELECT 'a' = 'a ', 'a' LIKE 'a ';+------------+---------------+| 'a' = 'a ' | 'a' LIKE 'a ' |+------------+---------------+| 1 | 0 |+------------+---------------+1 row in set (0.00 sec) With LIKE you can use the following two wildcard characters in the pattern. mysql> SELECT 'David!' LIKE 'David_'; -> 1mysql> SELECT 'David!' LIKE '%D%v%'; -> 1 To test for literal instances of a wildcard character, precede it by the escape character. If you do not specify the ESCAPE character, "\" is assumed. mysql> SELECT 'David!' LIKE 'David\_'; -> 0mysql> SELECT 'David_' LIKE 'David\_'; -> 1 To specify a different escape character, use the ESCAPE clause: mysql> SELECT 'David_' LIKE 'David|_' ESCAPE '|'; -> 1 The escape sequence should be empty or one character long. The expression must evaluate as a constant at execution time. If the NO_BACKSLASH_ESCAPES SQL mode is enabled, the sequence cannot be empty. 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'; -> 1mysql> SELECT 'abc' LIKE BINARY 'ABC'; -> 0 In MySQL, LIKE is permitted on numeric expressions. (This is an extension to the standard SQL LIKE.) mysql> SELECT 10 LIKE '1%'; -> 1 Note Because MySQL uses C escape syntax in strings (for example, "\n" to represent a newline character), you must double any "\" that you use in LIKE strings. For example, to search for "\n", specify it as "\\n". To search for "\", specify it as "\\\\"; this is because the backslashes are stripped once by the parser and again when the pattern match is made, leaving a single backslash to be matched against. Exception: At the end of the pattern string, backslash can be specified as "\\". At the end of the string, backslash stands for itself because there is nothing following to escape. Suppose that a table contains the following values: mysql> SELECT filename FROM t1;+--------------+| filename |+--------------+| C: | | C:\ | | C:\Programs | | C:\Programs\ | +--------------+ To test for values that end with backslash, you can match the values using either of the following patterns: mysql> SELECT filename, filename LIKE '%\\' FROM t1;+--------------+---------------------+| filename | filename LIKE '%\\' |+--------------+---------------------+| C: | 0 | | C:\ | 1 | | C:\Programs | 0 | | C:\Programs\ | 1 | +--------------+---------------------+mysql> SELECT filename, filename LIKE '%\\\\' FROM t1;+--------------+-----------------------+| filename | filename LIKE '%\\\\' |+--------------+-----------------------+| C: | 0 | | C:\ | 1 | | C:\Programs | 0 | | C:\Programs\ | 1 | +--------------+-----------------------+ expr NOT LIKE pat [ESCAPE 'escape_char'] This is the same as NOT (expr LIKE pat [ESCAPE 'escape_char']). Note Aggregate queries involving NOT LIKE comparisons with columns containing NULL may yield unexpected results. For example, consider the following table and data: CREATE TABLE foo (bar VARCHAR(10));INSERT INTO foo VALUES (NULL), (NULL); The query SELECT COUNT(*) FROM foo WHERE bar LIKE '%baz%'; returns 0. You might assume that SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%'; would return 2. However, this is not the case: The second query returns 0. This is because NULL NOT LIKE expr always returns NULL, regardless of the value of expr. The same is true for aggregate queries involving NULL and comparisons using NOT RLIKE or NOT REGEXP. In such cases, you must test explicitly for NOT NULL using OR (and not AND), as shown here: SELECT COUNT(*) FROM foo WHERE bar NOT LIKE '%baz%' OR bar IS NULL; 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'); -> -1mysql> SELECT STRCMP('text2', 'text'); -> 1mysql> SELECT STRCMP('text', 'text'); -> 0 STRCMP() performs the comparison using the collation of the arguments. mysql> SET @s1 = _latin1 'x' COLLATE latin1_general_ci;mysql> SET @s2 = _latin1 'X' COLLATE latin1_general_ci;mysql> SET @s3 = _latin1 'x' COLLATE latin1_general_cs;mysql> SET @s4 = _latin1 'X' COLLATE latin1_general_cs;mysql> SELECT STRCMP(@s1, @s2), STRCMP(@s3, @s4);+------------------+------------------+| STRCMP(@s1, @s2) | STRCMP(@s3, @s4) |+------------------+------------------+| 0 | 1 |+------------------+------------------+ If the collations are incompatible, one of the arguments must be converted to be compatible with the other. See Section 10.1.7.5, "Collation of Expressions". mysql> SELECT STRCMP(@s1, @s3);ERROR 1267 (HY000) at line 10: Illegal mix of collations (latin1_general_ci,IMPLICIT) and (latin1_general_cs,IMPLICIT)for operation 'strcmp'mysql> SELECT STRCMP(@s1, @s3 COLLATE latin1_general_ci);+--------------------------------------------+| STRCMP(@s1, @s3 COLLATE latin1_general_ci) |+--------------------------------------------+| 0 |+--------------------------------------------+
12.5.2. Regular ExpressionsTable 12.9. String Regular Expression Operators | Name | Description |
|---|
| NOT REGEXP | Negation of REGEXP | | REGEXP | Pattern matching using regular expressions | | RLIKE | Synonym for REGEXP |
A regular expression is a powerful way of specifying a pattern for a complex search. MySQL uses Henry Spencer's implementation of regular expressions, which is aimed at conformance with POSIX 1003.2. MySQL uses the extended version to support pattern-matching operations performed with the REGEXP operator in SQL statements. This section summarizes, with examples, the special characters and constructs that can be used in MySQL for REGEXP operations. It does not contain all the details that can be found in Henry Spencer's regex(7) manual page. That manual page is included in MySQL source distributions, in the regex.7 file under the regex directory. See also Section 3.3.4.7, "Pattern Matching". expr NOT REGEXP pat, expr NOT RLIKE pat This is the same as NOT (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 12.5.2, "Regular Expressions". Returns 1 if expr matches pat; otherwise it returns 0. If either expr or pat is NULL, the result is NULL. RLIKE is a synonym for REGEXP, provided for mSQL compatibility. The pattern need not be a literal string. For example, it can be specified as a string expression or table column. Note Because MySQL uses the C escape syntax in strings (for example, "\n" to represent the newline character), you must double any "\" that you use in your REGEXP strings. REGEXP is not case sensitive, except when used with binary strings. mysql> SELECT 'Monty!' REGEXP '.*'; -> 1mysql> SELECT 'new*\n*line' REGEXP 'new\\*.\\*line'; -> 1mysql> SELECT 'a' REGEXP 'A', 'a' REGEXP BINARY 'A'; -> 1 0mysql> SELECT 'a' REGEXP '^[a-d]'; -> 1 REGEXP and RLIKE use the character set and collations of the arguments when deciding the type of a character and performing the comparison. If the arguments have different character sets or collations, coercibility rules apply as described in Section 10.1.7.5, "Collation of Expressions". Warning The REGEXP and RLIKE operators work in byte-wise fashion, so they are not multi-byte safe and may produce unexpected results with multi-byte character sets. In addition, these operators compare characters by their byte values and accented characters may not compare as equal even if a given collation treats them as equal.
A regular expression describes a set of strings. The simplest regular expression is one that has no special characters in it. For example, the regular expression hello matches hello and nothing else. Nontrivial regular expressions use certain special constructs so that they can match more than one string. For example, the regular expression hello|word matches either the string hello or the string word. As a more complex example, the regular expression B[an]*s matches any of the strings Bananas, Baaaaas, Bs, and any other string starting with a B, ending with an s, and containing any number of a or n characters in between. A regular expression for the REGEXP operator may use any of the following special characters and constructs: ^ Match the beginning of a string. mysql> SELECT 'fo\nfo' REGEXP '^fo$'; -> 0mysql> SELECT 'fofo' REGEXP '^fo'; -> 1 $ Match the end of a string. mysql> SELECT 'fo\no' REGEXP '^fo\no$'; -> 1mysql> SELECT 'fo\no' REGEXP '^fo$'; -> 0 . Match any character (including carriage return and newline). mysql> SELECT 'fofo' REGEXP '^f.*$'; -> 1mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$'; -> 1 a* Match any sequence of zero or more a characters. mysql> SELECT 'Ban' REGEXP '^Ba*n'; -> 1mysql> SELECT 'Baaan' REGEXP '^Ba*n'; -> 1mysql> SELECT 'Bn' REGEXP '^Ba*n'; -> 1 a+ Match any sequence of one or more a characters. mysql> SELECT 'Ban' REGEXP '^Ba+n'; -> 1mysql> SELECT 'Bn' REGEXP '^Ba+n'; -> 0 a? Match either zero or one a character. mysql> SELECT 'Bn' REGEXP '^Ba?n'; -> 1mysql> SELECT 'Ban' REGEXP '^Ba?n'; -> 1mysql> SELECT 'Baan' REGEXP '^Ba?n'; -> 0 de|abc Match either of the sequences de or abc. mysql> SELECT 'pi' REGEXP 'pi|apa'; -> 1mysql> SELECT 'axe' REGEXP 'pi|apa'; -> 0mysql> SELECT 'apa' REGEXP 'pi|apa'; -> 1mysql> SELECT 'apa' REGEXP '^(pi|apa)$'; -> 1mysql> SELECT 'pi' REGEXP '^(pi|apa)$'; -> 1mysql> SELECT 'pix' REGEXP '^(pi|apa)$'; -> 0 (abc)* Match zero or more instances of the sequence abc. mysql> SELECT 'pi' REGEXP '^(pi)*$'; -> 1mysql> SELECT 'pip' REGEXP '^(pi)*$'; -> 0mysql> SELECT 'pipi' REGEXP '^(pi)*$'; -> 1 {1}, {2,3} {n} or {m,n} notation provides a more general way of writing regular expressions that match many occurrences of the previous atom (or "piece") of the pattern. m and n are integers. To be more precise, a{n} matches exactly n instances of a. a{n,} matches n or more instances of a. a{m,n} matches m through n instances of a, inclusive. m and n must be in the range from 0 to RE_DUP_MAX (default 255), inclusive. If both m and n are given, m must be less than or equal to n. mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e'; -> 0mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e'; -> 1mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e'; -> 1 [a-dX], [^a-dX] Matches any character that is (or is not, if ^ is used) either a, b, c, d or X. A - character between two other characters forms a range that matches all characters from the first character to the second. For example, [0-9] matches any decimal digit. To include a literal ] character, it must immediately follow the opening bracket [. To include a literal - character, it must be written first or last. Any character that does not have a defined special meaning inside a [] pair matches only itself. mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]'; -> 1mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$'; -> 0mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$'; -> 1mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$'; -> 0mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$'; -> 1mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$'; -> 0 [.characters.] Within a bracket expression (written using [ and ]), matches the sequence of characters of that collating element. characters is either a single character or a character name like newline. The following table lists the permissible character names. The following table shows the permissible character names and the characters that they match. For characters given as numeric values, the values are represented in octal. mysql> SELECT '~' REGEXP '[[.~.]]'; -> 1mysql> SELECT '~' REGEXP '[[.tilde.]]'; -> 1 [=character_class=] Within a bracket expression (written using [ and ]), [=character_class=] represents an equivalence class. It matches all characters with the same collation value, including itself. For example, if o and (+) are the members of an equivalence class, [[=o=]], [[=(+)=]], and [o(+)] are all synonymous. An equivalence class may not be used as an endpoint of a range. [:character_class:] Within a bracket expression (written using [ and ]), [:character_class:] represents a character class that matches all characters belonging to that class. The following table lists the standard class names. These names stand for the character classes defined in the ctype(3) manual page. A particular locale may provide other class names. A character class may not be used as an endpoint of a range. mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+'; -> 1mysql> SELECT '!!' REGEXP '[[:alnum:]]+'; -> 0 [[:<:]], [[:>:]] These markers stand for word boundaries. They match the beginning and end of words, respectively. A word is a sequence of word characters that is not preceded by or followed by word characters. A word character is an alphanumeric character in the alnum class or an underscore (_). mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]'; -> 1mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]'; -> 0
To use a literal instance of a special character in a regular expression, precede it by two backslash (\) characters. The MySQL parser interprets one of the backslashes, and the regular expression library interprets the other. For example, to match the string 1+2 that contains the special + character, only the last of the following regular expressions is the correct one: mysql> SELECT '1+2' REGEXP '1+2'; -> 0mysql> SELECT '1+2' REGEXP '1\+2'; -> 0mysql> SELECT '1+2' REGEXP '1\\+2'; -> 1 12.6. Numeric Functions and OperatorsTable 12.10. Numeric Functions and Operators | Name | Description |
|---|
| ABS() | Return the absolute value | | ACOS() | Return the arc cosine | | ASIN() | Return the arc sine | | ATAN2(), ATAN() | Return the arc tangent of the two arguments | | ATAN() | Return the arc tangent | | CEIL() | Return the smallest integer value not less than the argument | | CEILING() | Return the smallest integer value not less than the argument | | CONV() | Convert numbers between different number bases | | COS() | Return the cosine | | COT() | Return the cotangent | | CRC32() | Compute a cyclic redundancy check value | | DEGREES() | Convert radians to degrees | | DIV | Integer division | | / | Division operator | | EXP() | Raise to the power of | | FLOOR() | Return the largest integer value not greater than the argument | | LN() | Return the natural logarithm of the argument | | LOG10() | Return the base-10 logarithm of the argument | | LOG2() | Return the base-2 logarithm of the argument | | LOG() | Return the natural logarithm of the first argument | | - | Minus operator | | MOD() | Return the remainder | | % or MOD | Modulo operator | | PI() | Return the value of pi | | + | Addition operator | | POW() | Return the argument raised to the specified power | | POWER() | Return the argument raised to the specified power | | RADIANS() | Return argument converted to radians | | RAND() | Return a random floating-point value | | ROUND() | Round the argument | | SIGN() | Return the sign of the argument | | SIN() | Return the sine of the argument | | SQRT() | Return the square root of the argument | | TAN() | Return the tangent of the argument | | * | Multiplication operator | | TRUNCATE() | Truncate to specified number of decimal places | | - | Change the sign of the argument |
12.6.1. Arithmetic OperatorsTable 12.11. Arithmetic Operators | Name | Description |
|---|
| DIV | Integer division | | / | Division operator | | - | Minus operator | | % or MOD | Modulo operator | | + | Addition operator | | * | Multiplication operator | | - | Change the sign of the argument |
The usual arithmetic operators are available. The result is determined according to the following rules: In the case of -, +, and *, the result is calculated with BIGINT (64-bit) precision if both operands are integers. If both operands are integers and any of them are unsigned, the result is an unsigned integer. For subtraction, if the NO_UNSIGNED_SUBTRACTION SQL mode is enabled, the result is signed even if any operand is unsigned. If any of the operands of a +, -, /, *, % is a real or string value, the precision of the result is the precision of the operand with the maximum precision. In division performed with /, the scale of the result when using two exact-value operands is the scale of the first operand plus the value of the div_precision_increment system variable (which is 4 by default). For example, the result of the expression 5.05 / 0.014 has a scale of six decimal places (360.714286).
These rules are applied for each operation, such that nested calculations imply the precision of each component. Hence, (14620 / 9432456) / (24250 / 9432456), resolves first to (0.0014) / (0.0026), with the final result having 8 decimal places (0.60288653). Because of these rules and the way they are applied, care should be taken to ensure that components and subcomponents of a calculation use the appropriate level of precision. See Section 12.10, "Cast Functions and Operators". For information about handling of overflow in numeric expression evaluation, see Section 11.2.6, "Out-of-Range and Overflow Handling". Arithmetic operators apply to numbers. For other types of values, alternative operations may be available. For example, to add date values, use DATE_ADD(); see Section 12.7, "Date and Time Functions". + Addition: mysql> SELECT 3+5; -> 8 - Subtraction: mysql> SELECT 3-5; -> -2 - Unary minus. This operator changes the sign of the operand. mysql> SELECT - 2; -> -2 Note If this operator is used with a BIGINT, the return value is also a BIGINT. This means that you should avoid using - on integers that may have the value of �263. * Multiplication: mysql> SELECT 3*5; -> 15mysql> SELECT 18014398509481984*18014398509481984.0; -> 324518553658426726783156020576256.0mysql> SELECT 18014398509481984*18014398509481984; -> out-of-range error The last expression produces an error because the result of the integer multiplication exceeds the 64-bit range of BIGINT calculations. (See Section 11.2, "Numeric Types".) / Division: mysql> SELECT 3/5; -> 0.60 Division by zero produces a NULL result: mysql> SELECT 102/(1-1); -> NULL A division is calculated with BIGINT arithmetic only if performed in a context where its result is converted to an integer. DIV Integer division. Similar to FLOOR(), but is safe with BIGINT values. As of MySQL 5.5.3, if either operand has a noninteger type, the operands are converted to DECIMAL and divided using DECIMAL arithmetic before converting the result to BIGINT. If the result exceeds BIGINT range, an error occurs. Before MySQL 5.5.3, incorrect results may occur for noninteger operands that exceed BIGINT range. mysql> SELECT 5 DIV 2; -> 2 N % M, N MOD M Modulo operation. Returns the remainder of N divided by M. For more information, see the description for the MOD() function in Section 12.6.2, "Mathematical Functions".
12.6.2. Mathematical FunctionsTable 12.12. Mathematical Functions | Name | Description |
|---|
| ABS() | Return the absolute value | | ACOS() | Return the arc cosine | | ASIN() | Return the arc sine | | ATAN2(), ATAN() | Return the arc tangent of the two arguments | | ATAN() | Return the arc tangent | | CEIL() | Return the smallest integer value not less than the argument | | CEILING() | Return the smallest integer value not less than the argument | | CONV() | Convert numbers between different number bases | | COS() | Return the cosine | | COT() | Return the cotangent | | CRC32() | Compute a cyclic redundancy check value | | DEGREES() | Convert radians to degrees | | EXP() | Raise to the power of | | FLOOR() | Return the largest integer value not greater than the argument | | LN() | Return the natural logarithm of the argument | | LOG10() | Return the base-10 logarithm of the argument | | LOG2() | Return the base-2 logarithm of the argument | | LOG() | Return the natural logarithm of the first argument | | MOD() | Return the remainder | | PI() | Return the value of pi | | POW() | Return the argument raised to the specified power | | POWER() | Return the argument raised to the specified power | | RADIANS() | Return argument converted to radians | | RAND() | Return a random floating-point value | | ROUND() | Round the argument | | SIGN() | Return the sign of the argument | | SIN() | Return the sine of the argument | | SQRT() | Return the square root of the argument | | TAN() | Return the tangent of the argument | | TRUNCATE() | Truncate to specified number of decimal places |
All mathematical functions return NULL in the event of an error. ABS(X) Returns the absolute value of X. mysql> SELECT ABS(2); -> 2mysql> SELECT ABS(-32); -> 32 This function is safe to use with BIGINT values. 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); -> 0mysql> SELECT ACOS(1.0001); -> NULLmysql> SELECT ACOS(0); -> 1.5707963267949 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.20135792079033mysql> SELECT ASIN('foo');+-------------+| ASIN('foo') |+-------------+| 0 |+-------------+1 row in set, 1 warning (0.00 sec)mysql> SHOW WARNINGS;+---------+------+-----------------------------------------+| Level | Code | Message |+---------+------+-----------------------------------------+| Warning | 1292 | Truncated incorrect DOUBLE value: 'foo' |+---------+------+-----------------------------------------+ ATAN(X) Returns the arc tangent of X, that is, the value whose tangent is X. mysql> SELECT ATAN(2); -> 1.1071487177941mysql> SELECT ATAN(-2); -> -1.1071487177941 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.78539816339745mysql> SELECT ATAN2(PI(),0); -> 1.5707963267949 CEIL(X) CEIL() is a synonym for CEILING(). CEILING(X) Returns the smallest integer value not less than X. mysql> SELECT CEILING(1.23); -> 2mysql> SELECT CEILING(-1.23); -> -1 For exact-value numeric arguments, the return value has an exact-value numeric type. For string or floating-point arguments, the return value has a floating-point type. 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' COS(X) Returns the cosine of X, where X is given in radians. mysql> SELECT COS(PI()); -> -1 COT(X) Returns the cotangent of X. mysql> SELECT COT(12); -> -1.5726734063977mysql> SELECT COT(0); -> NULL CRC32(expr) Computes a cyclic redundancy check value and returns a 32-bit unsigned value. The result is NULL if the argument is NULL. The argument is expected to be a string and (if possible) is treated as one if it is not. mysql> SELECT CRC32('MySQL'); -> 3259397556mysql> SELECT CRC32('mysql'); -> 2501908538 DEGREES(X) Returns the argument X, converted from radians to degrees. mysql> SELECT DEGREES(PI()); -> 180mysql> SELECT DEGREES(PI() / 2); -> 90 EXP(X) Returns the value of e (the base of natural logarithms) raised to the power of X. The inverse of this function is LOG() (using a single argument only) or LN(). mysql> SELECT EXP(2); -> 7.3890560989307mysql> SELECT EXP(-2); -> 0.13533528323661mysql> SELECT EXP(0); -> 1 FLOOR(X) Returns the largest integer value not greater than X. mysql> SELECT FLOOR(1.23); -> 1mysql> SELECT FLOOR(-1.23); -> -2 For exact-value numeric arguments, the return value has an exact-value numeric type. For string or floating-point arguments, the return value has a floating-point type. FORMAT(X,D) Formats the number X to a format like '#,###,###.##', rounded to D decimal places, and returns the result as a string. For details, see Section 12.5, "String Functions". HEX(N_or_S) This function can be used to obtain a hexadecimal representation of a decimal number or a string; the manner in which it does so varies according to the argument's type. See this function's description in Section 12.5, "String Functions", for details. LN(X) Returns the natural logarithm of X; that is, the base-e logarithm of X. If X is less than or equal to 0, then NULL is returned. mysql> SELECT LN(2); -> 0.69314718055995mysql> SELECT LN(-2); -> NULL This function is synonymous with LOG(X). The inverse of this function is the EXP() function. LOG(X), LOG(B,X) If called with one parameter, this function returns the natural logarithm of X. If X is less than or equal to 0, then NULL is returned. The inverse of this function (when called with a single argument) is the EXP() function. mysql> SELECT LOG(2); -> 0.69314718055995mysql> SELECT LOG(-2); -> NULL If called with two parameters, this function returns the logarithm of X to the base B. If X is less than or equal to 0, or if B is less than or equal to 1, then NULL is returned. mysql> SELECT LOG(2,65536); -> 16mysql> SELECT LOG(10,100); -> 2mysql> SELECT LOG(1,100); -> NULL LOG(B,X) is equivalent to LOG(X) / LOG(B). LOG2(X) Returns the base-2 logarithm of X. mysql> SELECT LOG2(65536); -> 16mysql> SELECT LOG2(-100); -> NULL LOG2() is useful for finding out how many bits a number requires for storage. This function is equivalent to the expression LOG(X) / LOG(2). LOG10(X) Returns the base-10 logarithm of X. mysql> SELECT LOG10(2); -> 0.30102999566398mysql> SELECT LOG10(100); -> 2mysql> SELECT LOG10(-100); -> NULL LOG10(X) is equivalent to LOG(10,X). MOD(N,M), N % M, N MOD M Modulo operation. Returns the remainder of N divided by M. mysql> SELECT MOD(234, 10); -> 4mysql> SELECT 253 % 7; -> 1mysql> SELECT MOD(29,9); -> 2mysql> SELECT 29 MOD 9; -> 2 This function is safe to use with BIGINT values. MOD() also works on values that have a fractional part and returns the exact remainder after division: mysql> SELECT MOD(34.5,3); -> 1.5 MOD(N,0) returns NULL. PI() Returns the value of π (pi). The default number of decimal places displayed is seven, but MySQL uses the full double-precision value internally.mysql> SELECT PI()+0.000000000000000000; -> 3.141592653589793116 POW(X,Y) Returns the value of X raised to the power of Y. mysql> SELECT POW(2,2); -> 4mysql> SELECT POW(2,-2); -> 0.25 POWER(X,Y) This is a synonym for POW(). RADIANS(X) Returns the argument X, converted from degrees to radians. (Note that π radians equals 180 mysql> SELECT PI(); -> 3.141593 degrees.) mysql> SELECT RADIANS(90); -> 1.5707963267949 RAND(), RAND(N) Returns a random floating-point value v in the range 0 <= v < 1.0. If a constant integer argument N is specified, it is used as the seed value, which produces a repeatable sequence of column values. In the following example, note that the sequences of values produced by RAND(3) is the same both places where it occurs. mysql> CREATE TABLE t (i INT);Query OK, 0 rows affected (0.42 sec)mysql> INSERT INTO t VALUES(1),(2),(3);Query OK, 3 rows affected (0.00 sec)Records: 3 Duplicates: 0 Warnings: 0mysql> SELECT i, RAND() FROM t;+------+------------------+| i | RAND() |+------+------------------+| 1 | 0.61914388706828 || 2 | 0.93845168309142 || 3 | 0.83482678498591 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND(3) FROM t;+------+------------------+| i | RAND(3) |+------+------------------+| 1 | 0.90576975597606 || 2 | 0.37307905813035 || 3 | 0.14808605345719 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND() FROM t;+------+------------------+| i | RAND() |+------+------------------+| 1 | 0.35877890638893 || 2 | 0.28941420772058 || 3 | 0.37073435016976 |+------+------------------+3 rows in set (0.00 sec)mysql> SELECT i, RAND(3) FROM t;+------+------------------+| i | RAND(3) |+------+------------------+| 1 | 0.90576975597606 || 2 | 0.37307905813035 || 3 | 0.14808605345719 |+------+------------------+3 rows in set (0.01 sec) With a constant initializer, the seed is initialized once when the statement is compiled, prior to execution. If a nonconstant initializer (such as a column name) is used as the argument, the seed is initialized with the value for each invocation of RAND(). (One implication of this is that for equal argument values, RAND() will return the same value each time.) To obtain a random integer R in the range i <= R < j, use the expression FLOOR(i + RAND() * (j � i)). For example, to obtain a random integer in the range the range 7 <= R < 12, you could use the following statement: SELECT FLOOR(7 + (RAND() * 5)); RAND() in a WHERE clause is re-evaluated every time the WHERE is executed. You cannot use a column with RAND() values in an ORDER BY clause, because ORDER BY would evaluate the column multiple times. However, 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 from a set of rows: mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d -> ORDER BY RAND() LIMIT 1000; RAND() is not meant to be a perfect random generator. It is a fast way to generate random numbers on demand that is portable between platforms for the same MySQL version. This function is unsafe for statement-based replication. Beginning with MySQL 5.5.2, a warning is logged if you use this function when binlog_format is set to STATEMENT. (Bug #49222) ROUND(X), ROUND(X,D) Rounds the argument X to D decimal places. The rounding algorithm depends on the data type of X. D defaults to 0 if not specified. D can be negative to cause D digits left of the decimal point of the value X to become zero. mysql> SELECT ROUND(-1.23); -> -1mysql> SELECT ROUND(-1.58); -> -2mysql> SELECT ROUND(1.58); -> 2mysql> SELECT ROUND(1.298, 1); -> 1.3mysql> SELECT ROUND(1.298, 0); -> 1mysql> SELECT ROUND(23.298, -1); -> 20 The return type is the same type as that of the first argument (assuming that it is integer, double, or decimal). This means that for an integer argument, the result is an integer (no decimal places): mysql> SELECT ROUND(150.000,2), ROUND(150,2);+------------------+--------------+| ROUND(150.000,2) | ROUND(150,2) |+------------------+--------------+| 150.00 | 150 |+------------------+--------------+ ROUND() uses the following rules depending on the type of the first argument: For exact-value numbers, ROUND() uses the "round half away from zero" or "round toward nearest" rule: A value with a fractional part of .5 or greater is rounded up to the next integer if positive or down to the next integer if negative. (In other words, it is rounded away from zero.) A value with a fractional part less than .5 is rounded down to the next integer if positive or up to the next integer if negative. For approximate-value numbers, the result depends on the C library. On many systems, this means that ROUND() uses the "round to nearest even" rule: A value with any fractional part is rounded to the nearest even integer.
The following example shows how rounding differs for exact and approximate values: mysql> SELECT ROUND(2.5), ROUND(25E-1);+------------+--------------+| ROUND(2.5) | ROUND(25E-1) |+------------+--------------+| 3 | 2 |+------------+--------------+ For more information, see Section 12.18, "Precision Math". 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); -> -1mysql> SELECT SIGN(0); -> 0mysql> SELECT SIGN(234); -> 1 SIN(X) Returns the sine of X, where X is given in radians. mysql> SELECT SIN(PI()); -> 1.2246063538224e-16mysql> SELECT ROUND(SIN(PI())); -> 0 SQRT(X) Returns the square root of a nonnegative number X. mysql> SELECT SQRT(4); -> 2mysql> SELECT SQRT(20); -> 4.4721359549996mysql> SELECT SQRT(-16); -> NULL TAN(X) Returns the tangent of X, where X is given in radians. mysql> SELECT TAN(PI()); -> -1.2246063538224e-16mysql> SELECT TAN(PI()+1); -> 1.5574077246549 TRUNCATE(X,D) Returns the number X, truncated to D decimal places. If D is 0, the result has no decimal point or fractional part. D can be negative to cause D digits left of the decimal point of the value X to become zero. mysql> SELECT TRUNCATE(1.223,1); -> 1.2mysql> SELECT TRUNCATE(1.999,1); -> 1.9mysql> SELECT TRUNCATE(1.999,0); -> 1mysql> SELECT TRUNCATE(-1.999,1); -> -1.9mysql> SELECT TRUNCATE(122,-2); -> 100mysql> SELECT TRUNCATE(10.28*100,0); -> 1028 All numbers are rounded toward zero.
12.7. Date and Time Functions This section describes the functions that can be used to manipulate temporal values. See Section 11.3, "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. Table 12.13. Date/Time Functions Here is an example that uses date functions. The following query selects all rows 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; The query also selects rows with dates that lie in the future. Functions that expect date values usually accept datetime values and ignore the time part. Functions that expect time values usually 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 always produce the same result. (For our purposes, a single query also includes a call to a stored program (stored routine, trigger, or event) and all subprograms called by that program.) This principle also applies to CURDATE(), CURTIME(), UTC_DATE(), UTC_TIME(), UTC_TIMESTAMP(), and to any of their synonyms. The CURRENT_TIMESTAMP(), CURRENT_TIME(), CURRENT_DATE(), and FROM_UNIXTIME() functions return values in the connection's current time zone, which is available as the value of the time_zone system variable. In addition, UNIX_TIMESTAMP() assumes that its argument is a datetime value in the current time zone. See Section 10.6, "MySQL Server Time Zone Support". Some date functions can be used with "zero" dates or incomplete dates such as '2001-11-00', whereas others cannot. Functions that extract parts of dates typically work with incomplete dates and thus can return 0 when you might otherwise expect a nonzero value. For example: mysql> SELECT DAYOFMONTH('2001-11-00'), MONTH('2005-00-00'); -> 0, 0 Other functions expect complete dates and return NULL for incomplete dates. These include functions that perform date arithmetic or that map parts of dates to names. For example: mysql> SELECT DATE_ADD('2006-05-00',INTERVAL 1 DAY); -> NULLmysql> SELECT DAYNAME('2006-05-00'); -> NULLNote From MySQL 5.5.16 to 5.5.20, a change in handling of a date-related assertion caused several functions to become more strict when passed a DATE() function value as their argument and reject incomplete dates with a day part of zero. These functions are affected: CONVERT_TZ(), DATE_ADD(), DATE_SUB(), DAYOFYEAR(), LAST_DAY(), TIMESTAMPDIFF(), TO_DAYS(), TO_SECONDS(), WEEK(), WEEKDAY(), WEEKOFYEAR(), YEARWEEK(). Because this changes date-handling behavior in General Availability-status series MySQL 5.5, the change was reverted in 5.5.21. ADDDATE(date,INTERVAL expr unit), 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(). For information on the INTERVAL unit argument, see the discussion for DATE_ADD(). mysql> SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY); -> '2008-02-02'mysql> SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY); -> '2008-02-02' When invoked with the days form of the second argument, MySQL treats it as an integer number of days to be added to expr. mysql> SELECT ADDDATE('2008-01-02', 31); -> '2008-02-02' ADDTIME(expr1,expr2) ADDTIME() adds expr2 to expr1 and returns the result. expr1 is a time or datetime expression, and expr2 is a time expression. mysql> SELECT ADDTIME('2007-12-31 23:59:59.999999', '1 1:1:1.000002'); -> '2008-01-02 01:01:01.000001'mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998'); -> '03:00:01.999997' CONVERT_TZ(dt,from_tz,to_tz) CONVERT_TZ() converts a datetime value dt from the time zone given by from_tz to the time zone given by to_tz and returns the resulting value. Time zones are specified as described in Section 10.6, "MySQL Server Time Zone Support". This function returns NULL if the arguments are invalid. If the value falls out of the supported range of the TIMESTAMP type when converted from from_tz to UTC, no conversion occurs. The TIMESTAMP range is described in Section 11.1.2, "Date and Time Type Overview". mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET'); -> '2004-01-01 13:00:00'mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00'); -> '2004-01-01 22:00:00' 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(); -> '2008-06-13'mysql> SELECT CURDATE() + 0; -> 20080613 CURRENT_DATE, CURRENT_DATE() CURRENT_DATE and CURRENT_DATE() are synonyms for CURDATE(). CURRENT_TIME, CURRENT_TIME() CURRENT_TIME and CURRENT_TIME() are synonyms for CURTIME(). CURRENT_TIMESTAMP, CURRENT_TIMESTAMP() CURRENT_TIMESTAMP and CURRENT_TIMESTAMP() are synonyms for NOW(). CURTIME() Returns the current time as a value in 'HH:MM:SS' or HHMMSS.uuuuuu format, depending on whether the function is used in a string or numeric context. The value is expressed in the current time zone. mysql> SELECT CURTIME(); -> '23:50:26'mysql> SELECT CURTIME() + 0; -> 235026.000000 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' DATEDIFF(expr1,expr2) DATEDIFF() returns expr1 � expr2 expressed as a value in days from one date to the other. expr1 and expr2 are date or date-and-time expressions. Only the date parts of the values are used in the calculation. mysql> SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30'); -> 1mysql> SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31'); -> -31 DATE_ADD(date,INTERVAL expr unit), DATE_SUB(date,INTERVAL expr unit) These functions perform date arithmetic. The date argument specifies the starting date or datetime value. 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. unit is a keyword indicating the units in which the expression should be interpreted. The INTERVAL keyword and the unit specifier are not case sensitive. The following table shows the expected form of the expr argument for each unit value. The return value depends on the arguments: DATETIME if the first argument is a DATETIME (or TIMESTAMP) value, or if the first argument is a DATE and the unit value uses HOURS, MINUTES, or SECONDS. String otherwise.
To ensure that the result is DATETIME, you can use CAST() to convert the first argument to DATETIME. MySQL permits 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. Date arithmetic also can be performed using INTERVAL together with the + or - operator: date + INTERVAL expr unitdate - INTERVAL expr unit INTERVAL expr unit is permitted on either side of the + operator if the expression on the other side is a date or datetime value. For the - operator, INTERVAL expr unit is permitted only on the right side, because it makes no sense to subtract a date or datetime value from an interval. mysql> SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND; -> '2009-01-01 00:00:00'mysql> SELECT INTERVAL 1 DAY + '2008-12-31'; -> '2009-01-01'mysql> SELECT '2005-01-01' - INTERVAL 1 SECOND; -> '2004-12-31 23:59:59'mysql> SELECT DATE_ADD('2000-12-31 23:59:59', -> INTERVAL 1 SECOND); -> '2001-01-01 00:00:00'mysql> SELECT DATE_ADD('2010-12-31 23:59:59', -> INTERVAL 1 DAY); -> '2011-01-01 23:59:59'mysql> SELECT DATE_ADD('2100-12-31 23:59:59', -> INTERVAL '1:1' MINUTE_SECOND); -> '2101-01-01 00:01:00'mysql> SELECT DATE_SUB('2005-01-01 00:00:00', -> INTERVAL '1 1:1:1' DAY_SECOND); -> '2004-12-30 22:58:59'mysql> SELECT DATE_ADD('1900-01-01 00:00:00', -> INTERVAL '-1 10' DAY_HOUR); -> '1899-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 unit keyword), MySQL assumes that you have left out the leftmost parts of the interval value. For example, if you specify a unit 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 a time of day. Because expr is treated as a string, be careful if you specify a nonstring value with INTERVAL. For example, with an interval specifier of HOUR_MINUTE, 6/4 evaluates to 1.5000 and is treated as 1 hour, 5000 minutes: mysql> SELECT 6/4; -> 1.5000mysql> SELECT DATE_ADD('2009-01-01', INTERVAL 6/4 HOUR_MINUTE); -> '2009-01-04 12:20:00' To ensure interpretation of the interval value as you expect, a CAST() operation may be used. To treat 6/4 as 1 hour, 5 minutes, cast it to a DECIMAL value with a single fractional digit: mysql> SELECT CAST(6/4 AS DECIMAL(3,1)); -> 1.5mysql> SELECT DATE_ADD('1970-01-01 12:00:00', -> INTERVAL CAST(6/4 AS DECIMAL(3,1)) HOUR_MINUTE); -> '1970-01-01 13:05:00' 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('2013-01-01', INTERVAL 1 DAY); -> '2013-01-02'mysql> SELECT DATE_ADD('2013-01-01', INTERVAL 1 HOUR); -> '2013-01-01 01:00:00' 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('2009-01-30', INTERVAL 1 MONTH); -> '2009-02-28' Date arithmetic operations require complete dates and do not work with incomplete dates such as '2006-07-00' or badly malformed dates: mysql> SELECT DATE_ADD('2006-07-00', INTERVAL 1 DAY); -> NULLmysql> SELECT '2005-03-32' + INTERVAL 1 MONTH; -> NULL DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The "%" character is required before format specifier characters. Ranges for the month and day specifiers begin with zero due to the fact that MySQL permits the storing of incomplete dates such as '2014-00-00'. The language used for day and month names and abbreviations is controlled by the value of the lc_time_names system variable (Section 10.7, "MySQL Server Locale Support"). DATE_FORMAT() returns a string with a character set and collation given by character_set_connection and collation_connection so that it can return month and weekday names containing non-ASCII characters. mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y'); -> 'Sunday October 2009'mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s'); -> '22:23:00'mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00', -> '%D %y %a %d %m %b %j'); -> '4th 00 Thu 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> SELECT DATE_FORMAT('2006-06-00', '%d'); -> '00' DATE_SUB(date,INTERVAL expr unit) See the description for DATE_ADD(). DAY(date) DAY() is a synonym for DAYOFMONTH(). DAYNAME(date) Returns the name of the weekday for date. The language used for the name is controlled by the value of the lc_time_names system variable (Section 10.7, "MySQL Server Locale Support"). mysql> SELECT DAYNAME('2007-02-03'); -> 'Saturday' DAYOFMONTH(date) Returns the day of the month for date, in the range 1 to 31, or 0 for dates such as '0000-00-00' or '2008-00-00' that have a zero day part. mysql> SELECT DAYOFMONTH('2007-02-03'); -> 3 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('2007-02-03'); -> 7 DAYOFYEAR(date) Returns the day of the year for date, in the range 1 to 366. mysql> SELECT DAYOFYEAR('2007-02-03'); -> 34 EXTRACT(unit FROM date) The EXTRACT() function uses the same kinds of unit specifiers as DATE_ADD() or DATE_SUB(), but extracts parts from the date rather than performing date arithmetic. mysql> SELECT EXTRACT(YEAR FROM '2009-07-02'); -> 2009mysql> SELECT EXTRACT(YEAR_MONTH FROM '2009-07-02 01:02:03'); -> 200907mysql> SELECT EXTRACT(DAY_MINUTE FROM '2009-07-02 01:02:03'); -> 20102mysql> SELECT EXTRACT(MICROSECOND -> FROM '2003-01-02 10:30:00.000123'); -> 123 FROM_DAYS(N) Given a day number N, returns a DATE value. mysql> SELECT FROM_DAYS(730669); -> '2007-07-03' Use FROM_DAYS() with caution on old dates. It is not intended for use with values that precede the advent of the Gregorian calendar (1582). See Section 12.8, "What Calendar Is Used By MySQL?". 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.uuuuuu format, depending on whether the function is used in a string or numeric context. The value is expressed in the current time zone. unix_timestamp is an internal timestamp value such as is produced by the UNIX_TIMESTAMP() function. If format is given, the result is formatted according to the format string, which is used the same way as listed in the entry for the DATE_FORMAT() function. mysql> SELECT FROM_UNIXTIME(1196440219); -> '2007-11-30 10:30:19'mysql> SELECT FROM_UNIXTIME(1196440219) + 0; -> 20071130103019.000000mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(), -> '%Y %D %M %h:%i:%s %x'); -> '2007 30th November 10:30:59 2007' Note: If you use UNIX_TIMESTAMP() and FROM_UNIXTIME() to convert between TIMESTAMP values and Unix timestamp values, the conversion is lossy because the mapping is not one-to-one in both directions. For details, see the description of the UNIX_TIMESTAMP() function. GET_FORMAT({DATE|TIME|DATETIME}, {'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 possible values for the first and second arguments result in several possible format strings (for the specifiers used, see the table in the DATE_FORMAT() function description). ISO format refers to ISO 9075, not ISO 8601. TIMESTAMP can also be used as the first argument to GET_FORMAT(), in which case the function returns the same values as for DATETIME. 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' HOUR(time) Returns the hour for time. The range of the return value is 0 to 23 for time-of-day values. However, the range of TIME values actually is much larger, so HOUR can return values greater than 23. mysql> SELECT HOUR('10:05:03'); -> 10mysql> SELECT HOUR('272:59:59'); -> 272 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 LOCALTIME, LOCALTIME() LOCALTIME and LOCALTIME() are synonyms for NOW(). LOCALTIMESTAMP, LOCALTIMESTAMP() LOCALTIMESTAMP and LOCALTIMESTAMP() are synonyms for NOW(). MAKEDATE(year,dayofyear) Returns a date, given year and day-of-year values. dayofyear must be greater than 0 or the result is NULL. mysql> SELECT MAKEDATE(2011,31), MAKEDATE(2011,32); -> '2011-01-31', '2011-02-01'mysql> SELECT MAKEDATE(2011,365), MAKEDATE(2014,365); -> '2011-12-31', '2014-12-31'mysql> SELECT MAKEDATE(2011,0); -> NULL 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' 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'); -> 123456mysql> SELECT MICROSECOND('2009-12-31 23:59:59.000010'); -> 10 MINUTE(time) Returns the minute for time, in the range 0 to 59. mysql> SELECT MINUTE('2008-02-03 10:05:03'); -> 5 MONTH(date) Returns the month for date, in the range 1 to 12 for January to December, or 0 for dates such as '0000-00-00' or '2008-00-00' that have a zero month part. mysql> SELECT MONTH('2008-02-03'); -> 2 MONTHNAME(date) Returns the full name of the month for date. The language used for the name is controlled by the value of the lc_time_names system variable (Section 10.7, "MySQL Server Locale Support"). mysql> SELECT MONTHNAME('2008-02-03'); -> 'February' NOW() Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS.uuuuuu format, depending on whether the function is used in a string or numeric context. The value is expressed in the current time zone. mysql> SELECT NOW(); -> '2007-12-15 23:50:26'mysql> SELECT NOW() + 0; -> 20071215235026.000000 NOW() returns a constant time that indicates the time at which the statement began to execute. (Within a stored function or trigger, NOW() returns the time at which the function or triggering statement began to execute.) This differs from the behavior for SYSDATE(), which returns the exact time at which it executes. mysql> SELECT NOW(), SLEEP(2), NOW();+---------------------+----------+---------------------+| NOW() | SLEEP(2) | NOW() |+---------------------+----------+---------------------+| 2006-04-12 13:47:36 | 0 | 2006-04-12 13:47:36 |+---------------------+----------+---------------------+mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();+---------------------+----------+---------------------+| SYSDATE() | SLEEP(2) | SYSDATE() |+---------------------+----------+---------------------+| 2006-04-12 13:47:44 | 0 | 2006-04-12 13:47:46 |+---------------------+----------+---------------------+ In addition, the SET TIMESTAMP statement affects the value returned by NOW() but not by SYSDATE(). This means that timestamp settings in the binary log have no effect on invocations of SYSDATE(). Setting the timestamp to a nonzero value causes each subsequent invocation of NOW() to return that value. Setting the timestamp to zero cancels this effect so that NOW() once again returns the current date and time. See the description for SYSDATE() for additional information about the differences between the two functions. 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(200801,2); -> 200803 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(200802,200703); -> 11 QUARTER(date) Returns the quarter of the year for date, in the range 1 to 4. mysql> SELECT QUARTER('2008-04-01'); -> 2 SECOND(time) Returns the second for time, in the range 0 to 59. mysql> SELECT SECOND('10:05:03'); -> 3 SEC_TO_TIME(seconds) Returns the seconds argument, converted to hours, minutes, and seconds, as a TIME value. The range of the result is constrained to that of the TIME data type. A warning occurs if the argument corresponds to a value outside that range. mysql> SELECT SEC_TO_TIME(2378); -> '00:39:38'mysql> SELECT SEC_TO_TIME(2378) + 0; -> 3938 STR_TO_DATE(str,format) This is the inverse of the DATE_FORMAT() function. It takes a string str and a format string format. STR_TO_DATE() returns a DATETIME value if the format string contains both date and time parts, or a DATE or TIME value if the string contains only date or time parts. If the date, time, or datetime value extracted from str is illegal, STR_TO_DATE() returns NULL and produces a warning. The server scans str attempting to match format to it. The format string can contain literal characters and format specifiers beginning with %. Literal characters in format must match literally in str. Format specifiers in format must match a date or time part in str. For the specifiers that can be used in format, see the DATE_FORMAT() function description. mysql> SELECT STR_TO_DATE('01,5,2013','%d,%m,%Y'); -> '2013-05-01'mysql> SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y'); -> '2013-05-01' Scanning starts at the beginning of str and fails if format is found not to match. Extra characters at the end of str are ignored. mysql> SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s'); -> '09:30:17'mysql> SELECT STR_TO_DATE('a09:30:17','%h:%i:%s'); -> NULLmysql> SELECT STR_TO_DATE('09:30:17a','%h:%i:%s'); -> '09:30:17' Unspecified date or time parts have a value of 0, so incompletely specified values in str produce a result with some or all parts set to 0: mysql> SELECT STR_TO_DATE('abc','abc'); -> '0000-00-00'mysql> SELECT STR_TO_DATE('9','%m'); -> '0000-09-00'mysql> SELECT STR_TO_DATE('9','%s'); -> '00:00:09' Range checking on the parts of date values is as described in Section 11.3.1, "The DATE, DATETIME, and TIMESTAMP Types". This means, for example, that "zero" dates or dates with part values of 0 are permitted unless the SQL mode is set to disallow such values. mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y'); -> '0000-00-00'mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y'); -> '2004-04-31'Note You cannot use format "%X%V" to convert a year-week string to a date because the combination of a year and week does not uniquely identify a year and month if the week crosses a month boundary. To convert a year-week to a date, you should also specify the weekday: mysql> SELECT STR_TO_DATE('200442 Monday', '%X%V %W'); -> '2004-10-18' SUBDATE(date,INTERVAL expr unit), SUBDATE(expr,days) When invoked with the INTERVAL form of the second argument, SUBDATE() is a synonym for DATE_SUB(). For information on the INTERVAL unit argument, see the discussion for DATE_ADD(). mysql> SELECT DATE_SUB('2008-01-02', INTERVAL 31 DAY); -> '2007-12-02'mysql> SELECT SUBDATE('2008-01-02', INTERVAL 31 DAY); -> '2007-12-02' The second form enables the use of an integer value for days. In such cases, it is interpreted as the number of days to be subtracted from the date or datetime expression expr. mysql> SELECT SUBDATE('2008-01-02 12:00:00', 31); -> '2007-12-02 12:00:00' SUBTIME(expr1,expr2) SUBTIME() returns expr1 � expr2 expressed as a value in the same format as expr1. expr1 is a time or datetime expression, and expr2 is a time expression. mysql> SELECT SUBTIME('2007-12-31 23:59:59.999999','1 1:1:1.000002'); -> '2007-12-30 22:58:58.999997'mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998'); -> '-00:59:59.999999' SYSDATE() Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS.uuuuuu format, depending on whether the function is used in a string or numeric context. SYSDATE() returns the time at which it executes. This differs from the behavior for NOW(), which returns a constant time that indicates the time at which the statement began to execute. (Within a stored function or trigger, NOW() returns the time at which the function or triggering statement began to execute.) mysql> SELECT NOW(), SLEEP(2), NOW();+---------------------+----------+---------------------+| NOW() | SLEEP(2) | NOW() |+---------------------+----------+---------------------+| 2006-04-12 13:47:36 | 0 | 2006-04-12 13:47:36 |+---------------------+----------+---------------------+mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();+---------------------+----------+---------------------+| SYSDATE() | SLEEP(2) | SYSDATE() |+---------------------+----------+---------------------+| 2006-04-12 13:47:44 | 0 | 2006-04-12 13:47:46 |+---------------------+----------+---------------------+ In addition, the SET TIMESTAMP statement affects the value returned by NOW() but not by SYSDATE(). This means that timestamp settings in the binary log have no effect on invocations of SYSDATE(). Because SYSDATE() can return different values even within the same statement, and is not affected by SET TIMESTAMP, it is nondeterministic and therefore unsafe for replication if statement-based binary logging is used. If that is a problem, you can use row-based logging. Alternatively, you can use the --sysdate-is-now option to cause SYSDATE() to be an alias for NOW(). This works if the option is used on both the master and the slave. The nondeterministic nature of SYSDATE() also means that indexes cannot be used for evaluating expressions that refer to it. TIME(expr) Extracts the time part of the time or datetime expression expr and returns it as a string. This function is unsafe for statement-based replication. Beginning with MySQL 5.5.1, a warning is logged if you use this function when binlog_format is set to STATEMENT. (Bug #47995) 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' TIMEDIFF(expr1,expr2) TIMEDIFF() returns expr1 � expr2 expressed as a time value. expr1 and expr2 are time or date-and-time expressions, but both must be of the same type. The result returned by TIMEDIFF() is limited to the range allowed for TIME values. Alternatively, you can use either of the functions TIMESTAMPDIFF() and UNIX_TIMESTAMP(), both of which return integers. mysql> SELECT TIMEDIFF('2000:01:01 00:00:00', -> '2000:01:01 00:00:00.000001'); -> '-00:00:00.000001'mysql> SELECT TIMEDIFF('2008-12-31 23:59:59.000001', -> '2008-12-30 01:01:01.000002'); -> '46:58:57.999999' TIMESTAMP(expr), TIMESTAMP(expr1,expr2) With a single argument, this function returns the date or datetime expression expr as a datetime value. With two arguments, it adds the time expression expr2 to the date or datetime expression expr1 and returns the result as 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' TIMESTAMPADD(unit,interval,datetime_expr) Adds the integer expression interval to the date or datetime expression datetime_expr. The unit for interval is given by the unit argument, which should be one of the following values: MICROSECOND (microseconds), SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, or YEAR. It is possible to use FRAC_SECOND in place of MICROSECOND, but FRAC_SECOND is deprecated. FRAC_SECOND was removed in MySQL 5.5.3. The unit value may be specified using one of keywords as shown, or with a prefix of SQL_TSI_. For example, DAY and 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' TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2) Returns datetime_expr2 � datetime_expr1, where datetime_expr1 and datetime_expr2 are date or datetime expressions. One expression may be a date and the other a datetime; a date value is treated as a datetime having the time part '00:00:00' where necessary. The unit for the result (an integer) is given by the unit argument. The legal values for unit are the same as those listed in the description of the TIMESTAMPADD() function. mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01'); -> 3mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01'); -> -1mysql> SELECT TIMESTAMPDIFF(MINUTE,'2003-02-01','2003-05-01 12:05:55'); -> 128885 Note The order of the date or datetime arguments for this function is the opposite of that used with the TIMESTAMP() function when invoked with 2 arguments. TIME_FORMAT(time,format) This is used like the DATE_FORMAT() function, but the format string may contain format specifiers only for hours, minutes, seconds, and microseconds. 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' TIME_TO_SEC(time) Returns the time argument, converted to seconds. mysql> SELECT TIME_TO_SEC('22:23:00'); -> 80580mysql> SELECT TIME_TO_SEC('00:39:38'); -> 2378 TO_DAYS(date) Given a date date, returns a day number (the number of days since year 0). mysql> SELECT TO_DAYS(950501); -> 728779mysql> SELECT TO_DAYS('2007-10-07'); -> 733321 TO_DAYS() is not intended for use with values that precede the advent of the Gregorian calendar (1582), because it does not take into account the days that were lost when the calendar was changed. For dates before 1582 (and possibly a later year in other locales), results from this function are not reliable. See Section 12.8, "What Calendar Is Used By MySQL?", for details. Remember that MySQL converts two-digit year values in dates to four-digit form using the rules in Section 11.3, "Date and Time Types". For example, '2008-10-07' and '08-10-07' are seen as identical dates: mysql> SELECT TO_DAYS('2008-10-07'), TO_DAYS('08-10-07'); -> 733687, 733687 In MySQL, the zero date is defined as '0000-00-00', even though this date is itself considered invalid. This means that, for '0000-00-00' and '0000-01-01', TO_DAYS() returns the values shown here: mysql> SELECT TO_DAYS('0000-00-00');+-----------------------+| to_days('0000-00-00') |+-----------------------+| NULL |+-----------------------+1 row in set, 1 warning (0.00 sec)mysql> SHOW WARNINGS;+---------+------+----------------------------------------+| Level | Code | Message |+---------+------+----------------------------------------+| Warning | 1292 | Incorrect datetime value: '0000-00-00' |+---------+------+----------------------------------------+1 row in set (0.00 sec)mysql> SELECT TO_DAYS('0000-01-01');+-----------------------+| to_days('0000-01-01') |+-----------------------+| 1 |+-----------------------+1 row in set (0.00 sec) This is true whether or not the ALLOW_INVALID_DATES SQL server mode is enabled. TO_SECONDS(expr) Given a date or datetime expr, returns a the number of seconds since the year 0. If expr is not a valid date or datetime value, returns NULL. mysql> SELECT TO_SECONDS(950501); -> 62966505600mysql> SELECT TO_SECONDS('2009-11-29'); -> 63426672000mysql> SELECT TO_SECONDS('2009-11-29 13:43:32'); -> 63426721412mysql> SELECT TO_SECONDS( NOW() ); -> 63426721458 Like TO_DAYS(), TO_SECONDS() is not intended for use with values that precede the advent of the Gregorian calendar (1582), because it does not take into account the days that were lost when the calendar was changed. For dates before 1582 (and possibly a later year in other locales), results from this function are not reliable. See Section 12.8, "What Calendar Is Used By MySQL?", for details. Like TO_DAYS(), TO_SECONDS(), converts two-digit year values in dates to four-digit form using the rules in Section 11.3, "Date and Time Types". TO_SECONDS() is available beginning with MySQL 5.5.0. In MySQL, the zero date is defined as '0000-00-00', even though this date is itself considered invalid. This means that, for '0000-00-00' and '0000-01-01', TO_SECONDS() returns the values shown here: mysql> SELECT TO_SECONDS('0000-00-00');+--------------------------+| TO_SECONDS('0000-00-00') |+--------------------------+| NULL |+--------------------------+1 row in set, 1 warning (0.00 sec)mysql> SHOW WARNINGS;+---------+------+----------------------------------------+| Level | Code | Message |+---------+------+----------------------------------------+| Warning | 1292 | Incorrect datetime value: '0000-00-00' |+---------+------+----------------------------------------+1 row in set (0.00 sec)mysql> SELECT TO_SECONDS('0000-01-01');+--------------------------+| TO_SECONDS('0000-01-01') |+--------------------------+| 86400 |+--------------------------+1 row in set (0.00 sec) This is true whether or not the ALLOW_INVALID_DATES SQL server mode is enabled. UNIX_TIMESTAMP(), UNIX_TIMESTAMP(date) If called with no argument, returns a Unix timestamp (seconds since '1970-01-01 00:00:00' UTC) 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' UTC. date may be a DATE string, a DATETIME string, a TIMESTAMP, or a number in the format YYMMDD or YYYYMMDD. The server interprets date as a value in the current time zone and converts it to an internal value in UTC. Clients can set their time zone as described in Section 10.6, "MySQL Server Time Zone Support". mysql> SELECT UNIX_TIMESTAMP(); -> 1196440210mysql> SELECT UNIX_TIMESTAMP('2007-11-30 10:30:19'); -> 1196440219 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. Note: If you use UNIX_TIMESTAMP() and FROM_UNIXTIME() to convert between TIMESTAMP values and Unix timestamp values, the conversion is lossy because the mapping is not one-to-one in both directions. For example, due to conventions for local time zone changes, it is possible for two UNIX_TIMESTAMP() to map two TIMESTAMP values to the same Unix timestamp value. FROM_UNIXTIME() will map that value back to only one of the original TIMESTAMP values. Here is an example, using TIMESTAMP values in the CET time zone: mysql> SELECT UNIX_TIMESTAMP('2005-03-27 03:00:00');+---------------------------------------+| UNIX_TIMESTAMP('2005-03-27 03:00:00') |+---------------------------------------+| 1111885200 |+---------------------------------------+mysql> SELECT UNIX_TIMESTAMP('2005-03-27 02:00:00');+---------------------------------------+| UNIX_TIMESTAMP('2005-03-27 02:00:00') |+---------------------------------------+| 1111885200 |+---------------------------------------+mysql> SELECT FROM_UNIXTIME(1111885200);+---------------------------+| FROM_UNIXTIME(1111885200) |+---------------------------+| 2005-03-27 03:00:00 |+---------------------------+ If you want to subtract UNIX_TIMESTAMP() columns, you might want to cast the result to signed integers. See Section 12.10, "Cast Functions and Operators". 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_TIME, UTC_TIME() Returns the current UTC time as a value in 'HH:MM:SS' or HHMMSS.uuuuuu 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.000000 UTC_TIMESTAMP, UTC_TIMESTAMP() Returns the current UTC date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS.uuuuuu 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.000000 WEEK(date[,mode]) This function returns the week number for date. The two-argument form of WEEK() enables 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 53. If the mode argument is omitted, the value of the default_week_format system variable is used. See Section 5.1.4, "Server System Variables". The following table describes how the mode argument works. mysql> SELECT WEEK('2008-02-20'); -> 7mysql> SELECT WEEK('2008-02-20',0); -> 7mysql> SELECT WEEK('2008-02-20',1); -> 8mysql> SELECT WEEK('2008-12-31',1); -> 53 Note that if a date falls in the last week of the previous year, MySQL returns 0 if you do not 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 because we want the function to return "the week number in the given year." This makes use 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, use 0, 2, 5, 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'); -> 199952mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2); -> '52' WEEKDAY(date) Returns the weekday index for date (0 = Monday, 1 = Tuesday, � 6 = Sunday). mysql> SELECT WEEKDAY('2008-02-03 22:23:00'); -> 6mysql> SELECT WEEKDAY('2007-11-06'); -> 1 WEEKOFYEAR(date) Returns the calendar week of the date as a number in the range from 1 to 53. WEEKOFYEAR() is a compatibility function that is equivalent to WEEK(date,3). mysql> SELECT WEEKOFYEAR('2008-02-20'); -> 8 YEAR(date) Returns the year for date, in the range 1000 to 9999, or 0 for the "zero" date. mysql> SELECT YEAR('1987-01-01'); -> 1987 YEARWEEK(date), YEARWEEK(date,mode) Returns year and week for a date. The mode argument works exactly like the mode 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.
12.8. What Calendar Is Used By MySQL? MySQL uses what is known as a proleptic Gregorian calendar. Every country that has switched from the Julian to the Gregorian calendar has had to discard at least ten days during the switch. To see how this works, consider the month of October 1582, when the first Julian-to-Gregorian switch occurred. There are no dates between October 4 and October 15. This discontinuity is called the cutover. Any dates before the cutover are Julian, and any dates following the cutover are Gregorian. Dates during a cutover are nonexistent. A calendar applied to dates when it was not actually in use is called proleptic. Thus, if we assume there was never a cutover and Gregorian rules always rule, we have a proleptic Gregorian calendar. This is what is used by MySQL, as is required by standard SQL. For this reason, dates prior to the cutover stored as MySQL DATE or DATETIME values must be adjusted to compensate for the difference. It is important to realize that the cutover did not occur at the same time in all countries, and that the later it happened, the more days were lost. For example, in Great Britain, it took place in 1752, when Wednesday September 2 was followed by Thursday September 14. Russia remained on the Julian calendar until 1918, losing 13 days in the process, and what is popularly referred to as its "October Revolution" occurred in November according to the Gregorian calendar. Copyright © 1997, 2013, Oracle and/or its affiliates. All rights reserved. Legal Notices |
| |
