14.7 Date and Time Functions

14.7 Date and Time Functions

이 섹션에서는 temporal 값을 조작하는 데 사용할 수 있는 함수들을 설명합니다. 각 date 및 time 타입이 가지는 값의 범위와 값을 지정할 수 있는 유효한 포맷에 대한 설명은 Section 13.2, “Date and Time Data Types”을 참조하십시오.

Table 14.11 Date and Time Functions

Name	Description
ADDDATE()	date 값에 time 값(interval)을 더함
ADDTIME()	time 추가
CONVERT_TZ()	한 time zone 에서 다른 time zone 으로 변환
CURDATE()	현재 date 반환
CURRENT_DATE(), CURRENT_DATE	CURDATE()의 synonym
CURRENT_TIME(), CURRENT_TIME	CURTIME()의 synonym
CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP	NOW()의 synonym
CURTIME()	현재 time 반환
DATE()	date 또는 datetime expression 의 date 부분 추출
DATE_ADD()	date 값에 time 값(interval)을 더함
DATE_FORMAT()	지정된 대로 date 포맷
DATE_SUB()	date 에서 time 값(interval)을 뺌
DATEDIFF()	두 date 를 뺌
DAY()	DAYOFMONTH()의 synonym
DAYNAME()	요일 이름 반환
DAYOFMONTH()	month 의 일(0-31) 반환
DAYOFWEEK()	argument 의 weekday 인덱스 반환
DAYOFYEAR()	year 의 일(1-366) 반환
EXTRACT()	date 의 일부 추출
FROM_DAYS()	day number 를 date 로 변환
FROM_UNIXTIME()	Unix timestamp 를 date 로 포맷
GET_FORMAT()	date 포맷 문자열 반환
HOUR()	hour 추출
LAST_DAY	argument 에 대한 month 의 마지막 날 반환
LOCALTIME(), LOCALTIME	NOW()의 synonym
LOCALTIMESTAMP, LOCALTIMESTAMP()	NOW()의 synonym
MAKEDATE()	year 와 day of year 로부터 date 생성
MAKETIME()	hour, minute, second 로부터 time 생성
MICROSECOND()	argument 에서 microseconds 반환
MINUTE()	argument 에서 minute 반환
MONTH()	전달된 date 에서 month 반환
MONTHNAME()	month 이름 반환
NOW()	현재 date 와 time 반환
PERIOD_ADD()	year-month 에 period 추가
PERIOD_DIFF()	period 사이의 month 수 반환
QUARTER()	date argument 에서 quarter 반환
SEC_TO_TIME()	seconds 를 'hh:mm:ss' 포맷으로 변환
SECOND()	second(0-59) 반환
STR_TO_DATE()	string 을 date 로 변환
SUBDATE()	세 개의 argument 로 호출될 때 DATE_SUB()의 synonym
SUBTIME()	time 을 뺌
SYSDATE()	function 이 실행되는 시점의 time 반환
TIME()	전달된 expression 의 time 부분 추출
TIME_FORMAT()	time 으로 포맷
TIME_TO_SEC()	argument 를 seconds 로 변환하여 반환
TIMEDIFF()	time 을 뺌
TIMESTAMP()	단일 argument 인 경우, 이 function 은 date 또는 datetime expression 을 반환하고; 두 개의 argument 인 경우, argument 의 합을 반환
TIMESTAMPADD()	datetime expression 에 interval 추가
TIMESTAMPDIFF()	지정된 unit 을 사용하여 두 datetime expression 의 차이를 반환
TO_DAYS()	date argument 를 days 로 변환하여 반환
TO_SECONDS()	date 또는 datetime argument 를 Year 0 이후의 seconds 로 변환하여 반환
UNIX_TIMESTAMP()	Unix timestamp 반환
UTC_DATE()	현재 UTC date 반환
UTC_TIME()	현재 UTC time 반환
UTC_TIMESTAMP()	현재 UTC date 와 time 반환
WEEK()	week number 반환
WEEKDAY()	weekday 인덱스 반환
WEEKOFYEAR()	date 의 calendar week 반환(1-53)
YEAR()	year 반환
YEARWEEK()	year 와 week 반환

Name	Description

다음은 date 함수을 사용하는 예제입니다. 다음 query 는 지난 30일 이내의 date_col 값을 가진 모든 row 를 선택합니다:

1mysql> SELECT something FROM tbl_name
2    -> WHERE DATE_SUB(CURDATE(),INTERVAL 30 DAY) <= date_col;

이 query 는 또한 미래에 속하는 date 를 가진 row 도 선택합니다.

date 값을 기대하는 함수는 보통 datetime 값을 허용하고 time 부분을 무시합니다. time 값을 기대하는 함수는 보통 datetime 값을 허용하고 date 부분을 무시합니다.

현재 date 또는 time 을 반환하는 함수들은 query 실행 시작 시점에 query 당 한 번만 평가됩니다. 이는 단일 query 내에서 NOW() 와 같은 함수에 여러 번 참조하더라도 항상 같은 결과를 생성함을 의미합니다. (여기서 단일 query 는 저장 프로그램(stored routine, trigger, event)에 대한 호출과 그 프로그램이 호출하는 모든 하위 프로그램을 포함합니다.) 이 원칙은 CURDATE(), CURTIME(), UTC_DATE(), UTC_TIME(), UTC_TIMESTAMP() 및 이들의 모든 synonym 에도 적용됩니다.

CURRENT_TIMESTAMP(), CURRENT_TIME(), CURRENT_DATE(), FROM_UNIXTIME() 함수는 현재 세션 time zone 의 값을 반환하며, 이 값은 time_zone 시스템 변수의 세션 값으로 제공됩니다. 추가로, UNIX_TIMESTAMP() 는 argument 가 세션 time zone 의 datetime 값이라고 가정합니다. Section 7.1.15, “MySQL Server Time Zone Support”를 참조하십시오.

일부 date 함수는 “zero” date 나 '2001-11-00' 같은 incomplete date 와 함께 사용할 수 있지만, 다른 함수는 그렇지 않습니다. date 의 일부를 추출하는 함수는 일반적으로 incomplete date 에서 동작하며, nonzero 값을 기대할 법한 경우에도 0 을 반환할 수 있습니다. 예를 들면 다음과 같습니다:

1mysql> SELECT DAYOFMONTH('2001-11-00'), MONTH('2005-00-00');
2        -> 0, 0

다른 함수는 complete date 를 기대하며, incomplete date 에 대해서는 NULL 을 반환합니다. 여기에는 date 연산을 수행하거나 date 의 일부를 이름으로 매핑하는 함수가 포함됩니다. 예를 들면 다음과 같습니다:

1mysql> SELECT DATE_ADD('2006-05-00',INTERVAL 1 DAY);
2        -> NULL
3mysql> SELECT DAYNAME('2006-05-00');
4        -> NULL

여러 함수는 argument 로 DATE() 함수 값을 전달받을 때 엄격하게 동작하며 day 부분이 0 인 incomplete date 를 거부합니다: CONVERT_TZ(), DATE_ADD(), DATE_SUB(), DAYOFYEAR(), TIMESTAMPDIFF(), TO_DAYS(), TO_SECONDS(), WEEK(), WEEKDAY(), WEEKOFYEAR(), YEARWEEK().

TIME, DATETIME, TIMESTAMP 값에 대해 fractional seconds 가 지원되며, microsecond 까지 정밀도를 가집니다. temporal argument 를 받는 함수는 fractional seconds 가 있는 값을 허용합니다. temporal 함수의 반환 값은 적절한 경우 fractional seconds 를 포함합니다.

• ADDDATE(date,INTERVAL expr unit), ADDDATE(date,days)

두 번째 argument 의 INTERVAL 형식으로 호출될 때, ADDDATE()는 DATE_ADD()의 synonym 입니다. 관련 함수인 SUBDATE()는 DATE_SUB()의 synonym 입니다. INTERVAL unit argument 에 대한 정보는 Temporal Intervals를 참조하십시오.

1mysql> SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY);
2          -> '2008-02-02'
3mysql> SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY);
4          -> '2008-02-02'

두 번째 argument 의 days 형식으로 호출될 때, MySQL 은 이를 expr 에 더할 정수 일수로 처리합니다.

1mysql> SELECT ADDDATE('2008-01-02', 31);
2          -> '2008-02-02'

date 또는 days 가 NULL 이면 이 함수는 NULL 을 반환합니다.

• ADDTIME(expr1,expr2)

ADDTIME()은 expr2 를 expr1 에 더하고 그 결과를 반환합니다. expr1 은 time 또는 datetime expression 이고, expr2 는 time expression 입니다. expr1 또는 expr2 가 NULL 이면 NULL 을 반환합니다.

이 함수 및 SUBTIME() 함수의 반환 타입은 다음과 같이 결정됩니다:

• 첫 번째 argument 가 동적 파라미터(예: prepared statement 에서)인 경우, 반환 타입은 TIME 입니다.

• 그렇지 않으면, 함수의 resolved 타입은 첫 번째 argument 의 resolved 타입에서 파생됩니다.

1mysql> SELECT ADDTIME('2007-12-31 23:59:59.999999', '1 1:1:1.000002');
2        -> '2008-01-02 01:01:01.000001'
3mysql> SELECT ADDTIME('01:00:00.999999', '02:00:00.999998');
4        -> '03:00:01.999997'

• CONVERT_TZ(dt,from_tz,to_tz)

CONVERT_TZ()는 datetime 값 dt 를 from_tz 로 지정된 time zone 에서 to_tz 로 지정된 time zone 으로 변환하고, 결과 값을 반환합니다. time zone 은 Section 7.1.15, “MySQL Server Time Zone Support”에 설명된 대로 지정합니다. argument 가 유효하지 않거나 NULL 인 경우 이 함수는 NULL 을 반환합니다.

32-bit 플랫폼에서 이 함수에 대해 지원되는 값의 범위는 TIMESTAMP 타입에 대한 범위와 동일합니다(범위 정보는 Section 13.2.1, “Date and Time Data Type Syntax” 참조). 64-bit 플랫폼에서 지원되는 최대 값은 '3001-01-18 23:59:59.999999' UTC 입니다.

플랫폼이나 MySQL 버전과 상관없이, 값이 from_tz 에서 UTC 로 변환될 때 지원되는 범위를 벗어나면 변환이 수행되지 않습니다.

1mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','GMT','MET');
2          -> '2004-01-01 13:00:00'
3mysql> SELECT CONVERT_TZ('2004-01-01 12:00:00','+00:00','+10:00');
4          -> '2004-01-01 22:00:00'

참고

'MET' 이나 'Europe/Amsterdam' 과 같은 named time zone 을 사용하려면 time zone 테이블이 올바르게 설정되어 있어야 합니다. 설정 방법은 Section 7.1.15, “MySQL Server Time Zone Support”를 참조하십시오.

• CURDATE()

현재 date 를 'YYYY-MM-DD' 또는 YYYYMMDD 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다.

1mysql> SELECT CURDATE();
2          -> '2008-06-13'
3mysql> SELECT CURDATE() + 0;
4          -> 20080613

• CURRENT_DATE, CURRENT_DATE()

CURRENT_DATE 와 CURRENT_DATE()는 CURDATE()의 synonym 입니다.

• CURRENT_TIME, CURRENT_TIME([fsp])

CURRENT_TIME 와 CURRENT_TIME()는 CURTIME()의 synonym 입니다.

• CURRENT_TIMESTAMP, CURRENT_TIMESTAMP([fsp])

CURRENT_TIMESTAMP 와 CURRENT_TIMESTAMP()는 NOW()의 synonym 입니다.

• CURTIME([fsp])

현재 time 을 'hh:mm:ss' 또는 hhmmss 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다. 값은 세션 time zone 으로 표현됩니다.

fsp argument 를 사용하여 0 에서 6 사이의 fractional seconds 정밀도를 지정하면, 반환 값에는 해당 자리수의 fractional seconds 부분이 포함됩니다.

1mysql> SELECT CURTIME();
2+-----------+
3| CURTIME() |
4+-----------+
5| 19:25:37  |
6+-----------+
7
8mysql> SELECT CURTIME() + 0;
9+---------------+
10| CURTIME() + 0 |
11+---------------+
12|        192537 |
13+---------------+
14
15mysql> SELECT CURTIME(3);
16+--------------+
17| CURTIME(3)   |
18+--------------+
19| 19:25:37.840 |
20+--------------+

• DATE(expr)

date 또는 datetime expression expr 의 date 부분을 추출합니다. expr 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT DATE('2003-12-31 01:02:03');
2          -> '2003-12-31'

• DATEDIFF(expr1,expr2)

DATEDIFF()는 한 date 에서 다른 date 까지의 일수로 표현된 expr1 − expr2 를 반환합니다. expr1 과 expr2 는 date 또는 date-and-time expression 입니다. 계산에는 값의 date 부분만 사용됩니다.

1mysql> SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');
2          -> 1
3mysql> SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31');
4          -> -31

이 함수는 expr1 또는 expr2 가 NULL 이면 NULL 을 반환합니다.

• DATE_ADD(date,INTERVAL expr unit), DATE_SUB(date,INTERVAL expr unit)

이들 함수는 date 연산을 수행합니다. date argument 는 시작 date 또는 datetime 값을 지정합니다. expr 은 시작 date 에 더하거나 뺄 interval 값을 지정하는 expression 입니다. expr 은 문자열로 평가되며, 음수 interval 의 경우 - 로 시작할 수 있습니다. unit 은 expression 이 해석되어야 하는 단위를 나타내는 키워드입니다.

temporal interval 구문, unit 지정자 전체 목록, 각 unit 값에 대한 expr argument 의 예상 형태, temporal 연산에서 operand 해석 규칙에 대한 자세한 내용은 Temporal Intervals를 참조하십시오.

반환 값은 argument 에 따라 달라집니다:

• date 가 NULL 이면, 함수는 NULL 을 반환합니다.

• date argument 가 DATE 값이고 계산에 YEAR, MONTH, DAY 부분만(즉, time 부분 없음) 관련되는 경우, 반환 타입은 DATE 입니다.

• date argument 가 TIME 값이고 계산에 HOURS, MINUTES, SECONDS 부분만(즉, date 부분 없음) 관련되는 경우, 반환 타입은 TIME 입니다.

• 첫 번째 argument 가 DATETIME(또는 TIMESTAMP) 값이거나, 첫 번째 argument 가 DATE 이고 unit 값이 HOURS, MINUTES, SECONDS 를 사용하는 경우, 또는 첫 번째 argument 가 TIME 타입이고 unit 값이 YEAR, MONTH, DAY 를 사용하는 경우, 반환 타입은 DATETIME 입니다.

• 첫 번째 argument 가 동적 파라미터(예: prepared statement 의)인 경우, 두 번째 argument 가 YEAR, MONTH, DAY 값만 포함하는 interval 이면 resolved 타입은 DATE 이고; 그렇지 않으면 타입은 DATETIME 입니다.

• 그렇지 않으면 문자열(타입 VARCHAR) 입니다.

결과가 DATETIME 이 되도록 보장하려면, CAST()를 사용하여 첫 번째 argument 를 DATETIME 으로 변환할 수 있습니다.

1mysql> SELECT DATE_ADD('2018-05-01',INTERVAL 1 DAY);
2        -> '2018-05-02'
3mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
4        -> '2017-05-01'
5mysql> SELECT DATE_ADD('2020-12-31 23:59:59',
6    ->                 INTERVAL 1 SECOND);
7        -> '2021-01-01 00:00:00'
8mysql> SELECT DATE_ADD('2018-12-31 23:59:59',
9    ->                 INTERVAL 1 DAY);
10        -> '2019-01-01 23:59:59'
11mysql> SELECT DATE_ADD('2100-12-31 23:59:59',
12    ->                 INTERVAL '1:1' MINUTE_SECOND);
13        -> '2101-01-01 00:01:00'
14mysql> SELECT DATE_SUB('2025-01-01 00:00:00',
15    ->                 INTERVAL '1 1:1:1' DAY_SECOND);
16        -> '2024-12-30 22:58:59'
17mysql> SELECT DATE_ADD('1900-01-01 00:00:00',
18    ->                 INTERVAL '-1 10' DAY_HOUR);
19        -> '1899-12-30 14:00:00'
20mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
21        -> '1997-12-02'
22mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
23    ->            INTERVAL '1.999999' SECOND_MICROSECOND);
24        -> '1993-01-01 00:00:01.000001'

MONTH interval 을 DATE 또는 DATETIME 값에 더할 때, 결과 date 에 해당 month 에 존재하지 않는 day 가 포함되면, day 는 아래와 같이 month 의 마지막 날로 조정됩니다:

1mysql> SELECT DATE_ADD('2024-03-30', INTERVAL 1 MONTH) AS d1,
2     >        DATE_ADD('2024-03-31', INTERVAL 1 MONTH) AS d2;
3+------------+------------+
4| d1         | d2         |
5+------------+------------+
6| 2024-04-30 | 2024-04-30 |
7+------------+------------+
81 row in set (0.00 sec)

• DATE_FORMAT(date,format)

date 값을 format 문자열에 따라 포맷합니다. argument 중 하나라도 NULL 이면 함수는 NULL 을 반환합니다.

다음 테이블에 표시된 지정자는 format 문자열에 사용할 수 있습니다. 포맷 지정자 문자 앞에는 % 문자가 필요합니다. 이 지정자는 다른 함수에도 적용됩니다: STR_TO_DATE(), TIME_FORMAT(), UNIX_TIMESTAMP().

Specifier	Description
%a	축약 weekday 이름<br> (Sun..Sat)
%b	축약 month 이름 (Jan..Dec)
%c	month, numeric (0..12)
%D	English suffix 가 있는 day of the month (0th,<br> 1st, 2nd,<br> 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 이름 (January..December)
%m	month, numeric (00..12)
%p	AM 또는 PM
%r	12-hour time( hh:mm:ss 뒤에<br> AM 또는 PM)
%S	seconds (00..59)
%s	seconds (00..59)
%T	24-hour time( hh:mm:ss)
%U	week (00..53), 여기서 Sunday 는<br> week 의 첫째 날;<br> WEEK() mode 0
%u	week (00..53), 여기서 Monday 는<br> week 의 첫째 날;<br> WEEK() mode 1
%V	week (01..53), 여기서 Sunday 는<br> week 의 첫째 날;<br> WEEK() mode 2; %X 와 함께 사용
%v	week (01..53), 여기서 Monday 는<br> week 의 첫째 날;<br> WEEK() mode 3; %x 와 함께 사용
%W	weekday 이름 (Sunday..Saturday)
%w	day of the week<br> (0=Sunday..6=Saturday)
%X	Sunday 가 week 의 첫째 날인 week 의 year, numeric,<br> 네 자리; %V 와 함께 사용
%x	Monday 가 week 의 첫째 날인 week 의 year, numeric,<br> 네 자리; %v 와 함께 사용
%Y	year, numeric, 네 자리
%y	year, numeric(두 자리)
%%	literal % 문자
%x	나열되지 않은 임의의<br> “x” 에 대해 x

Specifier	Description

month 와 day 지정자의 범위가 0 으로 시작하는 이유는 MySQL 이 '2014-00-00' 같은 incomplete date 의 저장을 허용하기 때문입니다.

day 및 month 이름과 약어에 사용되는 언어는 lc_time_names 시스템 변수의 값에 의해 제어됩니다( Section 12.16, “MySQL Server Locale Support”).

%U, %u, %V, %v 지정자에 대해서는 week numbering 에 영향을 주는 mode 값에 대한 정보를 WEEK() 함수 설명에서 참조하십시오.

DATE_FORMAT()는 character_set_connection 및 collation_connection에 의해 주어지는 character set 과 collation 을 가진 문자열을 반환하므로, non-ASCII 문자를 포함하는 month 및 weekday 이름을 반환할 수 있습니다.

1mysql> SELECT DATE_FORMAT('2009-10-04 22:23:00', '%W %M %Y');
2          -> 'Sunday October 2009'
3mysql> SELECT DATE_FORMAT('2007-10-04 22:23:00', '%H:%i:%s');
4          -> '22:23:00'
5mysql> SELECT DATE_FORMAT('1900-10-04 22:23:00',
6      ->                 '%D %y %a %d %m %b %j');
7          -> '4th 00 Thu 04 10 Oct 277'
8mysql> SELECT DATE_FORMAT('1997-10-04 22:23:00',
9      ->                 '%H %k %I %r %T %S %w');
10          -> '22 22 10 10:23:00 PM 22:23:00 00 6'
11mysql> SELECT DATE_FORMAT('1999-01-01', '%X %V');
12          -> '1998 52'
13mysql> SELECT DATE_FORMAT('2006-06-00', '%d');
14          -> '00'

• DATE_SUB(date,INTERVAL expr unit)

DATE_ADD()에 대한 설명을 참조하십시오.

• DAY(date)

DAY()는 DAYOFMONTH()의 synonym 입니다.

• DAYNAME(date)

date 에 대한 weekday 이름을 반환합니다. 이름에 사용되는 언어는 lc_time_names 시스템 변수의 값에 의해 제어됩니다( Section 12.16, “MySQL Server Locale Support” 참조). date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT DAYNAME('2007-02-03');
2          -> 'Saturday'

• DAYOFMONTH(date)

date 에 대한 month 의 day 를 1 에서 31 범위 내에서 반환하거나, day 부분이 zero 인 '0000-00-00' 또는 '2008-00-00' 과 같은 date 에 대해서는 0 을 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT DAYOFMONTH('2007-02-03');
2          -> 3

• DAYOFWEEK(date)

date 에 대한 weekday 인덱스를 반환합니다(1 = Sunday, 2 = Monday, …, 7 = Saturday). 이러한 인덱스 값은 ODBC 표준에 해당합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT DAYOFWEEK('2007-02-03');
2          -> 7

• DAYOFYEAR(date)

date 에 대한 year 의 day 를 1 에서 366 범위 내에서 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT DAYOFYEAR('2007-02-03');
2          -> 34

• EXTRACT(unit FROM date)

EXTRACT() 함수는 DATE_ADD() 나 DATE_SUB() 과 동일한 종류의 unit 지정자를 사용하지만, date 연산을 수행하는 대신 date 에서 부분을 추출합니다. unit argument 에 대한 정보는 Temporal Intervals를 참조하십시오. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT EXTRACT(YEAR FROM '2019-07-02');
2          -> 2019
3mysql> SELECT EXTRACT(YEAR_MONTH FROM '2019-07-02 01:02:03');
4          -> 201907
5mysql> SELECT EXTRACT(DAY_MINUTE FROM '2019-07-02 01:02:03');
6          -> 20102
7mysql> SELECT EXTRACT(MICROSECOND
8      ->                FROM '2003-01-02 10:30:00.000123');
9          -> 123

• FROM_DAYS(N)

day number N 을 주면, DATE 값을 반환합니다. N 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT FROM_DAYS(730669);
2          -> '2000-07-03'

FROM_DAYS()는 오래된 date 에 대해 주의해서 사용해야 합니다. 이 함수는 Gregorian calendar(1582) 이전의 값에 사용하기 위한 것이 아닙니다. Section 13.2.7, “What Calendar Is Used By MySQL?”를 참조하십시오.

• FROM_UNIXTIME(unix_timestamp[,format])

unix_timestamp 를 datetime 또는 문자형 문자열 값으로 표현하여 반환합니다. 반환되는 값은 세션 time zone 을 사용해 표현됩니다. (클라이언트는 Section 7.1.15, “MySQL Server Time Zone Support”에 설명된 대로 세션 time zone 을 설정할 수 있습니다.) unix_timestamp 는 UNIX_TIMESTAMP() 함수가 생성하는 것과 같이, '1970-01-01 00:00:00' UTC 이후의 seconds 를 나타내는 내부 timestamp 값입니다.

format 이 생략된 경우, 이 함수는 DATETIME 값을 반환합니다.

unix_timestamp 또는 format 이 NULL 이면, 이 함수는 NULL 을 반환합니다.

unix_timestamp 가 정수이면, DATETIME 의 fractional seconds 정밀도는 0 입니다. unix_timestamp 가 소수 값인 경우, DATETIME 의 fractional seconds 정밀도는 소수 값의 정밀도와 동일하며, 최대 6 입니다. unix_timestamp 가 부동 소수점 숫자인 경우, datetime 의 fractional seconds 정밀도는 6 입니다.

32-bit 플랫폼에서 unix_timestamp 에 대해 유용한 최대 값은 2147483647.999999 로, '2038-01-19 03:14:07.999999' UTC 를 반환합니다. 64-bit 플랫폼에서는 유효한 최대 값이 32536771199.999999 로, '3001-01-18 23:59:59.999999' UTC 를 반환합니다. 플랫폼이나 버전과 상관없이, unix_timestamp 가 유효한 최대 값보다 크면 0 을 반환합니다.

format 은 DATE_FORMAT() 함수에 사용되는 포맷 문자열과 동일한 방식으로 결과를 포맷하는 데 사용됩니다. format 이 제공되면, 반환 값은 VARCHAR 입니다.

1mysql> SELECT FROM_UNIXTIME(1447430881);
2          -> '2015-11-13 10:08:01'
3mysql> SELECT FROM_UNIXTIME(1447430881) + 0;
4          -> 20151113100801
5mysql> SELECT FROM_UNIXTIME(1447430881,
6      ->                      '%Y %D %M %h:%i:%s %x');
7          -> '2015 13th November 10:08:01 2015'

참고

UTC 가 아닌 time zone 의 값과 Unix timestamp 값 사이를 변환하기 위해 UNIX_TIMESTAMP() 와 FROM_UNIXTIME()를 사용하는 경우, 매핑이 양방향으로 one-to-one 이 아니므로 변환이 손실을 동반합니다. 자세한 내용은 UNIX_TIMESTAMP() 함수 설명을 참조하십시오.

• GET_FORMAT({DATE|TIME|DATETIME},{'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'})

포맷 문자열을 반환합니다. 이 함수는 DATE_FORMAT() 및 STR_TO_DATE() 함수와 조합하여 사용할 때 유용합니다.

format 이 NULL 이면, 이 함수는 NULL 을 반환합니다.

첫 번째 및 두 번째 argument 의 가능한 값은 여러 가지 포맷 문자열을 생성합니다(사용되는 지정자에 대해서는 DATE_FORMAT() 함수 설명의 테이블을 참조하십시오). ISO 포맷은 ISO 8601 이 아니라 ISO 9075 를 가리킵니다.

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'

Function Call	Result

TIMESTAMP 역시 GET_FORMAT()의 첫 번째 argument 로 사용할 수 있으며, 이 경우 함수는 DATETIME 에 대해 반환하는 값과 동일한 값을 반환합니다.

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

• HOUR(time)

time 에 대한 hour 를 반환합니다. 하루 시간 값의 경우 반환 값의 범위는 0 에서 23 입니다. 하지만 TIME 값의 범위는 실제로 훨씬 크므로, HOUR 는 23 보다 큰 값을 반환할 수 있습니다. time 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT HOUR('10:05:03');
2          -> 10
3mysql> SELECT HOUR('272:59:59');
4          -> 272

• LAST_DAY(date)

date 또는 datetime 값을 받아, 해당 month 의 마지막 날에 대한 값을 반환합니다. argument 가 잘못되었거나 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT LAST_DAY('2003-02-05');
2          -> '2003-02-28'
3mysql> SELECT LAST_DAY('2004-02-05');
4          -> '2004-02-29'
5mysql> SELECT LAST_DAY('2004-01-01 01:01:01');
6          -> '2004-01-31'
7mysql> SELECT LAST_DAY('2003-03-32');
8          -> NULL

• LOCALTIME, LOCALTIME([fsp])

LOCALTIME 와 LOCALTIME()는 NOW()의 synonym 입니다.

• LOCALTIMESTAMP, LOCALTIMESTAMP([fsp])

LOCALTIMESTAMP 와 LOCALTIMESTAMP()는 NOW()의 synonym 입니다.

• MAKEDATE(year,dayofyear)

year 와 day-of-year 값을 받아 date 를 반환합니다. dayofyear 가 0 이하이면 결과는 NULL 입니다. 둘 중 하나의 argument 가 NULL 인 경우에도 NULL 입니다.

1mysql> SELECT MAKEDATE(2011,31), MAKEDATE(2011,32);
2          -> '2011-01-31', '2011-02-01'
3mysql> SELECT MAKEDATE(2011,365), MAKEDATE(2014,365);
4          -> '2011-12-31', '2014-12-31'
5mysql> SELECT MAKEDATE(2011,0);
6          -> NULL

• MAKETIME(hour,minute,second)

hour, minute, second argument 에서 계산된 time 값을 반환합니다. argument 중 하나라도 NULL 이면 NULL 을 반환합니다.

second argument 는 소수 부분을 가질 수 있습니다.

1mysql> SELECT MAKETIME(12,15,30);
2          -> '12:15:30'

• MICROSECOND(expr)

time 또는 datetime expression expr 에서 microseconds 를 0 에서 999999 범위의 숫자로 반환합니다. expr 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT MICROSECOND('12:00:00.123456');
2          -> 123456
3mysql> SELECT MICROSECOND('2019-12-31 23:59:59.000010');
4          -> 10

• MINUTE(time)

time 에 대한 minute 를 0 에서 59 범위 내에서 반환하거나, time 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT MINUTE('2008-02-03 10:05:03');
2          -> 5

• MONTH(date)

date 에 대한 month 를 January 에서 December 까지 1 에서 12 범위 내에서 반환하거나, month 부분이 zero 인 '0000-00-00' 또는 '2008-00-00' 과 같은 date 에 대해서는 0 을 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

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

• MONTHNAME(date)

date 에 대한 month 의 전체 이름을 반환합니다. 이름에 사용되는 언어는 lc_time_names 시스템 변수의 값에 의해 제어됩니다( Section 12.16, “MySQL Server Locale Support”). date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT MONTHNAME('2008-02-03');
2          -> 'February'

• NOW([fsp])

현재 date 와 time 을 'YYYY-MM-DD hh:mm:ss' 또는 YYYYMMDDhhmmss 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다. 값은 세션 time zone 으로 표현됩니다.

fsp argument 를 사용하여 0 에서 6 사이의 fractional seconds 정밀도를 지정하면, 반환 값에는 해당 자리수의 fractional seconds 부분이 포함됩니다.

1mysql> SELECT NOW();
2          -> '2007-12-15 23:50:26'
3mysql> SELECT NOW() + 0;
4          -> 20071215235026.000000

NOW()는 statement 가 실행을 시작한 시점을 나타내는 상수 time 을 반환합니다. (저장 함수 또는 trigger 내에서는, NOW()는 함수나 triggering statement 가 실행을 시작한 시점을 반환합니다.) 이는 실제 실행 시점을 반환하는 SYSDATE()의 동작과 다릅니다.

1mysql> SELECT NOW(), SLEEP(2), NOW();
2+---------------------+----------+---------------------+
3| NOW()               | SLEEP(2) | NOW()               |
4+---------------------+----------+---------------------+
5| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
6+---------------------+----------+---------------------+
7
8mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
9+---------------------+----------+---------------------+
10| SYSDATE()           | SLEEP(2) | SYSDATE()           |
11+---------------------+----------+---------------------+
12| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
13+---------------------+----------+---------------------+

또한, SET TIMESTAMP statement 는 NOW()가 반환하는 값에는 영향을 주지만, SYSDATE()에는 영향을 주지 않습니다. 이는 binary log 의 timestamp 설정이 SYSDATE() 호출에는 영향을 주지 않음을 의미합니다. timestamp 를 nonzero 값으로 설정하면, 이후 NOW() 호출은 매번 그 값을 반환하게 됩니다. timestamp 를 0 으로 설정하면 이 효과가 취소되어, NOW()는 다시 현재 date 와 time 을 반환합니다.

두 함수의 차이에 대한 추가 정보는 SYSDATE() 설명을 참조하십시오.

• PERIOD_ADD(P,N)

P(형식은 YYMM 또는 YYYYMM) 에 N 개의 month 를 더합니다. 반환 값은 YYYYMM 형식입니다.

참고

period argument P 는 date 값이 아닙니다.

이 함수는 P 또는 N 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT PERIOD_ADD(200801,2);
2          -> 200803

• PERIOD_DIFF(P1,P2)

period P1 과 P2 사이의 month 수를 반환합니다. P1 과 P2 는 YYMM 또는 YYYYMM 형식이어야 합니다. period argument 인 P1 과 P2 는 date 값이 아님에 주의하십시오.

이 함수는 P1 또는 P2 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT PERIOD_DIFF(200802,200703);
2          -> 11

• QUARTER(date)

date 에 대한 year 의 quarter 를 1 에서 4 범위 내에서 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

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

• SECOND(time)

time 에 대한 second 를 0 에서 59 범위 내에서 반환합니다. time 이 NULL 이면 NULL 을 반환합니다.

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

• SEC_TO_TIME(seconds)

seconds argument 를 hour, minute, second 로 변환하여 TIME 값으로 반환합니다. 결과의 범위는 TIME 데이터 타입의 범위로 제한됩니다. argument 가 이 범위를 벗어나는 값에 해당하면 경고가 발생합니다.

seconds 가 NULL 이면 함수는 NULL 을 반환합니다.

1mysql> SELECT SEC_TO_TIME(2378);
2          -> '00:39:38'
3mysql> SELECT SEC_TO_TIME(2378) + 0;
4          -> 3938

• STR_TO_DATE(str,format)

이는 DATE_FORMAT() 함수의 역(inverse)입니다. 이 함수는 문자열 str 과 포맷 문자열 format 을 받습니다. STR_TO_DATE() 는 포맷 문자열에 date 와 time 부분이 모두 포함된 경우 DATETIME 값을, 문자열에 date 부분만 있거나 time 부분만 있는 경우에는 각각 DATE 또는 TIME 값을 반환합니다. str 또는 format 이 NULL 이면 함수는 NULL 을 반환합니다. 서버가 따르는 규칙에 따라 str 에서 추출된 date, time 또는 datetime 값을 파싱할 수 없으면, STR_TO_DATE() 는 NULL 을 반환하고 경고를 생성합니다.

서버는 format 과 일치시키려고 str 의 시작부터 스캔합니다. 포맷 문자열은 리터럴 문자와 % 로 시작하는 포맷 지정자를 포함할 수 있습니다. format 의 리터럴 문자는 str 에서 문자 그대로 일치해야 합니다. format 의 포맷 지정자는 str 에서 date 또는 time 부분과 일치해야 합니다. format 에 사용할 수 있는 지정자는 DATE_FORMAT() 함수 설명을 참조하십시오.

1mysql> SELECT STR_TO_DATE('01,5,2013','%d,%m,%Y');
2          -> '2013-05-01'
3mysql> SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y');
4          -> '2013-05-01'

스캔은 str 의 시작에서 시작하며, format 이 일치하지 않는다고 판단되면 실패합니다. str 끝의 추가 문자는 무시됩니다.

1mysql> SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s');
2          -> '09:30:17'
3mysql> SELECT STR_TO_DATE('a09:30:17','%h:%i:%s');
4          -> NULL
5mysql> SELECT STR_TO_DATE('09:30:17a','%h:%i:%s');
6          -> '09:30:17'

지정되지 않은 date 또는 time 부분은 0 값을 가지므로, str 에서 불완전하게 지정된 값은 일부 또는 전체 부분이 0 인 결과를 생성합니다:

1mysql> SELECT STR_TO_DATE('abc','abc');
2          -> '0000-00-00'
3mysql> SELECT STR_TO_DATE('9','%m');
4          -> '0000-09-00'
5mysql> SELECT STR_TO_DATE('9','%s');
6          -> '00:00:09'

date 값의 부분에 대한 범위 검사는 Section 13.2.2, “The DATE, DATETIME, and TIMESTAMP Types”에 설명된 대로 수행됩니다. 예를 들어, SQL mode 를 그러한 값을 허용하지 않도록 설정하지 않는 한, “zero” date 나 0 의 부분 값을 가진 date 가 허용됩니다.

1mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
2          -> '0000-00-00'
3mysql> SELECT STR_TO_DATE('04/31/2004', '%m/%d/%Y');
4          -> '2004-04-31'

NO_ZERO_DATE SQL mode 가 활성화되면, zero date 는 허용되지 않습니다. 이 경우, STR_TO_DATE()는 NULL 을 반환하고 경고를 생성합니다:

1mysql> SET sql_mode = '';
2mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
3+---------------------------------------+
4| STR_TO_DATE('00/00/0000', '%m/%d/%Y') |
5+---------------------------------------+
6| 0000-00-00                            |
7+---------------------------------------+
8mysql> SET sql_mode = 'NO_ZERO_DATE';
9mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
10+---------------------------------------+
11| STR_TO_DATE('00/00/0000', '%m/%d/%Y') |
12+---------------------------------------+
13| NULL                                  |
14+---------------------------------------+
15mysql> SHOW WARNINGS\G
16*************************** 1. row ***************************
17    Level: Warning
18     Code: 1411
19Message: Incorrect datetime value: '00/00/0000' for function str_to_date

이전 일부 MySQL 버전에서는 '2021-11-31' 같은 잘못된 date 문자열을 이 함수에 전달할 수 있었습니다. MySQL 9.5 에서는 STR_TO_DATE() 가 완전한 범위 검사를 수행하며, 변환 후 date 가 잘못된 경우 에러를 발생시킵니다.

참고

year-week 문자열을 date 로 변환하기 위해 포맷 "%X%V" 를 사용할 수 없습니다. 이는 week 가 month 경계를 넘는 경우 year 와 week 의 조합이 year 와 month 를 고유하게 식별하지 않기 때문입니다. year-week 를 date 로 변환하려면 weekday 도 지정해야 합니다:

1mysql> SELECT STR_TO_DATE('200442 Monday', '%X%V %W');
2          -> '2004-10-18'

또한, date 및 datetime 값의 date 부분에 대해, STR_TO_DATE() 는 year, month, day of month 의 개별 값에 대해서만 유효성을 검사함을 알아야 합니다. 보다 정확히는, year 가 0-9999 범위(포함)인지, month 가 1-12 범위(포함)인지, day of month 가 1-31 범위(포함)인지 확인하지만, 이 값들의 조합은 검사하지 않습니다. 예를 들어, SELECT STR_TO_DATE('23-2-31', '%Y-%m-%d') 은 2023-02-31 을 반환합니다. ALLOW_INVALID_DATES 서버 SQL mode 를 활성화하거나 비활성화해도 이 동작에는 영향이 없습니다. 자세한 내용은 Section 13.2.2, “The DATE, DATETIME, and TIMESTAMP Types”를 참조하십시오.

• SUBDATE(date,INTERVAL expr unit), SUBDATE(expr,days)

두 번째 argument 의 INTERVAL 형식으로 호출될 때, SUBDATE()는 DATE_SUB()의 synonym 입니다. INTERVAL unit argument 에 대한 정보는 DATE_ADD()에 대한 설명을 참조하십시오.

1mysql> SELECT DATE_SUB('2008-01-02', INTERVAL 31 DAY);
2          -> '2007-12-02'
3mysql> SELECT SUBDATE('2008-01-02', INTERVAL 31 DAY);
4          -> '2007-12-02'

두 번째 형식은 days 에 대해 정수 값을 사용할 수 있게 합니다. 이 경우, 이것은 date 또는 datetime expression expr 에서 뺄 day 수로 해석됩니다.

1mysql> SELECT SUBDATE('2008-01-02 12:00:00', 31);
2          -> '2007-12-02 12:00:00'

이 함수는 argument 중 하나라도 NULL 이면 NULL 을 반환합니다.

• SUBTIME(expr1,expr2)

SUBTIME()은 expr1 − expr2 를 expr1 과 동일한 포맷의 값으로 반환합니다. expr1 은 time 또는 datetime expression 이고, expr2 는 time expression 입니다.

이 함수의 반환 타입 resolution 은 ADDTIME() 함수와 동일하게 수행됩니다. 자세한 내용은 해당 함수 설명을 참조하십시오.

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

이 함수는 expr1 또는 expr2 가 NULL 이면 NULL 을 반환합니다.

• SYSDATE([fsp])

현재 date 와 time 을 'YYYY-MM-DD hh:mm:ss' 또는 YYYYMMDDhhmmss 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다.

fsp argument 를 사용하여 0 에서 6 사이의 fractional seconds 정밀도를 지정하면, 반환 값에는 해당 자리수의 fractional seconds 부분이 포함됩니다.

SYSDATE()는 실행 시점을 반환합니다. 이는 statement 가 실행을 시작한 시점을 나타내는 상수 time 을 반환하는 NOW()의 동작과 다릅니다. (저장 함수 또는 trigger 내에서는, NOW()는 함수나 triggering statement 가 실행을 시작한 시점을 반환합니다.)

1mysql> SELECT NOW(), SLEEP(2), NOW();
2+---------------------+----------+---------------------+
3| NOW()               | SLEEP(2) | NOW()               |
4+---------------------+----------+---------------------+
5| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
6+---------------------+----------+---------------------+
7
8mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
9+---------------------+----------+---------------------+
10| SYSDATE()           | SLEEP(2) | SYSDATE()           |
11+---------------------+----------+---------------------+
12| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
13+---------------------+----------+---------------------+

또한, SET TIMESTAMP statement 는 NOW()가 반환하는 값에는 영향을 주지만, SYSDATE()에는 영향을 주지 않습니다. 이는 binary log 의 timestamp 설정이 SYSDATE() 호출에는 영향을 주지 않음을 의미합니다.

SYSDATE()는 동일한 statement 내에서도 서로 다른 값을 반환할 수 있으며 SET TIMESTAMP 의 영향을 받지 않으므로, nondeterministic 하며 statement-based binary logging 이 사용되는 경우 replication 에 unsafe 합니다. 이것이 문제가 된다면 row-based logging 을 사용할 수 있습니다.

대안으로, --sysdate-is-now option 을 사용하여 SYSDATE()를 NOW()의 alias 가 되도록 할 수 있습니다. 이 option 은 replication source 서버와 replica 모두에서 사용되는 경우에만 동작합니다.

SYSDATE()의 nondeterministic 한 특성은, 이를 참조하는 expression 을 평가할 때 인덱스를 사용할 수 없음을 의미하기도 합니다.

• TIME(expr)

time 또는 datetime expression expr 의 time 부분을 추출하여 문자열로 반환합니다. expr 이 NULL 이면 NULL 을 반환합니다.

이 함수는 statement-based replication 에 unsafe 합니다. binlog_format이 STATEMENT 로 설정되어 있을 때 이 함수를 사용하면 경고가 기록됩니다.

1mysql> SELECT TIME('2003-12-31 01:02:03');
2          -> '01:02:03'
3mysql> SELECT TIME('2003-12-31 01:02:03.000123');
4          -> '01:02:03.000123'

• TIMEDIFF(expr1,expr2)

TIMEDIFF()는 expr1 − expr2 를 time 값으로 반환합니다. expr1 과 expr2 는 TIME 또는 DATETIME expression 으로 변환되는 문자열이어야 하며, 변환 후 타입은 동일해야 합니다. expr1 또는 expr2 가 NULL 이면 NULL 을 반환합니다.

TIMEDIFF() 가 반환하는 결과는 TIME 값에 허용되는 범위로 제한됩니다. 대안으로, TIMESTAMPDIFF() 나 UNIX_TIMESTAMP() 같은 함수를 사용할 수 있으며, 이들은 정수를 반환합니다.

1mysql> SELECT TIMEDIFF('2000-01-01 00:00:00',
2      ->                 '2000-01-01 00:00:00.000001');
3          -> '-00:00:00.000001'
4mysql> SELECT TIMEDIFF('2008-12-31 23:59:59.000001',
5      ->                 '2008-12-30 01:01:01.000002');
6          -> '46:58:57.999999'

• TIMESTAMP(expr), TIMESTAMP(expr1,expr2)

단일 argument 의 경우, 이 함수는 date 또는 datetime expression expr 을 datetime 값으로 반환합니다. 두 개의 argument 가 주어지면, time expression expr2 를 date 또는 datetime expression expr1 에 더해 그 결과를 datetime 값으로 반환합니다. expr, expr1, expr2 중 하나라도 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT TIMESTAMP('2003-12-31');
2          -> '2003-12-31 00:00:00'
3mysql> SELECT TIMESTAMP('2003-12-31 12:00:00','12:00:00');
4          -> '2004-01-01 00:00:00'

• TIMESTAMPADD(unit,interval,datetime_expr)

정수 expression interval 을 date 또는 datetime expression datetime_expr 에 더합니다. interval 에 대한 단위는 unit argument 로 주어지며, MICROSECOND(microseconds), SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, QUARTER, YEAR 중 하나여야 합니다.

unit 값은 위와 같이 키워드를 사용해 지정하거나, SQL_TSI_ prefix 를 붙여 지정할 수 있습니다. 예를 들어, DAY 와 SQL_TSI_DAY 모두 허용됩니다.

이 함수는 interval 또는 datetime_expr 가 NULL 이면 NULL 을 반환합니다.

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

MONTH interval 을 DATE 또는 DATETIME 값에 더할 때, 결과 date 에 해당 month 에 존재하지 않는 day 가 포함되면, day 는 아래와 같이 month 의 마지막 날로 조정됩니다:

1mysql> SELECT TIMESTAMPADD(MONTH, 1, DATE '2024-03-30') AS t1,
2       >        TIMESTAMPADD(MONTH, 1, DATE '2024-03-31') AS t2;
3+------------+------------+
4| t1         | t2         |
5+------------+------------+
6| 2024-04-30 | 2024-04-30 |
7+------------+------------+
81 row in set (0.00 sec)

• TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)

datetime_expr2 − datetime_expr1 을 반환합니다. datetime_expr1 과 datetime_expr2 는 date 또는 datetime expression 입니다. 한 expression 은 date 이고 다른 한 expression 은 datetime 일 수 있습니다. 필요한 경우, date 값은 time 부분이 '00:00:00' 인 datetime 으로 처리됩니다. 결과(정수)에 대한 단위는 unit argument 로 주어집니다. unit 에 대해 허용되는 값은 TIMESTAMPADD() 함수 설명에 나열된 값과 동일합니다.

이 함수는 datetime_expr1 또는 datetime_expr2 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01');
2          -> 3
3mysql> SELECT TIMESTAMPDIFF(YEAR,'2002-05-01','2001-01-01');
4          -> -1
5mysql> SELECT TIMESTAMPDIFF(MINUTE,'2003-02-01','2003-05-01 12:05:55');
6          -> 128885

참고

이 함수의 date 또는 datetime argument 순서는, 2개의 argument 로 호출될 때 TIMESTAMP() 함수에서 사용되는 순서와 반대입니다.

• TIME_FORMAT(time,format)

이 함수는 DATE_FORMAT() 함수와 동일하게 사용되지만, format 문자열은 hour, minute, second, microsecond 에 대한 포맷 지정자만 포함할 수 있습니다. 다른 지정자는 NULL 또는 0 을 생성합니다. time 또는 format 이 NULL 이면 TIME_FORMAT() 은 NULL 을 반환합니다.

time 값에 23 보다 큰 hour 부분이 포함된 경우, %H 와 %k hour 포맷 지정자는 일반적인 0..23 범위를 넘어서는 값을 생성합니다. 다른 hour 포맷 지정자는 hour 값을 12 로 나눈 나머지(modulo 12)로 생성합니다.

1mysql> SELECT TIME_FORMAT('100:00:00', '%H %k %h %I %l');
2          -> '100 100 04 04 4'

• TIME_TO_SEC(time)

time argument 를 seconds 로 변환하여 반환합니다. time 이 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT TIME_TO_SEC('22:23:00');
2          -> 80580
3mysql> SELECT TIME_TO_SEC('00:39:38');
4          -> 2378

• TO_DAYS(date)

date date 를 주면 day number(Year 0 이후 일 수)를 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT TO_DAYS(950501);
2          -> 728779
3mysql> SELECT TO_DAYS('2007-10-07');
4          -> 733321

TO_DAYS()는 Gregorian calendar(1582) 이전의 값에 대해 사용하도록 설계되지 않았으므로, calendar 가 변경되면서 사라진 날들을 고려하지 않습니다. 1582년(및 다른 로케일에서는 이후의 어떤 년도) 이전의 date 에 대해 이 함수의 결과는 신뢰할 수 없습니다. 자세한 내용은 Section 13.2.7, “What Calendar Is Used By MySQL?”를 참조하십시오.

MySQL 은 date 에서 두 자리 year 값을 Section 13.2, “Date and Time Data Types”에 설명된 규칙을 사용하여 네 자리 형식으로 변환함을 기억하십시오. 예를 들어, '2008-10-07' 과 '08-10-07' 은 동일한 date 로 간주됩니다:

1mysql> SELECT TO_DAYS('2008-10-07'), TO_DAYS('08-10-07');
2          -> 733687, 733687

MySQL 에서 zero date 는 그 자체로 잘못된 date 로 간주되지만, '0000-00-00' 으로 정의됩니다. 이는 '0000-00-00' 과 '0000-01-01' 에 대해 TO_DAYS()가 다음과 같은 값을 반환함을 의미합니다:

1mysql> SELECT TO_DAYS('0000-00-00');
2+-----------------------+
3| to_days('0000-00-00') |
4+-----------------------+
5|                  NULL |
6+-----------------------+
71 row in set, 1 warning (0.00 sec)
8
9mysql> SHOW WARNINGS;
10+---------+------+----------------------------------------+
11| Level   | Code | Message                                |
12+---------+------+----------------------------------------+
13| Warning | 1292 | Incorrect datetime value: '0000-00-00' |
14+---------+------+----------------------------------------+
151 row in set (0.00 sec)
16
17
18mysql> SELECT TO_DAYS('0000-01-01');
19+-----------------------+
20| to_days('0000-01-01') |
21+-----------------------+
22|                     1 |
23+-----------------------+
241 row in set (0.00 sec)

이는 ALLOW_INVALID_DATES SQL 서버 mode 가 활성화되었는지 여부와 관계없이 참입니다.

• TO_SECONDS(expr)

date 또는 datetime expr 을 주면, Year 0 이후 seconds 수를 반환합니다. expr 이 유효한 date 또는 datetime 값이 아니거나(NULL 포함)면 NULL 을 반환합니다.

1mysql> SELECT TO_SECONDS(950501);
2          -> 62966505600
3mysql> SELECT TO_SECONDS('2009-11-29');
4          -> 63426672000
5mysql> SELECT TO_SECONDS('2009-11-29 13:43:32');
6          -> 63426721412
7mysql> SELECT TO_SECONDS( NOW() );
8          -> 63426721458

TO_DAYS()와 마찬가지로, TO_SECONDS() 는 Gregorian calendar(1582) 이전의 값에 사용하도록 설계되지 않았습니다. calendar 가 변경되면서 사라진 날들을 고려하지 않기 때문입니다. 1582년(및 다른 로케일에서는 이후의 어떤 년도) 이전의 date 에 대해 이 함수의 결과는 신뢰할 수 없습니다. 자세한 내용은 Section 13.2.7, “What Calendar Is Used By MySQL?”를 참조하십시오.

TO_DAYS()와 마찬가지로, TO_SECONDS() 역시 Section 13.2, “Date and Time Data Types”에 설명된 규칙을 사용하여 date 에서 두 자리 year 값을 네 자리 형식으로 변환합니다.

MySQL 에서 zero date 는 그 자체로 잘못된 date 로 간주되지만, '0000-00-00' 으로 정의됩니다. 이는 '0000-00-00' 과 '0000-01-01' 에 대해 TO_SECONDS()가 다음과 같은 값을 반환함을 의미합니다:

1mysql> SELECT TO_SECONDS('0000-00-00');
2+--------------------------+
3| TO_SECONDS('0000-00-00') |
4+--------------------------+
5|                     NULL |
6+--------------------------+
71 row in set, 1 warning (0.00 sec)
8
9mysql> SHOW WARNINGS;
10+---------+------+----------------------------------------+
11| Level   | Code | Message                                |
12+---------+------+----------------------------------------+
13| Warning | 1292 | Incorrect datetime value: '0000-00-00' |
14+---------+------+----------------------------------------+
151 row in set (0.00 sec)
16
17
18mysql> SELECT TO_SECONDS('0000-01-01');
19+--------------------------+
20| TO_SECONDS('0000-01-01') |
21+--------------------------+
22|                    86400 |
23+--------------------------+
241 row in set (0.00 sec)

이는 ALLOW_INVALID_DATES SQL 서버 mode 가 활성화되었는지 여부와 관계없이 참입니다.

• UNIX_TIMESTAMP([date])

UNIX_TIMESTAMP()가 date argument 없이 호출되면, '1970-01-01 00:00:00' UTC 이후 seconds 를 나타내는 Unix timestamp 를 반환합니다.

UNIX_TIMESTAMP()가 date argument 와 함께 호출되면, argument 의 값을 '1970-01-01 00:00:00' UTC 이후 seconds 값으로 반환합니다. 서버는 date 를 세션 time zone 의 값으로 해석하고, 이를 UTC 의 내부 Unix timestamp 값으로 변환합니다. (클라이언트는 Section 7.1.15, “MySQL Server Time Zone Support”에 설명된 대로 세션 time zone 을 설정할 수 있습니다.) date argument 는 DATE, DATETIME, TIMESTAMP 문자열이거나, YYMMDD, YYMMDDhhmmss, YYYYMMDD, YYYYMMDDhhmmss 포맷의 숫자일 수 있습니다. argument 에 time 부분이 포함된 경우, 선택적으로 fractional seconds 부분을 포함할 수 있습니다.

argument 가 없거나 argument 에 fractional seconds 부분이 포함되지 않은 경우 반환 값은 정수이며, fractional seconds 부분이 포함된 argument 를 제공하면 반환 값은 DECIMAL 입니다.

date argument 가 TIMESTAMP column 인 경우, UNIX_TIMESTAMP()는 암묵적인 “string-to-Unix-timestamp” 변환 없이 내부 timestamp 값을 직접 반환합니다.

argument 값의 유효한 범위는 TIMESTAMP 데이터 타입과 동일합니다: 32-bit 플랫폼에서는 '1970-01-01 00:00:01.000000' UTC 에서 '2038-01-19 03:14:07.999999' UTC 까지; 64-bit 플랫폼에서 실행되는 MySQL 의 경우, UNIX_TIMESTAMP() 의 argument 에 대한 유효한 범위는 '1970-01-01 00:00:01.000000' UTC 에서 '3001-01-19 03:14:07.999999' UTC(32536771199.999999 seconds 에 해당) 까지입니다.

MySQL 버전이나 플랫폼 아키텍처와 관계없이, 범위를 벗어난 date 를 UNIX_TIMESTAMP()에 전달하면 0 을 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT UNIX_TIMESTAMP();
2          -> 1447431666
3mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19');
4          -> 1447431619
5mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19.012');
6          -> 1447431619.012

UTC 가 아닌 time zone 의 값과 Unix timestamp 값 사이를 변환하기 위해 UNIX_TIMESTAMP() 와 FROM_UNIXTIME()를 사용하는 경우, 매핑이 양방향으로 one-to-one 이 아니므로 변환이 손실을 동반합니다. 예를 들어, Daylight Saving Time(DST) 같은 로컬 time zone 변경 규칙 때문에, UNIX_TIMESTAMP()가 UTC 가 아닌 time zone 에서 서로 다른 두 값을 동일한 Unix timestamp 값으로 매핑할 수 있습니다. FROM_UNIXTIME()는 이 값을 원래 값들 중 하나로만 매핑합니다. 다음 예에서는 MET time zone 에서 서로 다른 값들을 사용합니다:

1mysql> SET time_zone = 'MET';
2mysql> SELECT UNIX_TIMESTAMP('2005-03-27 03:00:00');
3+---------------------------------------+
4| UNIX_TIMESTAMP('2005-03-27 03:00:00') |
5+---------------------------------------+
6|                            1111885200 |
7+---------------------------------------+
8mysql> SELECT UNIX_TIMESTAMP('2005-03-27 02:00:00');
9+---------------------------------------+
10| UNIX_TIMESTAMP('2005-03-27 02:00:00') |
11+---------------------------------------+
12|                            1111885200 |
13+---------------------------------------+
14mysql> SELECT FROM_UNIXTIME(1111885200);
15+---------------------------+
16| FROM_UNIXTIME(1111885200) |
17+---------------------------+
18| 2005-03-27 03:00:00       |
19+---------------------------+

참고

'MET' 이나 'Europe/Amsterdam' 과 같은 named time zone 을 사용하려면 time zone 테이블이 올바르게 설정되어 있어야 합니다. 설정 방법은 Section 7.1.15, “MySQL Server Time Zone Support”를 참조하십시오.

UNIX_TIMESTAMP() column 을 서로 빼고자 하는 경우, 이를 signed integer 로 cast 하기를 원할 수 있습니다. Section 14.10, “Cast Functions and Operators”를 참조하십시오.

• UTC_DATE, UTC_DATE()

현재 UTC date 를 'YYYY-MM-DD' 또는 YYYYMMDD 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다.

1mysql> SELECT UTC_DATE(), UTC_DATE() + 0;
2          -> '2003-08-14', 20030814

• UTC_TIME, UTC_TIME([fsp])

현재 UTC time 을 'hh:mm:ss' 또는 hhmmss 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다.

fsp argument 를 사용하여 0 에서 6 사이의 fractional seconds 정밀도를 지정하면, 반환 값에는 해당 자리수의 fractional seconds 부분이 포함됩니다.

1mysql> SELECT UTC_TIME(), UTC_TIME() + 0;
2          -> '18:07:53', 180753.000000

• UTC_TIMESTAMP, UTC_TIMESTAMP([fsp])

현재 UTC date 와 time 을 'YYYY-MM-DD hh:mm:ss' 또는 YYYYMMDDhhmmss 포맷의 값으로 반환하며, 함수가 문자열 컨텍스트에서 사용되는지 숫자 컨텍스트에서 사용되는지에 따라 달라집니다.

fsp argument 를 사용하여 0 에서 6 사이의 fractional seconds 정밀도를 지정하면, 반환 값에는 해당 자리수의 fractional seconds 부분이 포함됩니다.

1mysql> SELECT UTC_TIMESTAMP(), UTC_TIMESTAMP() + 0;
2          -> '2003-08-14 18:08:04', 20030814180804.000000

• WEEK(date[,mode])

이 함수는 date 에 대한 week number 를 반환합니다. WEEK()의 두 번째 argument 형식을 사용하면 week 가 Sunday 나 Monday 중 어느 날부터 시작하는지, 그리고 반환 값이 0 에서 53 범위인지 1 에서 53 범위인지 지정할 수 있습니다. mode argument 가 생략되면, default_week_format 시스템 변수의 값이 사용됩니다. Section 7.1.8, “Server System Variables”를 참조하십시오. date 값이 NULL 이면, 함수는 NULL 을 반환합니다.

다음 테이블은 mode argument 의 동작을 설명합니다.

Mode	First day of week	Range	Week 1 is the first week …
0	Sunday	0-53	이 year 에 Sunday 가 있는 week
1	Monday	0-53	이 year 에 4일 이상 포함된 week
2	Sunday	1-53	이 year 에 Sunday 가 있는 week
3	Monday	1-53	이 year 에 4일 이상 포함된 week
4	Sunday	0-53	이 year 에 4일 이상 포함된 week
5	Monday	0-53	이 year 에 Monday 가 있는 week
6	Sunday	1-53	이 year 에 4일 이상 포함된 week
7	Monday	1-53	이 year 에 Monday 가 있는 week

“이 year 에 4일 이상 포함된 week” 라는 의미를 갖는 mode 값의 경우, week 는 ISO 8601:1988 에 따라 번호가 매겨집니다:

• 1월 1일이 포함된 week 에 새해에 속하는 날이 4일 이상 포함된 경우, 이 week 가 week 1 입니다.

• 그렇지 않으면, 이 week 는 이전 year 의 마지막 week 이고, 다음 week 가 week 1 입니다.

1mysql> SELECT WEEK('2008-02-20');
2        -> 7
3mysql> SELECT WEEK('2008-02-20',0);
4        -> 7
5mysql> SELECT WEEK('2008-02-20',1);
6        -> 8
7mysql> SELECT WEEK('2008-12-31',1);
8        -> 53

date 가 이전 year 의 마지막 week 에 속하는 경우, optional mode argument 로 2, 3, 6, 7 을 사용하지 않으면 MySQL 은 0 을 반환합니다:

1mysql> SELECT YEAR('2000-01-01'), WEEK('2000-01-01',0);
2        -> 2000, 0

주어진 date 가 실제로 1999년의 52번째 week 에 속하므로, WEEK()가 52 를 반환해야 한다고 주장할 수도 있습니다. WEEK()는 대신 “주어진 year 에서의 week number” 를 의미하는 0 을 반환합니다. 이는 다른 date 부분을 추출하는 함수와 조합하여 WEEK() 함수를 신뢰할 수 있게 만듭니다.

주어진 date 에 대한 week 의 첫째 날을 포함하는 year 를 기준으로 평가된 결과를 선호한다면, optional mode argument 로 0, 2, 5, 7 중 하나를 사용하십시오.

1mysql> SELECT WEEK('2000-01-01',2);
2        -> 52

또는 YEARWEEK() 함수를 사용할 수 있습니다:

1mysql> SELECT YEARWEEK('2000-01-01');
2        -> 199952
3mysql> SELECT MID(YEARWEEK('2000-01-01'),5,2);
4        -> '52'

• WEEKDAY(date)

date 에 대한 weekday 인덱스를 반환합니다(0 = Monday, 1 = Tuesday, …, 6 = Sunday). date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT WEEKDAY('2008-02-03 22:23:00');
2          -> 6
3mysql> SELECT WEEKDAY('2007-11-06');
4          -> 1

• WEEKOFYEAR(date)

date 에 대한 calendar week 를 1 에서 53 범위 내의 숫자로 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

WEEKOFYEAR()는 WEEK(date,3)과 동일한 호환 함수입니다.

1mysql> SELECT WEEKOFYEAR('2008-02-20');
2          -> 8

• YEAR(date)

date 에 대한 year 를 1000 에서 9999 범위 내에서 반환하거나, “zero” date 에 대해서는 0 을 반환합니다. date 가 NULL 이면 NULL 을 반환합니다.

1mysql> SELECT YEAR('1987-01-01');
2          -> 1987

• YEARWEEK(date), YEARWEEK(date,mode)

date 에 대한 year 와 week 를 반환합니다. 결과의 year 는 year 의 첫 번째 week 및 마지막 week 에 대해 date argument 의 year 와 다를 수 있습니다. date 가 NULL 이면 NULL 을 반환합니다.

mode argument 는 WEEK()의 mode argument 와 정확히 동일하게 동작합니다. 단일 argument 형식에서는 mode 값 0 이 사용됩니다. WEEK()와 달리, default_week_format 의 값은 YEARWEEK()에 영향을 주지 않습니다.

1mysql> SELECT YEARWEEK('1987-01-01');
2          -> 198652

week number 는 optional argument 가 0 또는 1 일 때 WEEK()가 반환하는 값(0)과 다릅니다. 이는 WEEK()가 이 경우에 주어진 year 의 컨텍스트에서 week 를 반환하기 때문입니다.