跳到主要内容
跳到主要内容
编辑此页

日期和时间函数

本节中的大多数函数接受一个可选的时区参数，例如 Europe/Amsterdam。在这种情况下，时区是指定的时区，而不是本地（默认）时区。

示例

SELECT
    toDateTime('2016-06-15 23:00:00') AS time,
    toDate(time) AS date_local,
    toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
    toString(time, 'US/Samoa') AS time_samoa
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘

makeDate​

创建一个 Date

  • 从年、月和日参数，或
  • 从年和年中天数参数。

语法

makeDate(year, month, day);
makeDate(year, day_of_year);

别名

  • MAKEDATE(year, month, day);
  • MAKEDATE(year, day_of_year);

参数

返回值

  • 从参数创建的日期。 Date。

示例

从年、月和日创建一个 Date

SELECT makeDate(2023, 2, 28) AS Date;

结果

┌───────date─┐
│ 2023-02-28 │
└────────────┘

从年和年中天数参数创建一个 Date

SELECT makeDate(2023, 42) AS Date;

结果

┌───────date─┐
│ 2023-02-11 │
└────────────┘

makeDate32​

从年、月、日（或可选的年和日）创建一个 Date32 类型的日期。

语法

makeDate32(year, [month,] day)

参数

注意

如果省略 month，则 day 应取 1 到 365 之间的值，否则应取 1 到 31 之间的值。

返回值

  • 从参数创建的日期。 Date32。

示例

从年、月和日创建一个日期

查询

SELECT makeDate32(2024, 1, 1);

结果

2024-01-01

从年和年中天数创建一个 Date

查询

SELECT makeDate32(2024, 100);

结果

2024-04-09

makeDateTime​

从年、月、日、小时、分钟和秒参数创建一个 DateTime。

语法

makeDateTime(year, month, day, hour, minute, second[, timezone])

参数

返回值

  • 从参数创建的带时间的日期。 DateTime。

示例

SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;

结果

┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘

makeDateTime64​

从其组件：年、月、日、小时、分钟、秒创建一个 DateTime64 数据类型值。带有可选的亚秒精度。

语法

makeDateTime64(year, month, day, hour, minute, second[, precision])

参数

返回值

  • 从提供的参数创建的日期和时间。 DateTime64。

示例

SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│                       2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘

timestamp​

将第一个参数 'expr' 转换为 DateTime64(6) 类型。如果提供了第二个参数 'expr_time'，它会将指定的时间添加到转换后的值。

语法

timestamp(expr[, expr_time])

别名： TIMESTAMP

参数

  • expr - 日期或带时间的日期。 字符串。
  • expr_time - 可选参数。要添加的时间。 字符串。

示例

SELECT timestamp('2023-12-31') as ts;

结果

┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') as ts;

结果

┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘

返回值

timeZone​

返回当前会话的时区，即设置 session_timezone 的值。 如果该函数在分布式表的上下文中执行，则它会生成一个普通列，其值与每个分片相关，否则它会生成一个常量值。

语法

timeZone()

别名： timezone。

返回值

示例

SELECT timezone()

结果

┌─timezone()─────┐
│ America/Denver │
└────────────────┘

另请参阅

serverTimeZone​

返回服务器的时区，即设置 timezone 的值。 如果该函数在分布式表的上下文中执行，则它会生成一个普通列，其值与每个分片相关。 否则，它会生成一个常量值。

语法

serverTimeZone()

别名： serverTimezone。

返回值

示例

SELECT serverTimeZone()

结果

┌─serverTimeZone()─┐
│ UTC              │
└──────────────────┘

另请参阅

toTimeZone​

将日期或带时间的日期转换为指定的时区。 不更改数据的内部值（Unix 秒数），仅更改值的时区属性和值的字符串表示形式。

语法

toTimezone(value, timezone)

别名： toTimezone。

参数

  • value — 时间或日期和时间。 DateTime64。
  • timezone — 返回值的时区。 字符串。 此参数是一个常量，因为 toTimezone 更改列的时区（时区是 DateTime* 类型的属性）。

返回值

示例

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;

结果

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

另请参阅

timeZoneOf​

返回 DateTime 或 DateTime64 数据类型的时区名称。

语法

timeZoneOf(value)

别名： timezoneOf。

参数

返回值

示例

SELECT timezoneOf(now());

结果

┌─timezoneOf(now())─┐
│ Etc/UTC           │
└───────────────────┘

timeZoneOffset​

返回从 UTC 的时区偏移量（以秒为单位）。 该函数将夏令时和指定日期和时间的历史时区更改考虑在内。 IANA 时区数据库用于计算偏移量。

语法

timeZoneOffset(value)

别名： timezoneOffset。

参数

返回值

  • 从 UTC 的偏移量（以秒为单位）。 Int32。

示例

SELECT toDateTime('2021-04-21 10:20:30', 'America/New_York') AS Time, toTypeName(Time) AS Type,
       timeZoneOffset(Time) AS Offset_in_seconds, (Offset_in_seconds / 3600) AS Offset_in_hours;

结果

┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │            -14400 │              -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘

toYear​

返回日期或带时间的日期的年份组成部分 (AD)。

语法

toYear(value)

别名： YEAR

参数

返回值

  • 给定日期/时间的年份。 UInt16。

示例

SELECT toYear(toDateTime('2023-04-21 10:20:30'))

结果

┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                      2023 │
└───────────────────────────────────────────┘

toQuarter​

返回日期或带时间的日期的季度 (1-4)。

语法

toQuarter(value)

别名： QUARTER

参数

返回值

  • 给定日期/时间的年份季度（1、2、3 或 4）。 UInt8。

示例

SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))

结果

┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│                                            2 │
└──────────────────────────────────────────────┘

toMonth​

返回日期或带时间的日期的月份组成部分 (1-12)。

语法

toMonth(value)

别名： MONTH

参数

返回值

  • 给定日期/时间的年份月份（1 - 12）。 UInt8。

示例

SELECT toMonth(toDateTime('2023-04-21 10:20:30'))

结果

┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                          4 │
└────────────────────────────────────────────┘

toDayOfYear​

返回日期或带时间的日期的年中天数 (1-366)。

语法

toDayOfYear(value)

别名： DAYOFYEAR

参数

返回值

  • 给定日期/时间的年中天数（1 - 366）。 UInt16。

示例

SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))

结果

┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                            111 │
└────────────────────────────────────────────────┘

toDayOfMonth​

返回日期或带时间的日期的月中天数 (1-31)。

语法

toDayOfMonth(value)

别名： DAYOFMONTH, DAY

参数

返回值

  • 给定日期/时间的月中天数（1 - 31）。 UInt8。

示例

SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))

结果

┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                              21 │
└─────────────────────────────────────────────────┘

toDayOfWeek​

返回日期或带时间的日期的周中天数。

toDayOfWeek() 的双参数形式允许您指定一周是从星期一还是星期日开始，以及返回值应在 0 到 6 还是 1 到 7 的范围内。如果省略 mode 参数，则默认模式为 0。日期时区可以指定为第三个参数。

模式一周的第一天范围
0星期一1-7：星期一 = 1，星期二 = 2，...，星期日 = 7
1星期一0-6：星期一 = 0，星期二 = 1，...，星期日 = 6
2星期日0-6：星期日 = 0，星期一 = 1，...，星期六 = 6
3星期日1-7：星期日 = 1，星期一 = 2，...，星期六 = 7

语法

toDayOfWeek(t[, mode[, timezone]])

别名： DAYOFWEEK。

参数

  • t - Date、Date32、DateTime 或 DateTime64
  • mode - 确定一周的第一天是哪一天。 可能的值为 0、1、2 或 3。 有关差异，请参见上表。
  • timezone - 可选参数，其行为类似于任何其他转换函数

第一个参数也可以指定为 String，格式受 parseDateTime64BestEffort() 支持。 仅出于与某些第三方工具期望的 MySQL 兼容性的原因，才存在字符串参数支持。 由于字符串参数支持将来可能会依赖于新的 MySQL 兼容性设置，并且由于字符串解析通常很慢，因此建议不要使用它。

返回值

  • 给定日期/时间的周中天数（1-7），具体取决于所选模式

示例

以下日期是 2023 年 4 月 21 日，星期五

SELECT
    toDayOfWeek(toDateTime('2023-04-21')),
    toDayOfWeek(toDateTime('2023-04-21'), 1)

结果

┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│                                     5 │                                        4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘

toHour​

返回带时间的日期的小时组成部分 (0-24)。

假设如果时钟提前，则提前一小时，发生在凌晨 2 点；如果时钟延后，则延后一小时，发生在凌晨 3 点（这并不总是完全发生的时间 - 这取决于时区）。

语法

toHour(value)

别名： HOUR

参数

返回值

  • 给定日期/时间的小时（0 - 23）。 UInt8。

示例

SELECT toHour(toDateTime('2023-04-21 10:20:30'))

结果

┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│                                        10 │
└───────────────────────────────────────────┘

toMinute​

返回带时间的日期的分钟组成部分 (0-59)。

语法

toMinute(value)

别名： MINUTE

参数

返回值

  • 给定日期/时间的分钟（0 - 59）。 UInt8。

示例

SELECT toMinute(toDateTime('2023-04-21 10:20:30'))

结果

┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│                                          20 │
└─────────────────────────────────────────────┘

toSecond​

返回带时间的日期的秒组成部分 (0-59)。 不考虑闰秒。

语法

toSecond(value)

别名： SECOND

参数

返回值

  • 给定日期/时间的秒（0 - 59）。 UInt8。

示例

SELECT toSecond(toDateTime('2023-04-21 10:20:30'))

结果

┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│                                          30 │
└─────────────────────────────────────────────┘

toMillisecond​

返回带时间的日期的毫秒组成部分 (0-999)。

语法

toMillisecond(value)

参数*

别名： MILLISECOND

SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))

结果

┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│                                                        456 │
└────────────────────────────────────────────────────────────┘

返回值

  • 给定日期/时间的毫秒（0 - 59）。 UInt16。

toUnixTimestamp​

将字符串、日期或带时间的日期转换为 UInt32 表示形式的 Unix 时间戳。

如果使用字符串调用该函数，它接受一个可选的时区参数。

语法

toUnixTimestamp(date)
toUnixTimestamp(str, [timezone])

返回值

  • 返回 Unix 时间戳。 UInt32。

示例

SELECT
    '2017-11-05 08:07:47' AS dt_str,
    toUnixTimestamp(dt_str) AS from_str,
    toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
    toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
    toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
    toUnixTimestamp(toDate(dt_str)) AS from_date,
    toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;

结果

Row 1:
──────
dt_str:          2017-11-05 08:07:47
from_str:        1509869267
from_str_tokyo:  1509836867
from_datetime:   1509869267
from_datetime64: 1509869267
from_date:       1509840000
from_date32:     1509840000
注意

下面描述的 toStartOf*、toLastDayOf*、toMonday、timeSlot 函数的返回类型由配置参数 enable_extended_results_for_datetime_functions 确定，默认值为 0。

行为对于

  • enable_extended_results_for_datetime_functions = 0:
    • 函数 toStartOfYear、toStartOfISOYear、toStartOfQuarter、toStartOfMonth、toStartOfWeek、toLastDayOfWeek、toLastDayOfMonth、toMonday 返回 Date 或 DateTime。
    • 函数 toStartOfDay、toStartOfHour、toStartOfFifteenMinutes、toStartOfTenMinutes、toStartOfFiveMinutes、toStartOfMinute、timeSlot 返回 DateTime。 尽管这些函数可以将扩展类型 Date32 和 DateTime64 的值作为参数，但是向它们传递超出正常范围的时间（对于 Date 为 1970 年到 2149 年/对于 DateTime 为 2106 年）将产生错误的结果。
  • enable_extended_results_for_datetime_functions = 1:
    • 函数 toStartOfYear、toStartOfISOYear、toStartOfQuarter、toStartOfMonth、toStartOfWeek、toLastDayOfWeek、toLastDayOfMonth、toMonday 在它们的参数是 Date 或 DateTime 时返回 Date 或 DateTime，并且在它们的参数是 Date32 或 DateTime64 时返回 Date32 或 DateTime64。
    • 函数 toStartOfDay、toStartOfHour、toStartOfFifteenMinutes、toStartOfTenMinutes、toStartOfFiveMinutes、toStartOfMinute、timeSlot 在它们的参数是 Date 或 DateTime 时返回 DateTime，并且在它们的参数是 Date32 或 DateTime64 时返回 DateTime64。

toStartOfYear​

将日期或带时间的日期向下舍入到年初的第一天。 返回日期作为 Date 对象。

语法

toStartOfYear(value)

参数

返回值

  • 输入日期/时间的年初第一天。 Date。

示例

SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))

结果

┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                       2023-01-01 │
└──────────────────────────────────────────────────┘

toStartOfISOYear​

将日期或带时间的日期向下舍入到 ISO 年的第一天，这可能与“常规”年份不同。 （请参阅 https://en.wikipedia.org/wiki/ISO_week_date。）

语法

toStartOfISOYear(value)

参数

返回值

  • 输入日期/时间的年初第一天。 Date。

示例

SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))

结果

┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-01-02 │
└─────────────────────────────────────────────────────┘

toStartOfQuarter​

将日期或带时间的日期向下舍入到季度的第一天。 季度的第一天是 1 月 1 日、4 月 1 日、7 月 1 日或 10 月 1 日。 返回日期。

语法

toStartOfQuarter(value)

参数

返回值

  • 给定日期/时间的季度第一天。 Date。

示例

SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))

结果

┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-04-01 │
└─────────────────────────────────────────────────────┘

toStartOfMonth​

将日期或带时间的日期向下舍入到每月的第一天。 返回日期。

语法

toStartOfMonth(value)

参数

返回值

  • 给定日期/时间的每月第一天。 Date。

示例

SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))

结果

┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                        2023-04-01 │
└───────────────────────────────────────────────────┘
注意

解析不正确日期的行为是特定于实现的。 ClickHouse 可能会返回零日期、抛出异常或执行“自然”溢出。

toLastDayOfMonth​

将日期或带时间的日期舍入到每月的最后一天。 返回日期。

语法

toLastDayOfMonth(value)

别名： LAST_DAY

参数

返回值

  • 给定日期/时间的每月最后一天。 Date。

示例

SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))

结果

┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│                                          2023-04-30 │
└─────────────────────────────────────────────────────┘

toMonday​

将日期或带时间的日期向下舍入到最近的星期一。 返回日期。

语法

toMonday(value)

参数

返回值

  • 给定日期或之前最近的星期一的日期。 Date。

示例

SELECT
    toMonday(toDateTime('2023-04-21 10:20:30')), /* a Friday */
    toMonday(toDate('2023-04-24')), /* already a Monday */

结果

┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│                                  2023-04-17 │                     2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘

toStartOfWeek​

将日期或带时间的日期向下舍入到最近的星期日或星期一。 返回日期。 mode 参数的工作方式与函数 toWeek() 中的 mode 参数完全相同。 如果未指定 mode，则默认为 0。

语法

toStartOfWeek(t[, mode[, timezone]])

参数

返回值

  • 给定日期或之前最近的星期日或星期一的日期，具体取决于 mode。 Date。

示例

SELECT
    toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
    toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
    toStartOfWeek(toDate('2023-04-24')), /* a Monday */
    toStartOfWeek(toDate('2023-04-24'), 1) /* a Monday */
FORMAT Vertical

结果

Row 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')):    2023-04-16
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')):                 2023-04-23
toStartOfWeek(toDate('2023-04-24'), 1):              2023-04-24

toLastDayOfWeek​

将日期或带时间的日期向上舍入到最近的星期六或星期日。 返回日期。 mode 参数的工作方式与函数 toWeek() 中的 mode 参数完全相同。 如果未指定 mode，则假定 mode 为 0。

语法

toLastDayOfWeek(t[, mode[, timezone]])

参数

  • t - Date、Date32、DateTime 或 DateTime64
  • mode - 确定一周的最后一天，如 toWeek 函数中所述
  • timezone - 可选参数，其行为类似于任何其他转换函数

返回值

  • 给定日期或之后最近的星期日或星期一的日期，具体取决于 mode。 Date。

示例

SELECT
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
    toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
    toLastDayOfWeek(toDate('2023-04-22')), /* a Saturday */
    toLastDayOfWeek(toDate('2023-04-22'), 1) /* a Saturday */
FORMAT Vertical

结果

Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')):    2023-04-22
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-23
toLastDayOfWeek(toDate('2023-04-22')):                 2023-04-22
toLastDayOfWeek(toDate('2023-04-22'), 1):              2023-04-23

toStartOfDay​

将带时间的日期向下舍入到一天的开始。

语法

toStartOfDay(value)

参数

返回值

  • 给定日期/时间的一天开始。 DateTime。

示例

SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))

结果

┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│                             2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘

toStartOfHour​

将带时间的日期向下舍入到小时的开始。

语法

toStartOfHour(value)

参数

返回值

  • 给定日期/时间的小时开始。 DateTime。

示例

SELECT
    toStartOfHour(toDateTime('2023-04-21 10:20:30')),
    toStartOfHour(toDateTime64('2023-04-21', 6))

结果

┌─toStartOfHour(toDateTime('2023-04-21 10:20:30'))─┬─toStartOfHour(toDateTime64('2023-04-21', 6))─┐
│                              2023-04-21 10:00:00 │                          2023-04-21 00:00:00 │
└──────────────────────────────────────────────────┴──────────────────────────────────────────────┘

toStartOfMinute​

将带时间的日期向下舍入到分钟的开始。

语法

toStartOfMinute(value)

参数

返回值

  • 给定日期/时间的分钟开始。 DateTime。

示例

SELECT
    toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
    toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical

结果

Row 1:
──────
toStartOfMinute(toDateTime('2023-04-21 10:20:30')):           2023-04-21 10:20:00
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8)): 2023-04-21 10:20:00

toStartOfSecond​

截断亚秒。

语法

toStartOfSecond(value, [timezone])

参数

  • value — 日期和时间。 DateTime64。
  • timezone — 返回值的时区（可选）。 如果未指定，则该函数使用 value 参数的时区。 字符串。

返回值

示例

不带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);

结果

┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘

带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');

结果

┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│                2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘

另请参阅

  • 时区服务器配置参数。

toStartOfMillisecond​

将带时间的日期向下舍入到毫秒的开始。

语法

toStartOfMillisecond(value, [timezone])

参数

  • value — 日期和时间。 DateTime64。
  • timezone — 返回值的时区（可选）。 如果未指定，则该函数使用 value 参数的时区。 字符串。

返回值

示例

不带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);

结果

┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘

带时区的查询

┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│               2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘

结果

┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│                     2020-01-01 12:20:30.999 │
└─────────────────────────────────────────────┘

toStartOfMicrosecond​

将带时间的日期向下舍入到微秒的开始。

语法

toStartOfMicrosecond(value, [timezone])

参数

  • value — 日期和时间。 DateTime64。
  • timezone — 返回值的时区（可选）。 如果未指定，则该函数使用 value 参数的时区。 字符串。

返回值

示例

不带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);

结果

┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘

带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');

结果

┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│               2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘

另请参阅

  • 时区服务器配置参数。

toStartOfNanosecond​

将带时间的日期向下舍入到纳秒的开始。

语法

toStartOfNanosecond(value, [timezone])

参数

  • value — 日期和时间。 DateTime64。
  • timezone — 返回值的时区（可选）。 如果未指定，则该函数使用 value 参数的时区。 字符串。

返回值

示例

不带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);

结果

┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘

带时区的查询

WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');

结果

┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│              2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘

另请参阅

  • 时区服务器配置参数。

toStartOfFiveMinutes​

将带时间的日期向下舍入到五分钟间隔的开始。

语法

toStartOfFiveMinutes(value)

参数

返回值

  • 给定日期/时间的五分钟间隔的开始。 DateTime。

示例

SELECT
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

结果

Row 1:
──────
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00

toStartOfTenMinutes​

将带时间的日期向下舍入到十分钟间隔的开始。

语法

toStartOfTenMinutes(value)

参数

返回值

  • 给定日期/时间的十分钟间隔的开始。 DateTime。

示例

SELECT
    toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

结果

Row 1:
──────
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:10:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00

toStartOfFifteenMinutes​

将带时间的日期向下舍入到十五分钟间隔的开始。

语法

toStartOfFifteenMinutes(value)

参数

返回值

  • 给定日期/时间的十五分钟间隔的开始。 DateTime。

示例

SELECT
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
    toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical

结果

Row 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00

toStartOfInterval​

此函数使用 toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]) 语法概括了其他 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) 相同的结果。

计算是相对于特定的时间点执行的

间隔开始
YEAR0 年
QUARTER1900 年 Q1
MONTH1900 年 1 月
WEEK1970 年，第 1 周 (01-05)
DAY1970-01-01
HOUR(*)
MINUTE1970-01-01 00:00:00
SECOND1970-01-01 00:00:00
MILLISECOND1970-01-01 00:00:00
MICROSECOND1970-01-01 00:00:00
NANOSECOND1970-01-01 00:00:00

(*) 小时间隔是特殊的：计算始终相对于当天 00:00:00（午夜）执行。 因此，只有 1 到 23 之间的小时值才有用。

如果指定了 unit WEEK，则 toStartOfInterval 假定周从星期一开始。 请注意，此行为与函数 toStartOfWeek 的行为不同，在函数 toStartOfWeek 中，周默认从星期日开始。

语法

toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])

别名： time_bucket, date_bin。

第二个重载模拟 TimescaleDB 的 time_bucket() 函数，以及 PostgreSQL 的 date_bin() 函数，例如

SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'));

结果

┌───toStartOfInterval(...)─┐
│      2023-01-01 14:44:30 │
└──────────────────────────┘

另请参阅

toTime​

将带时间的日期转换为某个固定的日期，同时保留时间。

语法

toTime(date[,timezone])

参数

返回值

  • DateTime，其日期等于 1970-01-02，同时保留时间。 DateTime。
注意

如果 date 输入参数包含亚秒组件，则它们将在返回的秒精度的 DateTime 值中被删除。

示例

查询

SELECT toTime(toDateTime64('1970-12-10 01:20:30.3000',3)) AS result, toTypeName(result);

结果

┌──────────────result─┬─toTypeName(result)─┐
│ 1970-01-02 01:20:30 │ DateTime           │
└─────────────────────┴────────────────────┘

toRelativeYearNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的年数。

语法

toRelativeYearNum(date)

参数

返回值

  • 自过去某个固定参考点以来的年数。 UInt16。

示例

查询

SELECT
    toRelativeYearNum(toDate('2002-12-08')) AS y1,
    toRelativeYearNum(toDate('2010-10-26')) AS y2

结果

┌───y1─┬───y2─┐
│ 2002 │ 2010 │
└──────┴──────┘

toRelativeQuarterNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的季度数。

语法

toRelativeQuarterNum(date)

参数

返回值

  • 自过去某个固定参考点以来的季度数。 UInt32。

示例

查询

SELECT
  toRelativeQuarterNum(toDate('1993-11-25')) AS q1,
  toRelativeQuarterNum(toDate('2005-01-05')) AS q2

结果

┌───q1─┬───q2─┐
│ 7975 │ 8020 │
└──────┴──────┘

toRelativeMonthNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的月数。

语法

toRelativeMonthNum(date)

参数

返回值

  • 自过去某个固定参考点以来的月数。 UInt32。

示例

查询

SELECT
  toRelativeMonthNum(toDate('2001-04-25')) AS m1,
  toRelativeMonthNum(toDate('2009-07-08')) AS m2

结果

┌────m1─┬────m2─┐
│ 24016 │ 24115 │
└───────┴───────┘

toRelativeWeekNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的周数。

语法

toRelativeWeekNum(date)

参数

返回值

  • 自过去某个固定参考点以来的周数。 UInt32。

示例

查询

SELECT
  toRelativeWeekNum(toDate('2000-02-29')) AS w1,
  toRelativeWeekNum(toDate('2001-01-12')) AS w2

结果

┌───w1─┬───w2─┐
│ 1574 │ 1619 │
└──────┴──────┘

toRelativeDayNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的天数。

语法

toRelativeDayNum(date)

参数

返回值

  • 自过去某个固定参考点以来的天数。 UInt32。

示例

查询

SELECT
  toRelativeDayNum(toDate('1993-10-05')) AS d1,
  toRelativeDayNum(toDate('2000-09-20')) AS d2

结果

┌───d1─┬────d2─┐
│ 8678 │ 11220 │
└──────┴───────┘

toRelativeHourNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的小时数。

语法

toRelativeHourNum(date)

参数

返回值

  • 自过去某个固定参考点以来的小时数。 UInt32。

示例

查询

SELECT
  toRelativeHourNum(toDateTime('1993-10-05 05:20:36')) AS h1,
  toRelativeHourNum(toDateTime('2000-09-20 14:11:29')) AS h2

结果

┌─────h1─┬─────h2─┐
│ 208276 │ 269292 │
└────────┴────────┘

toRelativeMinuteNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的分钟数。

语法

toRelativeMinuteNum(date)

参数

返回值

  • 自过去某个固定参考点以来的分钟数。 UInt32。

示例

查询

SELECT
  toRelativeMinuteNum(toDateTime('1993-10-05 05:20:36')) AS m1,
  toRelativeMinuteNum(toDateTime('2000-09-20 14:11:29')) AS m2

结果

┌───────m1─┬───────m2─┐
│ 12496580 │ 16157531 │
└──────────┴──────────┘

toRelativeSecondNum​

将日期或带时间的日期转换为自过去某个固定点以来经过的秒数。

语法

toRelativeSecondNum(date)

参数

返回值

  • 自过去某个固定参考点以来的秒数。 UInt32。

示例

查询

SELECT
  toRelativeSecondNum(toDateTime('1993-10-05 05:20:36')) AS s1,
  toRelativeSecondNum(toDateTime('2000-09-20 14:11:29')) AS s2

结果

┌────────s1─┬────────s2─┐
│ 749794836 │ 969451889 │
└───────────┴───────────┘

toISOYear​

将日期或带时间的日期转换为 ISO 年份，类型为 UInt16 数字。

语法

toISOYear(value)

参数

返回值

  • 输入值转换为 ISO 年份数字。 UInt16。

示例

查询

SELECT
  toISOYear(toDate('2024/10/02')) as year1,
  toISOYear(toDateTime('2024-10-02 01:30:00')) as year2

结果

┌─year1─┬─year2─┐
│  2024 │  2024 │
└───────┴───────┘

toISOWeek​

将日期或带时间的日期转换为包含 ISO 周数的 UInt8 数字。

语法

toISOWeek(value)

参数

  • value — 带有日期或带时间的数值。

返回值

  • value 转换为当前的 ISO 周数。 UInt8。

示例

查询

SELECT
  toISOWeek(toDate('2024/10/02')) AS week1,
  toISOWeek(toDateTime('2024/10/02 01:30:00')) AS week2

响应

┌─week1─┬─week2─┐
│    40 │    40 │
└───────┴───────┘

toWeek​

此函数返回日期或日期时间的周数。 toWeek() 的双参数形式允许您指定周是否从星期日或星期一开始，以及返回值应在 0 到 53 还是 1 到 53 的范围内。如果省略 mode 参数，则默认模式为 0。

toISOWeek() 是一个兼容性函数，等效于 toWeek(date,3)。

下表描述了 mode 参数的工作方式。

模式一周的第一天范围第 1 周是本年度的第一个周...
0星期日0-53在本年度内包含星期日
1星期一0-53在本年度内包含 4 天或更多天
2星期日1-53在本年度内包含星期日
3星期一1-53在本年度内包含 4 天或更多天
4星期日0-53在本年度内包含 4 天或更多天
5星期一0-53在本年度内包含星期一
6星期日1-53在本年度内包含 4 天或更多天
7星期一1-53在本年度内包含星期一
8星期日1-53包含 1 月 1 日
9星期一1-53包含 1 月 1 日

对于模式值为“在本年度内包含 4 天或更多天”的情况，周数按照 ISO 8601:1988 标准编号

  • 如果包含 1 月 1 日的周在新的一年中有 4 天或更多天，则它是第 1 周。

  • 否则，它是上一年的最后一周，下一周是第 1 周。

对于模式值为“包含 1 月 1 日”的情况，包含 1 月 1 日的周是第 1 周。 这与该周在新的一年中包含多少天无关，即使它只包含一天。 也就是说，如果 12 月的最后一周包含下一年的 1 月 1 日，那么它将是下一年的第 1 周。

语法

toWeek(t[, mode[, time_zone]])

别名: WEEK

参数

  • t – 日期或 DateTime。
  • mode – 可选参数，取值范围为 [0,9]，默认为 0。
  • Timezone – 可选参数，其行为类似于任何其他转换函数。

第一个参数也可以指定为 String，格式受 parseDateTime64BestEffort() 支持。 仅出于与某些第三方工具期望的 MySQL 兼容性的原因，才存在字符串参数支持。 由于字符串参数支持将来可能会依赖于新的 MySQL 兼容性设置，并且由于字符串解析通常很慢，因此建议不要使用它。

示例

SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9;
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │    52 │    52 │     1 │
└────────────┴───────┴───────┴───────┘

toYearWeek​

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

mode 参数的工作方式与 toWeek() 的 mode 参数相同。 对于单参数语法，使用模式值 0。

toISOYear() 是一个兼容性函数，等效于 intDiv(toYearWeek(date,3),100)。

危险

toYearWeek() 返回的周数可能与 toWeek() 返回的不同。 toWeek() 始终在给定年份的上下文中返回周数，并且在 toWeek() 返回 0 的情况下，toYearWeek() 返回与上一年的最后一周对应的值。 请参阅下面的示例中的 prev_yearWeek。

语法

toYearWeek(t[, mode[, timezone]])

别名: YEARWEEK

第一个参数也可以指定为 String，格式受 parseDateTime64BestEffort() 支持。 仅出于与某些第三方工具期望的 MySQL 兼容性的原因，才存在字符串参数支持。 由于字符串参数支持将来可能会依赖于新的 MySQL 兼容性设置，并且由于字符串解析通常很慢，因此建议不要使用它。

示例

SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek;
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │    201652 │    201652 │    201701 │        202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘

toDaysSinceYearZero​

对于给定的日期，返回自 公元 0 年 1 月 1 日 以来经过的天数，该日期基于 ISO 8601 定义的普罗列普特 Gregorian 历法。 此计算与 MySQL 的 TO_DAYS() 函数相同。

语法

toDaysSinceYearZero(date[, time_zone])

别名: TO_DAYS

参数

返回值

自 0000-01-01 日期以来经过的天数。 UInt32。

示例

SELECT toDaysSinceYearZero(toDate('2023-09-08'));

结果

┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│                                     713569 │
└────────────────────────────────────────────┘

另请参阅

fromDaysSinceYearZero​

对于给定的自 公元 0 年 1 月 1 日 以来经过的天数，返回 ISO 8601 定义的普罗列普特 Gregorian 历法 中的对应日期。 此计算与 MySQL 的 FROM_DAYS() 函数相同。

如果结果无法在 Date 类型的范围内表示，则结果未定义。

语法

fromDaysSinceYearZero(days)

别名: FROM_DAYS

参数

  • days — 自公元 0 年以来经过的天数。

返回值

与自公元 0 年以来经过的天数对应的日期。 Date。

示例

SELECT fromDaysSinceYearZero(739136), fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08')));

结果

┌─fromDaysSinceYearZero(739136)─┬─fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08')))─┐
│                    2023-09-08 │                                                       2023-09-08 │
└───────────────────────────────┴──────────────────────────────────────────────────────────────────┘

另请参阅

fromDaysSinceYearZero32​

类似于 fromDaysSinceYearZero，但返回 Date32。

age​

返回 startdate 和 enddate 之间差异的 unit 组件。 差异计算使用 1 纳秒的精度。 例如，2021-12-29 和 2022-01-01 之间的差异对于 day 单位是 3 天，对于 month 单位是 0 个月，对于 year 单位是 0 年。

对于 age 的替代方案，请参阅函数 date_diff。

语法

age('unit', startdate, enddate, [timezone])

参数

  • unit — 结果的时间间隔类型。 String。 可能的值

    • nanosecond, nanoseconds, ns
    • microsecond, microseconds, us, u
    • millisecond, milliseconds, ms
    • second, seconds, ss, s
    • minute, minutes, mi, n
    • hour, hours, hh, h
    • day, days, dd, d
    • week, weeks, wk, ww
    • month, months, mm, m
    • quarter, quarters, qq, q
    • year, years, yyyy, yy

  • startdate — 要减去的第一个时间值（被减数）。 Date, Date32, DateTime 或 DateTime64。

  • enddate — 要从中减去第二个时间值（减数）。 Date, Date32, DateTime 或 DateTime64。

  • timezone — 时区名称 (可选)。 如果指定，则应用于 startdate 和 enddate。 如果未指定，则使用 startdate 和 enddate 的时区。 如果它们不相同，则结果未指定。 String。

返回值

以 unit 表示的 enddate 和 startdate 之间的差值。 Int。

示例

SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'));

结果

┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│                                                                                24 │
└───────────────────────────────────────────────────────────────────────────────────┘
SELECT
    toDate('2022-01-01') AS e,
    toDate('2021-12-29') AS s,
    age('day', s, e) AS day_age,
    age('month', s, e) AS month__age,
    age('year', s, e) AS year_age;

结果

┌──────────e─┬──────────s─┬─day_age─┬─month__age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │       3 │          0 │        0 │
└────────────┴────────────┴─────────┴────────────┴──────────┘

date_diff​

返回在 startdate 和 enddate 之间跨越的指定 unit 边界的计数。 差异使用相对单位计算，例如，2021-12-29 和 2022-01-01 之间的差异对于单位 day 是 3 天（请参阅 toRelativeDayNum），对于单位 month 是 1 个月（请参阅 toRelativeMonthNum），对于单位 year 是 1 年（请参阅 toRelativeYearNum）。

如果指定了单位 week，则 date_diff 假定周从星期一开始。 请注意，此行为与函数 toWeek() 的行为不同，在 toWeek() 中，周默认从星期日开始。

对于 date_diff 的替代方案，请参阅函数 age。

语法

date_diff('unit', startdate, enddate, [timezone])

别名: dateDiff, DATE_DIFF, timestampDiff, timestamp_diff, TIMESTAMP_DIFF。

参数

  • unit — 结果的时间间隔类型。 String。 可能的值

    • nanosecond, nanoseconds, ns
    • microsecond, microseconds, us, u
    • millisecond, milliseconds, ms
    • second, seconds, ss, s
    • minute, minutes, mi, n
    • hour, hours, hh, h
    • day, days, dd, d
    • week, weeks, wk, ww
    • month, months, mm, m
    • quarter, quarters, qq, q
    • year, years, yyyy, yy

  • startdate — 要减去的第一个时间值（被减数）。 Date, Date32, DateTime 或 DateTime64。

  • enddate — 要从中减去第二个时间值（减数）。 Date, Date32, DateTime 或 DateTime64。

  • timezone — 时区名称 (可选)。 如果指定，则应用于 startdate 和 enddate。 如果未指定，则使用 startdate 和 enddate 的时区。 如果它们不相同，则结果未指定。 String。

返回值

以 unit 表示的 enddate 和 startdate 之间的差值。 Int。

示例

SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'));

结果

┌─dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'))─┐
│                                                                                     25 │
└────────────────────────────────────────────────────────────────────────────────────────┘
SELECT
    toDate('2022-01-01') AS e,
    toDate('2021-12-29') AS s,
    dateDiff('day', s, e) AS day_diff,
    dateDiff('month', s, e) AS month__diff,
    dateDiff('year', s, e) AS year_diff;

结果

┌──────────e─┬──────────s─┬─day_diff─┬─month__diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │        3 │           1 │         1 │
└────────────┴────────────┴──────────┴─────────────┴───────────┘

date_trunc​

将日期和时间数据截断为日期的指定部分。

语法

date_trunc(unit, value[, timezone])

别名: dateTrunc。

参数

  • unit — 用于截断结果的时间间隔类型。 字符串字面量。 可能的值

    • nanosecond - 仅与 DateTime64 兼容
    • microsecond - 仅与 DateTime64 兼容
    • milisecond - 仅与 DateTime64 兼容
    • second
    • minute
    • hour
    • day
    • week
    • month
    • quarter
    • year

    unit 参数不区分大小写。

  • value — 日期和时间。 Date, Date32, DateTime 或 DateTime64。

  • timezone — 返回值的 时区名称 (可选)。 如果未指定，则该函数使用 value 参数的时区。 String。

返回值

  • 截断为日期的指定部分的值。 DateTime。

示例

不带时区的查询

SELECT now(), date_trunc('hour', now());

结果

┌───────────────now()─┬─date_trunc('hour', now())─┐
│ 2020-09-28 10:40:45 │       2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘

使用指定的时区查询

SELECT now(), date_trunc('hour', now(), 'Asia/Istanbul');

结果

┌───────────────now()─┬─date_trunc('hour', now(), 'Asia/Istanbul')─┐
│ 2020-09-28 10:46:26 │                        2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘

另请参阅

date_add​

将时间间隔或日期间隔添加到提供的日期或带时间的日期。

如果加法运算导致值超出数据类型的范围，则结果未定义。

语法

date_add(unit, value, date)

备选语法

date_add(date, INTERVAL value unit)

别名: dateAdd, DATE_ADD。

参数

  • unit — 要添加的时间间隔类型。 注意：这不是 String，因此不能用引号引起来。 可能的值

    • second
    • minute
    • hour
    • day
    • week
    • month
    • quarter
    • year

  • value — 要添加的时间间隔的值。 Int。

  • date — 要向其添加 value 的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

返回值

通过将以 unit 表示的 value 添加到 date 而获得的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

SELECT date_add(YEAR, 3, toDate('2018-01-01'));

结果

┌─plus(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                    2021-01-01 │
└───────────────────────────────────────────────┘
SELECT date_add(toDate('2018-01-01'), INTERVAL 3 YEAR);

结果

┌─plus(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                    2021-01-01 │
└───────────────────────────────────────────────┘

另请参阅

date_sub​

从提供的日期或带时间的日期中减去时间间隔或日期间隔。

如果减法运算导致值超出数据类型的范围，则结果未定义。

语法

date_sub(unit, value, date)

备选语法

date_sub(date, INTERVAL value unit)

别名: dateSub, DATE_SUB。

参数

  • unit — 要减去的时间间隔类型。 注意：这不是 String，因此不能用引号引起来。

    可能的值

    • second
    • minute
    • hour
    • day
    • week
    • month
    • quarter
    • year

  • value — 要减去的时间间隔的值。 Int。

  • date — 要从中减去 value 的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

返回值

通过从 date 中减去以 unit 表示的 value 而获得的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

SELECT date_sub(YEAR, 3, toDate('2018-01-01'));

结果

┌─minus(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                     2015-01-01 │
└────────────────────────────────────────────────┘
SELECT date_sub(toDate('2018-01-01'), INTERVAL 3 YEAR);

结果

┌─minus(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                     2015-01-01 │
└────────────────────────────────────────────────┘

另请参阅

timestamp_add​

将指定的时间值与提供的日期或日期时间值相加。

如果加法运算导致值超出数据类型的范围，则结果未定义。

语法

timestamp_add(date, INTERVAL value unit)

别名: timeStampAdd, TIMESTAMP_ADD。

参数

  • date — 日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

  • value — 要添加的时间间隔的值。 Int。

  • unit — 要添加的时间间隔类型。 String。 可能的值

    • second
    • minute
    • hour
    • day
    • week
    • month
    • quarter
    • year

返回值

将以 unit 表示的指定 value 添加到 date 后得到的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

select timestamp_add(toDate('2018-01-01'), INTERVAL 3 MONTH);

结果

┌─plus(toDate('2018-01-01'), toIntervalMonth(3))─┐
│                                     2018-04-01 │
└────────────────────────────────────────────────┘

timestamp_sub​

从提供的日期或带时间的日期中减去时间间隔。

如果减法运算导致值超出数据类型的范围，则结果未定义。

语法

timestamp_sub(unit, value, date)

别名: timeStampSub, TIMESTAMP_SUB。

参数

  • unit — 要减去的时间间隔类型。 String。 可能的值

    • second
    • minute
    • hour
    • day
    • week
    • month
    • quarter
    • year

  • value — 要减去的时间间隔的值。 Int。

  • date — 日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

返回值

通过从 date 中减去以 unit 表示的 value 而获得的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

select timestamp_sub(MONTH, 5, toDateTime('2018-12-18 01:02:03'));

结果

┌─minus(toDateTime('2018-12-18 01:02:03'), toIntervalMonth(5))─┐
│                                          2018-07-18 01:02:03 │
└──────────────────────────────────────────────────────────────┘

addDate​

将时间间隔添加到提供的日期、带时间的日期或 String 编码的日期/带时间的日期。

如果加法运算导致值超出数据类型的范围，则结果未定义。

语法

addDate(date, interval)

参数

返回值

通过将 interval 添加到 date 而获得的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR);

结果

┌─addDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                       2021-01-01 │
└──────────────────────────────────────────────────┘

别名: ADDDATE

另请参阅

subDate​

从提供的日期、带时间的日期或 String 编码的日期/带时间的日期中减去时间间隔。

如果减法运算导致值超出数据类型的范围，则结果未定义。

语法

subDate(date, interval)

参数

返回值

通过从 date 中减去 interval 而获得的日期或带时间的日期。 Date, Date32, DateTime 或 DateTime64。

示例

SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR);

结果

┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│                                       2015-01-01 │
└──────────────────────────────────────────────────┘

别名: SUBDATE

另请参阅

now​

返回查询分析时刻的当前日期和时间。 该函数是一个常量表达式。

别名: current_timestamp。

语法

now([timezone])

参数

返回值

示例

不带时区的查询

SELECT now();

结果

┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘

使用指定的时区查询

SELECT now('Asia/Istanbul');

结果

┌─now('Asia/Istanbul')─┐
│  2020-10-17 10:42:23 │
└──────────────────────┘

now64​

返回查询分析时刻的具有亚秒精度的当前日期和时间。 该函数是一个常量表达式。

语法

now64([scale], [timezone])

参数

  • scale - 刻度大小（精度）：10-precision 秒。 有效范围：[ 0 : 9 ]。 通常使用 - 3（默认）（毫秒）、6（微秒）、9（纳秒）。
  • timezone — 返回值的 时区名称 (可选)。 String。

返回值

  • 具有亚秒精度的当前日期和时间。 DateTime64。

示例

SELECT now64(), now64(9, 'Asia/Istanbul');

结果

┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘

nowInBlock​

返回处理每个数据块时刻的当前日期和时间。 与函数 now 相比，它不是一个常量表达式，并且对于长时间运行的查询，返回的值在不同的块中将有所不同。

在长时间运行的 INSERT SELECT 查询中使用此函数生成当前时间是有意义的。

语法

nowInBlock([timezone])

参数

返回值

  • 处理每个数据块时刻的当前日期和时间。 DateTime。

示例

SELECT
    now(),
    nowInBlock(),
    sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock

结果

┌───────────────now()─┬────────nowInBlock()─┬─sleep(1)─┐
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:19 │        0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:20 │        0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:21 │        0 │
└─────────────────────┴─────────────────────┴──────────┘

today​

返回查询分析时刻的当前日期。 它与 ‘toDate(now())’ 相同，并且具有别名：curdate, current_date。

语法

today()

参数

  • 无

返回值

示例

查询

SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty

结果:

在 2024 年 3 月 3 日运行上面的查询将返回以下响应

┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃      today ┃    curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2024-03-03 │ 2024-03-03 │   2024-03-03 │
└────────────┴────────────┴──────────────┘

yesterday​

接受零个参数，并在查询分析的某个时刻返回昨天的日期。 与 ‘today() - 1’ 相同。

timeSlot​

将时间舍入到半小时长度间隔的开始。

语法

timeSlot(time[, time_zone])

参数

  • time — 要舍入到半小时长度间隔开始的时间。 DateTime/Date32/DateTime64。
  • time_zone — String 类型常量值或表示时区的表达式。 String。
注意

虽然此函数可以接受扩展类型 Date32 和 DateTime64 的值作为参数，但如果传递超出正常范围的时间（Date 为 1970 年到 2149 年 / DateTime 为 2106 年），将产生错误的结果。

返回类型

  • 返回舍入到半小时长度间隔开始的时间。 DateTime。

示例

查询

SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'));

结果

┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│                                2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘

toYYYYMM​

将日期或带时间的日期转换为包含年份和月份编号的 UInt32 数字 (YYYY * 100 + MM)。 接受第二个可选的时区参数。 如果提供，则时区必须是字符串常量。

此函数与函数 YYYYMMDDToDate() 相反。

示例

SELECT
    toYYYYMM(now(), 'US/Eastern')

结果

┌─toYYYYMM(now(), 'US/Eastern')─┐
│                        202303 │
└───────────────────────────────┘

toYYYYMMDD​

将日期或带时间的日期转换为包含年份和月份编号的 UInt32 数字 (YYYY * 10000 + MM * 100 + DD)。 接受第二个可选的时区参数。 如果提供，则时区必须是字符串常量。

示例

SELECT toYYYYMMDD(now(), 'US/Eastern')

结果

┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│                        20230302 │
└─────────────────────────────────┘

toYYYYMMDDhhmmss​

将日期或带时间的日期转换为包含年份和月份编号的 UInt64 数字 (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss)。 接受第二个可选的时区参数。 如果提供，则时区必须是字符串常量。

示例

SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')

结果

┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│                        20230302112209 │
└───────────────────────────────────────┘

YYYYMMDDToDate​

将包含年份、月份和日期编号的数字转换为 Date。

此函数与函数 toYYYYMMDD() 相反。

如果输入未编码有效的 Date 值，则输出未定义。

语法

YYYYMMDDToDate(yyyymmdd);

参数

返回值

  • 从参数创建的日期。 Date。

示例

SELECT YYYYMMDDToDate(20230911);

结果

┌─toYYYYMMDD(20230911)─┐
│           2023-09-11 │
└──────────────────────┘

YYYYMMDDToDate32​

类似于函数 YYYYMMDDToDate()，但生成 Date32。

YYYYMMDDhhmmssToDateTime​

将包含年份、月份、日期、小时、分钟和秒数的数字转换为 DateTime。

如果输入未编码有效的 DateTime 值，则输出未定义。

此函数与函数 toYYYYMMDDhhmmss() 相反。

语法

YYYYMMDDhhmmssToDateTime(yyyymmddhhmmss[, timezone]);

参数

  • yyyymmddhhmmss - 表示年份、月份和日期的数字。 Integer, Float 或 Decimal。
  • timezone - 返回值的 时区 (可选)。

返回值

  • 从参数创建的带时间的日期。 DateTime。

示例

SELECT YYYYMMDDToDateTime(20230911131415);

结果

┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│                           2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘

YYYYMMDDhhmmssToDateTime64​

类似于函数 YYYYMMDDhhmmssToDate()，但生成 DateTime64。

在 timezone 参数之后接受一个额外的可选 precision 参数。

changeYear​

更改日期或日期时间的年份组成部分。

语法


changeYear(date_or_datetime, value)

参数

返回值

  • 与 date_or_datetime 相同的类型。

示例

SELECT changeYear(toDate('1999-01-01'), 2000), changeYear(toDateTime64('1999-01-01 00:00:00.000', 3), 2000);

结果

┌─changeYear(toDate('1999-01-01'), 2000)─┬─changeYear(toDateTime64('1999-01-01 00:00:00.000', 3), 2000)─┐
│                             2000-01-01 │                                      2000-01-01 00:00:00.000 │
└────────────────────────────────────────┴──────────────────────────────────────────────────────────────┘

changeMonth​

更改日期或日期时间的月份组成部分。

语法

changeMonth(date_or_datetime, value)

参数

返回值

  • 返回与 date_or_datetime 相同类型的值。

示例

SELECT changeMonth(toDate('1999-01-01'), 2), changeMonth(toDateTime64('1999-01-01 00:00:00.000', 3), 2);

结果

┌─changeMonth(toDate('1999-01-01'), 2)─┬─changeMonth(toDateTime64('1999-01-01 00:00:00.000', 3), 2)─┐
│                           1999-02-01 │                                    1999-02-01 00:00:00.000 │
└──────────────────────────────────────┴────────────────────────────────────────────────────────────┘

changeDay​

更改日期或日期时间的天组成部分。

语法

changeDay(date_or_datetime, value)

参数

返回值

  • 返回与 date_or_datetime 相同类型的值。

示例

SELECT changeDay(toDate('1999-01-01'), 5), changeDay(toDateTime64('1999-01-01 00:00:00.000', 3), 5);

结果

┌─changeDay(toDate('1999-01-01'), 5)─┬─changeDay(toDateTime64('1999-01-01 00:00:00.000', 3), 5)─┐
│                         1999-01-05 │                                  1999-01-05 00:00:00.000 │
└────────────────────────────────────┴──────────────────────────────────────────────────────────┘

changeHour​

更改日期或日期时间的小时组成部分。

语法

changeHour(date_or_datetime, value)

参数

返回值

  • 返回与 date_or_datetime 相同类型的值。 如果输入是 Date，则返回 DateTime。 如果输入是 Date32，则返回 DateTime64。

示例

SELECT changeHour(toDate('1999-01-01'), 14), changeHour(toDateTime64('1999-01-01 00:00:00.000', 3), 14);

结果

┌─changeHour(toDate('1999-01-01'), 14)─┬─changeHour(toDateTime64('1999-01-01 00:00:00.000', 3), 14)─┐
│                  1999-01-01 14:00:00 │                                    1999-01-01 14:00:00.000 │
└──────────────────────────────────────┴────────────────────────────────────────────────────────────┘

changeMinute​

更改日期或日期时间的分钟组成部分。

语法

changeMinute(date_or_datetime, value)

参数

返回值

  • 返回与 date_or_datetime 相同类型的值。 如果输入是 Date，则返回 DateTime。 如果输入是 Date32，则返回 DateTime64。

示例

    SELECT changeMinute(toDate('1999-01-01'), 15), changeMinute(toDateTime64('1999-01-01 00:00:00.000', 3), 15);

结果

┌─changeMinute(toDate('1999-01-01'), 15)─┬─changeMinute(toDateTime64('1999-01-01 00:00:00.000', 3), 15)─┐
│                    1999-01-01 00:15:00 │                                      1999-01-01 00:15:00.000 │
└────────────────────────────────────────┴──────────────────────────────────────────────────────────────┘

changeSecond​

更改日期或日期时间的秒组成部分。

语法

changeSecond(date_or_datetime, value)

参数

返回值

  • 返回与 date_or_datetime 相同类型的值。 如果输入是 Date，则返回 DateTime。 如果输入是 Date32，则返回 DateTime64。

示例

SELECT changeSecond(toDate('1999-01-01'), 15), changeSecond(toDateTime64('1999-01-01 00:00:00.000', 3), 15);

结果

┌─changeSecond(toDate('1999-01-01'), 15)─┬─changeSecond(toDateTime64('1999-01-01 00:00:00.000', 3), 15)─┐
│                    1999-01-01 00:00:15 │                                      1999-01-01 00:00:15.000 │
└────────────────────────────────────────┴──────────────────────────────────────────────────────────────┘

addYears​

为日期、日期时间或字符串编码的日期/日期时间添加指定的年数。

语法

addYears(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addYears(date, 1) AS add_years_with_date,
    addYears(date_time, 1) AS add_years_with_date_time,
    addYears(date_time_string, 1) AS add_years_with_date_time_string
┌─add_years_with_date─┬─add_years_with_date_time─┬─add_years_with_date_time_string─┐
│          2025-01-01 │      2025-01-01 00:00:00 │         2025-01-01 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

addQuarters​

为日期、日期时间或字符串编码的日期/日期时间添加指定的季度数。

语法

addQuarters(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addQuarters(date, 1) AS add_quarters_with_date,
    addQuarters(date_time, 1) AS add_quarters_with_date_time,
    addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string
┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│             2024-04-01 │         2024-04-01 00:00:00 │            2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘

addMonths​

为日期、日期时间或字符串编码的日期/日期时间添加指定的月数。

语法

addMonths(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMonths(date, 6) AS add_months_with_date,
    addMonths(date_time, 6) AS add_months_with_date_time,
    addMonths(date_time_string, 6) AS add_months_with_date_time_string
┌─add_months_with_date─┬─add_months_with_date_time─┬─add_months_with_date_time_string─┐
│           2024-07-01 │       2024-07-01 00:00:00 │          2024-07-01 00:00:00.000 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘

addWeeks​

为日期、日期时间或字符串编码的日期/日期时间添加指定的周数。

语法

addWeeks(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addWeeks(date, 5) AS add_weeks_with_date,
    addWeeks(date_time, 5) AS add_weeks_with_date_time,
    addWeeks(date_time_string, 5) AS add_weeks_with_date_time_string
┌─add_weeks_with_date─┬─add_weeks_with_date_time─┬─add_weeks_with_date_time_string─┐
│          2024-02-05 │      2024-02-05 00:00:00 │         2024-02-05 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

addDays​

为日期、日期时间或字符串编码的日期/日期时间添加指定的天数。

语法

addDays(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addDays(date, 5) AS add_days_with_date,
    addDays(date_time, 5) AS add_days_with_date_time,
    addDays(date_time_string, 5) AS add_days_with_date_time_string
┌─add_days_with_date─┬─add_days_with_date_time─┬─add_days_with_date_time_string─┐
│         2024-01-06 │     2024-01-06 00:00:00 │        2024-01-06 00:00:00.000 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘

addHours​

为日期、日期时间或字符串编码的日期/日期时间添加指定的天数。

语法

addHours(date, num)

参数

返回值 o

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addHours(date, 12) AS add_hours_with_date,
    addHours(date_time, 12) AS add_hours_with_date_time,
    addHours(date_time_string, 12) AS add_hours_with_date_time_string
┌─add_hours_with_date─┬─add_hours_with_date_time─┬─add_hours_with_date_time_string─┐
│ 2024-01-01 12:00:00 │      2024-01-01 12:00:00 │         2024-01-01 12:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘

addMinutes​

为日期、日期时间或字符串编码的日期/日期时间添加指定的分钟数。

语法

addMinutes(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMinutes(date, 20) AS add_minutes_with_date,
    addMinutes(date_time, 20) AS add_minutes_with_date_time,
    addMinutes(date_time_string, 20) AS add_minutes_with_date_time_string
┌─add_minutes_with_date─┬─add_minutes_with_date_time─┬─add_minutes_with_date_time_string─┐
│   2024-01-01 00:20:00 │        2024-01-01 00:20:00 │           2024-01-01 00:20:00.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

addSeconds​

为日期、日期时间或字符串编码的日期/日期时间添加指定的秒数。

语法

addSeconds(date, num)

参数

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addSeconds(date, 30) AS add_seconds_with_date,
    addSeconds(date_time, 30) AS add_seconds_with_date_time,
    addSeconds(date_time_string, 30) AS add_seconds_with_date_time_string
┌─add_seconds_with_date─┬─add_seconds_with_date_time─┬─add_seconds_with_date_time_string─┐
│   2024-01-01 00:00:30 │        2024-01-01 00:00:30 │           2024-01-01 00:00:30.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘

addMilliseconds​

为日期时间或字符串编码的日期时间添加指定的毫秒数。

语法

addMilliseconds(date_time, num)

参数

返回值

  • 返回 date_time 加上 num 毫秒。 DateTime64。

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMilliseconds(date_time, 1000) AS add_milliseconds_with_date_time,
    addMilliseconds(date_time_string, 1000) AS add_milliseconds_with_date_time_string
┌─add_milliseconds_with_date_time─┬─add_milliseconds_with_date_time_string─┐
│         2024-01-01 00:00:01.000 │                2024-01-01 00:00:01.000 │
└─────────────────────────────────┴────────────────────────────────────────┘

addMicroseconds​

为日期时间或字符串编码的日期时间添加指定的微秒数。

语法

addMicroseconds(date_time, num)

参数

返回值

  • 返回 date_time 加上 num 微秒。 DateTime64。

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addMicroseconds(date_time, 1000000) AS add_microseconds_with_date_time,
    addMicroseconds(date_time_string, 1000000) AS add_microseconds_with_date_time_string
┌─add_microseconds_with_date_time─┬─add_microseconds_with_date_time_string─┐
│      2024-01-01 00:00:01.000000 │             2024-01-01 00:00:01.000000 │
└─────────────────────────────────┴────────────────────────────────────────┘

addNanoseconds​

为日期时间或字符串编码的日期时间添加指定的微秒数。

语法

addNanoseconds(date_time, num)

参数

  • 为日期时间或字符串编码的日期时间添加指定的纳秒数。
  • date_time: 要添加指定纳秒数的日期时间。 DateTime/DateTime64, String。

返回值

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    addNanoseconds(date_time, 1000) AS add_nanoseconds_with_date_time,
    addNanoseconds(date_time_string, 1000) AS add_nanoseconds_with_date_time_string
┌─add_nanoseconds_with_date_time─┬─add_nanoseconds_with_date_time_string─┐
│  2024-01-01 00:00:00.000001000 │         2024-01-01 00:00:00.000001000 │
└────────────────────────────────┴───────────────────────────────────────┘

返回 date_time 加上 num 纳秒。 DateTime64。

addInterval​

语法

addInterval(interval_1, interval_2)

参数

  • 将间隔添加到另一个间隔或间隔元组。
  • interval_1: 第一个间隔或间隔元组。 interval, tuple(interval)。

返回值

  • interval_2: 要添加的第二个间隔。 interval。
注意

返回间隔元组。 tuple(interval)。

示例

查询

SELECT addInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT addInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT addInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);

结果

┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1)                                             │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1)                                                                │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3)                                             │
└─────────────────────────────────────────────────┘

相同类型的间隔将合并为单个间隔。 例如，如果传递 toIntervalDay(1) 和 toIntervalDay(2)，则结果将是 (3) 而不是 (1,1)。

addTupleOfIntervals​

语法

addTupleOfIntervals(interval_1, interval_2)

参数

返回值

  • intervals: 要添加到 date 的间隔元组。 tuple(interval)。

示例

查询

WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))

结果

┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│                                                                           2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘

返回添加了 intervals 的 date。 date/date32/datetime/datetime64。

subtractYears​

语法

subtractYears(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的年数。
  • date: 要从中减去指定年数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractYears(date, 1) AS subtract_years_with_date,
    subtractYears(date_time, 1) AS subtract_years_with_date_time,
    subtractYears(date_time_string, 1) AS subtract_years_with_date_time_string
┌─subtract_years_with_date─┬─subtract_years_with_date_time─┬─subtract_years_with_date_time_string─┐
│               2023-01-01 │           2023-01-01 00:00:00 │              2023-01-01 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

返回 date 减去 num 年。 日期/Date32/DateTime/DateTime64。

subtractQuarters​

语法

subtractQuarters(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的季度数。
  • date: 要从中减去指定季度数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractQuarters(date, 1) AS subtract_quarters_with_date,
    subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
    subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string
┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│                  2023-10-01 │              2023-10-01 00:00:00 │                 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘

返回 date 减去 num 季度。 日期/Date32/DateTime/DateTime64。

subtractMonths​

语法

subtractMonths(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的月数。
  • date: 要从中减去指定月数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMonths(date, 1) AS subtract_months_with_date,
    subtractMonths(date_time, 1) AS subtract_months_with_date_time,
    subtractMonths(date_time_string, 1) AS subtract_months_with_date_time_string
┌─subtract_months_with_date─┬─subtract_months_with_date_time─┬─subtract_months_with_date_time_string─┐
│                2023-12-01 │            2023-12-01 00:00:00 │               2023-12-01 00:00:00.000 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘

返回 date 减去 num 月。 日期/Date32/DateTime/DateTime64。

subtractWeeks​

语法

subtractWeeks(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的周数。
  • date: 要从中减去指定周数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractWeeks(date, 1) AS subtract_weeks_with_date,
    subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time,
    subtractWeeks(date_time_string, 1) AS subtract_weeks_with_date_time_string
 ┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┬─subtract_weeks_with_date_time_string─┐
 │               2023-12-25 │           2023-12-25 00:00:00 │              2023-12-25 00:00:00.000 │
 └──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

返回 date 减去 num 周。 日期/Date32/DateTime/DateTime64。

subtractDays​

语法

subtractDays(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的天数。
  • date: 要从中减去指定天数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractDays(date, 31) AS subtract_days_with_date,
    subtractDays(date_time, 31) AS subtract_days_with_date_time,
    subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string
┌─subtract_days_with_date─┬─subtract_days_with_date_time─┬─subtract_days_with_date_time_string─┐
│              2023-12-01 │          2023-12-01 00:00:00 │             2023-12-01 00:00:00.000 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘

返回 date 减去 num 天。 日期/Date32/DateTime/DateTime64。

subtractHours​

语法

subtractHours(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的小时数。
  • date: 要从中减去指定小时数的日期/日期时间。 日期/Date32/Datetime/Datetime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractHours(date, 12) AS subtract_hours_with_date,
    subtractHours(date_time, 12) AS subtract_hours_with_date_time,
    subtractHours(date_time_string, 12) AS subtract_hours_with_date_time_string
┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┬─subtract_hours_with_date_time_string─┐
│      2023-12-31 12:00:00 │           2023-12-31 12:00:00 │              2023-12-31 12:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘

返回 date 减去 num 小时。 日期/Date32/Datetime/DateTime64。

subtractMinutes​

语法

subtractMinutes(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的分钟数。
  • date: 要从中减去指定分钟数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMinutes(date, 30) AS subtract_minutes_with_date,
    subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
    subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string
┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┬─subtract_minutes_with_date_time_string─┐
│        2023-12-31 23:30:00 │             2023-12-31 23:30:00 │                2023-12-31 23:30:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

返回 date 减去 num 分钟。 日期/Date32/DateTime/DateTime64。

subtractSeconds​

语法

subtractSeconds(date, num)

参数

  • 从日期、日期时间或字符串编码的日期/日期时间中减去指定的秒数。
  • date: 要从中减去指定秒数的日期/日期时间。 日期/Date32/DateTime/DateTime64, String。

返回值

示例

WITH
    toDate('2024-01-01') AS date,
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractSeconds(date, 60) AS subtract_seconds_with_date,
    subtractSeconds(date_time, 60) AS subtract_seconds_with_date_time,
    subtractSeconds(date_time_string, 60) AS subtract_seconds_with_date_time_string
┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┬─subtract_seconds_with_date_time_string─┐
│        2023-12-31 23:59:00 │             2023-12-31 23:59:00 │                2023-12-31 23:59:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘

返回 date 减去 num 秒。 日期/Date32/DateTime/DateTime64。

subtractMilliseconds​

语法

subtractMilliseconds(date_time, num)

参数

  • 从日期时间或字符串编码的日期时间中减去指定的毫秒数。
  • date_time: 要从中减去指定毫秒数的日期时间。 DateTime/DateTime64, String。

返回值

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
    subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string
┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│              2023-12-31 23:59:59.000 │                     2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

返回 date_time 减去 num 毫秒。 DateTime64。

subtractMicroseconds​

语法

subtractMicroseconds(date_time, num)

参数

  • 从日期时间或字符串编码的日期时间中减去指定的微秒数。
  • date_time: 要从中减去指定微秒数的日期时间。 DateTime/DateTime64, String。

返回值

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractMicroseconds(date_time, 1000000) AS subtract_microseconds_with_date_time,
    subtractMicroseconds(date_time_string, 1000000) AS subtract_microseconds_with_date_time_string
┌─subtract_microseconds_with_date_time─┬─subtract_microseconds_with_date_time_string─┐
│           2023-12-31 23:59:59.000000 │                  2023-12-31 23:59:59.000000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘

返回 date_time 减去 num 微秒。 DateTime64。

subtractNanoseconds​

语法

subtractNanoseconds(date_time, num)

参数

  • 从日期时间或字符串编码的日期时间中减去指定的纳秒数。
  • date_time: 要从中减去指定纳秒数的日期时间。 DateTime/DateTime64, String。

返回值

示例

WITH
    toDateTime('2024-01-01 00:00:00') AS date_time,
    '2024-01-01 00:00:00' AS date_time_string
SELECT
    subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
    subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string
┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│       2023-12-31 23:59:59.999999000 │              2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘

返回 date_time 减去 num 纳秒。 DateTime64。

subtractInterval​

语法

subtractInterval(interval_1, interval_2)

参数

  • 将取反的间隔添加到另一个间隔或间隔元组。
  • interval_1: 第一个间隔或间隔元组。 interval, tuple(interval)。

返回值

  • interval_2: 要添加的第二个间隔。 interval。
注意

interval_2: 要取反的第二个间隔。 interval。

示例

查询

SELECT subtractInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT subtractInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT subtractInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);

结果

┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1)                                                 │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1)                                                                    │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1)                                                  │
└──────────────────────────────────────────────────────┘

相同类型的间隔将合并为单个间隔。 例如，如果传递 toIntervalDay(2) 和 toIntervalDay(1)，则结果将是 (1) 而不是 (2,1)。

subtractTupleOfIntervals​

语法

subtractTupleOfIntervals(interval_1, interval_2)

参数

返回值

  • intervals: 要从 date 中减去的间隔元组。 tuple(interval)。

示例

查询

WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))

结果

┌─subtractTupleOfIntervals(date, (toIntervalDay(1), toIntervalYear(1)))─┐
│                                                            2016-12-31 │
└───────────────────────────────────────────────────────────────────────┘

返回减去 intervals 的 date。 Date/Date32/DateTime/DateTime64。

timeSlots​

语法

timeSlots(StartTime, Duration,\[, Size\])

示例

SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600));
SELECT timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299);
SELECT timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0));

结果

┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐
│ ['2012-01-01 12:00:00','2012-01-01 12:30:00']               │
└─────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299)─┐
│ ['1980-12-12 20:56:13','1980-12-12 21:01:12','1980-12-12 21:06:11']     │
└─────────────────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))─┐
│ ['1980-12-12 20:56:13.0000','1980-12-12 21:01:12.0000','1980-12-12 21:06:11.0000']                        │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘

对于从 ‘StartTime’ 开始并持续 ‘Duration’ 秒的时间间隔，它返回时间点的数组，这些时间点由该间隔中的点向下舍入到 ‘Size’ 秒组成。 ‘Size’ 是一个可选参数，默认设置为 1800（30 分钟）。 这对于例如在相应的会话中搜索页面浏览量是必要的。 接受 DateTime 和 DateTime64 作为 ‘StartTime’ 参数。 对于 DateTime，‘Duration’ 和 ‘Size’ 参数必须是 UInt32。 对于 ‘DateTime64’，它们必须是 Decimal64。 返回 DateTime/DateTime64 数组（返回类型与 ‘StartTime’ 的类型匹配）。 对于 DateTime64，返回值的小数位数可能与 ‘StartTime’ 的小数位数不同 --- 采用所有给定参数中的最高小数位数。

formatDateTime​

根据给定的格式字符串格式化时间。 格式是一个常量表达式，因此单个结果列不能有多种格式。

formatDateTime 使用 MySQL datetime 格式样式，请参阅 https://dev.mysqlserver.cn/doc/refman/8.0/en/date-and-time-functions.html#function_date-format。

此函数的相反操作是 parseDateTime。

语法

formatDateTime(Time, Format[, Timezone])

别名: DATE_FORMAT。

返回值

根据确定的格式返回时间和日期值。

替换字段

使用替换字段，您可以为结果字符串定义模式。 “示例”列显示了 2018-01-02 22:33:44 的格式化结果。占位符示例
描述%a缩写的工作日名称 (Mon-Sun)
%b缩写的月份名称 (Jan-Dec)Jan
%c月份作为整数 (01-12)，请参阅下面的“注意 4”01
%C年份除以 100 并截断为整数 (00-99)20
%d月份中的日期，用零填充 (01-31)02
%D简短的 MM/DD/YY 日期，等效于 %m/%d/%y01/02/18
%e月份中的日期，用空格填充 (1-31)  2
%f小数秒，请参阅下面的“注意 1”和“注意 2”123456
%F简短的 YYYY-MM-DD 日期，等效于 %Y-%m-%d2018-01-02
%g两位数年份格式，与 ISO 8601 对齐，从四位数表示法缩写18
%GISO 周数的四位数年份格式，从 ISO 8601 定义 的基于周的年份计算，通常仅与 %V 一起使用2018
%h12 小时制的小时 (01-12)09
%H24 小时制的小时 (00-23)22
%i分钟 (00-59)33
%I12 小时制的小时 (01-12)10
%j一年中的第几天 (001-366)002
%k24 小时制的小时 (00-23)，请参阅“注意 4”14
%l12 小时制的小时 (01-12)，请参阅“注意 4”09
%m月份作为整数 (01-12)01
%M完整的月份名称 (January-December)，请参阅“注意 3”January
%n换行符 (‘’)
%pAM 或 PM 指示PM
%Q季度 (1-4)1
%r12 小时制 HH:MMAM/PM 时间，等效于 %h:%i %p10:30 PM
%R24 小时制 HH:MM时间，等效于 %H:%i22:33
%s秒 (00-59)44
%S秒 (00-59)44
%t水平制表符 (’)
%TISO 8601 时间格式 (HH:MM:SS)，等效于 %H:%i:%S22:33:44
%uISO 8601 工作日作为数字，星期一为 1 (1-7)2
%VISO 8601 周数 (01-53)01
%w工作日作为整数，星期日为 0 (0-6)2
%W完整的工作日名称 (Monday-Sunday)星期一
%y年份，最后两位数字 (00-99)18
%Y年份2018
%zUTC 的时间偏移，格式为 +HHMM 或 -HHMM-0500
%%百分号 %%

注意 1：在低于 v23.4 的 ClickHouse 版本中，如果格式化的值是 Date、Date32 或 DateTime（它们没有小数秒）或精度为 0 的 DateTime64，则 %f 打印单个零 (0)。 可以使用设置 formatdatetime_f_prints_single_zero = 1 恢复之前的行为。

注意 2：在低于 v25.1 的 ClickHouse 版本中，%f 打印的位数与 DateTime64 的小数位数指定的一样多，而不是固定的 6 位数字。 可以使用设置 formatdatetime_f_prints_scale_number_of_digits= 1 恢复之前的行为。

注意 3：在低于 v23.4 的 ClickHouse 版本中，%M 打印分钟 (00-59) 而不是完整的月份名称 (January-December)。 可以使用设置 formatdatetime_parsedatetime_m_is_month_name = 0 恢复之前的行为。

注意 4：在低于 v23.11 的 ClickHouse 版本中，函数 parseDateTime() 需要格式化程序 %c（月份）和 %l/%k（小时）的前导零，例如 07。 在更高版本中，可以省略前导零，例如 7。 可以使用设置 parsedatetime_parse_without_leading_zeros = 0 恢复之前的行为。 请注意，函数 formatDateTime() 默认情况下仍然为 %c 和 %l/%k 打印前导零，以避免破坏现有的用例。 可以通过设置 formatdatetime_format_without_leading_zeros = 1 来更改此行为。

示例

SELECT formatDateTime(toDate('2010-01-04'), '%g')

结果

┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10                                         │
└────────────────────────────────────────────┘
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')

结果

┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560                                                             │
└─────────────────────────────────────────────────────────────────────┘

此外，formatDateTime 函数可以接受第三个 String 参数，其中包含时区名称。 示例：Asia/Istanbul。 在这种情况下，时间将根据指定的时区进行格式化。

示例

SELECT
    now() AS ts,
    time_zone,
    formatDateTime(ts, '%T', time_zone) AS str_tz_time
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10

┌──────────────────ts─┬─time_zone─────────┬─str_tz_time─┐
│ 2023-09-08 19:13:40 │ Europe/Amsterdam  │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Andorra    │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Astrakhan  │ 23:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Athens     │ 22:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Belfast    │ 20:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Belgrade   │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Berlin     │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Bratislava │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Brussels   │ 21:13:40    │
│ 2023-09-08 19:13:40 │ Europe/Bucharest  │ 22:13:40    │
└─────────────────────┴───────────────────┴─────────────┘

另请参阅

formatDateTimeInJodaSyntax​

类似于 formatDateTime，不同之处在于它以 Joda 样式而不是 MySQL 样式格式化日期时间。 请参阅 https://joda-time.sourceforge.net/apidocs/org/joda/time/format/DateTimeFormat.html。

此函数的相反操作是 parseDateTimeInJodaSyntax。

根据确定的格式返回时间和日期值。

使用替换字段，您可以为结果字符串定义模式。

使用替换字段，您可以为结果字符串定义模式。 “示例”列显示了 2018-01-02 22:33:44 的格式化结果。占位符表示示例
G纪元文本AD
C世纪 (>=0)数字20
Y纪元年 (>=0)year1996
xweekyear (尚不支持)year1996
wweek of weekyear (尚不支持)数字27
e星期几数字2
E星期几文本Tuesday; Tue
yyearyear1996
D一年中的第几天数字189
M一年中的月份monthJuly; Jul; 07
d月份中的日期数字10
a一天中的半天文本PM
K半天的小时 (0~11)数字0
h半天的时钟小时 (1~12)数字12
H一天中的小时 (0~23)数字0
k一天中的时钟小时 (1~24)数字24
m小时中的分钟数字30
s分钟中的秒数字55
S秒的小数数字978
z时区文本Eastern Standard Time; EST
Z时区偏移zone-0800; -0812
'文本转义符分隔符
''单引号字面值'

示例

SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')

结果

┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56                                                                     │
└─────────────────────────────────────────────────────────────────────────────────────────┘

dateName​

返回日期的指定部分。

语法

dateName(date_part, date)

参数

  • date_part — 日期部分。 可能的值：'year'、'quarter'、'month'、'week'、'dayofyear'、'day'、'weekday'、'hour'、'minute'、'second'。 String。
  • date — 日期。 Date, Date32, DateTime 或 DateTime64。
  • timezone — 时区。 可选。 String。

返回值

  • 日期的指定部分。 String

示例

WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
    dateName('year', date_value),
    dateName('month', date_value),
    dateName('day', date_value);

结果

┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021                         │ April                         │ 14                          │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘

monthName​

返回月份的名称。

语法

monthName(date)

参数

返回值

示例

WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value);

结果

┌─monthName(date_value)─┐
│ April                 │
└───────────────────────┘

fromUnixTimestamp​

此函数将 Unix 时间戳转换为日历日期和一天中的时间。

它可以通过两种方式调用

当给定 Integer 类型的单个参数时，它返回 DateTime 类型的值，即行为类似于 toDateTime。

别名: FROM_UNIXTIME。

示例

SELECT fromUnixTimestamp(423543535);

结果

┌─fromUnixTimestamp(423543535)─┐
│          1983-06-04 10:58:55 │
└──────────────────────────────┘

当给定两个或三个参数时，如果第一个参数是 Integer, Date, Date32, DateTime 或 DateTime64 类型的值，第二个参数是常量格式字符串，第三个参数是可选的常量时区字符串，则该函数返回 String 类型的值，即它的行为类似于 formatDateTime。在这种情况下，使用 MySQL 的 datetime 格式风格。

示例

SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime;

结果

┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘

另请参阅

fromUnixTimestampInJodaSyntax​

与 fromUnixTimestamp 相同，但以第二种方式（两个或三个参数）调用时，格式化将使用 Joda 风格 而不是 MySQL 风格。

示例

SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime;

结果

┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘

toModifiedJulianDay​

将 YYYY-MM-DD 文本形式的 前格里高利历 日期转换为 Int32 类型的 修正儒略日 数字。此函数支持从 0000-01-01 到 9999-12-31 的日期。如果参数无法解析为日期，或者日期无效，则会引发异常。

语法

toModifiedJulianDay(date)

参数

返回值

  • 修正儒略日数字。 Int32。

示例

SELECT toModifiedJulianDay('2020-01-01');

结果

┌─toModifiedJulianDay('2020-01-01')─┐
│                             58849 │
└───────────────────────────────────┘

toModifiedJulianDayOrNull​

与 toModifiedJulianDay() 类似，但它返回 NULL 而不是引发异常。

语法

toModifiedJulianDayOrNull(date)

参数

返回值

示例

SELECT toModifiedJulianDayOrNull('2020-01-01');

结果

┌─toModifiedJulianDayOrNull('2020-01-01')─┐
│                                   58849 │
└─────────────────────────────────────────┘

fromModifiedJulianDay​

将 修正儒略日 数字转换为 YYYY-MM-DD 文本形式的 前格里高利历 日期。此函数支持从 -678941 到 2973483 的日期数字（分别代表 0000-01-01 和 9999-12-31）。如果日期数字超出支持范围，则会引发异常。

语法

fromModifiedJulianDay(day)

参数

返回值

  • 文本形式的日期。 String

示例

SELECT fromModifiedJulianDay(58849);

结果

┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01                   │
└──────────────────────────────┘

fromModifiedJulianDayOrNull​

与 fromModifiedJulianDayOrNull() 类似，但它返回 NULL 而不是引发异常。

语法

fromModifiedJulianDayOrNull(day)

参数

返回值

示例

SELECT fromModifiedJulianDayOrNull(58849);

结果

┌─fromModifiedJulianDayOrNull(58849)─┐
│ 2020-01-01                         │
└────────────────────────────────────┘

toUTCTimestamp​

将 DateTime/DateTime64 类型值从其他时区转换为 UTC 时区时间戳。此函数主要为了与 Apache Spark 和类似框架兼容而包含。

语法

toUTCTimestamp(time_val, time_zone)

参数

返回值

  • 文本形式的 DateTime/DateTime64

示例

SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai');

结果

┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')┐
│                                     2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘

fromUTCTimestamp​

将 DateTime/DateTime64 类型值从 UTC 时区转换为其他时区时间戳。此函数主要为了与 Apache Spark 和类似框架兼容而包含。

语法

fromUTCTimestamp(time_val, time_zone)

参数

返回值

  • 文本形式的 DateTime/DateTime64

示例

SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai');

结果

┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│                                                 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘

UTCTimestamp​

返回查询分析时刻的当前日期和时间。 该函数是一个常量表达式。

注意

此函数给出与 now('UTC') 相同的结果。它仅为支持 MySQL 而添加，建议使用 now。

语法

UTCTimestamp()

别名：UTC_timestamp。

返回值

  • 返回查询分析时刻的当前日期和时间。 DateTime。

示例

查询

SELECT UTCTimestamp();

结果

┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘

timeDiff​

返回两个日期或带时间值的日期之间的差异。差异以秒为单位计算。它与 dateDiff 相同，仅为支持 MySQL 而添加。建议使用 dateDiff。

语法

timeDiff(first_datetime, second_datetime)

参数*

返回值

两个日期或带时间值的日期之间的差异，以秒为单位。

示例

查询

timeDiff(toDateTime64('1927-01-01 00:00:00', 3), toDate32('1927-01-02'));

结果:

┌─timeDiff(toDateTime64('1927-01-01 00:00:00', 3), toDate32('1927-01-02'))─┐
│                                                                    86400 │
└──────────────────────────────────────────────────────────────────────────┘

相关内容​