ADDDATE(日期,INTERVAL expr unit), ADDDATE(日期,天数)

当使用第二个参数的INTERVAL形式时，ADDDATE() 等同于DATE_ADD()。相关函数SUBDATE() 等同于DATE_SUB()。关于INTERVALunit参数的信息，请参见时间间隔。

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'

当使用第二个参数的天数形式时，MySQL将其视为要添加到expr中的整数天数。

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

这个函数如果日期或天数为NULL，则返回NULL。

ADDTIME(expr1,expr2)

ADDTIME() 将 expr2 添加到 expr1 并返回结果。 expr1 是时间或日期表达式，expr2 是时间表达式。如果 expr1 或 expr2 是 NULL，则返回 NULL。

这个函数和SUBTIME() 函数的返回类型如下确定：

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() 将 datetime 值 dt 从由 from_tz 指定的时区转换到由 to_tz 指定的时区，并返回结果值。时区指定见第7.1.15节，“MySQL 服务器时区支持”。该函数如果任何参数无效或为 NULL，返回 NULL。

在32位平台上，这个函数的支持值范围与TIMESTAMP 类型相同（见第13.2.1节，“日期和时间数据类型语法”，获取范围信息）。在64位平台上，最大支持值为 '3001-01-18 23:59:59.999999' UTC。

不管平台或 MySQL 版本，如果值在转换到 UTC 时超出支持范围，无转换发生。

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

CURDATE()

返回当前日期作为一个值，格式为 '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 格式，取决于函数在字符串或数字上下文中。该值以会话时区表示。

如果指定了 fsp 参数，以指定小数秒精度从 0 到 6，小数秒部分将包含该多个数字。

mysql> SELECT CURTIME();
+-----------+
| CURTIME() |
+-----------+
| 19:25:37  |
+-----------+

mysql> SELECT CURTIME() + 0;
+---------------+
| CURTIME() + 0 |
+---------------+
|        192537 |
+---------------+

mysql> SELECT CURTIME(3);
+--------------+
| CURTIME(3)   |
+--------------+
| 19:25:37.840 |
+--------------+

DATE(expr)

从日期或日期时间表达式 expr 中提取日期部分。如果 expr 是 NULL，则返回 NULL。

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

DATEDIFF(expr1,expr2)

DATEDIFF() 返回从一个日期到另一个日期的天数差异，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

如果 expr1 或 expr2 是 NULL，则该函数返回 NULL。

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

这些函数执行日期算术。date 参数指定开始日期或datetime值。expr 是一个指定要添加或减去的间隔值表达式，expr 将被评估为字符串，可以以 - 开头表示负间隔。unit 是一个关键字，指示表达式应该如何解释。

关于时间间隔语法的更多信息，包括完整的unit指定符列表、每个unit值对应的expr参数形式和时间间隔算术运算中的操作数解释，见时间间隔。

返回值取决于参数：

为了确保结果是DATETIME，可以使用CAST()将第一个参数转换为DATETIME。

mysql> SELECT DATE_ADD('2018-05-01',INTERVAL 1 DAY);
        -> '2018-05-02'
mysql> SELECT DATE_SUB('2018-05-01',INTERVAL 1 YEAR);
        -> '2017-05-01'
mysql> SELECT DATE_ADD('2020-12-31 23:59:59',
    ->                 INTERVAL 1 SECOND);
        -> '2021-01-01 00:00:00'
mysql> SELECT DATE_ADD('2018-12-31 23:59:59',
    ->                 INTERVAL 1 DAY);
        -> '2019-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('2025-01-01 00:00:00',
    ->                 INTERVAL '1 1:1:1' DAY_SECOND);
        -> '2024-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'

在将MONTH间隔添加到DATE或DATETIME值时，如果结果日期包含不在给定月份中的天数，天数将被调整到该月的最后一天，如下所示：

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

DATE_FORMAT(date,format)

根据format字符串格式化date值。如果两个参数都为NULL，函数返回NULL。

以下表格中的指定符可以在format字符串中使用。%字符是必需的，格式指定符字符前缀。这些指定符也适用于其他函数：STR_TO_DATE()、TIME_FORMAT()、UNIX_TIMESTAMP()。

月份和日期指定的范围从零开始，因为 MySQL 允许存储不完整的日期，如 '2014-00-00'。

控制日、月名称和缩写的语言由系统变量lc_time_names 的值控制（第12.16节，“MySQL 服务器 locale 支持”）。

对于 %U、%u、%V 和 %v 指定符，请查看WEEK() 函数的描述，了解模式值对周号命名的影响。

DATE_FORMAT() 返回一个字符集和排序规则由character_set_connection 和collation_connection 给定的字符串，以便返回包含非 ASCII 字符的月份和星期名称。

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 控制（见第12.16节，“MySQL 服务器 locale 支持”）。如果 date 是 NULL，则返回 NULL。

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

DAYOFMONTH(date)

返回 date 的月份，范围为 1 到 31，或对日期如 '0000-00-00' 或 '2008-00-00' 的零天部分返回 0。如果 date 是 NULL，则返回 NULL。

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

DAYOFWEEK(date)

返回 date 的星期几索引（1 = 星期天，2 = 星期一，…，7 = 星期六）。如果 date 是 NULL，则返回 NULL。

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

DAYOFYEAR(date)

返回 date 的年内日索引，范围为 1 到 366。如果 date 是 NULL，则返回 NULL.

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

EXTRACT(unit FROM date)

函数EXTRACT() 使用与DATE_ADD() 或 DATE_SUB() 相同的 unit 指定符，但从日期中提取部分，而不是执行日期运算。关于 unit 参数，请参阅时间间隔。如果 date 是 NULL，则返回 NULL.

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

FROM_DAYS(N)

给定一个日数 N，返回一个DATE 值。如果 N 是 NULL，则返回 NULL。

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

使用FROM_DAYS()时要小心。它不适用于前于格里高兰历的日期（1582年）。请参阅Section 13.2.7。

FROM_UNIXTIME(unix_timestamp[,format])

返回一个表示 unix_timestamp 的日期或字符字符串值。返回的值使用会话时区表达（客户端可以按照Section 7.1.15 中描述设置会话时区）。 unix_timestamp 是一个内部时间戳值，表示自 UTC‘1970-01-01 00:00:00’以来的秒数，如UNIX_TIMESTAMP() 函数生产的。

如果省略了format，该函数返回一个DATETIME值。

如果unix_timestamp或format为NULL，该函数返回NULL。

如果unix_timestamp是整数，那么DATETIME的小数秒精度为零。若unix_timestamp是一个十进制值，那么DATETIME的小数秒精度与该值相同，至多6位。若unix_timestamp是一个浮点数，那么datetime的小数秒精度为6位。

在32位平台上，unix_timestamp的最大有用值是2147483647.999999，返回UTC时间‘2038-01-19 03:14:07.999999’。在64位平台上，有效的最大值为32536771199.999999，返回UTC时间‘3001-01-18 23:59:59.999999’。无论平台还是版本，unix_timestamp的值大于有效最大值都将返回0。

format 用于将结果格式化，类似于DATE_FORMAT() 函数中的格式字符串。如果提供了 format，返回的值是一个VARCHAR。

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

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

返回一个格式字符串。这一函数在与DATE_FORMAT() 和 STR_TO_DATE() 函数结合时非常有用。

如果 format 是 NULL，这个函数返回 NULL。

第一个和第二个参数的可能值导致了多种格式字符串（用于指定的，见DATE_FORMAT()函数描述）。ISO 格式指的是 ISO 9075，不是 ISO 8601。

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(<em class="replaceable"><code>time</code></em>)

返回 <code>time</code> 的小时。返回值的范围是 0 到 23，但实际上 TIME 值的范围更大，所以 HOUR 可以返回值大于 23。如果 <code>time</code> 是 NULL，则返回 NULL。

mysql> SELECT HOUR('10:05:03');
        -> 10
mysql> SELECT HOUR('272:59:59');
        -> 272

LAST_DAY(<em class="replaceable"><code>date</code></em>)

对日期或 datetime 值进行处理，返回月份最后一天的值。如果参数无效或是 NULL，则返回 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([<em class="replaceable"><code>fsp</code></em>])

LOCALTIME 和 LOCALTIME() 等同于 NOW()。

LOCALTIMESTAMP, LOCALTIMESTAMP([fsp])

LOCALTIMESTAMP 和 LOCALTIMESTAMP() 等同于NOW().

MAKEDATE(year,dayofyear)

返回给定年和日历天值的日期。dayofyear必须大于0，否则结果为NULL。结果也为NULL如果任意一个参数为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参数计算的时间值。如果任意一个参数为NULL，返回NULL.

秒钟部分可以是小数。

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

MICROSECOND(<em class="replaceable"><code>expr</code></em>)

返回时间或日期表达式<em class="replaceable"><code>expr</code></em>中的微秒数，范围从<code class="literal">0</code>到<code class="literal">999999</code>。如果<em class="replaceable"><code>expr</code></em>为<code class="literal">NULL</code>，则返回<code class="literal">NULL</code>。

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

MINUTE(<em class="replaceable"><code>time</code></em>)

返回<em class="replaceable"><code>time</code></em>中的分钟数，范围从<code class="literal">0</code>到<code class="literal">59</code>，如果<em class="replaceable"><code>time</code></em>为<code class="literal">NULL</code>，则返回<code class="literal">NULL</code>。

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

MONTH(<em class="replaceable"><code>date</code></em>)

返回<em class="replaceable"><code>date</code></em>中的月份数，范围从<code class="literal">1</code>到<code class="literal">12</code>，对应于一月到十二月，或者返回<code class="literal">0</code>对于日期如<code class="literal">'0000-00-00'</code>或<code class="literal">'2008-00-00'</code>，这些日期的月份部分为零。 如果<em class="replaceable"><code>date</code></em>为<code class="literal">NULL</code>，则返回<code class="literal">NULL</code>。

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

MONTHNAME(<em class="replaceable"><code>date</code></em>)

返回日期的全名，对应于date。语言控制由lc_time_names系统变量（第12.16节，“MySQL 服务器 locale 支持”)。如果date为NULL，返回NULL。

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

NOW([fsp])

以字符串或数字上下文返回当前日期和时间，格式为'YYYY-MM-DD hh:mm:ss'或YYYYMMDDhhmmss，取决于函数的使用上下文。该值以会话时区表示。

如果给定fsp参数指定小数秒精度从0到6，返回值包括小数秒部分的该多个数字。

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() 的调用没有影响。将时间戳设置为非零值，使每次后续的NOW() 调用返回该值。将时间戳设置为零取消这个效果，使NOW() 再次返回当前日期和时间。

查看SYSDATE() 的描述，以了解这两个函数之间的差异。

PERIOD_ADD(P,N)

将期限 P (以格式 YYMM 或 YYYYMM 表示) 加 N 个月，返回值以格式 YYYYMM 表示。

如果 P 或 N 是 NULL，则该函数返回 NULL。

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

PERIOD_DIFF(P1,P2)

返回两个时间段 P1 和 P2 之间的月数。注意，期限参数 P1 和 P2 不是日期值。

如果 P1 或 P2 是 NULL，则该函数返回 NULL。

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

QUARTER(date)

返回 date 的年份季度，范围为 1 到 4，或如果 date 是 NULL 则返回 NULL。

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

SECOND(time)

返回第二个 time，范围为 0 到 59，或如果 time 是 NULL 则返回 NULL。

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

SEC_TO_TIME(seconds)

将 seconds 转换为小时、分钟和秒，作为一个TIME 值。结果的范围受 TIME 数据类型的约束。如果参数对应的值超出该范围，出现警告。

如果 seconds 是 NULL 则返回 NULL。

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或format为NULL，函数返回NULL。如果服务器根据规则无法解析从str中提取的日期、时间或datetime值，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 则失败。末尾的额外字符被忽略。

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'

日期值的范围检查如第13.2.2节，“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'

如果启用了NO_ZERO_DATE SQL 模式，零日期将被禁止。在这种情况下，STR_TO_DATE() 返回 NULL 并生成警告：

mysql> SET sql_mode = '';
mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
+---------------------------------------+
| STR_TO_DATE('00/00/0000', '%m/%d/%Y') |
+---------------------------------------+
| 0000-00-00                            |
+---------------------------------------+
mysql> SET sql_mode = 'NO_ZERO_DATE';
mysql> SELECT STR_TO_DATE('00/00/0000', '%m/%d/%Y');
+---------------------------------------+
| STR_TO_DATE('00/00/0000', '%m/%d/%Y') |
+---------------------------------------+
| NULL                                  |
+---------------------------------------+
mysql> SHOW WARNINGS\G
*************************** 1. row ***************************
  Level: Warning
   Code: 1411
Message: Incorrect datetime value: '00/00/0000' for function str_to_date

在 MySQL 的一些前版本中，可以将无效日期字符串，如 '2021-11-31' 传递给这个函数。在 MySQL 8.4 中，STR_TO_DATE() 完全执行范围检查，如果转换后的日期无效，则抛出错误。

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

您也应该注意，日期和datetime值的日期部分，STR_TO_DATE() 只检查单个年、月、日的有效性。更精确地说，这意味着年份被检查以确保在范围0-9999之间，月份被检查以确保在范围1-12之间，日份被检查以确保在范围1-31之间，但服务器不检查这些值的组合。例如，SELECT STR_TO_DATE('23-2-31', '%Y-%m-%d') 返回 2023-02-31。启用或禁用ALLOW_INVALID_DATES 服务器 SQL 模式对这个行为没有影响。见第13.2.2节，“DATE、DATETIME 和 TIMESTAMP 类型”，了解更多信息。

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

使用第二个参数的INTERVAL形式时，SUBDATE() 等同于DATE_SUB()。关于INTERVALunit参数的信息，请参阅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。在这种情况下，它将被解释为从日期或datetime表达式expr中减去的天数。

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

如果该函数的任意一个参数是NULL，则该函数返回NULL。

SUBTIME(expr1,expr2)

SUBTIME() 将返回 expr1 − expr2，以expr1 的相同格式表示。其中，expr1 是时间或datetime表达式，expr2 是时间表达式。

该函数的返回类型解析方式与ADDTIME() 函数相同；请参阅该函数的描述以获取更多信息。

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'

如果expr1或expr2为NULL，则该函数返回NULL。

SYSDATE([fsp])

以字符串或数字上下文返回当前日期和时间，格式为'YYYY-MM-DD hh:mm:ss'或YYYYMMDDhhmmss。

如果指定了fsp参数，用于指定小数点精度从0到6位，小数点部分的长度为该位数。

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中提取时间部分，并将其返回为字符串。如果expr是NULL，则返回NULL。

这个函数在语句级别复制中不安全。如果你使用这个函数，而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是字符串，将被转换为TIME或DATETIME表达式；这些必须在转换后具有相同的类型。如果expr1或expr2是NULL，则返回NULL。

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转换为datetime值。两个参数时，它将日期或日期时间表达式expr1和时间表达式expr2相加，并返回结果为datetime值。如果expr, expr1, 或expr2是NULL，则返回NULL。

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 都是合法的。

如果 interval 或 datetime_expr 是 NULL，则该函数返回 NULL。

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'

将 MONTH 间隔添加到 DATE 或 DATETIME 值中，如果结果日期包含不在给定月份的日子，会调整到该月最后一天，如下所示：

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

TIMESTAMPDIFF(unit,datetime_expr1,datetime_expr2)

返回 datetime_expr2 − datetime_expr1，其中 datetime_expr1 和 datetime_expr2 是日期或日期时间表达式。一个表达式可能是日期，另一个是日期时间；日期值将被视为具有'00:00:00'的日期时间，其中必要时。结果的单位由 unit 参数给出。unit 的合法值与TIMESTAMPADD() 函数的描述中列举的一样。

如果 datetime_expr1 或 datetime_expr2 是 NULL，则该函数返回 NULL。

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

TIME_FORMAT(time,format)

这个函数类似于DATE_FORMAT()函数，但是format字符串只能包含小时、分钟、秒和微秒的格式符号。其他符号将返回NULL或0TIME_FORMAT()如果time或format为NULL将返回NULL.

如果time值包含大于23的小时部分，%H和%k小时格式符号将产生一个大于通常范围0..23的值。其他小时格式符号将产生小时值的模12。

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

TIME_TO_SEC(time)

将time转换为秒，返回NULL如果time为NULL.

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

TO_DAYS(date)

给定日期date，返回一个天数（从年0开始的天数）。返回NULL如果date为NULL.

mysql> SELECT TO_DAYS(950501);
        -> 728779
mysql> SELECT TO_DAYS('2007-10-07');
        -> 733321

TO_DAYS() 不适用于前于公历曆日（1582）之前的日期，因为它不考虑曆法变更时所失去的天数。对于1582年以前（或其他地区可能晚于1582年的日期），该函数结果不可靠。请参阅第13.2.7节，“MySQL 使用哪种曆法？”，了解详细信息。

请记住，MySQL 将二位年份值在日期中转换为四位形式，遵循第13.2节，“日期和时间数据类型”中的规则。例如，'2008-10-07' 和 '08-10-07' 被视为相同的日期：

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

在 MySQL 中，零日期定义为 '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)

给定一个日期或datetime expr，返回自公元元年以来秒数。如果 expr 不是有效的日期或datetime值（包括NULL），则返回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年（或其他地区可能晚于该年）前的日期，函数结果不可靠。请参阅第13.2.7节，“MySQL 使用哪种日历？”，了解详细信息。

像TO_DAYS()一样，TO_SECONDS() 将二位年值日期转换为四位年值日期，使用第13.2节，“日期和时间数据类型”中规定的规则。

在 MySQL 中，零日期定义为'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() 返回自 1970-01-01 00:00:00 UTC 以来秒数。

如果提供了 日期 参数，UNIX_TIMESTAMP() 返回该参数的值，以 1970-01-01 00:00:00 UTC 为基准。服务器将 日期 解释为会话时区中的值，并将其转换为内部 Unix 时间戳值在 UTC 中。 (客户端可以按照第7.1.15节，“MySQL 服务器时区支持”中描述设置会话时区。) 日期 参数可以是DATE、DATETIME、TIMESTAMP 字符串，或者是 YYMMDD、YYMMDDhhmmss、YYYYMMDD 或 YYYYMMDDhhmmss 格式。如果参数包含时间部分，可以选itionally 包含小数秒部分。

如果不提供参数或参数不包含小数部分，返回值是一个整数；否则，如果参数包含小数部分，返回值是一个DECIMAL类型的值。

当date参数是TIMESTAMP列时，UNIX_TIMESTAMP()直接返回内部时间戳值，不进行隐式“字符串到Unix时间戳”转换。

参数的有效范围与TIMESTAMP数据类型相同：'1970-01-01 00:00:01.000000' UTC 到 '2038-01-19 03:14:07.999999' UTC（32位平台）；对于64位平台，参数的有效范围是'1970-01-01 00:00:01.000000' UTC 到 '3001-01-19 03:14:07.999999' UTC（对应32536771199.999999秒）。

无论MySQL版本或平台架构，如果将日期传递给UNIX_TIMESTAMP()，它返回0。如果date是NULLNULL。

mysql> SELECT UNIX_TIMESTAMP();
        -> 1447431666
mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19');
        -> 1447431619
mysql> SELECT UNIX_TIMESTAMP('2015-11-13 10:20:19.012');
        -> 1447431619.012

如果您使用UNIX_TIMESTAMP()和FROM_UNIXTIME()将非UTC时间区的值转换为Unix时间戳值，转换是有损失的，因为这两个方向的映射不是一对一的。例如，由于本地时间区的变化，如夏令时（DST），可能UNIX_TIMESTAMP()将两个非UTC时间区的值映射到同一个Unix时间戳值。FROM_UNIXTIME()将该值映射回原来的一个值。以下是一个示例，使用MET时间区的值：

mysql> SET time_zone = 'MET';
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()列，您可能想要将它们转换为有符号整数。请参阅第14.10节，“Cast Functions and Operators”。

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，取决于函数在字符串或数字上下文中使用。

如果给定了fsp参数指定小数秒精度从0到6，则返回值包括小数秒部分该多个位。

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，取决于函数在字符串或数字上下文中使用。

如果给定了fsp参数指定小数秒精度从0到6，则返回值包括小数秒部分该多个位。

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

WEEK(日期[,模式])

这个函数返回 日期 的周数。二个参数形式的 WEEK() 允许你指定周是否从星期天开始还是星期一开始，并且返回值是否在 0 到 53 或者 1 到 53 之间。如果缺少 模式 参数，使用 default_week_format 系统变量的值。见第7.1.8节，“服务器系统变量”。对于 NULL 日期值，函数返回 NULL。

以下表格描述了 模式 参数的工作方式。

对于mode值的含义为““在今年至少4天，””周以ISO 8601:1988编号:

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

如果日期落在上一年最后一周，MySQL返回0，除非使用2、3、6或7作为可选的mode参数：

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

有人可能认为WEEK()应该返回52因为给定的日期实际上是在1999年的52周。WEEK()返回0，以便返回值是“给定的年中的周号。”这使得使用WEEK()函数时结果可靠，结合其他函数提取日期部分。

如果你想以给定的日期的周首日所在年计算结果，使用0、2、5或7作为可选的mode参数。

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(日期)

返回日期的星期几索引（0 = 星期一，1 = 星期二，… 6 = 星期天）。如果日期是NULL，则返回NULL。

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

WEEKOFYEAR(日期)

返回日期的周次号，从1到53之间。返回NULL如果日期是NULL。

WEEKOFYEAR()是一个兼容函数，等同于WEEK(日期,3)。

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

YEAR(日期)

返回日期 date 的年份，范围为 1000 到 9999，或 0 对于“零”日期。如果 date 是 NULL 则返回 NULL。

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

YEARWEEK(date)，YEARWEEK(date,mode)

返回日期的年份和周数。结果中的年份可能与日期参数中的年份不同，首周和尾周除外。如果 date 是 NULL 则返回 NULL。

参数 mode 和 WEEK() 的参数相同。单个参数语法中，使用 mode 值为 0。与 WEEK() 不同的是，default_week_format 不影响 YEARWEEK()。

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

星期号与WEEK()函数返回的结果不同（0或1），因为WEEK()将在给定的年份中返回星期号。