日期和时间函数
本节中的大多数函数接受一个可选的时区参数,例如 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);
参数
year
— 年份。 Integer、Float 或 Decimal。month
— 月份。 Integer、Float 或 Decimal。day
— 日期。 Integer、Float 或 Decimal。day_of_year
— 一年中的第几天。 Integer、Float 或 Decimal。
返回值
- 根据参数创建的日期。 Date。
示例
从年份、月份和日期创建日期
SELECT makeDate(2023, 2, 28) AS Date;
结果
┌───────date─┐
│ 2023-02-28 │
└────────────┘
从年份和一年中的第几天参数创建日期
SELECT makeDate(2023, 42) AS Date;
结果
┌───────date─┐
│ 2023-02-11 │
└────────────┘
makeDate32
从年份、月份、日期(或可选的年份和日期)创建 Date32 类型的日期。
语法
makeDate32(year, [month,] day)
参数
year
— 年份。 Integer、Float 或 Decimal。month
— 月份(可选)。 Integer、Float 或 Decimal。day
— 日期。 Integer、Float 或 Decimal。
如果省略 month
,则 day
应取值为 1
到 365
之间,否则应取值为 1
到 31
之间。
返回值
- 根据参数创建的日期。 Date32。
示例
从年份、月份和日期创建日期
查询
SELECT makeDate32(2024, 1, 1);
结果
2024-01-01
从年份和一年中的第几天创建日期
查询
SELECT makeDate32(2024, 100);
结果
2024-04-09
makeDateTime
从年份、月份、日期、小时、分钟和秒参数创建一个 DateTime。
语法
makeDateTime(year, month, day, hour, minute, second[, timezone])
参数
year
— 年份。 Integer、Float 或 Decimal。month
— 月份。 Integer、Float 或 Decimal。day
— 日期。 Integer、Float 或 Decimal。hour
— 小时。 Integer、Float 或 Decimal。minute
— 分钟。 Integer、Float 或 Decimal。second
— 秒。 Integer、Float 或 Decimal。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])
参数
year
— 年份 (0-9999)。 Integer、Float 或 Decimal。month
— 月份 (1-12)。 Integer、Float 或 Decimal。day
— 日期 (1-31)。 Integer、Float 或 Decimal。hour
— 小时 (0-23)。 Integer、Float 或 Decimal。minute
— 分钟 (0-59)。 Integer、Float 或 Decimal。second
— 秒 (0-59)。 Integer、Float 或 Decimal。precision
— 亚秒级组件的可选精度 (0-9)。 Integer。
返回值
- 根据提供的参数创建的日期和时间。 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
参数
示例
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 │
└────────────────────────────┘
返回值
- DateTime64(6)
timeZone
返回当前会话的时区,即设置 session_timezone 的值。如果函数在分布式表的上下文中执行,则它会生成一个与每个分片相关的正常列,否则它会生成一个常量值。
语法
timeZone()
别名:timezone
。
返回值
- 时区。 String。
示例
SELECT timezone()
结果
┌─timezone()─────┐
│ America/Denver │
└────────────────┘
另请参阅
serverTimeZone
返回服务器的时区,即设置 timezone 的值。如果函数在分布式表的上下文中执行,则它会生成一个与每个分片相关的正常列。否则,它会生成一个常量值。
语法
serverTimeZone()
别名:serverTimezone
。
返回值
- 时区。 String。
示例
SELECT serverTimeZone()
结果
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
另请参阅
toTimeZone
将日期或日期时间转换为指定的时区。不会更改数据的内部值(Unix 秒数),只会更改值的时区属性和值的字符串表示形式。
语法
toTimezone(value, timezone)
别名:toTimezone
。
参数
value
— 时间或日期时间。 DateTime64。timezone
— 返回值的时区。 String。此参数是一个常量,因为toTimezone
会更改列的时区(时区是DateTime*
类型的属性)。
返回值
- 日期和时间。 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
另请参阅
- formatDateTime - 支持非常量时区。
- toString - 支持非常量时区。
timeZoneOf
返回 DateTime 或 DateTime64 数据类型的时区名称。
语法
timeZoneOf(value)
别名:timezoneOf
。
参数
value
— 日期和时间。 DateTime 或 DateTime64。
返回值
- 时区名称。 String。
示例
SELECT timezoneOf(now());
结果
┌─timezoneOf(now())─┐
│ Etc/UTC │
└───────────────────┘
timeZoneOffset
返回相对于 UTC 的时区偏移量(以秒为单位)。该函数考虑了指定的日期和时间处的 夏令时 和历史时区更改。 IANA 时区数据库 用于计算偏移量。
语法
timeZoneOffset(value)
别名:timezoneOffset
。
参数
value
— 日期和时间。 DateTime 或 DateTime64。
返回值
- 相对于 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
返回日期或日期时间的年份分量(公元)。
语法
toYear(value)
别名:YEAR
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间的年份。 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
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间所在的年份季度(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
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间所在的年份月份(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
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间在一年中的天数(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
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间在一个月中的天数(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 或 DateTime64mode
- 确定一周的第一天是什么。可能的值为 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
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的一天中的小时数(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
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的小时中的分钟数(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
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间中分钟中的秒数(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)
*参数**
value
- DateTime 或 DateTime64
别名: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
将字符串、日期或日期时间转换为 Unix 时间戳,以 UInt32
表示形式。
如果使用字符串调用该函数,则它接受一个可选的时区参数。
语法
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)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 输入日期/时间所在年份的第一天。 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)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 输入日期/时间所在年份的第一天。 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)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间所在季度的第一天。 Date。
示例
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
结果
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
toStartOfMonth
将日期或日期时间向下舍入到月份的第一天。返回日期。
语法
toStartOfMonth(value)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间所在月份的第一天。 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
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间所在月份的最后一天。 Date。
示例
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
结果
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
toMonday
将日期或日期时间向下舍入到最近的星期一。返回日期。
语法
toMonday(value)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期或之前最近的星期一的日期。 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 参数完全相同。如果未指定模式,则默认为 0。
语法
toStartOfWeek(t[, mode[, timezone]])
参数
t
- Date、Date32、DateTime 或 DateTime64mode
- 确定一周的第一天,如 toWeek() 函数中所述timezone
- 可选参数,其行为类似于任何其他转换函数
返回值
- 给定日期或之前最近的星期日或星期一的日期,具体取决于模式。 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 假设为 0。
语法
toLastDayOfWeek(t[, mode[, timezone]])
参数
t
- Date、Date32、DateTime 或 DateTime64mode
- 确定一周的最后一天,如 toWeek 函数中所述timezone
- 可选参数,其行为类似于任何其他转换函数
返回值
- 给定日期或之后最近的星期日或星期一的日期,具体取决于模式。 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)
参数
value
- Date、Date32、DateTime 或 DateTime64
返回值
- 给定日期/时间的一天开始时间。 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)
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的小时开始时间。 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)
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的分钟开始时间。 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
参数的时区。 String。
返回值
- 没有子秒的输入值。 DateTime64。
示例
无时区查询
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
参数的时区。 String。
返回值
- 包含毫秒以下部分的输入值。 DateTime64。
示例
无时区查询
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
参数的时区。 String。
返回值
- 包含微秒以下部分的输入值。 DateTime64。
示例
无时区查询
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
参数的时区。 String。
返回值
- 包含纳秒的输入值。 DateTime64。
示例
无时区查询
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)
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的五分钟间隔的开始。 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)
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的十分钟间隔的开始。 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)
参数
value
- DateTime 或 DateTime64
返回值
- 给定日期/时间的十五分钟间隔的开始。 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)
相同。
计算相对于特定时间点进行
间隔 | 开始 |
---|---|
YEAR | 公元0年 |
QUARTER | 1900年第一季度 |
MONTH | 1900年1月 |
WEEK | 1970年,第一周(01-05) |
DAY | 1970-01-01 |
HOUR | (*) |
MINUTE | 1970-01-01 00:00:00 |
SECOND | 1970-01-01 00:00:00 |
MILLISECOND | 1970-01-01 00:00:00 |
MICROSECOND | 1970-01-01 00:00:00 |
NANOSECOND | 1970-01-01 00:00:00 |
(*) 小时间隔是特殊的:计算始终相对于当前日期的00:00:00(午夜)进行。因此,只有1到23之间的小时值才有用。
如果指定了单位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])
参数
date
— 要转换为时间的日期。 Date/DateTime/DateTime64。timezone
(可选)— 返回值的时区。 String。
返回值
- 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)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的年数。 UInt16。
示例
查询
SELECT
toRelativeYearNum(toDate('2002-12-08')) AS y1,
toRelativeYearNum(toDate('2010-10-26')) AS y2
结果
┌───y1─┬───y2─┐
│ 2002 │ 2010 │
└──────┴──────┘
toRelativeQuarterNum
将日期或带有时间的日期转换为自过去某个固定点以来经过的季度数。
语法
toRelativeQuarterNum(date)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的季度数。 UInt32。
示例
查询
SELECT
toRelativeQuarterNum(toDate('1993-11-25')) AS q1,
toRelativeQuarterNum(toDate('2005-01-05')) AS q2
结果
┌───q1─┬───q2─┐
│ 7975 │ 8020 │
└──────┴──────┘
toRelativeMonthNum
将日期或带有时间的日期转换为自过去某个固定点以来经过的月数。
语法
toRelativeMonthNum(date)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的月数。 UInt32。
示例
查询
SELECT
toRelativeMonthNum(toDate('2001-04-25')) AS m1,
toRelativeMonthNum(toDate('2009-07-08')) AS m2
结果
┌────m1─┬────m2─┐
│ 24016 │ 24115 │
└───────┴───────┘
toRelativeWeekNum
将日期或带有时间的日期转换为自过去某个固定点以来经过的周数。
语法
toRelativeWeekNum(date)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的周数。 UInt32。
示例
查询
SELECT
toRelativeWeekNum(toDate('2000-02-29')) AS w1,
toRelativeWeekNum(toDate('2001-01-12')) AS w2
结果
┌───w1─┬───w2─┐
│ 1574 │ 1619 │
└──────┴──────┘
toRelativeDayNum
将日期或带有时间的日期转换为自过去某个固定点以来经过的天数。
语法
toRelativeDayNum(date)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的天数。 UInt32。
示例
查询
SELECT
toRelativeDayNum(toDate('1993-10-05')) AS d1,
toRelativeDayNum(toDate('2000-09-20')) AS d2
结果
┌───d1─┬────d2─┐
│ 8678 │ 11220 │
└──────┴───────┘
toRelativeHourNum
将日期或带有时间的日期转换为自过去某个固定点以来经过的小时数。
语法
toRelativeHourNum(date)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的小时数。 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)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的分钟数。 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)
参数
date
— 日期或带有时间的日期。 Date/DateTime/DateTime64。
返回值
- 自过去某个固定参考点以来的秒数。 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
将日期或带有时间的日期转换为作为UInt16数字的ISO年份。
语法
toISOYear(value)
参数
value
— 带有日期或带有时间的日期的值。 Date、Date32、DateTime或DateTime64
返回值
- 输入值转换为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天或更多天”的mode值,星期根据ISO 8601:1988进行编号
如果包含1月1日的星期在新的一年中包含4天或更多天,则它是第1周。
否则,它是前一年的最后一周,下一周是第1周。
对于含义为“包含1月1日”的mode值,包含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参数类似。对于单参数语法,使用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
对于给定日期,返回自公元0000年1月1日以来经过的天数,采用ISO 8601定义的推算格里高利历。计算与MySQL的TO_DAYS()
函数相同。
语法
toDaysSinceYearZero(date[, time_zone])
别名:TO_DAYS
参数
date
— 计算自公元元年起经过的天数的日期。 Date、Date32、DateTime 或 DateTime64。time_zone
— String 类型常量值或表示时区的表达式。 String 类型
返回值
自日期 0000-01-01 起经过的天数。 UInt32。
示例
SELECT toDaysSinceYearZero(toDate('2023-09-08'));
结果
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
另请参阅
fromDaysSinceYearZero
对于给定的自 公元 0000 年 1 月 1 日 起经过的天数,返回 ISO 8601 定义的推算格里高利历 中对应的日期。计算方法与 MySQL 的 FROM_DAYS()
函数相同。
如果无法在 Date 类型的范围内表示,则结果未定义。
语法
fromDaysSinceYearZero(days)
别名:FROM_DAYS
参数
days
— 自公元元年起经过的天数。
返回值
对应于自公元元年起经过的天数的日期。 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()
不同,在该函数中,一周默认从星期日开始。
有关 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。
返回值
- 截断到日期指定部分的值。 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
将时间间隔添加到提供的日期、日期时间或字符串编码的日期/日期时间。
如果加法导致的值超出数据类型的范围,则结果未定义。
语法
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
从提供的日期、日期时间或字符串编码的日期/日期时间中减去时间间隔。
如果减法导致的值超出数据类型的范围,则结果未定义。
语法
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])
参数
返回值
- 当前日期和时间。 DateTime。
示例
无时区查询
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()
参数
- 无
返回值
- 当前日期。 DateTime。
示例
查询
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。
尽管此函数可以接受扩展类型 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]);
参数
返回值
- 根据参数创建的带时间的日期。 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
- Date、Date32、DateTime 或 DateTime64value
- 年份的新值。 Integer。
返回值
- 与
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
- Date、Date32、DateTime 或 DateTime64value
- 月份的新值。 Integer。
返回值
- 返回与
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
- Date、Date32、DateTime 或 DateTime64value
- 日期的新值。 Integer。
返回值
- 返回与
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、Date32、DateTime 或 DateTime64value
- 小时的新值。 Integer。
返回值
- 返回与
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、Date32、DateTime 或 DateTime64value
- 分钟的新值。 Integer。
返回值
- 返回与
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、Date32、DateTime 或 DateTime64value
- 秒的新值。 Integer。
返回值
- 返回与
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)
参数
返回值
- 返回
date
加上num
年。 Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
个季度。 Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
个月。 Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
周。 Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
天。 Date/Date32/DateTime/DateTime64。
示例
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
- 返回
date
加上num
小时。Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
分钟。Date/Date32/DateTime/DateTime64。
示例
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)
参数
返回值
- 返回
date
加上num
秒。Date/Date32/DateTime/DateTime64。
示例
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
:要添加指定毫秒数的带时间戳的日期。DateTime/DateTime64,String。num
:要添加的毫秒数。(U)Int*,Float*。
返回值
- 返回
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
:要添加指定微秒数的带时间戳的日期。DateTime/DateTime64,String。num
:要添加的微秒数。(U)Int*,Float*。
返回值
- 返回
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。num
:要添加的纳秒数。(U)Int*,Float*。
返回值
- 返回
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
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 │
└────────────────────────────────┴───────────────────────────────────────┘
addInterval
将一个时间间隔添加到另一个时间间隔或时间间隔元组。
语法
addInterval(interval_1, interval_2)
参数
返回值
相同类型的时间间隔将合并成一个时间间隔。例如,如果传递了toIntervalDay(1)
和toIntervalDay(2)
,则结果将是(3)
而不是(1,1)
。
示例
查询
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) │
└─────────────────────────────────────────────────┘
addTupleOfIntervals
连续将时间间隔元组添加到日期或日期时间。
语法
addTupleOfIntervals(interval_1, interval_2)
参数
返回值
- 返回添加了
intervals
的date
。date/date32/datetime/datetime64。
示例
查询
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 │
└──────────────────────────────────────────────────────────────────────────────────────┘
subtractYears
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定年数。
语法
subtractYears(date, num)
参数
返回值
- 返回
date
减去num
年。Date/Date32/DateTime/DateTime64。
示例
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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
subtractQuarters
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定季度数。
语法
subtractQuarters(date, num)
参数
返回值
- 返回
date
减去num
季度。Date/Date32/DateTime/DateTime64。
示例
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 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
subtractMonths
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定月数。
语法
subtractMonths(date, num)
参数
返回值
- 返回
date
减去num
月。Date/Date32/DateTime/DateTime64。
示例
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 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
subtractWeeks
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定周数。
语法
subtractWeeks(date, num)
参数
返回值
- 返回
date
减去num
周。Date/Date32/DateTime/DateTime64。
示例
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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
subtractDays
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定天数。
语法
subtractDays(date, num)
参数
返回值
- 返回
date
减去num
天。Date/Date32/DateTime/DateTime64。
示例
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 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
subtractHours
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定小时数。
语法
subtractHours(date, num)
参数
返回值
- 返回
date
减去num
小时。Date/Date32/Datetime/DateTime64。
示例
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 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
subtractMinutes
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定分钟数。
语法
subtractMinutes(date, num)
参数
返回值
- 返回
date
减去num
分钟。Date/Date32/DateTime/DateTime64。
示例
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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
subtractSeconds
从日期、带时间戳的日期或字符串编码的日期/带时间戳的日期中减去指定秒数。
语法
subtractSeconds(date, num)
参数
返回值
- 返回
date
减去num
秒。Date/Date32/DateTime/DateTime64。
示例
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 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
subtractMilliseconds
从带时间戳的日期或字符串编码的带时间戳的日期中减去指定毫秒数。
语法
subtractMilliseconds(date_time, num)
参数
date_time
:要减去指定毫秒数的带时间戳的日期。DateTime/DateTime64,String。num
:要减去的毫秒数。(U)Int*,Float*。
返回值
- 返回
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
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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
subtractMicroseconds
从日期时间或字符串编码的日期时间中减去指定数量的微秒。
语法
subtractMicroseconds(date_time, num)
参数
date_time
:要从中减去指定数量的微秒的日期时间。 DateTime/DateTime64,String 类型。num
:要减去的微秒数。 (U)Int*,Float* 类型。
返回值
- 返回
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
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 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
subtractNanoseconds
从日期时间或字符串编码的日期时间中减去指定数量的纳秒。
语法
subtractNanoseconds(date_time, num)
参数
date_time
:要从中减去指定数量的纳秒的日期时间。 DateTime/DateTime64,String 类型。num
:要减去的纳秒数。 (U)Int*,Float* 类型。
返回值
- 返回
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
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 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
subtractInterval
将一个取反的间隔添加到另一个间隔或间隔元组中。
语法
subtractInterval(interval_1, interval_2)
参数
返回值
相同类型的间隔将合并成一个间隔。例如,如果传递了 toIntervalDay(2)
和 toIntervalDay(1)
,则结果将是 (1)
而不是 (2,1)
。
示例
查询
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) │
└──────────────────────────────────────────────────────┘
subtractTupleOfIntervals
连续地从日期或日期时间中减去一个间隔元组。
语法
subtractTupleOfIntervals(interval_1, interval_2)
参数
返回值
- 返回减去
intervals
后的date
。 Date/Date32/DateTime/DateTime64 类型。
示例
查询
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 │
└───────────────────────────────────────────────────────────────────────┘
timeSlots
对于从“StartTime”开始持续“Duration”秒的时间间隔,它返回一个时间点数组,该数组由该时间间隔中向下舍入到“Size”秒的点组成。“Size”是一个可选参数,默认为 1800(30 分钟)。例如,在搜索相应会话中的页面浏览量时,这很有必要。接受 DateTime 和 DateTime64 作为“StartTime”参数。对于 DateTime,“Duration”和“Size”参数必须是 UInt32
类型。对于“DateTime64”,它们必须是 Decimal64
类型。返回一个 DateTime/DateTime64 数组(返回类型与“StartTime”的类型匹配)。对于 DateTime64,返回值的比例可能与“StartTime”的比例不同——采用所有给定参数中最高的比例。
语法
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'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
formatDateTime
根据给定的格式字符串格式化时间。格式是一个常量表达式,因此您不能为单个结果列设置多个格式。
formatDateTime 使用 MySQL 日期时间格式样式,请参考 https://dev.mysqlserver.cn/doc/refman/8.0/en/date-and-time-functions.html#function_date-format。
此函数的反向操作是 parseDateTime。
别名:DATE_FORMAT
。
语法
formatDateTime(Time, Format[, Timezone])
返回值
根据确定的格式返回时间和日期值。
替换字段
使用替换字段,您可以为结果字符串定义一个模式。“示例”列显示了 2018-01-02 22:33:44
的格式化结果。
占位符 | 描述 | 示例 |
---|---|---|
%a | 缩写工作日名称(Mon-Sun) | Mon |
%b | 缩写月份名称(Jan-Dec) | Jan |
%c | 月份作为整数(01-12),参见下面的“注释 3” | 01 |
%C | 年份除以 100 并截断为整数(00-99) | 20 |
%d | 月份中的日期,用零填充(01-31) | 02 |
%D | 短日期 MM/DD/YY,等效于 %m/%d/%y | 01/02/18 |
%e | 月份中的日期,用空格填充(1-31) | 2 |
%f | 小数秒,参见下面的“注释 1” | 1234560 |
%F | 短日期 YYYY-MM-DD,等效于 %Y-%m-%d | 2018-01-02 |
%g | 两位数年份格式,与 ISO 8601 对齐,从四位数表示法缩写 | 18 |
%G | ISO 周数的四位数年份格式,根据 ISO 8601 标准定义的基于周的年份 计算得出,通常仅与 %V 一起使用 | 2018 |
%h | 12 小时制的小时(01-12) | 09 |
%H | 24 小时制的小时(00-23) | 22 |
%i | 分钟(00-59) | 33 |
%I | 12 小时制的小时(01-12) | 10 |
%j | 一年中的日期(001-366) | 002 |
%k | 24 小时制的小时(00-23),参见下面的“注释 3” | 14 |
%l | 12 小时制的小时(01-12),参见下面的“注释 3” | 09 |
%m | 月份作为整数(01-12) | 01 |
%M | 完整月份名称(January-December),参见下面的“注释 2” | January |
%n | 换行符(’’) | |
%p | AM 或 PM 表示 | PM |
%Q | 季度(1-4) | 1 |
%r | 12 小时制 HH:MM AM/PM 时间,等效于 %h:%i %p | 10:30 PM |
%R | 24 小时制 HH:MM 时间,等效于 %H:%i | 22:33 |
%s | 秒(00-59) | 44 |
%S | 秒(00-59) | 44 |
%t | 水平制表符(’) | |
%T | ISO 8601 时间格式(HH:MM:SS),等效于 %H:%i:%S | 22:33:44 |
%u | ISO 8601 工作日作为数字,星期一为 1(1-7) | 2 |
%V | ISO 8601 周数(01-53) | 01 |
%w | 工作日作为整数,星期日为 0(0-6) | 2 |
%W | 完整工作日名称(Monday-Sunday) | 星期一 |
%y | 年份,最后两位数字(00-99) | 18 |
%Y | 年份 | 2018 |
%z | 相对于 UTC 的时间偏移量,格式为 +HHMM 或 -HHMM | -0500 |
%% | 一个 % 符号 | % |
注释 1:在 v23.4 之前的 ClickHouse 版本中,如果格式化值为 Date、Date32 或 DateTime(没有小数秒)或精度为 0 的 DateTime64,则 %f
会打印单个零 (0)。可以使用设置 formatdatetime_f_prints_single_zero = 1
恢复以前的行为。
注释 2:在 v23.4 之前的 ClickHouse 版本中,%M
打印分钟(00-59)而不是完整月份名称(January-December)。可以使用设置 formatdatetime_parsedatetime_m_is_month_name = 0
恢复以前的行为。
注释 3:在 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
函数可以接受第三个包含时区名称的字符串参数。例如: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。
替换字段
使用替换字段,您可以为结果字符串定义一个模式。
占位符 | 描述 | 表示 | 示例 |
---|---|---|---|
G | 时代 | 文本 | AD |
C | 时代世纪(>=0) | 数字 | 20 |
Y | 时代年份(>=0) | year | 1996 |
x | 周数年份(暂不支持) | year | 1996 |
w | 周数年份中的周数(暂不支持) | 数字 | 27 |
e | 一周中的日期 | 数字 | 2 |
E | 一周中的日期 | 文本 | Tuesday; Tue |
y | year | year | 1996 |
D | 一年中的日期 | 数字 | 189 |
M | 一年中的月份 | month | July; 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 | 时区(暂不支持短名称) | 文本 | Pacific Standard Time; PST |
Z | 时区偏移量/ID(暂不支持) | 区域 | -0800; -08:00; America/Los_Angeles |
' | 文本转义 | 分隔符 | |
'' | 单引号 | 文字 | ' |
示例
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)
参数
date
— 日期或日期时间。 Date、DateTime 或 DateTime64 类型。
返回值
- 月份名称。 String 类型
示例
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 │
└──────────────────────────────┘
如果给出两个或三个参数,其中第一个参数是 整数、日期、Date32、DateTime 或 DateTime64 类型的值,第二个参数是常量格式字符串,第三个参数是可选的常量时区字符串,则该函数返回 字符串 类型的值,即其行为类似于 formatDateTime。在这种情况下,使用的是 MySQL 的日期时间格式样式。
示例
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)
参数
返回值
- 修正儒略日数字。 Nullable(Int32)。
示例
SELECT toModifiedJulianDayOrNull('2020-01-01');
结果
┌─toModifiedJulianDayOrNull('2020-01-01')─┐
│ 58849 │
└─────────────────────────────────────────┘
fromModifiedJulianDay
将 修正儒略日 数字转换为文本形式的 格里高利历 日期(YYYY-MM-DD
)。此函数支持从 -678941
到 2973483
的日数字(分别表示 0000-01-01 和 9999-12-31)。如果日数字超出支持范围,则会引发异常。
语法
fromModifiedJulianDay(day)
参数
day
— 修正儒略日数字。 任何整数类型。
返回值
- 文本形式的日期。 字符串
示例
SELECT fromModifiedJulianDay(58849);
结果
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
类似于 fromModifiedJulianDayOrNull(),但它返回 NULL
而不是引发异常。
语法
fromModifiedJulianDayOrNull(day)
参数
day
— 修正儒略日数字。 任何整数类型。
返回值
- 文本形式的日期。 Nullable(String)
示例
SELECT fromModifiedJulianDayOrNull(58849);
结果
┌─fromModifiedJulianDayOrNull(58849)─┐
│ 2020-01-01 │
└────────────────────────────────────┘
toUTCTimestamp
将 DateTime/DateTime64 类型的值从其他时区转换为 UTC 时区的 timestamp
语法
toUTCTimestamp(time_val, time_zone)
参数
time_val
— DateTime/DateTime64 类型常量值或表达式。 DateTime/DateTime64 类型time_zone
— String 类型常量值或表示时区的表达式。 String 类型
返回值
- 文本形式的 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 时区转换为其他时区的 timestamp
语法
fromUTCTimestamp(time_val, time_zone)
参数
time_val
— DateTime/DateTime64 类型常量值或表达式。 DateTime/DateTime64 类型time_zone
— String 类型常量值或表示时区的表达式。 String 类型
返回值
- 文本形式的 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)
*参数**
first_datetime
— DateTime/DateTime64 类型常量值或表达式。 DateTime/DateTime64 类型second_datetime
— DateTime/DateTime64 类型常量值或表达式。 DateTime/DateTime64 类型
返回值
两个日期或带有时间值的日期之间的差值(以秒为单位)。
示例
查询
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 │
└──────────────────────────────────────────────────────────────────────────┘