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

特定于数据类型的函数

1: 集合函数

1.1: APPLY_AVG
1.2: APPLY_COUNT (ARRAY_COUNT)
1.3: APPLY_COUNT_ELEMENTS (ARRAY_LENGTH)
1.4: APPLY_MAX
1.5: APPLY_MIN
1.6: APPLY_SUM
1.7: ARRAY_CAT
1.8: ARRAY_CONTAINS
1.9: ARRAY_DIMS
1.10: ARRAY_FIND
1.11: CONTAINS
1.12: EXPLODE
1.13: IMPLODE
1.14: SET_UNION
1.15: STRING_TO_ARRAY
1.16: TO_JSON

2: 日期/时间函数

2.1: ADD_MONTHS
2.2: AGE_IN_MONTHS
2.3: AGE_IN_YEARS
2.4: CLOCK_TIMESTAMP
2.5: CURRENT_DATE
2.6: CURRENT_TIME
2.7: CURRENT_TIMESTAMP
2.8: DATE_PART
2.9: DATE
2.10: DATE_TRUNC
2.11: DATEDIFF
2.12: DAY
2.13: DAYOFMONTH
2.14: DAYOFWEEK
2.15: DAYOFWEEK_ISO
2.16: DAYOFYEAR
2.17: DAYS
2.18: EXTRACT
2.19: GETDATE
2.20: GETUTCDATE
2.21: HOUR
2.22: ISFINITE
2.23: JULIAN_DAY
2.24: LAST_DAY
2.25: LOCALTIME
2.26: LOCALTIMESTAMP
2.27: MICROSECOND
2.28: MIDNIGHT_SECONDS
2.29: MINUTE
2.30: MONTH
2.31: MONTHS_BETWEEN
2.32: NEW_TIME
2.33: NEXT_DAY
2.34: NOW [日期/时间]
2.35: OVERLAPS
2.36: QUARTER
2.37: ROUND
2.38: SECOND
2.39: STATEMENT_TIMESTAMP
2.40: SYSDATE
2.41: TIME_SLICE
2.42: TIMEOFDAY
2.43: TIMESTAMPADD
2.44: TIMESTAMPDIFF
2.45: TIMESTAMP_ROUND
2.46: TIMESTAMP_TRUNC
2.47: TRANSACTION_TIMESTAMP
2.48: TRUNC
2.49: WEEK
2.50: WEEK_ISO
2.51: YEAR
2.52: YEAR_ISO

3: IP 地址函数

3.1: INET_ATON
3.2: INET_NTOA
3.3: V6_ATON
3.4: V6_NTOA
3.5: V6_SUBNETA
3.6: V6_SUBNETN
3.7: V6_TYPE

4: 序列函数

4.1: CURRVAL
4.2: NEXTVAL

5: 字符串函数

5.1: ASCII
5.2: BIT_LENGTH
5.3: BITCOUNT
5.4: BITSTRING_TO_BINARY
5.5: BTRIM
5.6: CHARACTER_LENGTH
5.7: CHR
5.8: COLLATION
5.9: CONCAT
5.10: DECODE
5.11: EDIT_DISTANCE
5.12: GREATEST
5.13: GREATESTB
5.14: HEX_TO_BINARY
5.15: HEX_TO_INTEGER
5.16: INITCAP
5.17: INITCAPB
5.18: INSERT
5.19: INSTR
5.20: INSTRB
5.21: ISUTF8
5.22: LEAST
5.23: LEASTB
5.24: LEFT
5.25: LENGTH
5.26: LOWER
5.27: LOWERB
5.28: LPAD
5.29: LTRIM
5.30: MAKEUTF8
5.31: MD5
5.32: OCTET_LENGTH
5.33: OVERLAY
5.34: OVERLAYB
5.35: POSITION
5.36: POSITIONB
5.37: QUOTE_IDENT
5.38: QUOTE_LITERAL
5.39: QUOTE_NULLABLE
5.40: REPEAT
5.41: REPLACE
5.42: RIGHT
5.43: RPAD
5.44: RTRIM
5.45: SHA1
5.46: SHA224
5.47: SHA256
5.48: SHA384
5.49: SHA512
5.50: SOUNDEX
5.51: SOUNDEX_MATCHES
5.52: SPACE
5.53: SPLIT_PART
5.54: SPLIT_PARTB
5.55: STRPOS
5.56: STRPOSB
5.57: SUBSTR
5.58: SUBSTRB
5.59: SUBSTRING
5.60: TRANSLATE
5.61: TRIM
5.62: UPPER
5.63: UPPERB

6: URI 函数

6.1: URI_PERCENT_DECODE
6.2: URI_PERCENT_ENCODE

7: UUID 函数

7.1: UUID_GENERATE

Vertica 提供了用于特定数据类型的函数，如此部分所述。

1 - 集合函数

此部分中的函数适用于集合类型（数组和集合）。

某些函数将聚合操作（例如 sum）应用于集合。这些函数名称都以 APPLY 开头。

此部分中的其他函数专门对数组或集合进行操作，如各个参考页所示。数组函数对原生数组值和外部表中的数组值进行操作。

注意

数组是从 0 开始索引的。第一个元素在 0 中的序号位置，第二个是 1，依此类推。索引对集合没有意义。
除非另有说明，否则函数仅适用于一维 (1D) 集合。要使用多维数组，您必须首先取消对一维数组类型的引用。集合只能是一维的。

1.1 - APPLY_AVG

返回具有数值的集合（数组或集合）中所有元素的平均值。

行为类型

不可变

语法

APPLY_AVG(collection)

参数

collection: 目标集合

NULL 处理

以下情况返回 NULL：

如果输入集合为 NULL
如果输入集合仅包含 null 值
如果输入集合为空

如果输入集合包含空元素和非空元素组合，则在计算平均值时仅考虑非空值。

示例

=> SELECT apply_avg(ARRAY[1,2.4,5,6]);
apply_avg
-----------
3.6
(1 row)

另请参阅

APPLY_SUM

1.2 - APPLY_COUNT (ARRAY_COUNT)

返回集合（数组或集合）中非空元素的总数。要计算包括空值在内的所有元素，请使用 APPLY_COUNT_ELEMENTS (ARRAY_LENGTH)。

行为类型

不可变

语法

APPLY_COUNT(collection)

ARRAY_COUNT 是 APPLY_COUNT 的同义词。

参数

collection: 目标集合

NULL 处理

空值不包括在计数中。

示例

此示例中的数组包含 6 个元素，其中一个为空值：

=> SELECT apply_count(ARRAY[1,NULL,3,7,8,5]);
apply_count
-------------
5
(1 row)

1.3 - APPLY_COUNT_ELEMENTS (ARRAY_LENGTH)

返回集合（数组或集合）中的元素总数，包括 NULL。要仅计算非空值，请使用 APPLY_COUNT (ARRAY_COUNT)。

行为类型

不可变

语法

APPLY_COUNT_ELEMENTS(collection)

ARRAY_LENGTH 是 APPLY_COUNT_ELEMENTS 的同义词。

参数

collection: 目标集合

NULL 处理

此函数计算所有成员，包括空值。

空集合（ARRAY[] 或 SET[]）的长度为 0。包含单个空值（ARRAY[null] 或 SET[null]）的集合的长度为 1。

示例

以下数组有 6 个元素，包括一个空值：

=> SELECT apply_count_elements(ARRAY[1,NULL,3,7,8,5]);
apply_count_elements
---------------------
                   6
(1 row)

如上例所示，空元素是一个元素。因此，一个只包含一个空元素的数组只有一个元素：

=> SELECT apply_count_elements(ARRAY[null]);
apply_count_elements
---------------------
                   1
(1 row)

集合不包含重复项。如果您构造一个集合并将其直接传递给此函数，则结果可能与输入的数量不同：

=> SELECT apply_count_elements(SET[1,1,3]);
apply_count_elements
---------------------
                   2
(1 row)

1.4 - APPLY_MAX

返回集合（数组或集合）中最大的非空元素。该函数类似于 MAX [聚合] 函数；APPLY_MAX 对集合的元素进行操作，MAX 对诸如列选择之类的表达式进行操作。

行为类型

不可变

语法

APPLY_MAX(collection)

参数

collection: 目标集合

NULL 处理

此函数忽略空元素。如果所有元素都为空值或集合为空白，则此函数返回空值。

示例

=> SELECT apply_max(ARRAY[1,3.4,15]);
apply_max
-----------
     15.0
(1 row)

1.5 - APPLY_MIN

返回集合（数组或集合）中最小的非空元素。该函数类似于 MIN [聚合] 函数；APPLY_MIN 对集合的元素进行操作，而 MIN 对诸如列选择之类的表达式进行操作。

行为类型

不可变

语法

APPLY_MIN(collection)

参数

collection: 目标集合

NULL 处理

此函数忽略空元素。如果所有元素都为空值或集合为空白，则此函数返回空值。

示例

=> SELECT apply_min(ARRAY[1,3.4,15]);
apply_min
-----------
       1.0
(1 row)

1.6 - APPLY_SUM

计算数值（INTEGER、FLOAT、NUMERIC 或 INTERVAL）的集合（数组或集合）中所有元素的总和。

行为类型

不可变

语法

APPLY_SUM(collection)

参数

collection: 目标集合

NULL 处理

以下情况返回 NULL：

如果输入集合为 NULL
如果输入集合仅包含 null 值
如果输入集合为空

示例

=> SELECT apply_sum(ARRAY[12.5,3,4,1]);
apply_sum
-----------
      20.5
(1 row)

另请参阅

APPLY_AVG

1.7 - ARRAY_CAT

连接元素类型和维度相同的两个数组。例如，ROW 元素必须具有相同的字段。

如果输入都是有界限的，则结果的界限是输入的界限之和。

如果任何输入均无界限，则结果是无界限的，其二进制大小是输入大小的总和。

行为类型

不可变

语法

ARRAY_CAT(array1,array2)

参数

array1, array2: 匹配维度和元素类型的数组

NULL 处理

如果任一输入为 NULL，则函数返回 NULL。

示例

如有必要，类型会被强制转换，如第二个示例所示。

=> SELECT array_cat(ARRAY[1,2], ARRAY[3,4,5]);
array_cat
-----------------------
[1,2,3,4,5]
(1 row)

=> SELECT array_cat(ARRAY[1,2], ARRAY[3,4,5.0]);
array_cat
-----------------------
["1.0","2.0","3.0","4.0","5.0"]
(1 row)

1.8 - ARRAY_CONTAINS

如果在数组中找到指定的元素，则返回 true，否则返回 false。两个实参都必须为非空，但数组可能为空白。

已弃用

此函数已重命名为 CONTAINS。

1.9 - ARRAY_DIMS

返回输入数组的维度。

行为类型

不可变

语法

ARRAY_DIMS(array)

参数

array: 目标数组

示例

=> SELECT array_dims(ARRAY[[1,2],[2,3]]);
array_dims
------------
        2
(1 row)

1.10 - ARRAY_FIND

返回数组中指定元素的序号位置，如果未找到，则返回 -1。数组可以为空白，但不能为 NULL。此函数在测试元素时使用空安全等同性检查。

行为类型

不可变

语法

ARRAY_FIND(array, val_to_find)

参数

array: 目标数组。
val_to_find: 要搜索的值；类型必须与数组的元素类型匹配或可以强制转换。

示例

=> SELECT array_find(array[1,2,3],2);
array_find
------------
          1
(1 row)

该函数返回指定元素的第一个实例。但是，没有什么可以确保值在数组中是唯一的。

=> SELECT array_find(ARRAY[1,2,7,5,7],7);
 array_find
------------
          2
(1 row)

如果未找到指定的元素，该函数将返回 -1。

=> SELECT array_find(ARRAY[1,3,5,7],4);
array_find
------------
        -1
(1 row)

您可以搜索复杂的元素类型：

=> SELECT ARRAY_FIND(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,2,3]);
 ARRAY_FIND
------------
          0
(1 row)

=> SELECT ARRAY_FIND(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,null,4]);
 ARRAY_FIND
------------
          1
(1 row)

第二个示例，比较数组与空元素，找到匹配项，因为 ARRAY_FIND 在评估元素时使用空安全等同性检查。

如前面的示例所示，第一个实参可以是原始类型的字面量多维数组。字面量数组不能包含 ROW 元素，如直接构造语法（字面量）中所述，但表中的数组可以。有关相关示例，请参阅 CONTAINS。

1.11 - CONTAINS

如果在集合中找到指定的元素，则返回 true，否则返回 false。集合可以为空白，但不能为 NULL。此函数在测试元素时使用空安全等同性检查。

行为类型

不可变

语法

CONTAINS(collection, val_to_test)

参数

collection: 目标集合（ARRAY 或 SET）。
val_to_test: 要搜索的值；类型必须与集合的元素类型匹配或可以强制转换。

示例

=> SELECT CONTAINS(SET[1,2,3,4],2);
 contains
----------
t
(1 row)

您可以搜索 NULL 作为元素值：

=> SELECT CONTAINS(ARRAY[1,null,2],null);
 contains
----------
 t
(1 row)

您可以搜索复杂的元素类型：

=> SELECT CONTAINS(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,2,3]);
 CONTAINS
----------
 t
(1 row)

=> SELECT CONTAINS(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,null,4]);
 CONTAINS
----------
 t
(1 row)

第二个示例，比较数组与空元素，返回 true，因为 CONTAINS 在评估元素时使用空安全等同性检查。

如前面的示例所示，第一个实参可以是原始类型的字面量多维数组。字面量数组不能包含 ROW 元素，如直接构造语法（字面量）中所述，但表中的数组可以。在以下示例中，orders 表具有以下定义：

=> CREATE EXTERNAL TABLE orders(
  orderid int,
  accountid int,
  shipments Array[
    ROW(
      shipid int,
      address ROW(
        street varchar,
        city varchar,
        zip int
      ),
      shipdate date
    )
  ]
 ) AS COPY FROM '...' PARQUET;

以下查询测试特定订单。将 ROW 字面量作为第二个实参传递时，转换任何不明确的字段以确保类型匹配：

=> SELECT CONTAINS(shipments,
            ROW(1,ROW('911 San Marcos St'::VARCHAR,
                  'Austin'::VARCHAR, 73344),
            '2020-11-05'::DATE))
   FROM orders;
 CONTAINS
----------
 t
 f
 f
(3 rows)

另请参阅

ARRAY_FIND

1.12 - EXPLODE

使用查询中指定的任何其他列，将集合中的一列或多列（ARRAY 或 SET）扩展为单独的表行，每个元素一行。对于每个分解的集合，结果包括两列，一列用于元素索引，另一列用于该位置的值。如果函数分解单个集合，这些列默认命名为 position 和 value。如果函数分解两个或多个集合，则每个集合的列被命名为 pos_column-name 和 val_column-name。您可以在 SELECT 中使用 AS 子句来更改这些列名。

此函数需要 OVER() 子句。

行为类型

不可变

语法

EXPLODE (column[,...] [USING PARAMETERS param=value])
OVER ( [window-partition-clause] )

参数

列: 正在查询的表中的列。您必须至少指定与 explode_count 参数的值一样多的集合列。不是集合的列将不加修改地传递。

参数

explode_count: 要分解的集合列数（默认为 1）。该函数检查每一列，一直到该值，如果是集合则将其分解，如果不是集合或已达到此限制，则将其传递。如果 explode_count 的值大于指定的集合列数，则函数返回错误。

NULL 处理

此函数将集合中的每个元素展开为一行，包括空值。如果要分解的列是 NULL（非空白），则该函数不会为该集合生成任何行。

示例

以下示例说明了将 EXPLODE() 与 OVER(PARTITION BEST) 子句一起使用。

考虑一个订单表，其中包含订单键、客户键、产品键、订单价格和电子邮件地址的列，其中一些包含数组。Vertica 中的基本查询结果如下：

=> SELECT orderkey, custkey, prodkey, orderprices, email_addrs FROM orders LIMIT 5;
  orderkey  | custkey |                    prodkey                    |            orderprices            |                                                  email_addrs
------------+---------+-----------------------------------------------+-----------------------------------+----------------------------------------------------------------------------------------------------------------
 113-341987 |  342799 | ["MG-7190 ","VA-4028 ","EH-1247 ","MS-7018 "] | ["60.00","67.00","22.00","14.99"] | ["bob@example,com","robert.jones@example.com"]
 111-952000 |  342845 | ["ID-2586 ","IC-9010 ","MH-2401 ","JC-1905 "] | ["22.00","35.00",null,"12.00"]    | ["br92@cs.example.edu"]
 111-345634 |  342536 | ["RS-0731 ","SJ-2021 "]                       | ["50.00",null]                    | [null]
 113-965086 |  342176 | ["GW-1808 "]                                  | ["108.00"]                        | ["joe.smith@example.com"]
 111-335121 |  342321 | ["TF-3556 "]                                  | ["50.00"]                         | ["789123@example-isp.com","alexjohnson@example.com","monica@eng.example.com","sara@johnson.example.name",null]
(5 rows)

此示例按升序扩展指定客户的 orderprices 列。custkey 和 email_addrs 列对每个数组元素重复。

=> SELECT EXPLODE(orderprices, custkey, email_addrs) OVER(PARTITION BEST) AS (position, orderprices, custkey, email_addrs)
   FROM orders WHERE custkey='342845' ORDER BY orderprices;
 position | orderprices | custkey |         email_addrs
----------+-------------+---------+------------------------------
        2 |             |  342845 | ["br92@cs.example.edu",null]
        3 |       12.00 |  342845 | ["br92@cs.example.edu",null]
        0 |       22.00 |  342845 | ["br92@cs.example.edu",null]
        1 |       35.00 |  342845 | ["br92@cs.example.edu",null]
(4 rows)

展开包含空值的列时，null 值显示为空。

您可以通过指定 explode_count 参数来展开多个列。

=> SELECT EXPLODE(orderkey, prodkey, orderprices USING PARAMETERS explode_count=2)
OVER(PARTITION BEST)
AS (orderkey,pk_idx,pk_val,ord_idx,ord_val)
FROM orders
WHERE orderkey='113-341987';
  orderkey  | pk_idx |  pk_val  | ord_idx | ord_val
------------+--------+----------+---------+---------
 113-341987 |      0 | MG-7190  |       0 |   60.00
 113-341987 |      0 | MG-7190  |       1 |   67.00
 113-341987 |      0 | MG-7190  |       2 |   22.00
 113-341987 |      0 | MG-7190  |       3 |   14.99
 113-341987 |      1 | VA-4028  |       0 |   60.00
 113-341987 |      1 | VA-4028  |       1 |   67.00
 113-341987 |      1 | VA-4028  |       2 |   22.00
 113-341987 |      1 | VA-4028  |       3 |   14.99
 113-341987 |      2 | EH-1247  |       0 |   60.00
 113-341987 |      2 | EH-1247  |       1 |   67.00
 113-341987 |      2 | EH-1247  |       2 |   22.00
 113-341987 |      2 | EH-1247  |       3 |   14.99
 113-341987 |      3 | MS-7018  |       0 |   60.00
 113-341987 |      3 | MS-7018  |       1 |   67.00
 113-341987 |      3 | MS-7018  |       2 |   22.00
 113-341987 |      3 | MS-7018  |       3 |   14.99
(16 rows)

以下示例使用多维数组：

=> SELECT name, pingtimes FROM network_tests;
 name |                       pingtimes
------+-------------------------------------------------------
 eng1 | [[24.24,25.27,27.16,24.97],[23.97,25.01,28.12,29.5]]
 eng2 | [[27.12,27.91,28.11,26.95],[29.01,28.99,30.11,31.56]]
 qa1  | [[23.15,25.11,24.63,23.91],[22.85,22.86,23.91,31.52]]
(3 rows)

=> SELECT EXPLODE(name, pingtimes USING PARAMETERS explode_count=1) OVER()
FROM network_tests;
 name | position |           value
------+----------+---------------------------
 eng1 |        0 | [24.24,25.27,27.16,24.97]
 eng1 |        1 | [23.97,25.01,28.12,29.5]
 eng2 |        0 | [27.12,27.91,28.11,26.95]
 eng2 |        1 | [29.01,28.99,30.11,31.56]
 qa1  |        0 | [23.15,25.11,24.63,23.91]
 qa1  |        1 | [22.85,22.86,23.91,31.52]
(6 rows)

1.13 - IMPLODE

接受任何标量类型的一列并返回一个无界数组。结合 GROUP BY，此函数可用于反转 EXPLODE 操作。

行为类型

不可变，如果 WITHIN GROUP ORDER BY 子句指定解析为每个输出数组组中唯一元素值的列或列集。
易变，否则因为结果是不可交换的。

语法

IMPLODE (input-column [ USING PARAMETERS param=value[,...] ] )
    [ within-group-order-by-clause ]

参数

input-column

要从中创建数组的任何标量类型的列。

within-group-order-by-clause

对每个输出数组组中的元素进行排序：

WITHIN GROUP (ORDER BY { column-expression[ sort-qualifiers ] }[,...])

sort-qualifiers: { ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }

提示

WITHIN GROUP ORDER BY 会消耗每个组的大量内存。为了最大限度地减少内存消耗，请创建支持 GROUPBY PIPELINED 的投影。

参数

allow_truncate: Boolean 值，如果为 true，则当输出长度超过列大小时截断结果。如果为 false（默认值），则当输出数组过大时，该函数将返回错误。
即使此参数设置为 true，如果任何单个数组元素过大，IMPLODE 也会返回错误。截断从输出数组中移除元素，但不改变单个元素。
max_binary_size: 返回数组的最大二进制大小（以字节为单位）。如果忽略此参数，IMPLODE 将使用配置参数 DefaultArrayBinarySize 的值。

示例

考虑使用包含以下内容的表：

=> SELECT * FROM filtered;

 position | itemprice | itemkey
----------+-----------+---------
        0 |     14.99 |     345
        0 |     27.99 |     567
        1 |     18.99 |     567
        1 |     35.99 |     345
        2 |     14.99 |     123
(5 rows)

以下查询调用 IMPLODE 将价格组合为数组（按键分组）：

=> SELECT itemkey AS key, IMPLODE(itemprice) AS prices
    FROM filtered GROUP BY itemkey ORDER BY itemkey;
 key |      prices
-----+-------------------
 123 | ["14.99"]
 345 | ["35.99","14.99"]
 567 | ["27.99","18.99"]
(3 rows)

您可以通过包括 WITHIN GROUP ORDER BY 子句来修改此查询，该子句指定如何对每个组中的数组元素进行排序：

=> SELECT itemkey AS key, IMPLODE(itemprice) WITHIN GROUP (ORDER BY itemprice) AS prices
    FROM filtered GROUP BY itemkey ORDER BY itemkey;
 key |      prices
-----+-------------------
 123 | ["14.99"]
 345 | ["14.99","35.99"]
 567 | ["18.99","27.99"]
(3 rows)

有关更完整的示例，请参阅数组和集（集合）。

1.14 - SET_UNION

返回包含两个输入集的所有元素的 SET。

如果输入都是有界限的，则结果的界限是输入的界限之和。

如果任何输入均无界限，则结果是无界限的，其二进制大小是输入大小的总和。

行为类型

不可变

语法

SET_UNION(set1,set2)

参数

set1, set2: 匹配元素类型集

NULL 处理

空实参会被忽略。如果输入之一为空，则函数返回非空输入。换言之，NULL 的实参等价于 SET[]。
如果两个输入均为空值，则函数返回 null。

示例

=> SELECT SET_UNION(SET[1,2,4], SET[2,3,4,5.9]);
set_union
-----------------------
["1.0","2.0","3.0","4.0","5.9"]
(1 row)

1.15 - STRING_TO_ARRAY

拆分包含数组值的字符串并返回原生一维数组。输出不包括“ARRAY”关键字。此函数不支持嵌套（多维）数组。

默认情况下，此函数将数组元素作为字符串返回。您可以转换为其他类型，如下例所示：

=> SELECT STRING_TO_ARRAY('[1,2,3]')::ARRAY[INT];

行为

不可变

语法

STRING_TO_ARRAY(string [USING PARAMETERS param=value[,...]])

以下语法已弃用：

STRING_TO_ARRAY(string, delimiter)

参数

string: 一维数组的字符串表示；可以是 VARCHAR 列、字面量字符串或表达式的字符串输出。
除非元素被单独引用，否则字符串中的空格将被移除。例如，' a,b,c' 等价于 'a,b,c'。要保留空间，请使用 '" a","b","c"'。

参数

这些参数的行为方式与加载分隔数据时的相应选项相同（请参阅 DELIMITED）。

任何参数不得与任何其他参数具有相同的值。

collection_delimiter: 用于分隔数组元素的字符或字符序列 (VARCHAR(8))。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。
默认值： 逗号 (',')。
collection_open, collection_close: 标记数组开头和末尾的字符 (VARCHAR(8))。在元素列表中的其他地方使用这些字符而不转义它们是错误的。这些字符可以从输入字符串中忽略。
默认值： 方括号（'[' 和 ']'）。
collection_null_element: 表示空元素值的字符串 (VARCHAR(65000))。您可以使用 E'\001' 到 E'\177'（包含）范围内的任何 ASCII 值指定 null 值（除 NULL 之外的任何 ASCII 值：E'\000'）。
默认值： 'null'
collection_enclose: 可选的引号字符，其中包含单个元素，允许将分隔符嵌入到字符串值中。您可以选择 E'\001' 到 E'\177'（包含）范围内的任何 ASCII 值（除 NULL 之外的任何 ASCII 字符：E'\000'）。元素不需要被该值包围。
默认： 双引号（'"'）

示例

该函数使用逗号作为默认分隔符。您可以指定不同的值：

=> SELECT STRING_TO_ARRAY('[1,3,5]');
 STRING_TO_ARRAY
-----------------
 ["1","3","5"]
(1 row)

=> SELECT STRING_TO_ARRAY('[t|t|f|t]' USING PARAMETERS collection_delimiter = '|');
  STRING_TO_ARRAY
-------------------
 ["t","t","f","t"]
(1 row)

边界括号是可选的：

=> SELECT STRING_TO_ARRAY('t|t|f|t' USING PARAMETERS collection_delimiter = '|');
  STRING_TO_ARRAY
-------------------
 ["t","t","f","t"]
(1 row)

输入可以使用其他字符进行打开和关闭：

=> SELECT STRING_TO_ARRAY('{NASA-1683,NASA-7867,SPX-76}' USING PARAMETERS collection_open = '{', collection_close = '}');
          STRING_TO_ARRAY
------------------------------------
 ["NASA-1683","NASA-7867","SPX-76"]
(1 row)

默认情况下，输入中的字符串 'null' 被视为空值：

=> SELECT STRING_TO_ARRAY('{"us-1672",null,"darpa-1963"}' USING PARAMETERS collection_open = '{', collection_close = '}');
        STRING_TO_ARRAY
-------------------------------
 ["us-1672",null,"darpa-1963"]
(1 row)

在以下示例中，输入来自列：

=> SELECT STRING_TO_ARRAY(name USING PARAMETERS collection_delimiter=' ') FROM employees;
    STRING_TO_ARRAY
-----------------------
 ["Howard","Wolowitz"]
 ["Sheldon","Cooper"]
(2 rows)

1.16 - TO_JSON

返回复杂类型实参的 JSON 表示，包括混合和嵌套的复杂类型。这与复杂类型列的查询返回的格式相同。

行为

不可变

语法

TO_JSON(value)

参数

value: 复杂类型的列或字面量

示例

这些示例查询下表：

=> SELECT name, contact FROM customers;
        name        |                                                        contact
--------------------+-----------------------------------------------------------------------------------------------------------------------
Missy Cooper       | {"street":"911 San Marcos St","city":"Austin","zipcode":73344,"email":["missy@mit.edu","mcooper@cern.gov"]}
Sheldon Cooper     | {"street":"100 Main St Apt 4B","city":"Pasadena","zipcode":91001,"email":["shelly@meemaw.name","cooper@caltech.edu"]}
Leonard Hofstadter | {"street":"100 Main St Apt 4A","city":"Pasadena","zipcode":91001,"email":["hofstadter@caltech.edu"]}
Leslie Winkle      | {"street":"23 Fifth Ave Apt 8C","city":"Pasadena","zipcode":91001,"email":[]}
Raj Koothrappali   | {"street":null,"city":"Pasadena","zipcode":91001,"email":["raj@available.com"]}
Stuart Bloom       |
(6 rows)

您可以在列或特定字段或数组元素上调用 TO_JSON：

=> SELECT TO_JSON(contact) FROM customers;
    to_json
-----------------------------------------------------------------------------------------------------------------------
{"street":"911 San Marcos St","city":"Austin","zipcode":73344,"email":["missy@mit.edu","mcooper@cern.gov"]}
{"street":"100 Main St Apt 4B","city":"Pasadena","zipcode":91001,"email":["shelly@meemaw.name","cooper@caltech.edu"]}
{"street":"100 Main St Apt 4A","city":"Pasadena","zipcode":91001,"email":["hofstadter@caltech.edu"]}
{"street":"23 Fifth Ave Apt 8C","city":"Pasadena","zipcode":91001,"email":[]}
{"street":null,"city":"Pasadena","zipcode":91001,"email":["raj@available.com"]}

(6 rows)

=> SELECT TO_JSON(contact.email) FROM customers;
    to_json
---------------------------------------------
["missy@mit.edu","mcooper@cern.gov"]
["shelly@meemaw.name","cooper@caltech.edu"]
["hofstadter@caltech.edu"]
[]
["raj@available.com"]

(6 rows)

使用 SET 调用 TO_JSON 时，请注意移除重复项并且可以重新排序元素：

=> SELECT TO_JSON(SET[1683,7867,76,76]);
    TO_JSON
----------------
[76,1683,7867]
(1 row)

2 - 日期/时间函数

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

使用

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）总是返回当前时间。

另请参阅

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

2.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.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)

2.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)

2.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)

另请参阅

2.5 - CURRENT_DATE

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

行为类型

稳定

语法

CURRENT_DATE()

注意

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

示例

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

2.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)

2.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)

2.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

2.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)

另请参阅

2.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)

2.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

2.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)

2.13 - DAYOFMONTH

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

行为类型

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

语法

DAYOFMONTH ( date )

参数

date

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

示例

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

2.14 - DAYOFWEEK

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

行为类型

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

语法

DAYOFWEEK ( date )

参数

date

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

示例

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

2.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)

另请参阅

2.16 - DAYOFYEAR

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

行为类型

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

语法

DAYOFYEAR ( date )

参数

date

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

示例

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

2.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)

2.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)

2.19 - GETDATE

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

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

行为类型

稳定

语法

GETDATE()

示例

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

另请参阅

日期/时间表达式

2.20 - GETUTCDATE

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

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

行为类型

稳定

语法

GETUTCDATE()

示例

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

另请参阅

日期/时间表达式

2.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)

2.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)

2.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)

2.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)

2.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)

2.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)

2.27 - MICROSECOND

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

行为类型

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

语法

MICROSECOND ( date )

参数

date

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

示例

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

2.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)

2.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)

2.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)

2.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)

2.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)

2.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)

2.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)

2.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)

2.36 - QUARTER

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

语法

QUARTER ( date )

行为类型

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

参数

date

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

示例

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

2.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

2.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)

2.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)

另请参阅

2.40 - SYSDATE

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

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

行为类型

稳定

语法

SYSDATE()

注意

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

示例

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

另请参阅

日期/时间表达式

2.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;

另请参阅

2.42 - TIMEOFDAY

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

行为类型

易变

语法

TIMEOFDAY()

示例

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

2.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)

2.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

2.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

2.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

2.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

2.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

2.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)

2.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)

2.51 - YEAR

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

语法

YEAR( date )

行为类型

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

参数

date

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

INTERVAL

示例

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

另请参阅

YEAR_ISO

2.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

3 - IP 地址函数

IP 函数对 IP、网络和子网地址执行转换、计算和处理操作。

3.1 - INET_ATON

将包含 IPv4 网络地址的点分表示的字符串转换为 INTEGER。剪裁字符串中周边的任何空格。如果字符串为 NULL 或包含除点分 IPv4 地址以外的任何内容，则此函数返回 NULL。

行为类型

不可变

语法

INET_ATON ( expression )

参数

expression: 要转换的字符串。

示例

=> SELECT INET_ATON('209.207.224.40');
 inet_aton
------------
 3520061480
(1 row)

=> SELECT INET_ATON('1.2.3.4');
 inet_aton
-----------
  16909060
(1 row)

=> SELECT TO_HEX(INET_ATON('1.2.3.4'));
 to_hex
---------
 1020304
(1 row)

另请参阅

3.2 - INET_NTOA

将 INTEGER 值转换为 IPv4 网络地址的 VARCHAR 点分表示。如果整数值为 NULL、负数或大于 2³² (4294967295)，则 INET_NTOA 返回 NULL。

行为类型

不可变

语法

INET_NTOA ( expression )

参数

表达式: 要转换的整数网络地址。

示例

=> SELECT INET_NTOA(16909060);
 inet_ntoa
-----------
 1.2.3.4
(1 row)

=> SELECT INET_NTOA(03021962);
 inet_ntoa
-------------
 0.46.28.138
(1 row)

另请参阅

3.3 - V6_ATON

将包含以冒号分隔的 IPv6 网络地址的字符串转换为 VARBINARY 字符串。IPv6 地址周围的所有空格都会被剪裁。如果输入值为 NULL 或无法解析为 IPv6 地址，则此函数返回 NULL。此函数依赖 Linux 函数 inet_pton。

行为类型

不可变

语法

V6_ATON ( expression )

参数

表达式: (VARCHAR) 包含要转换的 IPv6 地址的字符串。

示例

=> SELECT V6_ATON('2001:DB8::8:800:200C:417A');
                       v6_aton
------------------------------------------------------
  \001\015\270\000\000\000\000\000\010\010\000 \014Az
(1 row)

=> SELECT V6_ATON('1.2.3.4');
              v6_aton
------------------------------------------------------------------
 \000\000\000\000\000\000\000\000\000\000\377\377\001\002\003\004
(1 row)
SELECT TO_HEX(V6_ATON('2001:DB8::8:800:200C:417A'));
              to_hex
----------------------------------
 20010db80000000000080800200c417a
(1 row)

=> SELECT V6_ATON('::1.2.3.4');
              v6_aton
------------------------------------------------------------------
 \000\000\000\000\000\000\000\000\000\000\000\000\001\002\003\004
(1 row)

另请参阅

3.4 - V6_NTOA

将表示为变长二进制的 IPv6 地址转换为字符串。

行为类型

不可变

语法

V6_NTOA ( expression )

参数

expression: (VARBINARY) 是要转换的二进制字符串。

注意

下述语法将表示为 VARBINARY B 的 IPv6 地址转换为字符串 A。

V6_NTOA 在 B 右侧填充 0 至 16 字节（若必要），并调用 Linux 函数 inet_ntop。

=> V6_NTOA(VARBINARY B) -> VARCHAR A

如果 B 为 NULL 或超过 16 个字节，则结果为 NULL。

Vertica 自动将格式 "::ffff:1.2.3.4" 转换为 "1.2.3.4"。

示例

=> SELECT V6_NTOA(' \001\015\270\000\000\000\000\000\010\010\000 \014Az');
          v6_ntoa
---------------------------
 2001:db8::8:800:200c:417a
(1 row)

=> SELECT V6_NTOA(V6_ATON('1.2.3.4'));
 v6_ntoa
---------
 1.2.3.4
(1 row)

=> SELECT V6_NTOA(V6_ATON('::1.2.3.4'));
  v6_ntoa
-----------
 ::1.2.3.4
(1 row)

另请参阅

V6_ATON

3.5 - V6_SUBNETA

从二进制或字母数字 IPv6 地址返回一个包含 CIDR（无类别域间路由）格式的子网地址的 VARCHAR。如果任一参数为 NULL、地址无法解析为 IPv6 地址或子网值超出 0 到 128 的范围，则返回 NULL。

行为类型

不可变

语法

V6_SUBNETA ( address, subnet)

参数

address: 包含 IPv6 地址的 VARBINARY 或 VARCHAR。
subnet: 子网的大小（以位为单位），为 INTEGER。此值必须大于零且小于或等于 128。

示例

=> SELECT V6_SUBNETA(V6_ATON('2001:db8::8:800:200c:417a'), 28);
  v6_subneta
---------------
 2001:db0::/28
(1 row)

另请参阅

3.6 - V6_SUBNETN

从变长二进制或字母数字 IPv6 地址计算无类别域间路由 (CIDR) 格式的子网地址。

行为类型

不可变

语法

V6_SUBNETN ( address, subnet-size)

参数

address: IPv6 地址为 VARBINARY 或 VARCHAR。传入格式决定输出的日期类型。如果传入 VARBINARY 地址，则 V6_SUBNETN 返回 VARBINARY 值。如果传入一个 VARCHAR 值，则返回 VARCHAR。
subnet‑size: 子网的大小为 INTEGER。

注意

下述语法屏蔽 BINARY IPv6 地址 B，使得 S 最左侧的 N 位形成子网地址，而剩余最右侧的位被清除。

V6_SUBNETN 在 B 右侧填充 0 至 16 字节（若必要）并屏蔽 B，保留其 N 位子网前缀。

=> V6_SUBNETN(VARBINARY B, INT8 N) -> VARBINARY(16) S

若 B 是 NULL 或长于 16 字节，或者 N 不在 0 到 128 之间（包含），则结果为 NULL。

S = [B]/N 用无类别域间路由符号（CIDR 符号）表示。

下述语法屏蔽字母数字 IPv6 地址 A ，使得最左侧的 N 位形成子网地址，而剩余最右侧的位被清除。

=> V6_SUBNETN(VARCHAR A, INT8 N) -> V6_SUBNETN(V6_ATON(A), N) -> VARBINARY(16) S

示例

这个示例在使用 V6_ATON 将 VARCHAR 字符串转换为 VARBINARY 之后返回 VARBINARY：

=> SELECT V6_SUBNETN(V6_ATON('2001:db8::8:800:200c:417a'), 28);
                           v6_subnetn
---------------------------------------------------------------
  \001\015\260\000\000\000\000\000\000\000\000\000\000\000\000

另请参阅

3.7 - V6_TYPE

返回 INTEGER 值，该值对传递给它的网络地址类型进行分类，如 IETF RFC 4291 第 2.4 部分中所定义。例如，如果将字符串 127.0.0.1 传递给此函数，则返回 2，表示该地址为环回地址。此函数接受 IPv4 和 IPv6 地址。

行为类型

不可变

语法

V6_TYPE ( address)

参数

address: 包含要描述的 IPv6 或 IPv4 地址的 VARBINARY 或 VARCHAR。

函数返回的值为：

返回值取决于下表的 IP 地址范围：

如果将 NULL 值或无效地址传递给此函数，则此函数返回 NULL。

示例

=> SELECT V6_TYPE(V6_ATON('192.168.2.10'));
 v6_type
---------
       1
(1 row)

=> SELECT V6_TYPE(V6_ATON('2001:db8::8:800:200c:417a'));
 v6_type
---------
       0
(1 row)

另请参阅

4 - 序列函数

序列函数提供了简单多用户安全方法，从序列对象获取连续序列值。

4.1 - CURRVAL

返回所有节点中的最后一个值，由当前会话中此序列的 NEXTVAL 进行设置。如果 NEXTVAL 自创建后从未在此序列中调用，Vertica 将返回错误。

语法

CURRVAL ('[[database.]schema.]sequence-name')

参数

[database.]schema: 数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
sequence-name: 目标序列

特权

对序列的 SELECT 权限
对序列架构的 USAGE 权限

限制

在以下情况下，不能在 SELECT 语句中调用 CURRVAL：

WHERE 子句
GROUP BY 子句
ORDER BY 子句
DISTINCT 子句
UNION
子查询

也不能调用 CURRVAL 处理以下项中的序列：

UPDATE 或 DELETE 子查询
视图

示例

请参阅创建和使用命名序列。

另请参阅

NEXTVAL

4.2 - NEXTVAL

返回序列中的下一个值。创建序列并使用默认值初始化后，调用 NEXTVAL。接下来，调用 NEXTVAL 增加序列值，进行升序排列，或减少值，进行降序排列。

语法

NEXTVAL ('[[database.]schema.]sequence')

参数

[database.]schema: 数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
序列: 确定目标序列

特权

对序列的 SELECT 权限
对序列架构的 USAGE 权限

限制

在以下情况下，不能在 SELECT 语句中调用 NEXTVAL：

WHERE 子句
GROUP BY 子句
ORDER BY 子句
DISTINCT 子句
UNION
子查询

也不能调用 NEXTVAL 处理以下项中的序列：

UPDATE 或 DELETE 子查询
视图

您可以使用子查询解决部分限制。例如，要将序列与 DISTINCT 使用使用：

=> SELECT t.col1, shift_allocation_seq.NEXTVAL FROM (
     SELECT DISTINCT col1 FROM av_temp1) t;

示例

请参阅创建和使用命名序列。

另请参阅

CURRVAL

5 - 字符串函数

字符串函数执行字符串转换、提取或处理操作，或返回有关字符串的信息。

此部分描述了用于检查和处理字符串值的函数和运算符。在此文中的字符串包括 CHAR、VARCHAR、BINARY 和 VARBINARY 类型的值。

除非另行说明，否则此部分列出的所有函数适用于所有四种数据类型。与某些其它 SQL 实施相对的是，Vertica 内部维持不填充 CHAR 字符串，至在最终输出填充。因此，转换 CHAR(3) 'ab' 为 VARCHAR(5)，长度 2 而不是长度 3（包括一个行尾空格）的 VARCHAR。

此处描述的部分函数可以通过先将非字符串类型的数据转换为字符串表示形式，从而适用于此类数据。部分函数仅适用于字符形式的字符串，另一部分函数则仅适用于二进制字符串。很多函数适用于两者。BINARY 和 VARBINARY 函数忽略了多字节 UTF-8 字符界限。

非二进制字符形式的字符串函数处理 Unicode Consortium 规定的规范化多字节 UTF-8 字符。除非另有说明，否则这些相关的字符形式字符串函数可选择性地指定 VARCHAR 实参应解释为八位字节（字节）序列还是对于区域设置敏感的 UTF-8 字符序列。为此，您可以将“USING OCTETS”或“USING CHARACTERS”（默认值）添加为函数形参。

部分字符形式的字符串函数为稳定，因为 UTF-8 大小写转换、搜索和排序通常可以取决于区域设置。因此，LOWER 为稳定函数，而 LOWERB 为不可变函数。USING OCTETS 子句将这些函数转换为 "B" 形式，因此成为不可变函数。如果区域设置为默认设置 collation=binary，则所有字符串函数（除 CHAR_LENGTH/CHARACTER_LENGTH、LENGTH、SUBSTR 和 OVERLAY 以外）转换为各自的 "B" 形式，因此成为不可变函数。

BINARY 隐式转换为 VARBINARY，因此采用 VARBINARY 实参的函数可与 BINARY 使用。

有关对字符串（而非 VARBINARY）进行操作的其他函数，请参阅正则表达式函数。

5.1 - ASCII

将 VARCHAR 数据类型的第一个字符转换为 INTEGER。此函数与 CHR 函数相对。

ASCII 对 UTF-8 字符和单字节 ASCII 字符进行操作。针对 UTF-8 的 ASCII 子集返回相同的结果。

行为类型

不可变

语法

ASCII ( expression )

参数

表达式: 要转换的 VARCHAR（字符串）。

示例

此示例返回以 L 开头的员工姓氏。L 的 ASCII 等效值为 76：

=> SELECT employee_last_name FROM employee_dimension
      WHERE ASCII(SUBSTR(employee_last_name, 1, 1)) = 76
       LIMIT 5;
 employee_last_name
--------------------
 Lewis
 Lewis
 Lampert
 Lampert
 Li
(5 rows)

5.2 - BIT_LENGTH

按位（字节数 * 8）返回字符串表达式的长度作为 INTEGER 数据类型。BIT_LENGTH 适用于 VARCHAR 和 VARBINARY 字段的内容。

行为类型

不可变

语法

BIT_LENGTH ( expression )

参数

expression: （CHAR 或 VARCHAR 或 BINARY 或 VARBINARY）是要转换的字符串。

示例

表达式

结果

SELECT BIT_LENGTH('abc'::varbinary);

SELECT BIT_LENGTH('abc'::binary);

SELECT BIT_LENGTH(''::varbinary);

SELECT BIT_LENGTH(''::binary);

SELECT BIT_LENGTH(null::varbinary);

SELECT BIT_LENGTH(null::binary);

SELECT BIT_LENGTH(VARCHAR 'abc');

SELECT BIT_LENGTH(CHAR 'abc');

SELECT BIT_LENGTH(CHAR(6) 'abc');

SELECT BIT_LENGTH(VARCHAR(6) 'abc');

SELECT BIT_LENGTH(BINARY(6) 'abc');

SELECT BIT_LENGTH(BINARY 'abc');

SELECT BIT_LENGTH(VARBINARY 'abc');

SELECT BIT_LENGTH(VARBINARY(6) 'abc');

另请参阅

5.3 - BITCOUNT

在给定的 VARBINARY 值中返回一个二进制位数（有时称为设置位）。这也被称为种群统计。

行为类型

不可变

语法

BITCOUNT ( expression )

参数

expression: （BINARY 或 VARBINARY）是要返回的字符串。

示例

=> SELECT BITCOUNT(HEX_TO_BINARY('0x10'));
 BITCOUNT
----------
        1
(1 row)

=> SELECT BITCOUNT(HEX_TO_BINARY('0xF0'));
 BITCOUNT
----------
        4
(1 row)

=> SELECT BITCOUNT(HEX_TO_BINARY('0xAB'));
 BITCOUNT
----------
        5
(1 row)

5.4 - BITSTRING_TO_BINARY

将给定的 VARCHAR 位字符串表示转换为 VARBINARY 值。此函数是 TO_BITSTRING 的反函数。

行为类型

不可变

语法

BITSTRING_TO_BINARY ( expression )

参数

表达式: 要处理的 VARCHAR 字符串。

示例

如果十六进制值中有奇数个字符，第一个字符被视为第一个（最左边）字节的下半字节。

=> SELECT BITSTRING_TO_BINARY('0110000101100010');
 BITSTRING_TO_BINARY
---------------------
 ab
(1 row)

5.5 - BTRIM

从字符串的开头和结尾删除仅包含指定字符的最长字符串。

行为类型

不可变

语法

BTRIM ( expression [ , characters-to-remove ] )

参数

expression: （CHAR 或 VARCHAR）是要修改的字符串
characters-to-remove: （CHAR 或 VARCHAR）指定要删除的字符。默认值是空格字符。

示例

=> SELECT BTRIM('xyxtrimyyx', 'xy');
 BTRIM
-------
 trim
(1 row)

另请参阅

5.6 - CHARACTER_LENGTH

CHARACTER_LENGTH() 函数：

对于 CHAR 和 VARCHAR 列，返回以 UTF-8 字符数表示的字符串长度
对于 BINARY 和 VARBINARY 列，返回以字节（八位字节）表示的字符串长度
去掉 CHAR 表达式中的填充值，但是不去掉 VARCHAR 表达式中的填充值
与用于 CHAR 和 VARCHAR 的 LENGTH() 相同。对于二进制类型，CHARACTER_LENGTH() 与 OCTET_LENGTH() 相同。

行为类型

如果为 USING OCTETS，则是不可变，否则为稳定。

语法

[ CHAR_LENGTH | CHARACTER_LENGTH ] ( expression ... [ USING { CHARACTERS | OCTETS } ] )

参数

expression: （CHAR 或 VARCHAR）是要测量的字符串
USING CHARACTERS | OCTETS: 确定字符长度是以字节（默认值）还是以八位字节为单位表示的。

示例

=> SELECT CHAR_LENGTH('1234  '::CHAR(10) USING OCTETS);
 octet_length
--------------
            4
(1 row)

=> SELECT CHAR_LENGTH('1234  '::VARCHAR(10));
 char_length
-------------
           6
(1 row)

=> SELECT CHAR_LENGTH(NULL::CHAR(10)) IS NULL;
 ?column?
----------
 t
(1 row)

另请参阅

BIT_LENGTH

5.7 - CHR

将 INTEGER 数据类型的第一个字符转换为 VARCHAR。

行为类型

不可变

语法

CHR ( expression )

参数

expression: (INTEGER) 是要转换的字符串，并被屏蔽为单个字符。

注意

CHR 与 ASCII 函数相对。
CHR 对 UTF-8 字符进行操作，而不仅仅是单字节 ASCII 字符。对于 UTF-8 的 ASCII 子集，继续获取相同的结果。

示例

此示例从员工表返回 CHR 表达式 65 和 97 的 VARCHAR 数据类型：


=> SELECT CHR(65), CHR(97) FROM employee;
 CHR | CHR
-----+-----
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
 A   | a
(12 rows)

5.8 - COLLATION

可将一个排序规则应用于两个或更多字符串。COLLATION 可与 ORDER BY、GROUP BY 和相等子句一起使用。

语法

COLLATION ( 'expression' [ , 'locale_or_collation_name' ] )

参数

'expression'

对某一列名称或对两个或更多 CHAR 或 VARCHAR 类型的值进行求值的任何表达式。

'locale_or_collation_name'

要在对字符串进行排序时使用的 ICU（Unicode 国际组件）区域设置或排序规则名称。如果您忽略此参数，COLLATION 将使用与会话区域设置相关联的排序规则。

要确定当前的会话区域设置，请输入 vsql 元命令 \locale：

=> \locale
en_US@collation=binary

要设置区域设置和排序规则，请使用 \locale，具体如下所示：

=> \locale en_US@collation=binary
INFO 2567:  Canonical locale: 'en_US'
Standard collation: 'LEN_KBINARY'
English (United States)

区域设置

用于 COLLATION 的区域设置可以是以下类型之一：

默认区域设置
会话区域设置
您在调用 COLLATION 时指定的区域设置。如果您指定了区域设置，Vertica 会将与该区域规则相关联的排序规则应用于数据。 COLLATION 不会修改表中任何其他列的排序规则。

有关有效 ICU 区域设置的列表，请访问区域设置浏览器 (ICU)。

二进制和非二进制排序规则

Vertica 默认区域设置为 en_US@collation=binary，使用二进制排序规则。二进制排序规则将对字符串的二进制表示法进行比较。二进制排序规则速度较快，但它可能会导致 K 排在 c 之前的排序顺序，因为 K 的二进制表示法小于 c。

对于非二进制排序规则，Vertica 将按区域设置规则或指定排序规则转换数据，然后应用排序规则。假设区域设置排序规则为非二进制，而您请求对字符串数据进行 GROUP BY 操作。在这种情况下，无论是否在查询中指定函数，Vertica 都会调用 COLLATION。

有关排序规则命名的信息，请参阅排序器命名架构。

示例

对 GROUP BY 结果进行排序

以下示例基于 Premium_Customer 表，包含以下数据：

=> SELECT * FROM Premium_Customer;
 ID | LName  | FName
----+--------+---------
  1 | Mc Coy | Bob
  2 | Mc Coy | Janice
  3 | McCoy  | Jody
  4 | McCoy  | Peter
  5 | McCoy  | Brendon
  6 | Mccoy  | Cameron
  7 | Mccoy  | Lisa

第一个语句显示了 COLLATION 如何将适用于 EN_US 区域设置的排序规则应用于区域设置 LName 的 EN_US 列。Vertica 将对 GROUP BY 的输出进行排序，具体如下所示：

包含空格的姓氏
“coy”以小写字母开头的姓氏
“Coy”以大写字母开头的姓氏

=> SELECT * FROM Premium_Customer ORDER BY COLLATION(LName, 'EN_US'), FName;
 ID | LName  | FName
----+--------+---------
  1 | Mc Coy | Bob
  2 | Mc Coy | Janice
  6 | Mccoy  | Cameron
  7 | Mccoy  | Lisa
  5 | McCoy  | Brendon
  3 | McCoy  | Jody
  4 | McCoy  | Peter

下一个语句显示了 COLLATION 如何针对区域设置 LName 对 LEN_AS 列进行排序：

LEN 表示语言 (L) 为英语 (EN)。
AS （转换替代字母）指示 COLLATION 小写字母出现在大写（转换）字母之前。

在结果中，“coy”以小写字母开头的姓氏将出现在“Coy”以大写字母开头的姓氏之前。

=> SELECT * FROM Premium_Customer ORDER BY COLLATION(LName, 'LEN_AS'), FName;
 ID | LName  | FName
----+--------+---------
  6 | Mccoy  | Cameron
  7 | Mccoy  | Lisa
  1 | Mc Coy | Bob
  5 | McCoy  | Brendon
  2 | Mc Coy | Janice
  3 | McCoy  | Jody
  4 | McCoy  | Peter

将字符串与等式子句进行比较

在以下查询中，COLLATION 将在对两个英文字符串进行比较时删除空格和标点。随后它将确定这两个字符串在删除标点后是否仍然包含相同的值：

=> SELECT COLLATION ('U.S.A', 'LEN_AS') = COLLATION('USA', 'LEN_AS');
?column?
----------
 t

对非英语语言的字符串进行排序

下表包含使用德语字符 eszett（即 ß）的数据：

=> SELECT * FROM t1;
     a      | b | c
------------+---+----
 ßstringß   | 1 | 10
 SSstringSS | 2 | 20
 random1    | 3 | 30
 random1    | 4 | 40
 random2    | 5 | 50

当您指定排序规则 LDE_S1 时：

LDE 表示语言 (L) 为德语 (DE)。
S1 表示强度 (S) 为 1（主）。此值表示排序规则无需考虑重音和大小写。

查询将按以下顺序返回数据：

=> SELECT a FROM t1 ORDER BY COLLATION(a, 'LDE_S1'));
     a
------------
 random1
 random1
 random2
 SSstringSS
 ßstringß

5.9 - CONCAT

连接两个字符串并返回 varchar 数据类型。如果任一实参为 NULL，则 CONCAT 返回 NULL。

语法

CONCAT ('string‑expression1, string‑expression2)

行为类型

不可变

参数

string‑expression1, string‑expression2: 要连接的值，可转换为字符串值的任何数据类型。

示例

以下示例使用名为 alphabet 的示例表，其中包含两个 VARCHAR 列：

=> CREATE TABLE alphabet (letter1 varchar(2), letter2 varchar(2));
CREATE TABLE
=> COPY alphabet FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> A|B
>> C|D
>> \.
=> SELECT * FROM alphabet;
 letter1 | letter2
---------+---------
 C       | D
 A       | B
(2 rows)

用字符串连接第一列的内容：

=> SELECT CONCAT(letter1, ' is a letter') FROM alphabet;
    CONCAT
---------------
 A is a letter
 C is a letter
(2 rows)

连接两个嵌套 CONCAT 函数的输出：

=> SELECT CONCAT(CONCAT(letter1, ' and '), CONCAT(letter2, ' are both letters')) FROM alphabet;
          CONCAT
--------------------------
 C and D are both letters
 A and B are both letters
(2 rows)

连接日期和字符串：

=> SELECT current_date today;
   today
------------
 2021-12-10
(1 row)

=> SELECT CONCAT('2021-12-31'::date - current_date, ' days until end of year 2021');
             CONCAT
--------------------------------
 21 days until end of year 2021
(1 row)

5.10 - DECODE

逐一比较每个搜索值的表达式。如果表达式等同于搜索内容，则函数返回相应的结果。如果未找到匹配，则函数返回默认值。如果忽略了默认值，则函数返回 null。

DECODE 与 IF-THEN-ELSE 和 CASE 表达式相类似：

CASE expression
[WHEN search THEN result]
[WHEN search THEN result]
...
[ELSE default];

实参可以包含 Vertica 支持的所有数据类型。单独结果的类型会被提升到可用于表示全部结果的最不常见的类型。这样会产生字符串类型、精确数字类型、近似数字类型或 DATETIME 类型，其中所有的结果实参必须属于同一类型的分组。

行为类型

不可变

语法

DECODE ( expression, search, result [ , search, result ]...[, default ] )

参数

expression: 要比较的值。
search: 与表达式进行比较的值。
result: 表达式等同于搜索内容时返回的值。
default: 可选。如果未找到匹配，则 DECODE 返回默认值。如果忽略了默认值，则 DECODE 返回 NULL（如果未找到匹配）。

示例

以下示例将 product_dimension 表中权重列的数值在输出中转换为描述值。

=> SELECT product_description, DECODE(weight,
      2, 'Light',
     50, 'Medium',
     71, 'Heavy',
     99, 'Call for help',
         'N/A')
  FROM product_dimension
  WHERE category_description = 'Food'
  AND department_description = 'Canned Goods'
  AND sku_number BETWEEN 'SKU-#49750' AND 'SKU-#49999'
  LIMIT 15;
        product_description        |     case
-----------------------------------+---------------
 Brand #499 canned corn            | N/A
 Brand #49900 fruit cocktail       | Medium
 Brand #49837 canned tomatoes      | Heavy
 Brand #49782 canned peaches       | N/A
 Brand #49805 chicken noodle soup  | N/A
 Brand #49944 canned chicken broth | N/A
 Brand #49819 canned chili         | N/A
 Brand #49848 baked beans          | N/A
 Brand #49989 minestrone soup      | N/A
 Brand #49778 canned peaches       | N/A
 Brand #49770 canned peaches       | N/A
 Brand #4977 fruit cocktail        | N/A
 Brand #49933 canned olives        | N/A
 Brand #49750 canned olives        | Call for help
 Brand #49777 canned tomatoes      | N/A
(15 rows)

5.11 - EDIT_DISTANCE

计算并返回两个字符串之间的 Levenshtein 距离。返回值表示将一个字符串更改为另一个字符串所需的最小单字符编辑次数（插入、删除或替换）。

行为类型

不可变

语法

EDIT_DISTANCE ( string-expression1, string-expression2 )

参数

string-expression1, string-expression2: 要比较的两个 VARCHAR 表达式，请执行以下操作。

示例

kitten 与 knitting 之间的 Levenshtein 距离为 3：

=> SELECT EDIT_DISTANCE ('kitten', 'knitting');
 EDIT_DISTANCE
---------------
             3
(1 row)

EDIT_DISTANCE 计算出将 kitten 转换为 knitting 需要不少于三项更改：

kitten → knitten （在 k 之后插入 n）
knitten → knittin （用 i 替换 e）
knittin → knitting （附加 g）

5.12 - GREATEST

返回任何数据类型的表达式列表中的最大值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。

行为类型

稳定

语法

GREATEST ( { * | expression[,...] } )

参数

* | expression[,...]

要求值的表达式，为以下之一：

* （星号）

对查询表中的所有列进行求值。
表达式

任何数据类型的表达式。expression 中包含的函数必须具有确定性。

示例

GREATEST 返回 10 作为列表中的最大值：

=> SELECT GREATEST(7,5,10);
 GREATEST
----------
       10
(1 row)

如果在整数表达式周围添加引号，GREATEST 会将值作为字符串进行比较，并返回 "7" 作为最大值：

=> SELECT GREATEST('7', '5', '10');
 GREATEST
----------
 7
(1 row)

下一个示例返回 FLOAT 1.5 作为最大值，因为整数隐式转换为浮点类型：

=> SELECT GREATEST(1, 1.5);
 GREATEST
----------
      1.5
(1 row)

GREATEST 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最大值：

=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_width, shelf_height, shelf_depth, greatest(*) FROM query1 WHERE shelf_width = 1;
 shelf_width | shelf_height | shelf_depth | greatest
-------------+--------------+-------------+----------
           1 |            3 |           1 |        3
           1 |            3 |           3 |        3
           1 |            5 |           4 |        5
           1 |            2 |           2 |        2
           1 |            1 |           3 |        3
           1 |            2 |           2 |        2
           1 |            2 |           3 |        3
           1 |            1 |           5 |        5
           1 |            1 |           4 |        4
           1 |            5 |           3 |        5
           1 |            4 |           2 |        4
           1 |            4 |           5 |        5
           1 |            5 |           3 |        5
           1 |            2 |           5 |        5
           1 |            4 |           2 |        4
           1 |            4 |           4 |        4
           1 |            1 |           2 |        2
           1 |            4 |           3 |        4
...

另请参阅

LEAST

5.13 - GREATESTB

使用二进制排序返回任何数据类型的表达式列表中的最大值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。

行为类型

不可变

语法

GREATEST ( { * | expression[,...] } )

参数

* | expression[,...]

要求值的表达式，为以下之一：

* （星号）

对查询表中的所有列进行求值。
表达式

任何数据类型的表达式。expression 中包含的函数必须具有确定性。

示例

以下命令选择 straße 作为输入序列中的最大值：

=> SELECT GREATESTB('straße', 'strasse');
 GREATESTB
-----------
 straße
(1 row)

GREATESTB 返回 10 作为列表中的最大值：

=> SELECT GREATESTB(7,5,10);
 GREATESTB
-----------
        10
(1 row)

如果在整数表达式周围添加引号，GREATESTB 会将值作为字符串进行比较，并返回 "7" 作为最大值：

=> SELECT GREATESTB('7', '5', '10');
 GREATESTB
-----------
 7
(1 row)

下一个示例返回 FLOAT 1.5 作为最大值，因为整数隐式转换为浮点类型：

=> SELECT GREATESTB(1, 1.5);
 GREATESTB
-----------
       1.5
(1 row)

GREATESTB 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最大值：

=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_width, shelf_height, shelf_depth, greatestb(*) FROM query1 WHERE shelf_width = 1;
 shelf_width | shelf_height | shelf_depth | greatestb
-------------+--------------+-------------+-----------
           1 |            3 |           1 |         3
           1 |            3 |           3 |         3
           1 |            5 |           4 |         5
           1 |            2 |           2 |         2
           1 |            1 |           3 |         3
           1 |            2 |           2 |         2
           1 |            2 |           3 |         3
           1 |            1 |           5 |         5
           1 |            1 |           4 |         4
           1 |            5 |           3 |         5
           1 |            4 |           2 |         4
           1 |            4 |           5 |         5
           1 |            5 |           3 |         5
           1 |            2 |           5 |         5
           1 |            4 |           2 |         4
...

另请参阅

LEASTB

5.14 - HEX_TO_BINARY

将给定的 VARCHAR 十六进制表示方式转换为 VARBINARY 值。

行为类型

不可变

语法

HEX_TO_BINARY ( [ 0x ] expression )

参数

expression: （BINARY 或 VARBINARY）要转换的字符串。
0x: 可选前缀。

注意

VARBINARY HEX_TO_BINARY(VARCHAR) 将数据从十六进制格式字符类型转换为二进制类型。此函数是 TO_HEX 的反函数。

HEX_TO_BINARY(TO_HEX(x)) = x)
TO_HEX(HEX_TO_BINARY(x)) = x)

如果十六进制值中存在奇数个字符，则将第一个字符处理为第一个（最左边）字节的低效半字节。

示例

如果给定的字符串以“0x”开头，将忽略前缀。例如：

=> SELECT HEX_TO_BINARY('0x6162') AS hex1, HEX_TO_BINARY('6162') AS hex2;
 hex1 | hex2
------+------
 ab   | ab
(1 row)

如果给出的是无效的十六进制值，Vertica 将会返回“无效的二进制表达方式”错误；例如：

=> SELECT HEX_TO_BINARY('0xffgf');
ERROR:  invalid hex string "0xffgf"

另请参阅

TO_HEX

5.15 - HEX_TO_INTEGER

将给定的 VARCHAR 十六进制表示方式转换为 INTEGER 值。

Vertica 按如下方式完成此转换：

如果输入中未指定，则添加 0x 前缀
将 VARCHAR 字符串转换为 NUMERIC
将 NUMERIC 转换为 INTEGER

行为类型

不可变

语法

HEX_TO_INTEGER ( [ 0x ] expression )

参数

expression: VARCHAR 是要转换的字符串。
0x: 为可选前缀。

示例

您可以输入带有或不带有 Ox 前缀的字符串。例如：

=> SELECT HEX_TO_INTEGER ('0aedc')
         AS hex1,HEX_TO_INTEGER ('aedc') AS hex2;
 hex1  | hex2
-------+-------
 44764 | 44764
(1 row)

如果向函数传递无效十六进制值，Vertica 将返回 invalid input syntax 错误；例如：

=> SELECT HEX_TO_INTEGER ('0xffgf');
ERROR 3691:  Invalid input syntax for numeric: "0xffgf"

另请参阅

5.16 - INITCAP

使每个字母数字单词的首字母大写，并使其余字母小写。

行为类型

不可变

语法

INITCAP ( expression )

参数

expression: (VARCHAR) 是要格式化的字符串。

注意

具体取决于区域设置的排序规则设置。
INITCAP 限定为 32750 个八位字节输入，因为以 UTF-8 表示的结果大小可能会翻倍。

示例

5.17 - INITCAPB

使每个字母数字单词的首字母大写，并使其余字母小写。多字节字符不会转换，而是跳过。

行为类型

不可变

语法

INITCAPB ( expression )

参数

expression: (VARCHAR) 是要格式化的字符串。

注意

具体取决于区域设置的排序规则设置。

示例

表达式

结果

SELECT INITCAPB('étudiant');

éTudiant

SELECT INITCAPB('high speed database');

High Speed Database

SELECT INITCAPB('LINUX TUTORIAL');

Linux Tutorial

SELECT INITCAPB('abc DEF 123aVC 124Btd,lAsT');

Abc Def 123Avc 124Btd,Last

SELECT INITCAPB('');

SELECT INITCAPB(null);

5.18 - INSERT

将一个字符串插入另一个字符串的指定位置。

语法

INSERT( 'string1', n, m, 'string2' )

行为类型

不可变

参数

string1: (VARCHAR) 为要在其中插入新字符串的字符串。
n: INTEGER 类型的字符，表示在 string1 内执行插入的起点。指定 string1 中第一个字符的字符数作为插入的起点。例如，要在 "c" 之前插入字符，请在字符串 "abcdef" 中输入 3。
m: INTEGER 类型的字符，表示应替换为插入的 string1 （若有）中的字符数。例如，如果希望插入替换字符串 "abcdef" 中的字母 "cd"，请输入 2。
string2: (VARCHAR) 为要插入的字符串。

示例

以下示例使用 INSERT 函数将字符串 Warehouse 更改为 Storehouse：

=> SELECT INSERT ('Warehouse',1,3,'Stor');
   INSERT
------------
 Storehouse
(1 row)

5.19 - INSTR

搜索字符串中的子字符串，并返回一个整数，指示字符串中第一次出现的字符的位置。返回值代表被指定字符出现的位置。

行为类型

不可变

语法

INSTR ( string , substring [, position [, occurrence ] ] )

参数

string: (CHAR 或 VARCHAR，或 BINARY 或 VARBINARY) 搜索文本表达式。
substring: (CHAR 或 VARCHAR，或 BINARY 或 VARBINARY) 搜索字符串。
position: 非零整数，代表 Vertica 开始搜索的字符串中的字符。如果 position 为负，Vertica 在字符串尾部从右到左进行搜索。字符串的首字母 position 默认值为 1， position 不可为 0。
occurrence: 整数，代表 Vertica 搜索的第几次出现的字符串。occurrence 值必须为正 (大于 0)，默认值为 1。

注意

position 和 occurrence 都必须是能够解析为整数的类型。两个参数的默认值都是 1，代表 Vertica 开始搜索字符串的第一个字符在子字符串中首次出现的位置。返回值与 position 值无关，从字符串的开端开始计算，并且是一个字符。

如果搜索不成功（即子字符串未在 string 的 position 字符后显示出现次数，则返回值为 0。

示例

第一个例子是在字符串 ‘abc’ 中从左到右搜索子字符串 ‘b’。搜索 ‘b’ 在 ‘abc’ 中出现的位置，或 position 2。以为没有提供 position 参数，搜索默认从 position 1 ，‘a’ 开始。

=> SELECT INSTR('abc', 'b');
 INSTR
-------
     2
(1 row)

接下来的是哪个例子使用字符位置来从右到左搜索子字符串的位置。

注意

虽然函数返回一个负数看上去比较直观，n 出现的位置是从左到右数，而搜索是按照相反方向进行（从右到左进行）。

第一个例子中，函数从字符串最后一个字符 ‘c’ 开始，从右到左开始数一个字符。函数随后向后搜索第一次出现的‘a’，在搜索字符串中的第一个位置找到了该字符。

=> SELECT INSTR('abc', 'a', -1);
 INSTR
-------
     1
(1 row)

第二个例子中，函数从字符串最后一个字符 ‘c’ 开始，从右到左开始数一个字节。函数随后向后搜索第一次出现的‘a’，在搜索字符串中的第一个位置找到了该字符。

=> SELECT INSTR(VARBINARY 'abc', VARBINARY 'a', -1);
 INSTR
-------
     1
(1 row)

第三个例子中，函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字符，并且从右到左搜索子字符串 ‘bc’，并发现在所搜索字符串的第二个位置。

=> SELECT INSTR('abcb', 'bc', -1);
 INSTR
-------
     2
(1 row)

第四个例子中，函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字符，并且从右到左搜索子字符串 ‘bcef’，并没有搜索到。结果为 0。

=> SELECT INSTR('abcb', 'bcef', -1);
INSTR
-------
     0
(1 row)

第五个例子中，函数从函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字节，并且从右到左搜索子字符串 ‘bcef’，并没有搜索到。结果为 0。

=> SELECT INSTR(VARBINARY 'abcb', VARBINARY 'bcef', -1);
INSTR
-------
     0
(1 row)

多字节字符被认为是一个单独的字符：

=> SELECT INSTR('aébc', 'b');
 INSTR
-------
     3
(1 row)

使用 INSTRB 将多字节字符做为二进制处理。

=> SELECT INSTRB('aébc', 'b');
  INSTRB
--------
      4
(1 row)

5.20 - INSTRB

在 string 中搜索 substring，并返回一个指示八位字节在字符串中首次出现位置的整数。返回值取决于八位字节中标识字节的位置。

行为类型

不可变

语法

INSTRB ( string , substring [, position [, occurrence ] ] )

参数

string: 为要搜索的文本表达式。
substring: 为要搜索的字符串。
position: 为非零整数，代表 Vertica 开始搜索的字符串中的字符。如果 position 为负，Vertica 在字符串尾部从右到左进行搜索。字符串的首字节 position 默认值为 1，position 不可为 0。
occurrence: 为整数，代表 Vertica 搜索的第几次出现的字符串。occurrence 值必须为正 (大于 0)，默认值为 1。

注意

position 和 occurrence 都必须是能够解析为整数的类型。两个参数的默认值都是 1，代表 Vertica 开始搜索字符串的第一个字节在子字符串中首次出现的位置。返回值与 position 值无关，从字符串的开端开始计算，并且是一个八位字节。

如果搜索不成功（即子字符串未在 string 的 position 字符后显示出现次数，则返回值为 0。

示例

=> SELECT INSTRB('straße', 'ß');
 INSTRB
--------
      5
(1 row)

另请参阅

INSTR

5.21 - ISUTF8

测试字符串是否是有效的 UTF-8 字符串。如果字符串符合 UTF-8 标准，则返回 ture，否则返回 false。此函数可以在操作正则表达式函数之前，用来检验字符串是否符合 UTF-8 标准，例如 REGEXP_LIKE 默认是 UTF-8 字符。

ISUTF8 会按照 UTF-8 规则来检查无效的 UTF8 字节序列：

无效字节
意外的延续字节
开始字节后没有足够的延续字节
重载编码

无效 UTF-8 字节序列返回 false 值

要将字符串强制转换为 UTF-8，请使用 MAKEUTF8。

语法

ISUTF8( string );

参数

string: 待做 UTF-8 一致性检查的字符串

示例

=> SELECT ISUTF8(E'\xC2\xBF'); \-- UTF-8 INVERTED QUESTION MARK ISUTF8
--------
 t
(1 row)

=> SELECT ISUTF8(E'\xC2\xC0'); \-- UNDEFINED UTF-8 CHARACTER
 ISUTF8
--------
 f
(1 row)

5.22 - LEAST

返回任何数据类型的表达式列表中的最小值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。

行为类型

稳定

语法

LEAST ( { * | expression[,...] } )

参数

* | expression[,...]

要求值的表达式，为以下之一：

* （星号）

对查询表中的所有列进行求值。
表达式

任何数据类型的表达式。expression 中包含的函数必须具有确定性。

示例

LEASTB 返回 5 作为列表中的最小值：

=> SELECT LEASTB(7, 5, 10);
 LEASTB
--------
      5
(1 row)

如果在整数表达式周围添加引号，LEASTB 会将值作为字符串进行比较，并返回 "10" 作为最小值：

=> SELECT LEASTB('7', '5', '10');
 LEASTB
--------
 10
(1 row)

LEAST 返回 1.5，因为 INTEGER 2 隐式转换为 FLOAT：

=> SELECT LEAST(2, 1.5);
 LEAST
-------
   1.5
(1 row)

LEAST 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最小值：

=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_height, shelf_width, shelf_depth, least(*) FROM query1 WHERE shelf_height = 5;
 shelf_height | shelf_width | shelf_depth | least
--------------+-------------+-------------+-------
            5 |           3 |           4 |     3
            5 |           4 |           3 |     3
            5 |           1 |           4 |     1
            5 |           4 |           1 |     1
            5 |           2 |           4 |     2
            5 |           2 |           3 |     2
            5 |           1 |           3 |     1
            5 |           1 |           3 |     1
            5 |           5 |           1 |     1
            5 |           2 |           4 |     2
            5 |           4 |           5 |     4
            5 |           2 |           4 |     2
            5 |           4 |           4 |     4
            5 |           3 |           4 |     3
...

另请参阅

GREATEST

5.23 - LEASTB

使用二进制排序返回任何数据类型的表达式列表中的最小值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。

行为类型

不可变

语法

LEASTB ( { * | expression[,...] } )

参数

* | expression[,...]

要求值的表达式，为以下之一：

* （星号）

对查询表中的所有列进行求值。
表达式

任何数据类型的表达式。expression 中包含的函数必须具有确定性。

示例

以下命令选择 strasse 作为列表中的最小值：

=> SELECT LEASTB('straße', 'strasse');
 LEASTB
---------
 strasse
(1 row)

LEASTB 返回 5 作为列表中的最小值：

=> SELECT LEAST(7, 5, 10);
 LEAST
-------
     5
(1 row)

如果在整数表达式周围添加引号，LEAST 会将值作为字符串进行比较，并返回 "10" 作为最小值：

=> SELECT LEASTB('7', '5', '10');
 LEAST
-------
 10
(1 row)

下一个示例返回 1.5，因为 INTEGER 2 隐式转换为 FLOAT：

=> SELECT LEASTB(2, 1.5);
 LEASTB
--------
    1.5
(1 row)

LEASTB 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最小值：

=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_height, shelf_width, shelf_depth, leastb(*) FROM query1 WHERE shelf_height = 5;
 shelf_height | shelf_width | shelf_depth | leastb
--------------+-------------+-------------+--------
            5 |           3 |           4 |      3
            5 |           4 |           3 |      3
            5 |           1 |           4 |      1
            5 |           4 |           1 |      1
            5 |           2 |           4 |      2
            5 |           2 |           3 |      2
            5 |           1 |           3 |      1
            5 |           1 |           3 |      1
            5 |           5 |           1 |      1
            5 |           2 |           4 |      2
            5 |           4 |           5 |      4
            5 |           2 |           4 |      2
            5 |           4 |           4 |      4
            5 |           3 |           4 |      3
            5 |           5 |           4 |      4
            5 |           5 |           1 |      1
            5 |           3 |           1 |      1
...

另请参阅

GREATESTB

5.24 - LEFT

返回字符串左侧指定字符。

行为类型

不可变

语法

LEFT ( string‑expr, length )

参数

string‑expr: 要返回的字符串表达式。
length: 一个整数值，指定要返回的字符数。

示例

=> SELECT LEFT('vertica', 3);
 LEFT
------
 ver
(1 row)

 SELECT DISTINCT(
   LEFT (customer_name, 4)) FnameTruncated
   FROM customer_dimension ORDER BY FnameTruncated LIMIT 10;
 FnameTruncated
----------------
 Alex
 Amer
 Amy
 Anna
 Barb
 Ben
 Bett
 Bria
 Carl
 Crai
(10 rows)

另请参阅

SUBSTR

5.25 - LENGTH

返回字符串的长度。LENGTH 的行为因输入数据类型而异：

CHAR 和 VARCHAR：与 CHARACTER_LENGTH 相同，返回以 UTF-8 字符数表示的字符串长度，
CHAR：去掉填充值。
BINARY 和 VARBINARY：与 OCTET_LENGTH 相同，返回以字节（八位字节）数表示的字符串长度。

行为类型

不可变

语法

LENGTH ( expression )

参数

表达式: 要求值的字符串，为以下之一：CHAR、VARCHAR、BINARY 或 VARBINARY。

示例

另请参阅

BIT_LENGTH

5.26 - LOWER

接受一个字符串值并返回一个转换为小写的 VARCHAR 值。

行为类型

stable

语法

LOWER ( expression )

参数

表达式: 要转换的 CHAR 或 VARCHAR 字符串，其中字符串宽度 ≤ 65000 个八位字节。

重要

在实践中，expression 不得超过 32,500 个八位字节。LOWER 不使用区域设置的排序规则设置（例如，"collation=binary"）标识其编码，而是将输入实参视为 UTF-8 编码字符串。输入值的 UTF-8 表示可能是其原始宽度的两倍。因此，如果输入值超过 32,500 个八位字节，LOWER 将返回错误。

另请注意，如果 expression 为表列，则 LOWER 根据定义的列宽度而不是列数据计算其大小。如果列宽度大于 VARCHAR(32500)，Vertica 将返回错误。

示例

=> SELECT LOWER('AbCdEfG');
  LOWER
---------
 abcdefg
(1 row)

=> SELECT LOWER('The Bat In The Hat');
       LOWER
--------------------
 the bat in the hat
(1 row)

=> SELECT LOWER('ÉTUDIANT');
  LOWER
----------
 étudiant
(1 row)

5.27 - LOWERB

返回一个所有 ASCII 字符都转换为小写的字符串。跳过（而非转换）多字节字符。

行为类型

不可变

语法

LOWERB ( expression )

参数

表达式: 要转换的 CHAR 或 VARCHAR 字符串

示例

在下例中，多字节 UTF-8 字符 É 未转换为小写：

=> SELECT LOWERB('ÉTUDIANT');
  LOWERB
----------
 Étudiant
(1 row)

=> SELECT LOWER('ÉTUDIANT');
  LOWER
----------
 étudiant
(1 row)

=> SELECT LOWERB('AbCdEfG');
 LOWERB
---------
 abcdefg
(1 row)

=> SELECT LOWERB('The Vertica Database');
        LOWERB
----------------------
 the vertica database
(1 row)

5.28 - LPAD

返回一个 VARCHAR 值，该值表示在左侧用特定字符填充的特定长度的字符串。

行为类型

不可变

语法

LPAD ( expression , length [ , fill ] )

参数

expression: （CHAR 或 VARCHAR）指定要填充的字符串
length: (INTEGER) 指定要返回的字符数
fill: （CHAR 或 VARCHAR）指定用于填充输出字符串的重复字符串。默认值是空格字符。

示例

=> SELECT LPAD('database', 15, 'xzy');
      LPAD
-----------------
 xzyxzyxdatabase
(1 row)

如果字符串大于指定长度，则在右侧截断：

=> SELECT LPAD('establishment', 10, 'abc');
    LPAD
------------
 establishm
(1 row)

5.29 - LTRIM

返回一个表示从左侧（前部）移除空格的字符串的 VARCHAR 值。

行为类型

不可变

语法

LTRIM ( expression [ , characters ] )

参数

expression: （CHAR 或 VARCHAR）是要修剪的字符串
characters: （CHAR 或 VARCHAR）指定要从 expression 左侧移除的字符。默认值是空格字符。

示例

=> SELECT LTRIM('zzzyyyyyyxxxxxxxxtrim', 'xyz');
 LTRIM
-------
 trim
(1 row)

另请参阅

5.30 - MAKEUTF8

通过移除或替换非 UTF-8 字符，将字符串强制转换为 UTF-8。

MAKEUTF8 逐字节标记无效的 UTF-8 字符。例如，字节序列 0xE0 0x7F 0x80 为无效三字节 UTF-8 序列，但中间字节 0x7F 为有效单字节 UTF-8 字符。在本例中，0x7F 被保留，另外两个字节被移除或替换。

语法

MAKEUTF8( string‑expression [USING PARAMETERS param=value] );

参数

string-expression: 用于对非 UTF-8 字符进行求值的字符串表达式

参数

replacement_string

指定 MAKEUTF8 用于替换在 string-expression 中找到的每个非 UTF-8 字符的 VARCHAR(16) 字符串。如果省略此参数，则会移除非 UTF-8 字符。例如，以下 SQL 可指定将 name 列中的所有非 UTF 字符替换为字符串 ^：

=> SELECT MAKEUTF8(name USING PARAMETERS replacement_string='^') FROM people;

5.31 - MD5

计算字符串的 MD5 哈希值，将结果以十六进制的 VARCHAR 字符串形式返回。

行为类型

不可变

语法

MD5 ( string )

参数

string: 是实参字符串。

示例

=> SELECT MD5('123');
               MD5
----------------------------------
 202cb962ac59075b964b07152d234b70
(1 row)

=> SELECT MD5('Vertica'::bytea);
               MD5
----------------------------------
 fc45b815747d8236f9f6fdb9c2c3f676
(1 row)

另请参阅

5.32 - OCTET_LENGTH

将一个实参作为输入，并返回所有字符串类型的字符串长度（八位字节）。

行为类型

不可变

语法

OCTET_LENGTH ( expression )

参数

expression: (CHAR 或 VARCHAR 或 BINARY 或 VARBINARY) 是需要测量的字符串。

注意

如果 expression 的数据类型是 CHAR、VARCHAR 或 VARBINARY，结果与八位字节 expression 的实际长度相同。对于 CHAR，长度不包含任何结尾空格。
如果 expression 的数据类型是 BINARY，结果与 expression 的固定长度相同。
如果 expression 的值为 NULL，则结果为 NULL。

示例

另请参阅

5.33 - OVERLAY

将一个字符串的一部分替换为另一个字符串，并将新的字符串值以 VARCHAR 形式返回。

行为类型

如果使用 OCTETS，则为不可变，否则为稳定

语法

OVERLAY ( input‑string PLACING replace‑string FROM position [ FOR extent ] [ USING { CHARACTERS | OCTETS } ] )

参数

input‑string

要处理的字符串，类型为 CHAR 或 VARCHAR。

replace‑string

用于替换 input-string 的指定子字符串的字符串，类型为 CHAR 或 VARCHAR。

position

整数 ≥1，指定 input‑string 的第一个字符或八位字节覆盖 replace‑string。

extent

整数，指定要使用 replace‑string 覆盖的 input‑string 字符或八位字节的数量。如果省略，则 OVERLAY 使用 replace‑string 的长度。

例如，比较以下 OVERLAY 调用：

OVERLAY 省略 FOR 子句。输入字符串中替换的字符数等于替换字符串 ABC 中的字符数：


dbadmin=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5);
  overlay
-----------
 1234ABC89
(1 row)

OVERLAY 包括 FOR 子句，指定使用替换字符串替换输入字符串中的 4 个字符。替换字符串的长度为三个字符，因此 OVERLAY 返回的字符串比输入字符串少 1 个字符：
```
=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5 FOR 4);
 overlay
----------
 1234ABC9
(1 row)
```
OVERLAY 包括 FOR 子句，指定使用替换字符串替换输入字符串中的 -2 个字符。函数返回的字符串比输入字符串多 2 个字符：
```
=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5 FOR -2);
    overlay
----------------
 1234ABC3456789
(1 row)
```

USING CHARACTERS | OCTETS

指定 OVERLAY 使用字符（默认）还是八位字节。

注意

如果指定 USING OCTETS，Vertica 将调用 OVERLAYB 函数。

示例

=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2);
  overlay
-----------
 1xxx56789
(1 row)

=> SELECT OVERLAY('123456789' PLACING 'XXX' FROM 2 USING OCTETS);
 overlayb
-----------
 1XXX56789
(1 row)

=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 4);
 overlay
----------
 1xxx6789
(1 row)

=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 5);
 overlay
---------
 1xxx789
(1 row)

=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 6);
 overlay
---------
 1xxx89
(1 row)

5.34 - OVERLAYB

将一个字符串的一部分替换为另一个字符串，并将新的字符串以八位字节值的形式返回。

OVERLAYB 函数将多字节字符串视为八位字节（字节）串，并使用八进制数作为输入和输出的位置及长度说明符。字符串本身是 VARCHAR 类型，但把每个字节视为一个单独的字符串。

行为类型

不可变

语法

OVERLAYB ( input‑string, replace‑string, position [, extent ] )

参数

input‑string: 要处理的字符串，类型为 CHAR 或 VARCHAR。
replace‑string: 用于替换 input-string 的指定子字符串的字符串，类型为 CHAR 或 VARCHAR。
position: 整数 ≥1，指定 input‑string 的第一个八位字节覆盖 replace‑string。
extent: 整数，指定要使用 replace‑string 覆盖的 input‑string 八位字节的数量。如果省略，则 OVERLAY 使用 replace‑string 的长度。

示例

=> SELECT OVERLAYB('123456789', 'ééé', 2);
 OVERLAYB
----------
 1ééé89
(1 row)

=> SELECT OVERLAYB('123456789', 'ßßß', 2);
 OVERLAYB
----------
 1ßßß89
(1 row)

=> SELECT OVERLAYB('123456789', 'xxx', 2);
 OVERLAYB
-----------
 1xxx56789
(1 row)

=> SELECT OVERLAYB('123456789', 'xxx', 2, 4);
 OVERLAYB
----------
 1xxx6789
(1 row)

=> SELECT OVERLAYB('123456789', 'xxx', 2, 5);
 OVERLAYB
----------
 1xxx789
(1 row)

=> SELECT OVERLAYB('123456789', 'xxx', 2, 6);
 OVERLAYB
----------
 1xxx89
(1 row)

5.35 - POSITION

返回示带字符串的特定子字符串的字符位置的 INTEGER 值表（从 1 开始计数）。

行为类型

不可变

语法 1

POSITION ( substring IN string [ USING { CHARACTERS | OCTETS } ] )

参数

substring: （CHAR 或 VARCHAR）是要查找的子字符串
string: （CHAR 或 VARCHAR）是要从中查找子字符串的字符串
USING CHARACTERS | OCTETS: 确定是否使用字符（默认）或八进制数来报告位置。

语法 2

POSITION ( substring IN string )

参数

substring: (VARBINARY) 为要定位的子字符串
string: (VARBINARY) 为要在其中定位子字符串的字符串

注意

当字符串和子字符串为 CHAR 或 VARCHAR 时，返回值基于字符或子字符串的八进制数位置。
当字符串和子字符串为 VARBINARY 时，返回值通常基于子字符串的八进制数位置。
字符串和子字符串必须一致。不要将 VARBINARY 与 CHAR 或 VARCHAR 混合。
POSITION 类似于 STRPOS，尽管 POSITION 允许通过字符和八进制数查找。
如果未找到字符串，则返回值为零。

示例

=> SELECT POSITION('é' IN 'étudiant' USING CHARACTERS);
 position
----------
        1
(1 row)

=> SELECT POSITION('ß' IN 'straße' USING OCTETS);
 positionb
-----------
         5
(1 row)

=> SELECT POSITION('c' IN 'abcd' USING CHARACTERS);
 position
----------
        3
(1 row)

=> SELECT POSITION(VARBINARY '456' IN VARBINARY '123456789');
 position
----------
        4
(1 row)

SELECT POSITION('n' in 'León') as 'default',
       POSITIONB('León', 'n') as 'POSITIONB',
       POSITION('n' in 'León' USING CHARACTERS) as 'pos_chars',
       POSITION('n' in 'León' USING OCTETS) as 'pos_oct',INSTR('León','n'),
       INSTRB('León','n'), REGEXP_INSTR('León','n');
 default | POSITIONB | pos_chars | pos_oct | INSTR | INSTRB | REGEXP_INSTR
---------+-----------+-----------+---------+-------+--------+--------------
       4 |         5 |         4 |       5 |     4 |      5 |            4
(1 row)

5.36 - POSITIONB

返回一个 INTEGER 值，该值表示指定子字符串的八位字节在字符串中的位置（从 1 开始计数）。

行为类型

不可变

语法

POSITIONB ( string, substring )

参数

string: （CHAR 或 VARCHAR）是要从中查找子字符串的字符串
substring: （CHAR 或 VARCHAR）是要查找的子字符串

示例

=> SELECT POSITIONB('straße', 'ße');
 POSITIONB
-----------
         5
(1 row)


=> SELECT POSITIONB('étudiant', 'é');
 POSITIONB
-----------
         1
(1 row)

5.37 - QUOTE_IDENT

以在 SQL 语句中将字符串用作标识符所需的格式返回指定的字符串实参。根据需要添加引号 — 例如，如果字符串包含非标识符字符，或者为 SQL 或 Vertica 预留关键字：

1time
Next week
SELECT

嵌入的双引号将会加倍。

注意

SQL 标识符（例如表名称和列名称）以创建的形式存储，并使用不区分大小写的比较方法来解析对它们的引用。因此，无需使用双引号将混合大小写的标识符括起。
Vertica 引用所有保留关键字，即使未使用。

行为类型

不可变

语法

QUOTE_IDENT( 'string' )

参数

string: 要引用的字符串

示例

引用的标识符不区分大小写，并且 Vertica 不提供引号：

=> SELECT QUOTE_IDENT('VErtIcA');
 QUOTE_IDENT
-------------
 VErtIcA
(1 row)

=> SELECT QUOTE_IDENT('Vertica database');
    QUOTE_IDENT
--------------------
 "Vertica database"
(1 row)

嵌入的双引号将会加倍：

=> SELECT QUOTE_IDENT('Vertica "!" database');
       QUOTE_IDENT
--------------------------
 "Vertica ""!"" database"
(1 row)

以下示例使用了 SQL 关键 SELECT，因此结果使用双引号括起：

=> SELECT QUOTE_IDENT('select');
 QUOTE_IDENT
-------------
 "select"
(1 row)

另请参阅

5.38 - QUOTE_LITERAL

返回以适当方式引用的给定字符串，以便用作 SQL 语句字符串中的一个字符串字面量。嵌入的单引号和反斜杠将会加倍。根据 SQL 标准，函数将字符串字面量中的两个连续单引号识别为单引号字符。

行为类型

不可变

语法

QUOTE_LITERAL ( string )

参数

<<<<<<<
string-expression: 解析为一个或多个字符串以格式化为字符串文本的实参。 =======
string-expression: 解析为一个或多个字符串以格式化为字符串字面量的实参。

示例

在下例中，第一个查询没有返回 Cher 或 Sting 的名字；第二个查询使用 QUOTE_LITERAL，通过单引号设置字符串值，包括空字符串。在这种情况下，Sting 的 fname 设置为空字符串 ('')，而 Cher 的 fname 为空，表示设置为 NULL 值：

=> SELECT * FROM lead_vocalists ORDER BY lname ASC;
 fname  |  lname  |                      band
--------+---------+-------------------------------------------------
        | Cher    | ["Sonny and Cher"]
 Mick   | Jagger  | ["Rolling Stones"]
 Diana  | Ross    | ["Supremes"]
 Grace  | Slick   | ["Jefferson Airplane","Jefferson Starship"]
        | Sting   | ["Police"]
 Stevie | Winwood | ["Spencer Davis Group","Traffic","Blind Faith"]
(6 rows)

=> SELECT QUOTE_LITERAL (fname) "First Name", QUOTE_NULLABLE (lname) "Last Name", band FROM lead_vocalists ORDER BY lname ASC;
 First Name | Last Name |                      band
------------+-----------+-------------------------------------------------
            | 'Cher'    | ["Sonny and Cher"]
 'Mick'     | 'Jagger'  | ["Rolling Stones"]
 'Diana'    | 'Ross'    | ["Supremes"]
 'Grace'    | 'Slick'   | ["Jefferson Airplane","Jefferson Starship"]
 ''         | 'Sting'   | ["Police"]
 'Stevie'   | 'Winwood' | ["Spencer Davis Group","Traffic","Blind Faith"]
(6 rows)

另请参阅

5.39 - QUOTE_NULLABLE

返回适当引用的给定字符串，用作 SQL 语句字符串中的字符串字面量；或者，如果实参为 NULL，则返回不带引号的字符串 NULL。嵌入的单引号和反斜杠将会适当加倍。

行为类型

不可变

语法

QUOTE_NULLABLE ( string-expression )

参数

<<<<<<<
string-expression: 解析为一个或多个字符串以格式化为字符串文本的实参。如果 string-expression 解析为 NULL 值，则 QUOTE_NULLABLE 返回 NULL。 =======
string-expression: 解析为一个或多个字符串以格式化为字符串字面量的实参。如果 string-expression 解析为 NULL 值，则 QUOTE_NULLABLE 返回 NULL。

示例

以下示例使用表 lead_vocalists，其中 Cher 和 Sting 的名字 (fname) 分别设置为 NULL 和空字符串。

=> SELECT * from lead_vocalists ORDER BY lname DESC;
 fname  |  lname  |                      band
--------+---------+-------------------------------------------------
 Stevie | Winwood | ["Spencer Davis Group","Traffic","Blind Faith"]
        | Sting   | ["Police"]
 Grace  | Slick   | ["Jefferson Airplane","Jefferson Starship"]
 Diana  | Ross    | ["Supremes"]
 Mick   | Jagger  | ["Rolling Stones"]
        | Cher    | ["Sonny and Cher"]
(6 rows)

=> SELECT * FROM lead_vocalists WHERE fname IS NULL;
 fname | lname |        band
-------+-------+--------------------
       | Cher  | ["Sonny and Cher"]
(1 row)

=> SELECT * FROM lead_vocalists WHERE fname = '';
 fname | lname |    band
-------+-------+------------
       | Sting | ["Police"]
(1 row)

以下查询使用 QUOTE_NULLABLE。与 QUOTE_LITERAL 类似，QUOTE_NULLABLE 使用单引号设置字符串值，包括空字符串。与 QUOTE_LITERAL 不同，QUOTE_NULLABLE 对 NULL 值输出 NULL：


=> SELECT QUOTE_NULLABLE (fname) "First Name", QUOTE_NULLABLE (lname) "Last Name", band FROM lead_vocalists ORDER BY fname DESC;
 First Name | Last Name |                      band
------------+-----------+-------------------------------------------------
 NULL       | 'Cher'    | ["Sonny and Cher"]
 'Stevie'   | 'Winwood' | ["Spencer Davis Group","Traffic","Blind Faith"]
 'Mick'     | 'Jagger'  | ["Rolling Stones"]
 'Grace'    | 'Slick'   | ["Jefferson Airplane","Jefferson Starship"]
 'Diana'    | 'Ross'    | ["Supremes"]
 ''         | 'Sting'   | ["Police"]
(6 rows)

另请参阅

字符字符串字面量

5.40 - REPEAT

将字符串复制指定次数并连接复制的值作为单个字符串。返回值采用字符串实参的数据类型。非 LONG 数据类型和 LONG 数据类型的返回值的长度分别最多可达 65000 和 32000000 字节。如果 string * count 的长度超出这些限制，Vertica 将静默截断结果。

行为类型

不可变

语法

REPEAT ( 'string', count )

实参

string

要重复的字符串，为以下之一：

CHAR
VARCHAR
BINARY
VARBINARY
LONG VARCHAR
LONG VARBINARY

count

整数表达式，指定重复 string 的次数。

示例

以下示例将重复 vmart 三次：

=> SELECT REPEAT ('vmart', 3);
     REPEAT
-----------------
 vmartvmartvmart
(1 row)

5.41 - REPLACE

将字符串中的所有字符实例替换为另一组字符。

行为类型

不可变

语法

REPLACE ('string', 'target', 'replacement' )

参数

string: 要修改的字符串。
目标值: string 中要替换的字符。
replacement: 用于替换 target 的字符。

示例

=> SELECT REPLACE('Documentation%20Library', '%20', ' ');
        REPLACE
-----------------------
 Documentation Library
(1 row)

=> SELECT REPLACE('This &amp; That', '&amp;', 'and');
    REPLACE
---------------
 This and That
(1 row)

=> SELECT REPLACE('straße', 'ß', 'ss');
 REPLACE
---------
 strasse
(1 row)

5.42 - RIGHT

从字符串右侧返回指定的字符。

行为类型

不可变

语法

RIGHT ( string‑expr, length )

参数

string‑expr: 要返回的字符串表达式。
length: 一个整数值，指定要返回的字符数。

示例

以下查询将返回字符串 "vertica" 的最后三个字符：

=> SELECT RIGHT('vertica', 3);
 RIGHT
-------
 ica
(1 row)

以下查询从表 store.store_orders_fact 查询日期列 date_ordered。将日期强制转换为字符串并从每个字符串提取最后五个字符。然后，返回所有不同的字符串：

SELECT DISTINCT(
  RIGHT(date_ordered::varchar, 5)) MonthDays
  FROM store.store_orders_fact ORDER BY MonthDays;
 MonthDays
-----------
 01-01
 01-02
 01-03
 01-04
 01-05
 01-06
 01-07
 01-08
 01-09
 01-10
 02-01
 02-02
 02-03
 ...
 11-08
 11-09
 11-10
 12-01
 12-02
 12-03
 12-04
 12-05
 12-06
 12-07
 12-08
 12-09
 12-10
(120 rows)

另请参阅

SUBSTR

5.43 - RPAD

返回一个 VARCHAR 值，表示在右侧填充了特定字符的特定长度的字符串。

行为类型

不可变

语法

RPAD ( expression , length [ , fill ] )

参数

expression: （CHAR 或 VARCHAR）指定要填充的字符串
length: (INTEGER) 指定要返回的字符数
fill: （CHAR 或 VARCHAR）指定用于填充输出字符串的重复字符串。默认值是空格字符。

示例

=> SELECT RPAD('database', 15, 'xzy');
      RPAD
-----------------
 databasexzyxzyx
(1 row)

如果字符串大于指定长度，则在右侧截断：

=> SELECT RPAD('database', 6, 'xzy');
  RPAD
--------
 databa
(1 row)

5.44 - RTRIM

返回 VARCHAR 值，表示已从右侧（末尾）移除尾随空格的字符串。

行为类型

不可变

语法

RTRIM ( expression [ , characters ] )

参数

expression: （CHAR 或 VARCHAR）是要修剪的字符串
characters: （CHAR 或 VARCHAR）指定从 expression 右侧移除的字符。默认值是空格字符。

示例

=> SELECT RTRIM('trimzzzyyyyyyxxxxxxxx', 'xyz');
 RTRIM
-------
 trim
(1 row)

另请参阅

5.45 - SHA1

使用美国安全哈希算法 1 计算字符串的 SHA1 哈希。以十六进制 VARCHAR 字符串形式返回结果。

行为类型

不可变

语法

SHA1 ( string )

参数

string: 要计算的 VARCHAR 或 VARBINARY 字符串。

示例

以下示例计算提供的字符串的 SHA1 哈希：

=> SELECT SHA1('123');
                   SHA1
------------------------------------------
 40bd001563085fc35165329ea1ff5c5ecbdbbeef
(1 row)

=> SELECT SHA1('Vertica'::bytea);
                   SHA1
------------------------------------------
 ee2cff8d3444995c6c301546c4fc5ee152d77c11
(1 row)

另请参阅

5.46 - SHA224

使用美国安全哈希算法 2 计算字符串的 SHA224 哈希。以十六进制 VARCHAR 字符串形式返回结果。

行为类型

不可变

语法

SHA224 ( string )

参数

string: 要计算的 VARCHAR 或 VARBINARY 字符串。

示例

以下示例计算提供的字符串的 SHA224 哈希：

=> SELECT SHA224('abc');
                      SHA224
----------------------------------------------------------
78d8045d684abd2eece923758f3cd781489df3a48e1278982466017f
(1 row)

=> SELECT SHA224('Vertica'::bytea);
                      SHA224
----------------------------------------------------------
 135ac268f64ff3124aeeebc3cc0af0a29fd600a3be8e29ed97e45e25
(1 row)

=> SELECT sha224(''::varbinary) = 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f' AS "TRUE";
 TRUE
------
t
(1 row)

另请参阅

5.47 - SHA256

使用美国安全哈希算法 2 计算字符串的 SHA256 哈希。以十六进制 VARCHAR 字符串形式返回结果。

行为类型

不可变

语法

SHA256 ( string )

参数

string: 要计算的 VARCHAR 或 VARBINARY 字符串。

示例

以下示例计算提供的字符串的 SHA256 哈希：

=> SELECT SHA256('abc');
                              SHA256
------------------------------------------------------------------
 a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
(1 row)

=> SELECT SHA256('Vertica'::bytea);
                              SHA256
------------------------------------------------------------------
 9981b0b7df9f5be06e9e1a7f4ae2336a7868d9ab522b9a6ca6a87cd9ed95ba53
(1 row)

=> SELECT sha256('') = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' AS "TRUE";
 TRUE
------
t
(1 row)

另请参阅

5.48 - SHA384

使用美国安全哈希算法 2 计算字符串的 SHA384 哈希。以十六进制 VARCHAR 字符串形式返回结果。

行为类型

不可变

语法

SHA384 ( string )

参数

string: 要计算的 VARCHAR 或 VARBINARY 字符串。

示例

以下示例计算提供的字符串的 SHA384 哈希：

=> SELECT SHA384('123');
                                              SHA384
--------------------------------------------------------------------------------------------------
 9a0a82f0c0cf31470d7affede3406cc9aa8410671520b727044eda15b4c25532a9b5cd8aaf9cec4919d76255b6bfb00f
(1 row)

=> SELECT SHA384('Vertica'::bytea);
                                              SHA384
--------------------------------------------------------------------------------------------------
 3431a717dc3289862bbd636a064d26980b47ebe4684b800cff4756f0c24985866ef97763eafd548fedb0ce28722c96bb
(1 row)

另请参阅

5.49 - SHA512

使用美国安全哈希算法 2 计算字符串的 SHA512 哈希。以十六进制 VARCHAR 字符串形式返回结果。

行为类型

不可变

语法

SHA512 ( string )

参数

string: 要计算的 VARCHAR 或 VARBINARY 字符串。

示例

以下示例计算提供的字符串的 SHA512 哈希：

=> SELECT SHA512('123');
                                                          SHA512
----------------------------------------------------------------------------------------------------------------------------------
 3c9909afec25354d551dae21590bb26e38d53f2173b8d3dc3eee4c047e7ab1c1eb8b85103e3be7ba613b31bb5c9c36214dc9f14a42fd7a2fdb84856bca5c44c2

(1 row)

=> SELECT SHA512('Vertica'::bytea);
                                                          SHA512
----------------------------------------------------------------------------------------------------------------------------------
 c4ee2b2d17759226a3897c9c30d7c6df1145c4582849bb5191ee140bce05b83d3d869890cc3619b534fea6f97ff28a739d8b568a5ade66e756b3243ef97d3f00
(1 row)

另请参阅

5.50 - SOUNDEX

接受一个 VARCHAR 实参并返回一个四字符代码，该代码可以将该实参与其他 SOUNDEX 编码的字符串进行比较，这些字符串的英语拼写不同，但在语音上相似。SOUNDEX 实施由 Robert C. Russell 和 Margaret King Odell 开发的算法，并在计算机编程艺术（第 3 卷）中进行了介绍。

行为类型

不可变

语法

SOUNDEX ( string-expression )

参数

string-expression: 要编码的 VARCHAR 表达式。

Soundex 编码算法

Vertica 使用以下 Soundex 编码算法，该算法符合大多数 SQL 实施策略：

保存第一个字母。将所有出现的 a、e、i、o、u、y、h、w 映射到零 (0)。
使用数字替换所有辅音字母（包括第一个字母）：
- b、f、p、v → 1
- c、g、j、k、q、s、x、z → 2
- d、t → 3
- l → 4
- m、n → 5
- r → 6
使用一位数字替换所有相邻的相同数字，然后移除所有零 (0) 数字
如果保存的字母的数字与生成的第一个数字相同，则移除数字（保留字母）。
如果结果包含的数字少于 3 个，则附加 3 个零。移除除第一个字母及其后面 3 个数字以外的所有内容。

注意

编码会忽略所有非字母字符，例如 O'Connor 中的撇号。

示例

在 employee_dimension 表中查找与 Lee 发音相似的姓氏：

SELECT employee_last_name, employee_first_name, employee_state
    FROM public.employee_dimension
    WHERE SOUNDEX(employee_last_name) = SOUNDEX('Lee')
    ORDER BY employee_state, employee_last_name, employee_first_name;
 Lea                | James               | AZ
 Li                 | Sam                 | AZ
 Lee                | Darlene             | CA
 Lee                | Juanita             | CA
 Li                 | Amy                 | CA
 Li                 | Barbara             | CA
 Li                 | Ben                 | CA
 ...

另请参阅

SOUNDEX_MATCHES

5.51 - SOUNDEX_MATCHES

比较两个字符串的 Soundex 编码。然后，函数返回整数，以相同的顺序表示匹配字符的数量。返回值为 0 到 4（包含），其中 0 表示不匹配，4 表示完全匹配。

有关 Vertica 如何实施 Soundex 编码的详细信息，请参阅 Soundex 编码算法。

行为类型

不可变

语法

SOUNDEX_MATCHES ( string-expression1, string-expression2 )

参数

string-expression1, string-expression2: 要编码和比较的两个 VARCHAR 表达式。

示例

确定两个字符串的 Soundex 编码匹配程度：

比较 Lewis 与 Li 的 Soundex 编码：

> SELECT SOUNDEX_MATCHES('Lewis', 'Li');
 SOUNDEX_MATCHES
-----------------
               3
(1 row)

比较 Lee 与 Li 的 Soundex 编码：

=> SELECT SOUNDEX_MATCHES('Lee', 'Li');
 SOUNDEX_MATCHES
-----------------
               4
(1 row)

在 employee_dimension 表中查找其 Soundex 编码与 Lewis 编码中至少 3 个字符匹配的姓氏：

=> SELECT DISTINCT(employee_last_name)
      FROM public.employee_dimension
      WHERE SOUNDEX_MATCHES (employee_last_name, 'Lewis' ) >= 3 ORDER BY employee_last_name;
 employee_last_name
--------------------
 Lea
 Lee
 Leigh
 Lewis
 Li
 Reyes
(6 rows)

另请参阅

SOUNDEX

5.52 - SPACE

返回指定数量的空格，通常用于插入字符串。

行为类型

不可变

语法

SPACE(n)

参数

n: 整数实参，指定要插入的空格数量。

示例

以下示例连接字符串 x 和 y 并在二者之间插入 10 个空格：

=> SELECT 'x' || SPACE(10) || 'y' AS Ten_spaces;
  Ten_spaces
--------------
 x          y
(1 row)

5.53 - SPLIT_PART

使用分隔符拆分字符串，并返回指定字段开头位置的字符串（从 1 开始计数）。

行为类型

不可变

语法

SPLIT_PART ( string , delimiter , field )

参数

string: 实参字符串
delimiter: 分隔符
field: (INTEGER) 要返回的部分的编号

注意

将其用于子字段的字符形式。

示例

指定整数 2 返回第二个字符串或 def。

=> SELECT SPLIT_PART('abc~@~def~@~ghi', '~@~', 2);
 SPLIT_PART
------------
 def
(1 row)

在下一个示例中，指定 3，返回第三个字符串或 789。

=> SELECT SPLIT_PART('123~|~456~|~789', '~|~', 3);
 SPLIT_PART
------------
 789
(1 row)

波形符仅用于可读性。如果省略，则返回相同结果：

=> SELECT SPLIT_PART('123|456|789', '|', 3);
 SPLIT_PART
------------
 789
(1 row)

看看如果指定超出字符串数目的整数，会发生什么：结果不是 NULL，而是空字符串。

=> SELECT SPLIT_PART('123|456|789', '|', 4);
 SPLIT_PART
------------

(1 row)

=> SELECT SPLIT_PART('123|456|789', '|', 4) IS NULL;
 ?column?
----------
 f
(1 row)

如果 SPLIT_PART 返回 NULL，则 LENGTH 也应返回 0。

=> SELECT LENGTH (SPLIT_PART('123|456|789', '|', 4));
 LENGTH
--------
      0
(1 row)

如果数据库的区域设置为 BINARY，则 SPLIT_PART 调用 SPLIT_PARTB：

=> SHOW LOCALE;
  name  |               setting
--------+--------------------------------------
 locale | en_US@collation=binary (LEN_KBINARY)
(1 row)
=> SELECT SPLIT_PART('123456789', '5', 1);
 split_partb
-------------
 1234
(1 row)

=> SET LOCALE TO 'en_US@collation=standard';
INFO 2567:  Canonical locale: 'en_US@collation=standard'
Standard collation: 'LEN'
English (United States, collation=standard)
SET

=> SELECT SPLIT_PART('123456789', '5', 1);
 split_part
------------
 1234
(1 row)

另请参阅

SPLIT_PARTB

5.54 - SPLIT_PARTB

以分隔符字符分割输入字符串并返回第 N 个分段，从 1 开始计数。VARCHAR 实参视为八位字节，而不是 UTF-8 字符。

行为类型

不可变

语法

SPLIT_PARTB ( string, delimiter, part-number)

参数

string: VARCHAR，要拆分的字符串。
delimiter: VARCHAR，分段之间的分隔符。
part-number: INTEGER，要返回的部分编号。第一部分是 1，而不是 0。

示例

以下示例返回其输入的第三部分：

=> SELECT SPLIT_PARTB('straße~@~café~@~soupçon', '~@~', 3);
 SPLIT_PARTB
-------------
 soupçon
(1 row)

波形符仅用于可读性。如果省略，则返回相同结果：

=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 3);
 SPLIT_PARTB
-------------
  soupçon
(1 row)

如果请求的部分编号大于部分总数，则函数返回空字符串：

=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 4);
 SPLIT_PARTB
-------------

(1 row)

=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 4) IS NULL;
 ?column?
----------
 f
(1 row)

如果数据库的区域设置为 BINARY，则 SPLIT_PART 调用 SPLIT_PARTB：

=> SHOW LOCALE;
  name  |               setting
--------+--------------------------------------
 locale | en_US@collation=binary (LEN_KBINARY)
(1 row)
=> SELECT SPLIT_PART('123456789', '5', 1);
 split_partb
-------------
 1234
(1 row)

=> SET LOCALE TO 'en_US@collation=standard';
INFO 2567:  Canonical locale: 'en_US@collation=standard'
Standard collation: 'LEN'
English (United States, collation=standard)
SET

=> SELECT SPLIT_PART('123456789', '5', 1);
 split_part
------------
 1234
(1 row)

另请参阅

SPLIT_PART

5.55 - STRPOS

返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数）。如果未找到子字符串，则 STRPOS 返回 0。

STRPOS 类似于 POSITION；但 POSITION 允许按字符和八位字节查找。

行为类型

不可变

语法

STRPOS ( string‑expression , substring )

参数

string-expression: 要在其中定位子字符串的字符串
substring: 要在 string-expression 中定位的子字符串

示例

=> SELECT ship_type, shipping_key, strpos (ship_type, 'DAY') FROM shipping_dimension WHERE strpos > 0 ORDER BY ship_type, shipping_key;
           ship_type            | shipping_key | strpos
--------------------------------+--------------+--------
 NEXT DAY                       |            1 |      6
 NEXT DAY                       |           13 |      6
 NEXT DAY                       |           19 |      6
 NEXT DAY                       |           22 |      6
 NEXT DAY                       |           26 |      6
 NEXT DAY                       |           30 |      6
 NEXT DAY                       |           34 |      6
 NEXT DAY                       |           38 |      6
 NEXT DAY                       |           45 |      6
 NEXT DAY                       |           51 |      6
 NEXT DAY                       |           67 |      6
 NEXT DAY                       |           69 |      6
 NEXT DAY                       |           80 |      6
 NEXT DAY                       |           90 |      6
 NEXT DAY                       |           96 |      6
 NEXT DAY                       |           98 |      6
 TWO DAY                        |            9 |      5
 TWO DAY                        |           21 |      5
 TWO DAY                        |           28 |      5
 TWO DAY                        |           32 |      5
 TWO DAY                        |           40 |      5
 TWO DAY                        |           43 |      5
 TWO DAY                        |           49 |      5
 TWO DAY                        |           50 |      5
 TWO DAY                        |           52 |      5
 TWO DAY                        |           53 |      5
 TWO DAY                        |           61 |      5
 TWO DAY                        |           73 |      5
 TWO DAY                        |           81 |      5
 TWO DAY                        |           83 |      5
 TWO DAY                        |           84 |      5
 TWO DAY                        |           85 |      5
 TWO DAY                        |           94 |      5
 TWO DAY                        |          100 |      5
(34 rows)

5.56 - STRPOSB

返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数），其中字符串中的每个八位字节也被计算在内（与字符相反）。

行为类型

不可变

语法

STRPOSB ( string , substring )

参数

string: （CHAR 或 VARCHAR）是要从中查找子字符串的字符串
substring: （CHAR 或 VARCHAR）是要查找的子字符串

注意

除实参顺序以外，STRPOSB 与 POSITIONB 相同。

示例

=> SELECT STRPOSB('straße', 'e');
 STRPOSB
---------
       7
(1 row)


=> SELECT STRPOSB('étudiant', 'tud');
 STRPOSB
---------
       3
(1 row)

5.57 - SUBSTR

返回 VARCHAR 或 VARBINARY 值，表示指定字符串的子字符串。

行为类型

不可变

语法

SUBSTR ( string , position [ , extent ] )

参数

string: （CHAR/VARCHAR 或 BINARY/VARBINARY）是用于提取子字符串的字符串。如果为 NULL，则 Vertica 不返回任何结果。
position: （INTEGER 或 DOUBLE PRECISION）子字符串的开始位置（按字符从 1 计数）。如果为 0 或负数，则 Vertica 不返回任何结果。
extent: （INTEGER 或 DOUBLE PRECISION）是要提取的子字符串的长度（按字符数）。默认为字符串结束位置。

注意

SUBSTR 可以截断 DOUBLE PRECISION 输入值。

示例

=> SELECT SUBSTR('abc'::binary(3),1);
 substr
--------
 abc
(1 row)

=> SELECT SUBSTR('123456789', 3, 2);
 substr
--------
 34
(1 row)

=> SELECT SUBSTR('123456789', 3);
 substr
---------
 3456789
(1 row)

=> SELECT SUBSTR(TO_BITSTRING(HEX_TO_BINARY('0x10')), 2, 2);
 substr
--------
 00
(1 row)

=> SELECT SUBSTR(TO_HEX(10010), 2, 2);
 substr
--------
 71
(1 row)

5.58 - SUBSTRB

返回一个八位字节值，表示指定字符串的子字符串。

行为类型

不可变

语法

SUBSTRB ( string , position [ , extent ] )

参数

string: (CHAR/VARCHAR) 是用来提取子字符串的字符串。
position: （INTEGER 或 DOUBLE PRECISION）是子字符串的开始位置（八位字节从 1 计数）。
extent: （INTEGER 或 DOUBLE PRECISION）是要提取的子字符串长度（八位字节）。默认为字符串结束位置

注意

此函数将多字节字符形式字符串视为八位字节，并且使用八位字节数字作为传入和传出位置说明符与长度。字符串本身为 VARCHAR 类型，但视为每个八位字节都是单独字符。
SUBSTRB 可以截断 DOUBLE PRECISION 输入值。

示例

=> SELECT SUBSTRB('soupçon', 5);
 SUBSTRB
---------
 çon
(1 row)

=> SELECT SUBSTRB('soupçon', 5, 2);
 SUBSTRB
---------
 ç
(1 row)

如果使用 BINARY/VARBINARY，Vertica 返回以下错误消息：

=>SELECT SUBSTRB('abc'::binary(3),1);
ERROR: function substrb(binary, int) does not exist, or permission is denied for substrb(binary, int)
HINT: No function matches the given name and argument types. You may need to add explicit type casts.

5.59 - SUBSTRING

给定值、位置和可选长度的条件下，返回表示指定字符串在给定位置的子字符串的值。SUBSTRING 可以截断 DOUBLE PRECISION 输入值。

行为类型

如果使用 OCTETS，则为不可变，否则为稳定。

语法

SUBSTRING ( string, position[, length ]
    [USING {CHARACTERS | OCTETS } ] )

SUBSTRING ( string FROM position [ FOR length ]
    [USING { CHARACTERS | OCTETS } ] )

参数

string: （CHAR/VARCHAR 或 BINARY/VARBINARY）是用来提取子字符串的字符串
position: （INTEGER 或 DOUBLE PRECISION）是子字符串的开始位置（按字符或八位字节从 1 计数）。（默认值为字符。）如果位置大于给定值的长度，则返回空值。
length: （INTEGER 或 DOUBLE PRECISION）是要提取的字符或八位字节子字符串的长度。（默认值为字符。）默认为字符串的结束。如果给定长度，则结果最多是相等于长度的字节。最大长度就是给定值长度减给定位置。如果未给定长度或给定长度大于最大长度，则该长度设置为最大长度。
USING CHARACTERS | OCTETS: 决定值为字符（默认）还是八位字节形式。

示例

=> SELECT SUBSTRING('abc'::binary(3),1);
 substring
-----------
 abc
(1 row)

=> SELECT SUBSTRING('soupçon', 5, 2 USING CHARACTERS);
 substring
-----------
 ço
(1 row)

=> SELECT SUBSTRING('soupçon', 5, 2 USING OCTETS);
 substring
-----------
 ç
(1 row)

如果使用负数位置，则函数从不存在的位置开始。在此示例中，这表示从位置 -4 开始计数 8 个字符。因此，函数从空位置 -4 开始，并且计五个字符，包括同样为空的 0 位置。这将返回三个字符。

=> SELECT SUBSTRING('1234567890', -4, 8);
 substring
 -----------
 123
(1 row)

5.60 - TRANSLATE

将 string_to_replace 中的单个字符替换为其他字符。

行为类型

不可变

语法

TRANSLATE ( string_to_replace , from_string , to_string );

参数

string_to_replace: 要转换的字符串。
from_string: 包含 string_to_replace 中需要被替换的字符。
to_string: 若 string_to_replace 中任何字符与 from_string 中的字符匹配，则将前者替换为 to_string 中的相应字符。

示例

=> SELECT TRANSLATE('straße', 'ß', 'ss');
 TRANSLATE
-----------
 strase
(1 row)

5.61 - TRIM

将 BTRIM、LTRIM 和 RTRIM 函数合并为单个函数。

行为类型

不可变

语法

TRIM ( [ [ LEADING | TRAILING | BOTH ] characters FROM ] expression )

参数

LEADING: 从字符串左侧移除指定字符
TRAILING: 从字符串右侧移除指定字符
BOTH: 从字符串两侧移除指定字符（默认）
characters: （CHAR 或 VARCHAR）指定要从 expression 中移除的字符。默认值是空格字符。
expression: （CHAR 或 VARCHAR）是要修剪的字符串

示例

=> SELECT '-' || TRIM(LEADING 'x' FROM 'xxdatabasexx') || '-';
   ?column?
--------------
 -databasexx-
(1 row)

=> SELECT '-' || TRIM(TRAILING 'x' FROM 'xxdatabasexx') || '-';
   ?column?
--------------
 -xxdatabase-
(1 row)

=> SELECT '-' || TRIM(BOTH 'x' FROM 'xxdatabasexx') || '-';
  ?column?
------------
 -database-
(1 row)

=> SELECT '-' || TRIM('x' FROM 'xxdatabasexx') || '-';
  ?column?
------------
 -database-
(1 row)

=> SELECT '-' || TRIM(LEADING FROM '  database  ') || '-';
   ?column?
--------------
 -database  -
(1 row)

=> SELECT '-' || TRIM('  database  ') || '-';  ?column?
------------
 -database-
(1 row)

另请参阅

5.62 - UPPER

返回 VARCHAR 值，其中包含被转换为大写字母的实参。

自 5.1 版本开始，此函数将 string 实参视为 UTF-8 编码字符串，而不是根据区域设置的排序规则设置（例如 collation=binary）来识别编码。

行为类型

stable

语法

UPPER ( expression )

参数

expression: CHAR 或 VARCHAR 包含要转换的字符串

注意

UPPER 限定为 32500 个八位字节输入，因为以 UTF-8 表示的结果大小可能会翻倍。

示例

=> SELECT UPPER('AbCdEfG');
  UPPER
----------
 ABCDEFG
(1 row)
=> SELECT UPPER('étudiant');
  UPPER
----------
 ÉTUDIANT
(1 row)

5.63 - UPPERB

返回一个字符串，其中所有 ASCII 字符都转换为大写。多字节字符不会转换，而是跳过。

行为类型

不可变

语法

UPPERB ( expression )

参数

expression: （CHAR 或 VARCHAR）是要转换的字符串

示例

在下例中，多字节 UTF-8 字符 é 未转换为大写：

=> SELECT UPPERB('étudiant');
  UPPERB
----------
 éTUDIANT
(1 row)

=> SELECT UPPERB('AbCdEfG');
 UPPERB
---------
 ABCDEFG
(1 row)

=> SELECT UPPERB('The Vertica Database');
        UPPERB
----------------------
 THE VERTICA DATABASE
(1 row)

6 - URI 函数

此部分的函数遵循 RFC 3986 标准，用于对统一资源标识符 (URI) 进行百分比编码。

6.1 - URI_PERCENT_DECODE

根据 RFC 3986 标准，对百分比编码的通用资源标识符 (URI) 进行解码。

语法

URI_PERCENT_DECODE (expression)

行为类型

不可变

参数

expression: (VARCHAR) 是要转换的字符串。

示例

以下示例在 URI 表的 Websites 列上调用 uri_percent_decode 并返回解码 URI：

=> SELECT URI_PERCENT_DECODE(Websites) from URI;
              URI_PERCENT_DECODE
-----------------------------------------------
 http://www.faqs.org/rfcs/rfc3986.html x xj%a%
(1 row)

以下示例返回“网站 (Websites)”列中的原始 URI 及其解码版本：

=> SELECT Websites, URI_PERCENT_DECODE (Websites) from URI;

                     Websites                      |              URI_PERCENT_DECODE
---------------------------------------------------+---------------------------------------------
 http://www.faqs.org/rfcs/rfc3986.html+x%20x%6a%a% | http://www.faqs.org/rfcs/rfc3986.html x xj%a%

(1 row)

6.2 - URI_PERCENT_ENCODE

根据百分比编码的 RFC 3986 标准，对通用资源标识符 (URI) 进行编码。为与旧版编码器兼容，此函数将 + 转换为空格；将空格转换为 %20。

语法

URI_PERCENT_ENCODE (expression)

行为类型

不可变

参数

expression: (VARCHAR) 是要转换的字符串。

示例

以下示例显示了如何在 URI 表的“网站 (Websites)”列上调用 uri_percent_encode 函数并返回编码 URI：

=> SELECT URI_PERCENT_ENCODE(Websites) from URI;
            URI_PERCENT_ENCODE
------------------------------------------
 http%3A%2F%2Fexample.com%2F%3F%3D11%2F15
(1 row)

以下示例返回“网站 (Websites)”列中的原始 URI 及其编码形式：

=> SELECT Websites, URI_PERCENT_ENCODE(Websites) from URI;          Websites          |            URI_PERCENT_ENCODE
----------------------------+------------------------------------------
 http://example.com/?=11/15 | http%3A%2F%2Fexample.com%2F%3F%3D11%2F15
(1 row)

7 - UUID 函数

目前，Vertica 提供了一个函数来支持 UUID 数据类型 UUID_GENERATE。

7.1 - UUID_GENERATE

返回新的通用唯一标识符 (UUID)，该标识符基于 /dev/urandom 的高质量随机功能生成。

行为类型

易变

语法

UUID_GENERATE()

示例

=> CREATE TABLE Customers(
     cust_id UUID DEFAULT UUID_GENERATE(),
   lname VARCHAR(36),
   fname VARCHAR(24));
CREATE TABLE
=> INSERT INTO Customers VALUES (DEFAULT, 'Kearney', 'Thomas');
 OUTPUT
--------
      1
(1 row)

=> COPY Customers (lname, fname) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Pham|Duc
>> Garcia|Mary
>> \.
=> SELECT * FROM Customers;
               cust_id                |  lname  | fname
--------------------------------------+---------+--------
 03fe0794-ac5d-42d4-8246-54f7ec81ed0c | Pham    | Duc
 6950313d-c77e-4c11-a86e-0a54aa3ec114 | Kearney | Thomas
 9c9653ce-c2e4-4441-b0f7-0137b54cc28c | Garcia  | Mary
(3 rows)