MYSQL 날짜관련함수
- DAYOFWEEK(date) : 해당 날짜의 요일을 숫자로 반환한다. 일요일은 1, 토요일은 7 이다.
- 예 : select DAYOFWEEK('1998-02-03');
- WEEKDAY(date) : 해당 날짜에 대한 요일을 반환한다. 월요일은 0, 일요일은 6 이다.
- 예 : select WEEKDAY('1997-10-04 22:23:00');
- DAYOFYEAR(date) : 해당 날짜의 1월 1일부터의 날수를 반환한다. 결과값은 1에서 366 까지이다.
- 예 : select DAYOFYEAR('1998-02-03');
- YEAR(date) : 해당 날짜의 년을 반환한다.
- 예 : select YEAR('98-02-03');
- MONTH(date) : 해당 날짜의 월을 반환한다.
- 예 : select MONTH('1998-02-03');
- DAYOFMONTH(date) : 해당 날짜의 일을 반환한다. 결과값은 1 에서 31 까지이다.
- 예 : select DAYOFMONTH('1998-02-03');
- HOUR(time) : 해당날짜의 시간을 반환한다. 결과값은 0 에서 23 이다.
- 예 : select HOUR('10:05:03');
- MINUTE(time) : 해당날짜의 분을 반환한다. 결과값은 0 에서 59 이다.
- 예 : select MINUTE('98-02-03 10:05:03');
- SECOND(time) : 해당날짜의 초를 반환한다. 결과값은 0 에서 59 이다.
- 예 : select SECOND('10:05:03');
- DAYNAME(date) : 해당 날짜의 요일 이름을 반환한다. 일요일은 'Sunday' 이다.
- 예 : select DAYNAME("1998-02-05");
- MONTHNAME(date) : 해당 날짜의 월 이름을 반환한다. 2월은 'February' 이다.
- 예 : select MONTHNAME("1998-02-05");
- QUARTER(date) : 해당 날짜의 분기를 반환한다. 결과값은 1 에서 4 이다.
- WEEK(date,first) : 1월 1일부터 해당날가지의 주 수를 반환한다. 주의 시작을 일요일부터 할경우는 두번째 인자를 0, 월요일부터 시작할 경우는 1 을 넣는다. 결과값은 1 에서 52 이다.
- 예 : select WEEK('1998-02-20',1);
- PERIOD_ADD(P,N) : P (형식은 YYMM 또는 YYYYMM 이어야 한다.) 에 N 만큼의 달 수를 더한값을 반환한다. 주의할것은 두번째 인자는 숫자라는 것이다.
- 예 : select PERIOD_ADD(9801,2);
- PERIOD_DIFF(P1,P2) : 두개의 인자 사이의 달 수를 반환한다. 두개의 인자 모두 형식은 YYMM 또는 YYYYMM 이어야 한다.
- DATE_ADD(date,INTERVAL expr type) : 날짜를 더한 날짜를 반환한다.
- DATE_SUB(date,INTERVAL expr type) : 날짜를 뺀 날짜를 반환한다.
- ADDDATE(date,INTERVAL expr type) : DATE_ADD(date,INTERVAL expr type) 와 동일하다.
- SUBDATE(date,INTERVAL expr type) : DATE_SUB(date,INTERVAL expr type) 와 동일하다.
- EXTRACT(type FROM date) : 날짜에서 해당 부분을 추출한다.
- 예 : SELECT DATE_ADD("1997-12-31 23:59:59", INTERVAL 1 SECOND);
SELECT DATE_ADD("1997-12-31 23:59:59", INTERVAL 1 DAY);
SELECT DATE_ADD("1997-12-31 23:59:59", INTERVAL "1:1" MINUTE_SECOND);
SELECT DATE_SUB("1998-01-01 00:00:00", INTERVAL "1 1:1:1" DAY_SECOND);
SELECT DATE_ADD("1998-01-01 00:00:00", INTERVAL "-1 10" DAY_HOUR);
SELECT DATE_SUB("1998-01-02", INTERVAL 31 DAY);
SELECT EXTRACT(YEAR FROM "1999-07-02");
SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03");
SELECT EXTRACT(DAY_MINUTE FROM "1999-07-02 01:02:03");
- 참고 : type 에 사용되는 키워드는 SECOND, MINUTE, HOUR, DAY, MONTH, YEAR, MINUTE_SECOND, HOUR_MINUTE, DAY_HOUR, YEAR_MONTH, HOUR_SECOND, DAY_MINUTE, DAY_SECOND 이다.
- 주의 : 계산한 달의 날수가 작을 경우는 해당달의 마지막 날을 반환한다. 예를 들어 select DATE_ADD('1998-01-30', Interval 1 month); 의 경우 1998-02-28 을 반환한다.
- TO_DAYS(date) : 0 년 부터의 날짜수를 반환한다. 이 함수는 1582 이전 날에 대해서는 계산하지 않는다.
- 예 : select TO_DAYS(950501);
- FROM_DAYS(N) : 해당 숫자만큼의 날짜를 반환한다. 이 함수는 1582 이전 날에 대해서는 계산하지 않는다.
- 예 : select FROM_DAYS(729669);
- DATE_FORMAT(date,format) : 날짜를 해당 형식의 문자열로 변환하여 반환한다.
- 예 : select DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
select DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
select DATE_FORMAT('1997-10-04 22:23:00', '%D %y %a %d %m %b %j');
select DATE_FORMAT('1997-10-04 22:23:00', '%H %k %I %r %T %S %w');
- 참고 : 형식은 다음과 같다.
%M (달 이름),
%W (요일 이름),
%Y (YYYY 형식의 년도),
%y (YY 형식의 년도),
%a (요일 이름의 약자),
%d (DD 형식의 날짜),
%e (D 형식의 날짜),
%m (MM 형식의 날짜),
%c (M 형식의 날짜),
%H (HH 형식의 시간, 24시간 형식),
%k (H 형식의 시간, 24시간 형식),
%h (HH 형식의 시간, 12시간 형식),
%i (MM 형식의 분),
%p (AM 또는 PM)
- TIME_FORMAT(time,format) : DATE_FORMAT(date,format) 과 같은 방식으로 사용할수 있으나 날 이상의 것에 대해서는 NULL 이나 0 을 반환한다.
- CURDATE() : 현재날짜를 반환한다. 숫자와 연산을 할경우 숫자로 변환된다. 형식은 'YYYY-MM-DD' 또는 YYYYMMDD 이다.
- 예 : select CURDATE();
select CURDATE() + 0;
- CURTIME() : 현재시간을 반환한다. 숫자와 연산을 할경우 숫자로 변환된다. 형식은 'HH:MM:SS' 또는 HHMMSS 이다.
- 예 : select CURTIME();
select CURTIME() + 0;
- SYSDATE() : 현재날짜시간을 반환한다. 숫자와 연산을 할경우 숫자로 변환된다. 형식은 'YYYY-MM-DD HH:MM:SS' 또는 YYYYMMDDHHMMSS 이다.
- 예 : select NOW();
select NOW() + 0;
- NOW() : SYSDATE() 와 동일하다.
- UNIX_TIMESTAMP() : '1970-01-01 00:00:00' 부터의 초를 반환한다. 인자가 주어질 경우는 해당 날짜에 대한 유닉스 시간을 반환한다.
- 예 : select UNIX_TIMESTAMP();
select UNIX_TIMESTAMP('1997-10-04 22:23:00');
- FROM_UNIXTIME(unix_timestamp) : 유닉스시간에서 날짜 형식으로 변환한다.
- 예 : select FROM_UNIXTIME(875996580);
- FROM_UNIXTIME(unix_timestamp,format) : 유닉스시간을 날짜형식으로 변환하고 DATE_FORMAT(date,format) 에서 설명한 포맷으로 변환하여 반환한다.
- 예 : select FROM_UNIXTIME(UNIX_TIMESTAMP(), '%Y %D %M %h:%i:%s %x');
- TIME_TO_SEC(time) : 해당 시간의 0:0:0 에서부터의 초를 반환한다.
- 예 : select TIME_TO_SEC('22:23:00');
- SEC_TO_TIME(seconds) : 초를 시간으로 바꾼다.
- 예 : select SEC_TO_TIME(2378);
12.5. 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.
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;
Note that 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 routine or trigger and all sub-routines called by that routine/trigger). 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 5.11.8, “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. 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 type), ADDDATE(expr,days)
When invoked with the INTERVAL form of the second argument, ADDDATE() is a synonym for DATE_ADD(). The related function SUBDATE() is a synonym for DATE_SUB(). For information on the INTERVAL argument, see the discussion for DATE_ADD().
mysql> SELECT DATE_ADD('1998-01-02', INTERVAL 31 DAY);
-> '1998-02-02'
mysql> SELECT ADDDATE('1998-01-02', INTERVAL 31 DAY);
-> '1998-02-02'
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('1998-01-02', 31);
-> '1998-02-02'
ADDTIME(expr,expr2)
ADDTIME() adds expr2 to expr and returns the result. expr is a time or datetime expression, and expr2 is a time expression.
mysql> SELECT ADDTIME('1997-12-31 23:59:59.999999',
-> '1 1:1:1.000002');
-> '1998-01-02 01:01:01.000001'
mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
-> '03:00:01.999997'
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 5.11.8, “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 fom from_tz to UTC, no conversion occurs. The TIMESTAMP range is described in Section 11.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 5.11.8, “MySQL Server Time Zone Support”, for instructions.
CURDATE()
Returns the current date as a value in 'YYYY-MM-DD' or YYYYMMDD format, depending on whether the function is used in a string or numeric context.
mysql> SELECT CURDATE();
-> '1997-12-15'
mysql> SELECT CURDATE() + 0;
-> 19971215
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 format, depending on whether the function is used in a string or numeric context.
mysql> SELECT CURTIME();
-> '23:50:26'
mysql> SELECT CURTIME() + 0;
-> 235026
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(expr,expr2)
DATEDIFF() returns the number of days between the start date expr and the end date expr2. expr and expr2 are date or date-and-time expressions. Only the date parts of the values are used in the calculation.
mysql> SELECT DATEDIFF('1997-12-31 23:59:59','1997-12-30');
-> 1
mysql> SELECT DATEDIFF('1997-11-30 23:59:59','1997-12-31');
-> -31
DATE_ADD(date,INTERVAL expr type), DATE_SUB(date,INTERVAL expr type)
These functions perform date arithmetic. date is a DATETIME or DATE value specifying the starting date. expr is an expression specifying the interval value to be added or subtracted from the starting date. expr is a string; it may start with a ‘-’ for negative intervals. type is a keyword indicating how the expression should be interpreted.
The INTERVAL keyword and the type specifier are not case sensitive.
The following table shows the expected form of the expr argument for each type value.
type Value Expected expr Format
MICROSECOND MICROSECONDS
SECOND SECONDS
MINUTE MINUTES
HOUR HOURS
DAY DAYS
WEEK WEEKS
MONTH MONTHS
QUARTER QUARTERS
YEAR YEARS
SECOND_MICROSECOND 'SECONDS.MICROSECONDS'
MINUTE_MICROSECOND 'MINUTES.MICROSECONDS'
MINUTE_SECOND 'MINUTES:SECONDS'
HOUR_MICROSECOND 'HOURS.MICROSECONDS'
HOUR_SECOND 'HOURS:MINUTES:SECONDS'
HOUR_MINUTE 'HOURS:MINUTES'
DAY_MICROSECOND 'DAYS.MICROSECONDS'
DAY_SECOND 'DAYS HOURS:MINUTES:SECONDS'
DAY_MINUTE 'DAYS HOURS:MINUTES'
DAY_HOUR 'DAYS HOURS'
YEAR_MONTH 'YEARS-MONTHS'
The values QUARTER and WEEK are available beginning with MySQL 5.0.0.
MySQL allows any punctuation delimiter in the expr format. Those shown in the table are the suggested delimiters. If the date argument is a DATE value and your calculations involve only YEAR, MONTH, and DAY parts (that is, no time parts), the result is a DATE value. Otherwise, the result is a DATETIME value.
Date arithmetic also can be performed using INTERVAL together with the + or - operator:
date + INTERVAL expr type
date - INTERVAL expr type
INTERVAL expr type is allowed on either side of the + operator if the expression on the other side is a date or datetime value. For the - operator, INTERVAL expr type is allowed only on the right side, because it makes no sense to subtract a date or datetime value from an interval.
mysql> SELECT '1997-12-31 23:59:59' + INTERVAL 1 SECOND;
-> '1998-01-01 00:00:00'
mysql> SELECT INTERVAL 1 DAY + '1997-12-31';
-> '1998-01-01'
mysql> SELECT '1998-01-01' - INTERVAL 1 SECOND;
-> '1997-12-31 23:59:59'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL 1 SECOND);
-> '1998-01-01 00:00:00'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL 1 DAY);
-> '1998-01-01 23:59:59'
mysql> SELECT DATE_ADD('1997-12-31 23:59:59',
-> INTERVAL '1:1' MINUTE_SECOND);
-> '1998-01-01 00:01:00'
mysql> SELECT DATE_SUB('1998-01-01 00:00:00',
-> INTERVAL '1 1:1:1' DAY_SECOND);
-> '1997-12-30 22:58:59'
mysql> SELECT DATE_ADD('1998-01-01 00:00:00',
-> INTERVAL '-1 10' DAY_HOUR);
-> '1997-12-30 14:00:00'
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'
mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
-> INTERVAL '1.999999' SECOND_MICROSECOND);
-> '1993-01-01 00:00:01.000001'
If you specify an interval value that is too short (does not include all the interval parts that would be expected from the type keyword), MySQL assumes that you have left out the leftmost parts of the interval value. For example, if you specify a type of DAY_SECOND, the value of expr is expected to have days, hours, minutes, and seconds parts. If you specify a value like '1:10', MySQL assumes that the days and hours parts are missing and the value represents minutes and seconds. In other words, '1:10' DAY_SECOND is interpreted in such a way that it is equivalent to '1:10' MINUTE_SECOND. This is analogous to the way that MySQL interprets TIME values as representing elapsed time rather than as a time of day.
If you add to or subtract from a date value something that contains a time part, the result is automatically converted to a datetime value:
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 DAY);
-> '1999-01-02'
mysql> SELECT DATE_ADD('1999-01-01', INTERVAL 1 HOUR);
-> '1999-01-01 01:00:00'
If you add MONTH, YEAR_MONTH, or YEAR and the resulting date has a day that is larger than the maximum day for the new month, the day is adjusted to the maximum days in the new month:
mysql> SELECT DATE_ADD('1998-01-30', INTERVAL 1 MONTH);
-> '1998-02-28'
Date arithmetic operations require complete dates and do not work with incomplete dates such as '2005-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 allows the storing of incomplete dates such as '2004-00-00'.
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%W %M %Y');
-> 'Saturday October 1997'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00', '%H:%i:%s');
-> '22:23:00'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
'%D %y %a %d %m %b %j');
-> '4th 97 Sat 04 10 Oct 277'
mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
'%H %k %I %r %T %S %w');
-> '22 22 10 10:23:00 PM 22:23:00 00 6'
mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
-> '1998 52'
mysql> SELECT DATE_FORMAT('2006-06-00', '%d');
-> '00'
DAY(date)
DAY() is a synonym for DAYOFMONTH().
DAYNAME(date)
Returns the name of the weekday for date.
mysql> SELECT DAYNAME('1998-02-05');
-> 'Thursday'
DAYOFMONTH(date)
Returns the day of the month for date, in the range 0 to 31.
mysql> SELECT DAYOFMONTH('1998-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('1998-02-03');
-> 3
DAYOFYEAR(date)
Returns the day of the year for date, in the range 1 to 366.
mysql> SELECT DAYOFYEAR('1998-02-03');
-> 34
EXTRACT(type FROM date)
The EXTRACT() function uses the same kinds of interval type specifiers as DATE_ADD() or DATE_SUB(), but extracts parts from the date rather than performing date arithmetic.
mysql> SELECT EXTRACT(YEAR FROM '1999-07-02');
-> 1999
mysql> SELECT EXTRACT(YEAR_MONTH FROM '1999-07-02 01:02:03');
-> 199907
mysql> SELECT EXTRACT(DAY_MINUTE FROM '1999-07-02 01:02:03');
-> 20102
mysql> SELECT EXTRACT(MICROSECOND
-> FROM '2003-01-02 10:30:00.00123');
-> 123
FROM_DAYS(N)
Given a day number N, returns a DATE value.
mysql> SELECT FROM_DAYS(729669);
-> '1997-10-07'
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.6, “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 format, depending on whether the function is used in a string or numeric context. 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(875996580);
-> '1997-10-04 22:23:00'
mysql> SELECT FROM_UNIXTIME(875996580) + 0;
-> 19971004222300
mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
-> '%Y %D %M %h:%i:%s %x');
-> '2003 6th August 06:22:58 2003'
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(2001,31), MAKEDATE(2001,32);
-> '2001-01-31', '2001-02-01'
mysql> SELECT MAKEDATE(2001,365), MAKEDATE(2004,365);
-> '2001-12-31', '2004-12-30'
mysql> SELECT MAKEDATE(2001,0);
-> NULL
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('1997-12-31 23:59:59.000010');
-> 10
MINUTE(time)
Returns the minute for time, in the range 0 to 59.
mysql> SELECT MINUTE('98-02-03 10:05:03');
-> 5
MONTH(date)
Returns the month for date, in the range 0 to 12.
mysql> SELECT MONTH('1998-02-03');
-> 2
MONTHNAME(date)
Returns the full name of the month for date.
mysql> SELECT MONTHNAME('1998-02-05');
-> 'February'
NOW()
Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS format, depending on whether the function is used in a string or numeric context.
mysql> SELECT NOW();
-> '1997-12-15 23:50:26'
mysql> SELECT NOW() + 0;
-> 19971215235026
Within a stored routine or trigger, NOW() returns a constant time that indicates the time at which the routine or triggering statement began to execute. This differs from the behavior for SYSDATE(), which returns the exact time at which it executes.
PERIOD_ADD(P,N)
Adds N months to period P (in the format YYMM or YYYYMM). Returns a value in the format YYYYMM. Note that the period argument P is not a date value.
mysql> SELECT PERIOD_ADD(9801,2);
-> 199803
PERIOD_DIFF(P1,P2)
Returns the number of months between periods P1 and P2. P1 and P2 should be in the format YYMM or YYYYMM. Note that the period arguments P1 and P2 are not date values.
mysql> SELECT PERIOD_DIFF(9802,199703);
-> 11
QUARTER(date)
Returns the quarter of the year for date, in the range 1 to 4.
mysql> SELECT QUARTER('98-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 value in 'HH:MM:SS' or HHMMSS format, depending on whether the function is used in a string or numeric context.
mysql> SELECT SEC_TO_TIME(2378);
-> '00:39:38'
mysql> SELECT SEC_TO_TIME(2378) + 0;
-> 3938
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.
The date, time, or datetime values contained in str should be given in the format indicated by format. For the specifiers that can be used in format, see the DATE_FORMAT() function description. If str contains an illegal date, time, or datetime value, STR_TO_DATE() returns NULL. Starting from MySQL 5.0.3, an illegal value also produces a warning.
Range checking on the parts of date values is as described in Section 11.3.1, “The DATETIME, DATE, and TIMESTAMP Types”. This means, for example, that “zero” dates or dates with part values of 0 are allowed 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'
SUBDATE(date,INTERVAL expr type), SUBDATE(expr,days)
When invoked with the INTERVAL form of the second argument, SUBDATE() is a synonym for DATE_SUB(). For information on the INTERVAL argument, see the discussion for DATE_ADD().
mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'
mysql> SELECT SUBDATE('1998-01-02', INTERVAL 31 DAY);
-> '1997-12-02'
The second form allows 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('1998-01-02 12:00:00', 31);
-> '1997-12-02 12:00:00'
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, then you should also specify the weekday:
mysql> SELECT STR_TO_DATE('200442 Monday', '%X%V %W');
-> '2004-10-18'
SUBTIME(expr,expr2)
SUBTIME() subtracts expr2 from expr and returns the result. expr is a time or datetime expression, and expr2 is a time expression.
mysql> SELECT SUBTIME('1997-12-31 23:59:59.999999','1 1:1:1.000002');
-> '1997-12-30 22:58:58.999997'
mysql> SELECT SUBTIME('01:00:00.999999', '02:00:00.999998');
-> '-00:59:59.999999'
SYSDATE()
Returns the current date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS format, depending on whether the function is used in a string or numeric context.
Within a stored routine or trigger, SYSDATE() returns the time at which it executes. This differs from the behavior for NOW(), which returns the the time at which the routine or triggering statement began to execute.
TIME(expr)
Extracts the time part of the time or datetime expression expr and returns it as a string.
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(expr,expr2)
TIMEDIFF() returns the time between the start time expr and the end time expr2. expr and expr2 are time or date-and-time expressions, but both must be of the same type.
mysql> SELECT TIMEDIFF('2000:01:01 00:00:00',
-> '2000:01:01 00:00:00.000001');
-> '-00:00:00.000001'
mysql> SELECT TIMEDIFF('1997-12-31 23:59:59.000001',
-> '1997-12-30 01:01:01.000002');
-> '46:58:57.999999'
TIMESTAMP(expr), TIMESTAMP(expr,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 expr 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(interval,int_expr,datetime_expr)
Adds the integer expression int_expr to the date or datetime expression datetime_expr. The unit for int_expr is given by the interval argument, which should be one of the following values: FRAC_SECOND, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, or YEAR.
The interval value may be specified using one of keywords as shown, or with a prefix of SQL_TSI_. For example, DAY 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'
TIMESTAMPADD() is available as of MySQL 5.0.0.
TIMESTAMPDIFF(interval,datetime_expr1,datetime_expr2)
Returns the integer difference between the date or datetime expressions datetime_expr1 and datetime_expr2. The unit for the result is given by the interval argument. The legal values for interval are the same as those 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
TIMESTAMPDIFF() is available as of MySQL 5.0.0.
TIME_FORMAT(time,format)
This is used like the DATE_FORMAT() function, but the format string may contain format specifiers only for hours, minutes, and seconds. Other specifiers produce a NULL value or 0.
If the time value contains an hour part that is greater than 23, the %H and %k hour format specifiers produce a value larger than the usual range of 0..23. The other hour format specifiers produce the hour value modulo 12.
mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
-> '100 100 04 04 4'
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('1997-10-07');
-> 729669
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.6, “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, '1997-10-07' and '97-10-07' are seen as identical dates:
mysql> SELECT TO_DAYS('1997-10-07'), TO_DAYS('97-10-07');
-> 729669, 729669
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 5.11.8, “MySQL Server Time Zone Support”.
mysql> SELECT UNIX_TIMESTAMP();
-> 882226357
mysql> SELECT UNIX_TIMESTAMP('1997-10-04 22:23:00');
-> 875996580
When UNIX_TIMESTAMP is used on a TIMESTAMP column, the function returns the internal timestamp value directly, with no implicit “string-to-Unix-timestamp” conversion. If you pass an out-of-range date to UNIX_TIMESTAMP(), it returns 0.
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.8, “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 format, depending on whether the function is used in a string or numeric context.
mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
-> '18:07:53', 180753
UTC_TIMESTAMP, UTC_TIMESTAMP()
Returns the current UTC date and time as a value in 'YYYY-MM-DD HH:MM:SS' or YYYYMMDDHHMMSS format, depending on whether the function is used in a string or numeric context.
mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
-> '2003-08-14 18:08:04', 20030814180804
WEEK(date[,mode])
This function returns the week number for date. The two-argument form of WEEK() allows you to specify whether the week starts on Sunday or Monday and whether the return value should be in the range from 0 to 53 or from 1 to 53. If the mode argument is omitted, the value of the default_week_format system variable is used. See Section 5.2.2, “Server System Variables”.
The following table describes how the mode argument works.
First day
Mode 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('1998-02-20');
-> 7
mysql> SELECT WEEK('1998-02-20',0);
-> 7
mysql> SELECT WEEK('1998-02-20',1);
-> 8
mysql> SELECT WEEK('1998-12-31',1);
-> 53
Note 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('1998-02-03 22:23:00');
-> 1
mysql> SELECT WEEKDAY('1997-11-05');
-> 2
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('1998-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('98-02-03');
-> 1998
YEARWEEK(date), YEARWEEK(date,start)
Returns year and week for a date. The start argument works exactly like the start argument to WEEK(). The year in the result may be different from the year in the date argument for the first and the last week of the year.
mysql> SELECT YEARWEEK('1987-01-01');
-> 198653
Note that the week number is different from what the WEEK() function would return (0) for optional arguments 0 or 1, as WEEK() then returns the week in the context of the given year.
Previous / Next / Up / Table of Contents
User Comments
Posted by [name withheld] on June 20 2002 5:08am [Delete] [Edit]
When selecting a timestamp datatype from a table
and want adjust to a timezone (this example is
from pacific time to EST):
SELECT date_format(DATE_ADD([timestampcol],
INTERVAL 3 HOUR), '%M %e, %Y at %H:%i EST') FROM
[db table name];
Posted by Isaac Shepard on October 11 2003 4:53pm [Delete] [Edit]
If you're looking for generic SQL queries that will allow you to get the days, months, and years between any two given dates, you might consider using these. You just need to substitute date1 and date2 with your date expressions.
NOTE: Some of these formulas are complex because they account for all cases where date1 < date2, date1 = date2, and date1 > date2. Additionally, these formulas can be used in very generic queries where aliases and temporary variables are not allowed.
Number of days between date1 and date2:
TO_DAYS(date2) - TO_DAYS(date1)
Number of months between date1 and date2:
IF((((YEAR(date2) - 1) * 12 + MONTH(date2)) - ((YEAR(date1) - 1) * 12 + MONTH(date1))) > 0, (((YEAR(date2) - 1) * 12 + MONTH(date2)) - ((YEAR(date1) - 1) * 12 + MONTH(date1))) - (MID(date2, 9, 2) < MID(date1, 9, 2)), IF((((YEAR(date2) - 1) * 12 + MONTH(date2)) - ((YEAR(date1) - 1) * 12 + MONTH(date1))) < 0, (((YEAR(date2) - 1) * 12 + MONTH(date2)) - ((YEAR(date1) - 1) * 12 + MONTH(date1))) + (MID(date1, 9, 2) < MID(date2, 9, 2)), (((YEAR(date2) - 1) * 12 + MONTH(date2)) - ((YEAR(date1) - 1) * 12 + MONTH(date1)))))
Number of years between date1 and date2:
IF((YEAR(date2) - YEAR(date1)) > 0, (YEAR(date2) - YEAR(date1)) - (MID(date2, 6, 5) < MID(date1, 6, 5)), IF((YEAR(date2) - YEAR(date1)) < 0, (YEAR(date2) - YEAR(date1)) + (MID(date1, 6, 5) < MID(date2, 6, 5)), (YEAR(date2) - YEAR(date1))))
Now for some comments about these.
1. These results return integer number of years, months, and days. They are "floored." Thus, 1.4 days would display as 1 day, and 13.9 years would display as 13 years. Likewise, -1.4 years would display as -1 year, and -13.9 months would display as -13 months.
2. Note that I use boolean expressions in many cases. Because boolean expressions evaluate to 0 or 1, I can use them to subtract or add 1 from the total based on a condition.
For example, to calculate the number of years between to dates, first simply subtract the years. The problem is that doing so isn't always correct. Consider the number of years between July 1, 1950 and May 1, 1952. Technically, there is only one full year between them. On July 1, 1952 and later, there will be two years. Therefore, you should subtract one year in case the date hasn't yet reached a full year. This is done by checking the if the second month-day is before the first month-
day. If so, this results in a value of 1, which is subtracted from the total. The IF statements are in the formula because we must add one year when dealing with the dates in the opposite order, and we must not add or subtract anything when the difference of the date years is zero.
3. To get the month-day, I use MID. This is better
than using RIGHT, since it will work for both dates
and datetimes.
4. Unlike many other solutions, these queries should
work with dates prior to 01/01/1970.
Posted by Aurelio Sablone on December 6 2002 9:34am [Delete] [Edit]
In order to get the number of seconds between two
datetime values in a table, you could use the
following: SELECT unix_timestamp(date1) -
unix_timestamp(date2) FROM table_name
Posted by [name withheld] on February 6 2003 5:19pm [Delete] [Edit]
Spent some time trying to work out how to calculate the month start x months ago ( so that I can create historical stats on the fly)
here is what I came up with..
((PERIOD_ADD(EXTRACT(YEAR_MONTH FROM CURDATE()),-6)*100)+1)
this gives you the first day of the month six months before the start of the current month in datetime format
Posted by Adam Tylmad on July 29 2003 12:28am [Delete] [Edit]
To get the date difference between two date-type columns,
use this formula:
sec_to_time(unix_timestamp(EndDateTime) -
unix_timestamp(StartDateTime))
where StartDateTime and EndDateTime are the two columns
/A
Posted by Filip Wolak on August 4 2003 8:44am [Delete] [Edit]
Several times i have come to a followng date/time problem:
In the table i am storing both date and time information in the datetime column. Querying, I want to receive COUNTed results grouped by date, and not date and time. I came to the easy solution:
SELECT DATE_FORMAT(postdate, '%Y-%m-%d') AS dd, COUNT(id) FROM MyTable GROUP BY dd;
I suppose this solution to be quite slow (date formatting).
Later, i 'upgraded' this query to use the string function:
SELECT substring(postdate, 1,10) AS dd, COUNT(id) FROM MyTable GROUP BY dd;
knowing, that the result is in the fixed format. Works faster.
Posted by Stoyan Stefanov on August 16 2003 10:05pm [Delete] [Edit]
Hope this will help somebody. The way I found to sum time:
SELECT SEC_TO_TIME( SUM( TIME_TO_SEC( `time` ) ) ) AS total_time FROM time_table;
Posted by Gerard Manko on December 17 2003 10:27am [Delete] [Edit]
Comparing Dates when using MS Access and MyODBC
If you are using MS Access and have created Access queries to substitute for views (which are not yet available in mySQL), you can use the following syntax ro perform date comparisons and avoid the dreaded "ODBC -- call failed" error:
Select * from [Task Effort Summary]
Where ((Date() + 0) > CLng([Task Effort Summary].[s_end]))
This particular example retuns tasks that are overdue (where todays date is past the scheduled end date). This query was developed for reports on a TUTOS database.
Posted by [name withheld] on January 9 2004 8:59pm [Delete] [Edit]
Note that the built-in default values for the DATE and DATEFIELD column types is out of range. For example, 0000-00-00 is a valid way of expressing NULL, but if the column is set as NOT NULL, 0000-00-00 is still the default value. This can cause problems with some applications using MySQL.
Posted by [name withheld] on January 27 2004 4:25am [Delete] [Edit]
I was looking for a function to detect if the current week is odd or even. I could not find one so I use this:
MOD((DATE_FORMAT(CURDATE(),"%v")),2)
The output is a '0'(even) or a '1'(odd)
Posted by Steve West on February 15 2004 11:49pm [Delete] [Edit]
To create a DATETIME of NOW() in UTC without upgrading to 4.1.1, just use:
DATE_ADD( '1970-01-01', INTERVAL UNIX_TIMESTAMP() SECOND )
Posted by [name withheld] on March 2 2004 1:09pm [Delete] [Edit]
I am looking for a function to calculate the interval between two records of one column.
Posted by [name withheld] on March 4 2004 10:39am [Delete] [Edit]
workaround for STR_TO_DATE pre version 4.1.1. ugly but it seems to work fine.
assumption: you know the format of the received date (in the below example the format is mm/dd/yy, m/d/yy, mm/dd/yyyy, etc)
the statement extracts the year by locating the index of the second '/' and reading from the right of the string to that index. the index of the second is '/' is found by using LOCATE with the index of the first '/'.
it extracts the day by locating the indeces of the first and second '/' and reading between them
it extracts the month by locating the index of the first '/' and reading from the left of the string to that index.
it then CONCATs the year month and day pieces together separating them with hyphens.
lastly, it lets DATE_FORMAT do its magic on the string.
(replace the test string '1/11/03' with your field name, etc)
select DATE_FORMAT( CONCAT( RIGHT( '1/11/03' , length( '1/11/03') - LOCATE('/', '1/11/03' , LOCATE('/', '1/11/03' ) + 1 ) ) , '-' , LEFT( '1/11/03' , LOCATE('/', '1/11/03' ) - 1 ) , '-', SUBSTRING( '1/11/03' , LOCATE('/', '1/11/03' ) + 1, LOCATE('/', '1/11/03' , LOCATE('/', '1/11/03' ) + 1 ) - LOCATE('/', '1/11/03' ) - 1 ) ) , '%Y-%m-%d' )
Posted by Alex Boyne-Aitken on March 5 2004 2:24pm [Delete] [Edit]
Just a really easy way of getting the number of years between to dates:
SELECT ((TO_DAYS(recentdate) - TO-DAYS(olderdate))/365) as tempdate
Will leave a reminder but doesnt take much to clean that up
Posted by Olav Alexander Mjelde on March 15 2004 12:15pm [Delete] [Edit]
Lets say you have the mysql before 4.1.1 (where timediff() was implementet), and you want to do a timediff.
I wanted to make a "active users" on my page, but I found out that I didnt have the timediff function (to find persons which have been active within 5 minutes).
So, I figured this query out:
SELECT nick FROM `users` WHERE TO_DAYS( NOW( ) ) - TO_DAYS( last_login ) <=1 AND DATE_FORMAT( CURRENT_TIMESTAMP( ) , '%H%i' ) - DATE_FORMAT( last_login, '%H%i' ) <=5 ORDER BY `nick` ASC;
it selects the field nick (which is the only one to be displayd) and then it filters for 1 day or less in age of activity. after that, it filters for 5 minutes or less in activity.
first you need to filter away the other days, or your script might get fooled to think that yesterdays login was todays.
I'm currently using this, and it works fine!
on the other page, you of course need to update the timestamp field (when session excists, on reload)
Posted by Cherice Scharf on April 5 2004 1:24pm [Delete] [Edit]
Here is an example to convert various user inputs for a date field on an ASP page (VBScript) that will convert common formats (i.e., m/d/yy, mm/dd/yyyy, etc.) to MySQL database format of (yyyy-mm-dd). The function begins by establishing that there is a date in the field. Then splits the date (converted to string) into three parts by locating "/". DateArray(0), DateArray(1), DateArray(2) hold the month, day and year, respectively. These are then checked for the amount of digits, if there are not enough digits in month or day then a leading zero is added. If there are only two digits on the year (ie "04") then a leading "20" is added.
Function ConvertInputDate(varDate)
If (Len(Trim(varDate)) > 0) Then
DateArray=Split(CStr(varDate),"/")
IF Len(Trim(DateArray(0))) < 2 Then
DateArray(0) = "0" & DateArray(0)
End If
If Len(Trim(DateArray(1))) < 2 Then
DateArray(1) = "0" & DateArray(1)
End If
If Len(Trim(DateArray(2))) < 4 Then DateArray(2) = "20" & DateArray(2)
End If
varDate = DateArray(2) & "-" & DateArray(0) & "-" & DateArray(1)
End If
End Function
*Please note if a user does not use two slashes this function will not work. It is best to indicate "mm/dd/yy" near the label on the page. It will take 4/6/04, 10/6/04, 3/16/2004 and all combinations with two slashes.
Posted by Jason Richard on April 9 2004 9:20am [Delete] [Edit]
I had a problem with my login script using PHP and MySQL when daylight savings time (DST) came around this year.
I was using MYSQL NOW() function to add the current date and time to the user's record into a datetime field. When DST came into effect newly entered login times were an hour slow (I'm in EST). Since the last login is to be updated only if an hour or more has passed since the last login this was a big problem!
The problem is that PHP takes DST into account and MySQL does not (as far as I know) and I was entering the time using MySQL's NOW() function and then comparing the value returned by PHP's time() function.
A very simple solution to this is the following. Note the PHP time format string 'YmdHis' - it formats to YYYYMMDDHHMMSS which is what MySQL expects for a date/time field.
$now = time();
$lastLogin = strtotime($row['lastLogin']);
$diff = $now - $lastLogin;
$now = date('YmdHis',$now)
if($diff > 3600) { // 3600 seconds is 1 hour
$query = 'UPDATE members SET logins = logins + 1, lastLogin = '.$now.' WHERE memberID = '.$SEC_ID;
mysql_query($query);
}
Now the date entered is the PHP time (that accounts for DST) and we are comparing it to PHP time so all is well.
I think this approach will work well for any time you wish to enter a date into MySQL using PHP. Just format the date using the "YmdHis" format string and use the strtotime() function to read a date retrieved from MySQL.
The advantage to this approach rather than just entering the "normal" PHP date into a char or text field is that the dates are "human" readable in the table and all the MySQL date/time functions are available for future queries.
Posted by Martin Schwedes on April 25 2004 11:11am [Delete] [Edit]
to localize the weekday:
SELECT ELT( WEEKDAY('2004-04-10')+1, 'Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag','Sonntag');
long version with month:
SELECT DATE_FORMAT( '2004-04-10', CONCAT( ELT( WEEKDAY('2004-04-10')+1, 'Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag','Sonntag'),', %d. ', ELT( MONTH('2004-04-10'), 'Januar','Februar','Marz','April','Mai','Juni','Juli','August','September','Oktober','November','Dezember'),' %Y'));
--> Samstag, 10. April 2004
same for unix-timestamp:
SELECT DATE_FORMAT( FROM_UNIXTIME(1081548000), CONCAT( ELT( WEEKDAY(FROM_UNIXTIME(1081548000))+1, 'Mo','Di','Mi','Do','Fr','Sa','So'),', %d. ', ELT( MONTH(FROM_UNIXTIME(1081548000)), 'Jan.','Feb.','Marz','April','Mai','Juni','Juli','Aug.','Sept.','Okt.','Nov.','Dez.'),' %Y'));
--> Sa, 10. April 2004
Posted by Philippe Poelvoorde on April 30 2004 7:50am [Delete] [Edit]
I had to query a table and retrieve rows that were added only today, so :
select id from my_table
where
timestamp < date_format(date_add(CURRENT_TIMESTAMP(), interval 1 day),'%Y%m%d000000')
AND
timestamp >= date_format(CURRENT_TIMESTAMP(),'%Y%m%d000000')
starting with MySQL 4.0, you could also use the BETWEEN ... AND syntax.
If anyone has a better query to do that, let me know.
Posted by Michael Marcus on May 1 2004 4:41pm [Delete] [Edit]
After reading numerous articles and posts regarding converting back and forth between SQL datetime and VBscript datetime, I opted for the simplest solution for my databases. I simply save all datetime values in varchar(20) fields and call on either MySQL or VBscript functions to get datetime values or check/convert datetime values. For example:
currentDT = CStr(cn.execute("SELECT NOW()").Fields(0).Value)
will fetch current datetime in the SQL server's datetime format and then convert it to a string. [Obviously, cn is set by Set cn = Server.CreateObject("ADODB.Connection") to create the database connection, then the database is opened with a cn.open (parameters).]
You can then save this string to an appropriate field such as 'flddate_added' which is formatted as varchar(20).
When retrieving the flddate_added value, you can use this VBscript code to check if the value is indeed a datetime value and convert it to the datetime format of the user's computer"
if IsDate(flddate_added) then
=CDate(flddate_added) ' convert to user's system format for display using user's codepage
else
=flddate_added ' just display the string
end if
The above methods allow me to get around all of the issues regarding VBscript's datetime display format differences depending on the system local.
Posted by [name withheld] on July 23 2004 7:42pm [Delete] [Edit]
Some fun with "now()":
CREATE TABLE `test` (
`fecha` VARCHAR( 10 ) NOT NULL
);
INSERT INTO test values (now());
You'll see now you've on field "fecha" today's formatted date.
Regards
David Fernandez
Posted by Ray Morris on July 15 2004 6:37pm [Delete] [Edit]
Posted by Filip Wolak:
> Several times i have come to a followng date/time problem:
> In the table i am storing both date and time information in the datetime
> column. Querying, I want to receive COUNTed results grouped by date,
> and not date and time.
...
> SELECT substring(postdate, 1,10) ...
If it's a DATETIME column than substring is not appropriate -
it's logically nonsensical of course, and just happens to work
in some version of MySQL because the DATETIME happens
to be represented by a string in some contexts.
Better would be to treat the DATETIME as a DATETIME
rather than as a string, which will work in future versions
of MYSQL and in other RDMS:
SELECT DATE(postdate) ...
Posted by David Lyon on July 17 2004 6:12pm [Delete] [Edit]
Here is another VB/ASP function for converting Dates from standard to MySQL format. Cherise gave a nice example above, but it has extra complexity due to the use of arrays and also may be proned to user input errors.
The following example will work based on the Localization settings of the server on which it is run. So it shouldn't care whether the date is dd-mm-yyyy, mm/dd/yy, mm/dd/yyyy, m-d-yy, etc. Just make sure you pass it a date value that is formatted compliant to the server's localization. If necessary use VB's CDate(strDateValue) before passing strDateValue to the function.
You can also easily modify this function to do the same for Time values, except you use Hour, Minute, and Second VB functions, and delimit with a colon (:) instead of a dash (-).
Hope this helps!
Function funcMySqlDate(dtmChangeDate)
'CONVERTS LOCALIZED DATE FORMAT (for example: m/d/yy) TO MySQL FORMAT (yyyy-mm-dd)
Dim strTempYear, strTempMonth, strTempDay
strTempYear = Year(dtmChangeDate)
strTempMonth = Month(dtmChangeDate)
strTempDay = Day(dtmChangeDate)
if Len(strTempYear) = 2 then 'Y2K TEST - 1938-2037 - ADJUST AS NECESSARY
if strTempYear >= 38 then
strTempYear = "19" & strTempYear
else
strTempYear = "20" & strTempYear
end if
end if
if strTempMonth < 10 then strTempMonth = "0" & strTempMonth
if strTempDay < 10 then strTempDay = "0" & strTempDay
funcMySqlDate = strTempYear & "-" & strTempMonth & "-" & strTempDay
End Function
Posted by Benjamin Zagel on August 5 2004 2:44pm [Delete] [Edit]
To find out the last day of a month use:
SELECT (DATE_FORMAT('2004-01-20' ,'%Y-%m-01') - INTERVAL 1 DAY) + INTERVAL 1 MONTH;
It tooks me a few time to have this idea, but it works. If you want to have the first day of a month use:
SELECT DATE_FORMAT('2004-01-20' ,'%Y-%m-01');
To find out the first day of a month was my first development step, then it was easy to extract the last day of a month. It is usefull for accounting for services where I need this solution.
Greetings
Posted by Mark Stafford on August 6 2004 7:26pm [Delete] [Edit]
I see the use for both, but I find this layout more useful as a reference tool:
+--------------+----------+--------------------+| metric | variant | result |+--------------+----------+--------------------+| microseconds | %f | 000000..999999 || seconds | %s or %S | 00..59 || minutes | %i | 00..59 || hours | %H | 00...23 || | %h or %I | 00...12 || | %k | 0...23 || | %l | 1...12 || day | %a | Sun...Sat || | %D | 1st, 2nd, 3rd || | %d | 0.31 || | %e | 0..31 || | %j | 001...366 || | %W | Sunday...Sat || | %w | 0...6 || week | %U | 00...53 per Sun || | %u | 00...53 per Mon || * | %V | 01...53 per Sun || * | %v | 01...53 per Mon || month | %b | Jan...Dec || | %c | 0...12 || | %M | January...December || | %m | 00...12 || year | %Y | 1999 || | %y | 99 || * | %X | 1999 || * | %x | 99 || time | %r | 01:31:12 pm || | | %T | 01:31:12 pm || | %p | AM or PM || Percent sign | %% | % |+--------------+----------+--------------------+
Posted by M l on August 7 2004 8:53pm [Delete] [Edit]
Select records that are older than X days from the current date where sent_time is a Timestamp datatype field.
select ID from MESSAGE where SENT_TIME < (CURDATE() - INTERVAL 5 DAY);
Posted by R C on August 24 2004 9:21pm [Delete] [Edit]
If you do not have 4.xx yet here is a simple way to get the last day of the month. You can replace the current date with a var to find the last day of any month.
SELECT
SUBDATE( ADDDATE( CURDATE(), INTERVAL 1 MONTH), INTERVAL DAYOFMONTH( CURDATE() ) DAY) AS LAST_DAY_MONTH
seems to work well .
Posted by John Takacs on September 9 2004 12:39am [Delete] [Edit]
I'm not sure if this is mentioned above, however, none of the STR_TO_DATE() functions works in MySQL version 4.0.18.
So that there is no misunderstanding, the following SQL copied from the above STR_TO_DATE() section:
SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
returns the following error:
ERROR 1064: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near '('00/00/0000', '%m/%d/%Y')' at line 1
I copied and pasted all of the examples for STR_TO_DATE and none work.
Posted by Martin Algesten on September 9 2004 4:00pm [Delete] [Edit]
>Several times i have come to a followng date/time problem:
>In the table i am storing both date and time information in the
>datetime column. Querying, I want to receive COUNTed results
>grouped by date, and not date and time. I came to the easy
>solution:
I needed a query for a more general case to do time based reporting on arbitrary big "slices" of timestamped data.
My table has a column 'timestamp' which is of type 'datetime'.
The following makes '120' second big slices
select from_unixtime(unix_timestamp(timestamp) - unix_timestamp(timestamp) % 120) as slice, ... group by slice;
Posted by David Berry on September 17 2004 9:08pm [Delete] [Edit]
I wanted to find the start date (Sunday) and the end date (Saturday) for any given week when all I had to go from is an arbitrary date (more precisely, the current date). Since MySQL registers Sunday as 1, and Saturday as 7, if you wish to adjust the start and end points on a week, you'll have to modify the following function calls appropriately, and change the integers, or (as I have done) use variables:
set @someday = curdate();
set @weekstart = 1; // Sunday
set @weekend = 7; // Saturday
end of week:
select date_add(@someday, interval @weekend-dayofweek(@someday) day);
beginning of week:
select date_sub(@someday, interval dayofweek(@someday)-@weekstart day);
Of course, I use these functions in a more complex query that filters select results from a table with a "datetime" field. This allows me to focus on weekly data. A very neat thing is being able to replace 'curdate()' with a date at (theoretically) any point in time on the Gregorian calendar.
Posted by Jeffrey Friedl on October 31 2004 10:05am [Delete] [Edit]
The value returned by
UNIX_TIMESTAMP(NOW())
can be quite unintuitive during the last hour of daylight-saving time in the fall, as it can return a timestamp that's an hour ahead of the current time. (The docs indicate that this may be "fixed" from 4.1.3, but I have not tested.)
This is because CST-related information is lost during the conversion by NOW() from the current time to a string. When presented a date string like "2004-10-31 01:52:37" which names a time that happened twice (once during daylight-saving time, and again an hour later in standard time), it doesn't know which you intend it to be interpreted as.
The docs indicate that from 4.1.3, it uses the timezone in effect at the time of the SELECT, which implies that
FROM_UNIXTIME("2004-10-31 01:52:37")
returns a different value depending on whether you are currently under daylight-saving time or not. With 4.1.2 and before, it seems to always use standard time, and hence the one-hour "error" (which is not really an error, but damn unintuitive that UNIX_TIMESTAMP(NOW()) does not return the UNIX_TIMESTAMP for now.
Note that UNIX_TIMESTAMP() without args does return the proper unix timestamp for the current time.
Posted by Shamun toha on December 18 2004 11:45am [Delete] [Edit]
If you have a table1 , and (fields date which is varchar(100)
you can also convert it as date type look the following example
mysql> select str_to_date(date,'%d/%m/%Y') as Mydate from table1 order by Mydate DESC;
+------------+| Mydate |+------------+| 2004-12-16 || 2004-12-15 || 2004-12-02 || 2004-12-02 || 2004-11-01 || 2004-10-29 || 2004-10-12 || 2004-10-07 || 2004-09-12 || 2004-08-19 || 2004-08-13 || 2004-08-09 || 2004-08-04 || 2004-07-30 || 2004-07-26 || 2004-07-20 || 2004-07-16 || 2004-07-14 |+------------+
18 rows in set (0.00 sec)
mysql>
Posted by John Romano on January 26 2005 11:06pm [Delete] [Edit]
If you need to EXTRACT the QUARTER prior to v5.0 try CEILING(EXTRACT(MONTH FROM date)/3)
Posted by Robert Christiaanse on January 27 2005 3:18pm [Delete] [Edit]
CALCULATING A DATE USING A WEEK NUMBER
If you want to calculate the date having a year, a day of the week and a weeknumber (Let's say Thursday of week number 4 in 2005), you can calculate it like this:
SELECT DATE_ADD('2005-01-04', INTERVAL ((4-1)*7+(4 - DATE_FORMAT('2005-01-04','%w'))) DAY);
In PHP it would be something like this (when weeks start on Monday):
$Days=array('xx','ma','di','wo','do','vr','za','zo');
$DayOfWeek=array_search($aDay,$Days); //get day of week (1=Monday)
$Year=2005;
$Week=4;
$query = "SELECT DATE_ADD('".$Year."-01-04', INTERVAL ((".$Week."-1)*7+(".$DayOfWeek." - DATE_FORMAT('".$Year."-01-04','%w'))) DAY)";
January 4th is chosen as a base, because it is always in week number 1. ( January 1st is not necessarely in week1! )
You can test it with this:
<?php
//connect to your database first
$Year=2005;
for ($weeknr=0; $weeknr <= 53; $weeknr++)
{
for ($day=1; $day <= 7; $day++)
{
$query = "
SELECT
DATE_ADD('".$Year."-01-04',
INTERVAL ((".$weeknr."-1)*7+
(".$day." - DATE_FORMAT('".$Year."-01-04','%w'))) DAY)
";
$result= mysql_query($query);
if ($result)
{
$row = mysql_fetch_row($result);
echo "year=$Year weekno=$weeknr day=$day : ".$row[0].'<br>';
}
else
echo 'empty result set<br>'.EOL;
}
}
?>
Posted by Ralph Noordanus on February 18 2005 1:23pm [Delete] [Edit]
+---------------------+---------------------+| date1 | NOW() |+---------------------+---------------------+| 2005-03-17 16:00:00 | 2005-02-18 13:07:29 |+---------------------+---------------------+
If you're looking for an SQL query that returns the number of days, hours and minutes between date1 and now:
SELECT CONCAT(DAYOFYEAR(date1)-DAYOFYEAR(NOW()),' days ', DATE_FORMAT(ADDTIME("2000-00-00 00:00:00",SEC_TO_TIME(TIME_TO_SEC(date1)-TIME_TO_SEC(NOW()))),'%k hours and %i minutes')) AS time FROM time_table;
+---------------------------------+| time |+---------------------------------+| 27 days 2 hours and 52 minutes |+---------------------------------+
Posted by Luke Burgess on February 21 2005 7:11pm [Delete] [Edit]
There doesn't appear to be an official way of selecting * from a table where eg 'date is january 2005'. So far i've found 8 different ways!!
1. where date like '2005-01-%'
2. where DATE_FORMAT(date,'%Y-%m')='2005-01'
3. where EXTRACT(YEAR_MONTH FROM date)='200501'
4. where YEAR(date)='2005' and MONTH(date)='1'
5. where substring(date,1,7)='2005-01'
6. where date between '2005-01-01' and '2005-01-31'
7. where date >= '2005-01-01' and date <= '2005-01-31'
8. where date IN('2005-01-01','2005-01-02','2005-01-03','2005-01-04','2005-01-05','2005-01-06','2005-01-07','2005-01-08','2005-01-09','2005-01-10','2005-01-11','2005-01-12','2005-01-13','2005-01-14','2005-01-15','2005-01-16','2005-01-17','2005-01-18','2005-01-19','2005-01-20','2005-01-21','2005-01-22','2005-01-23','2005-01-24','2005-01-25','2005-01-26','2005-01-27','2005-01-28','2005-01-29','2005-01-30','2005-01-31')
Posted by Josh Hayden on March 20 2005 3:14am [Delete] [Edit]
I needed a query that would delete all rows that were created over an hour ago. Here's what I used:
To insert the row:
INSERT INTO `table_name` ( `time_col`) VALUES (NOW());
To delete the rows created over an hour ago:
DELETE FROM `table_name` WHERE `time_col` < ADDDATE(NOW(), INTERVAL -1HOUR);
Posted by Erin Quick-Laughlin on March 29 2005 2:49am [Delete] [Edit]
To take Cherice Scharf's vb example one step further, here's the conversion from vb's now format of 'MM/DD/YY HH:MM:SS PM' to 'YYYY-MM-DD HH:MM:SS' for easy insertion to the datetime field:
Function ConvertInputDateTime(varDateTime)
If (Len(Trim(varDateTime)) > 0) Then
DateTimeArray=Split(CStr(varDateTime)," ")
varDate = DateTimeArray(0)
varTime = DateTimeArray(1)
varAMPM = DateTimeArray(2)
If (Len(Trim(varDate)) > 0) Then
DateArray=Split(CStr(varDate),"/")
IF Len(Trim(DateArray(0))) < 2 Then
DateArray(0) = "0" & DateArray(0)
End If
If Len(Trim(DateArray(1))) < 2 Then
DateArray(1) = "0" & DateArray(1)
End If
If Len(Trim(DateArray(2))) < 4 Then
DateArray(2) = "20" & DateArray(2)
End If
varDate = DateArray(2) & "-" & DateArray(0) & "-" & DateArray(1)
End If
If (Len(Trim(varDate)) > 0) Then
TimeArray=Split(CStr(varTime),":")
If Trim(varAMPM) = "PM" Then
TimeArray(0) = CStr(TimeArray(0) + 12)
End If
If Len(Trim(TimeArray(0))) < 2 Then
TimeArray(0) = "0" & TimeArray(0)
End If
varTime = TimeArray(0) & ":" & TimeArray(1) & ":" & TimeArray(2)
End If
varDateTime = varDate & " " & varTime
End If
ConvertInputDateTime = varDateTime
End Function
Thanks for the starting code Cherice!
Posted by paul adams on April 1 2005 11:30am [Delete] [Edit]
"SELECT id, transactionid, (UNIX_TIMESTAMP(now()) - UNIX_TIMESTAMP(date)) AS date , sucessful, amount FROM Transaction where sucessful = 1"
to work out the difference between when it was placed to now.
Posted by Richard Hewitt on April 20 2005 6:39am [Delete] [Edit]
Here is a way to determine the age from a date of birth.
It handles leap years also.
SELECT IFNULL(CAST( (TO_DAYS(NOW())- TO_DAYS(dob)) / 365.25 as SIGNED) ,0) as Age from Table_Name
Posted by santi bari on June 10 2005 4:49pm [Delete] [Edit]
GENERATE missing days on a table with date gaps
=====================================
If you want to bring visits per day to your site and you have a table
wich
is storing the hits, in a way similar to this...
+--------------+--------------------------+| date | IP +--------------+--------------------------+|2004-8-3 | 123.123.124.155|2004-8-3 | 123.123.124.145|2004-8-5 | 123.123.124.145+--------------+--------------------------+
You may want to draw a chart and retrieve all the hits per day. The
problem is that DAYS WITHOUT HITS WON'T APPEAR. And you won't be able
to
display the info of '0 hits'.
One solution to this which is easy to code and clean, is to create and
have in your database, a table named 'calendar' with all the days from
today till some years from now (let's say, till 2034). The table
should
look something like this:
+----------+| date+----------+| 2004-1-1| 2004-1-2| 2004-1-3| 2004-1-4| 2004-1-5| ...| etc...+---------+
Here is a piece of code which will make such table:
<?php
mysql_query("CREATE TABLE `calendar` (
`id` int(11) NOT NULL auto_increment,
`date` date NOT NULL default '0000-00-00',
PRIMARY KEY (`id`)
) TYPE=MyISAM; ");
for($i=0;$i<=(365*30);$i++)
mysql_query("INSERT INTO CALENDAR SET date=date_add(now(),INTERVAL
LAST_INSERT_ID() DAY)");
?>
Then all you have to do is perform a LEFT JOIN from this table and
you've
got every day from the period of time you specify. Even those with 0
hits
SELECT calendar.date, count(*)
FROM calendar
LEFT JOIN visits ON calendar.date=visits.date
GROUP BY calendar.date
Posted by Benjamin Gehrels on May 12 2005 3:50am [Delete] [Edit]
Be carefull with the DAYOFYEAR-Function in comparisions, because you will run into a trap every 4 years, when Feburary is a day shorter...
Posted by Labb on May 20 2005 3:24pm [Delete] [Edit]
To Posted by Erin Quick-Laughlin on March 29 2005 2:49am
The much more easier way:
date = "YYYY/MM/DD HH-SS-MM"
date = Replace(date, "/", "-")
thats it...
Posted by Juan Antonio on May 23 2005 5:36pm [Delete] [Edit]
age from date of birth compared whith
in this function you can know the age of a person(it works for my). preg 12 is a date in the format show bellow i dont know if it is fast. if you have a recent version you can asign curtime to a variable for get more performance else use php,c++ or another to save it as:
YYYY-MM-DD example: 1997-03-31
left((curtime()-preg12),(CHAR_LENGTH(curtime()-preg12)-4))
another way is:
(TO_DAYS("a - date") - TO_DAYS("birth"))/365
you can replece the curdate for a before date changing curdate to this 20000619 NOT THIS: 2000-06-19 if you have beter way send it to my tanks bye.
Posted by John Anderson on May 25 2005 10:04pm [Delete] [Edit]
To calculate week ending date given an arbitrary date, use the following (assumes Saturday is week end)
SELECT DATE_ADD('2005-05-24', INTERVAL (7 - DAYOFWEEK('2005-05-24')) DAY)
SELECT DATE_ADD(table.column, INTERVAL (7 - DAYOFWEEK(table.column)) DAY)
Posted by Pe3k on June 15 2005 2:51pm [Delete] [Edit]
If U have older version of MySQL you can replace 'TIMEDIFF(time1,time2)' with
'SEC_TO_TIME( (TO_DAYS(time1)*24*3600+TIME_TO_SEC(time1)) - (TO_DAYS(time2)*24*3600+TIME_TO_SEC(time2)) )'
It is completly same. :)
Posted by santi bari on July 6 2005 5:25pm [Delete] [Edit]
A simple and precise way to get the AGE OF A PERSON:
SELECT YEAR( FROM_DAYS(TO_DAYS(NOW())-TO_DAYS(birth)) )
Posted by Daniel Schroeder on July 16 2005 6:58pm [Delete] [Edit]
I had the task to select rows of a table where the date of creation was in the future of a given date.
The problem was there was no date or timestamp-field, but two fields (int), one for month and one for year.
Since I have MySQL-Version prior to 4.1.1, where most of the nice date/time-functions have been added, I had to work out a query that builds and compares dates out of the given values.
Here it is:
SELECT *
FROM your_table
WHERE CONCAT(your_table.field_year,'-',REPEAT(0,2-LENGTH(your_table.field_month)),your_table.field_month,'-','01') >= CONCAT({MIN_YEAR},'-',REPEAT(0,2-LENGTH({MIN_MONTH})),{MIN_MONTH},'-','01')
ORDER BY your_table.field_year,
your_table.field_month;
I noticed an advantage compared to working with timestamps: You are able to work with dates before 1970.
Posted by Oliver Pereira on July 19 2005 3:40pm [Delete] [Edit]
The description of FROM_DAYS(N) - "Given a daynumber N, returns a DATE value" - uses the term "daynumber" without explaining it.
The description of TO_DAYS(date) - "Given a date date, returns a daynumber (the number of days since year 0)" - lower down the page at least tries to explain the term, but unsuccessfully.
There are two problems here. Firstly, there was no year 0 in the Gregorian calendar. Secondly, a number of days has to be counted from a day, not a year. Do they mean the beginning of the (non-existent) year, or the end of the (non-existent) year? Do non-existent years even have beginnings and ends? Someone should amend these descriptions.
Posted by k s on August 12 2005 9:51am [Delete] [Edit]
Here's another query to get the number of months between two dates:
select period_diff(DATE_FORMAT(date1,'%Y%m'),DATE_FORMAT(date2,'%Y%m')) from tablexy
Posted by Bob Terrell on August 22 2005 7:40pm [Delete] [Edit]
Note that there is currently no way to get the 'AM' or 'PM' part of a time-only value using the built-in functions. You must first convert it to a datetime and then use DATE_FORMAT('%p') or perform your own calculations in your app.
Posted by Deron Meranda on August 31 2005 10:33pm [Delete] [Edit]
On transactional consistency...Concerning the functions which use the real current time, such as NOW(), the manual says "Functions that return the current date or time each are evaluated only once per query at the start of query execution."
Note though that this does not apply across entire transactions, as you may expect. Thus a transaction like:
START TRANSACTION;
INSERT INTO EVENTS VALUES (NOW(), 'A');
INSERT INTO EVENTS VALUES (NOW(), 'B');
COMMIT;
will result in potentially two different times being recorded for the two records.
Posted by cameron green on September 16 2005 8:13am [Delete] [Edit]
If you need the type to be dynamically taken from a table (that is where you have "year", "day", "month" etc as a column in the table), here is the best way I could work out to do it. Expand as necessary :
SELECT set_date, unit_period, unit_multiplier, CASE WHEN unit_period = "month" THEN DATE_SUB(set_date, INTERVAL unit_multiplier MONTH) WHEN unit_period = "week" THEN DATE_SUB(set_date, INTERVAL (unit_multiplier * 7) DAY) WHEN unit_period = "year" THEN DATE_SUB(set_date, INTERVAL unit_multiplier YEAR) ELSE DATE_SUB(set_date, INTERVAL unit_multiplier DAY) END FROM dates_table;
Posted by Andrzej Salamon on September 22 2005 3:27pm [Delete] [Edit]
Returns all rows from actual month to given @months. eg. if you want get all rows in:
5 months from now:
(2005-09) - 5 = (2005-04)
all rows from 2005-04-01 to 2005-04-30
2 months from now
(2005-09) - 2 = (2005-07)
all rows from 2005-07-01 to 2005-07-31
SQL variables, can be PHP variables like $months,$nextMonth,$begin,$end
set @months = 1; #change only this value(months back from actual month)
set @nextMonth = @months+1;
set @begin = FROM_DAYS(TO_DAYS(LAST_DAY( DATE_SUB(NOW(), INTERVAL @nextMonth MONTH )))+1);
set @end = FROM_DAYS(TO_DAYS(LAST_DAY( DATE_SUB(NOW(), INTERVAL @months MONTH )))+1);
SELECT cols_u_want FROM tbl_u_want
WHERE timestampCol
BETWEEN @begin AND @end
It`s my solution. If U have Your own please email me.
Sorry for my english :)
Posted by C M on October 17 2005 10:50pm [Delete] [Edit]
I USED THIS TO GET THE AGE OF ANY PERSON GIVEN ONLY THEIR BIRTH DATE.
SELECT DATEDIFF(CURDATE(),'#BIRTH_DATE#')/365.25;
WHERE #BIRTH_DATE# REPRESENTS THE BIRTH DATE FIELD.
Posted by Bryan Donovan on November 14 2005 10:22pm [Delete] [Edit]
I'm not sure if this is the best way, but it works to get the date of the Monday of the week of a date. For example, if you have a datetime column called starttime in a table called test_events, you could select the distinct Mondays from your table as follows:
SELECT DISTINCT(STR_TO_DATE(CONCAT(YEARWEEK(starttime),'1'),'%x%v%w'))
FROM test_events;
Hopefully there is a better way..
Posted by Rodolfo Maripan on November 29 2005 4:52pm [Delete] [Edit]
I was using mysql v4 and the date was in a varchar data type, in order to change the data type in mysql v5 i use the following code:
update ssd_escondida.tactual_sag4 set ssd_escondida.tactual_sag4.Fecha=str_to_date(ssd_escondida.tactual_sag4.Fecha2,'%e/%m/%Y');
where:
ssd_escondida: database
tactual_sag4:is a table
Fecha: is a date type
Fecha2:is a varchar which contains a date, but is from 01/01/2005 to 04/01/2005 (with a zero at the begining)
why i used %e instead of %d??? the answer is very simple, there is a problem with de help about str_to_date:
%d: represents the days, but from 0 to 31 and...
%e: represents the days, but from 00 to 31.
that's the reason why we cannot use: str_to_date('00/00/0000',%d/%m/%Y), we must use str_to_date('00/00/0000','%e/%m/%Y')
Another way in order to change a string like: 00/00/0000 to a date is to use: str_to_date('00/00/0000','0%d/%m/%Y')
Posted by Regina Mullen on December 3 2005 11:25pm [Delete] [Edit]
Simple method of converting dates from any of
MM-DD-YYYY
MM/DD/YYYY
MM.DD.YYYY
(oldDate) to YYYY-MM-DD (addDate). Load date in as text and convert in one go using:
<code>
update table set addDate = CONCAT_WS('-', RIGHT( oldDate,4), LEFT( oldDate,2), SUBSTRING( oldDate,4,2))
</code>
Caveat: make sure your text input doesn't have spaces.
Posted by Hyper Hacker on December 26 2005 11:54pm [Delete] [Edit]
In MySQL 4.0, and possibly others, UNIX_TIMESTAMP() doesn't work with dates before 1970. This query does the same, and works with any date from from Fri, 13 Dec 1901 20:45:54 to Tue, 19 Jan 2038 03:14:07. 'date' is the name of the DATETIME column you need a timestamp of.
SELECT (((TO_DAYS(date) * 86400) + TIME_TO_SEC(date)) - (TO_DAYS("1970-01-01") * 86400)) AS timestamp
If you're using PHP, note that date() accounts for DST and thus may appear to return incorrect results; also, don't forget to escape the quotes around 1970-01-01.
Posted by Noel Athaide on December 27 2005 9:23am [Delete] [Edit]
Keyphrases: Birthday reminder, select dates between
This might be useful. If you have a database containing 'name' and 'birthday' (as columns) then the following query will list the birthdays in the next 15 days. (16 to be more precise :-))
What I found unique about this problem is that the YEAR (of birth) will always be different and hence one cannot simply use a query like :
| SELECT * FROM `friends` WHERE | `birthday` >= CURDATE() | AND | `birthday` <= ADDDATE(CURDATE(), INTERVAL 15 DAY);
because it would take the year into consideration.
The correct way, I believe, to get the desired result is as follows:
| SELECT * FROM `friends` WHERE (| EXTRACT(MONTH FROM `birthday` ) = EXTRACT(MONTH FROM | CURDATE()) | AND | DAYOFMONTH(`birthday`) >= DAYOFMONTH(CURDATE()) | AND | DAYOFMONTH(`birthday`) <= (DAYOFMONTH(CURDATE()) + 15) | ) || OR (| EXTRACT(MONTH FROM `birthday`) = EXTRACT(MONTH FROM | ADDDATE(CURDATE(), INTERVAL 15 DAY)) | AND | DAYOFMONTH(`birthday`) <= DAYOFMONTH(ADDDATE(CURDATE(), | INTERVAL 15 DAY))| )
The logic should be clear from the query itself. Note that in one place I use numerical addition (DAYOFMONTH(CURDATE()) + 15) while lower down I use the ADDDATE function. This distinction is important.
Would be happy if someone could refine the above method.
- Noel Athaide.
PS: Put this into a script and crontab it...and you have a simple Birthday reminder :-)
Posted by [name withheld] on January 13 2006 12:51am [Delete] [Edit]
the birthday-reminder doesn't work the way it should be. I found the bug and fixed it. this is a working example:
SELECT user_birthdate,user_name,user_id , EXTRACT(MONTH FROM `user_birthdate` ) month, EXTRACT(DAY FROM `user_birthdate` ) day
FROM ".$db_prefix."users
WHERE
(
EXTRACT(MONTH FROM `user_birthdate` ) = EXTRACT(MONTH FROM CURDATE())
AND
DAYOFMONTH(`user_birthdate`) > DAYOFMONTH(CURDATE())
AND
DAYOFMONTH(`user_birthdate`) <= (DAYOFMONTH(CURDATE()) + 15)
)
OR
(
EXTRACT(MONTH FROM ADDDATE(CURDATE(), INTERVAL 15 DAY))<>EXTRACT(MONTH FROM CURDATE())
AND
EXTRACT(MONTH FROM `user_birthdate`) = EXTRACT(MONTH FROM ADDDATE(CURDATE(), INTERVAL 15 DAY))
AND
DAYOFMONTH(`user_birthdate`) <= DAYOFMONTH(ADDDATE(CURDATE(), INTERVAL 15 DAY))
)
ORDER BY month, day, user_id ASC
sorry for the strange name, but this is the way my table are named...
hope you like it
Posted by Stijn Tas on January 23 2006 5:07pm [Delete] [Edit]
I'm using this query for a birthday-reminder:
SELECT `geb_Geboorte`
FROM `gebruikers`
WHERE
DAYOFYEAR( curdate( ) ) <= dayofyear( `geb_Geboorte` )
AND
DAYOFYEAR( curdate( ) ) +15 >= dayofyear( `geb_Geboorte` );
I change the year of birthday to the current year.
Sorry for the dutch tablenames.
Posted by John L. on January 25 2006 4:56pm [Delete] [Edit]
It took me a bit of time to find how to select data based on time periods (such as for quarterly or yearly reports). You can use group by month(DateTypeColumn).
example- to find periodic totals:
SELECT [Year|Quarter|Month|Day](date) as Period,shipcountry,shipstate,shipcity,sum(products),sum(shipping),sum(tax)
FROM products NATURAL JOIN shipping NATURAL JOIN tax
GROUP BY Period,shipcountry,shipstate,shipcity
more here-
http://dev.mysql.com/doc/refman/5.0/en/date-and-time-functions.html
I suppose you could alter the start of quarterly periods by doing some arithmetic on the (date), but you might have to do some conversions.
Posted by [name withheld] on March 6 2006 8:32pm [Delete] [Edit]
Time arithmetic using CURTIME() is quite willing to type everything into integers rather than adding and subtracting seconds. For example, where log_time is a TIME column;
SELECT log_time AS Time FROM call_log
WHERE log_time >= (CURTIME( ) - 60 );
will fetch all results from the last 60 seconds. However,
SELECT log_time AS Time FROM call_log
WHERE log_time >= (CURTIME( ) - 900 );
will fetch all results from the last 9 minutes. 900 is interpreted, not as 900 seconds (15 minutes), but as 9:00. An hour is 10000 (1:00:00), not 3600 (36:00).
If you want to add seconds, use something like the following (for the last hour);
SELECT log_time AS Time FROM call_log
WHERE log_time >= (CURTIME( ) - SEC_TO_TIME(3600) );
Posted by Issac Goldstand on March 9 2006 1:34am [Delete] [Edit]
If you have a column of date values and you want to compare the day portion of them with today's date, taking in mind shorter months which might not contain all the dates in your set (example, billing systems or anything else which needs to run on each record or recordset on a given day of the month), you can try one of these (replacing '2002-04-30' with the date field you're comparing):
SELECT DATE_FORMAT(CURDATE()-INTERVAL 1 MONTH, CONCAT('%Y-%m-',DAY('2002-04-30')))+INTERVAL 1 MONTH;
This tends to "round down" on missing days - for example for dates ending in 30, this will translate to feb 28 (in february).
'프로그래밍 > mysql' 카테고리의 다른 글
| mysql - 다른테이블 내용을 참조한 update 처리[join update] (0) | 2012.07.19 |
|---|---|
| mysql - 누적값 조회 (0) | 2012.07.19 |
| MySQL 5.0.xx 에서 트리거의 특징 (0) | 2012.07.19 |
| mysql - sqlrelay 설정 (0) | 2012.07.19 |
| mysql - split 함수 구현 (0) | 2012.07.19 |