String Operators

Name Description
ASCII() Return numeric value of left-most character
BIN() Return a string representation of the argument
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
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
 Name Description
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() Convert each pair of hexadecimal digits to a character
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 7.9.3, “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');
-> 50
mysql> SELECT ASCII(2);
 -> 50
mysql> 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'

As of MySQL 5.0.15, 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.

Before MySQL 5.0.15, CHAR() returns a string in the connection character set and the
USING clause is unavailable. In addition, each argument is interpreted modulo 256, so
CHAR(256) and CHAR(256*256) both are equivalent to CHAR(0).

 CHAR_LENGTH(str)

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

 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 binary string form; if you want to
avoid that, 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');
-> NULL
mysql> 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 (defaults to
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');
-> 2
mysql> 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)

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. D should be a constant value.

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'

 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');

-> 4
mysql> 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'

 LENGTH(str)

Returns the length of the string str, measured in bytes. A multi-byte

character counts as multiple bytes. This means that for a string containing
five two-byte characters, LENGTH() returns 10, whereas
CHAR_LENGTH() returns 5.

mysql> SELECT LENGTH('text');

-> 4

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

As of MySQL 5.0.19, 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');

-> 4
mysql> SELECT LOCATE('xbar', 'foobar');
-> 0
mysql> 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 single quote (“'”), backslash (“\”), ASCII NUL, and Control-Z
preceded by a backslash. If the argument is NULL, the return value is the word
“NULL” without enclosing single quotation marks.

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

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

 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:

o 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.
o 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'
 UPPER() is ineffective when applied to binary strings (BINARY, VARBINARY, BLOB).
The description of LOWER() shows how to perform lettercase conversion of binary
strings.

This function is multi-byte safe.

Date and Time Functions

This section describes the functions that can be used to manipulate temporal values. See
Section 10.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 11.12. Date/Time Functions

Name Description
ADDDATE() Add time values (intervals) to a date value
ADDTIME() Add time
CONVERT_TZ() Convert from one timezone to another
CURDATE() Return the current date
CURRENT_DATE(),
CURRENT_DATE
Synonyms for CURDATE()
CURRENT_TIME(),
CURRENT_TIME
Synonyms for CURTIME()
CURRENT_TIMESTAMP(),
CURRENT_TIMESTAMP
Synonyms for NOW()
CURTIME() Return the current time
DATE_ADD() Add time values (intervals) to a date value
DATE_FORMAT() Format date as specified
DATE_SUB() Subtract a time value (interval) from a date
DATE() Extract the date part of a date or datetime expression
DATEDIFF() Subtract two dates
DAY() Synonym for DAYOFMONTH()
DAYNAME() Return the name of the weekday
DAYOFMONTH() Return the day of the month (0-31)
DAYOFWEEK() Return the weekday index of the argument
DAYOFYEAR() Return the day of the year (1-366)
EXTRACT() Extract part of a date
FROM_DAYS() Convert a day number to a date
FROM_UNIXTIME() Format UNIX timestamp as a date
 Name Description
GET_FORMAT() Return a date format string
HOUR() Extract the hour
LAST_DAY Return the last day of the month for the argument
LOCALTIME(), LOCALTIME Synonym for NOW()
LOCALTIMESTAMP,
LOCALTIMESTAMP()
Synonym for NOW()
MAKEDATE() Create a date from the year and day of year
MAKETIME MAKETIME()
MICROSECOND() Return the microseconds from argument
MINUTE() Return the minute from the argument
MONTH() Return the month from the date passed
MONTHNAME() Return the name of the month
NOW() Return the current date and time
PERIOD_ADD() Add a period to a year-month
PERIOD_DIFF() Return the number of months between periods
QUARTER() Return the quarter from a date argument
SEC_TO_TIME() Converts seconds to 'HH:MM:SS' format
SECOND() Return the second (0-59)
STR_TO_DATE() Convert a string to a date
SUBDATE()
A synonym for DATE_SUB() when invoked with three
arguments
SUBTIME() Subtract times
SYSDATE() Return the time at which the function executes
TIME_FORMAT() Format as time
TIME_TO_SEC() Return the argument converted to seconds
TIME() Extract the time portion of the expression passed
TIMEDIFF() Subtract time
With a single argument, this function returns the date or
TIMESTAMP() datetime expression; with two arguments, the sum of the
arguments
TIMESTAMPADD() Add an interval to a datetime expression
TIMESTAMPDIFF() Subtract an interval from a datetime expression
TO_DAYS() Return the date argument converted to days
UNIX_TIMESTAMP() Return a UNIX timestamp
UTC_DATE() Return the current UTC date
UTC_TIME() Return the current UTC time
UTC_TIMESTAMP() Return the current UTC date and time
WEEK() Return the week number
WEEKDAY() Return the weekday index
WEEKOFYEAR() Return the calendar week of the date (0-53)
YEAR() Return the year
 Name Description
YEARWEEK() Return the year and week

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 9.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);

-> NULL
mysql> SELECT DAYNAME('2006-05-00');
-> NULL

 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 9.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 10.1.2, “Overview of Date and Time Types”.

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'

Note

To use named time zones such as 'MET' or 'Europe/Moscow', the time zone
tables must be properly set up. See Section 9.6, “MySQL Server Time Zone
Support”, for instructions.

Before MySQL 5.1.17, if you intend to use CONVERT_TZ() while other tables are
locked with LOCK TABLES, you must also lock the mysql.time_zone_name table. See
Section 12.3.5, “LOCK TABLES and UNLOCK TABLES Syntax”.

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

 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

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

 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');

-> 1
mysql> 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.

unit Value Expected expr Format

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

The return value depends on the arguments:

o 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.
o 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 unit

date - 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.5000
mysql> 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.5
mysql> 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);

-> NULL
mysql> 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.

Specifier Description
%a Abbreviated weekday name (Sun..Sat)
%b Abbreviated month name (Jan..Dec)
%c Month, numeric (0..12)
%D Day of the month with English suffix (0th, 1st, 2nd, 3rd, …)
%d Day of the month, numeric (00..31)
%e Day of the month, numeric (0..31)
%f Microseconds (000000..999999)
%H Hour (00..23)
%h Hour (01..12)
%I Hour (01..12)
%i Minutes, numeric (00..59)
%j Day of year (001..366)
%k Hour (0..23)
%l Hour (1..12)
%M Month name (January..December)
%m Month, numeric (00..12)
%p AM or PM
%r Time, 12-hour (hh:mm:ss followed by AM or PM)
%S Seconds (00..59)
%s Seconds (00..59)
%T Time, 24-hour (hh:mm:ss)
%U Week (00..53), where Sunday is the first day of the week
%u Week (00..53), where Monday is the first day of the week
%V Week (01..53), where Sunday is the first day of the week; used with %X
%v Week (01..53), where Monday is the first day of the week; used with %x
%W Weekday name (Sunday..Saturday)
%w Day of the week (0=Sunday..6=Saturday)
%X
Year for the week where Sunday is the first day of the week, numeric, four
digits; used with %V
%x
Year for the week, where Monday is the first day of the week, numeric, four
digits; used with %v
%Y Year, numeric, four digits
%y Year, numeric (two digits)
%% A literal “%” character
%x x, for any “x” not listed above

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

As of MySQL 5.1.12, the language used for day and month names and abbreviations
is controlled by the value of the lc_time_names system variable (Section 9.7,
“MySQL Server Locale Support”).

As of MySQL 5.1.15, 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. Before
5.1.15, the return value is a binary string.

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. As of MySQL 5.1.12, the language used
for the name is controlled by the value of the lc_time_names system variable
(Section 9.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');
-> 2009
mysql> SELECT EXTRACT(YEAR_MONTH FROM '2009-07-02 01:02:03');
-> 200907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '2009-07-02 01:02:03');
-> 20102
mysql> 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 11.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

begin_of_the_skype_highlighting              1196440219      end_of_t
he_skype_highlighting);
-> '2007-11-30 10:30:19'
mysql> SELECT FROM_UNIXTIME(1196440219
begin_of_the_skype_highlighting              1196440219      end_of_t
he_skype_highlighting) + 0;
-> 20071130103019.000000
mysql> 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.

Function Call Result

GET_FORMAT(DATE,'USA') '%m.%d.%Y'
GET_FORMAT(DATE,'JIS') '%Y-%m-%d'
GET_FORMAT(DATE,'ISO') '%Y-%m-%d'
GET_FORMAT(DATE,'EUR') '%d.%m.%Y'
GET_FORMAT(DATE,'INTERNAL') '%Y%m%d'
GET_FORMAT(DATETIME,'USA') '%Y-%m-%d %H.%i.%s'
GET_FORMAT(DATETIME,'JIS') '%Y-%m-%d %H:%i:%s'
GET_FORMAT(DATETIME,'ISO') '%Y-%m-%d %H:%i:%s'
GET_FORMAT(DATETIME,'EUR') '%Y-%m-%d %H.%i.%s'
GET_FORMAT(DATETIME,'INTERNAL') '%Y%m%d%H%i%s'
GET_FORMAT(TIME,'USA') '%h:%i:%s %p'
GET_FORMAT(TIME,'JIS') '%H:%i:%s'
GET_FORMAT(TIME,'ISO') '%H:%i:%s'
GET_FORMAT(TIME,'EUR') '%H.%i.%s'
GET_FORMAT(TIME,'INTERNAL') '%H%i%s'

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');

-> 10
mysql> 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');

-> 123456
mysql> 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. As of MySQL 5.1.12, the language used
for the name is controlled by the value of the lc_time_names system variable
(Section 9.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().

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');
-> NULL
mysql> 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 10.3.1, “The

DATETIME, DATE, 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.

Beginning with MySQL 5.1.42, a warning is logged if you use this function when
binlog_format is set to STATEMENT. (Bug#47995)

 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.1.42, 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.

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: FRAC_SECOND (microseconds), SECOND, MINUTE, HOUR,
DAY, WEEK, MONTH, QUARTER, or YEAR.

Beginning with MySQL 5.1.24, it is possible to use MICROSECOND in place of

FRAC_SECOND with this function, and FRAC_SECOND is deprecated. FRAC_SECOND is
removed in MySQL 5.5.

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');

-> 3
mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
-> -1
mysql> 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');

-> 80580
mysql> 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);

-> 728779
mysql> 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 11.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 10.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.

 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 9.6, “MySQL Server Time Zone Support”.

mysql> SELECT UNIX_TIMESTAMP();

-> 1196440210
begin_of_the_skype_highlighting              1196440210      end_of_t
he_skype_highlighting
mysql> SELECT UNIX_TIMESTAMP('2007-11-30 10:30:19');
-> 1196440219
begin_of_the_skype_highlighting              1196440219      end_of_t
he_skype_highlighting

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
begin_of_the_skype_highlighting              1111885200      end_of_t
he_skype_highlighting |
+---------------------------------------+
mysql> SELECT UNIX_TIMESTAMP('2005-03-27 02:00:00');
+---------------------------------------+
| UNIX_TIMESTAMP('2005-03-27 02:00:00') |
+---------------------------------------+
| 1111885200
begin_of_the_skype_highlighting              1111885200      end_of_t
he_skype_highlighting |
+---------------------------------------+
 mysql> SELECT FROM_UNIXTIME(1111885200
begin_of_the_skype_highlighting              1111885200      end_of_t
he_skype_highlighting);
+---------------------------+
| FROM_UNIXTIME(1111885200
begin_of_the_skype_highlighting              1111885200      end_of_t
he_skype_highlighting) |
+---------------------------+
| 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 11.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.

Mode First day of week Range Week 1 is the first week …

0 Sunday 0-53 with a Sunday in this year
 1 Monday 0-53 with more than 3 days this year
2 Sunday 1-53 with a Sunday in this year
3 Monday 1-53 with more than 3 days this year
4 Sunday 0-53 with more than 3 days this year
5 Monday 0-53 with a Monday in this year
6 Sunday 1-53 with more than 3 days this year
7 Monday 1-53 with a Monday in this year
mysql> SELECT WEEK('2008-02-20');
-> 7
mysql> SELECT WEEK('2008-02-20',0);
-> 7
mysql> SELECT WEEK('2008-02-20',1);
-> 8
mysql> 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');

-> 199952
mysql> 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');

-> 6
mysql> 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.

SEQUENCE-

A sequence is a set of integers 1, 2, 3, ... that are generated in order on demand. Sequences
are frequently used in databases because many applications require each row in a table to
contain a unique value, and sequences provide an easy way to generate them. This chapter
describes how to use sequences in MySQL.

Using AUTO_INCREMENT column:

The simplest way in MySQL to use Sequences is to define a column as
AUTO_INCREMENT and leave rest of the things to MySQL to take care.

Example:
Try out following example. This will create table and after that it will insert few rows in this
table where it is not required to give record ID because its auto incremented by MySQL.

mysql> CREATE TABLE insect

-> (
-> id INT UNSIGNED NOT NULL AUTO_INCREMENT,
-> PRIMARY KEY (id),
-> name VARCHAR(30) NOT NULL, # type of insect
 -> date DATE NOT NULL, # date collected
-> origin VARCHAR(30) NOT NULL # where collected
);
Query OK, 0 rows affected (0.02 sec)
mysql> INSERT INTO insect (id,name,date,origin) VALUES
-> (NULL,'housefly','2001-09-10','kitchen'),
-> (NULL,'millipede','2001-09-10','driveway'),
-> (NULL,'grasshopper','2001-09-10','front yard');
Query OK, 3 rows affected (0.02 sec)
Records: 3 Duplicates: 0 Warnings: 0
mysql> SELECT * FROM insect ORDER BY id;
+----+-------------+------------+------------+
| id | name | date | origin |
+----+-------------+------------+------------+
| 1 | housefly | 2001-09-10 | kitchen |
| 2 | millipede | 2001-09-10 | driveway |
| 3 | grasshopper | 2001-09-10 | front yard |
+----+-------------+------------+------------+
3 rows in set (0.00 sec)

MYSQL AND WEB

MySQL has become the #1 database choice for delivering online applications. MySQL
powers more online applications than any other database in the world including such high
profile web sites as: Yahoo!, Google, Flickr, YouTube, Wikipedia and thousands of corporate
online applications.

Why? Because MySQL is easy, safe, reliable, cost-effective, and very fast! With MySQL
Enterprise you can:

 Deliver your online application in a matters of hours, not days or weeks

 Implement a modern infrastructure leveraging the popular open source LAMP stack
(Linux, Apache, MySQL, PHP/Perl/Python)
 Scale your applications without limit
 Significantly reduce your TCO by minimizing your initial investment and keeping
costs low over time
 Reduce administrative overhead with an easy to use database that just works!
 Get fast answers and assistance when you need it

Record Selection Technology

 View
 Edit

Select Data From a Database Table

The SELECT statement is used to select data from a database.

Syntax

1. SELECT column_name(s)
 2. FROM table_name

To learn more about SQL, please visit our SQL tutorial.

To get PHP to execute the statement above we must use the mysql_query() function. This
function is used to send a query or command to a MySQL connection.

Example

The following example selects all the data stored in the "Persons" table (The * character
selects all the data in the table):

1. &lt;?php
2. $con = mysql_connect("localhost","peter","abc123");
3. if (!$con)
4. {
5. die('Could not connect: ' . mysql_error());
6. }
7.  
8. mysql_select_db("my_db", $con);
9.  
10. $result = mysql_query("SELECT * FROM Persons");
11.  
12. while($row = mysql_fetch_array($result))
13. {
14. echo $row['FirstName'] . " " . $row['LastName'];
15. echo "<br />";
16. }
17.  
18. mysql_close($con);
19. ?&gt;

The example above stores the data returned by the mysql_query() function in the $result
variable.

Next, we use the mysql_fetch_array() function to return the first row from the recordset as an
array. Each call to mysql_fetch_array() returns the next row in the recordset. The while loop
loops through all the records in the recordset. To print the value of each row, we use the PHP
$row variable ($row['FirstName'] and $row['LastName']).

The output of the code above will be:

1. Peter Griffin
2. Glenn Quagmire

Display the Result in an HTML Table

The following example selects the same data as the example above, but will display the data
in an HTML table:
 

1. &lt;?php
2. $con = mysql_connect("localhost","peter","abc123");
3. if (!$con)
4. {
5. die('Could not connect: ' . mysql_error());
6. }
7.  
8. mysql_select_db("my_db", $con);
9.  
10. $result = mysql_query("SELECT * FROM Persons");
11.  
12. echo "<table border='1'>
13. <tr>
14. <th>Firstname</th>
15. <th>Lastname</th>
16. </tr>";
17.  
18. while($row = mysql_fetch_array($result))
19. {
20. echo "<tr>";
21. echo "<td>" . $row['FirstName'] . "</td>";
22. echo "<td>" . $row['LastName'] . "</td>";
23. echo "</tr>";
24. }
25. echo "</table>";
26.  
27. mysql_close($con);
28. ?&gt;

The output of the code above will be:

Firstname Lastname

Glenn Quagmire
Peter Griffin

PHP…..
Operators :
There are many operators used in PHP, so we have separated them into the following
categories to make it easier to learn them all.

 Assignment Operators
 Arithmetic Operators
 Comparison Operators
 String Operators
 Combination Arithmetic & Assignment Operators

Assignment Operators:
Assignment operators are used to set a variable equal to a value or set a variable to another
variable's value. Such an assignment of value is done with the "=", or equal character.
Example:

 $my_var = 4;
 $another_var = $my_var;

1. <?php
2.  
3. $a = 3;
4. $a += 5; // sets $a to 8, as if we had said: $a = $a + 5;
5. $b = "Hello ";
6. $b .= "There!"; // sets $b to "Hello There!", just like $b = $b .
"There!";
7.  
8. ?>

Now both $my_var and $another_var contain the value 4. Assignments can also be used in
conjunction with arithmetic operators.

Arithmetic Operators:

Operator English Example

+ Addition 2+4
- Subtraction 6 - 2
* Multiplication 5 * 3
/ Division 15 / 3
% Modulus 43 % 10

PHP Code:

1. <?php
2. $addition = 2 + 4;
3. $subtraction = 6 - 2;
4. $multiplication = 5 * 3;
5. $division = 15 / 3;
6. $modulus = 5 % 2;
7. echo "Perform addition: 2 + 4 = ".$addition."<br />";
8. echo "Perform subtraction: 6 - 2 = ".$subtraction."<br />";
9. echo "Perform multiplication: 5 * 3 = ".$multiplication."<br />";
10. echo "Perform division: 15 / 3 = ".$division."<br />";
11. echo "Perform modulus: 5 % 2 = " . $modulus
12. . ". Modulus is the remainder after the division operation
has been performed.
13. In this case it was 5 / 2, which has a remainder of 1.";
14. ?>

Display:

Perform addition: 2 + 4 = 6
Perform subtraction: 6 - 2 = 4
Perform multiplication: 5 * 3 = 15
Perform division: 15 / 3 = 5
Perform modulus: 5 % 2 = 1. Modulus is the remainder after the division operation has been
performed. In this case it was 5 / 2, which has a remainder of 1.

Comparison Operators:

Comparisons are used to check the relationship between variables and/or values. If you would
like to see a simple example of a comparison operator in action, check out our If Statement
Lesson. Comparison operators are used inside conditional statements and evaluate to either
true or false. Here are the most important comparison operators of PHP.
Assume: $x = 4 and $y = 5;
Exampl
Operator English Result
e
== Equal To $x == $y false
!= Not Equal To $x != $y true
< Less Than $x < $y true
>  Greater Than $x > $y false
<= Less Than or Equal To $x <= $y true
Greater Than or Equal
>= $x >= $y false
To

String Operators:

As we have already seen in the Echo Lesson, the period "." is used to add two strings
together, or more technically, the period is the concatenation operator for strings.

PHP Code:

1. <?php
2. $a_string = "Hello";
3.  
4. $another_string = " Billy";
5.  
6. $new_string = $a_string . $another_string;
7.  
8. echo $new_string . "!";
9. ?>

Display:

Hello Billy!

Combination Arithmetic & Assignment Operators:

In programming it is a very common task to have to increment a variable by some fixed

amount. The most common example of this is a counter. Say you want to increment a counter
by 1, you would have:
  $counter = $counter + 1;

However, there is a shorthand for doing this.

 $counter += 1;

This combination assignment/arithmetic operator would accomplish the same task. The
downside to this combination operator is that it reduces code readability to those
programmers who are not used to such an operator. Here are some examples of other
common shorthand operators. In general, "+=" and "-=" are the most widely used
combination operators.
Operator English Example Equivalent Operation
+= Plus Equals $x += 2; $x = $x + 2;
-= Minus Equals $x -= 4; $x = $x - 4;
*= Multiply Equals $x *= 3; $x = $x * 3;
/= Divide Equals $x /= 2; $x = $x / 2;
%= Modulo Equals $x %= 5; $x = $x % 5;
.= Concatenate Equals $my_str.="hello"; $my_str = $my_str . "hello";

Pre/Post-Increment & Pre/Post-Decrement:

This may seem a bit absurd, but there is even a shorter shorthand for the common task of
adding 1 or subtracting 1 from a variable. To add one to a variable or "increment" use the "+
+" operator:

 $x++; Which is equivalent to $x += 1; or $x = $x + 1;

To subtract 1 from a variable, or "decrement" use the "--" operator:

 $x--; Which is equivalent to $x -= 1; or $x = $x - 1;

In addition to this "shorterhand" technique, you can specify whether you want to increment
before the line of code is being executed or after the line has executed. Our PHP code below
will display the difference.
PHP Code:

1. <?php
2. $x = 4;
3.  
4. echo "The value of x with post-plusplus = " . $x++;
5.  
6. echo "<br /> The value of x after the post-plusplus is " . $x;
7.  
8. $x = 4;
9.  
10. echo "<br />The value of x with with pre-plusplus = " . ++$x;
11.  
12. echo "<br /> The value of x after the pre-plusplus is " . $x;
13. ?>
Display:

The value of x with post-plusplus = 4

The value of x after the post-plusplus is = 5
The value of x with with pre-plusplus = 5
The value of x after the pre-plusplus is = 5

Manipulating and Searching Strings

 View
 Edit

Searching a String:

strpos()

             The way strpos works is it takes some string you want to search in as its first
argument and another string, which is what you are actually searching for, as the second
argument. If the function can find a search match, then it will return the position of the first
match. However, if it can't find a match it will return false.

Example:

1. <?php
2. $mystring = 'abc';
3. $findme = 'a';
4. $pos = strpos($mystring, $findme);
5.  
6. // The !== operator can also be used. Using != would not work as
expected
7. // because the position of 'a' is 0. The statement (0 != false)
evaluates
8. // to false.
9. if ($pos !== false) {
10. echo "The string '$findme' was found in the string
'$mystring'";
11. echo " and exists at position $pos";
12. } else {
13. echo "The string '$findme' was not found in the string
'$mystring'";
14. }
15. ?>

str_replace()

                The str_replace function is similar to a word processor's "Replace All" command
that lets you specify a word and what to replace it with, then replaces every occurrence of that
word in the document.
str_replace Parameters:

                str_replace has three parameters that are required for the function to work properly.
str_replace(search, replace, originalString).

1. search - This is what you want to search your string for. This can be a string or an array.
2. replace - All matches for search will be replaced with this value. This can be a string or an
array.
3. originalString - This is what search and replace will be operating on. The str_replace function
will return a modified version of originalString when it completes.

Example:

1. <?php
2. // Provides: <body text='black'>
3. $bodytag = str_replace("%body%", "black", "<body text='%body%'>");
4.  
5. // Provides: Hll Wrld f PHP
6. $vowels = array("a", "e", "i", "o", "u", "A", "E", "I", "O", "U");
7. $onlyconsonants = str_replace($vowels, "", "Hello World of PHP");
8.  
9. // Provides: You should eat pizza, beer, and ice cream every day
10. $phrase = "You should eat fruits, vegetables, and fiber every
day.";
11. $healthy = array("fruits", "vegetables", "fiber");
12. $yummy = array("pizza", "beer", "ice cream");
13.  
14. $newphrase = str_replace($healthy, $yummy, $phrase);
15.  
16. // Use of the count parameter is available as of PHP 5.0.0
17. $str = str_replace("ll", "", "good golly miss molly!", $count);
18. echo $count; // 2
19.  
20. // Order of replacement
21. $str = "Line 1\nLine 2\rLine 3\r\nLine 4\n";
22. $order = array("\r\n", "\n", "\r");
23. $replace = '<br />';
24. // Processes \r\n's first so they aren't converted twice.
25. $newstr = str_replace($order, $replace, $str);
26.  
27. // Outputs: apearpearle pear
28. $letters = array('a', 'p');
29. $fruit = array('apple', 'pear');
30. $text = 'a p';
31. $output = str_replace($letters, $fruit, $text);
32. echo $output;
33. ?>

substr_replace()

                The function substr_replace introduces some additional functionality to

compliment str_replace. substr_replace is a more mathematically based replace function,
which relies on starting points and lengths to replace parts of strings, as opposed to searching
and replacing.
               There are three required parameters for the substr_replace function (original string,
replacement string, starting point) and one that's optional (length).

1. original string - This is your original string that will be operated on.
2. replacement string - This string will be used to replace everything in the string from the
starting point to the ending point (specified by length).
3. starting point - This is the place in the original string that will be used to mark the
replacement's beginning. A negative value specifies the number of characters from the end
of the string.
4. optional length - How many characters from the original string will be replaced. If no length
is specified then the end of the string is used. If a value of 0 is used then no characters will
be replaced and an insert is performed. A negative value specifies the number of characters
from the end of the string.

Example:

1. <?php
2. $var = 'ABCDEFGH:/MNRPQR/';
3. echo "Original: $var<hr />\n";
4.  
5. /* These two examples replace all of $var with 'bob'. */
6. echo substr_replace($var, 'bob', 0) . "<br />\n";
7. echo substr_replace($var, 'bob', 0, strlen($var)) . "<br />\n";
8.  
9. /* Insert 'bob' right at the beginning of $var. */
10. echo substr_replace($var, 'bob', 0, 0) . "<br />\n";
11.  
12. /* These next two replace 'MNRPQR' in $var with 'bob'. */
13. echo substr_replace($var, 'bob', 10, -1) . "<br />\n";
14. echo substr_replace($var, 'bob', -7, -1) . "<br />\n";
15.  
16. /* Delete 'MNRPQR' from $var. */
17. echo substr_replace($var, '', 10, -1) . "<br />\n";
18. ?>

PHP - String Capitalization Functions

              If you've ever wanted to manipulate the capitalization of your PHP strings, then this
lesson will be quite helpful to you. PHP has three primary capitalization related functions:
strtoupper, strtolower and ucwords. The function names are pretty self-explanatory, but why
they are useful in programming might be new to you.

strtoupper()

             The strtoupper function takes one argument, the string you want converted to upper
case and returns the converted string. Only letters of the alphabet are changed, numbers will
remain the same.

Example:

 
 1. <?php
2. $str = "Mary Had A Little Lamb and She LOVED It So";
3. $str = strtoupper($str);
4. echo $str; // Prints MARY HAD A LITTLE LAMB AND SHE LOVED IT SO
5. ?>

strtolower()

              The strtolower function also has one argument: the string that will be converted to
lower case.

Example:

1. <?php
2. $str = "Mary Had A Little Lamb and She LOVED It So";
3. $str = strtolower($str);
4. echo $str; // Prints mary had a little lamb and she loved it so
5. ?>

ucwords()

               Titles of various media types often capitalize the first letter of each word and PHP
has a time-saving function that will do just this.

Example:

1. <?php
2. $foo = 'hello world!';
3. $foo = ucwords($foo); // Hello World!
4.  
5. $bar = 'HELLO WORLD!';
6. $bar = ucwords($bar); // HELLO WORLD!
7. $bar = ucwords(strtolower($bar)); // Hello World!
8. ?>

Error Handling Functions

See Also

See also syslog().

Table of Contents
  debug_backtrace — Generates a backtrace
 debug_print_backtrace — Prints a backtrace
 error_get_last — Get the last occurred error
 error_log — Send an error message somewhere
 error_reporting — Sets which PHP errors are reported
 restore_error_handler — Restores the previous error handler function
 restore_exception_handler — Restores the previously defined exception handler function
 set_error_handler — Sets a user-defined error handler function
 set_exception_handler — Sets a user-defined exception handler function
 trigger_error — Generates a user-level error/warning/notice message
 user_error — Alias of trigger_error

Security
. The overall proportion of PHP-related vulnerabilities on the database amounted to: 20% in
2004, 28% in 2005, 43% in 2006, 36% in 2007, 35% in 2008, and 30% in 2009.[43] Most of
these PHP-related vulnerabilities can be exploited remotely: they allow crackers to steal or
destroy data from data sources linked to the webserver (such as an SQL database), send spam
or contribute to DoS attacks using malware, which itself can be installed on the vulnerable
servers.

These vulnerabilities are caused mostly by not following best practice programming rules:
technical security flaws of the language itself or of its core libraries are not frequent (23 in
2008, about 1% of the total). [44][45]

Hosting PHP applications on a server requires a careful and constant attention to deal with
these security risks.[49] There are advanced protection patches such as Suhosin and Hardening-
Patch, especially designed for web hosting environments.[

PHP Templates
This note describes a PHP templating scheme where

1. Each template file contains a full HTML document, so that a designer can edit the template
file in a WYSIWYG tool like Dreamweaver. There is no need to store fragments of the HTML
template out of context in separate files.
2. Content files are primarily HTML with small embedded PHP scripts. There is no need to put
large chunks of HTML content in PHP strings, such as assigning to a 'content' template
variable.

We use the Template class provided in the template.inc file shipped with PHPlib.

Example files
page.ihtml -- A template file

<!-- BEGIN header -->

<html>
 <head>
<title>{TITLE}</title>
</head>
<body>
<h1>{TITLE}</h1>
<hr>
<!-- END header -->

{CONTENT}

<!-- BEGIN footer -->

<hr>
<address>[email protected]</address>
<!-- END footer -->

The first BEGIN and END comment lines define a block named header, and the second such
lines delimit a similar footer block. The template has variables for TITLE and CONTENT.

Our example will use the blocks, not the file as a whole, so the CONTENT variable part will be
unused since it is outside of any block. In fact, it might be useful to put some representative
text (Lorem ipsum...) in that place so that the page-layout designer sees how that section will
be formatted.

example1.php3 -- A content file using the template

<?php
include("template.inc");
$t = new Template(".", "keep");
$t->set_file('page', "page.ihtml");
$t->set_var('TITLE', "An Example Generated File");

$t->set_block('page', 'header');
// The 'header' block has been extracted from the 'page' template and
// saved as a template variable also named 'header'.
$t->pparse('out', 'header');
// header has been output.
?>

<h3>Arbitrary HTML and PHP content here</h3>

yada, yada, yada
... lots more HTML content goes here ...

<?
$t->set_block('page', 'footer');
$t->pparse('out', 'footer');
// footer has been output
?>

This typical content file loads a page template variable with the entire contents of the
template file, then (the key point of this note) it calls set_block() to extract the header
block from the page template and save it as the header template variable. Note that page is
never output as a whole -- it is only a source for extracting the header and footer blocks.