date-and-time-functions.md

## 12.7 日期和时间函数

[](<>)[](<>)

本节介绍可用于操作时间值的函数。看[第 11.2 节，“日期和时间数据类型”](date-and-time-types.html)，用于描述每个日期和时间类型具有的值范围以及可以指定值的有效格式。

[](<>)

**表 12.11 日期和时间函数**

| 姓名 | 描述 |
| --- | --- |
| [`添加日期（）`](date-and-time-functions.html#function_adddate) | 将时间值（间隔）添加到日期值 |
| [`添加时间（）`](date-and-time-functions.html#function_addtime) | 添加时间 |
| [`转换_TZ()`](date-and-time-functions.html#function_convert-tz) | 从一个时区转换到另一个时区 |
| [`CURDATE()`](date-and-time-functions.html#function_curdate) | 返回当前日期 |
| [`当前的日期（）`,`当前的日期`](date-and-time-functions.html#function_current-date) | CURDATE() 的同义词 |
| [`当前时间（）`,`当前时间`](date-and-time-functions.html#function_current-time) | CURTIME() 的同义词 |
| [`CURRENT_TIMESTAMP()`,`CURRENT_TIMESTAMP`](date-and-time-functions.html#function_current-timestamp) | NOW() 的同义词 |
| [`时间（）`](date-and-time-functions.html#function_curtime) | 返回当前时间 |
| [`日期（）`](date-and-time-functions.html#function_date) | 提取日期或日期时间表达式的日期部分 |
| [`DATE_ADD()`](date-and-time-functions.html#function_date-add) | 将时间值（间隔）添加到日期值 |
| [`日期格式（）`](date-and-time-functions.html#function_date-format) | 按指定格式日期 |
| [`DATE_SUB()`](date-and-time-functions.html#function_date-sub) | 从日期中减去时间值（间隔） |
| [`日期判断（）`](date-and-time-functions.html#function_datediff) | 减去两个日期 |
| [`日（）`](date-and-time-functions.html#function_day) | DAYOFMONTH() 的同义词 |
| [`日期名称（）`](date-and-time-functions.html#function_dayname) | 返回工作日的名称 |
| [`DAYOFMONTH()`](date-and-time-functions.html#function_dayofmonth) | 返回月份中的第几天 (0-31) |
| [`星期几（）`](date-and-time-functions.html#function_dayofweek) | 返回参数的工作日索引 |
| [`年份（）`](date-and-time-functions.html#function_dayofyear) | 返回一年中的某一天 (1-366) |
| [`提炼（）`](date-and-time-functions.html#function_extract) | 提取日期的一部分 |
| [`FROM_DAYS()`](date-and-time-functions.html#function_from-days) | 将天数转换为日期 |
| [`FROM_UNIXTIME()`](date-and-time-functions.html#function_from-unixtime) | 将 Unix 时间戳格式化为日期 |
| [`GET_FORMAT()`](date-and-time-functions.html#function_get-format) | 返回日期格式字符串 |
| [`小时（）`](date-and-time-functions.html#function_hour) | 提取小时 |
| [`最后一天`](date-and-time-functions.html#function_last-day) | 返回参数的月份的最后一天 |
| [`当地时间（）`, `当地时间`](date-and-time-functions.html#function_localtime) | 现在（）的同义词 |
| [`本地时间戳`, `本地时间戳（）`](date-and-time-functions.html#function_localtimestamp) | 现在（）的同义词 |
| [`制作日期（）`](date-and-time-functions.html#function_makedate) | 根据年份和日期创建日期 |
| [`找时间（）`](date-and-time-functions.html#function_maketime) | 从小时、分钟、秒创建时间 |
| [`微秒（）`](date-and-time-functions.html#function_microsecond) | 从参数返回微秒 |
| [`分钟（）`](date-and-time-functions.html#function_minute) | 从参数返回分钟 |
| [`月（）`](date-and-time-functions.html#function_month) | 从过去的日期返回月份 |
| [`月名()`](date-and-time-functions.html#function_monthname) | 返回月份的名称 |
| [`现在（）`](date-and-time-functions.html#function_now) | 返回当前日期和时间 |
| [`PERIOD_ADD()`](date-and-time-functions.html#function_period-add) | 为年月添加期间 |
| [`PERIOD_DIFF()`](date-and-time-functions.html#function_period-diff) | 返回期间之间的月数 |
| [`25美分硬币（）`](date-and-time-functions.html#function_quarter) | 从日期参数返回季度 |
| [`SEC_TO_TIME()`](date-and-time-functions.html#function_sec-to-time) | 将秒转换为 'hh:mm:ss' 格式 |
| [`第二（）`](date-and-time-functions.html#function_second) | 返回第二个 (0-59) |
| [`STR_TO_DATE()`](date-and-time-functions.html#function_str-to-date) | 将字符串转换为日期 |
| [`子日期（）`](date-and-time-functions.html#function_subdate) | 日期的同义词\_使用三个参数调用 SUB() |
| [`次时间（）`](date-and-time-functions.html#function_subtime) | 减去时间 |
| [`系统日期（）`](date-and-time-functions.html#function_sysdate) | 返回函数执行的时间 |
| [`时间（）`](date-and-time-functions.html#function_time) | 提取传递的表达式的时间部分 |
| [`时间格式（）`](date-and-time-functions.html#function_time-format) | 格式为时间 |
| [`TIME_TO_SEC()`](date-and-time-functions.html#function_time-to-sec) | 返回转换为秒的参数 |
| [`时差（）`](date-and-time-functions.html#function_timediff) | 减去时间 |
| [`时间戳（）`](date-and-time-functions.html#function_timestamp) | 使用单个参数，此函数返回日期或日期时间表达式；有两个参数，参数的总和 |
| [`时间戳记（）`](date-and-time-functions.html#function_timestampadd) | 向日期时间表达式添加间隔 |
| [`时间戳 ()`](date-and-time-functions.html#function_timestampdiff) | 从日期时间表达式中减去间隔 |
| [`TO_DAYS()`](date-and-time-functions.html#function_to-days) | 返回转换为天的日期参数 |
| [`TO_SECONDS()`](date-and-time-functions.html#function_to-seconds) | 返回自第 0 年以来转换为秒的日期或日期时间参数 |
| [`UNIX_TIMESTAMP()`](date-and-time-functions.html#function_unix-timestamp) | 返回一个 Unix 时间戳 |
| [`UTC_DATE()`](date-and-time-functions.html#function_utc-date) | 返回当前 UTC 日期 |
| [`UTC_TIME()`](date-and-time-functions.html#function_utc-time) | 返回当前 UTC 时间 |
| [`UTC_TIMESTAMP()`](date-and-time-functions.html#function_utc-timestamp) | 返回当前 UTC 日期和时间 |
| [`星期（）`](date-and-time-functions.html#function_week) | 返回周数 |
| [`平日（）`](date-and-time-functions.html#function_weekday) | 返回工作日索引 |
| [`一周年（）`](date-and-time-functions.html#function_weekofyear) | 返回日期的日历周 (1-53) |
| [`年（）`](date-and-time-functions.html#function_year) | 返回年份 |
| [`年周（）`](date-and-time-functions.html#function_yearweek) | 返回年份和星期 |

这是一个使用日期函数的示例。以下查询选择所有行*`date_col`*过去 30 天内的值：

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

该查询还选择日期在未来的行。

期望日期值的函数通常接受日期时间值并忽略时间部分。期望时间值的函数通常接受日期时间值并忽略日期部分。

每个返回当前日期或时间的函数在查询执行开始时每个查询只计算一次。这意味着对一个函数的多次引用，例如[`现在（）`](date-and-time-functions.html#function_now)在单个查询中总是产生相同的结果。（为了我们的目的，单个查询还包括对存储程序（存储例程、触发器或事件）的调用以及该程序调用的所有子程序。）这个原则也适用于[`CURDATE()`](date-and-time-functions.html#function_curdate),[`时间（）`](date-and-time-functions.html#function_curtime),[`UTC_DATE()`](date-and-time-functions.html#function_utc-date),[`UTC_TIME()`](date-and-time-functions.html#function_utc-time),[`UTC_TIMESTAMP()`](date-and-time-functions.html#function_utc-timestamp)，以及它们的任何同义词。

这[`CURRENT_TIMESTAMP()`](date-and-time-functions.html#function_current-timestamp),[`当前时间（）`](date-and-time-functions.html#function_current-time),[`当前的日期（）`](date-and-time-functions.html#function_current-date)， 和[`FROM_UNIXTIME()`](date-and-time-functions.html#function_from-unixtime)函数返回当前会话时区的值，可作为[`时区`](server-system-variables.html#sysvar_time_zone)系统变量。此外，[`UNIX_TIMESTAMP()`](date-and-time-functions.html#function_unix-timestamp)假定其参数是会话时区中的日期时间值。看[第 5.1.15 节，“MySQL 服务器时区支持”](time-zone-support.html).

某些日期函数可以与“零”日期或不完整日期一起使用，例如`'2001-11-00'`，而其他人不能。提取部分日期的函数通常适用于不完整的日期，因此当您可能期望一个非零值时可以返回 0。例如：

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

其他函数需要完整的日期并返回`空值`对于不完整的日期。这些包括执行日期算术或将部分日期映射到名称的函数。例如：

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

几个函数在传递时是严格的[`日期（）`](date-and-time-functions.html#function_date)函数值作为它们的参数，并拒绝日期部分为零的不完整日期：[`转换_TZ()`](date-and-time-functions.html#function_convert-tz),[`DATE_ADD()`](date-and-time-functions.html#function_date-add),[`DATE_SUB()`](date-and-time-functions.html#function_date-sub),[`年份（）`](date-and-time-functions.html#function_dayofyear),[`时间戳 ()`](date-and-time-functions.html#function_timestampdiff),[`TO_DAYS()`](date-and-time-functions.html#function_to-days),[`TO_SECONDS()`](date-and-time-functions.html#function_to-seconds),[`星期（）`](date-and-time-functions.html#function_week),[`平日（）`](date-and-time-functions.html#function_weekday),[`一周年（）`](date-and-time-functions.html#function_weekofyear),[`年周（）`](date-and-time-functions.html#function_yearweek).

小数秒为`时间`,`约会时间`， 和`时间戳`支持值，精度高达微秒。采用时间参数的函数接受带有小数秒的值。时间函数的返回值包括适当的小数秒。

-   [](<>)

    [`添加日期（*`日期`*，间隔 *`表达式`* *`单元`*)`](date-and-time-functions.html#function_adddate),[`添加日期（*`表达式`*,*`天`*)`](date-and-time-functions.html#function_adddate)

    [](<>)

    当调用`间隔`第二个参数的形式，[`添加日期（）`](date-and-time-functions.html#function_adddate)是同义词[`DATE_ADD()`](date-and-time-functions.html#function_date-add).相关功能[`子日期（）`](date-and-time-functions.html#function_subdate)是同义词[`DATE_SUB()`](date-and-time-functions.html#function_date-sub).有关信息`间隔` *`单元`*论据，见[时间间隔](expressions.html#temporal-intervals).

    ```
    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 将其视为要添加到的整数天数*`表达式`*.

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

-   [](<>)

    [`添加时间（*`expr1`*,*`expr2`*)`](date-and-time-functions.html#function_addtime)

    [](<>)

    [`添加时间（）`](date-and-time-functions.html#function_addtime)添加*`expr2`*到*`expr1`*并返回结果。*`expr1`*是时间或日期时间表达式，并且*`expr2`*是时间表达式。

    从 MySQL 8.0.28 开始，此函数的返回类型和[`次时间（）`](date-and-time-functions.html#function_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'
    ```

-   [](<>)

    [`转换_TZ(*`dt`*,*`from_tz`*,*`to_tz`*)`](date-and-time-functions.html#function_convert-tz)

    [](<>)

    [`转换_TZ()`](date-and-time-functions.html#function_convert-tz)转换日期时间值*`dt`*从给定的时区*`from_tz`*到给定的时区*`to_tz`*并返回结果值。时区的指定如中所述[第 5.1.15 节，“MySQL 服务器时区支持”](time-zone-support.html).这个函数返回`空值`如果参数无效。

    在 32 位平台上，此函数支持的值范围与[`时间戳`](datetime.html)类型（见[第 11.2.1 节，“日期和时间数据类型语法”](date-and-time-type-syntax.html)，用于范围信息）。在 64 位平台上，从 MySQL 8.0.28 开始，支持的最大值为`'3001-01-18 23:59:59.999999'`世界标准时间。

    无论平台或 MySQL 版本，如果转换时值超出支持范围*`from_tz`*到 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'
    ```

    笔记

    使用命名时区，例如`'遇见'`要么`“欧洲/阿姆斯特丹”`，时区表必须正确设置。有关说明，请参阅[第 5.1.15 节，“MySQL 服务器时区支持”](time-zone-support.html).

-   [](<>)

    [`CURDATE()`](date-and-time-functions.html#function_curdate)

    [](<>)

    将当前日期作为值返回`'*`YYYY-MM-DD`*'`要么*`YYYYMMDD`*格式，取决于函数是在字符串还是数字上下文中使用。

    ```
    mysql> SELECT CURDATE();
            -> '2008-06-13'
    mysql> SELECT CURDATE() + 0;
            -> 20080613
    ```

-   [](<>)

    [`当前的日期`](date-and-time-functions.html#function_current-date),[`当前的日期（）`](date-and-time-functions.html#function_current-date)

    [](<>)

    [`当前的日期`](date-and-time-functions.html#function_current-date)和[`当前的日期（）`](date-and-time-functions.html#function_current-date)是同义词[`CURDATE()`](date-and-time-functions.html#function_curdate).

-   [](<>)

    [`当前时间`](date-and-time-functions.html#function_current-time),[`当前时间（[*`fsp`*])`](date-and-time-functions.html#function_current-time)

    [](<>)

    [`当前时间`](date-and-time-functions.html#function_current-time)和[`当前时间（）`](date-and-time-functions.html#function_current-time)是同义词[`时间（）`](date-and-time-functions.html#function_curtime).

-   [](<>)

    [`CURRENT_TIMESTAMP`](date-and-time-functions.html#function_current-timestamp),[`CURRENT_TIMESTAMP([*`fsp`*])`](date-and-time-functions.html#function_current-timestamp)

    [](<>)

    [`CURRENT_TIMESTAMP`](date-and-time-functions.html#function_current-timestamp)和[`CURRENT_TIMESTAMP()`](date-and-time-functions.html#function_current-timestamp)是同义词[`现在（）`](date-and-time-functions.html#function_now).

-   [](<>)

    [`课时（[*`fsp`*])`](date-and-time-functions.html#function_curtime)

    [](<>)

    将当前时间作为值返回*`'hh:mm:ss'`*要么*`嗯嗯`*格式，取决于函数是在字符串还是数字上下文中使用。该值以会话时区表示。

    如果*`fsp`*给出参数以指定从 0 到 6 的小数秒精度，返回值包括那么多数字的小数秒部分。

    ```
    mysql> SELECT CURTIME();
            -> '23:50:26'
    mysql> SELECT CURTIME() + 0;
            -> 235026.000000
    ```

-   [](<>)

    [`日期（*`表达式`*)`](date-and-time-functions.html#function_date)

    [](<>)

    提取日期或日期时间表达式的日期部分*`表达式`*.

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

-   [](<>)

    [`日期（*`expr1`*,*`expr2`*)`](date-and-time-functions.html#function_datediff)

    [](<>)

    [`日期判断（）`](date-and-time-functions.html#function_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-and-time-functions.html#function_date-add),[`DATE_SUB(*`日期`*，间隔 *`表达式`* *`单元`*)`](date-and-time-functions.html#function_date-sub)

    [](<>)[](<>)

    这些函数执行日期算术。这*`日期`*参数指定开始日期或日期时间值。*`表达式`*是一个表达式，指定要从开始日期添加或减去的间隔值。*`表达式`*被评估为字符串；它可能以`-`对于负区间。*`单元`*是一个关键字，表示应该解释表达式的单位。

    有关时间间隔语法的更多信息，包括完整列表*`单元`*说明符，预期的形式*`表达式`*每个人的论据*`单元`*值，以及时间算术中操作数解释的规则，请参见[时间间隔](expressions.html#temporal-intervals).

    返回值取决于参数：

    -   [`日期`](datetime.html)如果*`日期`*论证是一个[`日期`](datetime.html)价值和你的计算只涉及`年`,`月`， 和`日`部分（即没有时间部分）。

    -   (*MySQL 8.0.28 及更高版本*:) [`时间`](time.html)如果*`日期`*论证是一个`时间`值和计算只涉及`小时`, `分钟`， 和`秒`部分（即没有日期部分）。

    -   [`约会时间`](datetime.html)如果第一个参数是[`约会时间`](datetime.html)（要么[`时间戳`](datetime.html)) 值，或者如果第一个参数是[`日期`](datetime.html)和*`单元`*价值用途`小时`, `分钟`， 要么`秒`, 或者如果第一个参数是类型[`时间`](time.html)和*`单元`*价值用途`年`,`月`， 要么`日`.

    -   (*MySQL 8.0.28 及更高版本*:) 如果第一个参数是动态参数（例如，准备好的语句），它的解析类型是`日期`如果第二个参数是包含某种组合的区间`年`,`月`， 要么`日`仅值；否则，其类型为`约会时间`.

    -   否则为字符串（类型[`VARCHAR`](char.html)）。

    笔记

    在 MySQL 8.0.22 到 8.0.27 中，当在准备好的语句中使用时，这些函数返回`约会时间`无论参数类型如何。（错误 #103781）

    为了确保结果是[`约会时间`](datetime.html)， 您可以使用[`投掷（）`](cast-functions.html#function_cast)将第一个参数转换为[`约会时间`](datetime.html).

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

-   [](<>)

    [`日期格式（*`日期`*,*`格式`*)`](date-and-time-functions.html#function_date-format)

    [](<>)

    格式化*`日期`*根据价值*`格式`*细绳。

    下表中显示的说明符可用于*`格式`*细绳。这`%`在格式说明符字符之前需要字符。说明符也适用于其他函数：[`STR_TO_DATE()`](date-and-time-functions.html#function_str-to-date),[`时间格式（）`](date-and-time-functions.html#function_time-format),[`UNIX_TIMESTAMP()`](date-and-time-functions.html#function_unix-timestamp).

    | 说明符 | 描述 |
    | --- | --- |
    | `％一种` | 缩写的工作日名称 (`太阳`..`星期六`) |
    | `%b` | 缩写月份名称 (`简`..`十二月`) |
    | `％C` | 月份，数字（`0`..`12`) |
    | `%D` | 带有英文后缀（`第0个`, `第一`, `第二`, `第三`, …) |
    | `%d` | 日期，数字 (`00`..`31`) |
    | `%e` | 日期，数字 (`0`..`31`) |
    | `％F` | 微秒 (`000000`..`999999`) |
    | `％H` | 小时 （`00`..`23`) |
    | `％H` | 小时 （`01`..`12`) |
    | `％一世` | 小时 （`01`..`12`) |
    | `％一世` | 分钟，数字（`00`..`59`) |
    | `%j` | 一年中的某一天 (`001`..`366`) |
    | `%k` | 小时 （`0`..`23`) |
    | `%l` | 小时 （`1`..`12`) |
    | `%M` | 月份名称 (`一月`..`十二月`) |
    | `%m` | 月份，数字（`00`..`12`) |
    | `%p` | `是`要么`下午` |
    | `%r` | 时间，12 小时 (*`hh:mm:ss`*其次是`是`要么`下午`) |
    | `%S` | 秒 (`00`..`59`) |
    | `%s` | 秒 (`00`..`59`) |
    | `%T` | 时间，24 小时制 (*`hh:mm:ss`*) |
    | `%U` | 星期 （`00`..`53`)，其中星期日是一周的第一天；[`星期（）`](date-and-time-functions.html#function_week)模式 0 |
    | `%u` | 星期 （`00`..`53`)，其中星期一是一周的第一天；[`星期（）`](date-and-time-functions.html#function_week)模式一 |
    | `%V` | 星期 （`01`..`53`)，其中星期日是一周的第一天；[`星期（）`](date-and-time-functions.html#function_week)模式二；与`％X` |
    | `%v` | 星期 （`01`..`53`)，其中星期一是一周的第一天；[`星期（）`](date-and-time-functions.html#function_week)模式3；与`％X` |
    | `%W` | 工作日名称 (`星期日`..`周六`) |
    | `%w` | 一周中的天 （`0`=星期天..`6`=星期六） |
    | `％X` | 星期天是一周的第一天的一周年，数字，四位数字；与`%V` |
    | `％X` | 一周的年份，其中星期一是一周的第一天，数字，四位数字；与`%v` |
    | `%Y` | 年份，数字，四位数 |
    | `%y` | 年份，数字（两位数） |
    | `%%` | 一个字面`%`特点 |
    | `%*`x`*` | *`x`*, 对于任何“*`x`*”未在上面列出 |

    由于 MySQL 允许存储不完整的日期，例如，月份和日期说明符的范围从零开始`'2014-00-00'`.

    用于日期和月份名称和缩写的语言由[`lc_time_names`](server-system-variables.html#sysvar_lc_time_names)系统变量 ([第 10.16 节，“MySQL 服务器语言环境支持”](locale-support.html)）。

    为了`%U`,`%u`,`%V`， 和`%v`说明符，请参阅[`星期（）`](date-and-time-functions.html#function_week)函数获取有关模式值的信息。该模式会影响周编号的发生方式。

    [`日期格式（）`](date-and-time-functions.html#function_date-format)返回具有字符集和排序规则的字符串[`字符集连接`](server-system-variables.html#sysvar_character_set_connection)和[`collat​​ion_connection`](server-system-variables.html#sysvar_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-and-time-functions.html#function_date-sub)

    [](<>)

    请参阅说明[`DATE_ADD()`](date-and-time-functions.html#function_date-add).

-   [](<>)

    [`日（*`日期`*)`](date-and-time-functions.html#function_day)

    [](<>)

    [`日（）`](date-and-time-functions.html#function_day)是同义词[`DAYOFMONTH()`](date-and-time-functions.html#function_dayofmonth).

-   [](<>)

    [`日期名称（*`日期`*)`](date-and-time-functions.html#function_dayname)

    [](<>)

    返回工作日的名称*`日期`*.名称所使用的语言由[`lc_time_names`](server-system-variables.html#sysvar_lc_time_names)系统变量 ([第 10.16 节，“MySQL 服务器语言环境支持”](locale-support.html)）。

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

-   [](<>)

    [`DAYOFMONTH(*`日期`*)`](date-and-time-functions.html#function_dayofmonth)

    [](<>)

    返回月份中的第几天*`日期`*， 范围中`1`到`31`， 要么`0`对于日期，例如`'0000-00-00'`要么`'2008-00-00'`有零日部分。

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

-   [](<>)

    [`星期几(*`日期`*)`](date-and-time-functions.html#function_dayofweek)

    [](<>)

    返回工作日索引*`日期`*(`1`= 星期日，`2`= 星期一，……，`7`= 星期六）。这些索引值对应于 ODBC 标准。

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

-   [](<>)

    [`日期（*`日期`*)`](date-and-time-functions.html#function_dayofyear)

    [](<>)

    返回一年中的某一天*`日期`*， 范围中`1`到`366`.

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

-   [](<>)

    [`提炼（*`单元`* 从 *`日期`*)`](date-and-time-functions.html#function_extract)

    [](<>)

    这[`提炼（）`](date-and-time-functions.html#function_extract)函数使用相同种类的*`单元`*说明符为[`DATE_ADD()`](date-and-time-functions.html#function_date-add)要么[`DATE_SUB()`](date-and-time-functions.html#function_date-sub), 但从日期中提取部分而不是执行日期算术。有关信息*`单元`*论据，见[时间间隔](expressions.html#temporal-intervals).

    ```
    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(*`ñ`*)`](date-and-time-functions.html#function_from-days)

    [](<>)

    给定一个天数*`ñ`*, 返回一个[`日期`](datetime.html)价值。

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

    采用[`FROM_DAYS()`](date-and-time-functions.html#function_from-days)谨慎对待旧日期。它不适用于公历 (1582) 出现之前的值。看[第 12.9 节，“MySQL 使用什么日历？”](mysql-calendar.html).

-   [](<>)

    [`FROM_UNIXTIME(*`unix_timestamp`*[,*`格式`*])`](date-and-time-functions.html#function_from-unixtime)

    [](<>)

    返回一个表示*`unix_timestamp`*作为日期时间或字符串值。返回的值使用会话时区表示。（客户端可以设置会话时区，如[第 5.1.15 节，“MySQL 服务器时区支持”](time-zone-support.html).)*`unix_timestamp`*是一个内部时间戳值，表示自`'1970-01-01 00:00:00'`UTC，例如由[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)作用

    如果*`总体安排`*如果省略，该函数将返回[`约会时间`](datetime.html)价值

    如果*`unix_时间戳`*是一个整数，是`约会时间`是零。什么时候*`unix_时间戳`*是一个十进制值，即`约会时间`与十进制值的精度相同，最大为6。什么时候*`unix_时间戳`*是一个浮点数，datetime的小数秒精度为6。

    在32位平台上*`unix_时间戳`*是2147483647.999999，返回`'2038-01-19 03:14:07.999999'`UTC。在运行MySQL 8.0.28或更高版本的64位平台上，有效最大值为32536771199.999999，返回`'3001-01-18 23:59:59.999999'`UTC。无论是平台还是版本，更大的价值*`unix_时间戳`*超过有效的最大回报`0`.

    *`总体安排`*用于格式化结果的方式与用于[`日期格式（）`](date-and-time-functions.html#function_date-format)作用如果*`总体安排`*则返回的值为[`瓦尔查尔`](char.html).

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

    笔记

    如果你使用[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)和[`来自_UNIXTIME（）`](date-and-time-functions.html#function_from-unixtime)要在非UTC时区的值和Unix时间戳值之间转换，转换是有损的，因为在两个方向上的映射不是一一对应的。有关详细信息，请参见[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)作用

-   [](<>)

    [`获取|格式（{DATE | TIME | DATETIME}，{'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'}）`](date-and-time-functions.html#function_get-format)

    [](<>)

    返回格式字符串。此功能与[`日期格式（）`](date-and-time-functions.html#function_date-format)还有[`STR_TO_DATE（）`](date-and-time-functions.html#function_str-to-date)功能。

    第一个和第二个参数的可能值会产生几个可能的格式字符串（有关使用的说明符，请参阅[`日期格式（）`](date-and-time-functions.html#function_date-format)功能描述）。ISO格式指的是ISO 9075，而不是ISO 8601。

    | 函数调用 | 后果 |
    | ---- | --- |
    | [`获取格式（日期，'USA'）`](date-and-time-functions.html#function_get-format) | `“%m.%d.%y”` |
    | [`GET FORMAT（日期，'JIS'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d”` |
    | [`GET FORMAT（日期，'ISO'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d”` |
    | [`GET FORMAT（日期，'EUR'）`](date-and-time-functions.html#function_get-format) | `“%d.%m.%y”` |
    | [`获取格式（日期，'internal'）`](date-and-time-functions.html#function_get-format) | `“%y%m%d”` |
    | [`GET FORMAT（日期时间，'USA'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d%h.%i.%s”` |
    | [`GET FORMAT（日期时间，'JIS'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d%h:%i:%s”` |
    | [`GET FORMAT（日期时间，'ISO'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d%h:%i:%s”` |
    | [`GET FORMAT（日期时间，'EUR'）`](date-and-time-functions.html#function_get-format) | `“%y-%m-%d%h.%i.%s”` |
    | [`get format（日期时间，'internal'）`](date-and-time-functions.html#function_get-format) | `“%y%m%d%h%i%s”` |
    | [`GET FORMAT（时间，'USA'）`](date-and-time-functions.html#function_get-format) | `“%h:%i:%s%p”` |
    | [`GET FORMAT（时间，'JIS'）`](date-and-time-functions.html#function_get-format) | `“%h:%i:%s”` |
    | [`GET FORMAT（时间，'ISO'）`](date-and-time-functions.html#function_get-format) | `“%h:%i:%s”` |
    | [`GET FORMAT（时间，'EUR'）`](date-and-time-functions.html#function_get-format) | `“%h.%i.%s”` |
    | [`获取格式（时间，'internal'）`](date-and-time-functions.html#function_get-format) | `“%h%i%s”` |

    [`时间戳`](datetime.html)也可以用作[`获取格式（）`](date-and-time-functions.html#function_get-format)，在这种情况下，函数返回的值与[`约会时间`](datetime.html).

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

-   [](<>)

    [`小时(*`时间`*)`](date-and-time-functions.html#function_hour)

    [](<>)

    返回所需的时间*`时间`*.返回值的范围为`0`到`23`获取一天中的时间值。但是[`时间`](time.html)值实际上要大得多，所以`小时`可以返回大于的值`23`.

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

-   [](<>)

    [`最后一天(*`日期`*)`](date-and-time-functions.html#function_last-day)

    [](<>)

    获取日期或日期时间值，并返回当月最后一天的相应值。退换商品`无效的`如果论点无效。

    ```
    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
    ```

-   [](<>)

    [`本地时间`](date-and-time-functions.html#function_localtime), [`本地时间([*`fsp`*])`](date-and-time-functions.html#function_localtime)

    [](<>)

    [`当地时间`](date-and-time-functions.html#function_localtime)和[`当地时间（）`](date-and-time-functions.html#function_localtime)是同义词[`现在（）`](date-and-time-functions.html#function_now).

-   [](<>)

    [`本地时间戳`](date-and-time-functions.html#function_localtimestamp), [`本地时间戳（[*`fsp`*])`](date-and-time-functions.html#function_localtimestamp)

    [](<>)

    [`本地时间戳`](date-and-time-functions.html#function_localtimestamp)和[`本地时间戳（）`](date-and-time-functions.html#function_localtimestamp)是同义词[`现在（）`](date-and-time-functions.html#function_now).

-   [](<>)

    [`制作日期（*`年`*,*`一年中的一天`*)`](date-and-time-functions.html#function_makedate)

    [](<>)

    返回一个日期，给定年份和年份值。*`一年中的一天`*必须大于 0 否则结果为`空值`.

    ```
    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
    ```

-   [](<>)

    [`找时间（*`小时`*,*`分钟`*,*`第二`*)`](date-and-time-functions.html#function_maketime)

    [](<>)

    返回从*`小时`*, *`分钟`*， 和*`第二`*论据。

    这*`第二`*参数可以有小数部分。

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

-   [](<>)

    [`微秒（*`表达式`*)`](date-and-time-functions.html#function_microsecond)

    [](<>)

    从时间或日期时间表达式返回微秒*`表达式`*作为范围内的数字`0`到`999999`.

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

-   [](<>)

    [`分钟（*`时间`*)`](date-and-time-functions.html#function_minute)

    [](<>)

    返回分钟*`时间`*， 范围中`0`到`59`.

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

-   [](<>)

    [`月（*`日期`*)`](date-and-time-functions.html#function_month)

    [](<>)

    返回月份*`日期`*， 范围中`1`到`12`一月至十二月，或`0`对于日期，例如`'0000-00-00'`要么`'2008-00-00'`有零个月的部分。

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

-   [](<>)

    [`月名(*`日期`*)`](date-and-time-functions.html#function_monthname)

    [](<>)

    返回月份的全名*`日期`*.名称所使用的语言由[`lc_time_names`](server-system-variables.html#sysvar_lc_time_names)系统变量 ([第 10.16 节，“MySQL 服务器语言环境支持”](locale-support.html)）。

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

-   [](<>)

    [`现在（[*`fsp`*])`](date-and-time-functions.html#function_now)

    [](<>)

    返回当前日期和时间作为值`'*`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
    ```

    [`现在（）`](date-and-time-functions.html#function_now)返回一个常数时间，指示语句开始执行的时间。（在存储的函数或触发器中，[`现在（）`](date-and-time-functions.html#function_now)返回函数或触发语句开始执行的时间。）这与[`系统日期（）`](date-and-time-functions.html#function_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 |
    +---------------------+----------+---------------------+
    ```

    除此之外`设置时间戳`语句影响返回的值[`现在（）`](date-and-time-functions.html#function_now)但不是通过[`系统日期（）`](date-and-time-functions.html#function_sysdate).这意味着二进制日志中的时间戳设置对调用没有影响[`系统日期（）`](date-and-time-functions.html#function_sysdate).将时间戳设置为非零值会导致每次后续调用[`现在（）`](date-and-time-functions.html#function_now)返回该值。将时间戳设置为零会取消此效果，以便[`现在（）`](date-and-time-functions.html#function_now)再次返回当前日期和时间。

    请参阅说明[`系统日期（）`](date-and-time-functions.html#function_sysdate)有关这两个函数之间差异的更多信息。

-   [](<>)

    [`PERIOD_ADD(*`磷`*,*`ñ`*)`](date-and-time-functions.html#function_period-add)

    [](<>)

    添加*`ñ`*几个月到月经*`磷`*（格式为*`YYMM`*要么*`YYYYMM`*）。返回格式中的值*`YYYYMM`*.

    笔记

    时期论证*`磷`*是*不是*日期值。

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

-   [](<>)

    [`PERIOD_DIFF(*`P1`*,*`P2`*)`](date-and-time-functions.html#function_period-diff)

    [](<>)

    返回期间之间的月数*`P1`*和*`P2`*.*`P1`*和*`P2`*应该是格式*`YYMM`*要么*`YYYYMM`*.请注意，句点参数*`P1`*和*`P2`*是*不是*日期值。

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

-   [](<>)

    [`25美分硬币（*`日期`*)`](date-and-time-functions.html#function_quarter)

    [](<>)

    返回一年中的季度*`日期`*， 范围中`1`到`4`.

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

-   [](<>)

    [`第二（*`时间`*)`](date-and-time-functions.html#function_second)

    [](<>)

    返回第二个*`时间`*， 范围中`0`到`59`.

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

-   [](<>)

    [`SEC_TO_TIME(*`秒`*)`](date-and-time-functions.html#function_sec-to-time)

    [](<>)

    返回*`秒`*参数，转换为小时、分钟和秒，作为[`时间`](time.html)价值。结果的范围被限制在[`时间`](time.html)数据类型。如果参数对应的值超出该范围，则会出现警告。

    ```
    mysql> SELECT SEC_TO_TIME(2378);
            -> '00:39:38'
    mysql> SELECT SEC_TO_TIME(2378) + 0;
            -> 3938
    ```

-   [](<>)

    [`STR_TO_DATE(*`字符串`*,*`格式`*)`](date-and-time-functions.html#function_str-to-date)

    [](<>)

    这是相反的[`日期格式（）`](date-and-time-functions.html#function_date-format)功能。它需要一个字符串*`字符串`*和一个格式字符串*`格式`*.[`STR_TO_DATE()`](date-and-time-functions.html#function_str-to-date)返回一个[`约会时间`](datetime.html)如果格式字符串同时包含日期和时间部分，则为值，或者[`日期`](datetime.html)要么[`时间`](time.html)如果字符串仅包含日期或时间部分，则为值。如果日期、时间或日期时间值从*`字符串`*是非法的，[`STR_TO_DATE()`](date-and-time-functions.html#function_str-to-date)返回`空值`并产生警告。

    服务器扫描*`字符串`*试图匹配*`格式`*给它。格式字符串可以包含文字字符和以开头的格式说明符`%`.中的文字字符*`格式`*必须在字面上匹配*`字符串`*.格式说明符*`格式`*必须匹配日期或时间部分*`字符串`*.对于可用于的说明符*`格式`*，见[`日期格式（）`](date-and-time-functions.html#function_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'
    ```

    扫描从开头开始*`字符串`*如果失败*`格式`*发现不匹配。末尾的多余字符*`字符串`*被忽略。

    ```
    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，因此在*`字符串`*产生部分或全部部分设置为 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.2.2 节，“DATE、DATETIME 和 TIMESTAMP 类型”](datetime.html).这意味着，例如，允许“零”日期或部分值为 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-mode.html#sqlmode_no_zero_date)启用 SQL 模式，不允许零日期。在这种情况下，[`STR_TO_DATE()`](date-and-time-functions.html#function_str-to-date)返回`空值`并生成警告：

    ```
    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
    ```

    笔记

    您不能使用格式`“%X%V”`将年-周字符串转换为日期，因为如果周跨越月边界，年和周的组合不会唯一标识年和月。要将年周转换为日期，您还应该指定工作日：

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

-   [](<>)

    [`子日期（*`日期`*，间隔 *`表达式`* *`单元`*)`](date-and-time-functions.html#function_subdate),[`子日期（*`表达式`*,*`天`*)`](date-and-time-functions.html#function_subdate)

    [](<>)

    当调用`间隔`第二个参数的形式，[`子日期（）`](date-and-time-functions.html#function_subdate)是同义词[`DATE_SUB()`](date-and-time-functions.html#function_date-sub).有关信息`间隔` *`单元`*论点，见讨论[`DATE_ADD()`](date-and-time-functions.html#function_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'
    ```

    第二种形式允许使用整数值*`天`*.在这种情况下，它被解释为从日期或日期时间表达式中减去的天数*`表达式`*.

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

-   [](<>)

    [`次时间（*`expr1`*,*`expr2`*)`](date-and-time-functions.html#function_subtime)

    [](<>)

    [`次时间（）`](date-and-time-functions.html#function_subtime)返回*`expr1`*-*`expr2`*表示为格式相同的值*`expr1`*.*`expr1`*是时间或日期时间表达式，并且*`expr2`*是时间表达式。

    此函数的返回类型的解析按原样执行[`添加时间（）`](date-and-time-functions.html#function_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'
    ```

-   [](<>)

    [`系统日期（[*`fsp`*])`](date-and-time-functions.html#function_sysdate)

    [](<>)

    返回当前日期和时间作为值`'*`YYYY-MM-DD hh:mm:ss`*'`要么*`YYYYMMDDhhmmss`*格式，取决于函数是在字符串还是数字上下文中使用。

    如果*`fsp`*给出参数以指定从 0 到 6 的小数秒精度，返回值包括那么多数字的小数秒部分。

    [`系统日期（）`](date-and-time-functions.html#function_sysdate)返回它执行的时间。这与行为不同[`现在（）`](date-and-time-functions.html#function_now)，它返回一个常数时间，指示语句开始执行的时间。（在存储的函数或触发器中，[`现在（）`](date-and-time-functions.html#function_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 |
    +---------------------+----------+---------------------+
    ```

    除此之外`设置时间戳`语句影响返回的值[`现在（）`](date-and-time-functions.html#function_now)但不是通过[`系统日期（）`](date-and-time-functions.html#function_sysdate).这意味着二进制日志中的时间戳设置对调用没有影响[`系统日期（）`](date-and-time-functions.html#function_sysdate).

    因为[`系统日期（）`](date-and-time-functions.html#function_sysdate)即使在同一个语句中也可以返回不同的值，并且不受`设置时间戳`，如果使用基于语句的二进制日志记录，它是不确定的，因此复制不安全。如果这是一个问题，您可以使用基于行的日志记录。

    或者，您可以使用[`--sysdate-is-now`](server-options.html#option_mysqld_sysdate-is-now)导致的选项[`系统日期（）`](date-and-time-functions.html#function_sysdate)做一个别名[`现在（）`](date-and-time-functions.html#function_now).如果在复制源服务器和副本上都使用该选项，则此方法有效。

    不确定性的本质[`系统日期（）`](date-and-time-functions.html#function_sysdate)也意味着索引不能用于评估引用它的表达式。

-   [](<>)

    [`时间（*`表达式`*)`](date-and-time-functions.html#function_time)

    [](<>)

    提取时间或日期时间表达式的时间部分*`表达式`*并将其作为字符串返回。

    此函数对于基于语句的复制是不安全的。如果您在以下情况下使用此功能，则会记录警告[`binlog_format`](replication-options-binary-log.html#sysvar_binlog_format)被设定为`陈述`.

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

-   [](<>)

    [`时差(*`expr1`*,*`expr2`*)`](date-and-time-functions.html#function_timediff)

    [](<>)

    [`时差（）`](date-and-time-functions.html#function_timediff)返回*`expr1`*-*`expr2`*表示为时间值。*`expr1`*和*`expr2`*是时间或日期和时间表达式，但两者必须属于同一类型。

    返回的结果`时差（）`被限制在允许的范围内[`时间`](time.html)价值观。或者，您可以使用任一功能[`时间戳 ()`](date-and-time-functions.html#function_timestampdiff)和[`UNIX_TIMESTAMP()`](date-and-time-functions.html#function_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'
    ```

-   [](<>)

    [`时间戳（*`表达式`*)`](date-and-time-functions.html#function_timestamp),[`时间戳（*`expr1`*,*`expr2`*)`](date-and-time-functions.html#function_timestamp)

    [](<>)

    使用单个参数，此函数返回日期或日期时间表达式*`表达式`*作为日期时间值。使用两个参数，它添加了时间表达式*`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'
    ```

-   [](<>)

    [`时间戳记（*`单元`*,*`间隔`*,*`日期时间表达式`*)`](date-and-time-functions.html#function_timestampadd)

    [](<>)

    添加整数表达式*`间隔`*到日期或日期时间表达式*`日期时间表达式`*.单位为*`间隔`*由*`单元`*参数，它应该是以下值之一：`微秒`（微秒），`第二`,`分钟`,`小时`,`日`,`星期`,`月`,`25美分硬币`， 要么`年`.

    这*`单元`*可以使用所示的关键字之一指定值，也可以使用前缀`SQL_TSI_`.例如，`日`和`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'
    ```

-   [](<>)

    [`时间戳（*`单元`*,*`datetime_expr1`*,*`datetime_expr2`*)`](date-and-time-functions.html#function_timestampdiff)

    [](<>)

    退货*`datetime_expr2`*-*`datetime_expr1`*， 在哪里*`datetime_expr1`*和*`datetime_expr2`*是日期或日期时间表达式。一个表达式可以是日期，而另一个表达式可以是日期时间；日期值被视为具有时间部分的日期时间`'00:00:00'`在必要时。结果的单位（整数）由*`单元`*争论。法律价值*`单元`*与描述中列出的相同[`时间戳记（）`](date-and-time-functions.html#function_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
    ```

    笔记

    此函数的日期或日期时间参数的顺序与使用的相反[`时间戳（）`](date-and-time-functions.html#function_timestamp)使用 2 个参数调用时的函数。

-   [](<>)

    [`时间格式（*`时间`*,*`格式`*)`](date-and-time-functions.html#function_time-format)

    [](<>)

    这就像使用[`日期格式（）`](date-and-time-functions.html#function_date-format)功能，但*`格式`*字符串可能仅包含小时、分钟、秒和微秒的格式说明符。其他说明符产生`空值`价值或`0`.

    如果*`时间`*value 包含大于的小时部分`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(*`时间`*)`](date-and-time-functions.html#function_time-to-sec)

    [](<>)

    返回*`时间`*参数，转换为秒。

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

-   [](<>)

    [`TO_DAYS(*`日期`*)`](date-and-time-functions.html#function_to-days)

    [](<>)

    给定一个日期*`日期`*, 返回一个天数（自 0 年以来的天数）。

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

    [`TO_DAYS()`](date-and-time-functions.html#function_to-days)不适用于公历 (1582) 出现之前的值，因为它没有考虑日历更改时丢失的天数。对于 1582 年之前的日期（在其他语言环境中可能是更晚的年份），此函数的结果不可靠。看[第 12.9 节，“MySQL 使用什么日历？”](mysql-calendar.html), 了解详情。

    请记住，MySQL 使用以下规则将日期中的两位数年份值转换为四位数形式[第 11.2 节，“日期和时间数据类型”](date-and-time-types.html).例如，`'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（）`](date-and-time-functions.html#function_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)
    ```

    这是真的，无论[`允许无效日期`](sql-mode.html#sqlmode_allow_invalid_dates)SQL server模式已启用。

-   [](<>)

    [`几秒钟(*`expr`*)`](date-and-time-functions.html#function_to-seconds)

    [](<>)

    给定日期或日期时间*`expr`*，返回自0年以来的秒数。如果*`expr`*不是有效的日期或日期时间值，返回`无效的`.

    ```
    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（）`](date-and-time-functions.html#function_to-days),`到_秒（）`不适用于公历（1582）出现之前的值，因为它不考虑日历更改时损失的天数。对于1582年之前的日期（在其他地区可能是更晚的一年），此函数的结果不可靠。看见[第12.9节，“MySQL使用什么日历？”](mysql-calendar.html)，以获取详细信息。

    喜欢[`TO_DAYS（）`](date-and-time-functions.html#function_to-days),`到_秒（）`，使用中的规则将日期中的两位数年份值转换为四位数形式[第11.2节，“日期和时间数据类型”](date-and-time-types.html).

    在MySQL中，零日期定义为`'0000-00-00'`，即使该日期本身被视为无效。这意味着`'0000-00-00'`和`'0000-01-01'`, [`到_秒（）`](date-and-time-functions.html#function_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)
    ```

    这是真的，无论[`允许无效日期`](sql-mode.html#sqlmode_allow_invalid_dates)SQL server模式已启用。

-   [](<>)

    [`UNIX_时间戳([*`日期`*])`](date-and-time-functions.html#function_unix-timestamp)

    [](<>)

    如果[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)被称为没有*`日期`*参数，它返回一个Unix时间戳，表示自`'1970-01-01 00:00:00'`UTC。

    如果[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)被称为*`日期`*参数，它以秒为单位返回参数的值`'1970-01-01 00:00:00'`UTC。服务器解释*`日期`*作为会话时区中的值，并将其转换为内部Unix时间戳值（UTC）。（客户端可以按照中的说明设置会话时区。）[第5.1.15节，“MySQL服务器时区支持”](time-zone-support.html)）The*`日期`*争论可能是一场争论[`日期`](datetime.html), [`约会时间`](datetime.html)或[`时间戳`](datetime.html)字符串，或*`YYMMDD`*, *`取当前时间`*, *`YYYYMMDD`*或*`YYYYMMDDhhmmss`*总体安排如果参数包含时间部分，则可以选择包含小数秒部分。

    如果未给出参数或参数不包含小数秒部分，则返回值为整数，或[`十进制的`](fixed-point-types.html)如果给出的参数包含小数秒部分。

    当*`日期`*争论是一场争论[`时间戳`](datetime.html)柱[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)直接返回内部时间戳值，不进行隐式的“字符串到Unix时间戳”转换。

    在MySQL 8.0.28之前，参数值的有效范围与[`时间戳`](datetime.html)数据类型：`'1970-01-01 00:00:01.000000'`UTC至`'2038-01-19 03:14:07.999999'`UTC。MySQL 8.0.28及更高版本的32位平台也是如此。对于在64位平台上运行的MySQL 8.0.28及更高版本`UNIX_时间戳（）`是`'1970-01-01 00:00:01.000000'`UTC至`'3001-01-19 03:14:07.999999'`UTC（相当于32536771199.999999秒）。

    无论MySQL版本或平台架构如何，如果您将超出范围的日期传递给[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)，它回来了`0`.

    ```
    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_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)和[`来自_UNIXTIME（）`](date-and-time-functions.html#function_from-unixtime)要在非UTC时区的值和Unix时间戳值之间转换，转换是有损的，因为在两个方向上的映射不是一一对应的。例如，由于夏令时（DST）等本地时区更改的约定，可以[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)将非UTC时区中不同的两个值映射到相同的Unix时间戳值。[`来自_UNIXTIME（）`](date-and-time-functions.html#function_from-unixtime)仅将该值映射回一个原始值。下面是一个示例，使用在`遇见`时区：

    ```
    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       |
    +---------------------------+
    ```

    笔记

    使用命名时区，例如`“大都会”`或`“欧洲/阿姆斯特丹”`，必须正确设置时区表。有关说明，请参阅[第5.1.15节，“MySQL服务器时区支持”](time-zone-support.html).

    如果你想减法[`UNIX_时间戳（）`](date-and-time-functions.html#function_unix-timestamp)列，您可能希望将它们转换为有符号整数。看见[第12.11节，“转换函数和运算符”](cast-functions.html).

-   [](<>)

    [`UTC_日期`](date-and-time-functions.html#function_utc-date), [`UTC_日期（）`](date-and-time-functions.html#function_utc-date)

    [](<>)

    将当前UTC日期作为值返回到`'*`YYYY-MM-DD`*'`或*`YYYYMMDD`*格式，具体取决于函数是在字符串上下文中使用还是在数字上下文中使用。

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

-   [](<>)

    [`UTC_时间`](date-and-time-functions.html#function_utc-time), [`UTC_时间([*`fsp`*])`](date-and-time-functions.html#function_utc-time)

    [](<>)

    将当前UTC时间作为值返回到*`“hh:mm:ss”`*或*`HHMMS`*格式，具体取决于函数是在字符串上下文中使用还是在数字上下文中使用。

    如果*`fsp`*参数用于指定0到6之间的小数秒精度，返回值包括该数字中的小数秒部分。

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

-   [](<>)

    [`UTC_时间戳`](date-and-time-functions.html#function_utc-timestamp), [`UTC_时间戳([*`fsp`*])`](date-and-time-functions.html#function_utc-timestamp)

    [](<>)

    将当前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
    ```

-   [](<>)

    [`周(*`日期`*[,*`模式`*])`](date-and-time-functions.html#function_week)

    [](<>)

    此函数用于返回工作的周数*`日期`*.两个论点的形式[`第（周）`](date-and-time-functions.html#function_week)使您可以指定一周是从星期天还是星期一开始，以及返回值是否应在以下范围内：`0`到`53`或者来自`1.`到`53`.如果*`模式`*如果省略参数，则[`默认的周格式`](server-system-variables.html#sysvar_default_week_format)使用系统变量。看见[第5.1.8节“服务器系统变量”](server-system-variables.html).

    下表描述了*`模式`*争论是有效的。

    | 模式 | 一周的第一天 | 范围 | 第一周是第一周… |
    | --- | ------ | --- | -------- |
    | 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天或更多天”的数值，根据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
    ```

    如果日期落在前一年的最后一周，MySQL将返回`0`如果你不使用`2.`, `3.`, `6.`或`7.`作为可选选项*`模式`*论点：

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

    有人可能会说[`第（周）`](date-and-time-functions.html#function_week)应该回来`52`因为给定的日期实际上发生在1999年的第52周。[`第（周）`](date-and-time-functions.html#function_week)返回`0`相反，返回值是“给定年份中的周数”这就利用了[`第（周）`](date-and-time-functions.html#function_week)与从日期中提取日期部分的其他函数结合使用时，功能可靠。

    如果您希望根据包含给定日期一周中第一天的年份评估结果，请使用`0`, `2.`, `5.`或`7.`作为可选选项*`模式`*论点

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

    或者，使用[`年度周刊（）`](date-and-time-functions.html#function_yearweek)功能：

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

-   [](<>)

    [`工作日(*`日期`*)`](date-and-time-functions.html#function_weekday)

    [](<>)

    返回的工作日索引*`日期`* (`0`=星期一，`1.`星期二…`6.`=周日）。

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

-   [](<>)

    [`周末(*`日期`*)`](date-and-time-functions.html#function_weekofyear)

    [](<>)

    将日期的日历周返回为以下范围内的数字：`1.`到`53`. [`周末（年）`](date-and-time-functions.html#function_weekofyear)是一个兼容函数，相当于[`周(*`日期`*,3)`](date-and-time-functions.html#function_week).

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

-   [](<>)

    [`年(*`日期`*)`](date-and-time-functions.html#function_year)

    [](<>)

    返回年份*`日期`*，在范围内`1000`到`9999`或`0`“零”日期。

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

-   [](<>)

    [`年度周刊(*`日期`*)`](date-and-time-functions.html#function_yearweek), [`年度周刊(*`日期`*,*`模式`*)`](date-and-time-functions.html#function_yearweek)

    [](<>)

    返回日期的年份和星期。结果中的年份可能与一年中第一周和最后一周的日期参数中的年份不同。

    这个*`模式`*论点的工作原理与*`模式`*争论[`第（周）`](date-and-time-functions.html#function_week).对于单参数语法*`模式`*使用0的值。不像[`第（周）`](date-and-time-functions.html#function_week)，价值[`默认的周格式`](server-system-variables.html#sysvar_default_week_format)不影响[`年度周刊（）`](date-and-time-functions.html#function_yearweek).

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

    周数不同于[`第（周）`](date-and-time-functions.html#function_week)函数将返回(`0`)对于可选参数`0`或`1.`像[`第（周）`](date-and-time-functions.html#function_week)然后返回给定年份上下文中的周。