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

返回本页常规视图.

字符串函数

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

此部分描述了用于检查和处理字符串值的函数和运算符。在此文中的字符串包括 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）进行操作的其他函数，请参阅 正则表达式函数。

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)

2 - BIT_LENGTH

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

行为类型

不可变

语法

BIT_LENGTH ( expression )

参数

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

示例

表达式
结果
SELECT BIT_LENGTH('abc'::varbinary);
24
SELECT BIT_LENGTH('abc'::binary);
8
SELECT BIT_LENGTH(''::varbinary);
0
SELECT BIT_LENGTH(''::binary);
8
SELECT BIT_LENGTH(null::varbinary);
SELECT BIT_LENGTH(null::binary);
SELECT BIT_LENGTH(VARCHAR 'abc');
24
SELECT BIT_LENGTH(CHAR 'abc');
24
SELECT BIT_LENGTH(CHAR(6) 'abc');
48
SELECT BIT_LENGTH(VARCHAR(6) 'abc');
24
SELECT BIT_LENGTH(BINARY(6) 'abc');
48
SELECT BIT_LENGTH(BINARY 'abc');
24
SELECT BIT_LENGTH(VARBINARY 'abc');
24
SELECT BIT_LENGTH(VARBINARY(6) 'abc');
24

另请参阅

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)

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 - BTRIM

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

行为类型

不可变

语法

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

参数

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

示例

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

另请参阅

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)

另请参阅

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)

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ß

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)

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)

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 需要不少于三项更改：

  1. kitten → knitten （在 k 之后插入 n）

  2. knitten → knittin （用 i 替换 e）

  3. knittin → knitting （附加 g）

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

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

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"

另请参阅

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"

另请参阅

16 - INITCAP

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

行为类型

不可变

语法

INITCAP ( expression )

参数

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

注意

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

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

示例

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);

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)

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)

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

第一个例子中， 函数从字符串最后一个字符 ‘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)

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)

另请参阅

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)

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

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

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

25 - LENGTH

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

  • CHAR 和 VARCHAR：与 CHARACTER_LENGTH 相同，返回以 UTF-8 字符数表示的字符串长度，

  • CHAR：去掉填充值。

  • BINARY 和 VARBINARY：与 OCTET_LENGTH 相同，返回以字节（八位字节）数表示的字符串长度。

行为类型

不可变

语法

LENGTH ( expression )

参数

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

示例

另请参阅

BIT_LENGTH

26 - LOWER

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

行为类型

stable

语法

LOWER ( expression )

参数

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

示例

=> 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)

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)

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)

29 - LTRIM

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

行为类型

不可变

语法

LTRIM ( expression [ , characters ] )

参数

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

示例

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

另请参阅

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;

31 - MD5

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

行为类型

不可变

语法

MD5 ( string )

参数

string
是实参字符串。

示例

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

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

另请参阅

32 - OCTET_LENGTH

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

行为类型

不可变

语法

OCTET_LENGTH ( expression )

参数

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

注意

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

  • 如果 expression 的数据类型是 BINARY，结果与 expression 的固定长度相同。

  • 如果 expression 的值为 NULL，则结果为 NULL。

示例

另请参阅

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 使用字符（默认）还是八位字节。

示例

=> 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)

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)

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)

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)

37 - QUOTE_IDENT

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

  • 1time

  • Next week

  • SELECT

嵌入的双引号将会加倍。

行为类型

不可变

语法

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)

另请参阅

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)

另请参阅

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)

另请参阅

字符字符串字面量

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)

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)

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

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)

44 - RTRIM

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

行为类型

不可变

语法

RTRIM ( expression [ , characters ] )

参数

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

示例

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

另请参阅

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)

另请参阅

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)

另请参阅

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)

另请参阅

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)

另请参阅

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)

另请参阅

50 - SOUNDEX

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

行为类型

不可变

语法

SOUNDEX ( string-expression )

参数

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

Soundex 编码算法

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

  1. 保存第一个字母。将所有出现的 a、e、i、o、u、y、h、w 映射到零 (0)。

  2. 使用数字替换所有辅音字母（包括第一个字母）：

    • b、f、p、v → 1

    • c、g、j、k、q、s、x、z → 2

    • d、t → 3

    • l → 4

    • m、n → 5

    • r → 6

  3. 使用一位数字替换所有相邻的相同数字，然后移除所有零 (0) 数字

  4. 如果保存的字母的数字与生成的第一个数字相同，则移除数字（保留字母）。

  5. 如果结果包含的数字少于 3 个，则附加 3 个零。移除除第一个字母及其后面 3 个数字以外的所有内容。

示例

在 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

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

52 - SPACE

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

行为类型

不可变

语法

SPACE(n)

参数

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

示例

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

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

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)

另请参阅

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)

另请参阅

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)

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)

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)

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.

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)

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)

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)

另请参阅

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)

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)