### addDate :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `adddate` 返回添加指定时间后的日期。 **语法** ```SQL adddate(date, INTERVAL expr unit) adddate(expr, days) ``` **参数类型** * `date` * 要添加时间的日期或日期时间表达式 * Date/Date32/Datetime/Datetime64 * String * `INTERVAL expr unit` * 添加的时间间隔和单位 * unit可取值为：second、minute、hour、day、month、 year、minute_second、hour_second、hour_minute、day_second、 day_minute、day_hour、year_month * String * `expr` * 添加的时间间隔 * String * Int64 * `days` * 添加的天数 * String * Int64 **返回类型** Date **示例** **示例 1:** ```SQL SELECT adddate(date '2024-07-21', INTERVAL '3' day) as result; ``` ```Plain Text ┌─────result─┐ │ 2024-07-24 │ └────────────┘ ``` **示例 2:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' day) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-24 00:00:00 │ └─────────────────────┘ ``` **示例 3:** ```SQL SELECT adddate('2024-07-21', INTERVAL '3' day) as result; ``` ```Plain Text ┌──────────────────result─┐ │ 2024-07-24 00:00:00.000 │ └─────────────────────────┘ ``` **示例 4:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' second) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 00:00:03 │ └─────────────────────┘ ``` **示例 5:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' minute) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 00:03:00 │ └─────────────────────┘ ``` **示例 6:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' hour) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 03:00:00 │ └─────────────────────┘ ``` **示例 7:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' month) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-10-21 00:00:00 │ └─────────────────────┘ ``` **示例 8:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '3' year) as result; ``` ```Plain Text ┌──────────────result─┐ │ 2027-07-21 00:00:00 │ └─────────────────────┘ ``` **示例 9:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '01:01:10' hour_second) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 01:01:10 │ └─────────────────────┘ ``` **示例 10:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '00:10' hour_minute) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 00:10:00 │ └─────────────────────┘ ``` **示例 11:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '1 01:01:10' day_second) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-22 01:01:10 │ └─────────────────────┘ ``` **示例 12:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '01:10' minute_second) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 00:01:10 │ └─────────────────────┘ ``` **示例 13:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '1 01:01' day_minute) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-22 01:01:00 │ └─────────────────────┘ ``` **示例 14:** ```SQL SELECT adddate(datetime '2024-07-21', INTERVAL '1 01' day_hour) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-22 01:00:00 │ └─────────────────────┘ ``` **示例 15:** ```SQL SELECT adddate(datetime '2024-07-21 12:13:14', INTERVAL '2 2' year_month) AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2026-09-21 12:13:14 │ └─────────────────────┘ ``` **示例 16:** ```SQL SELECT adddate('2024-07-21', '3'); ``` ```Plain Text ┌─addDays('2024-07-21', '3')─┐ │ 2024-07-24 00:00:00.000 │ └────────────────────────────┘ ``` **示例 17:** ```SQL SELECT adddate('2024-07-21', 3); ``` ```Plain Text ┌─addDays('2024-07-21', 3)─┐ │ 2024-07-24 00:00:00.000 │ └──────────────────────────┘ ``` **示例 18:** ```SQL SELECT adddate(datetime '2024-07-21 12:13:14', 3); ``` ```Plain Text ┌─addDays(toDateTime('2024-07-21 12:13:14'), 3)─┐ │ 2024-07-24 12:13:14 │ └───────────────────────────────────────────────┘ ``` **示例 19:** ```SQL SELECT adddate(datetime '2024-07-21 12:13:14', '3'); ``` ```Plain Text ┌─addDays(toDateTime('2024-07-21 12:13:14'), '3')─┐ │ 2024-07-24 12:13:14 │ └─────────────────────────────────────────────────┘ ``` **示例 20:** ```SQL SELECT adddate('2024-07-21 12:13:14', 3); ``` ```Plain Text ┌─addDays('2024-07-21 12:13:14', 3)─┐ │ 2024-07-24 12:13:14.000 │ └───────────────────────────────────┘ ``` **示例 21:** ```SQL SELECT adddate('2024-07-21 12:13:14', '3'); ``` ```Plain Text ┌─addDays('2024-07-21 12:13:14', '3')─┐ │ 2024-07-24 12:13:14.000 │ └─────────────────────────────────────┘ ``` ### addDays 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。 **语法** ```SQL addDays(date, interval) addDays(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addDays(date, 1) AS add_days_with_date, addDays(date_time, 1) AS add_days_with_date_time ``` ```Plain Text ┌─add_days_with_date─┬─add_days_with_date_time─┐ │ 2018-01-02 │ 2018-01-02 00:00:00 │ └────────────────────┴─────────────────────────┘ ``` ### addHours 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。 **语法** ```SQL addHours(date, interval) addHours(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addHours(date, 1) AS add_hours_with_date, addHours(date_time, 1) AS add_hours_with_date_time ``` ```Plain Text ┌─add_hours_with_date─┬─add_hours_with_date_time─┐ │ 2018-01-01 01:00:00 │ 2018-01-01 01:00:00 │ └─────────────────────┴──────────────────────────┘ ``` ### addMinutes 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。 **语法** ```SQL addMinutes(date, interval) addMinutes(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addMinutes(date, 1) AS add_minutes_with_date, addMinutes(date_time, 1) AS add_minutes_with_date_time ``` ```Plain Text ┌─add_minutes_with_date─┬─add_minutes_with_date_time─┐ │ 2018-01-01 00:01:00 │ 2018-01-01 00:01:00 │ └───────────────────────┴────────────────────────────┘ ``` ### addMonths 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。例如： **语法** ```SQL addMonths(date, interval) addMonths(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addMonths(date, 1) AS add_months_with_date, addMonths(date_time, 1) AS add_months_with_date_time ``` ```Plain Text ┌─add_months_with_date─┬─add_months_with_date_time─┐ │ 2018-02-01 │ 2018-02-01 00:00:00 │ └──────────────────────┴───────────────────────────┘ ``` ### addQuarters 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。 **语法** ```SQL addQuarters(date, interval) addQuarters(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addQuarters(date, 1) AS add_quarters_with_date, addQuarters(date_time, 1) AS add_quarters_with_date_time ``` ```Plain Text ┌─add_quarters_with_date─┬─add_quarters_with_date_time─┐ │ 2018-04-01 │ 2018-04-01 00:00:00 │ └────────────────────────┴─────────────────────────────┘ ``` ### addSeconds 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。例如： **语法** ```SQL addSeconds(date, interval) addSeconds(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addSeconds(date, 1) AS add_seconds_with_date, addSeconds(date_time, 1) AS add_seconds_with_date_time ``` ```Plain Text ┌─add_seconds_with_date─┬─add_seconds_with_date_time─┐ │ 2018-01-01 00:00:01 │ 2018-01-01 00:00:01 │ └───────────────────────┴────────────────────────────┘ ``` ### addWeeks 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。 **语法** ```SQL addWeeks(date, interval) addWeeks(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addWeeks(date, 1) AS add_weeks_with_date, addWeeks(date_time, 1) AS add_weeks_with_date_time ``` ```Plain Text ┌─add_weeks_with_date─┬─add_weeks_with_date_time─┐ │ 2018-01-08 │ 2018-01-08 00:00:00 │ └─────────────────────┴──────────────────────────┘ ``` ### addYears 函数将日期/日期时间间隔添加到日期/日期时间，然后返回日期/日期时间。例如： **语法** ```SQL addYears(date, interval) addYears(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2018-01-01') AS date, toDateTime('2018-01-01 00:00:00') AS date_time SELECT addYears(date, 1) AS add_years_with_date, addYears(date_time, 1) AS add_years_with_date_time ``` ```Plain Text ┌─add_years_with_date─┬─add_years_with_date_time─┐ │ 2019-01-01 │ 2019-01-01 00:00:00 │ └─────────────────────┴──────────────────────────┘ ``` ### addTime :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `addtime` 返回添加指定时间后的时间，即返回 `expr1` 增加 `expr2` 后的结果。语法 ```SQL addtime(expr1, expr2) ``` **参数类型** * `expr1` 基础时间 * Date/Date32 * Datetime/Datetime64 * Time * String * `expr2` 增量时间 * Time * String **返回类型** * String **示例** **示例 1:** ```SQL SELECT addtime(DATE '2023-07-15', '02:30:30'); ``` ```Plain Text ┌─addtime(toDate('2023-07-15'), '02:30:30')─┐ │ 2023-07-15 02:30:30.000 │ └───────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT addtime(TIME '12:00:00', '02:30:30'); ``` ```Plain Text ┌─addtime(toTimeType('12:00:00'), '02:30:30')─┐ │ 14:30:30.000 │ └─────────────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT addtime(DATETIME '2023-07-15 14:00:00', '02:30:30'); ``` ```Plain Text ┌─addtime(toDateTime('2023-07-15 14:00:00'), '02:30:30')─┐ │ 2023-07-15 16:30:30.000 │ └────────────────────────────────────────────────────────┘ ``` **示例 4:** ```SQL SELECT addtime(TIMESTAMP '2023-07-15 14:00:00', Time'02:30:30'); ``` ```Plain Text ┌─addtime(toDateTime('2023-07-15 14:00:00'), '02:30:30')─┐ │ 2023-07-15 16:30:30.000 │ └────────────────────────────────────────────────────────┘ ``` **示例 5:** ```SQL SELECT addtime('2023-07-15 14:00:00', '02:30:30'); ``` ```Plain Text ┌─addtime('2023-07-15 14:00:00', '02:30:30')─┐ │ 2023-07-15 16:30:30.000 │ └────────────────────────────────────────────┘ ``` ### convert_tz :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `convert_tz` 函数用于将日期时间值从一个时区转换到另一个时区，并返回结果。 **语法** ```SQL convert_tz(expr, from_tz, to_tz) ``` **参数** * `expr` * 需要转换的时间日期值 * Datetime * `from_tz` * 日期时间值的原始时区。 * `to_tz` * 要转换到的目标时区。 **返回类型** * Datetime **示例** **示例 1:** ```SQL SELECT convert_tz('2023-06-15 09:30:00', '+00:00', '+08:00'); ``` ```Plain Text ┌─convert_tz('2023-06-15 09:30:00', '+00:00', '+08:00')─┐ │ 2023-06-15 17:30:00 │ └───────────────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT convert_tz('2023-12-25 18:45:00', 'UTC', 'CET'); ``` ```Plain Text ┌─convert_tz('2023-12-25 18:45:00', 'UTC', 'CET')─┐ │ 2023-12-25 19:45:00 │ └─────────────────────────────────────────────────┘ ``` ### curdate :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `curdate` 函数返回当前日期。同today() **语法** ```SQL curdate() ``` **返回类型** * Date **示例** ```SQL SELECT curdate(); ``` ```Plain Text ┌────today()─┐ │ 2024-07-25 │ └────────────┘ ``` ### curtime :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `curtime` 函数返回当前时间。 **语法** ```SQL curtime() ``` **返回类型** * Time **示例** ```SQL SELECT curtime(); ``` ```Plain Text ┌────CURTIME()─┐ │ 16:39:50.844 │ └──────────────┘ ``` ### date :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `date` 返回日期或日期时间表达式中的日期。 **语法** ```SQL DATE(expr) ``` **参数类型** * `expr` * Date/Date32 * Datetime/Datetime64 * String **返回类型** * Date **示例** **示例 1:** ```SQL SELECT DATE('2023-06-15 08:45:30'::Datetime); ``` ```Plain Text ┌─DATE(CAST('2023-06-15 08:45:30', 'Datetime'))─┐ │ 2023-06-15 │ └───────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT DATE('2023-06-15 08:45:30'::Date); ``` ```Plain Text ┌─DATE(CAST('2023-06-15 08:45:30', 'Date'))─┐ │ 2023-06-15 │ └───────────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT DATE('2023-06-15 08:45:30'); ``` ```Plain Text ┌─DATE('2023-06-15 08:45:30')─┐ │ 2023-06-15 │ └─────────────────────────────┘ ``` ### dateDiff 返回两个日期或具有时间值的日期之间的差值。 **语法** ```SQL dateDiff('unit', startdate, enddate, [timezone]) ``` **参数** * `unit`— 结果区间的类型。字符串。可能的值： * second * minute * hour * day * week * month * quarter * year * `startdate`— 要减去的第一个时间值（减数）。日期或日期时间。 * `enddate`— 要减去的第二个时间值（被减数）。日期或日期时间。 * `timezone`— 时区名称（可选）。如果指定，则同时应用于开始日期和结束日期。如果未指定，则使用开始日期和结束日期的时区。如果它们不相同，则结果未指定。字符串。 **示例** ```SQL SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')); ``` ```Plain Text ┌─dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'))─┐ │ 25 │ └────────────────────────────────────────────────────────────────────────────────────────┘ ``` ### date_format :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: 同formatDateTime() ### date_add 将时间间隔或日期间隔添加到提供的日期或时间日期。 **语法** ```SQL date_add(date, value) date_add(datetime, value [,timezone]) ``` **参数** * `datevalue`—添加时间的日期或日期。日期或日期时间。 * `timezone`仅当第一个参数为 DateTime 类型时才允许使用时区参数 **返回值** 通过添加获得的日期或带有时间的日期`value`。类型：日期或日期时间。 **示例** ```SQL SELECT date_add(toDate('2018-01-01'),3); ``` ```Plain Text ┌─date_add(toDate('2018-01-01'), 3)─┐ │ 2018-01-04 │ └───────────────────────────────────┘ ``` ```SQL SELECT date_add(toDateTime('2018-01-01 00:00:00'), 3, 'UTC'); ``` ```Plain Text ┌─date_add(toDateTime('2018-01-01 00:00:00'), 3, 'UTC')─┐ │ 2018-01-03 16:00:00 │ └───────────────────────────────────────────────────────┘ ``` ### date_sub 从提供的日期或时间日期中减去时间间隔或日期间隔。 **语法** ```SQL date_sub(date, value) date_sub(datetime, value [,timezone]) ``` **参数** * `datevalue`—添加时间的日期或日期。日期或日期时间。 * `timezone`仅当第一个参数为 DateTime 类型时才允许使用时区参数 **返回值** 通过减去得到的日期或时间日期`value`。类型：日期或日期时间。 **示例** ```SQL SELECT date_sub(toDate('2018-01-01'),3); ``` ```Plain Text ┌─date_sub(toDate('2018-01-01'), 3)─┐ │ 2017-12-29 │ └───────────────────────────────────┘ ``` ```SQL SELECT date_sub(toDateTime('2018-01-01 00:00:00'), 3, 'UTC'); ``` ```Plain Text ┌─date_sub(toDateTime('2018-01-01 00:00:00'), 3, 'UTC')─┐ │ 2017-12-28 16:00:00 │ └───────────────────────────────────────────────────────┘ ``` ### dateTrunc 将日期和时间值截断到指定的日期部分。 **语法** ```SQL dateTrunc(unit, datetime[, timezone]) ``` **别名**：`DATE_TRUNC` **参数** * `unit` — 截断结果的间隔类型。`unit` 参数不区分大小写。String 类型。不同 `unit` 的兼容性说明如下： | | | \ |单位 |兼容性 | |---|---| | | | \ |`nanosecond` |仅与 DateTime64 兼容 | | | | \ |`microsecond` |仅与 DateTime64 兼容 | | | | \ |`millisecond` |仅与 DateTime64 兼容 | | | | \ |`second` |兼容 DateTime64，DateTime | | | | \ |`minute` |兼容 DateTime64，DateTime | | | | \ |`hour` |兼容 DateTime64，DateTime | | | | \ |`day` |兼容 DateTime64，DateTime，Date | | | | \ |`week` |兼容 DateTime64，DateTime，Date | | | | \ |`month` |兼容 DateTime64，DateTime，Date | | | | \ |`quarter` |兼容 DateTime64，DateTime，Date | | | | \ |`year` |兼容 DateTime64，DateTime，Date | * `datetime` — 日期和时间。`Date` 或 `Date32` 或 `DateTime` 或 `DateTime64` 类型。 * `timezone` — 可选，返回 datetime 的时区名称。如果未指定，函数将使用 `datetime` 参数的时区。 `String` 类型。 **返回值** 返回截断后的日期和时间值。 | | | | \ |单位参数 |`datetime` 参数 |返回类型 | |---|---|---| | | | | \ |年、季度、月、周 |`Date32` 或 `DateTime64` 或 `Date` 或 `DateTime` |`Date32` 或 `Date` | | | | | \ |天、小时、分钟、秒 |`Date32`、`DateTime64`、`Date`或`DateTime` |`DateTime64` 或 `DateTime` | | | | | \ |毫秒、微秒 |任何 |`DateTime64` | | | | | \ |纳秒 |无 |精度为 3、6 或 9 | **示例** **无时区截断** 查询： ```SQL SELECT now(), dateTrunc('hour', now()); ``` 输出结果： ```SQL ┌───────────────now()─┬─dateTrunc('hour', now())──┐ │ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │ └─────────────────────┴───────────────────────────┘ ``` **带指定时区的截断** 查询： ```SQL SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul'); ``` 输出结果： ```SQL ┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐ │ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │ └─────────────────────┴────────────────────────────────────────────┘ ``` ### ### day/dayOfMonth 返回日期中的日。 **语法** ```SQL DAY(expr) DAYOFMONTH(expr) ``` **参数类型** * `expr` * Date/Date32 * Datetime/Datetime64 * Time * String **返回类型** * `UInt8` **示例** **示例 1:** ```SQL SELECT DAYOFMONTH('2022-01-22 12:23:09'); ``` ```Plain Text ┌─DAYOFMONTH('2022-01-22 12:23:09')─┐ │ 22 │ └───────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT DAYOFMONTH(TIME '17:01:10'); ``` ```SQL -- use current date ┌─DAYOFMONTH(toTimeType('17:01:10'))─┐ │ 25 │ └────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT DAY('2022-01-22'); ``` ```Plain Text ┌─DAY('2022-01-22')─┐ │ 22 │ └───────────────────┘ ``` ### **dayname** :::tip **MySQL兼容语法，推荐在相关方言下使用** ::: `dayname` 返回日期对应的星期几的名称。 **语法** ```SQL dayname(expr) ``` **参数类型** * `expr` * Datetime/Datetime64 * Date/Date32 * String **返回类型** * String **示例** **示例 1:** ```SQL SELECT dayname(DATETIME '2023-04-21 03:01:00'); ``` ```Plain Text ┌─dayname(toDateTime('2023-04-21 03:01:00'))─┐ │ Friday │ └────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT dayname('2023-04-21 03:01:00'); ``` ```Plain Text ┌─dayname('2023-04-21 03:01:00')─┐ │ Friday │ └────────────────────────────────┘ ``` ### **dayOfWeek** :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `dayofweek` 返回日期对应的星期几索引值，星期日为1，作为起始。 **语法** ```SQL dayofweek(expr) ``` 参数类型 * `expr` * Datetime/Datetime64 * Date/Date32 * String **返回类型** * UInt8 **示例** **示例 1:** ```SQL SELECT dayofweek(DATETIME '2024-04-10 20:30:00'); ``` ```Plain Text ┌─DAYOFWEEK(toDateTime('2024-04-10 20:30:00'))─┐ │ 4 │ └──────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT dayofweek(DATE '2022-01-30'); ``` ```Plain Text ┌─DAYOFWEEK(toDate('2024-01-30'))─┐ │ 3 │ └─────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT dayofweek('2024-10-21'); ``` ```Plain Text ┌─DAYOFWEEK('2024-10-21')─┐ │ 2 │ └─────────────────────────┘ ``` **dayOfYear** :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `dayofyear` 返回指定日期在当年的天数，范围为 [1, 366]。 **语法** ```SQL dayofyear(expr) ``` **参数类型** * `expr` * Datetime/Datetime64 * Date/Date32 * String **返回类型** * UInt64 **示例** **示例 1:** ```SQL SELECT dayofyear(DATETIME '2024-07-21 13:13:13'); ``` ```Plain Text ┌─DAYOFYEAR(toDateTime('2024-07-21 13:13:13'))─┐ │ 203 │ └──────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT dayofyear('2024-07-21'); ``` ```Plain Text ┌─DAYOFYEAR('2024-07-21')─┐ │ 203 │ └─────────────────────────┘ ``` ### extract :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `extract` 返回日期或时间的单独部分，由 `unit` 指定，比如年、月、日、小时、分钟等。 **语法** ```SQL extract(unit FROM date) ``` **参数类型** * `unit` * 时间单位 * `unit` 可取值为：second、minute、hour、day、month、year、minute_second、hour_second、hour_minute、day_second、day_minute、day_hour、year_month。 * `date` * 要提取部分的日期或时间表达式 * Date/Date32/Datetime/Datetime64/Time * String **返回类型** * Int64 **示例** **示例 1:** ```SQL SELECT extract(second FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 14 │ └────────┘ ``` **示例 2:** ```SQL SELECT extract(minute FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 13 │ └────────┘ ``` **示例 3:** ```SQL SELECT extract(hour FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 12 │ └────────┘ ``` **示例 4:** ```SQL SELECT extract(day FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 21 │ └────────┘ ``` **示例 5:** ```SQL SELECT extract(month FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 7 │ └────────┘ ``` **示例 6:** ```SQL SELECT extract(year FROM timestamp '2024-07-21') as result; ``` ```Plain Text ┌─result─┐ │ 2024 │ └────────┘ ``` **示例 7:** ```SQL SELECT extract(year FROM datetime '2024-07-21') as result; ``` ```Plain Text ┌─result─┐ │ 2024 │ └────────┘ ``` **示例 8:** ```SQL SELECT extract(year FROM time '12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 2024 │ └────────┘ ``` **示例 9:** ```SQL SELECT extract(minute_second FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 1314 │ └────────┘ ``` **示例 10:** ```SQL SELECT extract(hour_second FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 121314 │ └────────┘ ``` **示例 11:** ```SQL SELECT extract(hour_minute FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 1213 │ └────────┘ ``` **示例 12:** ```SQL SELECT extract(day_second FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌───result─┐ │ 21121314 │ └──────────┘ ``` **示例 13:** ```SQL sql Copy code SELECT extract(day_minute FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 211213 │ └────────┘ ``` **示例 14:** ```SQL SELECT extract(day_hour FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 2112 │ └────────┘ ``` **示示例 15:** ```SQL SELECT extract(year_month FROM '2024-07-21 12:13:14') as result; ``` ```Plain Text ┌─result─┐ │ 202407 │ └────────┘ ``` ### from_days :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `from_days` 根据指定的天数 expr，返回对应的Date值。 **语法** ```SQL expr ``` **参数类型** * `expr` * String * UInt/Int **返回类型** * DATE **示例** **示例 1:** ```SQL SELECT from_days(739453); ``` ```Plain Text ┌─from_days(739453)─┐ │ 2024-07-21 │ └───────────────────┘ ``` **示例 2:** ```SQL SELECT from_days('739453'); ``` ```Plain Text ┌─from_days(739453)─┐ │ 2024-07-21 │ └───────────────────┘ ``` **from_unixtime** :::tip MySQL兼容语法，推荐在相关方言下使用。 ::: `from_unixtime` 根据 Unix 时间戳，返回符合指定格式的值。格式遵从 `date_format` 函数中的格式。 **语法** ```SQL from_unixtime(expr[, format]) ``` **参数类型** * `expr` * String * UInt/Int * Float/Double * `format` * String **返回类型** * String **示例** **示例 1:** ```SQL SELECT from_unixtime('1704733565', '%Y %M %h:%i:%s'); ``` ```Plain Text ┌─FROM_UNIXTIME('1704733565', '%Y %M %h:%i:%s')─┐ │ 2024 January 01:06:05 │ └───────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT from_unixtime(1704733565); ``` ```Plain Text ┌─FROM_UNIXTIME(1704733565)─┐ │ 2024-01-09 01:06:05 │ └───────────────────────────┘ ``` ### formatDateTime 根据给定的格式字符串格式化时间。格式是一个常量表达式，因此单个结果列不能有多种格式。 **语法** ```SQL formatDateTime(Time, Format\[, Timezone\]) ``` **参数** * `Time`日期/日期时间 * `Format`格式模式 **替换字段** 使用替换字段，您可以为结果字符串定义一个模式。“示例”列显示了的格式化结果`2018-01-02 22:33:44`。 | | | | \ |**占位符** |**描述** |**示例** | |---|---|---| | | | | \ |%C |year divided by 100 and truncated to integer (00-99) |\ | |年份除以 100 并截断为整数 (00-99) |20 | | | | | \ |%d |day of the month, zero-padded (01-31) |\ | |月份中的某一天，以零填充（01-31） |02 | | | | | \ |%D |Short MM/DD/YY date, equivalent to %m/%d/%y |\ | |简短的 MM/DD/YY 日期，相当于 %m/%d/%y |01/02/18 | | | | | \ |%e |day of the month, space-padded ( 1-31) |\ | |月份中的日期，以空格填充（1-31） |2 | | | | | \ |%F |short YYYY-MM-DD date, equivalent to %Y-%m-%d |\ | |短日期 YYYY-MM-DD，相当于 %Y-%m-%d |2018-01-02 | | | | | \ |%H |hour in 24h format (00-23) |\ | |24 小时格式的小时（00-23） |22 | | | | | \ |%I |hour in 12h format (01-12) |\ | |12 小时格式的小时（01-12） |10 | | | | | \ |%j |day of the year (001-366) |\ | |一年中的某一天 (001-366) |002 | | | | | \ |%m |month as a decimal number (01-12) |\ | |十进制数形式的月份 (01-12) |01 | | | | | \ |%M |minute (00-59) |\ | |分钟 (00-59) |33 | | | || \ |%n |new-line character (‘’) |\ | |换行符 ('') | | | | | | \ |%p |AM or PM designation |\ | |AM 或 PM 指定 |PM | | | | | \ |%R |24-hour HH:MMtime, equivalent to %H:%M |\ | |24 小时制 HH:MM 时间，相当于 %H:%M |22:33 | | | | | \ |%S |second (00-59) |\ | |秒 (00-59) |44 |\ | | | | | | || \ |%t |\ | |horizontal-tab character (’) |\ | |水平制表符 (') | | | | | | \ |%T |ISO8601 time format (HH:MM:SS), equivalent to %H:%M:%S |\ | |ISO8601 时间格式 (HH:MM:SS)，相当于 %H:%M:%S |22:33:44 | | | | | \ |%u |ISO8601 weekday as number with Monday as 1 (1-7) |\ | |ISO8601 星期几为数字，星期一为 1（1-7） |2 | | | | | \ |%V |ISO8601 week number (01-53) |\ | |ISO8601 周数（01-53） |01 | | | | | \ |%w |weekday as a decimal number with Sunday as 0 (0-6) |\ | |以十进制数表示星期几，星期日为 0（0-6） |2 | | | | | \ |%y |Year, last two digits (00-99) |\ | |年份，最后两位数字（00-99） |18 | | | | | \ |%Y |Year |\ | |年 |2018 | | | | | \ |%% |a % sign |% | **返回值** 根据确定的格式返回时间和日期值。 **示例** ```SQL SELECT formatDateTime(toDate('2010-01-04'), '%d'); ``` ```SQL ┌─formatDateTime(toDate('2010-01-04'), '%d')─┐ │ 04 │ └────────────────────────────────────────────┘ --from_unixtime --函数将 Unix 时间戳转换为日历日期和一天中的时间。当只有一个 Integer 类型的参数时，其作用与 toDateTime 相同并返回 DateTime 类型。- --示例 SELECT FROM_UNIXTIME(423543535); ``` ```Plain Text ┌─FROM_UNIXTIME(423543535)─┐ │ 1983-06-04 10:58:55 │ └──────────────────────────┘ ``` 当有两个参数时：第一个是 Integer 或 DateTime，第二个是常量格式字符串 — — 它的行为与 formatDateTime 相同并返回 String 类型。例如： ```SQL SELECT FROM_UNIXTIME(1234334543, '%Y-%m-%d %R:%S') AS DateTime; ``` ```Plain Text ┌─DateTime────────────┐ │ 2009-02-11 14:42:23 │ └─────────────────────┘ ``` ### hour 返回日期时间中的小时，同toHour()。 ### last_day :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `last_day` 返回日期或日期时间中对应月份的最后一天。 **语法** ```SQL last_day(expr) ``` **参数类型** * `expr` * Datetime/Datetime64 * Date/Date32 * String **返回类型** * Date **示例** **示例 1:** ```SQL SELECT last_day('2024-07-21'); ``` ```Plain Text ┌─toLastDayOfMonth('2024-07-21')─┐ │ 2024-07-31 │ └────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT last_day(DATETIME '2024-07-21 10:00:00'); ``` ```Plain Text ┌─toLastDayOfMonth(toDateTime('2024-07-21 10:00:00'))─┐ │ 2024-07-31 │ └─────────────────────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT last_day('2024-07-21 10:00:00'); ``` ```Plain Text ┌─toLastDayOfMonth('2024-07-21 10:00:00')─┐ │ 2024-07-31 │ └─────────────────────────────────────────┘ ``` ### localtime/localtimestamp 返回当前日期和时间，同now()。 ### makedate :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `makedate` 根据参数 `year` 和 `dayofyear` 返回一个日期。 **语法** ```SQL makedate(year, dayofyear) ``` **参数类型** * `year` * UInt * String * `dayofyear` * UInt * String **返回类型** * Date **示例** **示例 1:** ```SQL SELECT makedate(2024, 202), makedate(2024, 203); ``` ```Plain Text ┌─makeDate(2024, 202)─┬─makeDate(2024, 203)─┐ │ 2024-07-20 │ 2024-07-21 │ └─────────────────────┴─────────────────────┘ ``` **示例 2:** ```SQL SELECT makedate('2024', '202'), makedate('2024', '203'); ``` ```Plain Text ┌─makeDate('2024', '202')─┬─makeDate('2024', '203')─┐ │ 2024-07-20 │ 2024-07-21 │ └─────────────────────────┴─────────────────────────┘ ``` ### maketime :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `maketime` 根据参数 `hour`、`minute` 和 `second` 返回一个时间。 **语法** ```SQL maketime(hour, minute, second) ``` **参数类型** * `hour` * UInt * String * `minute` * UInt * String * `second` * UInt * String **返回类型** * Time **示例** **示例 1:** ```SQL SELECT maketime(07, 21, 10); ``` ```Plain Text ┌─makeTime(7, 21, 10)─┐ │ 07:21:10.000 │ └─────────────────────┘ ``` **示例 2:** ```SQL SELECT maketime('07', '21', '30'); ``` ```Plain Text ┌─makeTime('07', '21', '30')─┐ │ 07:21:30.000 │ └────────────────────────────┘ ``` ### minute 返回日期时间中的分钟，同toMinute()。 ### month 返回日期时间中的月份，同toMonth()。 ### monthname :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `monthname` 返回日期中月份的英文全称。 **语法** ```SQL monthname(date) ``` **参数类型** * `date` * Datetime/Datetime64 * Date/Date32 * String **返回类型** * String **示例** **示例 1:** ```SQL SELECT monthname(DATETIME '2024-07-21 00:00:00'); ``` ```Plain Text ┌─monthName(toDateTime('2024-07-21 00:00:00'))─┐ │ July │ └──────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT monthname(DATE'2024-07-21'); ``` ```Plain Text ┌─monthName(toDate('2024-07-21'))─┐ │ July │ └─────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT monthname('2024-07-21'); ``` ```Plain Text ┌─monthName('2024-07-21')─┐ │ July │ └─────────────────────────┘ ``` ### now 返回当前日期和时间。 **语法** ```SQL now() ``` **返回值** * 当前日期和时间。类型：日期时间。 **示例** ```SQL SELECT now(); ``` ```Plain Text ┌─now()───────────────┐ │ 2021-08-11 14:35:47 │ └─────────────────────┘ ``` ### period_add :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `period_add` 将日期格式的expr1向后推expr2个月。 **语法** ```SQL period_add(expr1, expr2) ``` **参数类型** * `expr1` * UInt * String * `expr2` * UInt * String **返回类型** * UInt **示例** **示例 1:** ```SQL SELECT period_add(202401, 6); ``` ```Plain Text ┌─period_add(202401, 6)─┐ │ 202407 │ └───────────────────────┘ ``` **示例 2:** ```SQL SELECT period_add('202401', '6'); ``` ```Plain Text ┌─period_add('202401', '6')─┐ │ 202407 │ └───────────────────────────┘ ``` ### period_diff `period_diff` 计算 expr1 和 expr2 之间的月份差。 :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: **语法** ```SQL period_diff(expr1, expr2) ``` **参数类型** * `expr1` * UInt * String * `expr2` * UInt * String **返回类型** * UInt **示例** **示例 1:** ```SQL SELECT period_diff(202407, 202301); ``` ```Plain Text ┌─period_diff(202407, 202301)─┐ │ 18 │ └─────────────────────────────┘ ``` **示例 2:** ```SQL SELECT period_diff('202407', '202301'); ``` ```Plain Text ┌─period_diff('202407', '202301')─┐ │ 18 │ └─────────────────────────────────┘ ``` ### quarter 返回日期时间中对应的季度，同toQuarter()。 ### sec_to_time :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `sec_to_time` 将秒数转换为时间格式。 **语法** ```SQL sec_to_time(seconds) ``` **参数类型** * `seconds` * UInt/Int * String **返回类型** * Time **示例** **示例 1:** ```SQL SELECT sec_to_time(7321); ``` ```Plain Text ┌─sec_to_time(7321)─┐ │ 02:02:01.000 │ └───────────────────┘ ``` **示例 2:** ```SQL SELECT sec_to_time('7321'); ``` ```Plain Text ┌─sec_to_time('7321')─┐ │ 02:02:01.000 │ └─────────────────────┘ ``` ### second 返回日期时间中的秒，同toSecond()。 ### str_to_date :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `str_to_date` 将字符串按照指定的日期或时间格式转换为日期或日期时间类型。格式遵从 `date_format` 函数中的格式。 **语法** ```SQL str_to_date(str, format) ``` **参数类型** * `str` * 需要转换的 string * String * `format` * 格式 * String **返回类型** * Datetime **示例** **示例 1:** ```SQL SELECT str_to_date('2024-07-21 12:13:14', '%Y-%m-%d %H:%i:%s') AS result; ``` ```Plain Text ┌─────────────────────result─┐ │ 2024-07-21 12:13:14.000000 │ └────────────────────────────┘ ``` ### subtractDays 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractDays(date, interval) subtractDays(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractDays(date, 1) AS subtract_days_with_date, subtractDays(date_time, 1) AS subtract_days_with_date_time ``` ```Plain Text ┌─subtract_days_with_date─┬─subtract_days_with_date_time─┐ │ 2018-12-31 │ 2018-12-31 00:00:00 │ └─────────────────────────┴──────────────────────────────┘ ``` ### subtractHours 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractHours(date, interval) subtractHours(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractHours(date, 1) AS subtract_hours_with_date, subtractHours(date_time, 1) AS subtract_hours_with_date_time ``` ```Plain Text ┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┐ │ 2002-11-25 │ 2018-12-31 23:00:00 │ └──────────────────────────┴───────────────────────────────┘ ``` ### subtractMinutes 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractMinutes(date, interval) subtractMinutes(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractMinutes(date, 1) AS subtract_minutes_with_date, subtractMinutes(date_time, 1) AS subtract_minutes_with_date_time ``` ```Plain Text ┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┐ │ 2012-08-04 │ 2018-12-31 23:59:00 │ └────────────────────────────┴─────────────────────────────────┘ ``` ### subtractMonths 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractMonths(date, interval) subtractMonths(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractMonths(date, 1) AS subtract_months_with_date, subtractMonths(date_time, 1) AS subtract_months_with_date_time ``` ```Plain Text ┌─subtract_months_with_date─┬─subtract_months_with_date_time─┐ │ 2018-12-01 │ 2018-12-01 00:00:00 │ └───────────────────────────┴────────────────────────────────┘ ``` ### subtractQuarters 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractQuarters(date, interval) subtractQuarters(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractQuarters(date, 1) AS subtract_quarters_with_date, subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time ``` ```Plain Text ┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┐ │ 2018-10-01 │ 2018-10-01 00:00:00 │ └─────────────────────────────┴──────────────────────────────────┘ ``` ### subtractSeconds 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractSeconds(date, interval) subtractSeconds(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractSeconds(date, 1) AS subtract_seconds_with_date, subtractSeconds(date_time, 1) AS subtract_seconds_with_date_time ``` ```Plain Text ┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┐ │ 2012-10-02 │ 2018-12-31 23:59:59 │ └────────────────────────────┴─────────────────────────────────┘ ``` ### subtractWeeks 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractWeeks(date, interval) subtractWeeks(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractWeeks(date, 1) AS subtract_weeks_with_date, subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time ``` ```Plain Text ┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┐ │ 2018-12-25 │ 2018-12-25 00:00:00 │ └──────────────────────────┴───────────────────────────────┘ ``` ### subtractYears 函数将日期/日期时间减去日期/日期时间间隔，然后返回日期/日期时间。 **语法** ```SQL subtractYears(date, interval) subtractYears(datetime, interval) ``` **参数** * `date/datetime`日期/日期时间 * `interval`日期/日期时间 **返回值** * 日期/日期时间 **示例** ```SQL WITH toDate('2019-01-01') AS date, toDateTime('2019-01-01 00:00:00') AS date_time SELECT subtractYears(date, 1) AS subtract_years_with_date, subtractYears(date_time, 1) AS subtract_years_with_date_time ``` ```Plain Text ┌─subtract_years_with_date─┬─subtract_years_with_date_time─┐ │ 2018-01-01 │ 2018-01-01 00:00:00 │ └──────────────────────────┴───────────────────────────────┘ ``` ### subtime :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `subtime` 返回 `expr1` 减去 `expr2` 后的时间。 **语法** ```SQL subtime(expr1, expr2) ``` **参数类型** * `expr1` * 需要被减去时间的表达式 * Datetime * `expr2` * 要减去的时间 * String **返回类型** * Datetime **示例** **示例 1:** ```SQL SELECT subtime(date '2024-07-21', '0:1:1'); ``` ```Plain Text ┌─subtime(toDate('2024-07-21'), '0:1:1')─┐ │ 2024-07-20 23:58:59.000 │ └────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT subtime(datetime '2024-07-21 12:13:14', '0:1:1'); ``` ```Plain Text ┌─subtime(toDateTime('2024-07-21 12:13:14'), '0:1:1')─┐ │ 2024-07-21 12:12:13.000 │ └─────────────────────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT subtime(time '12:13:14', '0:1:1'); ``` ```Plain Text ┌─subtime(toTimeType('12:13:14'), '0:1:1')─┐ │ 12:12:13.000 │ └──────────────────────────────────────────┘ ``` **示例 4:** ```SQL SELECT subtime('2024-07-21 12:13:14', '0:1:1'); ``` ```Plain Text ┌─subtime('2024-07-21 12:13:14', '0:1:1')─┐ │ 2024-07-21 12:12:13.000 │ └─────────────────────────────────────────┘ ``` ### sysdate 返回当前系统时间，同now()。 ### time :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: 返回 `expr` 中的时间。 **语法** ```SQL time(expr[, scale]) ``` **参数类型** * `expr` * 表示要提取时间的表达式 * String * Datetime/Datetime64 * `scale` * 表示目标时间的小数精度 * UInt8 **返回类型** * Time **示例** **示例 1:** ```SQL SELECT time('2024-07-21 12:13:14'); ``` ```Plain Text ┌─TIME('2024-07-21 12:13:14')─┐ │ 12:13:14.000 │ └─────────────────────────────┘ ``` **示例 2:** ```SQL SELECT time('2024-07-21 12:13:14', 0); ``` ```Plain Text ┌─TIME('2024-07-21 12:13:14', 0)─┐ │ 12:13:14 │ └────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT time(Datetime64'2024-07-21 12:13:14.123456', 3); ``` ```Plain Text ┌─TIME(toDateTime64('2024-07-21 12:13:14.123456'), 3)─┐ │ 12:13:14.123 │ └─────────────────────────────────────────────────────┘ ``` ### timeDiff :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: 返回两个输入的时间差，同subtime()。 ### timestamp :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `timestamp` 返回 `expr` 表示的日期或日期时间。 **语法** ```SQL timestamp(expr) ``` **参数类型** * `expr` * 要转换为时间戳的表达式 * Date/Date32 * String **返回类型** * Datetime **示例** **示例 1:** ```SQL SELECT timestamp(date '2024-07-21'); ``` ```Plain Text ┌─timestamp(toDate('2024-07-21'))─┐ │ 2024-07-21 00:00:00.000000 │ └─────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT timestamp('2024-07-21'); ``` ```Plain Text ┌────timestamp('2024-07-21')─┐ │ 2024-07-21 00:00:00.000000 │ └────────────────────────────┘ ``` ### timestampAdd :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `timestampadd` 将 `interval` 添加到日期或日期时间表达式 `datetime_expr` 中。`interval` 的单位由 `unit` 规定。`unit` 的可取值为：`second`、`minute`、`hour`、`day`、`week`、`month`、`quarter`、`year`。 **语法** ```SQL timestampadd(unit, interval, datetime_expr) ``` **参数类型** * `unit` * 时间单位 * `interval` * 时间间隔 * String * UInt64 * `datetime_expr` * 日期或日期时间表达式 * String * Date/Date32/Datetime/Datetime64/Time **返回类型** * Datetime **示例** **示例 1:** ```SQL SELECT timestampadd(second, '1', datetime '2024-07-21 12:13:14') AS result; ``` ```Plain Text ┌──────────────result─┐ │ 2024-07-21 12:13:15 │ └─────────────────────┘ ``` **示例 2:** ```SQL SELECT timestampadd(second, '1', date '2024-07-21') AS result; ``` ```SQL ┌──────────────result─┐ │ 2024-07-21 00:00:01 │ └─────────────────────┘ ``` ### timestampDiff :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `timestampdiff` 返回日期或日期时间表达式 `datetime_expr2` 减去 `datetime_expr1` 后的结果，结果的单位由 `unit` 指定。`unit` 的可取值为：second、minute、hour、day、week、month、quarter 或 year。 **语法** ```SQL timestampdiff(unit, datetime_expr1, datetime_expr2) ``` **参数类型** * `unit` * 时间单位 * String * `datetime_expr1` * 要计算的起始日期或日期时间表达式 * Date/Date32/Datetime/Datetime64 * `datetime_expr2` * 要计算的结束日期或日期时间表达式 * Date/Date32/Datetime/Datetime64 * String **返回类型** * Int64 **示例** **示例 1:** ```SQL SELECT timestampdiff(second, datetime '2024-07-21 10:12:13', datetime '2024-07-21 12:13:14') AS result; ``` ```Plain Text ┌─result─┐ │ 7261 │ └────────┘ ``` **示例 2:** ```SQL SELECT timestampdiff(minute, '2024-07-21 10:12:13', '2024-07-21 12:13:14'); ``` ```Plain Text ┌─timestampdiff('minute', '2024-07-21 10:12:13', '2024-07-21 12:13:14')─┐ │ 121 │ └───────────────────────────────────────────────────────────────────────┘ ``` ### timeSlot 将时间四舍五入到半小时。此功能是 Yandex.Metrica 特有的，因为如果跟踪标签显示单个用户的连续页面浏览量在时间上相差严格超过半小时，则半小时是将会话分为两个会话的最短时间。这意味着可以使用三元组（标签 ID、用户 ID 和时间段）来搜索相应会话中包含的页面浏览量。 **语法** ```SQL timeSlot(datetime) ``` **参数** * `datetime` **返回值** * `DateTime` **示例** ```SQL SELECT timeSlot(toDateTime('2018-01-01 01:01:01')) ``` ```Plain Text ┌─timeSlot(toDateTime('2018-01-01 01:01:01'))─┐ │ 2018-01-01 01:00:00 │ └─────────────────────────────────────────────┘ ``` ### timeSlots 对于从“StartTime”开始并持续“Duration”秒的时间间隔，它将返回一个时间点数组，该数组由该间隔中的点组成，四舍五入为“Size”（以秒为单位）。“Size”是一个可选参数：一个常量 UInt32，默认设置为 1800。这对于在相应会话中搜索页面浏览量是必要的。 **语法** ```SQL timeSlots(StartTime, Duration,[, Size]) ``` **参数** * `StartTime`：开始时间 * `Duration`：持续时间（以秒为单位），UInt32 * `Size`：间隔的大小。 **返回值** * 时间段数组。 **示例** ```SQL SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600)) ``` ```Plain Text ┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐ │ [2012-01-01 12:00:00, 2012-01-01 12:30:00] │ └─────────────────────────────────────────────────────────────┘ ``` 到本月的哪天将日期或时间日期转换为包含月份天数的 UInt8 数字（1-31）。 **语法** ```SQL toDayOfMonth(date) toDayOfMonth(datetime) sql ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 月份中的某一天。UInt8 **示例** ```SQL SELECT toDayOfMonth(toDate('2021-08-12')) sql ``` ```Plain Text ┌─toDayOfMonth(toDate('2021-08-12'))─┐ │ 12 │ └────────────────────────────────────┘ ``` ```SQL SELECT toDayOfMonth(toDateTime('2021-08-12 00:00:00')) sql ``` ```Plain Text ┌─toDayOfMonth(toDateTime('2021-08-12 00:00:00'))─┐ │ 12 │ └─────────────────────────────────────────────────┘ ``` ### time_format :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `time_format` 按照 `format` 指定的格式，以字符串格式显示时间 `time`。`format` 遵从 `date_format` 函数中的格式。 **语法** ```SQL time_format(time, format) ``` **参数类型** * `time` * 要格式化的时间 * String * Date/Date32/Datetime/Datetime64/Time * `format` * 格式 * String **返回类型** * String **示例** **示例 1:** ```SQL SELECT time_format('12:00:00', '%H %k %h %I %l'); ``` ```Plain Text ┌─TIME_FORMAT('12:00:00', '%H %k %h %I %l')─┐ │ 12 12 12 12 12 │ └───────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT time_format(datetime '2024-07-21 23:00:00', '%H %k %h %I %l') AS result; ``` ```Plain Text ┌─result─────────┐ │ 23 23 11 11 11 │ └────────────────┘ ``` **示例 3:** ```SQL SELECT time_format(time '23:00:00', '%H %k %h %I %l'); ``` ```Plain Text ┌─TIME_FORMAT(toTimeType('23:00:00'), '%H %k %h %I %l')─┐ │ 23 23 11 11 11 │ └───────────────────────────────────────────────────────┘ ``` **示例 4:** ```SQL SELECT time_format(date '2024-07-21', '%H %k %h %I %l'); ``` ```Plain Text ┌─TIME_FORMAT(toDate('2024-07-21'), '%H %k %h %I %l')─┐ │ 00 00 12 12 12 │ └─────────────────────────────────────────────────────┘ ``` ### time_to_sec :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `time_to_sec` 返回 `time` 转换为秒的结果。 **语法** ```SQL time_to_sec(time) ``` **参数类型** * `time` * 要转换为秒的时间 * String * Date/Date32/Datetime/Datetime64/Time **返回类型** * UInt64 **示例** **示例 1:** ```SQL SELECT time_to_sec(datetime '2024-07-21 22:23:00'); ``` ```Plain Text ┌─time_to_sec(toDateTime('2024-07-21 22:23:00'))─┐ │ 80580 │ └────────────────────────────────────────────────┘ ``` **示例 2:** ```SQL sql Copy code SELECT time_to_sec(date '2024-07-21'); ``` ```Plain Text ┌─time_to_sec(toDate('2024-07-21'))─┐ │ 0 │ └───────────────────────────────────┘ ``` **示例 4:** ```SQL SELECT time_to_sec(time '12:12:12'); ``` ```Plain Text ┌─time_to_sec(toTimeType('12:12:12'))─┐ │ 43932 │ └─────────────────────────────────────┘ ``` **示例 5:** ```SQL SELECT time_to_sec('22:23:00'); ``` ```Plain Text ┌─time_to_sec('22:23:00')─┐ │ 80580 │ └─────────────────────────┘ ``` ### toDayOfWeek :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: 将日期或时间日期转换为包含星期几的 UInt8 数字（星期一为 1，星期日为 7）。 **语法** ```SQL toDayOfWeek(date) toDayOfWeek(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 星期几。UInt8 **示例** ```SQL SELECT toDayOfWeek(toDate('2021-08-12')) ``` ```Plain Text ┌─toDayOfWeek(toDate('2021-08-12'))─┐ │ 4 │ └───────────────────────────────────┘ ``` ```SQL SELECT toDayOfWeek(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toDayOfWeek(toDateTime('2021-08-12 00:00:00'))─┐ │ 4 │ └────────────────────────────────────────────────┘ ``` ### toDayOfYear :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: 将日期或时间日期转换为包含一年中天数的 UInt16 数字（1-366）。 **语法** ```SQL toDayOfYear(date) toDayOfYear(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 一年中的某一天。UInt8 **示例** ```SQL SELECT toDayOfWeek(toDate('2021-08-12')) ``` ```Plain Text ┌─toDayOfWeek(toDate('2021-08-12'))─┐ │ 4 │ └───────────────────────────────────┘ ``` ```SQL SELECT toDayOfWeek(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toDayOfWeek(toDateTime('2021-08-12 00:00:00'))─┐ │ 4 │ └────────────────────────────────────────────────┘ ``` ### toHour 将带有时间的日期转换为包含 24 小时制小时数（0-23）的 UInt8 数字。此函数假设如果时钟向前移动，则会移动一个小时，发生在凌晨 2 点，如果时钟向后移动，则会移动一个小时，发生在凌晨 3 点（这并不总是正确的 - 即使在莫斯科，时钟也在不同的时间调整了两次）。 **语法** ```SQL toHour(datetime) ``` **参数** * `datetime`：日期时间 **返回值** * 24 小时制的小时数。UInt8 **示例** ```SQL SELECT toHour(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toHour(toDateTime('2021-08-12 00:00:00'))─┐ │ 0 │ └───────────────────────────────────────────┘ ``` ### toISOWeek 将日期或时间日期转换为包含 ISO 周数的 UInt8 数字。 **语法** ```SQL toISOWeek(date) toISOWeek(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * ISO 周数。UInt8 **示例** ```SQL SELECT toISOWeek(toDate('2021-08-12')) ``` ```Plain Text ┌─toISOWeek(toDate('2021-08-12'))─┐ │ 32 │ └─────────────────────────────────┘ ``` ```SQL SELECT toISOWeek(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toISOWeek(toDateTime('2021-08-12 00:00:00'))─┐ │ 32 │ └──────────────────────────────────────────────┘ ``` ### toISOYear 将日期或时间日期转换为包含 ISO 年份数字的 UInt16 数字。 **语法** ```SQL toISOYear(date) toISOYear(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * ISO 年份数字。UInt16 **示例** ```SQL SELECT toISOYear(toDate('2021-08-12')) ``` ```Plain Text ┌─toISOYear(toDate('2021-08-12'))─┐ │ 2021 │ └─────────────────────────────────┘ ``` ```SQL SELECT toISOYear(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toISOYear(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021 │ └──────────────────────────────────────────────┘ ``` ### toMinute 将带有时间的日期转换为包含小时分钟数的 UInt8 数字（0-59）。 **语法** ```SQL toMinute(datetime) ``` **参数** * `datetime`：时间 **返回值** * 一小时内的分钟数，类型为 UInt8。 **示例** ```SQL SELECT toMinute(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toMinute(toDateTime('2021-08-12 00:00:00'))─┐ │ 0 │ └─────────────────────────────────────────────┘ ``` ### toMonday 将日期或日期时间向下舍入到最近的星期一。返回日期。 **语法** ```SQL toMonday(date) toMonday(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 日期到最近的星期一。日期 **示例** ```SQL SELECT toMonday(toDate('2021-08-12')) ``` ```Plain Text ┌─toMonday(toDate('2021-08-12'))─┐ │ 2021-08-09 │ └────────────────────────────────┘ ``` ```SQL SELECT toMonday(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toMonday(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021-08-09 │ └─────────────────────────────────────────────┘ ``` ### toMonth 将日期或时间日期转换为包含月份数字 (1-12) 的 UInt8 数字。 **语法** ```SQL toMonth(date) toMonth(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 日期到最近的星期一。日期 **示例** ```SQL SELECT toMonday(toDate('2021-08-12')) ``` ```Plain Text ┌─toMonday(toDate('2021-08-12'))─┐ │ 2021-08-09 │ └────────────────────────────────┘ ``` ```SQL SELECT toMonday(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toMonday(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021-08-09 │ └─────────────────────────────────────────────┘ ``` ### toQuarter 将日期或时间日期转换为包含季度数的 UInt8 数字。 **语法** ```SQL toQuarter(date) toQuarter(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 季度数。UInt8 **示例** ```SQL SELECT toQuarter(toDate('2021-08-12')) ``` ```Plain Text ┌─toQuarter(toDate('2021-08-12'))─┐ │ 3 │ └─────────────────────────────────┘ ``` ```SQL SELECT toQuarter(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toQuarter(toDateTime('2021-08-12 00:00:00'))─┐ │ 3 │ └──────────────────────────────────────────────┘ ``` ### toRelativeDayNum 将带有时间或日期的日期转换为从过去某个固定点开始的天数。 **语法** ```SQL toRelativeDayNum(date) toRelativeDayNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的日期数。UInt16 **示例** ```SQL SELECT toRelativeDayNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeDayNum(toDate('2021-08-12'))─┐ │ 18851 │ └────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeDayNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeDayNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 18851 │ └─────────────────────────────────────────────────────┘ ``` ### toRelativeHourNum 将带有时间或日期的日期转换为小时数，从过去某个固定点开始。 **语法** ```SQL toRelativeHourNum(date) toRelativeHourNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 小时数，从过去某个固定点开始。UInt32 **示例** ```SQL SELECT toRelativeHourNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeHourNum(toDate('2021-08-12'))─┐ │ 452416 │ └─────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeHourNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeHourNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 452416 │ └──────────────────────────────────────────────────────┘ ``` ### toRelativeMinuteNum 将带有时间或日期的日期转换为分钟数，从过去某个固定点开始。 **语法** ```SQL toRelativeMinuteNum(date) toRelativeMinuteNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 分钟数，从过去某个固定点开始。UInt32 **示例** ```SQL SELECT toRelativeMinuteNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeMinuteNum(toDate('2021-08-12'))─┐ │ 27144960 │ └───────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeMinuteNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeMinuteNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 27144960 │ └────────────────────────────────────────────────────────┘ ``` ### toRelativeMonthNum 将带有时间或日期的日期转换为月份数字，从过去某个固定点开始。 **语法** ```SQL toRelativeMonthNum(date) toRelativeMonthNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的月份数。UInt16 **示例** ```SQL SELECT toRelativeMonthNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeMonthNum(toDate('2021-08-12'))─┐ │ 24260 │ └──────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeMonthNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeMonthNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 24260 │ └───────────────────────────────────────────────────────┘ ``` ### toRelativeQuarterNum 将带有时间或日期的日期转换为从过去某个固定点开始的季度数字。 **语法** ```SQL toRelativeQuarterNum(date) toRelativeQuarterNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的季度编号。UInt16 **示例** ```SQL SELECT toRelativeQuarterNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeQuarterNum(toDate('2021-08-12'))─┐ │ 8086 │ └────────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeQuarterNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeQuarterNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 8086 │ └─────────────────────────────────────────────────────────┘ ``` ### toRelativeSecondNum 将带有时间或日期的日期转换为秒数，从过去某个固定点开始。 **语法** ```SQL toRelativeSecondNum(date) toRelativeSecondNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的秒数。UInt32 **示例** ```SQL SELECT toRelativeSecondNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeSecondNum(toDate('2021-08-12'))─┐ │ 1628697600 │ └───────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeSecondNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeSecondNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 1628697600 │ └────────────────────────────────────────────────────────┘ ``` ### toRelativeWeekNum 将带有时间或日期的日期转换为周数，从过去某个固定点开始。 **语法** ```SQL toRelativeWeekNum(date) toRelativeWeekNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的星期数。UInt16 **示例** ```SQL SELECT toRelativeWeekNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeWeekNum(toDate('2021-08-12'))─┐ │ 2693 │ └─────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeWeekNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeWeekNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 2693 │ └──────────────────────────────────────────────────────┘ ``` ### toRelativeYearNum 将带有时间或日期的日期转换为年份数字，从过去某个固定点开始。 **语法** ```SQL toRelativeYearNum(date) toRelativeYearNum(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 从过去某个固定时间点开始的年份数字。UInt16 **示例** ```SQL SELECT toRelativeYearNum(toDate('2021-08-12')) ``` ```Plain Text ┌─toRelativeYearNum(toDate('2021-08-12'))─┐ │ 2021 │ └─────────────────────────────────────────┘ ``` ```SQL SELECT toRelativeYearNum(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toRelativeYearNum(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021 │ └──────────────────────────────────────────────────────┘ ``` ### toSecond 将带有时间的日期转换为包含分钟内秒数的 UInt8 数字（0-59）。闰秒不予考虑。 **语法** ```SQL toSecond(datetime) ``` **参数** * `datetime`：日期时间 **返回值** * 分钟内的秒数，类型为 UInt8。 **示例** ```SQL SELECT toSecond(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toSecond(toDateTime('2021-08-12 00:00:00'))─┐ │ 0 │ └─────────────────────────────────────────────┘ ``` ### toStartOfDay 将日期时间向下舍入到一天的开始时间。 **语法** ```SQL toStartOfDay(datetime) ``` **参数** * `datetime`：日期时间 **返回值** * 将日期时间向下舍入到一天的开始时间。日期时间 **示例** ```SQL SELECT toStartOfDay(toDateTime('2021-08-12 08:00:00')) ``` ```Plain Text ┌─toStartOfDay(toDateTime('2021-08-12 08:00:00'))─┐ │ 2021-08-12 00:00:00 │ └─────────────────────────────────────────────────┘ ``` ### toStartOfFifteenMinutes 将日期时间向下舍入到十五分钟间隔的开始时间。 **语法** ```SQL toStartOfFifteenMinutes(datetime) ``` **参数** * `datetime`：日期时间 **返回值** * 将日期时间向下舍入到十五分钟间隔的开始时间。类型为 DateTime。 **示例** ```SQL SELECT toStartOfFifteenMinutes(toDateTime('2021-08-12 00:10:00')) ``` ```Plain Text ┌─toStartOfFifteenMinutes(toDateTime('2021-08-12 00:10:00'))─┐ │ 2021-08-12 00:00:00 │ └────────────────────────────────────────────────────────────┘ ``` ### toStartOfFiveMinute 将日期时间向下舍入到五分钟间隔的开始位置。 **语法** ```SQL toStartOfFiveMinute(datetime) ``` **参数** * `datetim`：日期时间 **返回值** * 将日期时间向下舍入到五分钟间隔的开始时间，类型为 DateTim： **示例** ```SQL SELECT toStartOfFiveMinute(toDateTime('2021-08-12 00:09:00')) ``` ```Plain Text ┌─toStartOfFiveMinute(toDateTime('2021-08-12 00:09:00'))─┐ │ 2021-08-12 00:05:00 │ └────────────────────────────────────────────────────────┘ ``` ### toStartOfHour 将日期时间向下舍入到小时的开始。 **语法** ```SQL toStartOfHour(datetime) ``` **参数** * `datetime`DateTime **返回值** * 将日期时间向下舍入到小时的开始。DateTime **示例** ```SQL SELECT toStartOfHour(toDateTime('2021-08-12 01:09:00')) ``` ```Plain Text ┌─toStartOfHour(toDateTime('2021-08-12 01:09:00'))─┐ │ 2021-08-12 01:00:00 │ └──────────────────────────────────────────────────┘ ``` ### toStartOfISOYear 将日期或日期时间向下舍入到 ISO 年份的第一天。返回日期。 **语法** ```SQL toStartOfISOYear(date) toStartOfISOYear(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或带时间的日期向下舍入到 ISO 年份的第一天。日期 **示例** ```SQL SELECT toStartOfISOYear(toDate('2021-08-12')) ``` ```Plain Text ┌─toStartOfISOYear(toDate('2021-08-12'))─┐ │ 2021-01-04 │ └────────────────────────────────────────┘ ``` ```SQL SELECT toStartOfISOYear(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toStartOfISOYear(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021-01-04 │ └─────────────────────────────────────────────────────┘ ``` ### toStartOfInterval 这是其他名为的函数的泛化`toStartOf*`。例如， `toStartOfInterval(t, INTERVAL 1 year)`返回与相同的值`toStartOfYear(t)`、 `toStartOfInterval(t, INTERVAL 1 month)`返回与相同的值`toStartOfMonth(t)`、 `toStartOfInterval(t, INTERVAL 1 day)`返回与相同的值`toStartOfDay(t)`、 `toStartOfInterval(t, INTERVAL 15 minute)`返回与相同的值`toStartOfFifteenMinutes(t)`等。 **语法** ```SQL toStartOfInterval(time_or_data, INTERVAL x unit [, time_zone]) ``` **参数** * `time_or_data`日期/日期时间 * `x unit`x 是 UInt*，单位可以是秒、分、时、日、月、年、季度 **返回值** * 日期/日期时间 **示例** ```SQL SELECT toStartOfInterval(toDateTime('2021-08-12 01:09:00'), INTERVAL 2 minute) ``` ```Plain Text ┌─toStartOfInterval(toDateTime('2021-08-12 01:09:00'), toIntervalMinute(2))─┐ │ 2021-08-12 01:08:00 │ └───────────────────────────────────────────────────────────────────────────┘ ``` ### toStartOfMinute 将日期时间向下舍入到分钟的开始。 **语法** ```SQL toStartOfMinute(datetime) ``` **参数** * `datetime`日期时间 **返回值** * 将日期时间向下舍入到分钟的开始。DateTime **示例** ```SQL SELECT toStartOfMinute(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfMinute(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-08-12 00:01:00 │ └────────────────────────────────────────────────────┘ ``` ### toStartOfMonth 将日期或日期时间向下舍入到该月的第一天。返回日期。 **语法** ```SQL toStartOfMonth(date) toStartOfMonth(datetime) sql ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或日期时间向下舍入到该月的第一天。日期 **示例** ```SQL SELECT toStartOfMonth(toDate('2021-08-12')) ``` ```Plain Text ┌─toStartOfMonth(toDate('2021-08-12'))─┐ │ 2021-08-01 │ └──────────────────────────────────────┘ ``` ```SQL SELECT toStartOfMonth(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfMonth(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-08-01 │ └───────────────────────────────────────────────────┘ ``` ### toStartOfQuarter 将日期或时间日期向下舍入到季度的第一天。季度的第一天可以是 1 月 1 日、4 月 1 日、7 月 1 日或 10 月 1 日。返回日期。 **语法** ```SQL toStartOfQuarter(date) toStartOfQuarter(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或日期时间向下舍入到该季度的第一天。日期 **示例** ```SQL SELECT toStartOfQuarter(toDate('2021-08-12')) ``` ```Plain Text ┌─toStartOfQuarter(toDate('2021-08-12'))─┐ │ 2021-07-01 │ └────────────────────────────────────────┘ ``` ```SQL SELECT toStartOfQuarter(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfQuarter(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-07-01 │ └─────────────────────────────────────────────────────┘ ``` ### toStartOfTenMinutes 将日期时间向下舍入到十分钟间隔的开始时间。 **语法** ```SQL toStartOfTenMinutes(datetime) ``` **参数** * `datetime`日期时间 **返回值** * 将日期时间向下舍入到十分钟间隔的开始时间。DateTime **示例** ```SQL SELECT toStartOfTenMinutes(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfTenMinutes(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-08-12 00:00:00 │ └────────────────────────────────────────────────────────┘ ``` ### toStartOfWeek 根据 mode 将日期或带时间的日期向下舍入到最近的星期日或星期一。返回日期。mode 参数的作用与 toWeek() 的 mode 参数完全相同。对于单参数语法，使用 mode 值 0。 **语法** ```SQL toStartOfWeek(date\[,mode\]) toStartOfWeek(datetime\[,mode\]) ``` **参数** * `date/datetime`日期/日期时间 * `mode`参考周模式。 **返回值** * 根据模式将日期或带时间的日期向下舍入到最近的星期日或星期一。 **示例** ```SQL SELECT toStartOfWeek(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfWeek(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-08-08 │ └──────────────────────────────────────────────────┘ ``` ### toStartOfYear 将日期或日期时间向下舍入到一年的第一天。返回日期。 **语法** ```SQL toStartOfYear(date) toStartOfYear(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或日期时间向下舍入到一年的第一天。日期 **示例** ```SQL SELECT toStartOfYear(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toStartOfYear(toDateTime('2021-08-12 00:01:30'))─┐ │ 2021-01-01 │ └──────────────────────────────────────────────────┘ ``` ### toTime 将带有时间的日期转换为某个固定日期，同时保留时间。 **语法** ```SQL toTime(date) toTime(datetime) ``` **参数** * `date/datetime`：日期/日期时间 **返回值** * 日期和时间 **示例** ```SQL SELECT toTime(toDateTime('2021-08-12 00:01:30')) ``` ```Plain Text ┌─toTypeName(toTime(toDateTime('2021-08-12 00:01:30')))─┐ │ DateTime('PRC') │ └───────────────────────────────────────────────────────┘ ``` ### toTimezone 将时间或日期和时间转换为指定的时区。时区是`Date`和`DateTime`数据类型的属性。表字段或结果集列的内部值（秒数）不变，列的类型会发生变化，其字符串表示也会相应变化。 **语法** ```SQL toTimezone(value, timezone) ``` **参数** * `value`— 时间或日期和时间。日期/日期时间。 * `timezone`— 返回值的时区。字符串。 **返回值** * 日期和时间。日期时间。 **示例** ```SQL SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc, toTypeName(time_utc) AS type_utc, toInt32(time_utc) AS int32utc, toTimeZone(time_utc, 'Asia/Yekaterinburg') AS time_yekat, toTypeName(time_yekat) AS type_yekat, toInt32(time_yekat) AS int32yekat, toTimeZone(time_utc, 'US/Samoa') AS time_samoa, toTypeName(time_samoa) AS type_samoa, toInt32(time_samoa) AS int32samoa FORMAT Vertical; ``` ```Plain Text Row 1: ────── time_utc: 2019-01-01 00:00:00 type_utc: DateTime('UTC') int32utc: 1546300800 time_yekat: 2019-01-01 05:00:00 type_yekat: DateTime('Asia/Yekaterinburg') int32yekat: 1546300800 time_samoa: 2018-12-31 13:00:00 type_samoa: DateTime('US/Samoa') int32samoa: 1546300800 ``` `toTimeZone(time_utc, 'Asia/Yekaterinburg')`将类型更改`DateTime('UTC')`为`DateTime('Asia/Yekaterinburg')`。值（Unixtimestamp） 1546300800 保持不变，但字符串表示形式（toString() 函数的结果）从更改`time_utc: 2019-01-01 00:00:00`为`time_yekat: 2019-01-01 05:00:00`。 ### toWeek 此函数返回日期或日期时间的周数。toWeek() 的两个参数形式允许您指定周是从星期日还是星期一开始，以及返回值应在 0 到 53 还是 1 到 53 范围内。如果省略模式参数，则默认模式为 0。`toISOWeek()`是一个相当于的兼容函数`toWeek(date,3)`。下表描述了模式参数的工作原理。 | | | | | \ |**模式** |**一周的第一天** |**范围** |**第一周是第一周……** | |---|---|---|---| | | | | | \ |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 |今年有一个星期一 | | | | | | \ |8 |星期日 |1-53 |包含 1 月 1 日 | | | | | | \ |9 |周一 |1-53 |包含 1 月 1 日 | 对于含义为“今年有 4 天或以上”的模式值，周数按照 ISO 8601:1988 进行编号： * 如果包含 1 月 1 日的一周在新年中有 4 天或更多天，则该周为第 1 周。 * 否则，它是上一年的最后一周，下一周是第一周。对于含义为“包含 1 月 1 日”的模式值，包含 1 月 1 日的星期为第 1 周。该星期包含新年的多少天并不重要，即使只包含一天也可以。 **语法** ```SQL toWeek(date, [, mode][, Timezone]) ``` **参数** * `date`– 日期或日期时间。 * `mode`– 可选参数，取值范围为[0,9]，默认为0。 * `Timezone`– 可选参数，其行为与任何其他转换函数一样。 **返回值** * 周数。UInt8 **示例** ```SQL SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9; ``` ```Plain Text ┌─date───────┬─week0─┬─week1─┬─week9─┐ │ 2016-12-27 │ 52 │ 52 │ 1 │ └────────────┴───────┴───────┴───────┘ ``` ### toYYYYMM 将日期或时间日期转换为包含年份和月份数字 (YYYY * 100 + MM) 的 UInt32 数字。 **语法** ```SQL toYYYYMM(date) toYYYYMM(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 包含年份和月份的数字。UInt32 **示例** ```SQL SELECT toYYYYMM(toDate('2021-08-12')) ``` ```Plain Text ┌─toYYYYMM(toDate('2021-08-12'))─┐ │ 202108 │ └────────────────────────────────┘ ``` ```SQL SELECT toYYYYMM(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toYYYYMM(toDateTime('2021-08-12 00:00:00'))─┐ │ 202108 │ └─────────────────────────────────────────────┘ ``` ### toYYYYMMDD 将日期或时间日期转换为包含年、月、日的 UInt32 数字 (YYYY * 10000 + MM * 100 + DD)。 **语法** ```SQL toYYYYMMDD(date) toYYYYMMDD(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 包含年月日的数字。UInt32 **示例** ```SQL SELECT toYYYYMMDD(toDate('2021-08-12')) ``` ```Plain Text ┌─toYYYYMMDD(toDate('2021-08-12'))─┐ │ 20210812 │ └──────────────────────────────────┘ ``` ```SQL SELECT toYYYYMMDD(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toYYYYMMDD(toDateTime('2021-08-12 00:00:00'))─┐ │ 20210812 │ └───────────────────────────────────────────────┘ ``` ### toYYYYMMDDhhmmss 将日期或带有时间的日期转换为包含年、月、日、时、分、秒的 UInt64 数字（YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss）。 **语法** ```SQL toYYYYMMDDhhmmss(date) toYYYYMMDDhhmmss(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 包含年、月、日、时、分、秒的数字。UInt32 **示例** ```SQL SELECT toYYYYMMDDhhmmss(toDate('2021-08-12')) ``` ```Plain Text ┌─toYYYYMMDDhhmmss(toDate('2021-08-12'))─┐ │ 20210812000000 │ └────────────────────────────────────────┘ ``` ```SQL SELECT toYYYYMMDDhhmmss(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toYYYYMMDDhhmmss(toDateTime('2021-08-12 00:00:00'))─┐ │ 20210812000000 │ └─────────────────────────────────────────────────────┘ ``` ### toYear 将日期或时间日期转换为包含年份（AD）的 UInt16 数字。 **语法** ```SQL toYear(date) toYear(datetime) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或时间日期转换为包含年份（AD）的 UInt16 数字。UInt16 **示例** ```SQL SELECT toYear(toDate('2021-08-12')) ``` ```Plain Text ┌─toYear(toDate('2021-08-12'))─┐ │ 2021 │ └──────────────────────────────┘ ``` ```SQL SELECT toYear(toDateTime('2021-08-12 00:00:00')) ``` ```Plain Text ┌─toYear(toDateTime('2021-08-12 00:00:00'))─┐ │ 2021 │ └───────────────────────────────────────────┘ ``` ### toYearWeek 返回日期的年份和星期。结果中的年份可能与日期参数中该年第一周和最后一周的年份不同。 mode 参数的作用与 toWeek() 的 mode 参数完全相同。对于单参数语法，使用 mode 值 0。 `toISOYear()`是一个相当于的兼容函数`intDiv(toYearWeek(date,3),100)`。 **语法** ```SQL toYearWeek(date[,mode]) toYearWeek(datetime[,mode]) ``` **参数** * `date/datetime`日期/日期时间 * `mode`参考周模式。 **返回值** * 日期的年份和星期。UInt32 **示例** ```SQL SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9; ``` ```Plain Text ┌─date───────┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┐ │ 2016-12-27 │ 201652 │ 201652 │ 201701 │ └────────────┴───────────┴───────────┴───────────┘ ``` ### today 接受零个参数并返回请求执行时某一时刻的当前日期。与‘toDate(now())’相同。 **语法** ```SQL today() ``` **返回值** * 日期。 **示例** ```SQL SELECT today() ``` ### to_days :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `to_days` 根据指定日期 `date`，返回自公元 0 年开始的天数。 **语法** ```SQL to_days(date) ``` **参数类型** * `date` * 要转换为天数的日期 * Date/Date32/Datetime/Datetime64 * String **返回类型** * UInt64 **示例** **示例 1:** ```SQL SELECT to_days(date '2024-07-21'); ``` ```Plain Text ┌─to_days(toDate('2024-07-21'))─┐ │ 739453 │ └───────────────────────────────┘ ``` **示例 2:** ```SQL SELECT to_days('2024-07-21'); ``` ```Plain Text ┌─to_days('2024-07-21')─┐ │ 739453 │ └───────────────────────┘ ``` ### to_seconds :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `to_seconds` 根据给定的 `expr`，返回自公元 0 年开始的秒数。 **语法** ```SQL to_seconds(expr) ``` **参数类型** * `expr` * 要转换为秒数的表达式 * Date/Date32/Datetime/Datetime64 * String * Time **返回类型** * UInt64 **示例** **示例 1:** ```SQL SELECT to_seconds(date '2024-07-21'); ``` ```Plain Text ┌─to_seconds(toDate('2024-07-21'))─┐ │ 63888710400 │ └──────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT to_seconds(datetime '2024-07-21 12:13:14'); ``` ```Plain Text ┌─to_seconds(toDateTime('2024-07-21 12:13:14'))─┐ │ 63888754394 │ └───────────────────────────────────────────────┘ ``` ### unix_timestamp :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `unix_timestamp` 返回自 '1970-01-01 00:00:00' UTC 至当前时间的秒数。`unix_timestamp(date)` 将参数的值返回为自 '1970-01-01 00:00:00' UTC 至 `date` 指定时间的秒数。 **语法** ```SQL unix_timestamp() unix_timestamp(date) ``` **参数类型** * `date` * 要转换为 UNIX 时间戳的日期或日期时间表达式 * String * Date/Date32/Datetime/Datetime64 **返回类型** * Int64 **示例** **示例 1:** ```SQL SELECT unix_timestamp(); ``` ```Plain Text ┌─toUnixTimestamp()─┐ │ 1721987167 │ └───────────────────┘ ``` **示例 2:** ```SQL SELECT unix_timestamp(datetime '2024-07-21 12:13:14'); ``` ```Plain Text ┌─toUnixTimestamp(toDateTime('2024-07-21 12:13:14'))─┐ │ 1721535194 │ └────────────────────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT unix_timestamp(date '2024-07-21'); ``` ```Plain Text ┌─toUnixTimestamp(toDate('2024-07-21'))─┐ │ 1721491200 │ └───────────────────────────────────────┘ ``` ### utc_date :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `utc_date` 返回 UTC 日期。 **语法** ```SQL utc_date() ``` **返回类型** * Date **示例** ```SQL SELECT utc_date(); ``` ```Plain Text ┌─utc_date()─┐ │ 2024-07-26 │ └────────────┘ ``` ### utc_time :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `utc_time` 返回 UTC 时间。 **语法** ```SQL utc_time() ``` **返回类型** * Time **示例** ```SQL SELECT utc_time(); ``` ```Plain Text ┌───utc_time()─┐ │ 09:49:58.000 │ └─────────────┘ ``` ### utc_timestamp :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `utc_timestamp` 返回 UTC 时间戳。 **语法** ```SQL utc_timestamp() ``` **返回类型** * Datetime **示例** ```SQL SELECT utc_timestamp(); ``` ```Plain Text ┌──────UTCTimestamp()─┐ │ 2024-07-26 09:50:19 │ └─────────────────────┘ ``` ### week ToWeek 的别名 ### weekday :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `weekday` 返回 `date` 是一周中的第几天。返回值 0 = Monday, 1 = Tuesday, 2 = Wednesday, 3 = Thursday, 4 = Friday, 5 = Saturday, 6 = Sunday。 **语法** ```SQL weekday(date) ``` **参数类型** * `date` * Date/Date32/Datetime/Datetime64 * String **返回类型** * UInt8 **示例** **示例 1:** ```SQL SELECT weekday(datetime '2024-07-21 00:09:00'); ``` ```Plain Text ┌─WEEKDAY(toDateTime('2024-07-21 00:09:00'))─┐ │ 6 │ └────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT weekday(date '2024-07-21'); ``` ```Plain Text ┌─WEEKDAY(toDate('2024-07-21'))─┐ │ 6 │ └───────────────────────────────┘ ``` **示例 3:** ```SQL SELECT weekday('2024-07-21'); ``` ```Plain Text ┌─WEEKDAY('2024-07-21')─┐ │ 6 │ └───────────────────────┘ ``` ### weekofyear :::warning MySQL兼容语法，推荐在相关方言下使用。 ::: `weekofyear` 返回 `date` 对应的日历周，取值范围为 [1, 53]。 **语法** ```SQL weekofyear(date) ``` **参数类型** * `date` * Date/Date32/Datetime/Datetime64 * String **返回类型** * UInt64 **示例** **示例 1:** ```SQL SELECT weekofyear(datetime '2024-07-21 09:00:00'); ``` ```Plain Text ┌─toWeekOfYear(toDateTime('2024-07-21 09:00:00'))─┐ │ 29 │ └─────────────────────────────────────────────────┘ ``` **示例 2:** ```SQL SELECT weekofyear(date '2024-07-21'); ``` ```Plain Text ┌─toWeekOfYear(toDate('2024-07-21'))─┐ │ 29 │ └────────────────────────────────────┘ ``` **示例 3:** ```SQL SELECT weekofyear('2024-07-21'); ``` ```Plain Text ┌─toWeekOfYear('2024-07-21')─┐ │ 29 │ └────────────────────────────┘ ``` ### year toYear 的别名 ### yearweek 返回日期的年份和星期。结果中的年份可能与日期参数中该年第一周和最后一周的年份不同。 mode 参数的作用与 toWeek() 的 mode 参数完全相同。对于单参数语法，使用 mode 值 0。 `toISOYear()`是一个相当于的兼容函数`intDiv(toYearWeek(date,3),100)`。 **语法** ```SQL toYearWeek(date[,mode]) ``` **参数** * `date/datetime`日期/日期时间 **返回值** * 将日期或带时间的日期向下舍入到 ISO 年份的第一天。日期 **示例** ```SQL SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9; ``` ```Plain Text ┌─date───────┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┐ │ 2016-12-27 │ 201652 │ 201652 │ 201701 │ └────────────┴───────────┴───────────┴───────────┘ ``` ### yesterday 接受零个参数并在请求执行的某一时刻返回昨天的日期。与‘today() - 1’相同。 **语法** ```SQL yesterday() ``` **返回值** * 日期。 **示例** ```SQL SELECT yesterday() ``` ##

ByteHouse云数仓版