这是本节的多页打印视图。点击此处打印.

日期/时间函数

1: ADD_MONTHS
2: AGE_IN_MONTHS
3: AGE_IN_YEARS
4: CLOCK_TIMESTAMP
5: CURRENT_DATE
6: CURRENT_TIME
7: CURRENT_TIMESTAMP
8: DATE_PART
9: DATE
10: DATE_TRUNC
11: DATEDIFF
12: DAY
13: DAYOFMONTH
14: DAYOFWEEK
15: DAYOFWEEK_ISO
16: DAYOFYEAR
17: DAYS
18: EXTRACT
19: GETDATE
20: GETUTCDATE
21: HOUR
22: ISFINITE
23: JULIAN_DAY
24: LAST_DAY
25: LOCALTIME
26: LOCALTIMESTAMP
27: MICROSECOND
28: MIDNIGHT_SECONDS
29: MINUTE
30: MONTH
31: MONTHS_BETWEEN
32: NEW_TIME
33: NEXT_DAY
34: NOW [日期/时间]
35: OVERLAPS
36: QUARTER
37: ROUND
38: SECOND
39: STATEMENT_TIMESTAMP
40: SYSDATE
41: TIME_SLICE
42: TIMEOFDAY
43: TIMESTAMPADD
44: TIMESTAMPDIFF
45: TIMESTAMP_ROUND
46: TIMESTAMP_TRUNC
47: TRANSACTION_TIMESTAMP
48: TRUNC
49: WEEK
50: WEEK_ISO
51: YEAR
52: YEAR_ISO

日期和时间函数进行日期和时间数据类型的转换、提取或处理操作，可以返回日期和时间信息。

使用

TIME 或 TIMESTAMP 输入函数有两种变体：

TIME WITH TIME ZONE 或者 TIMESTAMP WITH TIME ZONE
TIME WITHOUT TIME ZONE 或者 TIMESTAMP WITHOUT TIME ZONE

简洁起见，这些变体不单独显示。

和 * 运算符以交换对的形式出现，例如，DATE + INTEGER和 INTEGER + DATE。每个交换对仅显示其中一个运算符。

夏令时注意事项

将 INTERVAL 值添加到（或从中扣除 INTERVAL 值）TIMESTAMP WITH TIME ZONE 值时，白天组件按指定天数增加（或递减）TIMESTAMP WITH TIME ZONE 的日期。在多次夏令时更改（会话时区设置为识别 DST 的时区）中，这意味着 INTERVAL '1 day' 不一定等于 INTERVAL '24 hours'。

例如，会话时区设置为 CST7CDT 时：

TIMESTAMP WITH TIME ZONE '2014-04-02 12:00-07' + INTERVAL '1 day'

会生成

TIMESTAMP WITH TIME ZONE '2014-04-03 12:00-06'

将 INTERVAL '24 hours' 添加到相同的开头字母 TIMESTAMP WITH TIME ZONE 会生成

TIMESTAMP WITH TIME ZONE '2014-04-03 13:00-06',

出现此结果是因为在时区 2014-04-03 02:00 中 CST7CDT 的夏令时发生了变化。

事务中的日期/时间函数

某些日期/时间函数（例如 CURRENT_TIMESTAMP 和 NOW）会返回当前事务的开始时间；在该事务的时间段内，这些函数会返回相同的值。其他日期/时间函数（例如 TIMEOFDAY）总是返回当前时间。

另请参阅

用于日期/时间格式化的模板模式

1 - ADD_MONTHS

将指定的月数添加到日期并以 DATE 的形式返回总和。通常，ADD_MONTHS 返回与开始日期具有相同日部分的日期。例如：

=> SELECT ADD_MONTHS ('2015-09-15'::date, -2) "2 Months Ago";
 2 Months Ago
--------------
 2015-07-15
(1 row)

有两个例外：

如果开始日期的日部分大于结果月份的最后一天，则 ADD_MONTHS 返回结果月份的最后一天。例如：
```
=> SELECT ADD_MONTHS ('31-Jan-2016'::TIMESTAMP, 1) "Leap Month";
 Leap Month
------------
 2016-02-29
(1 row)
```
如果开始日期的日部分是该月的最后一天，并且结果月份的天数比开始日期月份的天数多，则 ADD_MONTHS 返回结果月份的最后一天。例如：
```
=> SELECT ADD_MONTHS ('2015-09-30'::date,-1) "1 Month Ago";
 1 Month Ago
-------------
 2015-08-31
(1 row)
```

行为类型

不可变，如果 start-date 实参为 TIMESTAMP 或 DATE
稳定，如果 start‑date 实参为 TIMESTAMPTZ

语法

ADD_MONTHS ( start‑date, num‑months );

参数

start‑date

要处理的日期，是求值结果具有以下一种数据类型的表达式：

DATE
TIMESTAMP
TIMESTAMPTZ

num‑months

整数表达式，指定要添加到 start‑date 中或从中减去的月数。

示例

在当前日期上加一个月：

=> SELECT CURRENT_DATE Today;
   Today
------------
 2016-05-05
(1 row)

VMart=> SELECT ADD_MONTHS(CURRENT_TIMESTAMP,1);
 ADD_MONTHS
------------
 2016-06-05
(1 row)

从当前日期减去四个月：

=> SELECT ADD_MONTHS(CURRENT_TIMESTAMP, -4);
 ADD_MONTHS
------------
 2016-01-05
(1 row)

2016 年 1 月 31 日加一个月：

=> SELECT ADD_MONTHS('31-Jan-2016'::TIMESTAMP, 1) "Leap Month";
 Leap Month
------------
 2016-02-29
(1 row)

以下示例将时区设置为 EST；然后它将 24 个月添加到指定 PST 时区的 TIMESTAMPTZ，因此 ADD_MONTHS 会考虑时间变化：

=> SET TIME ZONE 'America/New_York';
SET
VMart=> SELECT ADD_MONTHS('2008-02-29 23:30 PST'::TIMESTAMPTZ, 24);
 ADD_MONTHS
------------
 2010-03-01
(1 row)

2 - AGE_IN_MONTHS

返回两个日期之间的月份差，以整数表示。

行为类型

不可变，如果两个日期实参均为 TIMESTAMP 数据类型
稳定，如果任一日期为 TIMESTAMPTZ 或仅提供一个实参

语法

AGE_IN_MONTHS ( [ date1,] date2 )

参数

date1 date2

指定要测量的期限的边界。如果您只提供一个实参，Vertica 会将 date2 设置为当前日期。这两个参数的计算结果必须为以下数据类型之一：

DATE
TIMESTAMP
TIMESTAMPTZ

如果 date1 < date2，AGE_IN_MONTHS 将返回负值。

示例

获取 1972 年 3 月 2 日出生的人截至 1990 年 6 月 21 日的月龄：

=> SELECT AGE_IN_MONTHS('1990-06-21'::TIMESTAMP, '1972-03-02'::TIMESTAMP);
  AGE_IN_MONTHS
---------------
           219
(1 row)

如果第一个日期小于第二个日期，AGE_IN_MONTHS 将返回负值

=> SELECT AGE_IN_MONTHS('1972-03-02'::TIMESTAMP, '1990-06-21'::TIMESTAMP);
AGE_IN_MONTHS
---------------
-220
(1 row)

获取 1939 年 11 月 21 日出生的人截至今天的月龄：

=> SELECT AGE_IN_MONTHS ('1939-11-21'::DATE);
 AGE_IN_MONTHS
---------------
           930
(1 row)

3 - AGE_IN_YEARS

返回两个日期之间的年份差，以整数表示。

行为类型

不可变，如果两个日期实参均为 TIMESTAMP 数据类型
稳定，如果任一日期为 TIMESTAMPTZ 或仅提供一个实参

语法

AGE_IN_YEARS( [ date1,] date2 )

参数

date1 date2

指定要测量的期限的边界。如果您只提供一个实参，Vertica 会将 date1 设置为当前日期。这两个参数的计算结果必须为以下数据类型之一：

DATE
TIMESTAMP
TIMESTAMPTZ

如果 date1 < date2，AGE_IN_YEARS 将返回负值。

示例

获取 1972 年 3 月 2 日出生的人截至 1990 年 6 月 21 日的年龄：

=> SELECT AGE_IN_YEARS('1990-06-21'::TIMESTAMP, '1972-03-02'::TIMESTAMP);
 AGE_IN_YEARS
--------------
           18
(1 row)

如果第一个日期早于第二个日期，AGE_IN_YEARS 将返回负数：

=> SELECT AGE_IN_YEARS('1972-03-02'::TIMESTAMP, '1990-06-21'::TIMESTAMP);
AGE_IN_YEARS
--------------
          -19
(1 row)

获取 1939 年 11 月 21 日出生的人截至今天的年龄：

=> SELECT AGE_IN_YEARS('1939-11-21'::DATE);
 AGE_IN_YEARS
--------------
           77
(1 row)

4 - CLOCK_TIMESTAMP

返回 TIMESTAMP WITH TIMEZONE 类型的值，该值表示当前系统时钟时间。

CLOCK_TIMESTAMP 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间应相同。每次调用时，值都会更改。

行为类型

易变

语法

CLOCK_TIMESTAMP()

示例

以下命令返回系统上的当前时间：

SELECT CLOCK_TIMESTAMP() "Current Time";
         Current Time
------------------------------
 2010-09-23 11:41:23.33772-04
(1 row)

每当调用函数时，都会得到不同的结果。此示例中的差异以微秒为单位：

SELECT CLOCK_TIMESTAMP() "Time 1", CLOCK_TIMESTAMP() "Time 2";
            Time 1             |            Time 2
-------------------------------+-------------------------------
 2010-09-23 11:41:55.369201-04 | 2010-09-23 11:41:55.369202-04
(1 row)

另请参阅

5 - CURRENT_DATE

返回当前交易的开始日期（date-type 值）。

行为类型

稳定

语法

CURRENT_DATE()

注意

您可以不带括号调用此函数。

示例

SELECT CURRENT_DATE;
  ?column?
------------
 2010-09-23
(1 row)

6 - CURRENT_TIME

返回 TIME WITH TIMEZONE 类型值，代表当前事务的开始时间。

事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIME 将返回相同的时间戳。

行为类型

稳定

语法

CURRENT_TIME  [ ( precision ) ]

注意

如果指定不带精度的列标签，还必须省略括号。

参数

precision: 介于 0-6 之间的整数值，指定将秒部分字段结果四舍五入到指定数字位数。

示例


=> SELECT CURRENT_TIME(1) AS Time;
     Time
---------------
 06:51:45.2-07
(1 row)
=> SELECT CURRENT_TIME(5) AS Time;
       Time
-------------------
 06:51:45.18435-07
(1 row)

7 - CURRENT_TIMESTAMP

返回 TIME WITH TIMEZONE 类型值，代表当前事务的开始时间。

事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIMESTAMP 将返回相同的时间戳。

行为类型

稳定

语法

CURRENT_TIMESTAMP ( precision )

参数

precision: 介于 0-6 之间的整数值，指定将秒部分字段结果四舍五入到指定数字位数。

示例


=> SELECT CURRENT_TIMESTAMP(1) AS time;
           time
--------------------------
 2017-03-27 06:50:49.7-07
(1 row)
=> SELECT CURRENT_TIMESTAMP(5) AS time;
             time
------------------------------
 2017-03-27 06:50:49.69967-07
(1 row)

8 - DATE_PART

从日期/时间表达式中提取子字段（如年或小时），等同于 SQL 标准函数 EXTRACT。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 INTERVAL，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

DATE_PART ( 'field', date )

参数

field

一个常数值，指定要从 date 中提取的子字段（请参阅下文的字段值）。

date

要处理的日期，是求值结果具有以下一种数据类型的表达式：

DATE （转换为 TIMESTAMP）
TIMESTAMP/TIMESTAMPTZ
INTERVAL

字段值

注意

按照 ISO-8601 标准，一周的开始时间是星期一，一年的第一周包含 1 月 4 日。因此，一月初的日期有时可能会位于上一个历年的第 52 周或第 53 周。例如：

=> SELECT YEAR_ISO('01-01-2016'::DATE), WEEK_ISO('01-01-2016'), DAYOFWEEK_ISO('01-01-2016');
 YEAR_ISO | WEEK_ISO | DAYOFWEEK_ISO
----------+----------+---------------
     2015 |       53 |             5
(1 row)

示例

提取日期值：

SELECT DATE_PART('DAY', TIMESTAMP '2009-02-24 20:38:40') "Day";
  Day
-----
  24
(1 row)

提取月份值：

SELECT DATE_PART('MONTH', '2009-02-24 20:38:40'::TIMESTAMP) "Month";
  Month
-------
     2
(1 row)

提取年份值：

SELECT DATE_PART('YEAR', '2009-02-24 20:38:40'::TIMESTAMP) "Year";
  Year
------
 2009
(1 row)

提取小时：

SELECT DATE_PART('HOUR', '2009-02-24 20:38:40'::TIMESTAMP) "Hour";
  Hour
------
   20
(1 row)

提取分钟：

SELECT DATE_PART('MINUTES', '2009-02-24 20:38:40'::TIMESTAMP) "Minutes";
  Minutes
---------
      38
(1 row)

提取季度日期 (DOQ)：

SELECT DATE_PART('DOQ', '2009-02-24 20:38:40'::TIMESTAMP) "DOQ";
 DOQ
-----
  55
(1 row)

另请参阅

TO_CHAR

9 - DATE

将输入值转换为 DATE 数据类型。

行为类型

如果输入值为 TIMESTAMP、DATE、VARCHAR 或整数，则是不可变
如果输入值为 TIMESTAMPTZ，则是稳定

语法

DATE ( value )

参数

value

要转换的值为以下之一：

TIMESTAMP、TIMESTAMPTZ、VARCHAR 或另一个 DATE。
整数：Vertica 将整数视为自 01/01/0001 以来的天数并返回日期。

示例

=> SELECT DATE (1);
    DATE
------------
 0001-01-01
(1 row)

=> SELECT DATE (734260);
    DATE
------------
 2011-05-03
(1 row)

=> SELECT DATE('TODAY');
    DATE
------------
 2016-12-07
(1 row)

另请参阅

10 - DATE_TRUNC

将日期和时间值截断为指定的精度。返回值与输入值的数据类型相同。所有小于指定精度的字段均设置为 0，或设置为 1 表示日和月。

行为类型

稳定

语法

DATE_TRUNC( precision, trunc‑target )

参数

precision: 一个字符串常量，指定截断值的精度。请参阅下文的精度字段值。精度必须对 trunc-target 日期或时间有效。
trunc‑target: 有效日期/时间表达式。

精度字段值

MILLENNIUM

千年序号。

CENTURY

世纪序号。

一世纪始于 0001-01-01 00:00:00 AD。此定义适用于所有采用公历的国家/地区。

DECADE

年份字段除以 10。

YEAR

年份字段。请记住，不存在 0 AD，因此将 AD 年份相应地从 BC 年份中减去。

QUARTER

指定日期的日历季度，为整数，其中一月至三月的季度为 1。

MONTH

对于 timestamp 值，为年份第几月 (1–12)；对于 interval 值，为月份数，模数 12 (0-11)。

WEEK

日期所处的年周序号。

=> SELECT YEAR_ISO('01-01-2016'::DATE), WEEK_ISO('01-01-2016'), DAYOFWEEK_ISO('01-01-2016');
 YEAR_ISO | WEEK_ISO | DAYOFWEEK_ISO
----------+----------+---------------
     2015 |       53 |             5
(1 row)

DAY

（月份）第几日字段 (1–31)。

HOUR

小时字段 (0–23)。

MINUTE

分钟字段 (0–59)。

SECOND

秒字段，包括小数部分 (0–59)（如果操作系统实施闰秒，则为 60）。

MILLISECONDS

秒数字段，包括小数部分，而且乘以了 1000。请注意，这包括完整的秒数。

MICROSECONDS

秒数字段，包括小数部分，而且乘以了 1,000,000。这包括完整的秒数。

示例

以下示例将字段值设置为小时并返回小时，截断分钟和秒：

=> SELECT DATE_TRUNC('HOUR', TIMESTAMP '2012-02-24 13:38:40') AS HOUR;
        HOUR
---------------------
 2012-02-24 13:00:00
(1 row)

以下示例从输入 timestamptz '2012-02-24 13:38:40' 返回年份。函数还将月份和日期默认为 1 月 1 日，截断时间戳的时：分：秒，并附加时区（-05）：

=> SELECT DATE_TRUNC('YEAR', TIMESTAMPTZ '2012-02-24 13:38:40') AS YEAR;
          YEAR
------------------------
 2012-01-01 00:00:00-05
(1 row)

以下示例返回年份和月份，将默认月份日期设置为 1，截断字符串的其余部分：

=> SELECT DATE_TRUNC('MONTH', TIMESTAMP '2012-02-24 13:38:40') AS MONTH;
        MONTH
---------------------
 2012-02-01 00:00:00
(1 row)

11 - DATEDIFF

以指定的间隔返回两个日期之间的时间跨度。 DATEDIFF 在其计算中不包括开始日期。

行为类型

如果开始日期和结束日期为 TIMESTAMP、DATE、TIME 或 INTERVAL，则是不可变
如果开始日期和结束日期为 TIMESTAMPTZ，则是稳定

语法

DATEDIFF ( datepart, start, end );

参数

datepart

指定 DATEDIFF 返回的日期或时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：

DATEDIFF((expression), start, end;

datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：

year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us

start, end

指定开始日期和结束日期，其中 start 和 end 的求值结果为以下数据类型之一：

如果 end < start，则 DATEDIFF 返回负值。

注意

如果 datepart 设置为 year、quarter 或 month，则 TIME 和 INTERVAL 数据类型对开始日期和结束日期无效。

兼容开始日期和结束日期数据类型

下表显示了可匹配为开始日期和结束日期的数据类型：

例如，如果将开始日期设置为 INTERVAL 数据类型，则结束日期也必须为 INTERVAL，否则 Vertica 将返回错误：

 SELECT DATEDIFF(day, INTERVAL '26 days', INTERVAL '1 month ');
 datediff
----------
        4
(1 row)

日期部分间隔

DATEDIFF 使用 datepart 实参计算两个日期之间的间隔数，而不是二者之间的实际时间量。 DATEDIFF 使用以下截止点计算这些间隔：

year：1 年 1 月
quarter：1 月 1 日、4 月 1 日、7 月 1 日、10 月 1 日
month：当月的第一天
week：周日午夜 (24:00)

例如，如果 datepart 设置为 year，则 DATEDIFF 使用 1 月 1 日计算两个日期之间的年数。以下 DATEDIFF 语句将 datepart 设置为 year，并将时间跨度指定为 2005 年 1 月 1 日到 2008 年 6 月 15 日：

SELECT DATEDIFF(year, '01-01-2005'::date, '12-31-2008'::date);
 datediff
----------
        3
(1 row)

DATEDIFF 在计算间隔时始终排除开始日期 — 在本例中为 2005 年 1 月 1。 DATEDIFF 计算过程中只考虑开始日历年，因此本例中只计算 2006、2007 和 2008 年。函数返回 3，尽管实际时间跨度接近四年。

如果将开始日期和结束日期分别更改为 2004 年 12 月 31 日和 2009 年 1 月 1 日，则 DATEDIFF 还会计算 2005 年和 2009 年。这一次，返回 5，尽管实际时间跨度刚刚超过四年：

=> SELECT DATEDIFF(year, '12-31-2004'::date, '01-01-2009'::date);
 datediff
----------
        5
(1 row)

同样，DATEDIFF 在计算两个日期之间的月数时使用月份开始日期。因此，在以下语句中，DATEDIFF 计算 2 月到 9 月之间的月份并返回 8：

=> SELECT DATEDIFF(month, '01-31-2005'::date, '09-30-2005'::date);
 datediff
----------
        8
(1 row)

另请参阅

TIMESTAMPDIFF

12 - DAY

以整数形式从输入值中返回日期。

行为类型

如果输入值为 TIMESTAMP、DATE、VARCHAR 或 INTEGER，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

DAY ( value )

参数

value: 要转换的值为以下之一：TIMESTAMP、TIMESTAMPTZ、INTERVAL、VARCHAR 或 INTEGER。

示例

=> SELECT DAY (6);
 DAY
-----
   6
(1 row)

=> SELECT DAY(TIMESTAMP 'sep 22, 2011 12:34');
 DAY
-----
  22
(1 row)

=> SELECT DAY('sep 22, 2011 12:34');
 DAY
-----
  22
(1 row)

=> SELECT DAY(INTERVAL '35 12:34');
 DAY
-----
  35
(1 row)

13 - DAYOFMONTH

以整数形式返回月份第几日。

行为类型

如果目标日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

DAYOFMONTH ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT DAYOFMONTH (TIMESTAMP 'sep 22, 2011 12:34');
 DAYOFMONTH
------------
         22
(1 row)

14 - DAYOFWEEK

以整数形式返回星期几，其中星期日是第 1 天。

行为类型

如果目标日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

DAYOFWEEK ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT DAYOFWEEK (TIMESTAMP 'sep 17, 2011 12:34');
 DAYOFWEEK
-----------
         7
(1 row)

15 - DAYOFWEEK_ISO

以整数形式返回 ISO 8061 星期几，其中星期一是第 1 天。

行为类型

如果目标日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

DAYOFWEEK_ISO ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT DAYOFWEEK_ISO(TIMESTAMP 'Sep 22, 2011 12:34');
 DAYOFWEEK_ISO
---------------
             4
(1 row)

以下示例显示了如何组合 DAYOFWEEK_ISO、WEEK_ISO 和 YEAR_ISO 函数以查找 ISO 星期几、星期和年：

=> SELECT DAYOFWEEK_ISO('Jan 1, 2000'), WEEK_ISO('Jan 1, 2000'),YEAR_ISO('Jan1,2000');
 DAYOFWEEK_ISO | WEEK_ISO | YEAR_ISO
---------------+----------+----------
             6 |       52 |     1999
(1 row)

另请参阅

16 - DAYOFYEAR

以整数形式返回年份第几日，其中 1 月 1 日是第 1 天。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

DAYOFYEAR ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT DAYOFYEAR (TIMESTAMP 'SEPT 22,2011 12:34');
 DAYOFYEAR
-----------
       265
(1 row)

17 - DAYS

返回指定日期的整数值，其中 1 AD 为 1。如果日期早于 1 AD，则 DAYS 返回负整数。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

DAYS ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT DAYS (DATE '2011-01-22');
  DAYS
--------
 734159
(1 row)

=> SELECT DAYS (DATE 'March 15, 0044 BC');
  DAYS
--------
 -15997
(1 row)

18 - EXTRACT

返回子字段，例如日期/时间值中的年份或小时，然后返回类型为 NUMERIC 的值。 EXTRACT 旨在用于计算处理，而不是用于格式化日期/时间值以进行显示。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 INTERVAL，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

EXTRACT ( field FROM date )

参数

field

一个常数值，指定要从 date 中提取的子字段（请参阅下文的字段值）。

date

要处理的日期，是求值结果具有以下一种数据类型的表达式：

DATE （转换为 TIMESTAMP）
TIMESTAMP/TIMESTAMPTZ
INTERVAL

字段值

示例

从当前 TIMESTAMP 中提取季度中的星期几和日期：

=> SELECT CURRENT_TIMESTAMP AS NOW;
              NOW
-------------------------------
 2016-05-03 11:36:08.829004-04
(1 row)
=> SELECT EXTRACT (DAY FROM CURRENT_TIMESTAMP);
 date_part
-----------
         3
(1 row)

=> SELECT EXTRACT (DOQ FROM CURRENT_TIMESTAMP);
 date_part
-----------
        33
(1 row)

从当前时间中提取时区小时：

=> SELECT CURRENT_TIMESTAMP;
           ?column?
-------------------------------
 2016-05-03 11:36:08.829004-04
(1 row)

=>  SELECT EXTRACT(TIMEZONE_HOUR FROM CURRENT_TIMESTAMP);
 date_part
-----------
        -4
(1 row)

提取从 01-01-1970 00:00 至今的秒数：

=> SELECT EXTRACT(EPOCH FROM '2001-02-16 20:38:40-08'::TIMESTAMPTZ);
    date_part
------------------
 982384720.000000
(1 row)

提取 01-01-1970 00:00 和在此之前 5 天 3 小时之间的秒数：

=> SELECT EXTRACT(EPOCH FROM -'5 days 3 hours'::INTERVAL);
   date_part
----------------
 -442800.000000
(1 row)

将上个示例中的结果转换为 TIMESTAMP：

=> SELECT 'EPOCH'::TIMESTAMPTZ -442800  * '1 second'::INTERVAL;
        ?column?
------------------------
 1969-12-26 16:00:00-05
(1 row)

19 - GETDATE

以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。此函数与 SYSDATE 相同。

GETDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETDATE 将 STATEMENT_TIMESTAMP 从 TIMESTAMPTZ 转换为 TIMESTAMP。

行为类型

稳定

语法

GETDATE()

示例

=> SELECT GETDATE();
          GETDATE
----------------------------
 2011-03-07 13:21:29.497742
(1 row)

另请参阅

日期/时间表达式

20 - GETUTCDATE

以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。

GETUTCDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETUTCDATE 于 TIME ZONE 'UTC' 转换 STATEMENT_TIMESTAMP。

行为类型

稳定

语法

GETUTCDATE()

示例

=> SELECT GETUTCDATE();
         GETUTCDATE
----------------------------
 2011-03-07 20:20:26.193052
(1 row)

另请参阅

日期/时间表达式

21 - HOUR

以整数形式返回指定日期的小时部分，其中 0 指 00:00 到 00:59。

行为类型

如果指定的日期为 TIMESTAMP，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

HOUR( date )

参数

date

处理日期，具有以下一种数据类型：

INTERVAL

示例

=> SELECT HOUR (TIMESTAMP 'sep 22, 2011 12:34');
 HOUR
------
   12
(1 row)
=> SELECT HOUR (INTERVAL '35 12:34');
 HOUR
------
   12
(1 row)
=> SELECT HOUR ('12:34');
 HOUR
------
   12
(1 row)

22 - ISFINITE

测试特殊 TIMESTAMP 常量 INFINITY 并返回 BOOLEAN 类型的值。

行为类型

不可变

语法

ISFINITE ( timestamp )

参数

timestamp: TIMESTAMP 类型的表达式

示例

SELECT ISFINITE(TIMESTAMP '2009-02-16 21:28:30');
 ISFINITE
----------
 t
(1 row)

SELECT ISFINITE(TIMESTAMP 'INFINITY');
 ISFINITE
----------
 f
(1 row)

23 - JULIAN_DAY

根据儒略历返回指定日期的整数值，其中 1 代表儒略时期的第一天，即公元前 4713 年 1 月 1 日（对于公历，则为公元前 4714 年 11 月 24 日）。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

JULIAN_DAY ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT JULIAN_DAY (DATE 'MARCH 15, 0044 BC');
 JULIAN_DAY
------------
    1705428
(1 row)

=> SELECT JULIAN_DAY (DATE '2001-01-01');
 JULIAN_DAY
------------
    2451911
(1 row)

24 - LAST_DAY

返回指定日期内月份的最后一天。

行为类型

如果指定的是 TIMESTAMP 或 DATE，则为不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

LAST_DAY ( date )

参数

date

处理日期，具有以下一种数据类型：

计算每月的第一天

SQL 不支持任何函数返回给定日期当月第一天。必须使用其他函数解决此限制。例如：

=> SELECT DATE ('2022/07/04') - DAYOFMONTH ('2022/07/04') +1;
  ?column?
------------
 2022-07-01
(1 row)

=> SELECT LAST_DAY('1929/06/06') - (SELECT DAY(LAST_DAY('1929/06/06'))-1);
  ?column?
------------
 1929-06-01
(1 row)

示例

以下示例将 2 月的最后一天返回为 29，因为 2016 年是闰年：

=> SELECT LAST_DAY('2016-02-28 23:30 PST') "Last Day";
  Last Day
------------
 2016-02-29
(1 row)

以下示例返回非闰年 2 月的最后一天：

> SELECT LAST_DAY('2017/02/03') "Last";
    Last
------------
 2017-02-28
(1 row)

以下示例将字符串值转换为指定的 DATE 类型后返回 3 月的最后一天：

=> SELECT LAST_DAY('2003/03/15') "Last";
    Last
------------
 2012-03-31
(1 row)

25 - LOCALTIME

返回 TIME 类型值，代表当前事务的开始时间。

事务处理过程中返回值保持不变。因此，在同一事务中多次调用 LOCALTIME 将返回相同的时间戳。

行为类型

稳定

语法

LOCALTIME [ ( precision ) ]

参数

precision: 将结果在秒字段中舍入到指定的小数位数。

示例

=> CREATE TABLE t1 (a int, b int);
CREATE TABLE

=> INSERT INTO t1 VALUES (1,2);
 OUTPUT
--------
      1
(1 row)

=> SELECT LOCALTIME time;
    time
-----------------
 15:03:14.595296
(1 row)

=> INSERT INTO t1 VALUES (3,4);
 OUTPUT
--------
      1
(1 row)

=> SELECT LOCALTIME;
    time
-----------------
 15:03:14.595296
(1 row)

=> COMMIT;
COMMIT
=> SELECT LOCALTIME;
    time
-----------------
 15:03:49.738032
(1 row)

26 - LOCALTIMESTAMP

返回 TIMESTAMP/TIMESTAMPTZ 类型值，代表当前事务的开始时间，并在事务关闭之前保持不变。因此，在给定事务中多次调用 LOCALTIMESTAMP 将返回相同的时间戳。

行为类型

稳定

语法

LOCALTIMESTAMP [ ( precision ) ]

参数

precision: 将结果在秒字段中舍入到指定的小数位数。

示例

=> CREATE TABLE t1 (a int, b int);
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2);
 OUTPUT
--------
      1
(1 row)

=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
    local timestamp
------------------------
 2021-03-05 10:48:58.26
(1 row)

=> INSERT INTO t1 VALUES (3,4);
 OUTPUT
--------
      1
(1 row)

=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
    local timestamp
------------------------
 2021-03-05 10:48:58.26
(1 row)

=> COMMIT;
COMMIT
=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
    local timestamp
------------------------
 2021-03-05 10:50:08.99
(1 row)

27 - MICROSECOND

以整数形式返回指定日期的微秒部分。

行为类型

如果指定的日期为 TIMESTAMP、INTERVAL 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

MICROSECOND ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT MICROSECOND (TIMESTAMP 'Sep 22, 2011 12:34:01.123456');
 MICROSECOND
-------------
      123456
(1 row)

28 - MIDNIGHT_SECONDS

在指定日期内，返回午夜与日期时间部分之间的秒数。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

MIDNIGHT_SECONDS ( date )

参数

date

处理日期，具有以下一种数据类型：

示例

获取自午夜以来的秒数：

=> SELECT MIDNIGHT_SECONDS(CURRENT_TIMESTAMP);
 MIDNIGHT_SECONDS
------------------
            36480
(1 row)

获取 2016 年 3 月 3 日午夜和正午之间的秒数：

=> SELECT MIDNIGHT_SECONDS('3-3-2016 12:00'::TIMESTAMP);
 MIDNIGHT_SECONDS
------------------
            43200
(1 row)

29 - MINUTE

以整数形式返回指定日期的分钟部分。

行为类型

如果指定的日期为 TIMESTAMP、DATE、VARCHAR 或 INTERVAL，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

MINUTE ( date )

参数

date

处理日期，具有以下一种数据类型：

INTERVAL

示例

=> SELECT MINUTE('12:34:03.456789');
 MINUTE
--------
     34
(1 row)
=>SELECT MINUTE (TIMESTAMP 'sep 22, 2011 12:34');
 MINUTE
--------
     34
(1 row)
=> SELECT MINUTE(INTERVAL '35 12:34:03.456789');
 MINUTE
--------
     34
(1 row)

30 - MONTH

以整数形式返回指定日期的月份部分。

行为类型

如果指定的日期为 TIMESTAMP、DATE、VARCHAR 或 INTERVAL，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

MONTH ( date )

参数

date

处理日期，具有以下一种数据类型：

INTERVAL

示例

在下例中，Vertica 返回指定字符串的月份部分。例如，'6-9' 表示 9 月 6 日。

=> SELECT MONTH('6-9');
 MONTH
-------
     9
(1 row)
=> SELECT MONTH (TIMESTAMP 'sep 22, 2011 12:34');
 MONTH
-------
     9
(1 row)
=> SELECT MONTH(INTERVAL '2-35' year to month);
 MONTH
-------
    11
(1 row)

31 - MONTHS_BETWEEN

返回两个日期之间的月份数。 MONTHS_BETWEEN 可返回整数或 FLOAT：

整数：date1 和 date2 的日期部分相同，且两个日期都不是本月的最后一天。 MONTHS_BETWEEN 如果 date1 和 date2 中的两个日期都是各自月份的最后一个，也返回整数。例如，MONTHS_BETWEEN 将 4 月 30 日到 3 月 31 日之间的差异计算为 1 个月。
FLOAT：date1 和 date2 的日期部分不同，且其中一个或两个日期并非各自月份的最后一天。例如，4 月 2 日和 3 月 1 日之间的差异为 1.03225806451613。为计算月份部分，MONTHS_BETWEEN 假设所有月份都包含 31 天。

MONTHS_BETWEEN 忽略时间戳时间部分。

行为类型

如果两个日期实参均为数据类型 TIMESTAMP 或 DATE，则是不可变
如果任一日期为 TIMESTAMPTZ，则是稳定

语法

MONTHS_BETWEEN ( date1 , date2 );

参数

date1 date2

指定要求值的日期，其中 date1 和 date2 的求值结果为以下数据类型之一：

DATE
TIMESTAMP
TIMESTAMPTZ

如果 date1 < date2，则 MONTHS_BETWEEN 返回负值。

示例

返回 2016 年 4 月 7 日到 2015 年 1 月 7 日之间的月份数：

=> SELECT MONTHS_BETWEEN ('04-07-16'::TIMESTAMP, '01-07-15'::TIMESTAMP);
 MONTHS_BETWEEN
----------------
             15
(1 row)

返回 2016 年 3 月 31 日到 2016 年 2 月 28 日之间的月份数（MONTHS_BETWEEN 假设两个月都包含 31 天）：

=> SELECT MONTHS_BETWEEN ('03-31-16'::TIMESTAMP, '02-28-16'::TIMESTAMP);
  MONTHS_BETWEEN
------------------
 1.09677419354839
(1 row)

返回 2016 年 3 月 31 日到 2016 年 2 月 29 日之间的月份数：

=> SELECT MONTHS_BETWEEN ('03-31-16'::TIMESTAMP, '02-29-16'::TIMESTAMP);
 MONTHS_BETWEEN
----------------
              1
(1 row)

32 - NEW_TIME

将时间戳值从一个时区转换为另一个时区并返回一个 TIMESTAMP。

行为类型

不可变

语法

NEW_TIME( 'timestamp' , 'timezone1' , 'timezone2')

参数

timestamp

要转换的时间戳符合以下格式之一：

TIMESTAMP/ TIMESTAMPTZ
DATE
可转换为 TIMESTAMP 的字符串，例如 May 24, 2012 10:00。

timezone1 timezone2

指定源时区和目标时区， /opt/vertica/share/timezonesets 中定义的字符串之一。例如：

GMT：格林威治标准时间
AST / ADT：大西洋标准/夏令时
EST / EDT：东部标准/夏令时
CST / CDT：中部标准/夏令时
MST / MDT：山区标准/夏令时
PST / PDT：太平洋标准/夏令时

示例

将指定的时间从东部标准时间 (EST) 转换为太平洋标准时间 (PST)：

=> SELECT NEW_TIME('05-24-12 13:48:00', 'EST', 'PST');
      NEW_TIME
---------------------
 2012-05-24 10:48:00
(1 row)

将 2012 年 1 月凌晨 1:00 从 EST 转换为 PST：

=> SELECT NEW_TIME('01-01-12 01:00:00', 'EST', 'PST');
      NEW_TIME
---------------------
 2011-12-31 22:00:00
(1 row)

将 EST 当前时间转换为 PST：


=> SELECT NOW();
              NOW
-------------------------------
 2016-12-09 10:30:36.727307-05
(1 row)

=> SELECT NEW_TIME('NOW', 'EDT', 'CDT');
          NEW_TIME
----------------------------
 2016-12-09 09:30:36.727307
(1 row)

以下示例以格林威治标准时间返回“公元前 45 年”，并将其转换为纽芬兰标准时间：

=>  SELECT NEW_TIME('April 1, 45 BC', 'GMT', 'NST')::DATE;
   NEW_TIME
---------------
 0045-03-31 BC
(1 row)

33 - NEXT_DAY

返回指定日期之后一周中特定一天的第一个实例的日期。

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

语法

NEXT_DAY( 'date', 'day‑string')

参数

date

处理日期，具有以下一种数据类型：

day‑string

要处理的星期几，CHAR 或 VARCHAR 字符串或字符常量。提供完整英文名称（如星期二）或任何常规缩写（如 Tue 或 Tues）。day-string 不区分大小写，并忽略尾部空格。

示例

获取 2016 年 4 月 29 日之后的第一个星期一的日期：

=> SELECT NEXT_DAY('4-29-2016'::TIMESTAMP,'Monday') "NEXT DAY" ;
  NEXT DAY
------------
 2016-05-02
(1 row)

获取今天之后的第一个星期二：

SELECT NEXT_DAY(CURRENT_TIMESTAMP,'tues') "NEXT DAY" ;
  NEXT DAY
------------
 2016-05-03
(1 row)

34 - NOW [日期/时间]

返回一个 TIMESTAMP WITH TIME ZONE 类型的值，它表示当前事务的开始时间。NOW 等于 CURRENT_TIMESTAMP，除非不接受精度参数。

事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIMESTAMP 将返回相同的时间戳。

行为类型

稳定

语法

NOW()

示例


=> CREATE TABLE t1 (a int, b int);
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2);
 OUTPUT
--------
      1
(1 row)

=> SELECT NOW();
             NOW
------------------------------
 2016-12-09 13:00:08.74685-05
(1 row)

=> INSERT INTO t1 VALUES (3,4);
 OUTPUT
--------
      1
(1 row)

=> SELECT NOW();
             NOW
------------------------------
 2016-12-09 13:00:08.74685-05
(1 row)

=> COMMIT;
COMMIT
dbadmin=> SELECT NOW();
              NOW
-------------------------------
 2016-12-09 13:01:31.420624-05
(1 row)

35 - OVERLAPS

计算两个时间段，并在其重叠时返回 true，否则返回 false。

行为类型

当同时使用 TIMESTAMP 和 TIMESTAMPTZ 或将 TIMESTAMPTZ 与 INTERVAL 配合使用时，则为稳定
否则为不可变

语法

( start, end ) OVERLAPS ( start, end )
( start, interval) OVERLAPS ( start, interval )

参数

start: DATE、TIME 或 TIMESTAMP/TIMESTAMPTZ 值，用于指定时间段的开始日期。
end: DATE、TIME 或 TIMESTAMP/TIMESTAMPTZ 值，用于指定时间段的结束日期。
interval: 指定时间段长度的值。

示例

求值日期范围 2016 年 2 月 16 日 - 12 月 21 日与 2008 年 10 月 10 日 - 2016 年 10 月 3 日是否重叠：

=> SELECT (DATE '2016-02-16', DATE '2016-12-21') OVERLAPS (DATE '2008-10-30', DATE '2016-10-30');
 overlaps
----------
 t
(1 row)

求值日期范围 2016 年 2 月 16 日 - 12 月 21 日与 2008 年 1 月 1 日 - 10 月 30 日 - 2016 年 10 月 3 日是否重叠：

=> SELECT (DATE '2016-02-16', DATE '2016-12-21') OVERLAPS (DATE '2008-01-30', DATE '2008-10-30');
 overlaps
----------
 f
(1 row)

求值日期范围 2016 年 2 月 2 日 + 1 周与 2016 年 10 月 16 日 - 8 个月的日期范围是否重叠：

=> SELECT (DATE '2016-02-16', INTERVAL '1 week') OVERLAPS (DATE '2016-10-16', INTERVAL '-8 months');
 overlaps
----------
 t
(1 row)

36 - QUARTER

以整数形式返回指定日期的日历季度，其中一月至三月的季度为 1。

语法

QUARTER ( date )

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变。
如果指定的日期为 TIMESTAMPTZ，则是稳定

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT QUARTER (TIMESTAMP 'sep 22, 2011 12:34');
 QUARTER
---------
       3
(1 row)

37 - ROUND

舍入指定的日期或时间。如果省略精度实参，ROUND 将舍入到天 (DD) 精度。

行为类型

如果目标日期为 TIMESTAMP 或 DATE ，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

ROUND( rounding‑target[, 'precision'] )

参数

rounding‑target

求值结果为以下数据类型之一的表达式：

precision

一个字符串常量，指定舍入值的精度，为以下之一：

世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS

注意

DATE 表达式不支持时、分和秒舍入。

示例

五入到最近的小时：

=> SELECT ROUND(CURRENT_TIMESTAMP, 'HH');
        ROUND
---------------------
 2016-04-28 15:00:00
(1 row)

五入到最近的月份：

=> SELECT ROUND('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
        ROUND
---------------------
 2011-10-01 00:00:00
(1 row)

另请参阅

TIMESTAMP_ROUND

38 - SECOND

以整数形式返回指定日期的秒部分。

语法

SECOND ( date )

行为类型

不可变，TIMESTAMPTZ 实参除外，TIMESTAMPTZ 实参为稳定。

参数

date

处理日期，具有以下一种数据类型：

示例

=> SELECT SECOND ('23:34:03.456789');
 SECOND
--------
      3
(1 row)
=> SELECT SECOND (TIMESTAMP 'sep 22, 2011 12:34');
 SECOND
--------
      0
(1 row)
=> SELECT SECOND (INTERVAL '35 12:34:03.456789');
 SECOND
--------
      3
(1 row)

39 - STATEMENT_TIMESTAMP

类似于 TRANSACTION_TIMESTAMP，返回 TIMESTAMP WITH TIME ZONE 类型值，代表当前语句的开始时间。

语句执行过程中返回值保持不变。因此，语句执行的不同阶段始终具有相同的时间戳。

行为类型

稳定

语法

STATEMENT_TIMESTAMP()

示例

=> SELECT foo, bar FROM (SELECT STATEMENT_TIMESTAMP() AS foo)foo, (SELECT STATEMENT_TIMESTAMP() as bar)bar;
              foo              |              bar
-------------------------------+-------------------------------
 2016-12-07 14:55:51.543988-05 | 2016-12-07 14:55:51.543988-05
(1 row)

另请参阅

40 - SYSDATE

以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。此函数与 GETDATE 相同。

SYSDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETDATE 将 STATEMENT_TIMESTAMP 从 TIMESTAMPTZ 转换为 TIMESTAMP。

行为类型

稳定

语法

SYSDATE()

注意

您可以不带括号调用此函数。

示例

=> SELECT SYSDATE;
          sysdate
----------------------------
 2016-12-12 06:11:10.699642
(1 row)

另请参阅

日期/时间表达式

41 - TIME_SLICE

按照不同的固定时间间隔聚合数据，并将向上舍入的输入 TIMESTAMP 值返回到与时间片间隔开始或结束时间相对应的值。

提供输入 TIMESTAMP 值，例如 2000-10-28 00:00:01，3 秒时间片间隔的开始时间为 2000-10-28 00:00:00，同一时间片结束时间为 2000-10-28 00:00:03。

行为类型

不可变

语法

TIME_SLICE( expression, slice-length [, 'time‑unit' [, 'start‑or‑end' ] ] )

参数

表达式

以下几项之一：

列类型 TIMESTAMP
可解析为 TIMESTAMP 值的字符串常量。例如：

'2004/10/19 10:23:54'

Vertica 对每一行的表达式求值。

slice-length

指定片长度的正整数。

time‑unit

片的时间单位为以下之一：

HOUR
MINUTE
SECOND （默认值）
MILLISECOND
MICROSECOND

start‑or‑end

使用以下字符串之一指定返回值是否与开始或结束时间关联：

START （默认值）
END

注意

仅当您还提供非 null time‑unit 实参时，才能包含此参数。

null 实参处理

TIME_SLICE 按如下所示处理 null 实参：

TIME_SLICE 在任何一个 slice-length、time-unit 或 start-or-end 参数为 null 时返回错误。
如果表达式为 null 且 slice-length、time‑unit 或 start‑or‑end 包含合法值，则 TIME_SLICE 返回 NULL 值而不是错误。

使用

以下命令返回（默认） 3 秒时间片的开始时间：

=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3);
     TIME_SLICE
---------------------
 2009-09-19 00:00:00
(1 row)

以下命令返回 3 秒时间片的结束时间：

=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'SECOND', 'END');
     TIME_SLICE
---------------------
 2009-09-19 00:00:03
(1 row)

此命令返回使用 3 秒时间片的结果（毫秒）：

=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'ms');
       TIME_SLICE
-------------------------
 2009-09-19 00:00:00.999

(1 row)

此命令返回使用 9 秒时间片的结果（毫秒）：

=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'us');
         TIME_SLICE
----------------------------
 2009-09-19 00:00:00.999999
(1 row)

下一个示例使用 3 秒间隔，输入值为 '00:00:01'。为了特别突出秒数，该示例忽略日期，但所有值均隐含为时间戳的一部分，规定输入为 '00:00:01'：

'00:00:00 ' 是 3 秒时间片的开始时间
'00:00:03 ' 是 3 秒时间片的结束时间。
'00:00:03' 也是 3 秒时间片的 second 开始时间。在时间片界限中，时间片的结束值不属于该时间片，它是下一个时间片的开始值。

时间片间隔不是 60 秒的因数，例如以下示例中，规定片长度为 9，该时间片不会始终以 00 秒数开始或结束：

=> SELECT TIME_SLICE('2009-02-14 20:13:01', 9);
     TIME_SLICE
---------------------
 2009-02-14 20:12:54
(1 row)

这是预期行为，因为所有时间片的以下属性为真：

长度相同
连续（时间片之间没有间隙）
无重叠

为强制上述示例 ('2009-02-14 20:13:01') 的开始时间为 '2009-02-14 20:13:00'，请调整输出时间戳值，使剩余 54 计数至 60：

=> SELECT TIME_SLICE('2009-02-14 20:13:01', 9 )+'6 seconds'::INTERVAL AS time;
        time
---------------------
 2009-02-14 20:13:00
(1 row)

或者，您可以使用能被 60 整除的不同片长度，例如 5：

=> SELECT TIME_SLICE('2009-02-14 20:13:01', 5);
     TIME_SLICE
---------------------
 2009-02-14 20:13:00
(1 row)

TIMESTAMPTZ 值隐式强制转换为 TIMESTAMP。例如，以下两个语句的效果相同。

=> SELECT TIME_SLICE('2009-09-23 11:12:01'::timestamptz, 3);
     TIME_SLICE
---------------------
 2009-09-23 11:12:00
(1 row)


=> SELECT TIME_SLICE('2009-09-23 11:12:01'::timestamptz::timestamp, 3);

     TIME_SLICE
---------------------
 2009-09-23 11:12:00
(1 row)

示例

您可以使用 SQL 分析函数 FIRST_VALUE 和 LAST_VALUE 来找到每个时间片组（属于相同时间片的行集合）内的第一个/最后一个价格。如果您要通过从每个时间片组选择一行来取样输入数据，此结构很实用。

=> SELECT date_key, transaction_time, sales_dollar_amount,TIME_SLICE(DATE '2000-01-01' + date_key + transaction_time, 3),
FIRST_VALUE(sales_dollar_amount)
OVER (PARTITION BY TIME_SLICE(DATE '2000-01-01' + date_key + transaction_time, 3)
     ORDER BY DATE '2000-01-01' + date_key + transaction_time) AS first_value
FROM store.store_sales_fact
LIMIT 20;

 date_key | transaction_time | sales_dollar_amount |     time_slice      | first_value
----------+------------------+---------------------+---------------------+-------------
        1 | 00:41:16         |                 164 | 2000-01-02 00:41:15 |         164
        1 | 00:41:33         |                 310 | 2000-01-02 00:41:33 |         310
        1 | 15:32:51         |                 271 | 2000-01-02 15:32:51 |         271
        1 | 15:33:15         |                 419 | 2000-01-02 15:33:15 |         419
        1 | 15:33:44         |                 193 | 2000-01-02 15:33:42 |         193
        1 | 16:36:29         |                 466 | 2000-01-02 16:36:27 |         466
        1 | 16:36:44         |                 250 | 2000-01-02 16:36:42 |         250
        2 | 03:11:28         |                  39 | 2000-01-03 03:11:27 |          39
        3 | 03:55:15         |                 375 | 2000-01-04 03:55:15 |         375
        3 | 11:58:05         |                 369 | 2000-01-04 11:58:03 |         369
        3 | 11:58:24         |                 174 | 2000-01-04 11:58:24 |         174
        3 | 11:58:52         |                 449 | 2000-01-04 11:58:51 |         449
        3 | 19:01:21         |                 201 | 2000-01-04 19:01:21 |         201
        3 | 22:15:05         |                 156 | 2000-01-04 22:15:03 |         156
        4 | 13:36:57         |                -125 | 2000-01-05 13:36:57 |        -125
        4 | 13:37:24         |                -251 | 2000-01-05 13:37:24 |        -251
        4 | 13:37:54         |                 353 | 2000-01-05 13:37:54 |         353
        4 | 13:38:04         |                 426 | 2000-01-05 13:38:03 |         426
        4 | 13:38:31         |                 209 | 2000-01-05 13:38:30 |         209
        5 | 10:21:24         |                 488 | 2000-01-06 10:21:24 |         488
(20 rows)

TIME_SLICE 将事务处理时间四舍五入至 3 秒片长度。

以下示例使用分析（窗口） OVER 子句来返回每个 3 秒时间片分区中的最后交易价格（按 TickTime 排序的最后一行）：

=> SELECT DISTINCT TIME_SLICE(TickTime, 3), LAST_VALUE(price)OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING);

注意

如果您从分析子句中省略窗口子句，则 LAST_VALUE 默认为 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。结果似乎并不直观，因为与当前分区底部返回值不一样，该函数返回 window 顶部，而且随着正处理的当前输入行持续变化。有关详细信息，请参阅时序分析和 SQL 分析。

在下一个示例中，会对每个输入记录求一次 FIRST_VALUE 的值，而且按升序值对数据进行排序。使用 SELECT DISTINCT 移除重复值，每个 TIME_SLICE 仅返回一个输出记录：

=> SELECT DISTINCT TIME_SLICE(TickTime, 3), FIRST_VALUE(price)OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ASC)
FROM tick_store;
     TIME_SLICE      | ?column?
---------------------+----------
 2009-09-21 00:00:06 |    20.00
 2009-09-21 00:00:09 |    30.00
 2009-09-21 00:00:00 |    10.00
(3 rows)

上述查询的信息输出也可以返回每个时间片内的 MIN、MAX 和 AVG 交易价格。

=> SELECT DISTINCT TIME_SLICE(TickTime, 3),FIRST_VALUE(Price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ASC),
  MIN(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)),
  MAX(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)),
  AVG(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3))
FROM tick_store;

另请参阅

42 - TIMEOFDAY

以文本字符串的形式返回时钟时间。事务处理过程中函数结果提前。

行为类型

易变

语法

TIMEOFDAY()

示例

=> SELECT TIMEOFDAY();
              TIMEOFDAY
-------------------------------------
 Mon Dec 12 08:18:01.022710 2016 EST
(1 row)

43 - TIMESTAMPADD

将指定数量的间隔添加到 TIMESTAMP 或 TIMESTAMPTZ 值，并返回相同数据类型的结果。

行为类型

如果输入日期为 TIMESTAMP，则是不可变
如果输入日期为 TIMESTAMPTZ，则是稳定

语法

TIMESTAMPADD ( datepart, count, start‑date );

参数

datepart

指定 TIMESTAMPADD 添加到指定开始日期的时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：

TIMESTAMPADD((expression), interval, start;

datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：

year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us

count

整数或整数表达式，指定要添加到 start‑date 的 datepart 间隔数。

start‑date

TIMESTAMP 或 TIMESTAMPTZ 值。

示例

向当前日期添加两个月：

=> SELECT CURRENT_TIMESTAMP AS Today;
           Today
-------------------------------
 2016-05-02 06:56:57.923045-04
(1 row)

=> SELECT TIMESTAMPADD (MONTH, 2, (CURRENT_TIMESTAMP)) AS TodayPlusTwoMonths;;
      TodayPlusTwoMonths
-------------------------------
 2016-07-02 06:56:57.923045-04
(1 row)

向当月月初添加 14 天：

=> SELECT TIMESTAMPADD (DD, 14, (SELECT TRUNC((CURRENT_TIMESTAMP), 'MM')));
    timestampadd
---------------------
 2016-05-15 00:00:00
(1 row)

44 - TIMESTAMPDIFF

以指定的间隔返回两个 TIMESTAMP 或 TIMESTAMPTZ 值之间的时间跨度。 TIMESTAMPDIFF 在其计算中不包括开始日期。

行为类型

如果开始日期和结束日期为 TIMESTAMP，则是不可变
如果开始日期和结束日期为 TIMESTAMPTZ，则是稳定

语法

TIMESTAMPDIFF ( datepart, start, end );

参数

datepart

指定 TIMESTAMPDIFF 返回的日期或时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：

TIMESTAMPDIFF((expression), start, end );

datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：

year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us

start, end

指定开始日期和结束日期，其中 start 和 end 的求值结果为以下数据类型之一：

TIMESTAMP/TIMESTAMPTZ
TIMESTAMPTZ

如果 end < start，则 TIMESTAMPDIFF 返回负值。

日期部分间隔

TIMESTAMPDIFF 使用 datepart 实参计算两个日期之间的间隔数，而不是二者之间的实际时间量。有关详细信息，请参阅 DATEDIFF。

示例

=> SELECT TIMESTAMPDIFF (YEAR,'1-1-2006 12:34:00', '1-1-2008 12:34:00');
 timestampdiff
---------------
             2
(1 row)

另请参阅

DATEDIFF

45 - TIMESTAMP_ROUND

对指定的 TIMESTAMP 进行四舍五入。如果省略精度实参，TIMESTAMP_ROUND 将舍入到天 (DD) 精度。

行为类型

如果目标日期为 TIMESTAMP，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

TIMESTAMP_ROUND ( rounding‑target[, 'precision'] )

参数

rounding‑target

求值结果为以下数据类型之一的表达式：

TIMESTAMP/TIMESTAMPTZ
TIMESTAMPTZ

precision

一个字符串常量，指定舍入值的精度，为以下之一：

世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS

注意

DATE 表达式不支持时、分和秒舍入。

示例

五入到最近的小时：

=> SELECT TIMESTAMP_ROUND(CURRENT_TIMESTAMP, 'HH');
        ROUND
---------------------
 2016-04-28 15:00:00
(1 row)

五入到最近的月份：

=> SELECT TIMESTAMP_ROUND('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
        ROUND
---------------------
 2011-10-01 00:00:00
(1 row)

另请参阅

ROUND

46 - TIMESTAMP_TRUNC

截断指定的 TIMESTAMP。如果省略精度实参，TIMESTAMP_TRUNC 将截断到天 (DD) 精度。

行为类型

如果目标日期为 TIMESTAMP，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

TIMESTAMP_TRUNC( trunc‑target[, 'precision'] )

参数

trunc‑target

求值结果为以下数据类型之一的表达式：

TIMESTAMP/TIMESTAMPTZ
TIMESTAMPTZ

precision

一个字符串常量，指定截断值的精度，为以下之一：

世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
日期： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS

注意

DATE 表达式不支持时、分和秒截断。

示例

截断到当前小时：

=> SELECT TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, 'HH');
   TIMESTAMP_TRUNC
---------------------
 2016-04-29 08:00:00
(1 row)

截断到月份：

=> SELECT TIMESTAMP_TRUNC('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
   TIMESTAMP_TRUNC
---------------------
 2011-09-01 00:00:00
(1 row)

另请参阅

TRUNC

47 - TRANSACTION_TIMESTAMP

返回 TIME WITH TIMEZONE 类型的值，代表当前事务的开始时间。

事务处理过程中返回值保持不变。因此，在同一事务中多次调用 TRANSACTION_TIMESTAMP 将返回相同的时间戳。

TRANSACTION_TIMESTAMP 等于 CURRENT_TIMESTAMP，除非不接受精度参数。

行为类型

稳定

语法

TRANSACTION_TIMESTAMP()

示例

=> SELECT foo, bar FROM (SELECT TRANSACTION_TIMESTAMP() AS foo)foo, (SELECT TRANSACTION_TIMESTAMP() as bar)bar;
              foo              |              bar
-------------------------------+-------------------------------
 2016-12-12 08:18:00.988528-05 | 2016-12-12 08:18:00.988528-05
(1 row)

另请参阅

CLOCK_TIMESTAMP
STATEMENT_TIMESTAMP

48 - TRUNC

截断指定的日期或时间。如果省略精度实参，TRUNC 将截断到天 (DD) 精度。

行为类型

如果目标日期为 TIMESTAMP 或 DATE ，则是不可变
如果目标日期为 TIMESTAMPTZ，则是稳定

语法

TRUNC( trunc‑target[, 'precision'] )

参数

trunc‑target

求值结果为以下数据类型之一的表达式：

precision

一个字符串常量，指定截断值的精度，为以下之一：

世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS

注意

DATE 表达式不支持时、分和秒截断。

示例

截断到当前小时：

=> => SELECT TRUNC(CURRENT_TIMESTAMP, 'HH');
        TRUNC
---------------------
 2016-04-29 10:00:00
(1 row)

截断到月份：

=> SELECT TRUNC('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
   TIMESTAMP_TRUNC
---------------------
 2011-09-01 00:00:00
(1 row)

另请参阅

TIMESTAMP_TRUNC

49 - WEEK

以整数形式返回指定日期为一年中的第几周，其中第一周从 1 月 1 日或之前的第一个星期日开始。

语法

WEEK ( date )

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

参数

date

处理日期，具有以下一种数据类型：

示例

1 月 2 日是星期六，所以 WEEK 返回 1：

=> SELECT WEEK ('1-2-2016'::DATE);
 WEEK
------
    1
(1 row)

1 月 3 日是 2016 年的第二个星期日，所以 WEEK 返回 2：

=> SELECT WEEK ('1-3-2016'::DATE);
 WEEK
------
    2
(1 row)

50 - WEEK_ISO

以整数形式返回指定日期为一年中的第几周，其中第一周从星期一开始，包含 1 月 4 日。此函数符合 ISO 8061 标准。

语法

WEEK_ISO ( date )

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

参数

date

处理日期，具有以下一种数据类型：

示例

2016 年的第一周自 1 月 4 日星期一开始：

=> SELECT WEEK_ISO ('1-4-2016'::DATE);
 WEEK_ISO
----------
        1
(1 row)

2016 年 1 月 3 日返回上一年（2015 年）的第 53 周：

=> SELECT WEEK_ISO ('1-3-2016'::DATE);
 WEEK_ISO
----------
       53
(1 row)

2015 年 1 月 4 日是星期日，因此 2015 年的第一周自上一个星期一（2014 年 12 月 29 日）开始：

=> SELECT WEEK_ISO ('12-29-2014'::DATE);
 WEEK_ISO
----------
        1
(1 row)

51 - YEAR

返回表示指定日期的年份部分的整数。

语法

YEAR( date )

行为类型

如果指定的日期为 TIMESTAMP、DATE、VARCHAR 或 INTERVAL，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

参数

date

处理日期，具有以下一种数据类型：

INTERVAL

示例

=> SELECT YEAR(CURRENT_DATE::DATE);
 YEAR
------
 2016
(1 row)

另请参阅

YEAR_ISO

52 - YEAR_ISO

返回表示指定日期的年份部分的整数。返回值基于 ISO 8061 标准。

ISO 年的第一周是包含 1 月 4 日的一周。

语法

YEAR_ISO ( date )

行为类型

如果指定的日期为 TIMESTAMP、DATE 或 VARCHAR，则是不可变
如果指定的日期为 TIMESTAMPTZ，则是稳定

参数

date

处理日期，具有以下一种数据类型：

示例

> SELECT YEAR_ISO(CURRENT_DATE::DATE);
 YEAR_ISO
----------
     2016
(1 row)

另请参阅

YEAR