MySQL 中文文档

# 12.7 日期和时间函数

本节介绍可用于操作时间值的函数。看第 11.2 节，“日期和时间数据类型”，用于描述每个日期和时间类型具有的值范围以及可以指定值的有效格式。

表 12.11 日期和时间函数

姓名 描述
添加日期（） 将时间值（间隔）添加到日期值
添加时间（） 添加时间
转换_TZ() 从一个时区转换到另一个时区
CURDATE() 返回当前日期
当前的日期（）,当前的日期 CURDATE() 的同义词
当前时间（）,当前时间 CURTIME() 的同义词
CURRENT_TIMESTAMP(),CURRENT_TIMESTAMP NOW() 的同义词
时间（） 返回当前时间
日期（） 提取日期或日期时间表达式的日期部分
DATE_ADD() 将时间值（间隔）添加到日期值
日期格式（） 按指定格式日期
DATE_SUB() 从日期中减去时间值（间隔）
日期判断（） 减去两个日期
日（） DAYOFMONTH() 的同义词
日期名称（） 返回工作日的名称
DAYOFMONTH() 返回月份中的第几天 (0-31)
星期几（） 返回参数的工作日索引
年份（） 返回一年中的某一天 (1-366)
提炼（） 提取日期的一部分
FROM_DAYS() 将天数转换为日期
FROM_UNIXTIME() 将 Unix 时间戳格式化为日期
GET_FORMAT() 返回日期格式字符串
小时（） 提取小时
最后一天 返回参数的月份的最后一天
当地时间（）, 当地时间 现在（）的同义词
本地时间戳, 本地时间戳（） 现在（）的同义词
制作日期（） 根据年份和日期创建日期
找时间（） 从小时、分钟、秒创建时间
微秒（） 从参数返回微秒
分钟（） 从参数返回分钟
月（） 从过去的日期返回月份
月名() 返回月份的名称
现在（） 返回当前日期和时间
PERIOD_ADD() 为年月添加期间
PERIOD_DIFF() 返回期间之间的月数
25美分硬币（） 从日期参数返回季度
SEC_TO_TIME() 将秒转换为 'hh:mm:ss' 格式
第二（） 返回第二个 (0-59)
STR_TO_DATE() 将字符串转换为日期
子日期（） 日期的同义词_使用三个参数调用 SUB()
次时间（） 减去时间
系统日期（） 返回函数执行的时间
时间（） 提取传递的表达式的时间部分
时间格式（） 格式为时间
TIME_TO_SEC() 返回转换为秒的参数
时差（） 减去时间
时间戳（） 使用单个参数，此函数返回日期或日期时间表达式；有两个参数，参数的总和
时间戳记（） 向日期时间表达式添加间隔
时间戳 () 从日期时间表达式中减去间隔
TO_DAYS() 返回转换为天的日期参数
TO_SECONDS() 返回自第 0 年以来转换为秒的日期或日期时间参数
UNIX_TIMESTAMP() 返回一个 Unix 时间戳
UTC_DATE() 返回当前 UTC 日期
UTC_TIME() 返回当前 UTC 时间
UTC_TIMESTAMP() 返回当前 UTC 日期和时间
星期（） 返回周数
平日（） 返回工作日索引
一周年（） 返回日期的日历周 (1-53)
年（） 返回年份
年周（） 返回年份和星期

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

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

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

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

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

这CURRENT_TIMESTAMP(),当前时间（）,当前的日期（）， 和FROM_UNIXTIME()函数返回当前会话时区的值，可作为时区系统变量。此外，UNIX_TIMESTAMP()假定其参数是会话时区中的日期时间值。看第 5.1.15 节，“MySQL 服务器时区支持”.

某些日期函数可以与“零”日期或不完整日期一起使用，例如'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

几个函数在传递时是严格的日期（）函数值作为它们的参数，并拒绝日期部分为零的不完整日期：转换_TZ(),DATE_ADD(),DATE_SUB(),年份（）,时间戳 (),TO_DAYS(),TO_SECONDS(),星期（）,平日（）,一周年（）,年周（）.

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

  • 添加日期（*日期*，间隔 *表达式* *单元*),添加日期（*表达式*,*天*)

    当调用间隔第二个参数的形式，添加日期（）是同义词DATE_ADD().相关功能子日期（）是同义词DATE_SUB().有关信息间隔 *单元*论据，见时间间隔.

    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*)

    添加时间（）添加*expr2到expr1并返回结果。expr1是时间或日期时间表达式，并且expr2*是时间表达式。

    从 MySQL 8.0.28 开始，此函数的返回类型和次时间（）函数确定如下：

    • 如果第一个参数是动态参数（例如在准备好的语句中），则返回类型为时间.

    • 否则，函数的解析类型派生自第一个参数的解析类型。

    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*)

    转换_TZ()转换日期时间值*dt从给定的时区from_tz到给定的时区to_tz*并返回结果值。时区的指定如中所述第 5.1.15 节，“MySQL 服务器时区支持”.这个函数返回空值如果参数无效。

    在 32 位平台上，此函数支持的值范围与时间戳类型（见第 11.2.1 节，“日期和时间数据类型语法”，用于范围信息）。在 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 服务器时区支持”.

  • CURDATE()

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

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

  • 当前的日期,当前的日期（）

    当前的日期和当前的日期（）是同义词CURDATE().

  • 当前时间,当前时间（[*fsp*])

    当前时间和当前时间（）是同义词时间（）.

  • CURRENT_TIMESTAMP,CURRENT_TIMESTAMP([*fsp*])

    CURRENT_TIMESTAMP和CURRENT_TIMESTAMP()是同义词现在（）.

  • 课时（[*fsp*])

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

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

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

  • 日期（*表达式*)

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

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

  • 日期（*expr1*,*expr2*)

    日期判断（）返回*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_SUB(*日期*，间隔 *表达式* *单元*)

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

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

    返回值取决于参数：

    • 日期如果*日期*论证是一个日期价值和你的计算只涉及年,月， 和日部分（即没有时间部分）。

    • (MySQL 8.0.28 及更高版本😃 时间如果*日期*论证是一个时间值和计算只涉及小时, 分钟， 和秒部分（即没有日期部分）。

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

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

    • 否则为字符串（类型VARCHAR）。

    笔记

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

    为了确保结果是约会时间， 您可以使用投掷（）将第一个参数转换为约会时间.

    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'

  • 日期格式（*日期*,*格式*)

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

    下表中显示的说明符可用于*格式*细绳。这%在格式说明符字符之前需要字符。说明符也适用于其他函数：STR_TO_DATE(),时间格式（）,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)，其中星期日是一周的第一天；星期（）模式 0
    %u 星期 （00..53)，其中星期一是一周的第一天；星期（）模式一
    %V 星期 （01..53)，其中星期日是一周的第一天；星期（）模式二；与％X
    %v 星期 （01..53)，其中星期一是一周的第一天；星期（）模式3；与％X
    %W 工作日名称 (星期日..周六)
    %w 一周中的天 （0=星期天..6=星期六）
    ％X 星期天是一周的第一天的一周年，数字，四位数字；与%V
    ％X 一周的年份，其中星期一是一周的第一天，数字，四位数字；与%v
    %Y 年份，数字，四位数
    %y 年份，数字（两位数）
    %% 一个字面%特点
    %*x* x, 对于任何“x”未在上面列出

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

    用于日期和月份名称和缩写的语言由lc_time_names系统变量 (第 10.16 节，“MySQL 服务器语言环境支持”）。

    为了%U,%u,%V， 和%v说明符，请参阅星期（）函数获取有关模式值的信息。该模式会影响周编号的发生方式。

    日期格式（）返回具有字符集和排序规则的字符串字符集连接和collat​​ion_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_ADD().

  • 日（*日期*)

    日（）是同义词DAYOFMONTH().

  • 日期名称（*日期*)

    返回工作日的名称*日期*.名称所使用的语言由lc_time_names系统变量 (第 10.16 节，“MySQL 服务器语言环境支持”）。

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

  • DAYOFMONTH(*日期*)

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

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

  • 星期几(*日期*)

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

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

  • 日期（*日期*)

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

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

  • 提炼（*单元* 从 *日期*)

    这提炼（）函数使用相同种类的*单元说明符为DATE_ADD()要么DATE_SUB(), 但从日期中提取部分而不是执行日期算术。有关信息单元*论据，见时间间隔.

    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(*ñ*)

    给定一个天数*ñ*, 返回一个日期价值。

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

    采用FROM_DAYS()谨慎对待旧日期。它不适用于公历 (1582) 出现之前的值。看第 12.9 节，“MySQL 使用什么日历？”.

  • FROM_UNIXTIME(*unix_timestamp*[,*格式*])

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

    如果*总体安排*如果省略，该函数将返回约会时间价值

    如果*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.

    *总体安排用于格式化结果的方式与用于日期格式（）作用如果总体安排*则返回的值为瓦尔查尔.

    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_时间戳（）和来自_UNIXTIME（）要在非UTC时区的值和Unix时间戳值之间转换，转换是有损的，因为在两个方向上的映射不是一一对应的。有关详细信息，请参见UNIX_时间戳（）作用

  • 获取|格式（{DATE | TIME | DATETIME}，{'EUR'|'USA'|'JIS'|'ISO'|'INTERNAL'}）

    返回格式字符串。此功能与日期格式（）还有STR_TO_DATE（）功能。

    第一个和第二个参数的可能值会产生几个可能的格式字符串（有关使用的说明符，请参阅日期格式（）功能描述）。ISO格式指的是ISO 9075，而不是ISO 8601。

    函数调用 后果
    获取格式（日期，'USA'） “%m.%d.%y”
    GET FORMAT（日期，'JIS'） “%y-%m-%d”
    GET FORMAT（日期，'ISO'） “%y-%m-%d”
    GET FORMAT（日期，'EUR'） “%d.%m.%y”
    获取格式（日期，'internal'） “%y%m%d”
    GET FORMAT（日期时间，'USA'） “%y-%m-%d%h.%i.%s”
    GET FORMAT（日期时间，'JIS'） “%y-%m-%d%h:%i:%s”
    GET FORMAT（日期时间，'ISO'） “%y-%m-%d%h:%i:%s”
    GET FORMAT（日期时间，'EUR'） “%y-%m-%d%h.%i.%s”
    get format（日期时间，'internal'） “%y%m%d%h%i%s”
    GET FORMAT（时间，'USA'） “%h:%i:%s%p”
    GET FORMAT（时间，'JIS'） “%h:%i:%s”
    GET FORMAT（时间，'ISO'） “%h:%i:%s”
    GET FORMAT（时间，'EUR'） “%h.%i.%s”
    获取格式（时间，'internal'） “%h%i%s”

    时间戳也可以用作获取格式（），在这种情况下，函数返回的值与约会时间.

    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'

  • 小时(*时间*)

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

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

  • 最后一天(*日期*)

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

    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

  • 本地时间, 本地时间([*fsp*])

    当地时间和当地时间（）是同义词现在（）.

  • 本地时间戳, 本地时间戳（[*fsp*])

    本地时间戳和本地时间戳（）是同义词现在（）.

  • 制作日期（*年*,*一年中的一天*)

    返回一个日期，给定年份和年份值。*一年中的一天*必须大于 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

  • 找时间（*小时*,*分钟*,*第二*)

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

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

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

  • 微秒（*表达式*)

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

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

  • 分钟（*时间*)

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

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

  • 月（*日期*)

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

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

  • 月名(*日期*)

    返回月份的全名*日期*.名称所使用的语言由lc_time_names系统变量 (第 10.16 节，“MySQL 服务器语言环境支持”）。

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

  • 现在（[*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

    现在（）返回一个常数时间，指示语句开始执行的时间。（在存储的函数或触发器中，现在（）返回函数或触发语句开始执行的时间。）这与系统日期（），它返回它执行的确切时间。

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

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

    请参阅说明系统日期（）有关这两个函数之间差异的更多信息。

  • PERIOD_ADD(*磷*,*ñ*)

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

    笔记

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

    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

  • 25美分硬币（*日期*)

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

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

  • 第二（*时间*)

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

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

  • SEC_TO_TIME(*秒*)

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

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

  • STR_TO_DATE(*字符串*,*格式*)

    这是相反的日期格式（）功能。它需要一个字符串*字符串和一个格式字符串格式.STR_TO_DATE()返回一个约会时间如果格式字符串同时包含日期和时间部分，则为值，或者日期要么时间如果字符串仅包含日期或时间部分，则为值。如果日期、时间或日期时间值从字符串*是非法的，STR_TO_DATE()返回空值并产生警告。

    服务器扫描*字符串试图匹配格式给它。格式字符串可以包含文字字符和以开头的格式说明符%.中的文字字符格式必须在字面上匹配字符串.格式说明符格式必须匹配日期或时间部分字符串.对于可用于的说明符格式*，见日期格式（）功能说明。

    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 类型”.这意味着，例如，允许“零”日期或部分值为 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()返回空值并生成警告：

    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_SUB().有关信息间隔 *单元*论点，见讨论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*)

    次时间（）返回*expr1-expr2表示为格式相同的值expr1.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'

  • 系统日期（[*fsp*])

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

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

    系统日期（）返回它执行的时间。这与行为不同现在（），它返回一个常数时间，指示语句开始执行的时间。（在存储的函数或触发器中，现在（）返回函数或触发语句开始执行的时间。）

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

    除此之外设置时间戳语句影响返回的值现在（）但不是通过系统日期（）.这意味着二进制日志中的时间戳设置对调用没有影响系统日期（）.

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

    或者，您可以使用--sysdate-is-now导致的选项系统日期（）做一个别名现在（）.如果在复制源服务器和副本上都使用该选项，则此方法有效。

    不确定性的本质系统日期（）也意味着索引不能用于评估引用它的表达式。

  • 时间（*表达式*)

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

    此函数对于基于语句的复制是不安全的。如果您在以下情况下使用此功能，则会记录警告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*)

    时差（）返回*expr1-expr2表示为时间值。expr1和expr2*是时间或日期和时间表达式，但两者必须属于同一类型。

    返回的结果时差（）被限制在允许的范围内时间价值观。或者，您可以使用任一功能时间戳 ()和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'

  • 时间戳（*表达式*),时间戳（*expr1*,*expr2*)

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

  • 时间戳记（*单元*,*间隔*,*日期时间表达式*)

    添加整数表达式*间隔到日期或日期时间表达式日期时间表达式.单位为间隔由单元*参数，它应该是以下值之一：微秒（微秒），第二,分钟,小时,日,星期,月,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*)

    退货*datetime_expr2-datetime_expr1， 在哪里datetime_expr1和datetime_expr2是日期或日期时间表达式。一个表达式可以是日期，而另一个表达式可以是日期时间；日期值被视为具有时间部分的日期时间'00:00:00'在必要时。结果的单位（整数）由单元争论。法律价值单元*与描述中列出的相同时间戳记（）功能。

    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

    笔记

    此函数的日期或日期时间参数的顺序与使用的相反时间戳（）使用 2 个参数调用时的函数。

  • 时间格式（*时间*,*格式*)

    这就像使用日期格式（）功能，但*格式*字符串可能仅包含小时、分钟、秒和微秒的格式说明符。其他说明符产生空值价值或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(*时间*)

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

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

  • TO_DAYS(*日期*)

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

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

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

    请记住，MySQL 使用以下规则将日期中的两位数年份值转换为四位数形式第 11.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)

    这是真的，无论允许无效日期SQL server模式已启用。

  • 几秒钟(*expr*)

    给定日期或日期时间*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（）,到_秒（）不适用于公历（1582）出现之前的值，因为它不考虑日历更改时损失的天数。对于1582年之前的日期（在其他地区可能是更晚的一年），此函数的结果不可靠。看见第12.9节，“MySQL使用什么日历？”，以获取详细信息。

    喜欢TO_DAYS（）,到_秒（），使用中的规则将日期中的两位数年份值转换为四位数形式第11.2节，“日期和时间数据类型”.

    在MySQL中，零日期定义为'0000-00-00'，即使该日期本身被视为无效。这意味着'0000-00-00'和'0000-01-01', 到_秒（）返回此处显示的值：

    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 server模式已启用。

  • UNIX_时间戳([*日期*])

    如果UNIX_时间戳（）被称为没有*日期*参数，它返回一个Unix时间戳，表示自'1970-01-01 00:00:00'UTC。

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

    如果未给出参数或参数不包含小数秒部分，则返回值为整数，或十进制的如果给出的参数包含小数秒部分。

    当*日期*争论是一场争论时间戳柱UNIX_时间戳（）直接返回内部时间戳值，不进行隐式的“字符串到Unix时间戳”转换。

    在MySQL 8.0.28之前，参数值的有效范围与时间戳数据类型：'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_时间戳（），它回来了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_时间戳（）和来自_UNIXTIME（）要在非UTC时区的值和Unix时间戳值之间转换，转换是有损的，因为在两个方向上的映射不是一一对应的。例如，由于夏令时（DST）等本地时区更改的约定，可以UNIX_时间戳（）将非UTC时区中不同的两个值映射到相同的Unix时间戳值。来自_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服务器时区支持”.

    如果你想减法UNIX_时间戳（）列，您可能希望将它们转换为有符号整数。看见第12.11节，“转换函数和运算符”.

  • UTC_日期, UTC_日期（）

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

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

  • UTC_时间, UTC_时间([*fsp*])

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

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

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

  • UTC_时间戳, UTC_时间戳([*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

  • 周(*日期*[,*模式*])

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

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

    模式 一周的第一天 范围 第一周是第一周…
    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

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

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

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

    或者，使用年度周刊（）功能：

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

  • 工作日(*日期*)

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

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

  • 周末(*日期*)

    将日期的日历周返回为以下范围内的数字：1.到53. 周末（年）是一个兼容函数，相当于周(*日期*,3).

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

  • 年(*日期*)

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

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

  • 年度周刊(*日期*), 年度周刊(*日期*,*模式*)

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

    这个*模式论点的工作原理与模式争论第（周）.对于单参数语法模式*使用0的值。不像第（周），价值默认的周格式不影响年度周刊（）.

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

    周数不同于第（周）函数将返回(0)对于可选参数0或1.像第（周）然后返回给定年份上下文中的周。

← 12.8 字符串函数和运算符 →