MySQL5.6 날짜 및 시간 함수

12.7 날짜 및 시간 함수

이 섹션에서는 시간 값 처리에 사용할 수있는 함수에 대해 설명합니다. 각 날짜 기입 형이 가지는 값의 범위 및 값을 지정할 때의 유효한 형식에 대해서는 11.3 절 "날짜 및 시간 형식" 을 참조하십시오.

표 12.13 날짜 / 시간 함수

이름	설명
`ADDDATE ()`	날짜 값에 시간 값 (간격)을 가산합니다
`ADDTIME ()`	시간을 가산합니다
`CONVERT_TZ ()`	한 시간대에서 다른 시간대로 변환합니다
`CURDATE ()`	현재 날짜를 반환합니다
`CURRENT_DATE()` , `CURRENT_DATE`	CURDATE ()의 동의어입니다
`CURRENT_TIME()` , `CURRENT_TIME`	CURTIME ()의 동의어입니다
`CURRENT_TIMESTAMP()` , `CURRENT_TIMESTAMP`	NOW ()의 동의어입니다
`CURTIME ()`	현재의 시간을 돌려줍니다
`DATE_ADD ()`	날짜 값에 시간 값 (간격)을 가산합니다
`DATE_FORMAT ()`	날짜를 지정된 형식으로 설정합니다
`DATE_SUB ()`	날짜에서 시간 값 (간격)을 뺍니다
`DATE ()`	날짜 또는 시간 식의 날짜 부분을 추출합니다
`DATEDIFF ()`	두 날짜의 차이를 구합니다
`DAY ()`	DAYOFMONTH ()의 동의어입니다
`DAYNAME ()`	요일의 이름을 돌려줍니다
`DAYOFMONTH ()`	달의 날을 돌려줍니다 (0 - 31)
`DAYOFWEEK ()`	인수의 요일 인덱스를 돌려줍니다
`DAYOFYEAR ()`	설날을 반환합니다 (1 - 366)
`EXTRACT ()`	날짜의 일부를 추출합니다
`FROM_DAYS ()`	날짜를 날짜로 변환합니다
`FROM_UNIXTIME ()`	UNIX 타임 스탬프를 날짜로 서식합니다
`GET_FORMAT ()`	날짜 서식 캐릭터 라인을 돌려줍니다
`HOUR ()`	시간을 추출합니다
`LAST_DAY`	인수의 달의 마지막 날을 반환합니다
`LOCALTIME()` , `LOCALTIME`	NOW ()의 동의어입니다
`LOCALTIMESTAMP` , `LOCALTIMESTAMP()`	NOW ()의 동의어입니다
`MAKEDATE ()`	연도와 연도의 일에서 날짜를 만듭니다
`MAKETIME ()`	시, 분, 초에서 시간을 만듭니다
`MICROSECOND ()`	인수에서 마이크로 초를 반환합니다
`MINUTE ()`	인수에서 분을 반환합니다
`MONTH ()`	건네받은 날짜에서 월을 반환합니다
`MONTHNAME ()`	달의 이름을 돌려줍니다
`NOW ()`	현재 날짜와 시간을 반환합니다
`PERIOD_ADD ()`	세월에 기간을 가산합니다
`PERIOD_DIFF ()`	기간의 월수를 돌려줍니다
`QUARTER ()`	날짜 인수에서 분기를 돌려줍니다
`SEC_TO_TIME ()`	초 "HH : MM : SS"형식으로 변환합니다
`SECOND ()`	초 (0-59)을 반환합니다
`STR_TO_DATE ()`	문자열을 날짜로 변환합니다
`SUBDATE ()`	3 개의 인수로 호출 될 때 DATE_SUB ()의 동의어입니다
`SUBTIME ()`	시간의 차이를 구합니다
`SYSDATE ()`	이 함수가 실행되는 시간을 돌려줍니다
`TIME_FORMAT ()`	시간 서식합니다
`TIME_TO_SEC ()`	초로 변환 된 인수를 돌려줍니다
`TIME ()`	전달 된 표현식의시 부분을 추출합니다
`TIMEDIFF ()`	시간의 차이를 구합니다
`TIMESTAMP ()`	인수가 1 개의 경우,이 함수는 날짜 또는 시간 식을 반환합니다. 인수가 2 개의 경우, 인수의 합계를 반환합니다
`TIMESTAMPADD ()`	날짜 시간 식으로 간격을 가산합니다
`TIMESTAMPDIFF ()`	날짜 시간 식에서 간격을 뺍니다
`TO_DAYS ()`	하루에 변환 된 날짜 인수를 돌려줍니다
`TO_SECONDS ()`	0 년 이후 초에 변환 된 날짜 또는 시간 인수를 돌려줍니다
`UNIX_TIMESTAMP ()`	UNIX 타임 스탬프를 돌려줍니다
`UTC_DATE ()`	현재 UTC 날짜를 반환합니다
`UTC_TIME ()`	현재 UTC 시간을 반환합니다
`UTC_TIMESTAMP ()`	현재 UTC 날짜와 시간을 반환합니다
`WEEK ()`	주 번호를 반환합니다
`WEEKDAY ()`	요일 인덱스를 돌려줍니다
`WEEKOFYEAR ()`	날짜 달력 주를 반환합니다 (0 - 53)
`YEAR ()`	연도를 반환합니다
`YEARWEEK ()`	연도와 주를 반환합니다

다음 날짜 함수의 사용 예를 보여줍니다. 다음 쿼리는 지난 30 일 동안의 date_col 값을 포함하는 모든 행을 선택합니다.

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

이 쿼리는 미래의 날짜를 가진 행을 선택합니다.

일반적으로 날짜 값이 요구되는 함수는 날짜 시간 값이 받아 들여져 시간 부분은 무시됩니다. 일반적으로 시간 값이 요구되는 함수는 날짜 시간 값이 받아 들여져 날짜 부분은 무시됩니다.

현재 날짜 또는 시간을 각각 반환 함수는 쿼리 실행을 시작할 때 쿼리마다 한 번만 계산됩니다. 즉, NOW() 등의 함수가 단일 쿼리에서 여러 번 참조 되어도 항상 같은 결과가 생성됩니다. (설계, 단일 쿼리는 저장 프로그램 (스토어드 루틴, 트리거 또는 이벤트)의 호출 및 그 프로그램에 의해 호출되는 모든 하위 프로그램도 포함되어 있습니다.)이 원칙은 CURDATE() , CURTIME() , UTC_DATE() , UTC_TIME() , UTC_TIMESTAMP() 및 그 동의어에도 적용됩니다.

CURRENT_TIMESTAMP() , CURRENT_TIME() , CURRENT_DATE() 및 FROM_UNIXTIME() 함수는 time_zone 시스템 변수의 값으로 사용할 수있는 연결의 현재 시간대 값을 반환합니다. 또한 UNIX_TIMESTAMP() 는 인수가 현재의 시간대에서 날짜 시간 값으로 간주됩니다. 섹션 10.6 "MySQL Server에서 시간대 지원" 을 참조하십시오.

"zero"날짜 또는 '2001-11-00' 와 같은 불완전한 날짜와 함께 사용할 수있는 날짜 함수도 있지만, 사용할 수없는 날짜 함수도 있습니다. 일반적으로 날짜의 일부를 추출하는 함수는 불완전한 날짜도 제대로 작동하기 위해 0이 아닌 값이 요구되는 경우에 0을 반환 할 수 있습니다. 예 :

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

기타 함수는 완전한 날짜가 요구되고 날짜가 불완전한 경우는 NULL 이 반환됩니다. 여기에는 날짜 연산을 수행하는 함수와 날짜의 일부를 이름에 매핑하는 함수가 포함되어 있습니다. 예 :

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

MySQL 5.6.4의 시점에서는 일부 함수는 인자로 DATE() 함수의 값을 전달할 때 의해 엄격하게 되었기 때문에, 제로의 날짜 부분을 가지는 불완전한 날짜는 거부됩니다. CONVERT_TZ() , DATE_ADD() , DATE_SUB() , DAYOFYEAR() , LAST_DAY() , TIMESTAMPDIFF() , TO_DAYS() , TO_SECONDS() , WEEK() , WEEKDAY() , WEEKOFYEAR() , YEARWEEK() 함수가 영향 를받습니다. 5.6.5의 LAST_DAY() 에서는 이러한 제한이 완만 제로의 날짜 부분은 허용되어있었습니다.

MySQL 5.6.4 이상에서는 마이크로 초까지의 정확도를 가진 소수 초 TIME , DATETIME , 그리고 TIMESTAMP 값으로 지원하고 있습니다. 시간 인수를 취하는 함수는 초 부분을 포함한 값을 받아들입니다. 시간 함수의 반환 값은 필요에 따라 소수 초이 포함됩니다.

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

INTERVAL 형식의 두 번째 인수로 호출하면 ADDDATE() 는 DATE_ADD() 의 동의어입니다. 관련 함수 SUBDATE() 는 DATE_SUB() 의 동의어입니다. INTERVAL unit 인수는 DATE_ADD() 설명을 참조하십시오.
```
 mysql> SELECT DATE_ADD('2008-01-02', INTERVAL 31 DAY);
         -> '2008-02-02'
 mysql> SELECT ADDDATE('2008-01-02', INTERVAL 31 DAY);
         -> '2008-02-02'
```
days 형식의 두 번째 인수로 호출되면 MySQL은 expr 에 가산되는 정수의 일수로 처리됩니다.
```
 mysql> SELECT ADDDATE('2008-01-02', 31);
         -> '2008-02-02'
```

ADDTIME ( expr1 , expr2 )

ADDTIME() 는 expr2 와 expr1 을 더하고 결과를 반환합니다. expr1 은 시간 또는 날짜 시간 식이며 expr2 는 시간 식입니다.

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

CONVERT_TZ ( dt , from_tz , to_tz )

CONVERT_TZ() 날짜 시간 값 dt 를 from_tz 에서 지정된 시간대에서 to_tz 에서 지정된 시간대로 변환하고 결과 값을 반환합니다. 시간대는 섹션 10.6 "MySQL Server에서 시간대 지원" 에 설명 된대로 지정됩니다. 인수가 무효 인 경우,이 함수는 NULL 을 반환합니다.

from_tz 에서 UTC로 변환 될 때 값이 TIMESTAMP 에서 지원되는 범위를 벗어난 경우 변환이 수행되지 않습니다. TIMESTAMP 의 범위에 대해서는 섹션 11.1.2 "날짜 및 시간 형식 개요" 에 설명되어 있습니다.
```
 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'
```
참고
명명 된 시간대 ( 'MET' 이나 'Europe/Moscow' 등)을 사용하려면 시간대 테이블이 올바르게 설정되어 있어야합니다. 자세한 내용은 섹션 10.6 "MySQL Server에서 시간대 지원" 을 참조하십시오.
CURDATE ()

함수가 문자열과 숫자 문맥의 어디에서 사용되고 있는지에 따라 현재 날짜를 'YYYY-MM-DD' 또는 YYYYMMDD 형식의 값으로 반환합니다.
```
 mysql> SELECT CURDATE();
         -> '2008-06-13'
 mysql> SELECT CURDATE() + 0;
         -> 20080613
```
CURRENT_DATE , CURRENT_DATE()

CURRENT_DATE 및 CURRENT_DATE() 는 CURDATE() 의 동의어입니다.
CURRENT_TIME , CURRENT_TIME([ fsp ])

CURRENT_TIME 및 CURRENT_TIME() 는 CURTIME() 의 동의어입니다.
CURRENT_TIMESTAMP , CURRENT_TIMESTAMP([ fsp ])

CURRENT_TIMESTAMP 및 CURRENT_TIMESTAMP() 는 NOW() 의 동의어입니다.
CURTIME ( fsp )

함수가 문자열과 숫자 문맥의 어디에서 사용되고 있는지에 따라 현재 시간을 'HH:MM:SS' 또는 HHMMSS 형식의 값으로 반환합니다. 값은 현재의 시간대로 표현되어 있습니다.

MySQL 5.6.4의 시점에서는 0에서 6까지의 소수 초 정밀도를 지정하기 위해 fsp 인수가 지정되어있는 경우는 그 자리수의 소수 초 부분이 반환 값에 포함됩니다. 5.6.4 이전에서는 모든 인수가 무시됩니다.
```
 mysql> SELECT CURTIME();
         -> '23 : 50 : 26 '
 mysql> SELECT CURTIME() + 0;
         -> 235026.000000
```

DATE ( expr )

날짜 또는 시간 식 expr 의 날짜 부분을 추출합니다.

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

DATEDIFF ( expr1 , expr2 )

DATEDIFF() 는 한 날짜에서 다른 날짜까지의 날짜 값으로 표현 된 expr1 - expr2 를 반환합니다. expr1 과 expr2 는 날짜 또는 시간 식입니다. 값의 날짜 부분 만 계산에 사용됩니다.
```
 mysql> SELECT DATEDIFF('2007-12-31 23:59:59','2007-12-30');
         -> 1
 mysql> SELECT DATEDIFF('2010-11-30 23:59:59','2010-12-31');
         -> -31
```

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

이 함수는 날짜 연산을 수행합니다. date 인수는 시작 날짜 값 또는 시작 날짜 시간 값을 지정합니다. expr 는 시작 날짜로부터 가산 또는 감산되는 간격 값을 지정하는 식입니다. expr 는 문자열이며, 음수 간격의 경우 " - "로 시작할 수 있습니다. unit 식을 해석 할 때의 단위를 나타내는 키워드입니다.

INTERVAL 키워드 및 unit 지정자에서는 대소 문자를 구분하지 않습니다.

다음 표는 unit 값에 대해 요구되는 형식의 expr 인수를 표시합니다.

`unit` 값	요구되는 `expr` 서식
`MICROSECOND`	`MICROSECONDS`
`SECOND`	`SECONDS`
`MINUTE`	`MINUTES`
`HOUR`	`HOURS`
`DAY`	`DAYS`
`WEEK`	`WEEKS`
`MONTH`	`MONTHS`
`QUARTER`	`QUARTERS`
`YEAR`	`YEARS`
`SECOND_MICROSECOND`	`'SECONDS.MICROSECONDS'`
`MINUTE_MICROSECOND`	`'MINUTES : SECONDS.MICROSECONDS'`
`MINUTE_SECOND`	`'MINUTES : SECONDS'`
`HOUR_MICROSECOND`	`'HOURS : MINUTES : SECONDS.MICROSECONDS'`
`HOUR_SECOND`	`'HOURS : MINUTES : SECONDS'`
`HOUR_MINUTE`	`'HOURS : MINUTES'`
`DAY_MICROSECOND`	`'DAYS HOURS : MINUTES : SECONDS.MICROSECONDS'`
`DAY_SECOND`	`'DAYS HOURS : MINUTES : SECONDS'`
`DAY_MINUTE`	`'DAYS HOURS : MINUTES'`
`DAY_HOUR`	`'DAYS HOURS'`
`YEAR_MONTH`	`'YEARS-MONTHS'`

반환 값은 인수에 따라 다릅니다.

제 1 인자가 DATETIME (또는 TIMESTAMP ) 값인 경우와 제 1 인자가 DATE 에서 unit 값에 HOURS , MINUTES 또는 SECONDS 가 사용되는 경우는 DATETIME 입니다.
그렇지 않으면 문자열입니다.

반드시 결과가 DATETIME 되게하려면 CAST() 를 사용하면, 제 1 인수를 DATETIME 으로 변환 할 수 있습니다.

MySQL은 expr 형식의 문장 단락 문자가 허용됩니다. 표에는 제시되는 구분 기호를 표시합니다. date 인수가 DATE 값이며, 계산에 YEAR , MONTH 및 DAY 부분 만 포함 된 (즉, 시간 부분은 포함되지 않는다) 경우는 결과가 DATE 값입니다. 그렇지 않으면 결과가 DATETIME 값입니다.

또한 날짜 연산은 + 또는 - 연산자와 함께 INTERVAL 을 사용하여 수행 할 수 있습니다.

 date + INTERVAL expr unit
 date - INTERVAL expr unit

INTERVAL expr unit 는 다른 측면의식이 날짜 또는 날짜 사이 값 인 경우 + 연산자의 한쪽이 허용됩니다. - 연산자는 거리에서 날짜 또는 날짜 사이 값을 추출하고도 의미가 없기 때문에 INTERVAL expr unit 는 오른쪽에서만 허용됩니다.

 mysql> SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND;
         -> '2009-01-01 00:00:00'
 mysql> SELECT INTERVAL 1 DAY + '2008-12-31';
         -> '2009-01-01'
 mysql> SELECT '2005-01-01' - INTERVAL 1 SECOND;
         -> '2004-12-31 23:59:59'
 mysql> SELECT DATE_ADD('2000-12-31 23:59:59',
     ->  INTERVAL 1 SECOND);
         -> '2001-01-01 00:00:00'
 mysql> SELECT DATE_ADD('2010-12-31 23:59:59',
     ->  INTERVAL 1 DAY);
         -> '2011-01-01 23:59:59'
 mysql> SELECT DATE_ADD('2100-12-31 23:59:59',
     ->  INTERVAL '1:1' MINUTE_SECOND);
         -> '2101-01-01 00:01:00'
 mysql> SELECT DATE_SUB('2005-01-01 00:00:00',
     ->  INTERVAL '1 1:1:1' DAY_SECOND);
         -> '2004-12-30 22:58:59'
 mysql> SELECT DATE_ADD('1900-01-01 00:00:00',
     ->  INTERVAL '-1 10' DAY_HOUR);
         -> '1899-12-30 14:00:00'
 mysql> SELECT DATE_SUB('1998-01-02', INTERVAL 31 DAY);
         -> '1997-12-02'
 mysql> SELECT DATE_ADD('1992-12-31 23:59:59.000002',
     -> INTERVAL '1.999999' SECOND_MICROSECOND);
         -> '1993-01-01 00 : 00 : 01.000001'

지정된 간격 값 ( unit 키워드에서 요구되는 모든 간격 부분은 포함되지 않습니다)이 너무 짧은 경우, MySQL 그럼 간격 값의 왼쪽 부분이 생략 된 것으로 간주됩니다. 예를 들어, DAY_SECOND 의 unit 을 지정했을 경우는 expr 값은 일,시, 분, 초 부분이 포함 된 것으로 간주됩니다. '1:10' 과 같은 값을 지정하면 MySQL에서는 일과 시간 부분이 누락 있고, 값은 분과 초를 나타내는 것으로 간주됩니다. 즉, '1:10' DAY_SECOND 는 '1:10' MINUTE_SECOND 과 동일한 방법으로 해석됩니다. 이것은 MySQL에서 TIME 값이 시간이 아닌 경과 시간을 나타내고 있다고 해석하는 방법과 유사합니다.

expr 는 문자열로 처리되기 때문에 INTERVAL 에 문자열이 아닌 값을 지정하는 경우주의하십시오. 예를 들어, 간격 지정자가 HOUR_MINUTE 의 경우 6/4 가 1.5000 로 평가되어 1 시간 5000 분으로 처리됩니다.

 mysql> SELECT 6/4;
         -> 1.5000
 mysql> SELECT DATE_ADD('2009-01-01', INTERVAL 6/4 HOUR_MINUTE);
         -> '2009-01-04 12:20:00'

간격 값이 예상대로 해석되도록하려면 CAST() 연산을 사용합니다. 6/4 을 1 시간 5 분으로 처리하려면 소수점 이하의 자리수가 1 자리 DECIMAL 값으로 변환합니다.

 mysql> SELECT CAST(6/4 AS DECIMAL(3,1));
         -> 1.5
 mysql> SELECT DATE_ADD('1970-01-01 12:00:00',
     ->  INTERVAL CAST(6/4 AS DECIMAL(3,1)) HOUR_MINUTE);
         -> '1970-01-01 13:05:00'

시간 부분이 포함 된 것을 날짜 값에 더하거나 날짜 값에서 차감하거나하면 결과가 자동으로 날짜 시간 값으로 변환됩니다.

 mysql> SELECT DATE_ADD('2013-01-01', INTERVAL 1 DAY);
         -> '2013-01-02'
 mysql> SELECT DATE_ADD('2013-01-01', INTERVAL 1 HOUR);
         -> '2013-01-01 01:00:00'

MONTH , YEAR_MONTH 또는 YEAR 를 더한 결과의 날짜에 새로운 달의 최대 일수보다 큰 일이 있으면 그날이 새로운 달의 최대 기간이 조정됩니다.

 mysql> SELECT DATE_ADD('2009-01-30', INTERVAL 1 MONTH);
         -> '2009-02-28'

날짜 산술는 완전한 날짜가 필수이기 때문에 '2006-07-00' 와 같은 불완전한 날짜 나 잘못된 형식의 날짜가 제대로 작동하지 않습니다.

 mysql> SELECT DATE_ADD('2006-07-00', INTERVAL 1 DAY);
         -> NULL
 mysql> SELECT '2005-03-32' + INTERVAL 1 MONTH;
         -> NULL

DATE_FORMAT ( date , format )

format 문자열에 따라 date 값을 서식합니다.

다음 지정자가 format 문자열로 사용되는 경우가 있습니다. 형식 지정자 문자의 전에 " % "문자를 지정해야합니다.

지정자	설명
`% a`	간단한 요일 이름 ( `Sun` .. `Sat` )
`% b`	간단 월명 ( `Jan` .. `Dec` )
`% c`	월, 숫자 ( `0` .. `12` )
`% D`	영어 접미사를 가지는 일자 ( `0th` , `1st` , `2nd` , `3rd` , ...)
`% d`	날 숫자 ( `00` .. `31` )
`% e`	날, 숫자 ( `0` .. `31` )
`% f`	마이크로 세컨드 ( `000000` .. `999999` )
`% H`	시간 ( `00` .. `23` )
`% h`	시간 ( `01` .. `12` )
`% I`	시간 ( `01` .. `12` )
`% i`	분 숫자 ( `00` .. `59` )
`% j`	연도의 날 ( `001` .. `366` )
`% k`	때 ( `0` .. `23` )
`% l`	시 ( `1` .. `12` )
`% M`	월명 ( `January` .. `December` )
`% m`	월, 숫자 ( `00` .. `12` )
`% p`	`AM` 또는 `PM`
`% r`	시간, 12 시간 ( `hh:mm:ss` 에 `AM` 또는 `PM` 이 계속)
`% S`	초 ( `00` .. `59` )
`% s`	초 ( `00` .. `59` )
`% T`	시간, 24 시간 단위 ( `hh:mm:ss` )
`% U`	주 ( `00` .. `53` ), 일요일이주의 첫날 `WEEK()` 모드 0
`% u`	주 ( `00` .. `53` ), 월요일이 일주일의 첫날 `WEEK()` 모드 1
`% V`	주 ( `01` .. `53` ), 일요일이주의 첫날 `WEEK()` 모드 2, `%X` 와 함께 사용
`% v`	주 ( `01` .. `53` ), 월요일이 일주일의 첫날 `WEEK()` 모드 3 `%x` 와 함께 사용
`% W`	요일 이름 ( `Sunday` .. `Saturday` )
`% w`	요일 ( `0` = Sunday .. `6` = Saturday)
`% X`	연간 주 일요일이 일주일의 첫날, 숫자 4 자리, `%V` 와 함께 사용
`% x`	연간 주 월요일이 일주일의 첫날, 숫자 4 자리, `%v` 와 함께 사용
`% Y`	년, 숫자 4 자리
`% y`	연도 숫자 (2 자리)
`%%`	리터럴 " `%` "문자
`% x`	`x` (위없는 모든 " `x` ")

MySQL은 '2014-00-00' 등의 불완전한 날짜 저장이 허용되기 때문에 달과 일 지정자의 범위는 처음부터 시작됩니다.

일 및 월 이름과 약어 사용되는 언어는 lc_time_names 시스템 변수 ( 섹션 10.7 "MySQL Server의 로케일 지원" )의 값으로 제어됩니다.

%U % %u % %V 와 %v 지정자의 모드 값은 WEEK() 함수의 설명을 참조하십시오. 모드에 따라 주 번호가 부여되는 방식에 영향을받습니다.

DATE_FORMAT() 는 비 ASCII 문자가 포함 된 달과 주 이름을 반환 할 수 있도록 character_set_connection 및 collation_connection 에서 지정된 문자 집합 및 정렬 순서를 포함한 캐릭터 라인을 돌려줍니다.

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

DATE_SUB ( date , INTERVAL expr unit )

DATE_ADD() 설명을 참조하십시오.
DAY ( date )

DAY() 는 DAYOFMONTH() 의 동의어입니다.
DAYNAME ( date )

date 에 해당하는 요일의 이름을 반환합니다. 이름에 사용되는 언어는 lc_time_names 시스템 변수 ( 섹션 10.7 "MySQL Server의 로케일 지원" )의 값으로 제어됩니다.
```
 mysql> SELECT DAYNAME('2007-02-03');
         -> 'Saturday'
```
DAYOFMONTH ( date )

1 에서 31 까지의 범위 내에서 date 에 해당하는 날을 반환합니다. '0000-00-00' 또는 '2008-00-00' 처럼 일 파트가 0 인 경우는 0 을 돌려줍니다.
```
 mysql> SELECT DAYOFMONTH('2007-02-03');
         -> 3
```
DAYOFWEEK ( date )

date 의 요일 인덱스 ( 1 = Sunday, 2 = Monday, ..., 7 = Saturday)를 돌려줍니다. 이러한 인덱스 값은 ODBC 표준에 대응하고 있습니다.
```
 mysql> SELECT DAYOFWEEK('2007-02-03');
         -> 7
```
DAYOFYEAR ( date )

1 에서 366 까지의 범위 내에서 date 에 해당하는 통 날짜를 반환합니다.
```
 mysql> SELECT DAYOFYEAR('2007-02-03');
         -> 34
```

EXTRACT ( unit FROM 날짜 )

EXTRACT() 함수는 DATE_ADD() 나 DATE_SUB() 와 같은 단위 지정자를 사용하지만 데이터 연산이 수행되는 것이 아니라 데이터의 일부가 추출됩니다.

 mysql> SELECT EXTRACT(YEAR FROM '2009-07-02');
        -> 2009
 mysql> SELECT EXTRACT(YEAR_MONTH FROM '2009-07-02 01:02:03');
        -> 200907
 mysql> SELECT EXTRACT(DAY_MINUTE FROM '2009-07-02 01:02:03');
        -> 20102
 mysql> SELECT EXTRACT(MICROSECOND
     -> FROM '2003-01-02 10:30:00.000123');
         -> 123

FROM_DAYS ( N )

일수 N 가 지정되어 DATE 값을 반환합니다.
```
 mysql> SELECT FROM_DAYS(730669);
         -> '2007-07-03'
```
이전 날짜는 FROM_DAYS() 을 신중하게 사용하십시오. 태양력 (1582)의 출현 이전의 값과 함께 사용할 수 있도록 설계되어 있지 않습니다. 섹션 12.8 "MySQL에서 사용되는 달력" 을 참조하십시오.
FROM_UNIXTIME( unix_timestamp ) , FROM_UNIXTIME( unix_timestamp , format )

함수가 문자열과 숫자 중의 문맥으로 사용되었는지에 따라 unix_timestamp 인수의 표현을 'YYYY-MM-DD HH:MM:SS' 또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다. 값은 현재의 시간대로 표현되어 있습니다. unix_timestamp 는 UNIX_TIMESTAMP() 함수로 생성되도록 내부 타임 스탬프 값입니다.

format 이 지정되어있는 경우는 DATE_FORMAT() 함수의 항목으로 나열되는 경우와 같은 방법으로 사용되는 format 문자열에 따라 결과가 서식됩니다.
```
 mysql> SELECT FROM_UNIXTIME(1196440219);
         -> '2007-11-30 10:30:19'
 mysql> SELECT FROM_UNIXTIME(1196440219) + 0;
         -> 20071130103019.000000
 mysql> SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),
     -> '%Y %D %M %h:%i:%s %x');
         -> '2007 30th November 10:30:59 2007'
```
참고 : UNIX_TIMESTAMP() 및 FROM_UNIXTIME() 를 사용하여 TIMESTAMP 값과 Unix 타임 스탬프 값과 변환하려면 어느 방향에서도 매핑이 1 대 1이 아니므로 변환은 돌이킬입니다. 자세한 내용은 UNIX_TIMESTAMP() 함수의 설명을 참조하십시오.

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

서식 문자열을 반환합니다. 이 함수는 DATE_FORMAT() 과 STR_TO_DATE() 함수와 함께 사용하면 편리합니다.

1 번째와 2 번째의 인수에 값을 지정할 수 있으므로 여러 서식 문자열을 생성 할 수 있습니다 (사용되는 지정자에 대해서는 DATE_FORMAT() 함수의 설명에서 표를 참조하십시오). ISO 형식은 ISO 8601이 아니라 ISO 9075을 참조합니다.

함수 호출	결과
`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 는 GET_FORMAT() 에 대한 첫 번째 인수로 사용할 수 있습니다. 그 경우, 함수는 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 )

time 에 해당하는 시간을 반환합니다. 반환 값의 범위는 날짜 시간 값의 0 에서 23 까지입니다. 그러나 TIME 값의 범위는 실제로는 더 크기 때문에 HOUR 는 23 보다 큰 값을 반환 할 수 있습니다.
```
 mysql> SELECT HOUR('10:05:03');
         -> 10
 mysql> SELECT HOUR('272:59:59');
         -> 272
```

LAST_DAY ( date )

날짜 또는 시간 값이 지정된 달의 마지막 날에 해당하는 값을 반환합니다. 인수가 무효 인 경우는 NULL 를 돌려줍니다.

 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([ fsp ])

LOCALTIME 및 LOCALTIME() 는 NOW() 의 동의어입니다.
LOCALTIMESTAMP , LOCALTIMESTAMP([ fsp ])

LOCALTIMESTAMP 및 LOCALTIMESTAMP() 는 NOW() 의 동의어입니다.

MAKEDATE ( year , dayofyear )

지정된 연도와 연도 값에서 날짜를 리턴합니다. dayofyear 는 0보다 커야하며 그렇지 않으면 결과는 NULL 이됩니다.

 mysql> SELECT MAKEDATE(2011,31), MAKEDATE(2011,32);
         -> '2011-01-31', '2011-02-01'
 mysql> SELECT MAKEDATE(2011,365), MAKEDATE(2014,365);
         -> '2011-12-31', '2014-12-31'
 mysql> SELECT MAKEDATE(2011,0);
         -> NULL

MAKETIME ( hour , minute , second )

hour , minute 및 second 인수에서 계산 된 시간 값을 반환합니다.

MySQL 5.6.4의 시점에서는 second 인수에 소수 부분을 포함 할 수 있습니다.
```
 mysql> SELECT MAKETIME(12,15,30);
         -> '12 : 15 : 30 '
```

MICROSECOND ( expr )

0 에서 999999 까지의 범위의 수치로, 시간 또는 날짜 시간 식 expr 에서 마이크로 초를 반환합니다.

 mysql> SELECT MICROSECOND('12:00:00.123456');
         -> 123456
 mysql> SELECT MICROSECOND('2009-12-31 23:59:59.000010');
         -> 10

MINUTE ( time )

0 에서 59 까지의 범위 내에서 time 에 해당하는 분을 반환합니다.
```
 mysql> SELECT MINUTE('2008-02-03 10:05:03');
         -> 5
```
MONTH ( date )

1 (1 월)에서 12 (12 월)의 범위 내에서 date 에 해당하는 달을 반환합니다. '0000-00-00' 또는 '2008-00-00' 처럼 달의 파트가 0 인 경우는 0 을 돌려줍니다.
```
 mysql> SELECT MONTH('2008-02-03');
         -> 2
```
MONTHNAME ( date )

date 에 해당 월의 전체 이름을 반환합니다. 이름에 사용되는 언어는 lc_time_names 시스템 변수 ( 섹션 10.7 "MySQL Server의 로케일 지원" )의 값으로 제어됩니다.
```
 mysql> SELECT MONTHNAME('2008-02-03');
         -> 'February'
```
NOW ( fsp )

함수가 문자열과 숫자의 두 맥락에서 사용되고 있는지에 따라 현재 날짜와 시간을 'YYYY-MM-DD HH:MM:SS' 또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다. 값은 현재의 시간대로 표현되어 있습니다.

MySQL 5.6.4의 시점에서는 0에서 6까지의 소수 초 정밀도를 지정하기 위해 fsp 인수가 지정되어있는 경우는 그 자리수의 소수 초 부분이 반환 값에 포함됩니다. 5.6.4 이전에서는 모든 인수가 무시됩니다.
```
 mysql> SELECT NOW();
         -> '2007-12-15 23:50:26'
 mysql> SELECT NOW() + 0;
         -> 20071215235026.000000
```
NOW() 는 명령문이 실행을 시작하는 시간을 나타내는 상수 시간을 반환합니다. (스토어드 함수 또는 트리거는 NOW() 함수 또는 트리거 명령문이 실행을 시작하는 시간을 반환합니다.) 이것은 정확한 실행 시간을 반환 SYSDATE() 의 동작과는 다릅니다.
```
mysql> SELECT NOW(), SLEEP(2), NOW();
+---------------------+----------+---------------------+
| NOW()               | SLEEP(2) | NOW()               |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
+---------------------+----------+---------------------+

mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
+---------------------+----------+---------------------+
| SYSDATE()           | SLEEP(2) | SYSDATE()           |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
+---------------------+----------+---------------------+
```
또한 SET TIMESTAMP 명령문은 NOW() 에서 반환 된 값은 영향을 받지만 SYSDATE() 에서 반환 된 값은 영향을받지 않습니다. 즉, 바이너리 로그의 타임 스탬프 설정은 SYSDATE() 의 호출에 영향을 미치지 않음을 의미합니다. 타임 스탬프를 0이 아닌 값으로 설정하면 후속 NOW() 가 호출 될 때마다 그 값이 반환됩니다. 타임 스탬프를 제로로 설정하면이 효과가 취소되고 다시 NOW() 가 현재 날짜와 시간을 반환합니다.

두 함수의 차이점에 대한 자세한 내용은 SYSDATE() 의 설명을 참조하십시오.
PERIOD_ADD ( P , N )

N 달 기간 P 에 ( YYMM 또는 YYYYMM 형식으로) 가산합니다. YYYYMM 형식으로 값을 반환합니다.
참고
기간 인수 P 는 날짜 값이 없습니다.
```
 mysql> SELECT PERIOD_ADD(200801,2);
         -> 200803
```
PERIOD_DIFF ( P1 , P2 )

기간 P1 과 P2 사이의 개월 수를 반환합니다. P1 및 P2 는 YYMM 또는 YYYYMM 형식으로해야합니다. 기간 인수 P1 및 P2 는 날짜 값이 아닌 점에 유의하십시오.
```
 mysql> SELECT PERIOD_DIFF(200802,200703);
         -> 11
```
QUARTER ( date )

1 에서 4 까지의 범위 내에서 date 에 해당하는 분기를 돌려줍니다.
```
 mysql> SELECT QUARTER('2008-04-01');
         -> 2
```
SECOND ( time )

0 에서 59 까지의 범위 내에서 time 에 대응하는 초 수를 반환합니다.
```
 mysql> SELECT SECOND('10:05:03');
         -> 3
```
SEC_TO_TIME ( seconds )

TIME 값으로 시간, 분, 초로 변환 된 seconds 인수를 돌려줍니다. 결과의 범위는 TIME 데이터 타입의 범위에 제한됩니다. 인수가 범위를 벗어난 값에 해당하는 경우 경고가 발행됩니다.
```
 mysql> SELECT SEC_TO_TIME(2378);
         -> '00 : 39 : 38 '
 mysql> SELECT SEC_TO_TIME(2378) + 0;
         -> 3938
```
STR_TO_DATE ( str , format )

이것은 DATE_FORMAT() 함수의 반대입니다. 문자열 str 와 형식 문자열 format 이 지정됩니다. STR_TO_DATE() 는 형식 문자열에 날짜와 시간의 두 부분이 포함되는 경우는 DATETIME 값을 반환 문자열에 날짜와 시간 부분 중 하나만 있으면 DATE 또는 TIME 값을 반환합니다. str 에서 추출 된 날짜 값, 시간 값 또는 날짜 시간 값이 잘못된 경우 STR_TO_DATE() 에 의해 NULL 을 반환 경고가 발행됩니다.

서버는 str 을 스캔하여 format 의 일치를 시도합니다. 서식 캐릭터 라인은 리터럴 문자와 % 로 시작하는 서식 지정자를 포함 할 수 있습니다. format 의 리터럴 문자는 str 에서와 정확히 일치해야합니다. format 의 형식 지정자는 str 의 날짜 또는 시간 부분과 일치해야합니다. format 에 사용할 수있는 지정자에 대해서는 DATE_FORMAT() 함수의 설명을 참조하십시오.
```
 mysql> SELECT STR_TO_DATE('01,5,2013','%d,%m,%Y');
         -> '2013-05-01'
 mysql> SELECT STR_TO_DATE('May 1, 2013','%M %d,%Y');
         -> '2013-05-01'
```
str 의 처음부터 검색을 시작하고 일치하지 않는 format 이 발견되면 실패합니다. str 의 끝에있는 여분의 문자는 무시됩니다.
```
 mysql> SELECT STR_TO_DATE('a09:30:17','a%h:%i:%s');
         -> '09 : 30 : 17 '
 mysql> SELECT STR_TO_DATE('a09:30:17','%h:%i:%s');
         -> NULL
 mysql> SELECT STR_TO_DATE('09:30:17a','%h:%i:%s');
         -> '09 : 30 : 17 '
```
지정되지 않은 날짜 또는 시간 부분의 값은 0이되기 때문에 str 에 지정된 값이 불완전한 경우는 결과의 일부 또는 전부가 0으로 설정됩니다.
```
 mysql> SELECT STR_TO_DATE('abc','abc');
         -> '0000-00-00'
 mysql> SELECT STR_TO_DATE('9','%m');
         -> '0000-09-00'
 mysql> SELECT STR_TO_DATE('9','%s');
         -> '00 : 00 : 09 '
```
날짜 값 부분을 체크하는 범위는 섹션 11.3.1 "DATE, DATETIME, 그리고 TIMESTAMP 형" 의 설명대로입니다. 예를 들어, "제로"날짜 또는 부분 값이 0 날짜는 이러한 값이 허용되지 않도록 SQL 모드가 설정되어 있지 않으면 허용됩니다.
```
 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'
```
참고
주이 달의 경계를 넘은 경우는 연도와 주 조합은 해와 달을 고유하게 식별 할 수 없기 때문에 "%X%V" 형식을 사용하여 연도와 주 문자열을 날짜로 변환 할 수 없습니다. 연도와 주를 날짜로 변환하려면 요일도 지정해야합니다.
```
 mysql> SELECT STR_TO_DATE('200442 Monday', '%X%V %W');
         -> '2004-10-18'
```
SUBDATE( date ,INTERVAL expr unit ) , SUBDATE( expr , days )

INTERVAL 형식으로 두 번째 인수로 호출하면 SUBDATE() 는 DATE_SUB() 의 동의어입니다. INTERVAL unit 인수는 DATE_ADD() 설명을 참조하십시오.
```
 mysql> SELECT DATE_SUB('2008-01-02', INTERVAL 31 DAY);
         -> '2007-12-02'
 mysql> SELECT SUBDATE('2008-01-02', INTERVAL 31 DAY);
         -> '2007-12-02'
```
두 번째 형식에서는 days 정수 값을 사용할 수 있습니다. 이런 경우는 날짜 또는 시간 식 expr 에서 일수가 감소되는 것으로 해석됩니다.
```
 mysql> SELECT SUBDATE('2008-01-02 12:00:00', 31);
         -> '2007-12-02 12:00:00'
```

SUBTIME ( expr1 , expr2 )

SUBTIME() 은 expr1 과 동일한 형식으로 표현되는 expr1 과 expr2 를 반환합니다. expr1 은 시간 또는 날짜 시간 식이며 expr2 는 시간 식입니다.

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

SYSDATE ( fsp )

함수가 문자열과 숫자의 두 맥락에서 사용되고 있는지에 따라 현재 날짜와 시간을 'YYYY-MM-DD HH:MM:SS' 또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다.

MySQL 5.6.4의 시점에서는 0에서 6까지의 소수 초 정밀도를 지정하기 위해 fsp 인수가 지정되어있는 경우는 그 자리수의 소수 초 부분이 반환 값에 포함됩니다. 5.6.4 이전에서는 모든 인수가 무시됩니다.

SYSDATE() 가 실행 된 시간을 반환합니다. 이것은 명령문이 실행을 시작하는 시간을 나타내는 상수 시간을 반환 NOW() 의 동작과는 다릅니다. (스토어드 함수 또는 트리거는 NOW() 함수 또는 트리거 명령문이 실행을 시작하는 시간을 반환합니다.)
```
mysql> SELECT NOW(), SLEEP(2), NOW();
+---------------------+----------+---------------------+
| NOW()               | SLEEP(2) | NOW()               |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:36 |        0 | 2006-04-12 13:47:36 |
+---------------------+----------+---------------------+

mysql> SELECT SYSDATE(), SLEEP(2), SYSDATE();
+---------------------+----------+---------------------+
| SYSDATE()           | SLEEP(2) | SYSDATE()           |
+---------------------+----------+---------------------+
| 2006-04-12 13:47:44 |        0 | 2006-04-12 13:47:46 |
+---------------------+----------+---------------------+
```
또한 SET TIMESTAMP 명령문은 NOW() 에서 반환 된 값은 영향을 받지만 SYSDATE() 에서 반환 된 값은 영향을받지 않습니다. 즉, 바이너리 로그의 타임 스탬프 설정은 SYSDATE() 의 호출에 영향을 미치지 않음을 의미합니다.

SYSDATE() 은 같은 문 내에서도 다양한 값을 반환 할 수 있고 SET TIMESTAMP 의한 영향도받지 않기 때문에 비 결정적입니다. 따라서 명령문 기반 바이너리 로깅이 사용되는 경우 복제로 안전하게 사용할 수 없습니다. 이것이 문제가되는 경우는 행 기반 로깅을 사용할 수 있습니다.

또한 --sysdate-is-now 옵션을 사용하면 SYSDATE() 를 NOW() 의 별칭으로 할 수 있습니다. 이 옵션은 마스터와 슬레이브로 사용되는 경우에 작동합니다.

SYSDATE() 에 비 결정적인 특성이 있다는 것은 그것을 참조하는 수식을 평가할 때 인덱스를 사용할 수없는 것을 의미합니다.
TIME ( expr )

시간 또는 날짜 시간 식 expr 의 시간 부분을 추출하고 문자열로 반환합니다.

이 함수는 명령문 기반의 복제는 안전하게 사용할 수 없습니다. binlog_format 가 STATEMENT 로 설정되어있을 때이 함수를 사용하면 경고가 기록됩니다.
```
mysql> SELECT TIME ( '2003-12-31 01:02:03');
         -> '01 : 02 : 03 '
mysql> SELECT TIME ( '2003-12-31 01 : 02 : 03.000123');
         -> '01 : 02 : 03.000123 '
```
TIMEDIFF ( expr1 , expr2 )

TIMEDIFF () 은 시간 값으로 표현 된 expr1 - expr2 를 반환합니다. expr1 과 expr2 는 시간 또는 날짜 시간 식이지만, 모두 같은 형태로해야합니다.

TIMEDIFF () 에서 반환 된 결과는 TIME 값이 허용하는 범위로 제한되어 있습니다. 또한 TIMESTAMPDIFF () 및 UNIX_TIMESTAMP () 함수 중 하나를 사용할 수 있습니다. 모두 정수를 반환합니다.
```
mysql> SELECT TIMEDIFF ( '2000 : 01 : 01 00:00:00' 
    -> '2000 : 01 : 01 00 : 00 : 00.000001');
         -> '-00 : 00 : 00.000001'
mysql> SELECT TIMEDIFF ( '2008-12-31 23 : 59 : 59.000001' 
    -> '2008-12-30 01 : 01 : 01.000002');
         -> '46 : 58 : 57.999999 '
```
TIMESTAMP ( expr ) , TIMESTAMP ( expr1 , expr2 )

인수를 하나만 추가하면이 함수는 날짜 또는 시간 식 expr 을 날짜 시간 값으로 반환합니다. 인수를 두 넣으면 시간 식 expr2 를 날짜 또는 시간 식 expr1 에 더하고 결과를 날짜 시간 값으로 반환합니다.
```
mysql> SELECT TIMESTAMP ( '2003-12-31');
         -> '2003-12-31 00:00:00'
mysql> SELECT TIMESTAMP ( '2003-12-31 12:00:00', '12:00:00');
         -> '2004-01-01 00:00:00'
```
TIMESTAMPADD ( unit , interval , datetime_expr )

정수 식 interval 을 날짜 또는 시간 식 datetime_expr 에 가산합니다. interval 단위는 unit 인수로 지정됩니다. 이 인수는 MICROSECOND (마이크로 초), SECOND , MINUTE , HOUR , DAY , WEEK , MONTH , QUARTER , YEAR 값 중 하나를해야합니다.

unit 값을 지정하려면 여기에 표시된 키워드 중 하나를 사용하거나 SQL_TSI_ 을 접두어로 지정합니다. 예를 들어, DAY 와 SQL_TSI_DAY 는 모두 유효합니다.
```
mysql> SELECT TIMESTAMPADD (MINUTE 1 '2003-01-02');
         -> '2003-01-02 00:01:00'
mysql> SELECT TIMESTAMPADD (WEEK 1 '2003-01-02');
         -> '2003-01-09'
```
TIMESTAMPDIFF ( unit , datetime_expr1 , datetime_expr2 )

datetime_expr2 - datetime_expr1 을 반환합니다. datetime_expr1 과 datetime_expr2 는 날짜 또는 시간 식입니다. 식의 일방이 날짜이고, 다른 날짜 시간에 할 수 있습니다. 날짜 값은 필요에 따라 시간 부분이 '00 : 00 : 00 ' 의 날짜 시간으로 처리됩니다. 결과 (정수)의 단위는 unit 인수로 지정됩니다. unit 의 유효한 값은 TIMESTAMPADD () 함수의 설명에 나열 된 값과 동일합니다.
```
mysql> SELECT TIMESTAMPDIFF (MONTH '2003-02-01', '2003-05-01');
         -> 3
mysql> SELECT TIMESTAMPDIFF (YEAR '2002-05-01', '2001-01-01');
         -> -1
mysql> SELECT TIMESTAMPDIFF (MINUTE '2003-02-01', '2003-05-01 12:05:55');
         -> 128885
```
참고
이 함수의 날짜 또는 시간 인수의 순서는 TIMESTAMP () 함수를 두 개의 인수를 사용하여 호출 순서와 반대로됩니다.
TIME_FORMAT ( time , format )

이것은 DATE_FORMAT () 함수처럼 사용되지만, format 문자열은시, 분, 초, 마이크로 초 형식 지정자 만 포함 할 수 있습니다. 기타 지정자에서는 NULL 값 또는 0 이 생성됩니다.

time 값이 23 보다 큰 시간 부분이 포함 된 경우에는 % H 와 % k 시간 형식 지정자에 의해 0..23 의 정상 범위보다 큰 값이 생성됩니다. 다른 시간 형식 지정자에서는 시간 값 모듈로 (12)가 생성됩니다.
```
mysql> SELECT TIME_FORMAT ( '100 : 00 : 00', '% H % k % h % I % l');
         -> '100 100 04 04'
```

TIME_TO_SEC ( time )

초로 변환 된 time 인수를 돌려줍니다.

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

TO_DAYS ( date )

날짜 date 가 지정된 일수 (0 년 이후의 일)을 반환합니다.
```
mysql> SELECT TO_DAYS (950501);
         -> 728779
mysql> SELECT TO_DAYS ( '2007-10-07');
         -> 733321
```
TO_DAYS () 는 달력이 변경되었을 때 잃어버린 날이 고려되지 않기 때문에, 태양력 (1582)의 출현 이전의 값과 함께 사용하도록 설계되어 있지 않습니다. 날짜가 1582보다 이전 경우 (다른 로케일에서는 더 뒤의 해가 될 가능성이 있습니다)이 함수의 결과는 신뢰할 수 없습니다. 자세한 내용은 섹션 12.8 "MySQL에서 사용되는 달력" 을 참조하십시오.

MySQL은 11.3 절 "날짜 및 시간 형식" 규칙을 사용하여 날짜 2 자리 연도 값이 4 자리 형식으로 변환하는 것을 잊지 마십시오. 예를 들어, '2008-10-07' 과 '08 -10-07 ' 은 같은 날짜로 인식됩니다.
```
mysql> SELECT TO_DAYS ( '2008-10-07') TO_DAYS ('08 -10-07 ');
         -> 733687, 733687
```
MySQL에서 0 날짜는 '0000-00-00' 로 정의됩니다. 그러나이 데이터 자체는 무효로 간주됩니다. 즉, '0000-00-00' 과 '0000-01-01' 의 경우 TO_DAYS () 는 다음 값을 반환합니다.
```
mysql> SELECT TO_DAYS('0000-00-00');
+-----------------------+
| to_days('0000-00-00') |
+-----------------------+
|                  NULL |
+-----------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+----------------------------------------+
| Level   | Code | Message                                |
+---------+------+----------------------------------------+
| Warning | 1292 | Incorrect datetime value: '0000-00-00' |
+---------+------+----------------------------------------+
1 row in set (0.00 sec)


mysql> SELECT TO_DAYS('0000-01-01');
+-----------------------+
| to_days('0000-01-01') |
+-----------------------+
|                     1 |
+-----------------------+
1 row in set (0.00 sec)
```
이것은 ALLOW_INVALID_DATES SQL 서버 모드가 유효한지 여부에 관계없이 적용됩니다.
TO_SECONDS ( expr )

날짜 또는 시간 expr 이 지정된 0 년 이후의 날짜 수를 반환합니다. expr 이 유효한 날짜 또는 시간 값이 아닌 경우는 NULL 를 돌려줍니다.
```
mysql> SELECT TO_SECONDS (950501);
         -> 62966505600
mysql> SELECT TO_SECONDS ( '2009-11-29');
         -> 63426672000
mysql> SELECT TO_SECONDS ( '2009-11-29 13:43:32');
         -> 63426721412
mysql> SELECT TO_SECONDS (NOW ());
         -> 63426721458
```
TO_DAYS () 와 마찬가지로, TO_SECONDS () 는 달력이 변경되었을 때 잃어버린 날이 고려되지 않기 때문에, 태양력 (1582)의 출현 이전의 값과 함께 사용하도록 설계되어 있지 않습니다 . 날짜가 1582보다 이전 경우 (다른 로케일에서는 더 뒤의 해가 될 가능성이 있습니다)이 함수의 결과는 신뢰할 수 없습니다. 자세한 내용은 섹션 12.8 "MySQL에서 사용되는 달력" 을 참조하십시오.

TO_DAYS () 와 마찬가지로, TO_SECONDS () 는 11.3 절 "날짜 및 시간 형식" 규칙을 사용하여 날짜 2 자리 연도 값을 4 자리 형식으로 변환합니다.

MySQL에서 0 날짜는 '0000-00-00' 로 정의됩니다. 그러나이 데이터 자체는 무효로 간주됩니다. 즉, '0000-00-00' 과 '0000-01-01' 의 경우 TO_SECONDS () 는 다음 값을 반환합니다.
```
mysql> SELECT TO_SECONDS('0000-00-00');
+--------------------------+
| TO_SECONDS('0000-00-00') |
+--------------------------+
|                     NULL |
+--------------------------+
1 row in set, 1 warning (0.00 sec)

mysql> SHOW WARNINGS;
+---------+------+----------------------------------------+
| Level   | Code | Message                                |
+---------+------+----------------------------------------+
| Warning | 1292 | Incorrect datetime value: '0000-00-00' |
+---------+------+----------------------------------------+
1 row in set (0.00 sec)


mysql> SELECT TO_SECONDS('0000-01-01');
+--------------------------+
| TO_SECONDS('0000-01-01') |
+--------------------------+
|                    86400 |
+--------------------------+
1 row in set (0.00 sec)
```
이것은 ALLOW_INVALID_DATES SQL 서버 모드가 유효한지 여부에 관계없이 적용됩니다.
UNIX_TIMESTAMP () , UNIX_TIMESTAMP ( date )

인수없이 호출 된 경우, Unix 타임 스탬프 ( '1970-01-01 00:00:00' UTC 이후의 초)을 부호없는 정수로서 돌려줍니다. date 인수로 UNIX_TIMESTAMP () 가 불려 갔을 경우, 그 인수의 값이 '1970-01-01 00:00:00' UTC 이후의 초로 반환됩니다. date 는 DATE 문자열, DATETIME 문자열, TIMESTAMP , YYMMDD 또는 YYYYMMDD 형식의 숫자를 지정할 수 있습니다. 서버는 date 를 현재의 타임 존의 값으로 해석하고 UTC의 내부 값으로 변환합니다. 클라이언트는 섹션 10.6 "MySQL Server에서 시간대 지원" 에서 설명하는대로 자신의 시간대를 설정할 수 있습니다.
```
mysql> SELECT UNIX_TIMESTAMP ();
         -> 1196440210
mysql> SELECT UNIX_TIMESTAMP ( '2007-11-30 10:30:19');
         -> 1196440219
```
UNIX_TIMESTAMP () 가 TIMESTAMP 컬럼에서 사용되면 암묵적으로 ' string-to-Unix-timestamp " 로 변환되지 않고 내부 타임 스탬프 값을 직접 반환됩니다. UNIX_TIMESTAMP () 에 범위를 벗어난 날짜를 전달하면 0 이 반환됩니다.

참고 : UNIX_TIMESTAMP () 및 FROM_UNIXTIME () 를 사용하여 TIMESTAMP 값과 Unix 타임 스탬프 값과 변환하려면 어느 방향에서도 매핑이 1 대 1이 아니므로 변환은 돌이킬입니다. 예를 들어, 로컬 시간대를 변경하기위한 변환으로 인해 두 UNIX_TIMESTAMP () 에 2 개의 TIMESTAMP 값이 같은 Unix 타임 스탬프 값에 매핑 될 수 있습니다. FROM_UNIXTIME () 는 그 값을 원래 TIMESTAMP 값 중 하나에만 다시 매핑해야합니다. 그런 CET 시간대에서 TIMESTAMP 값의 사용 예를 보여줍니다.
```
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       |
+---------------------------+
```
UNIX_TIMESTAMP () 컬럼을 빼는 경우는 결과를 부호있는 정수로 변환합니다. 섹션 12.10 「캐스트 함수 및 연산자 " 를 참조하십시오.
UTC_DATE , UTC_DATE ()

함수가 문자열과 숫자의 두 맥락에서 사용되고 있는지에 따라 현재의 UTC 날짜를 'YYYY-MM-DD' 또는 YYYYMMDD 형식의 값으로 반환합니다.
```
mysql> SELECT UTC_DATE () UTC_DATE () + 0;
         -> '2003-08-14', 20030814
```
UTC_TIME , UTC_TIME ( fsp )

함수가 문자열과 숫자의 두 맥락에서 사용되고 있는지에 따라 현재 UTC 시간을 'HH : MM : SS' 또는 HHMMSS 형식의 값으로 반환합니다.

MySQL 5.6.4의 시점에서는 0에서 6까지의 소수 초 정밀도를 지정하기 위해 fsp 인수가 지정되어있는 경우는 그 자리수의 소수 초 부분이 반환 값에 포함됩니다. 5.6.4 이전에서는 모든 인수가 무시됩니다.
```
mysql> SELECT UTC_TIME () UTC_TIME () + 0;
         -> '18 : 07 : 53 ', 180753.000000
```
UTC_TIMESTAMP , UTC_TIMESTAMP ( fsp )

함수가 문자열과 숫자의 두 맥락에서 사용되고 있는지에 따라 현재의 UTC 날짜와 시간을 'YYYY-MM-DD HH : MM : SS' 또는 YYYYMMDDHHMMSS 형식의 값으로 반환합니다.

MySQL 5.6.4의 시점에서는 0에서 6까지의 소수 초 정밀도를 지정하기 위해 fsp 인수가 지정되어있는 경우는 그 자리수의 소수 초 부분이 반환 값에 포함됩니다. 5.6.4 이전에서는 모든 인수가 무시됩니다.
```
mysql> SELECT UTC_TIMESTAMP () UTC_TIMESTAMP () + 0;
         -> '2003-08-14 18:08:04', 20030814180804.000000
```

WEEK ( date [, mode ])

이 함수는 date 에 해당주의 번호를 반환합니다. 2 개의 인수를 취하는 형식의 WEEK () 를 사용하면 주 일요일과 월요일의 어느쪽으로부터 시작되는지, 그리고 반환 값이 0 에서 53 까지와 1 에서 53 까지의 어느 범위인지를 지정할 수 있습니다 . mode 인수가 생략 된 경우 default_week_format 시스템 변수의 값이 사용됩니다. 섹션 5.1 "서버 시스템 변수" 를 참조하십시오.

다음 표에서는 mode 인수가 어떻게 작동하는지에 대해 설명합니다.

모드	주 1 일	범위	제 1 주 다음 조건이 충족 첫 주
0	일요일	0-53	올해의 일요일을 포함
1	월요일	0-53	올해의 4 일 이상을 포함
2	일요일	1-53	올해의 일요일을 포함
3	월요일	1-53	올해의 4 일 이상을 포함
4	일요일	0-53	올해의 4 일 이상을 포함
5	월요일	0-53	올해의 월요일을 포함
6	일요일	1-53	올해의 4 일 이상을 포함
7	월요일	1-53	올해의 월요일을 포함

" 올해의 4 일 이상을 포함하는 ' 이라는 의미를 가진 mode 값은 ISO 8601 : 1988에 따라週番가 표시됩니다.

1 월 1 일 주간에 새해 4 일 이상이있는 경우 그 주가 제 1 주입니다.
그렇지 않으면, 전년의 마지막 주입니다 다음의 주가 제 1 주입니다.

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

날짜가 전년의 마지막 주에있을 경우, 옵션의 mode 인수로 2 , 3 , 6 또는 7 을 사용하지 않으면, MySQL에 의해 0 이 반환됩니다.

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

지정된 날짜 실제로 1999 년의 제 52 주에 발생하기 때문에 WEEK () 는 52 를 반환 할 필요가 있다고 논의 될 수도 있습니다. 대신 WEEK () 는 반환 값이 " 지정된 연도의 주 번호 " 가되도록 0 을 반환합니다. 이렇게하면 날짜에서 날짜 부분을 추출하는 다른 함수와 결합 WEEK () 함수를 신뢰하고 사용할 수 있습니다.

지정된 날짜에 해당주의 1 일째를 포함 해에 대해 평가 된 결과를 우선하는 경우, 옵션의 mode 인수로서 0 , 2 , 5 또는 7 을 사용합니다.

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

또는 YEARWEEK () 함수를 사용합니다.

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

WEEKDAY ( date )

date 에 해당하는 요일 인덱스 ( 0 = Monday, 1 = Tuesday, ... 6 = Sunday)을 반환합니다.

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

WEEKOFYEAR ( date )

1 에서 53 까지의 범위 내에서 날짜의 달력 주를 반환합니다. WEEKOFYEAR () 는 WEEK ( date , 3) 에 완벽하게 호환되는 함수입니다.
```
mysql> SELECT WEEKOFYEAR ( '2008-02-20');
         -> 8
```
YEAR ( date )

1000 에서 9999 까지의 범위 내에서 date 에 해당하는 연도를 반환합니다. 날짜가 " 제로 " 의 경우는 0 을 돌려줍니다.
```
mysql> SELECT YEAR ( '1987-01-01');
         -> 1987
```
YEARWEEK ( date ) , YEARWEEK ( date , mode )

날짜에 해당하는 연도와 주를 반환합니다. mode 인수는 WEEK () 의 mode 인수와 동일하게 작동합니다. 결과의 연도와 날짜 인수 연도는 그 해의 처음과 마지막 주이 다를 수 있습니다.
```
mysql> SELECT YEARWEEK ( '1987-01-01');
         -> 198653
```
WEEK () 는 다음 지정된 연도의 문맥에서 주를 반환하므로 주 번호는 선택적 인수 0 또는 1 을 선택한 경우에 WEEK () 함수에서 반환되는 숫자 ( 0 )와는 다릅니다.