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

返回本页常规视图.

SQL 参考

Vertica 提供了一组可靠的 SQL 元素，可供您快速、可靠地管理和分析海量数据，其中包括：

  • 语言元素，例如关键字、运算符、表达式、谓词和提示

  • 数据类型，包括复杂类型

  • 函数，包括利用 Vertica 独特的列存储架构优势的 Vertica 专用函数

  • SQL 语句，可用来编写强大的查询，从而快速返回大量数据

1 - 系统限制

此部分描述了 Vertica 数据库中对象的大小和数量的系统限制。在大多数情况下，限制因素为计算机内存和磁盘驱动器。

2 - 语言元素

以下主题详细描述了 Vertica SQL 的语言元素和约定。

2.1 - 关键字

关键字指的是 SQL 语言中具有特别含义的字。每个 SQL 语句都包含一个或多个关键字。SQL 对关键字不区分大小写，但是通常情况下以大写字母形式出现，以保证其可读性。

保留字和关键字

许多关键字同时也是保留字。

Vertica 建议您不要使用保留字作为对象名称或标识符。包含保留字可能会导致 SQL 语句发生混淆。用作对象名称或标识符的保留字必须用双引号括住。

非保留关键字

非保留关键字在某些情况下具有特殊含义，但是在其他情况下可以用作标识符。可以将费保留关键字做为别名使用 — 例如，SOURCE：

=> SELECT my_node AS SOURCE FROM nodes;

查看保留关键字和非保留关键字列表

要查看 Vertica 保留字和非保留字的当前列表，请查询系统表 KEYWORDS。Vertica 按字母顺序列出了所有的关键字，并标注其为保留 (R)或非保留 (N)。

例如，以下查询获取所有以 B 开头的保留关键字：

=> SELECT * FROM keywords WHERE reserved = 'R' AND keyword ilike 'B%';
 keyword | reserved
---------+----------
 BETWEEN | R
 BIGINT  | R
 BINARY  | R
 BIT     | R
 BOOLEAN | R
 BOTH    | R
(6 rows)

2.2 - 标识符

架构、表、投影、列名称等对象的标识符（名称），长度最多可以为 128 个字节。

无引号的标识符

无引号的 SQL 标识符必须用以下值开头：

  • 非 Unicode 字母：A–Z 或 a-z

  • 下划线 (_)

标识符中的后续字符可以是以下任意组合：

  • 非 Unicode 字母：A–Z 或 a-z

  • 下划线 (_)

  • 数位 (0–9)

  • Unicode 字母（字母具有发音或不属于拉丁字母表），模型名称不支持

  • 美元符号 ($)，型号名称不支持

带引号的标识符

用双引号 (") 字符括住的标识符可以包含任何字符。如果要包括双引号，需要成对使用；例如 """"。您可以使用可能无效的名称，例如仅包含数字字符 ("123") 或仅包含空格字符、标点符号、SQL 或 Vertica 预留关键字。例如：

CREATE SEQUENCE "my sequence!";

对于字母数字和 SQL 关键字，例如 “1time”、“Next week”和“Select”，需要双引号。

区分大小写

标识符不区分大小写。因此，标识符 "ABC"、"ABc" 和 "aBc" 是同义词，类似于 ABC、ABc 和 aBc.

非 ASCII 字符

Vertica 接受非 ASCII UTF-8 Unicode 字符作为表名称、列名称和其他标识符，并将忽略大写/小写区别的情况扩展到所有字母，其中包括拉丁语、斯拉夫语和希腊语。

例如，以下 CREATE TABLE 语句在表名中使用了 ß（德语 eszett）：

=> CREATE TABLE straße(x int, y int);
   CREATE TABLE

标识符按创建时的形态保存

SQL 标识符未转换为小写，例如表和列名称。它们按照创建时的形态保存，使用区分大小写比较来解析对它们的引用。例如，以下语句创建表 ALLCAPS。

=> CREATE TABLE ALLCAPS(c1 varchar(30));
=> INSERT INTO ALLCAPS values('upper case');

以下语句是同一个查询的变体：

=> SELECT * FROM ALLCAPS;
=> SELECT * FROM allcaps;
=> SELECT * FROM "allcaps";

三个查询都返回相同的结果：

     c1
------------
 upper case
(1 row)

请注意，如果尝试创建表 AllCaps，Vertica 会返回错误：

=> CREATE TABLE AllCaps(c1 varchar(30));
   ROLLBACK:  table "AllCaps" already exists

有关其他信息，请参阅 QUOTE_IDENT。

2.3 - 字面量

字面量指的是 SQL 中做为常数使用的数字或字符串。选择列表中包括字面量以及表达式和内置函数，也可做为常数存在。

Vertica 支持数字类型的文本（整数和数字）、字符串字面量、VARBINARY 字符串字面量和日期/时间字面量。本章将讨论不同的字符串字面量格式。

2.3.1 - 数字类型字面量

Vertica 支持三种类型的数字：整数、数字和浮点数。

  • Integers 是小于 2^63 的完整数，且必须是数字。

  • Numerics 是大于 2^63 或包含具有精度和标度的小数点的完整数。Numerics 可含有指数。以 0x 开头的数字是十六进制数。

Numeric-类型值也可通过使用来自字符串的投影生成。这是一个更普遍的语法。请参阅下文的例子，以及 数据类型强制运算符 (CAST)。

语法

digits 
digits.[digits] | [digits].digits
digits e[+-]digits | [digits].digits e[+-]digits | digits.[digits] e[+-]digits

参数

注意

  • 如果 e 存在，则至少有一个数字跟阶码标记符在 (e)之后。
  • 常数中不得嵌入任何空格或其他字符。

  • 前面的加号 (+) 或减号 (–) 标记不作为常数的一部分；它们是应用于常量的一元运算符。

  • 在大多数情况下，numeric-类型的常数根据上下文，自动强制转换为最合适的类型。如有必要，您可以根据 数据类型强制运算符 (CAST)所述，通过投影将 numeric 值强制转换为指定的数据类型。

  • 不支持浮点字面字面量如果您需要指定浮点数，可根据 数据类型强制运算符 (CAST)进行投影。

  • Vertica 遵循 IEEE 浮点规范，包括 NaN（非数字）和 Infinity (Inf)。

  • NaN 不大于同时也不小于任何值（甚至是本身）。换句话说，每当涉及到 NaN，比较始终返回 false。

  • 除法 INTEGERS (x / y) 生成 NUMERIC 结果。您可以使用 // 运算符将结果截断为完整数。

示例

下面是数字类型字面字面量的例子：

42
3.5
4.
.001
5e2
1.925e-3

科学记数法:

=> SELECT NUMERIC '1e10';
 ?column?
-------------
 10000000000
(1 row)

BINARY 缩放:

=> SELECT NUMERIC '1p10';
 ?column?
----------
     1024
(1 row)
=> SELECT FLOAT 'Infinity';
  ?column?
----------
 Infinity
(1 row)

下面的例子对使用 / 和 // 运算符除整数进行了说明：

=> SELECT 40/25;
 ?column?
----------------------
 1.600000000000000000
(1 row)

=> SELECT 40//25;
 ?column?
----------
        1
(1 row)

另请参阅

数据类型强制转换

2.3.2 - 字符串字面量

字符串字面量是使用单引号或双引号引用的字符串值。双引号字符串需使用反斜杠，单引号字符串则不要求使用反斜杠，但 \\' 和 \\\ 除外。

您可以将单引号和反斜杠嵌入单引号字符串。

如需包含其他反斜杠（转义）序列，例如 \t (Tab)，您必须使用双引号形式。

对于单引号字符串，在字符串和其前面的词语之间必须加入空格，因为单引号允许用于标识符。

另请参阅

2.3.2.1 - 字符字符串字面量

字符字符串字面量是由预定义字符集中的字符组成的序列，两边加上单引号。

语法

'character-seq'

参数

嵌入式单引号

如果字符字符串字面量包含单引号，则必须成对出现。例如：

=> SELECT 'Chester''s gorilla';
  ?column?
-------------------
Chester's gorilla
(1 row)

符合标准的字符串和转义字符

Vertica 按照 SQL 标准中指定的要求，使用符合标准的字符串，将反斜杠处理为字符串字面量，而不是处理为转义字符。

示例

=> SELECT 'This is a string';
  ?column?
------------------
 This is a string
(1 row)
=> SELECT 'This \is a string';
   WARNING:  nonstandard use of escape in a string literal at character 8
   HINT:  Use the escape string syntax for escapes, e.g., E'\r\n'.
     ?column?
------------------
 This is a string
(1 row)
vmartdb=> SELECT E'This \is a string';
     ?column?
------------------
 This is a string
=> SELECT E'This is a \n new line';
       ?column?
----------------------
 This is a
 new line
(1 row)
=> SELECT 'String''s characters';
      ?column?
--------------------
 String's characters
(1 row)

另请参阅

2.3.2.2 - 以美元为界的字符串字面量

以美元为界的字符串字面量很少使用，但为了方便起见，在此处提供了这种文本。

用来指定字符串字面量的标准语法可能很难理解。在这种情况下，为了提高查询的可读性，Vertica SQL 提供了美元界限。美元界限不是 SQL 标准的一部分，但它通常用来编写复杂的字符串字面量，比符合标准的单引号语法更方便。

语法

$$characters$$

参数

以美元为界的字符串内容被视为字面量。在以美元为界的字符串中，单引号、反斜杠和美元符号字符中没有特殊含义。

注意

关键字或标识符后面以美元为界的字符串必须与前面的单词用空格分隔；否则，美元界限分隔符将作为前面标识符的一部分。

示例

=> SELECT $$Fred's\n car$$;
     ?column?
-------------------
 Fred's\n car
(1 row)

=> SELECT 'SELECT 'fact';';
ERROR:  syntax error at or near "';'" at character 21
LINE 1: SELECT 'SELECT 'fact';';

=> SELECT 'SELECT $$fact';$$;
   ?column?
---------------
 SELECT $$fact
(1 row)

=> SELECT 'SELECT ''fact'';';
    ?column?
----------------
 SELECT 'fact';
(1 row)

2.3.2.3 - Unicode 字符串字面量

语法

U&'characters' [ UESCAPE '<Unicode escape character>' ]

参数

使用符合标准的字符串

启用 StandardConformingStrings 时，Vertica 支持 SQL 标准 Unicode 字符字符串字面量（字符集为仅 UTF-8）。

在输入 Unicode 字符字符串字面量之前，请通过以下方式之一启用符合标准的字符串。

另请参阅扩展的字符串字面量。

示例

要以十六进制输入 Unicode 字符（例如 'thank you' 的俄语短语），请使用以下语法：

=> SET STANDARD_CONFORMING_STRINGS TO ON;
=> SELECT U&'\0441\043F\0430\0441\0438\0431\043E' as 'thank you';
 thank you
-----------
 спасибо
(1 row)

要以十六进制输入德语单词 mude（其中 u 是变元音）：

=> SELECT U&'m\00fcde';
?column?
----------
müde
(1 row)
=> SELECT 'ü';
?column?
----------
ü
(1 row)

要以十六进制输入 LINEAR B IDEOGRAM B240 WHEELED CHARIOT：

=> SELECT E'\xF0\x90\x83\x8C';
?column?
----------
(wheeled chariot character)
(1 row)

另请参阅

2.3.2.4 - VARBINARY 字符串字面量

您可以通过 VARBINARY 字符串字面量在字符串字面量中指定十六进制数字或二进制数字。

语法

X''
B''

参数

示例

=> SELECT X'abcd';
 ?column?
----------
 \253\315
(1 row)


=> SELECT B'101100';
 ?column?
----------
 ,
(1 row)

2.3.2.5 - 扩展字符串字面量

语法

E'characters'

参数

您可以采用扩展字符串字面量的 C 样式反斜杠序列，这是结构化查询语言 (SQL) 标准的扩展。您可以通过将字母 E 作为前缀（在开放的单引号前）来指定一个扩展字符串字面量；例如：

E'extended character string\n'

在扩展字符串内，反斜杠字符 (\\) 启动 C 样式反斜杠序列，在该序列中反斜杠组合和后面的字符或数字代表一个特别的字节值，如下表所示：任何后接反斜杠的字符都按字面理解；例如，要包含一个反斜杠字符，就输入两个反斜杠 (\\\)。

  • \\\ 是一个反斜杠

  • \b 是一个退格符

  • \f 是一个换页符

  • \n 是一个换行符

  • \r 是一个回车符

  • \t 是一个制表符

  • \x##,其中 ## 是 1 位或 2 位十六进制数；例如 \x07 是一个制表符

  • \\###，其中 ### 是 1、2 或 3 位八进制数，表示带有相应代码的字节。

当扩展的字符串字面量衔接起来跨过线时，只在首个开放的引号前输入 E。

=> SELECT E'first part o'
    'f a long line';
         ?column?
---------------------------
 first part of a long line
(1 row)

将两个相邻的单引号作为一个单引号使用：

=> SELECT 'Aren''t string literals fun?';
          ?column?
-----------------------------
 Aren't string literals fun?
(1 row)

符合标准的字符串和转义字符

解释命令（例如，在 vsql 中输入的命令，或者在通过 JDBC 或 ODBC 传递的查询中输入的命令）时，Vertica 采用 SQL 标准中指定的符合标准的字符串。在符合标准的字符串中，反斜杠视作字符串字面量（普通字符），而非转义字符。

可以按照以下内容操作，但是 Vertica 建议您在发生警告后尽快使用符合标准的字符串移动您的应用程序。

  • 要将反斜杠视为转义字符，请将配置参数 StandardConformingStrings 设置为 0。

  • 要永久启用符合标准的字符串，请将 StandardConformingStrings 参数设置为 '1'，如下面所述。

  • 要使每一会话均为符合标准的字符串，采用设置符合标准的字符串为开启，此设置只有在当前会话将反斜杠视为转义字符。

识别不符合标准的字符串

以下程序可以用于识别您的应用程序中不符合标准的字符串，从而您可以将这些字符串转换为符合标准的字符串：

  1. 确保 StandardConformingStrings 参数处于关闭状态，如国际化参数中所述。

    => ALTER DATABASE DEFAULT SET StandardConformingStrings = 0;

  2. 如有必要，请打开 EscapeStringWarning 参数。

    => ALTER DATABASE DEFAULT SET EscapeStringWarning = 1;

    目前，Vertica 每次在字符串字面量中遇到一个转义字符串时都会返回一项警告。例如，Vertica 在下面的示例中将 \n 解释为换行符：

    => SELECT 'a\nb';
   WARNING:  nonstandard use of escape in a string literal at character 8
   HINT:  Use the escape string syntax for escapes, e.g., E'\r\n'.
 ?column?
----------
 a
b
(1 row)

    当 StandardConformingStrings 为 ON 时，该字符串解释为四个字符：a \ n b

    通过扩展由 Vertica 标记的每个字符来对其进行修改，如以下示例中所示：

    E'a\nb'

    或者如果该字符串已经引用了单引号，那么使用两个单引号，例如， 'one'' double'.

  3. 为全部会话开启 StandardConformingStrings 参数：

    => ALTER DATABASE DEFAULT SET StandardConformingStrings = 1;

两个单引号

这节内容讨论不传递给服务器的 vsql 输入值。 Vertica 将一个字符串字面量中两个连续的单引号视为一个单引号符。例如以下输入，'You''re here!' 忽略了第二个连续引号并返回以下内容：

=> SELECT 'You''re here!';
   ?column?
--------------
 You're here!at
(1 row)

这就是 SQL 标准表示法，且在表格中多见，'You\\'re here!'，因为反斜杠和之前的解析不同。您需要忽略掉反斜杠：

=> SELECT (E'You\'re here!');
   ?column?
--------------
 You're here!
(1 row)

此更改行为在使用 vsql meta-command \set 时引进一个潜在的不兼容性，这会自动将其命令行实参衔接起来。例如：

\set file  '\''  'pwd'  '/file.txt'  '\''\echo :file

vsql 接受这四个参数并输出以下内容：

'/home/vertica/file.txt'

Vertica 按如下方式解析相邻的单引号：

\set file  '\'''pwd''/file.txt''\''\echo :file
'/home/vertica/file.txt''

注意末尾额外的单引号。这是因为相邻的单引号与引用反斜杠的单引号进行了配对。

额外的引号可以被解析为上面的第一个案例或是将字面意义进行组合，如下：

\set file '\''`pwd`'/file.txt'''\echo :file
'/home/vertica/file.txt'

在这两种情况中，引用反斜杠的单引号应该改为两个单引号，如下：

\set file '''' `pwd` '/file.txt'''

其他示例

=> SELECT 'This \is a string';
     ?column?
------------------
 This \is a string
(1 row)


=> SELECT E'This \is a string';
     ?column?
------------------
 This is a string


=> SELECT E'This is a \n new line';
       ?column?
----------------------
 This is a
 new line
(1 row)


=> SELECT 'String''s characters';
      ?column?
--------------------
 String's characters
(1 row)

2.3.3 - 日期/时间字面量

输入的日期或时间字面量必须用单引号括起来。可接受几乎任何合理格式的输入，包括符合 ISO 8601 和 SQL 标准、传统的 POSTGRES 和其他格式。

Vertica 可以在 SQL 标准要求之上更灵活地处理日期/时间输入。日期/时间表达式 中说明了日期/时间输入和已识别文本字段（包括月份、星期和时区）的精确解析规则。

2.3.3.1 - 时区值

Vertica 尝试与时区的 SQL 标准定义兼容。但是，SQL 标准的日期和时间类型与功能组合较为怪异。存在以下明显问题：

  • 虽然 DATE 类型不含关联时区，但 TIME/TIMETZ 类型可以包含关联时区。除非与日期和时间相关联，否则时区在现实世界中几乎没有任何意义，因为偏移量在一年当中会随夏令时边界的变化而变化。

  • Vertica 假设本地时区适用于任何仅包含日期或时间的数据类型。

  • 默认时区指定为相对于 UTC 的偏移量常数。因此，在跨 DST 边界进行日期/时间算术时，不可能适应夏令时。

为了克服这些困难，Micro Focus 建议您在使用时区时使用包含日期和时间的日期/时间类型。Micro Focus 建议您不要使用类型 TIME WITH TIME ZONE,，即使它支持传统应用程序且符合 SQL 标准也不例外。

时区和时区约定不仅仅受地球几何形状的影响，还会受政治决策的影响。1900 年代，全球时区开始趋于标准化，但仍然会面临一些随机变化，特别是夏令时规则方面。

Vertica 目前支持从 1902 年到 2038 年这个时间段确立的夏令时规则，对应于完整传统 UNIX 系统时间。一旦时间超出该范围，则视为所选时区的“标准时间”，无论该时间处于一年当中的哪个时段。 

2.3.3.2 - 星期几的名称

系统将以下标记识别为星期几的名称：

2.3.3.3 - 月份名称

系统将以下标记识别月份名称：

2.3.3.4 - 间隔字面量

表示时间跨度的字面量。

语法

[ @ ] [-] { quantity subtype-unit }[...] [ AGO ]

参数

注意

  • 不同的单位数量会自动叠加。

  • 间隔常量的上下限分别为：

    • 9223372036854775807 usec 到 ‑9223372036854775807 usec

    • 296533 years 3 mons 21 days 04:00:54.775807 到 ‑296533 years ‑3 mons ‑21 days ‑04:00:54.775807

  • 间隔常量的范围是 +/– 263 – 1 微秒。

  • 在 Vertica 中，间隔字段可以增加，允许大浮点数。

示例

请参阅指定间隔输入。

2.3.3.4.1 - 间隔子类型单位

下表列出了可在间隔字面量中指定的子类型单位，分为以下几个主要类别：

年-月子类型单位

天-时间子类型单位

处理 m 输入

Vertica 根据上下文将输入单位 m 解释为月份或分钟。例如，以下命令可创建包含间隔值的单列表：

=> CREATE TABLE int_test(i INTERVAL YEAR TO MONTH);

在以下 INSERT 语句中，Vertica 将间隔字面量 1y 6m 解释为 1 年 6 个月：

=> INSERT INTO int_test VALUES('1y 6m');
 OUTPUT
--------
      1
(1 row)
=> COMMIT;
COMMIT
=> SET INTERVALSTYLE TO UNITS;
SET
=> SELECT * FROM int_test;
        i
-----------------
 1 year 6 months
(1 row)

以下 ALTER TABLE 语句可将 DAY TO MINUTE 间隔列添加到表 int_test 中：

=>  ALTER TABLE int_test ADD COLUMN x INTERVAL DAY TO MINUTE;
ALTER TABLE

下一个 INSERT 语句将第一列和第二列分别设置为 3y 20m 和 1y 6m。在这种情况下，Vertica 通过以下两种方式解释 m 输入字面量：

  • 对于第 i 列，Vertica 将 m 输入解释为月份，显示 4 年 8 个月。

  • 对于第 x 列，Vertica 将 m 输入解释为分钟。由于间隔定义为 DAY TO MINUTE，因此将插入的输入值 1y 6m 转换为 365 天 6 分钟：

=> INSERT INTO int_test VALUES ('3y 20m', '1y 6m');
 OUTPUT
--------
      1
(1 row)

=> SELECT * FROM int_test;
        i         |        x
------------------+-----------------
 1 year 6 months  |
 4 years 8 months | 365 days 6 mins
(2 rows)

2.3.3.4.2 - 间隔限定符

指定如何解释输出的间隔字面量并为其设置格式，同时可选择性设置精度。间隔限定符由一或两个单元组成：

unit [ TO unit ] [ (p) ]

其中：

  • 单位指定天-时间或年-月子类型。

  • p 指定精度，0 到 6 之间的整数。

如果间隔省略了间隔限定符，则默认值为 DAY TO SECOND(6)。

间隔限定符分为以下两个类别：

天-时间间隔限定符

年-月间隔限定符

示例

请参阅控制间隔格式。

2.4 - 运算符

运算符是指为求值、比较或计算值而在 SQL 中使用的逻辑、数学和等式符号。

2.4.1 - 位运算符

位运算符对 INTEGER 和 BINARY/VARBINARY 数据类型执行位操作：

†对 BINARY/VARBINARY 数据类型无效

字符串实参处理

对于所有位运算符，必须将字符串实参显式转换为 BINARY 或 VARBINARY 数据类型。例如：

=> SELECT 'xyz'::VARBINARY & 'zyx'::VARBINARY AS AND;
 AND
-----
 xyx
(1 row)

=> SELECT 'xyz'::VARBINARY | 'zyx'::VARBINARY AS OR;
 OR
-----
 zyz
(1 row)

位运算符将所有字符串实参视为长度相同。如果实参长度不同，则运算符函数会使用一个或多个零字节右侧填充较小的字符串，使其长度与较大的字符串相同。

例如，以下语句 AND 长度不同的字符串 xyz 和 zy。Vertica 使用一个零字节右侧填充字符串 zy。相应地，结果中的最后一个字符表示为 \000：

=> SELECT 'xyz'::VARBINARY & 'zy'::VARBINARY AS AND;
  AND
--------
 xy\000
(1 row)

2.4.2 - 布尔运算符

Vertica 支持以下布尔运算符：

  • AND

  • OR

  • NOT

运算符 AND 和 OR 可交换，也就是说，可以在不影响结果的情况下切换左右操作数。但是，未定义子表达式的求值顺序。要强制执行求值顺序，请使用 CASE 构造。

逻辑

SQL 使用三值布尔逻辑，其中 NULL 表示“未知”。

2.4.3 - 比较运算符

只要比较有意义，比较运算符可适用于所有数据类型。所有比较运算符均为二元运算符，可返回 true、false 或 NULL 这些值。

NULL 处理

如果一个或两个操作数为 NULL，则比较运算符返回 NULL。存在一个例外： <=> 如果两个操作数都为 NULL，则返回 true；如果一个操作数为 NULL，则返回 false。

集合

当对集合进行比较时，NULL 集合排在最后。否则，逐个元素比较集合，直到出现不匹配，然后根据不匹配的元素对它们进行排序。如果所有元素的长度都依次等于较短的元素的长度，则首先排序较短的元素。

2.4.4 - 数据类型强制运算符 (CAST)

数据类型强制转换（转换）将表达式的值传递给输入转换例程以转换为指定的数据类型，得到指定类型的常数。在 Vertica 中，可以通过使用以下结构之一的显式转换请求来调用数据类型强制功能：

语法

SELECT CAST ( expression AS data‑type )

SELECT expression::data‑type

SELECT data‑type 'string'

参数

截断

如果将二进位值转换（隐式或显式）为较小长度的二进位类型，该值将被自动截断。例如：

=> SELECT 'abcd'::BINARY(2);
 ?column?
----------
 ab
(1 row)

类似地，如果将字符值转换（隐式或显式）为较小长度的字符值，该值将被自动截断。例如：

=> SELECT 'abcd'::CHAR(3);
 ?column?
----------
 abc
(1 row)

二进制转换和调整大小

Vertica 仅支持以下转换和调整大小操作：

  • 从 BINARY 转换到和转换自 VARBINARY

  • 从 VARBINARY 转换到和转换自 LONG VARBINARY

  • 从 BINARY 转换到和转换自 LONG VARBINARY

对于包含少于目标列字节的值的二进位数据，零字节 '\0' 的值向右扩展为整个列宽。可变长度的二进位值的尾随零不能向右扩展：

=> SELECT 'ab'::BINARY(4), 'ab'::VARBINARY(4), 'ab'::LONG VARBINARY(4);
  ?column?  | ?column? | ?column?
------------+----------+----------
 ab\000\000 | ab       | ab
(1 row)

自动强制

如果常数类型明确，可以忽略显式类型转换。例如，直接分配常数到一列中，该常数会自动强制转换为该列的数据类型。

示例

=> SELECT CAST((2 + 2) AS VARCHAR);
 ?column?
----------
 4
(1 row)

=> SELECT (2 + 2)::VARCHAR;
 ?column?
----------
 4
(1 row)

=> SELECT INTEGER '123';
 ?column?
----------
      123
(1 row)

=> SELECT (2 + 2)::LONG VARCHAR
 ?column?
----------
 4
(1 row)

=> SELECT '2.2' + 2;
   ERROR:  invalid input syntax for integer: "2.2"

=> SELECT FLOAT '2.2' + 2;
 ?column?
----------
      4.2
(1 row)

另请参阅

2.4.4.1 - 转换失败

当您通过显式转换调用数据类型转换（转换），但该转换失败时，结果将返回错误或 NULL。当您尝试进行冲突的转换时，如尝试将包含字母的 VARCHAR 表达式转换为整数，通常就会发生转换失败。

当转换失败时，返回的结果取决于数据类型。

启用严格的时间转换

您可以使所有转换失败产生错误，包括针对日期/时间数据类型的转换。这样做将使您能查看某些或所有转换失败的原因。要返回错误而不是 NULL，请将配置参数 EnableStrictTimeCasts 设置为 1：

ALTER SESSION SET EnableStrictTimeCasts=1;

默认情况下，EnableStrictTimeCasts 设置为 0。因此，以下尝试将 VARCHAR 转换为 TIME 数据类型的行为返回 NULL：


==> SELECT current_value from configuration_parameters WHERE parameter_name ilike '%EnableStrictTimeCasts%';
 current_value
---------------
 0
(1 row)

=> CREATE TABLE mytable (a VARCHAR);
CREATE TABLE
=> INSERT INTO mytable VALUES('one');
OUTPUT
--------
1
(1 row)

=> INSERT INTO mytable VALUES('1');
OUTPUT
--------
1
(1 row)

=> COMMIT;
COMMIT
=> SELECT a::time FROM mytable;
 a
---


(2 rows)

如果启用 EnableStrictTimeCasts，则转换失败返回错误：


=> ALTER SESSION SET EnableStrictTimeCasts=1;
ALTER SESSION
=> SELECT a::time FROM mytable;
ERROR 3679:  Invalid input syntax for time: "1"

使所有转换失败返回 NULL

要将某一表达式显式转换为请求的数据类型，请使用以下结构：

SELECT expression::data-type

使用此命令将任何值转换为冲突的数据类型，将返回以下错误：

=> SELECT 'one'::time;
ERROR 3679:  Invalid input syntax for time: "one"

Vertica 也支持使用强制转换运算符 ::!，当希望返回以下结果时很有用：

  • 对于非日期/时间数据类型，返回 NULL 而不是错误

  • 在设置 EnableStrictTimeCasts 后，返回 NULL 而不是错误

使所有转换失败返回 NULL 可使在转换期间成功的表达式显示在结果中。但在转换期间失败的表达式将产生 NULL 值。

以下示例使用强制转换运算符 ::! 查询 mytable。查询返回 NULL，其中列 a 包含字符串 one；返回 1，其中列包含 1。无论如何设置 EnableStrictTimeCasts，查询结果都相同：

=> SELECT current_value FROM configuration_parameters WHERE parameter_name ilike '%EnableStrictTimeCasts%';
 current_value
---------------
 0
(1 row)

=> SELECT a::!int FROM mytable;
a
---

1
(2 rows)

ALTER SESSION SET EnableStrictTimeCasts=1;
ALTER SESSION
=> SELECT a::!int FROM mytable;
 a
---

 1
(2 rows)

您可以使用 ::! 转换数组和集合。转换单独解析每个元素，为无法转换的元素生成 NULL。

2.4.5 - 日期/时间运算符

语法

[ + | – | * | / ]

参数

+  Addition
–  Subtraction
*  Multiplication
/  Division

注意

  • 下文描述的 TIME 或 TIMESTAMP 输入运算符其实有两种变体：一种是 TIME WITH TIME ZONE 或 TIMESTAMP WITH TIME ZONE；另一种是 TIME WITHOUT TIME ZONE 或 TIMESTAMP WITHOUT TIME ZONE。简洁起见，这些变体不单独显示。

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

2.4.6 - 数学运算符

为很多数据类型提供数学运算符。

阶乘运算符支持

Vertica 支持对正负浮点 (DOUBLE PRECISION) 数和整数使用阶乘运算符。例如：

=> SELECT 4.98!;
   ?column?
------------------
 115.978600750905
(1 row)

阶乘在 gamma 函数的术语中定义，其中 (-1) = 无限，其他负整数未定义。例如：

(–4)! = NaN
–(4!) = –24

对于所有复数 z，阶乘定义如下：

z! = gamma(z+1)

有关详细信息，请参阅 Abramowitz 和 Stegun：数学函数手册。

2.4.7 - NULL 运算符

要检查某个值是否为 NULL，请使用以下构造：

[expression IS NULL | expression IS NOT NULL]

或者，使用等效（但非标准）构造：

[expression ISNULL | expression NOTNULL]

不要写入 expression = NULL，因为 NULL 表示未知值，两个未知值不一定相等。此行为遵守 SQL 标准。

2.4.8 - 字符串串联运算符

要串联同一行的两个字符串，请使用串联运算符（两条连续的竖线）。

语法

string || string

参数

注意

  • || 用于串联表达式和常量.表达式应尽可能投射至 VARCHAR ，否则就投射至 VARBINARY，而且必须投射至其中一个。

  • 单个 SQL 语句中的两个连续字符串在不同行会自动串联

示例

以下示例是位于两行的单个字符串：

=> SELECT E'xx'-> '\\';
 ?column?
----------
 xx\
(1 row)

以下示例显示两个串联的字符串：

=> SELECT E'xx' ||-> '\\';
 ?column?
----------
 xx\\
(1 row)

=> SELECT 'auto' || 'mobile';
 ?column?
----------
 automobile
(1 row)


=> SELECT 'auto'-> 'mobile';
 ?column?
----------
 automobile
(1 row)


=> SELECT 1 || 2;
 ?column?
----------
 12
(1 row)


=> SELECT '1' || '2';
 ?column?
----------
 12
(1 row)

=> SELECT '1'-> '2';
 ?column?
----------
 12
(1 row)

2.5 - 表达式

SQL 表达式是将某个值或多个值与其他值进行比较的查询的组件。它们还可以执行计算。在任何 SQL 命令中发现的表达式通常采用条件语句的形式。

运算符优先级

下表按递减（由高到低）顺序显示运算符优先级。

表达式求值规则

未定义子表达式的求值顺序。特别是，不必由左到右或以任何其他固定顺序对运算符或函数输入进行求值。要强制按特定顺序进行求值，请使用 CASE 构造。例如，这是一种在 WHERE 子句中尝试避免除数为零的不受信任方式：

=> SELECT x, y WHERE x <> 0 AND y/x > 1.5;

但这种方式比较安全：

=> SELECT x, y
   WHERE
     CASE
       WHEN x <> 0 THEN y/x > 1.5
       ELSE false
     END;

此方式中使用的 CASE 构造会导致优化尝试失败，因此仅在必要时使用。（在这个特定示例中，最好改为写入 y > 1.5*x 以避免相关问题。）

SQL 表达式的限制

对于您可在表达式中使用的修饰符和递归的数量，存在一些限制。您应该注意以下两项限制：

  • 第一项限制基于可供表达式使用的堆栈。Vertica 需要至少 100kb 的可用堆栈。如果超出此限制，则可能引发错误“查询包含的表达式过于复杂而无法分析 (The query contains an expression that is too complex to analyze)”。额外增加物理内存和/或增大 ulimit -s max 值可增加可用堆栈并防止错误。

  • 第二项限制为分析表达式中可能的递归数。上限为 2000。如果超出此限制，则可能引发错误“查询包含的表达式过于复杂而无法分析 (The query contains an expression that is too complex to analyze)”。此限制无法提高。

2.5.1 - 聚合表达式

聚合表达式在查询选定的各个行或行组中应用聚合函数。

聚合表达式只能出现在选择列表中或 HAVING 语句的 SELECT 子句中。它在其他子句（如 WHERE）中无效，因为这些子句是在聚合结果形成之前进行评估的。

语法

聚合表达式的格式如下：

aggregate‑function ( [ * ] [ ALL | DISTINCT ] expression )

参数

示例

AVG 聚合函数返回 customer_dimension 表中的平均收入：

=> SELECT AVG(annual_income) FROM customer_dimension;
 AVG
--------------
 2104270.6485
(1 row)

以下示例显示了如何使用具有 DISTINCT 关键字的 COUNT 聚合函数返回对所有 inventory_fact 记录计算表达式 x+y 得到的所有不同值。

=> SELECT COUNT (DISTINCT date_key + product_key) FROM inventory_fact;
COUNT
-------
21560
(1 row)

2.5.2 - CASE 表达式

CASE 表达式是一个通用条件表达式，可在表达式有效的情况下使用。它与其他语言的 CASE 和 IF/THEN/ELSE 语句相似。

语法（第一种形式）

CASE
  WHEN condition THEN result
  [ WHEN condition THEN result ]
  ...
  [ ELSE result ]
END

参数

语法（第二种形式）

CASE expression
 WHEN value THEN result
 [ WHEN value THEN result ]
 ...
 [ ELSE result ]
END

参数

注意

所有 result 表达式的数据类型必须可转换为一个输出类型。

示例

以下示例显示了 CASE 语句的两种使用方法。

=> SELECT * FROM test;
 a
---
 1
 2
 3

=> SELECT a,
     CASE WHEN a=1 THEN 'one'
          WHEN a=2 THEN 'two'
          ELSE 'other'
     END
   FROM test;
 a | case
---+-------
 1 | one
 2 | two
 3 | other

=> SELECT a,
     CASE a WHEN 1 THEN 'one'
            WHEN 2 THEN 'two'
            ELSE 'other'
     END
   FROM test;
 a | case
---+-------
 1 | one
 2 | two
 3 | other

特殊示例

CASE 表达式不会对无需确定结果的子表达式求值。您可以使用此行为来避免被零除错误：

=> SELECT x FROM T1 WHERE
      CASE WHEN x <> 0 THEN y/x > 1.5
      ELSE false
    END;

2.5.3 - 列引用

语法

[[[database.]schema.]table-name.]column-name

参数

限制

列引用不能包含任何空格。

2.5.4 - 注释

注释为任意字符序列，以两个连续的连字符开头并延伸到行的结尾。例如：

   -- This is a standard SQL comment

先从输入流中移除注释再执行进一步的语法分析，并有效替换为空格。

或者，也可以使用 C 样式块注释，其中注释以 /* 开头并延伸到匹配出现的 */。

   /* multiline comment
    * with nesting: /* nested block comment */
    */

这些块注释根据 SQL 标准中指定的方法嵌套。与 C 不同，您可以注释掉可能包含现有块注释的较大代码块。

2.5.5 - 日期/时间表达式

Vertica 将内部启发式解析器用于全部日期/时间输入支持。日期和时间以字符串输入，通过初步确定字段中可能存在的信息种类，拆分为不同字段。每个字段均被解释并分配数值，或者被忽略或拒绝。解析器包含所有文本字段的内部查询表，包括月份、星期和时区。

Vertica 解析日期/时间类型输入内容如下：

  1. 将输入字符串拆分为标记，并将每个标记分类为字符串、时间、时区或数字。

  2. 数字标记包含：

    • 冒号 (:)- 解析为时间字符串，包括所有后续数字和冒号。

    • 破折号 (-)、斜杠 (/) 或者两个或更多的点 (.)- 解析为日期字符串，可能包含文本月份。

    • 仅数字 - 解析为单一字段或 ISO 8601 串联日期（19990113 表示 1999 年 1 月 13 日）或时间（141516 表示 14:15:16）。

  3. 以加号 (+) 或减号 (–) 作为开头的标记：解析为时区或特殊字段。

  4. 标记是文本字符串：与可能的字符串相匹配。

    • 使用二分搜索表查找标记，特殊字符串（例如今日）、星期（例如星期四）、月份（例如一月）或干扰词（例如 at、on）。

    • 设置字段的字段值和位掩码。例如，设置今日对应的年、月、日，还有当前的小时、分钟、秒钟。

    • 如果未找到，进行类似的二分搜索表查询，将标记与时区进行匹配。

    • 如果仍未找到，则会收到错误消息。

  5. 标记可以是一个数字或数字字段：

    • 如果是 8 位或 6 位数，且之前没有读取其他日期字段，则解释为“串联日期”（19990118 或 990118）。此解释为 YYYYMMDD 或 YYMMDD。

    • 如果标记是三位数，并且已经读取了年份，则解释为一年中的第几日。

    • 如果标记是四位或六位数，并且已经读取了年份，则解释为时间（HHMM 或 HHMMSS）。

    • 如果是三位或更多位数，且未找到日期字段，则解释为年份（这样会强制剩余的日期字段按“年-月-日”的格式排序）。

    • 否则，假定日期字段排序遵循 DateStyle 设置：月-日-年、日-月-年或年-月-日。如果发现月份或日期字段超出范围，则会收到错误消息。

  6. 如果已指定 BC：忽略年份并添加一个用于内部存储。（在 Vertica 实施中，1 BC = 元年。）

  7. 如果未指定 BC，且年份字段是两位长度：将年份调整为四位数。如果字段小于 70，则添加 2000，否则添加 1900。

年月日排序

对于某些格式，年、月、日的日期输入排序不明确，可支持指定这些字段的预期排序。

特殊日期/时间值

为了方便起见，Vertica 支持数个特殊日期/时间值，如下所示。当用作 SQL 语句中的常数时，所有这些值在书写时都需要加单引号。

值 INFINITY 和 -INFINITY 在系统中以特殊形式表示，并以相同方式显示。其他值为读取时转换为普通日期/时间值的简写符号。（尤其是，NOW 和相关字符串在读取后立即转换为特定时值。）

以下兼容 SQL 的函数也可用于获取相应数据类型的当前时间值。

后四个接受可选的精度要求。（请参阅日期/时间函数。）然而，这些函数是 SQL 函数，不能识别为数据输入字符串。

2.5.6 - NULL 值

NULL 是一个保留关键字，用于表示未知的数据值。它是 NULL 字符 (\0) 的 ASCII 缩写。

表达式中的使用情况

Vertica 不会将空字符串视为 NULL 值。表达式必须指定 NULL 才能表示列值未知。

以下注意事项适用于在表达式中使用 NULL：

  • NULL 不大于、小于、等于或不等于任何其他表达式。使用 布尔谓词 确定一个表达式的值是否为 NULL。

  • 您可以通过含有 NULL=NULL 联接的 <=> 运算符的表达式编写查询。请参阅等联接和非等联接。

  • Vertica 接受常量字符串中的 NULL 字符 ('\0')，且并未从输入或输出的 VARCHAR 字段移除 NULL 字符。

NULL 数据的投影排序

Vertica 对投影列中的 NULL 值进行排序，如下所示：

另请参阅

NULL 处理函数

2.6 - 谓词

谓词为事实测试。如果谓词测试为 true，则返回一个值。按行对每个谓词进行求值，因此当谓词是完整表 SELECT 语句的一部分时，该语句可以返回多个结果。

谓词由一组参数和实参组成。例如，在以下示例 WHERE 子句中：

WHERE name = 'Smith';

  • name = 'Smith' 为谓词

  • 'Smith' 为表达式

2.6.1 - BETWEEN 谓词

为方便使用，提供特殊的 BETWEEN 谓词。

语法

WHERE a BETWEEN x AND y

示例

WHERE a BETWEEN x AND y

等效于：

WHERE a >= x AND a <= y

同样：

WHERE a NOT BETWEEN x AND y

等效于：

WHERE a < x OR a > y

可以为日期范围使用 BETWEEN 谓词：

=> CREATE TABLE t1 (c1 INT, c2 INT, c3 DATE);
=> COPY t1 FROM stdin DELIMITER '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1 | 2 | 2014-07-26
>> 2 | 3 | 2014-07-27
>> 3 | 4 | 2014-07-28
>> 4 | 5 | 2014-07-29
>> 5 | 6 | 2014-07-30
>> 6 | 7 | 2014-07-31
>> 7 | 8 | 2014-08-01
>> 8 | 9 | 2014-08-02
>> \.

=> SELECT* FROM t1 WHERE c3 BETWEEN DATE('2014-07-26') AND DATE('2014-07-30');
 c1 | c2 |     c3
----+----+------------
  1 |  2 | 2014-07-26
  2 |  3 | 2014-07-27
  3 |  4 | 2014-07-28
  4 |  5 | 2014-07-29
  5 |  6 | 2014-07-30
(5 rows)

也可以使用 NOW 和 INTERVAL 关键字从日期范围中选择：

=> SELECT * FROM t1 WHERE c3 BETWEEN NOW()-INTERVAL '1 week' AND NOW();
 c1 | c2 |     c3
----+----+------------
  7 |  8 | 2014-08-01
  1 |  2 | 2014-07-26
  2 |  3 | 2014-07-27
  3 |  4 | 2014-07-28
  4 |  5 | 2014-07-29
  5 |  6 | 2014-07-30
  6 |  7 | 2014-07-31
(7 rows)

2.6.2 - 布尔谓词

检索表达式的值为 true、false 或 unknown (null) 的行。

语法

expression IS [NOT] TRUE
expression IS [NOT] FALSE
expression IS [NOT] UNKNOWN

注意

  • 一个 null 输入被视为值 UNKNOWN。

  • IS UNKNOWN 和 IS NOT UNKNOWN 实际上与 NULL 谓词 相同，不过输入表达式不必是单个列值。要检查 NULL 的单个列值，使用 NULL 谓词。

  • 不要将布尔谓词与 布尔运算符 或布尔数据类型相混淆，后者只有两个值：true 和 false。

2.6.3 - 列值谓词

语法

column-name comparison-op constant-expression

参数

注意

要检查某一列值是否是 NULL，请使用 NULL 谓词。

示例

table.column1 = 2
table.column2 = 'Seafood'
table.column3 IS NULL

2.6.4 - IN 谓词

语法

(column‑list) [ NOT ] IN ( values‑list )

参数

示例

以下 SELECT 语句可查询表 t11 中的所有数据。

=> SELECT * FROM t11 ORDER BY pk;
 pk | col1 | col2 | SKIP_ME_FLAG
----+------+------+--------------
  1 |    2 |    3 | t
  2 |    3 |    4 | t
  3 |    4 |    5 | f
  4 |    5 |    6 | f
  5 |    6 |    7 | t
  6 |      |    8 | f
  7 |    8 |      | t
(7 rows)

以下查询可指定 IN 谓词，以查找 t11 中的所有行，其中 col1 和 col2 列包含 (2,3) 或 (6,7) 的值：


=> SELECT * FROM t11 WHERE (col1, col2) IN ((2,3), (6,7)) ORDER BY pk;
 pk | col1 | col2 | SKIP_ME_FLAG
----+------+------+--------------
  1 |    2 |    3 | t
  5 |    6 |    7 | t
(2 rows)

2.6.5 - INTERPOLATE

使用某些有序属性将两个 事件序列联接在一起，通过联接事件序列，您可以直接比较两个序列的值，而不是将这些序列都标准化为相同的度量间隔。

语法

expression1 INTERPOLATE PREVIOUS VALUE expression2

参数

描述

  • 事件序列联接是常规外联接的扩展。事件序列联接不会在找不到匹配时用 NULL 值填充非保留侧，而是用表中的前一个值填充非保留侧。

  • 常规外联接与事件序列联接表达式的不同之处在于 ON 子句中使用的 INTERPOLATE 谓词。请参阅“注释和限制”下方的示例 部分。另请参阅 事件序列联接。

  • 根据其他 ON 子句等同谓词将表中数据按照逻辑分区。

  • 插值来源于包含 null 值的表，而不是其他表。

  • Vertica 无法保证输出中不存在 null 值。如果不匹配行之前没有值，则用 null 填充该行。

  • 事件序列联接需要两个表的列均按照等同谓词以任何顺序进行排序，然后接 INTERPOLATED 列。如果数据已经按照这个顺序排序，则可以避免显式排序，从而提升查询性能。例如，给定下表：

    ask: exchange, stock, ts, pricebid: exchange,
stock, ts, price

    在接下来的查询中

    • ask 按 exchange, stock 排序（或相反）， ts

    • bid 按 exchange, stock 排序（或相反）， ts

    SELECT ask.price - bid.price, ask.ts, ask.stock, ask.exchange
FROM ask FULL OUTER JOIN bid
   ON ask.stock = bid.stock AND ask.exchange =
   bid.exchange AND ask.ts INTERPOLATE PREVIOUS
   VALUE bid.ts;

限制

  • 每个联接仅可使用 INTERPOLATE 表达式一次。

  • INTERPOLATE 表达式仅使用 ANSI SQL-99 语法 (ON 子句)，其支持全外联接。

  • INTERPOLATE 仅可使用等同谓词。

  • 支持 AND 运算符，但不支持 OR 和 NOT 运算符。

  • 不支持表达式以及隐式转换和显式转换，但可以使用子查询。

示例

接下来的示例中使用了此简单架构。 

CREATE TABLE t(x TIME);
CREATE TABLE t1(y TIME);
INSERT INTO t VALUES('12:40:23');
INSERT INTO t VALUES('14:40:25');
INSERT INTO t VALUES('14:45:00');
INSERT INTO t VALUES('14:49:55');
INSERT INTO t1 VALUES('12:40:23');
INSERT INTO t1 VALUES('14:00:00');
COMMIT;

常规全外联接

=> SELECT * FROM t FULL OUTER JOIN t1 ON t.x = t1.y;

请注意来自非保留表的 null 行。

    x     |    y
----------+----------
 12:40:23 | 12:40:23
 14:40:25 |
 14:45:00 |
 14:49:55 |
          | 14:00:00
(5 rows)

带插值的全外联接

=> SELECT * FROM t FULL OUTER JOIN t1 ON t.x INTERPOLATE
PREVIOUS VALUE t1.y;

在本例中，没有入口点的行用前一行的值进行填充。

    x     |    y
----------+----------
 12:40:23 | 12:40:23
 12:40:23 | 14:00:00
 14:40:25 | 14:00:00
 14:45:00 | 14:00:00
 14:49:55 | 14:00:00
(5 rows)

常规左外联接

=> SELECT * FROM t LEFT OUTER JOIN t1 ON t.x = t1.y;

同样，非保留表中有 null

    x     |    y
----------+----------
 12:40:23 | 12:40:23
 14:40:25 |
 14:45:00 |
 14:49:55 |
(4 rows)

带插值的左外联接

=> SELECT * FROM t LEFT OUTER JOIN t1 ON t.x INTERPOLATE
   PREVIOUS VALUE t1.y;

用插值填充 null。

    x     |    y
----------+----------
 12:40:23 | 12:40:23
 14:40:25 | 14:00:00
 14:45:00 | 14:00:00
 14:49:55 | 14:00:00
(4 rows)

内联接

对于内联接，常规内联接与事件序列内联接没有差别。因为结果集中没有 null 值，所以无需插值操作。

常规内联接仅返回唯一匹配行 12:40:23:

=> SELECT * FROM t INNER JOIN t1 ON t.x = t1.y;
    x     |    y
----------+----------
 12:40:23 | 12:40:23
(1 row)

事件序列内联接也找到了相同的唯一匹配行 12:40:23:

=> SELECT * FROM t INNER JOIN t1 ON t.x INTERPOLATE
PREVIOUS VALUE t1.y;
    x     |    y
----------+----------
 12:40:23 | 12:40:23
(1 row)

语义

如果要编写事件序列联接以取代常规联连，则按下列方式来评估值（使用上述示例中的架构）：

  • t 是外部保留表

  • t1 是内部非保留表

  • 对于外部表 t 中的每一行，针对内部表 t1 中每一行的每个组合来评估 ON 子句谓词。

  • 如果针对任意的行组合的 ON 子句谓词评估为真，则在输出中生成组合行。

  • 如果针对所有组合的 ON 子句为假，则生成一个单独的输出行，其中包含t 中行的值，以及 t1 中的列，其选自 t1 中具有最大 t1.y 值的行，以使得 t1.y < t.x；如果没有找到这样的行，则用 null 填充。

在全外联接的情况下，两个表中的所有值都被保留。

另请参阅

2.6.6 - 联接谓词

指定联接两个或两个以上表中的记录的列。您可以使用逻辑运算符 AND、OR 和 NOT 连接多个联接谓词。

语法

ON column-ref = column-ref [ {AND | OR | NOT } column-ref = column-ref ]...

参数

2.6.7 - LIKE 谓词

当某列的字符串值与指定模式匹配时，检索该行。该模式可能包括一个或多个通配符 (*)。

语法

string‑expression [ NOT ] { LIKE | ILIKE | LIKEB | ILIKEB } 'pattern' [ESCAPE 'escape‑character' ]

参数

替换符号

可将以下符号替换为 LIKE 及其变体：

模式匹配

LIKE 要求整个字符串表达式与 patten 匹配。要与字符串中的任意一序列字符匹配， patten 开头和结尾必须使用百分比符号。

LIKE 不会忽略尾部空格字符。如果要匹配的数据值以不确定量的空格结尾，请将通配符 % 附加到 pattern。

LIKE 变体比较

该 LIKE 谓词符合 SQL 标准。Vertica 还支持多种非标准变体，特别是 ILIKE，该变体等同于 LIKE，但可执行不区分大小写的搜索。以下差异与 LIKE 及其变体有关：

  • LIKE 对 UTF-8 字符字符串执行操作。精确行为取决于排序规则参数，如强度。特殊情况下，ILIKE 在当前会话语言环境下设置 S=2 (不计大小写)。

  • LIKE 和 ILIKE 对字符字符串 稳定，但对二进制字符串 不可变，而 LIKEB 和 ILIKEB 在两种情况下都不可变。

  • LIKEB 和 ILIKEB 谓词挨个字节进行 ASCII 比较。

区域设置依赖关系

默认语言环境设置下，LIKE 和 ILIKE 挨个 UTF-8 字符进行比较，比较不区分语言环境设置。 ILIKE 将独立语言转换为小写。

在非默认区域设置下，LIKE 和 ILIKE 将字符串做对比，区分语言环境设置，包括为 VARCHAR 类型使用与 "=" 相同的算法进行自动标准化。

ESCAPE 对于非默认语言环境设置，表达式的求值结果恰好为一个八位字节或一个 UTF-8 字符。

示例

以下示例显示了区域的模式匹配。

\locale default=> CREATE TABLE src(c1 VARCHAR(100));
=> INSERT INTO src VALUES (U&'\00DF'); --The sharp s (ß)
=> INSERT INTO src VALUES ('ss');
=> COMMIT;

默认区域下查询 src 表返回 ss 和 sharp s。

=> SELECT * FROM src;
 c1
----
 ß
 ss
(2 rows)

下列查询结合了参数匹配谓词来返回 c1 列的结果：

=> SELECT c1, c1 = 'ss' AS equality, c1 LIKE 'ss'
   AS LIKE, c1 ILIKE 'ss' AS ILIKE FROM src;
 c1 | equality | LIKE | ILIKE
----+----------+------+-------
 ß  | f        | f    | f
 ss | t        | t    | t
(2 rows)

下一个查询指定 c1 的 unicode 格式。

=> SELECT c1, c1 = U&'\00DF' AS equality,
   c1 LIKE U&'\00DF' AS LIKE,
   c1 ILIKE U&'\00DF' AS ILIKE from src;
 c1 | equality | LIKE | ILIKE
----+----------+------+-------
 ß  | t        | t    | t
 ss | f        | f    | f
(2 rows)

将区域改为德文，强度为 1（忽略大小写和口音）：

\locale LDE_S1
=> SELECT c1, c1 = 'ss' AS equality,
c1 LIKE 'ss' as LIKE, c1 ILIKE 'ss' AS ILIKE from src;
 c1 | equality | LIKE | ILIKE
----+----------+------+-------
 ß  | t        | t    | t
 ss | t        | t    | t
(2 rows)

该例说明使用模式匹配谓词二进制数据类型：

=> CREATE TABLE t (c BINARY(1));
=> INSERT INTO t values(HEX_TO_BINARY('0x00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFF'));
=> SELECT TO_HEX(c) from t;
 TO_HEX
--------
 00
 ff
(2 rows)
select * from t;
  c
------
 \000
 \377
(2 rows)
=> SELECT c, c = '\000', c LIKE '\000', c ILIKE '\000' from t;
  c   | ?column? | ?column? | ?column?
------+----------+----------+----------
 \000 | t        | t        | t
 \377 | f        | f        | f
(2 rows)
=> SELECT c, c = '\377', c LIKE '\377', c ILIKE '\377' from t;
  c   | ?column? | ?column? | ?column?
------+----------+----------+----------
 \000 | f        | f        | f
 \377 | t        | t        | t
(2 rows)

2.6.8 - NULL 谓词

null 值测试。

语法

value_expression IS [ NOT ] NULL

参数

示例

列名称：

=> SELECT date_key FROM date_dimension WHERE date_key IS NOT NULL;
 date_key
----------
        1
      366
     1462
     1097
        2
        3
        6
        7
        8
...

函数：

=> SELECT MAX(household_id) IS NULL FROM customer_dimension;
 ?column?
----------
 f
(1 row)

字面量：

=> SELECT 'a' IS NOT NULL;
 ?column?
----------
 t
(1 row)

2.7 - 提示

提示是您嵌入到查询或 定向查询中的指令。这些指令符合以下语法：

/*+hint-name[, hint-name]...*/

用注释字符 /*+ 和 */ 括住提示，这种方式可以括住多个用逗号分隔的提示。例如：

SELECT /*+syntactic_join,verbatim*/

限制

在查询中嵌入提示时，请注意以下限制：

  • 不要在注释字符 /* 和 */ 中嵌入空格。

  • 通常，允许在加号 (+) 字符和 hint‑name 前后使用空格；但是，某些第三方工具不支持在 /*+ 中嵌入空格。

支持的提示

Vertica 支持以下提示：

一般提示

Eon 模式提示

联接提示

投影提示

定向查询提示

以下提示仅通过定向查询提供支持：

2.7.1 - :c

在定向查询中，标记必须包含在输入查询中的查询常量；否则，将取消该输入查询使用定向查询的资格。

语法

/*+:c*/

使用

默认情况下，优化器生成的定向查询集忽略谓词常量的常量 (:v) 提示。您可以通过在不得忽略的输入查询常量上设置 :c 提示来覆盖此行为。例如，以下语句创建了一个定向查询，该查询只能用于联接谓词常量与原始输入查询相同的输入查询 — 8：

=> CREATE DIRECTED QUERY OPTIMIZER simpleJoin_KeepPredicateConstant SELECT * FROM S JOIN T ON S.a = T.b WHERE S.a = 8 /*+:c*/;
CREATE DIRECTED QUERY
=> ACTIVATE DIRECTED QUERY simpleJoin_KeepPredicateConstant;

另请参阅

保留定向查询中的谓词常量

2.7.2 - :v

在定向查询中，标记优化器在考虑是否对给定查询使用定向查询时忽略的输入查询常量。使用此提示创建可对输入查询的多个变体使用的定向查询。

Vertica 还支持将 IGNORECONST 作为 :v 的别名。优化器生成的定向查询会自动在输入和带注释的查询中标记谓词常量并附带 :v 提示。

有关详细信息，请参阅忽略定向查询中的常量。

语法

/*+:v(arg)*/

/*+IGNORECONST(arg)*/
arg
为将每个输入查询 :v 提示与一个或多个带注释的查询 :v 提示配对而在定向查询中使用的整数实参。

示例

请参阅忽略定向查询中的常量。

2.7.3 - ALLNODES

限定 EXPLAIN 语句请求假设所有节点均处于活动状态的查询计划。如果忽略此提示，EXPLAIN 语句将生成一个查询计划，将当前处于关闭状态的任何节点考虑在内。

语法

EXPLAIN /*+ALLNODES*/

示例

在以下示例中，ALLNODES 提示将请求假设所有节点均处于活动状态的查询计划。

QUERY PLAN DESCRIPTION:
 ------------------------------

 Opt Vertica Options
 --------------------
 PLAN_ALL_NODES_ACTIVE


 EXPLAIN /*+ALLNODES*/ select * from Emp_Dimension;

 Access Path:
 +-STORAGE ACCESS for Emp_Dimension [Cost: 125, Rows: 10K (NO STATISTICS)] (PATH ID: 1)
 |  Projection: public.Emp_Dimension_b0
 |  Materialize: Emp_Dimension.Employee_key, Emp_Dimension.Employee_gender, Emp_Dimension.Courtesy_title, Emp_Dimension.Employee_first_name, Emp_Dimension.Employee_middle_initial, Emp_Dimension.Employee_last_name, Emp_Dimension.Employee_age, Emp_Dimension.Employee_birthdate, Emp_Dimension.Employee_street, Emp_Dimension.Employee_city, Emp_Dimension.Employee_state, Emp_Dimension.Employee_region, Emp_Dimension.Employee_position
 |  Execute on: All Nodes

2.7.4 - DEPOT_FETCH

仅限 Eon 模式

当存储库缺少此查询的数据时，指定查询是否从公共存储将数据提取到存储库中。此提示会覆盖配置参数 DepotOperationsForQuery。

语法

SELECT /*+DEPOT_FETCH (option)*/

参数

可选
指定当存储库不包含查询的文件数据时的行为，为以下之一：

  • ALL （默认值）：从公共存储中提取文件数据，如有必要，通过将现有文件从存储库中逐出来替换它们。

  • FETCHES：仅当空间可用时才从公共存储中提取文件数据；否则，直接从公共存储中读取查询的数据。

  • NONE：请勿将文件数据提取到存储库，而应直接从公共存储中读取查询的数据。

示例

SELECT /*+DEPOT_FETCH(All)*/ count(*) FROM bar;
SELECT /*+DEPOT_FETCH(FETCHES)*/ count(*) FROM bar;
SELECT /*+DEPOT_FETCH(NONE)*/ count(*) FROM bar;

2.7.5 - DISTRIB

指定优化器如何分发联接键以实施联接。

语法

JOIN /*+DISTRIB(outer-join, inner-join)*/

参数

外联接
内联接
指定如何分发外联接和内连接上的数据：

  • L （当地）：在各节点上对内联接键和外联接键进行相同分段，本地联接。

  • R （重新分段）：内部和外部联接键没有进行相同分段。实施联接前对联接键数据进行重新分段。

  • B （广播）：内部和外部联接键没有进行相同分段。实施联接前将此联接键的数据广播至其他节点。

  • F （筛选）：联接表未分段。实施联接前根据需要按其他联接键筛选数据。

  • A （任意）：让优化器自行选择最有效的分发方法。

描述

DISTRIB 提示指定优化器如何按顺序分发联接键以实施联接。如果指定的分发方法不可行，优化器会忽略提示并发出警告。

需要满足以下要求：

  • 包含 DISTRIB 提示的查询必须也包含 SYNTACTIC_JOIN 提示。否则，优化器会忽略 DISTRIB 提示并抛出一条警告。

  • 联接语法必须符合 ANSI SQL-92 联接约定。

示例

在以下查询中，联接受 DISTRIB 的提示 /*+DISTRIB(L,R)*/ 限定。此提示指示优化器先对联接键 stores.store_key 的数据进行重新分段，然后再将其联接至 sales.store_key 数据：

SELECT /*+SYNTACTIC_JOIN*/ sales.store_key, stores.store_name, sales.product_description, sales.sales_quantity, sales.sale_date
FROM (store.storeSales AS sales JOIN /*+DISTRIB(L,R),JTYPE(H)*/ store.store_dimension AS stores ON (sales.store_key = stores.store_key))
WHERE (sales.sale_date = '2014-12-01'::date) ORDER BY sales.store_key, sales.sale_date;

2.7.6 - EARLY_MATERIALIZATION

为当前查询指定表的早期实体化。一个查询可以针对任意数量的表包含这项提示。通常，查询优化器会将实体化延迟到查询执行流程后期。此提示会覆盖优化器通过其他方式做出的任何选择。

如果后续实体化联接输入会妨碍其他优化 — 例如，将聚合下推到联接，或使用实时聚合投影，此提示可能会非常有用。在这些情况下，使用 EARLY_MATERIALIZATION 限定联接输入可以启用优化。

语法

table-name [ [AS] alias ] /*+EARLY_MATERIALIZATION*/

2.7.7 - ECSMODE

仅限 Eon 模式

设置优化器在订户节点之间划分分片数据处理职责时使用的 ECS 策略。仅当子群集使用弹性处理调整 (ECS) 时才会应用此提示。

语法

SELECT /*+ECSMODE(option)*/

参数

可选
指定在其订阅节点之间划分分片数据时使用的策略，为以下之一：

  • AUTO：优化器选择要使用的策略，仅当在会话级别设置 ECS 模式时才有用（请参阅为会话或数据库设置 ECS 策略）。

  • IO_OPTIMIZED：使用 I/O 优化策略。

  • COMPUTE_OPTIMIZED：使用计算优化策略。

  • NONE：对此查询禁用 ECS。只有参与节点才会涉及查询执行；协作节点不会涉及。

示例

以下示例显示了简单的单表查询（被强制使用计算优化策略）的查询计划：

=> EXPLAIN SELECT /*+ECSMode(COMPUTE_OPTIMIZED)*/ employee_last_name,
             employee_first_name,employee_age
             FROM employee_dimension
             ORDER BY employee_age DESC;

                                   QUERY PLAN
--------------------------------------------------------------------------------
 ------------------------------
 QUERY PLAN DESCRIPTION:
 The execution of this query involves non-participating nodes.
 Crunch scaling strategy preserves data segmentation
 ------------------------------
. . .

2.7.8 - ENABLE_WITH_CLAUSE_MATERIALIZATION

启用当前 WITH 子句中所有查询的实体化。否则，实体化由配置参数 WithClauseMaterialization 设置，默认设置为 0（禁用）。如果禁用 WithClauseMaterialization，则 WITH 子句的主查询返回时会自动清除实体化。有关详细信息，请参阅WITH 子句的实体化。

语法

WITH /*+ENABLE_WITH_CLAUSE_MATERIALIZATION*/

2.7.9 - GBYTYPE

指定 Vertica 查询优化器应使用哪一种算法（GROUPBY HASH 或 GROUPBY PIPELINED）实施 GROUP BY 子句。如果两种算法对此查询都有效，则查询优化器会优先选择指定的算法，而不是查询优化器可能通过其他方式在其查询计划中选择的算法。

语法

GROUP BY /*+GBYTYPE( HASH | PIPE )*/

参数

HASH | PIPE
指定要使用的 GROUP BY 算法：

  • HASH：GROUPBY HASH 算法

  • PIPE：GROUPBY PIPELINED 算法

有关两种算法的详细信息，请参阅 GROUP BY 实施选项。

示例

请参阅控制 GROUPBY 算法选项。

2.7.10 - JFMT

指定联接这些列中的表时如何调整 VARCHAR 列数据的大小并相应缓冲数据。JFMT 提示覆盖由配置参数 JoinDefaultTupleFormat 设置的默认行为，可在数据库和会话级别进行设置。

有关详细信息，请参阅联接可变长度字符串数据。

语法

JOIN /*+JFMT(format-type)*/

参数

format‑type
指定联接这些列中的表时如何设置 VARCHAR 列数据的格式并相应缓冲数据。设置为以下值之一：

  • f （固定）：使用联接列元数据将列数据的大小调整为固定长度，并相应地进行缓冲。

  • v （变量）：使用联接列数据的实际长度，因此每个联接的缓冲区大小不同。

例如：

SELECT /*+SYNTACTIC_JOIN*/ s.store_region, SUM(e.vacation_days) TotalVacationDays
   FROM public.employee_dimension e
   JOIN /*+JFMT(f)*/ store.store_dimension s ON s.store_region=e.employee_region
   GROUP BY s.store_region ORDER BY TotalVacationDays;

要求

  • 包含 JFMT 提示的查询必须也包含 SYNTACTIC_JOIN 提示。否则，优化器会忽略 JFMT 提示并抛出一条警告。

  • 联接语法必须符合 ANSI SQL-92 联接约定。

2.7.11 - JTYPE

指定联接算法是哈希联接还是合并联接。

使用 JTYPE 提示以指定优化器用来联接表数据的算法。如果指定算法不可行，优化器将忽略提示并发出警告。

语法

JOIN /*+JTYPE(join-type)*/

参数

联接类型
以下几项之一：

  • H：哈希联接

  • M：合并联接仅在联接列的输入均排序的情况下有效，否则 Vertica 会忽略并发出警告。优化器依靠查询或 DDL 来验证输入数据是否已排序，而不是依靠数据的实际运行时顺序。

  • FM：强制合并联接合并前，优化器会重新针对联接输入进行排序。联接列必须是相同的类型、精度或小数位数，但字符串列可以是不同的长度。

FM 的值仅对简单的联接状态有效。例如：

=> SELECT /*+SYNTACTIC_JOIN*/ * FROM x JOIN /*+JTYPE(FM)*/ y ON x.c1 = y.c1;

要求

  • 包含 JTYPE 提示的查询必须也包含 SYNTACTIC_JOIN 提示。否则，优化器会忽略 JTYPE 提示并抛出一条警告。

  • 联接语法必须符合 ANSI SQL-92 联接约定。

2.7.12 - LABEL

为语句分配标签，以便轻松识别标签，评估性能和调试问题。

LABEL 提示在以下语句中有效：

语法

statement-name /*+LABEL (label‑string)*/

参数

标签字串
最长为 128 个八位字节的字符串。如果用单引号括起，label-string 可以包含嵌入空格。

示例

请参阅标记语句。

2.7.13 - PROJS

指定要用于查询的表的一个或多个投影。

语法

FROM table-name /*+PROJS( [[database.]schema.]projection[,...] )*/

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要使用的投影。可以指定逗号分隔投影的列表。

描述

PROJS 提示可指定多个投射；优化器指定了哪些有效并使用已查询表中最低成本的一个。如果没有有效的已提示投影，则查询将返回警告并忽略投影提示。

示例

employee_dimension 表包含两个投影：分段的超投影public.employee_dimension，包括所有表列；未分段的投影 public.employee_dimension_rep，包括列的子集：


=> SELECT export_objects('','employee_dimension');
                                                      export_objects
--------------------------------------------------------------------------------------------------------------------------

CREATE TABLE public.employee_dimension
(
    employee_key int NOT NULL,
    employee_gender varchar(8),
    courtesy_title varchar(8),
    employee_first_name varchar(64),
    employee_middle_initial varchar(8),
    employee_last_name varchar(64),
    employee_age int,
    hire_date date,
    employee_street_address varchar(256),
    employee_city varchar(64),
    employee_state char(2),
    employee_region char(32),
    job_title varchar(64),
    reports_to int,
    salaried_flag int,
    annual_salary int,
    hourly_rate float,
    vacation_days int,
    CONSTRAINT C_PRIMARY PRIMARY KEY (employee_key) DISABLED
);

CREATE PROJECTION public.employee_dimension
...
AS
 SELECT employee_dimension.employee_key,
        employee_dimension.employee_gender,
        employee_dimension.courtesy_title,
        employee_dimension.employee_first_name,
        employee_dimension.employee_middle_initial,
        employee_dimension.employee_last_name,
        employee_dimension.employee_age,
        employee_dimension.hire_date,
        employee_dimension.employee_street_address,
        employee_dimension.employee_city,
        employee_dimension.employee_state,
        employee_dimension.employee_region,
        employee_dimension.job_title,
        employee_dimension.reports_to,
        employee_dimension.salaried_flag,
        employee_dimension.annual_salary,
        employee_dimension.hourly_rate,
        employee_dimension.vacation_days
 FROM public.employee_dimension
 ORDER BY employee_dimension.employee_key
SEGMENTED BY hash(employee_dimension.employee_key) ALL NODES KSAFE 1;

CREATE PROJECTION public.employee_dimension_rep
...
AS
 SELECT employee_dimension.employee_key,
        employee_dimension.employee_gender,
        employee_dimension.employee_first_name,
        employee_dimension.employee_middle_initial,
        employee_dimension.employee_last_name,
        employee_dimension.employee_age,
        employee_dimension.employee_street_address,
        employee_dimension.employee_city,
        employee_dimension.employee_state,
        employee_dimension.employee_region
 FROM public.employee_dimension
 ORDER BY employee_dimension.employee_key
UNSEGMENTED ALL NODES;

SELECT MARK_DESIGN_KSAFE(1);

(1 row)

以下查询从 employee_dimension 选择所有表列并包含 PROJS 提示，指定两个投影。 public.employee_dimension_rep 未包含查询表中的所有列，因此优化器无法使用它。分段的投影包含了所有表列，因此优化器可以使用它，已经以下查询计划验证：

=> EXPLAIN SELECT * FROM employee_dimension /*+PROJS('public.employee_dimension_rep', 'public.employee_dimension')*/;

QUERY PLAN DESCRIPTION:
------------------------------
EXPLAIN SELECT * FROM employee_dimension /*+PROJS('public.employee_dimension_rep', 'public.employee_dimension')*/;

 Access Path:
 +-STORAGE ACCESS for employee_dimension [Cost: 177, Rows: 10K (NO STATISTICS)] (PATH ID: 1)
 |  Projection: public.employee_dimension_b0

2.7.14 - SKIP_PROJS

指定要避免用于查询的表的投影。如果 SKIP_PROJS 不包括对查询有效的所有可用投影，则优化器会发出警告并忽略投影提示。

语法

FROM table-name /*+SKIP_PROJS( [[database.]schema.]projection[,...] )*/

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要跳过的投影。可以指定逗号分隔投影的列表。

示例

在此示例中，EXPLAIN 输出显示优化器使用了给定查询的投影 public.employee_dimension_b0：


QUERY PLAN DESCRIPTION:
------------------------------

 EXPLAIN SELECT employee_last_name, employee_first_name, employee_city, job_title FROM employee_dimension;

 Access Path:
 +-STORAGE ACCESS for employee_dimension [Cost: 59, Rows: 10K (NO STATISTICS)] (PATH ID: 1)
 |  Projection: public.employee_dimension_b0
 |  Materialize: employee_dimension.employee_first_name, employee_dimension.employee_last_name, employee_dimension.employee_city, employee_dimension.job_title
 |  Execute on: All Nodes

您可使用 SKIP_PROJS 提示避免使用此投射。如果有对此查询有效的其他投影，优化器将改用此投影：


QUERY PLAN DESCRIPTION:
------------------------------

EXPLAIN SELECT employee_last_name, employee_first_name, employee_city, job_title FROM employee_dimension /*+SKIP_PROJS('public.employee_dimension')*/;

 Access Path:
 +-STORAGE ACCESS for employee_dimension [Cost: 156, Rows: 10K (NO STATISTICS)] (PATH ID: 1)
 |  Projection: public.employee_dimension_super
 |  Materialize: employee_dimension.employee_first_name, employee_dimension.employee_last_name, employee_dimension.emplo
yee_city, employee_dimension.job_title
 |  Execute on: Query Initiator

2.7.15 - SKIP_STATISTICS

指示优化器生成仅包含由 ANALYZE_ROW_COUNT 收集的最少统计信息的查询计划。优化器会忽略由 ANALYZE_STATISTICS 和 ANALYZE_STATISTICS_PARTITION 使用和生成的其他统计信息。当用于对小型表执行查询时，此提示尤其有用，其中收集完整统计信息所需的时间量通常大于实际执行时间。

语法

SELECT /*+SKIP_STAT[ISTIC]S*/

EXPLAIN 输出

EXPLAIN 为包含 SKIP_STATISTICS（使用其缩写形式 SKIP_STATS）的查询返回以下输出：


=> EXPLAIN SELECT /*+ SKIP_STATS*/ customer_key, customer_name, customer_gender, customer_city||', '||customer_state, customer_age
    FROM customer_dimension WHERE customer_region = 'East' AND customer_age > 60;

 QUERY PLAN DESCRIPTION:
 ------------------------------

 EXPLAIN SELECT /*+ SKIP_STATS*/ customer_key, customer_name, customer_gender, customer_city||', '||customer_state,
 customer_age FROM customer_dimension WHERE customer_region = 'East' AND customer_age > 60;

 Access Path:
 +-STORAGE ACCESS for customer_dimension [Cost: 2K, Rows: 10K (STATISTICS SKIPPED)] (PATH ID: 1)
 |  Projection: public.customer_dimension_b0
 |  Materialize: public.customer_dimension.customer_age, public.customer_dimension.customer_key, public.customer_dimensi
on.customer_name, public.customer_dimension.customer_gender, public.customer_dimension.customer_city, public.customer_di
mension.customer_state
 |  Filter: (public.customer_dimension.customer_region = 'East')
 |  Filter: (public.customer_dimension.customer_age > 60)
 |  Execute on: All Nodes
...

2.7.16 - SYNTACTIC_JOIN

强制执行联接顺序并启用其他联接提示。

语法

SELECT /*+SYN[TACTIC]_JOIN*/

描述

为了实现最佳性能，优化器经常覆盖查询的指定联接顺序。通过包括 SYNTACTIC_JOIN 提示，可以确保优化器严格按规定强制执行查询的联接顺序。一个要求适用：联接语法必须符合 ANSI SQL-92 惯例。

SYNTACTIC_JOIN 提示必须紧跟在 SELECT 后面。如果带注释查询包含的另一个提示也必须跟在 SELECT 后面（例如 VERBATIM），则将这两个提示组合在一起。例如：

SELECT /*+ syntactic_join,verbatim*/

示例

在以下示例中，优化器为两个查询产生不同的计划，区别就在于包括或排除了 SYNTACTIC_JOIN 提示。

排除 SYNTACTIC_JOIN

EXPLAIN SELECT sales.store_key, stores.store_name, products.product_description, sales.sales_quantity, sales.sale_date
FROM (store.store_sales sales JOIN products ON sales.product_key=products.product_key)
JOIN store.store_dimension stores ON sales.store_key=stores.store_key
WHERE sales.sale_date='2014-12-01' order by sales.store_key, sales.sale_date;

 Access Path:
 +-SORT [Cost: 14K, Rows: 100K (NO STATISTICS)] (PATH ID: 1)
 |  Order: sales.store_key ASC, sales.sale_date ASC
 |  Execute on: All Nodes
 | +---> JOIN HASH [Cost: 11K, Rows: 100K (NO STATISTICS)] (PATH ID: 2) Outer (RESEGMENT)(LOCAL ROUND ROBIN) Inner (RESEGMENT)
 | |      Join Cond: (sales.product_key = products.product_key)
 | |      Materialize at Input: sales.store_key, sales.product_key, sales.sale_date, sales.sales_quantity
 | |      Execute on: All Nodes
 | | +-- Outer -> JOIN HASH [Cost: 1K, Rows: 100K (NO STATISTICS)] (PATH ID: 3)
 | | |      Join Cond: (sales.store_key = stores.store_key)
 | | |      Execute on: All Nodes
 | | | +-- Outer -> STORAGE ACCESS for sales [Cost: 1K, Rows: 100K (NO STATISTICS)] (PATH ID: 4)
 | | | |      Projection: store.store_sales_b0
 | | | |      Materialize: sales.store_key
 | | | |      Filter: (sales.sale_date = '2014-12-01'::date)
 | | | |      Execute on: All Nodes
 | | | |      Runtime Filter: (SIP1(HashJoin): sales.store_key)
 | | | +-- Inner -> STORAGE ACCESS for stores [Cost: 34, Rows: 250] (PATH ID: 5)
 | | | |      Projection: store.store_dimension_DBD_10_rep_VMartDesign_node0001
 | | | |      Materialize: stores.store_key, stores.store_name
 | | | |      Execute on: All Nodes
 | | +-- Inner -> STORAGE ACCESS for products [Cost: 3K, Rows: 60K (NO STATISTICS)] (PATH ID: 6)
 | | |      Projection: public.products_b0
 | | |      Materialize: products.product_key, products.product_description
 | | |      Execute on: All Nodes

包括 SYNTACTIC_JOIN

EXPLAIN SELECT /*+SYNTACTIC_JOIN*/ sales.store_key, stores.store_name, products.product_description, sales.sales_quantity, sales.sale_date
FROM (store.store_sales sales JOIN products ON sales.product_key=products.product_key)
JOIN store.store_dimension stores ON sales.store_key=stores.store_key
WHERE sales.sale_date='2014-12-01' order by sales.store_key, sales.sale_date;

 Access Path:
 +-SORT [Cost: 11K, Rows: 100K (NO STATISTICS)] (PATH ID: 1)
 |  Order: sales.store_key ASC, sales.sale_date ASC
 |  Execute on: All Nodes
 | +---> JOIN HASH [Cost: 8K, Rows: 100K (NO STATISTICS)] (PATH ID: 2)
 | |      Join Cond: (sales.store_key = stores.store_key)
 | |      Execute on: All Nodes
 | | +-- Outer -> JOIN HASH [Cost: 7K, Rows: 100K (NO STATISTICS)] (PATH ID: 3) Outer (BROADCAST)(LOCAL ROUND ROBIN)
 | | |      Join Cond: (sales.product_key = products.product_key)
 | | |      Execute on: All Nodes
 | | |      Runtime Filter: (SIP1(HashJoin): sales.store_key)
 | | | +-- Outer -> STORAGE ACCESS for sales [Cost: 2K, Rows: 100K (NO STATISTICS)] (PATH ID: 4)
 | | | |      Projection: store.store_sales_b0
 | | | |      Materialize: sales.sale_date, sales.store_key, sales.product_key, sales.sales_quantity
 | | | |      Filter: (sales.sale_date = '2014-12-01'::date)
 | | | |      Execute on: All Nodes
 | | | +-- Inner -> STORAGE ACCESS for products [Cost: 3K, Rows: 60K (NO STATISTICS)] (PATH ID: 5)
 | | | |      Projection: public.products_b0
 | | | |      Materialize: products.product_key, products.product_description
 | | | |      Execute on: All Nodes
 | | +-- Inner -> STORAGE ACCESS for stores [Cost: 34, Rows: 250] (PATH ID: 6)
 | | |      Projection: store.store_dimension_DBD_10_rep_VMartDesign_node0001
 | | |      Materialize: stores.store_key, stores.store_name
 | | |      Execute on: All Nodes

2.7.17 - UTYPE

指定如何组合 UNION ALL 输入。

语法

UNION ALL /*+UTYPE(union-type)*/

参数

union‑type
以下实参之一：

  • U：连接 UNION ALL 输入（默认）。

  • M：合并 UNION ALL 输入，排序顺序与源查询结果相同。此选项要求来自源查询的所有输入均采用相同的排序顺序；否则，Vertica 将发出警告并连接 UNION ALL 输入。

要求

包含 UTYPE 提示的查询必须也包含 SYNTACTIC_JOIN 提示。否则，优化器会忽略 UTYPE 提示并抛出一条警告。

2.7.18 - VERBATIM

完全按编写强制执行带注释查询。

VERBATIM 指示优化器创建一个包含某带注释查询中所有提示的查询计划。而且，它指示优化器不将其自身的计划开发处理用于与这些提示相关的查询计划组件。

此提示的用法在 optimizer-generated 与 custom 定向查询之间有所不同，如下所述。

语法

SELECT /*+ VERBATIM*/

要求

VERBATIM 提示必须紧跟在 SELECT 后面。如果带注释查询包含的另一个提示也必须跟在 SELECT 后面（例如 SYNTACTIC_JOIN），则将这两个提示组合在一起。例如：

SELECT /*+ syntactic_join,verbatim*/

优化器生成的定向查询

在优化器为定向查询生成的带注释查询中，始终包含 VERBATIM 提示。例如，对于以下 CREATE DIRECTED QUERY OPTIMIZER 语句：


=> CREATE DIRECTED QUERY OPTIMIZER getStoreSales SELECT sales.store_key, stores.store_name, sales.product_description, sales.sales_quantity, sales.sale_date FROM store.storesales sales JOIN store.store_dimension stores ON sales.store_key=stores.store_key WHERE sales.sale_date='2014-12-01' /*+IGNORECONST(1)*/ AND stores.store_name='Store1' /*+IGNORECONST(2)*/ ORDER BY sales.store_key, sales.sale_date;
CREATE DIRECTED QUERY

优化器将生成包含 VERBATIM 提示的带注释查询：

=> SELECT query_name, annotated_query FROM V_CATALOG.DIRECTED_QUERIES WHERE query_name = 'getStoreSales';
-[ RECORD 1 ]---+------
query_name      | getStoreSales
annotated_query | SELECT /*+ syntactic_join,verbatim*/ sales.store_key AS store_key, stores.store_name AS store_name, sales.product_description AS product_description, sales.sales_quantity AS sales_quantity, sales.sale_date AS sale_date
FROM (store.storeSales AS sales/*+projs('store.storeSales')*/ JOIN /*+Distrib(L,L),JType(H)*/ store.store_dimension AS stores/*+projs('store.store_dimension_DBD_10_rep_VMartDesign')*/  ON (sales.store_key = stores.store_key))
WHERE (sales.sale_date = '2014-12-01'::date /*+IgnoreConst(1)*/) AND (stores.store_name = 'Store1'::varchar(6) /*+IgnoreConst(2)*/)
ORDER BY 1 ASC, 5 ASC

当优化器使用此定向查询时，将生成一个查询计划，该查询计划与其生成此定向查询时所使用的查询计划相等同：

=> ACTIVATE DIRECTED QUERY getStoreSales;
ACTIVATE DIRECTED QUERY

=> EXPLAIN SELECT sales.store_key, stores.store_name, sales.product_description, sales.sales_quantity, sales.sale_date FROM store.storesales sales JOIN store.store_dimension stores ON sales.store_key=stores.store_key WHERE sales.sale_date='2014-12-04' AND stores.store_name='Store14' ORDER BY sales.store_key, sales.sale_date;

 QUERY PLAN DESCRIPTION:
 ------------------------------

 EXPLAIN SELECT sales.store_key, stores.store_name, sales.product_description, sales.sales_quantity, sales.sale_date FROM store.storesales sales JOIN store.store_dimension stores ON sales.store_key=stores.store_key WHERE sales.sale_date='2014-12-04' AND stores.store_name='Store14' ORDER BY sales.store_key, sales.sale_date;

 The following active directed query(query name: getStoreSales) is being executed:
 SELECT /*+syntactic_join,verbatim*/ sales.store_key, stores.store_name, sales.product_description, sales.sales_quantity, sales.sale_date
FROM (store.storeSales sales/*+projs('store.storeSales')*/ JOIN /*+Distrib('L', 'L'), JType('H')*/store.store_dimension stores
/*+projs('store.store_dimension_DBD_10_rep_VMartDesign')*/ ON ((sales.store_key = stores.store_key))) WHERE ((sales.sale_date = '2014-12-04'::date)
AND (stores.store_name = 'Store14'::varchar(7))) ORDER BY sales.store_key, sales.sale_date

 Access Path:
 +-JOIN HASH [Cost: 463, Rows: 622 (NO STATISTICS)] (PATH ID: 2)
 |  Join Cond: (sales.store_key = stores.store_key)
 |  Materialize at Output: sales.sale_date, sales.sales_quantity, sales.product_description
 |  Execute on: All Nodes
 | +-- Outer -> STORAGE ACCESS for sales [Cost: 150, Rows: 155K (NO STATISTICS)] (PATH ID: 3)
 | |      Projection: store.storeSales_b0
 | |      Materialize: sales.store_key
 | |      Filter: (sales.sale_date = '2014-12-04'::date)
 | |      Execute on: All Nodes
 | |      Runtime Filter: (SIP1(HashJoin): sales.store_key)
 | +-- Inner -> STORAGE ACCESS for stores [Cost: 35, Rows: 2] (PATH ID: 4)
 | |      Projection: store.store_dimension_DBD_10_rep_VMartDesign_node0001
 | |      Materialize: stores.store_name, stores.store_key
 | |      Filter: (stores.store_name = 'Store14')
 | |      Execute on: All Nodes

自定义定向查询

只有当您为定向查询编写的带注释查询中显式包含 VERBATIM 提示时，自定义定向查询才会包含该提示。当优化器使用该定向查询时，会遵循 VERBATIM 提示，相应地创建查询计划。

如果您在创建自定义定向查询时忽略了 VERBATIM 提示，则不会将该提示与带注释查询一起存储起来。当优化器使用该定向查询时，会将其自身的计划开发处理应用于带注释查询，然后再生成查询计划。相比于此查询计划，若优化器针对创建定向查询时所使用的 Vertica 版本生成查询计划，则后者可能与之不等同。

3 - 数据类型

下表汇总了 Vertica 支持的内部数据类型。其中还显示了投影中 NULL 值的默认放置方式。“大小”列列出未压缩的字节数。

3.1 - 二进制数据类型（BINARY 和 VARBINARY）

存储原始字节数据，如 IP 地址，最多 65000 个字节。BINARY 和 BINARY VARYING (VARBINARY) 数据类型统称为二进制字符串类型，其值称为二进制字符串。二进制字符串是八位字节或字节序列。

BYTEA 和 RAW 是 VARBINARY 的同义词。

语法

BINARY ( length )

{ VARBINARY | BINARY VARYING | BYTEA | RAW } ( max-length )

实参

BINARY 和 VARBINARY 数据类型

BINARY 和 VARBINARY 数据类型具有以下属性：

  • BINARY：一个固定宽度的 length 字节字符串，其中字节数声明为类型的可选说明符。如果忽略 length，默认值为 1。必要时，值将向右扩展到包含零字节的列的全宽。例如：

    => SELECT TO_HEX('ab'::BINARY(4));
  to_hex
----------
 61620000

  • VARBINARY：一个宽度可变的字符串，可扩展到 max-length 字节长度，其中最大字节数声明为类型的可选说明符。默认值是默认的属性大小，即 80，最大长度为 65000 个字节。VARBINARY 值不会扩展到列的全宽。例如：

    => SELECT TO_HEX('ab'::VARBINARY(4));
 to_hex
--------
 6162

输入格式

使用二进制值时，可以使用多种格式。十六进制格式通常最简单，Vertica 文档中也曾强调过。

二进制值也可以通过在值前加上反斜杠 '\\' 以八进制格式表示。

也可以输入用可打印字符表示的值。例如，十六进制值 '0x61' 也可以用符号 a 来表示。

请参阅数据加载。

输入时，字符串将从

这两个函数都使用 VARCHAR 实参并返回 VARBINARY 值。

输出格式

和输入格式一样，输出格式是八进制代码和可打印的 ASCII 字符的组合。在可打印的 ASCII 字符范围（范围 [0x20, 0x7e]）内的字节由相应的 ASCII 字符表示，反斜杠 ('\\') 除外，反斜杠可以转义为 '\\\'。所有其他字节值由相应的八进制值表示。例如，字节 {97,92,98,99}，在 ASCII 中为 {a,\\,b,c}，转换成文本后为 'a\\\bc'。

二元运算符和函数

二元运算符 &、~、|和 # 针对二进制数据类型采取特殊的行为，如位运算符中所述。

二进制数据类型支持以下聚合函数：

BIT_AND、BIT_OR 和 BIT_XOR 是应用于组中每个非空值的位元运算，而 MAX 和 MIN 是二进制值的逐字节比较。

和对应的二元运算符一样，如果组中的值长度不同，聚合函数会通过用零字节将较短的值扩展到列的全宽，按照长度相等的值来处理这些值。例如，假定一个组包含值 'ff', null, and 'f'，二元聚合会忽略 null 值，并值 'f' 视为 'f0'。此外，和对应的二元运算符一样，这些聚合函数会显式处理 VARBINARY 类型并通过转换隐式处理 BINARY 类型。请参阅数据类型强制运算符 (CAST)。

二进制与字符数据类型

BINARY 和 VARBINARY 二进制类型分别类似于 CHAR 和 VARCHAR 字符数据类型。它们的区别如下：

  • 二进制数据类型包含字节串（八位字节或字节序列）。

  • 字符数据类型包含字符串（文本）。

  • 二进制数据类型的长度以字节为单位，而字符数据类型的长度以字符为单位。

示例

以下示例显示 HEX_TO_BINARY 和 TO_HEX 的用法。

表 t 及其投影用二进制列创建：

=> CREATE TABLE t (c BINARY(1));
=> CREATE PROJECTION t_p (c) AS SELECT c FROM t;

插入最小字节值和最大字节值：

=> INSERT INTO t values(HEX_TO_BINARY('0x00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFF'));

然后可以在输出时使用 TO_HEX 函数用十六进制设置二进制值的格式：

=> SELECT TO_HEX(c) FROM t;
 to_hex
 --------
  00
  ff
 (2 rows)

BIT_AND、BIT_OR 和 BIT_XOR 函数在处理一组值时很有用。例如，创建一个包含二进制列的示例表和投影：

示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：

=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));

查询表 t 以查看列 c 输出：

=> SELECT TO_HEX(c) FROM t;
 TO_HEX
--------
 ff00
 ffff
 f00f
(3 rows)

现在发出位元 AND 运算。因为这些都是聚合函数，因此使用 (ff00&(ffff)&f00f) 对结果执行隐式 GROUP BY 操作：

=> SELECT TO_HEX(BIT_AND(c)) FROM t;
 TO_HEX
--------
f000
(1 row)

对 (ff00|(ffff)|f00f) 发出位元 OR 运算：

=> SELECT TO_HEX(BIT_OR(c)) FROM t;
 TO_HEX
--------
ffff
(1 row)

对 (ff00#(ffff)#f00f) 发出位元 XOR 运算：

=> SELECT TO_HEX(BIT_XOR(c)) FROM t;
 TO_HEX
--------
f0f0
(1 row)

3.2 - 布尔数据类型

Vertica 提供标准 SQL 类型 BOOLEAN，它有两种状态：true 与 false。SQL 布尔逻辑中的第三种状态是未知，由 NULL 值表示。

语法

BOOLEAN

参数

用于输入的有效字面量数据值如下：

注意

  • 不要将 BOOLEAN 数据类型与 布尔运算符 或 布尔谓词 相混淆。

  • 关键字 TRUE 和 FALSE 是首选项且兼容 SQL。

  • NULL 布尔值按升序显示在最后（最大）。

  • 所有其他值必须用单引号引起来。

  • 布尔值是使用字母 t 和 f 的输出。

另请参阅

3.3 - 字符数据类型（CHAR 和 VARCHAR）

存储由字母、数字和符号组成的字符串。数据类型 CHARACTER (CHAR) 和 CHARACTER VARYING (VARCHAR) 统称为字符串类型，而字符串类型的值称为字符串。

字符数据可以存储为固定长度或可变长度的字符串。固定长度的字符串在输出时通过空格向右扩展；可变长度的字符串不能扩展。

SQL 语句中的字符串字面量必须以单引号引起。

语法

{ CHAR | CHARACTER } [ (octet‑length) ]

{ VARCHAR | CHARACTER VARYING ] } [ (octet‑length) ]

实参

CHAR 与 VARCHAR 数据类型

以下差异适用于 CHAR 和 VARCHAR 数据：

  • CHAR 在概念上是固定长度、填充空格式字符串。结尾空格将在输入时移除，并且在输出时还原。默认长度为 1，最大长度为 65000 个八位字节（字节）。

  • VARCHAR 是可变长度的字符数据类型。默认长度为 80，最大长度为 65000 个八位字节。对于长于 65000 的字符串值，使用 长数据类型。值可以包括结尾空格。

通常，您对所有字符串数据使用 VARCHAR。在需要固定宽度的字符串输出时，请使用 CHAR。例如，对于要传输到需要固定宽度字符串的旧系统的数据，可以使用 CHAR 列。

设置最大长度

在您定义字符列时，请指定要存储在某一列中的任何字符串的最大大小。例如，要存储最大长度为 24 个八位字节的字符串，请使用以下定义之一：

CHAR(24)    --- fixed-length
VARCHAR(24) --- variable-length

VARCHAR 和 CHAR 数据类型的最大长度参数是指可存储在该字段中的八位字节数，而不是字符数（Unicode 代码点）。在使用多字节 UTF-8 字符时，必须根据数据将字段大小调整为每个字符能够容纳 1 至 4 个八位字节。如果加载到 VARCHAR 或 CHAR 列中的数据超过了为该列指定的最大大小，将根据 UTF-8 字符边界截断数据，以符合指定大小。请参阅 COPY。

由于 Vertica 中的压缩，导致过高估计这些字段的长度产生成本，主要是在加载时和排序期间产生成本。

NULL 与 NUL

NULL 和 NUL 区别如下：

  • NUL 表示其 ASCII/Unicode 代码为 0 的字符，有时限定为“ASCII NUL”。

  • NULL 是指没有值，字段（列）或常数皆是如此，字符却不。

CHAR、LONG VARCHAR 和 VARCHAR 字符串数据类型接受 ASCII NUL 值。

在升序排序中，NULL 出现在最后（最大）。

有关 NULL 排序的更多信息，请参阅 NULL 排序顺序。

以下示例将包含 NUL 值的输入字符串转换为 VARCHAR：

=> SELECT 'vert\0ica'::CHARACTER VARYING AS VARCHAR;
 VARCHAR
---------
 vert\0ica
(1 row)

结果包含 9 个字符：

=> SELECT LENGTH('vert\0ica'::CHARACTER VARYING);
 length
--------
      9
(1 row)

如果您使用扩展字符串字面量，则长度为 8 个字符：

=> SELECT E'vert\0ica'::CHARACTER VARYING AS VARCHAR;
 VARCHAR
---------
 vertica
(1 row)
=> SELECT LENGTH(E'vert\0ica'::CHARACTER VARYING);
 LENGTH
--------
      8
(1 row)

3.4 - 日期/时间数据类型

Vertica 支持全套 SQL 日期和时间数据类型。

以下规则适用于所有日期/时间数据类型：

  • 所有类型的大小均为 8 字节。

  • 相对于所有其他日期/时间值，日期/时间值 NULL 是最小的。

  • 基于一年的平均长度为 365.2425 天这一假设，Vertica 使用儒略日期进行所有日期/时间计算，可正确预测和计算任何日期，从早于 4713 BC 到很远的未来。

  • 所有的日期/时间数据类型均支持使用特殊字面量值 NOW 来指定当前日期和时间。例如：

    => SELECT TIMESTAMP 'NOW';
         ?column?
---------------------------
 2020-09-23 08:23:50.42325
(1 row)

  • 默认情况下，Vertica 舍入的最大精度为六位小数。可以用 0 到 6 之间的整数替换 p 以指定首选的精度级别。。

下表列出了日期/时间数据类型的特定属性：

输入的时区缩写

Vertica 将 /opt/vertica/share/timezonesets 中的文件识别为日期/时间输入值并定义 AT TIME ZONE zone 参数中接受的默认字符串列表。这些名称不一定用于日期/时间输出，输出使用当前所选时区参数设置相关的正式时区缩写。

3.4.1 - DATE

由月、日和年组成。

语法

DATE

参数/限制

有关排序的信息，请参阅 SET DATESTYLE。

3.4.2 - DATETIME

DATETIME 是 TIMESTAMP/TIMESTAMPTZ 的别名。

3.4.3 - INTERVAL

表示两个时间点之间的时间差。间隔可以是正，也可以是负。INTERVAL 数据类型符合 SQL:2008 标准，并支持拆分为两个主要子类型的间隔限定符：

  • 年-月：年和月的时间范围

  • 天-时间：以天、小时、分钟、秒以及毫秒为单位的时间跨度

间隔在内部表示为若干微秒，印刷为多达 60 秒钟、60 分钟、24 小时、30 天、12 个月，以及需要的年数。您可以使用 SET INTERVALSTYLE 和 SET DATESTYLE 来控制间隔单位的输出格式。

语法

INTERVAL 'interval-literal' [ interval-qualifier ] [ (p) ]

参数

限制

3.4.3.1 - 设置间隔单位显示

SET INTERVALSTYLE 和 SET DATESTYLE 控制间隔单位的输出格式。

省略间隔单位

要从输出中省略间隔单位，请将 INTERVALSTYLE 设置为 PLAIN。这是默认设置，符合 SQL:2008 标准：

=> SET INTERVALSTYLE TO PLAIN;
SET
=> SELECT INTERVAL '3 2';
?column?
----------
 3 02:00

当 INTERVALSTYLE 设置为 PLAIN 时，输出中会省略单位，即使查询指定了输入单位：

=> SELECT INTERVAL '3 days 2 hours';
 ?column?
----------
 3 02:00

如果 DATESTYLE 设置为 SQL，则 Vertica 符合 SQL:2008 标准，并始终从输出中省略间隔单位：


=> SET DATESTYLE TO SQL;
SET
=> SET INTERVALSTYLE TO UNITS;
SET
=> SELECT INTERVAL '3 2';
 ?column?
----------
 3 02:00

显示间隔单位

要启用间隔单位的显示，必须将 DATESTYLE 设置为 ISO。然后，您可以通过将 INTERVALSTYLE 设置为 UNITS 来显示间隔单位：


=> SET DATESTYLE TO ISO;
SET
=> SET INTERVALSTYLE TO UNITS;
SET
=> SELECT INTERVAL '3 2';
 ?column?
----------------
 3 days 2 hours

检查 INTERVALSTYLE 和 DATESTYLE 设置

使用 SHOW 语句检查 INTERVALSTYLE 和 DATESTYLE 设置：

=> SHOW INTERVALSTYLE;
     name      | setting
---------------+---------
 intervalstyle | units
=> SHOW DATESTYLE;
   name    | setting
-----------+----------
 datestyle | ISO, MDY

3.4.3.2 - 指定间隔输入

间隔值通过字面量类时间间隔表示。字面量类时间间隔由一个或多个间隔字段组成，其中每个字段代表天和时间或年和月的时间范围，如下所示：

[-] { quantity subtype-unit }[...] [AGO]

使用子类型单位

子类型单位对于天-时间间隔是可选的；而对于年-月间隔则必须指定。

例如，下面的第一个语句隐式指定了天和时间；第二个语句显式标识天和时间单位。两个语句都返回相同的结果：


=> SET INTERVALSTYLE TO UNITS;
=> SELECT INTERVAL '1 12:59:10:05';
      ?column?
--------------------
 1 day 12:59:10.005
(1 row)

=> SELECT INTERVAL '1 day 12 hours 59 min 10 sec 5 milliseconds';
      ?column?
--------------------
 1 day 12:59:10.005
(1 row)

以下两个语句分别将 28 天和 4 周添加到当前日期。两种情况下的间隔相等，并且语句返回相同的结果。但是，在第一个语句中，字面量类时间间隔省略了子类型（隐式 days）；在第二个语句中，字面量类时间间隔必须包含子类型单位 weeks：

=> SELECT CURRENT_DATE;
  ?column?
------------
 2016-08-15
(1 row)

=> SELECT CURRENT_DATE + INTERVAL '28';
      ?column?
---------------------
 2016-09-12 00:00:00
(1 row)

dbadmin=> SELECT CURRENT_DATE + INTERVAL '4 weeks';
      ?column?
---------------------
 2016-09-12 00:00:00
(1 row)

字面量类时间间隔可以包括天-时间和年-月字段。例如，以下语句将 4 年、4 周、4 天和 14 小时的间隔添加到当前日期。年和周字段必须包含子类型单位；天和小时字段则将其省略：

> SELECT CURRENT_DATE + INTERVAL '4 years 4 weeks 4 14';
      ?column?
---------------------
 2020-09-15 14:00:00
(1 row)

省略子类型单位

您可以指定天、小时、分钟和秒的数量，无需指定单位。Vertica 将字面量类时间间隔中的冒号识别为时间戳的一部分：

=> SELECT INTERVAL '1 4 5 6';
 ?column?
------------
 1 day 04:05:06
=> SELECT INTERVAL '1 4:5:6';
 ?column?
------------
 1 day 04:05:06
=> SELECT INTERVAL '1 day 4 hour 5 min 6 sec';
 ?column?
------------
 1 day 04:05:06

如果 Vertica 无法确定单位，它会根据间隔限定符将该数量应用于缺失单位。在接下来的两个示例中，Vertica 使用默认间隔限定符 (DAY TO SECOND(6)) 并将尾数 1 分配给天，因为它已经在输出中处理了小时、分钟和秒：

=> SELECT INTERVAL '4:5:6 1';
 ?column?
------------
 1 day 04:05:06
=> SELECT INTERVAL '1 4:5:6';
 ?column?
------------
 1 day 04:05:06

在接下来的两个示例中，Vertica 将 4:5 识别为 hours:minutes。将字面量类时间间隔中的剩余值分配给缺失单位： 1 分配给天，而 2 分配给秒。

SELECT INTERVAL '4:5 1 2';
  ?column?
------------
 1 day 04:05:02
=> SELECT INTERVAL '1 4:5 2';
 ?column?
------------
 1 day 04:05:02

指定间隔限定符可以改变 Vertica 解释 4:5 的方式：

=> SELECT INTERVAL '4:5' MINUTE TO SECOND;
  ?column?
------------
 00:04:05

3.4.3.3 - 控制间隔格式

间隔限定符指定 Vertica 用来解释和格式化字面量类时间间隔的一系列选项。间隔限定符也可以指定精度。每个间隔限定符由一个或两个单位组成：

unit[p] [ TO unit[p] ]

其中：

  • 单位指定天-时间或年-月子类型。

  • p 指定精度，0 到 6 之间的整数。通常，精度仅适用于 SECOND 单位。SECOND 的默认精度为 6。有关详细信息，请参阅指定时间间隔精度。

如果间隔省略了间隔限定符，Vertica 将使用默认值 DAY TO SECOND(6)。

间隔限定符类别

间隔限定符属于以下类别之一：

  • 年-月：年和月的时间范围

  • 天-时间：以天、小时、分钟、秒以及毫秒为单位的时间跨度

年-月

Vertica 支持两种年-月子类型： YEAR 和 MONTH。

在以下示例中，YEAR TO MONTH 限定字面量类时间间隔 1 2 以指示时间范围为 1 年零两个月：

=> SELECT interval '1 2' YEAR TO MONTH;
 ?column?
----------
 1-2
(1 row)

如果省略限定符，Vertica 将使用默认间隔限定符 DAY TO SECOND 并返回不同的结果：

=> SELECT interval '1 2';
 ?column?
----------
 1 02:00
(1 row)

以下示例使用间隔限定符 YEAR。在这种情况下，Vertica 仅从字面量类时间间隔 1y 10m 中提取年份：

=> SELECT INTERVAL '1y 10m' YEAR;
 ?column?
----------
 1
(1 row)

在下一个示例中，间隔限定符 MONTH 将相同的字面量类时间间隔转换为月份：

=> SELECT INTERVAL '1y 10m' MONTH;
 ?column?
----------
 22
(1 row)

天-时间

Vertica 支持四种天-时间子类型：DAY、HOUR、MINUTE 和 SECOND。

在以下示例中，间隔限定符 DAY TO SECOND(4) 限定字面量类时间间隔 1h 3m 6s 5msecs 57us。限定符还将秒的精度设置为 4：

=> SELECT INTERVAL '1h 3m 6s 5msecs 57us' DAY TO SECOND(4);
   ?column?
---------------
 01:03:06.0051
(1 row)

如果未指定间隔限定符，则 Vertica 将使用默认子类型 DAY TO SECOND(6)，无论您如何指定字面量类时间间隔。例如，作为 SQL:2008 的扩展，以下两个命令都将返回 91days：

=> SELECT INTERVAL '2-6';
    ?column?
-----------------
 910
=> SELECT INTERVAL '2 years 6 months';
 ?column?
-----------------
 910

间隔限定符可以从输入参数中提取其他值。例如，以下命令从字面量类时间间隔 3 days 2 hours 中提取 HOUR 值：

=> SELECT INTERVAL '3 days 2 hours' HOUR;
 ?column?
----------
 74

主要的天/时间 (DAY TO SECOND) 和年/月 (YEAR TO MONTH) 子类型范围可以通过间隔限定符限制为更具体的类型范围。例如，HOUR TO MINUTE 是天/时间间隔的有限形式，可用于表示时区偏移量。

=> SELECT INTERVAL '1 3' HOUR to MINUTE;
 ?column?
---------------
 01:03

hh:mm:ss 和 hh:mm 格式仅在间隔限定符中指定的至少两个字段非零且不超过 23 小时或 59 分钟时使用：

=> SELECT INTERVAL '2 days 12 hours 15 mins' DAY TO MINUTE;
  ?column?
--------------
 2 12:15
=> SELECT INTERVAL '15 mins 20 sec' MINUTE TO SECOND;
 ?column?
----------
 15:20
=> SELECT INTERVAL '1 hour 15 mins 20 sec' MINUTE TO SECOND;
 ?column?
-----------------
 75:20

3.4.3.4 - 指定时间间隔精度

通常，时间间隔精度仅适用于秒。如果未明确指定精度，则 Vertica 将精度四舍五入到最多六位小数。例如：

=> SELECT INTERVAL '2 hours 4 minutes 3.709384766 seconds' DAY TO SECOND;
    ?column?
-----------------
 02:04:03.709385
(1 row)

Vertica 允许您通过两种方式指定时间间隔精度：

  • 在 INTERVAL 关键字之后

  • 在时间间隔限定符的 SECOND 单元之后，指定以下之一：

    • DAY TO SECOND

    • HOUR TO SECOND

    • MINUTE TO SECOND

    • SECOND

例如，以下语句使用全部两种方法来设置精度，并返回相同的结果：

=> SELECT INTERVAL(4) '2 hours 4 minutes 3.709384766 seconds' DAY TO SECOND;
   ?column?
---------------
 02:04:03.7094
(1 row)

=> SELECT INTERVAL '2 hours 4 minutes 3.709384766 seconds' DAY TO SECOND(4);
   ?column?
---------------
 02:04:03.7094
(1 row)

如果同一语句多次指定精度，则 Vertica 使用较低的精度。例如，以下语句指定两次精度：INTERVAL 关键字指定精度 1，时间间隔限定符 SECOND 指定精度 2。Vertica 使用较低的精度 1：

=> SELECT INTERVAL(1) '1.2467' SECOND(2);
 ?column?
----------
 1.2 secs

设置时间间隔表列的精度

如果创建具有时间间隔列的表，则以下限制适用于列定义：

  • 仅当您不指定时间间隔限定符时，才能在 INTERVAL 关键字上设置精度。如果您尝试在 INTERVAL 关键字上设置精度并包含时间间隔限定符，则 Vertica 返回错误。

  • 您只能在时间间隔限定符的最后一个单元上设置精度。例如：

    CREATE TABLE public.testint2
(
    i INTERVAL HOUR TO SECOND(3)
);

    如果您在另一个单元上指定精度，Vertica 会在保存表定义时将其丢弃。

3.4.3.5 - 间隔单位的小数秒

Vertica 支持以毫秒为单位的时间间隔 (hh:mm:ss:ms)，其中 01:02:03:25 表示 1 小时、2 分钟、3 秒和 025 毫秒。毫秒转换为小数秒，如下例所示，返回 1 天、2 小时、3 分钟、4 秒和 25.5 毫秒：

=> SELECT INTERVAL '1 02:03:04:25.5';
  ?column?
------------
 1 day 02:03:04.0255

Vertica 允许使用小数分钟。小数分钟四舍五入为秒：

=> SELECT INTERVAL '10.5 minutes';
  ?column?
------------
 00:10:30
=> select interval '10.659 minutes';
  ?column?
-------------
 00:10:39.54
=> select interval '10.3333333333333 minutes';
 ?column?
----------
 00:10:20

考量

  • INTERVAL 只能包含您需要的单位子集；但是，年/月间隔表示没有固定天数的日历年和月，因此年/月间隔值不能包括天、小时、分钟。当为天/时间间隔指定年/月值时，间隔扩展假定每月 30 天，每年 365 天。由于给定月份或年份的长度会有所不同，因此天/时间间隔永远不会以月或年的形式输出，而只会以天、小时、分钟等形式输出。

  • 天/时间和年/月间隔在逻辑上是相互独立的，不能相互组合或相互比较。在以下示例中，包含 DAYS 的字面量类时间间隔不能与 YEAR TO MONTH 类型组合：

    => SELECT INTERVAL '1 2 3' YEAR TO MONTH;
ERROR 3679:  Invalid input syntax for interval year to month: "1 2 3"

  • Vertica 接受最多 2^63 – 1 微秒或月（约 18 位）的时间间隔。

  • INTERVAL YEAR TO MONTH 可在分析 RANGE 窗口中使用，其条件是当 ORDER BY 列类型为 TIMESTAMP/TIMESTAMP WITH TIMEZONE 或 DATE 时。不支持使用 TIME/TIME WITH TIMEZONE。

  • 当 ORDER BY 列类型为 TIMESTAMP/TIMESTAMP WITH TIMEZONE、DATE 和 TIME/TIME WITH TIMEZONE 时，您可以使用 INTERVAL DAY TO SECOND。

示例

此部分中的示例假设 INTERVALSTYLE 设置为 PLAIN，因此结果省略了子类型单位。省略间隔限定符的间隔值使用默认值 DAY TO SECOND(6)。

3.4.3.6 - 处理带符号的间隔

在 SQL:2008 标准中，字面量类时间间隔前的减号或作为字面量类时间间隔的第一个字符的减号会整个字面量为负，而不仅仅是第一个组件。在 Vertica 中，前导减号会使整个间隔为负，而不仅仅是第一个组件。以下命令都返回相同的值：

=> SELECT INTERVAL '-1 month - 1 second';
 ?column?
----------
 -29 days 23:59:59

=> SELECT INTERVAL -'1 month - 1 second';
 ?column?
----------
 -29 days 23:59:59

改为使用以下命令之一来返回预期结果：

=> SELECT INTERVAL -'1 month 1 second';
 ?column?
----------
 -30 days 1 sec
=> SELECT INTERVAL -'30 00:00:01';
 ?column?
----------
 -30 days 1 sec

两个负号叠加会返回一个正数：

=> SELECT INTERVAL -'-1 month - 1 second';
 ?column?
----------
 29 days 23:59:59
=> SELECT INTERVAL -'-1 month 1 second';
 ?column?
----------
 30 days 1 sec

您可以使用不带空格的年-月语法。Vertica 允许输入负数月份，但与年份配对时需要两个负数。

=> SELECT INTERVAL '3-3' YEAR TO MONTH;
 ?column?
----------
 3 years 3 months
=> SELECT INTERVAL '3--3' YEAR TO MONTH;
 ?column?
----------
 2 years 9 months

当字面量类时间间隔看起来像年/月类型，但类型是天/秒（反之亦然）时，Vertica 会从左到右读取字面量类时间间隔，而数字-数字是年-月，数字 <空格> <带符号的数字> 是指定的任何单位。Vertica 将以下命令处理为 (–) 1 年 1 个月 = (–) 365 + 30 = –395 天：

=> SELECT INTERVAL '-1-1' DAY TO HOUR;
 ?column?
----------
 -395 days

如果您在字面量类时间间隔中插入空格，Vertica 会根据子类型 DAY TO HOUR 对其进行处理：(–) 1 天 – 1 小时 = (–) 24 – 1 = –23 小时：

=> SELECT INTERVAL '-1 -1' DAY TO HOUR;
 ?column?
----------
 -23 hours

两个负号叠加会返回一个正数，因此 Vertica 将以下命令处理为 (–) 1 年 – 1 个月 = (–) 365 – 30 = –335 天：

=> SELECT INTERVAL '-1--1' DAY TO HOUR;
  ?column?
----------
 -335 days

如果省略连字符后的值，则 Vertica 假定 0 个月并将以下命令处理为 1 年 0 月 –1 天 = 365 + 0 – 1 = –364 天：

=> SELECT INTERVAL '1- -1' DAY TO HOUR;
  ?column?
----------
 364 days

3.4.3.7 - 间隔转换

您可以使用 CAST 将字符串转换为间隔，反之亦然。

字符串到间隔

您可以如下所示将字符串转换为间隔：

CAST( [ INTERVAL[(p)] ] [-] ] interval‑literal AS INTERVAL[(p)] interval‑qualifier )

例如：

=> SELECT CAST('3700 sec' AS INTERVAL);
 ?column?
----------
 01:01:40

您可以在日期-时间或年-月子类型中投射转换间隔，但不能在其之间转换：

=> SELECT CAST(INTERVAL '4440' MINUTE as INTERVAL);
  ?column?
----------
 3 days 2 hours
=> SELECT CAST(INTERVAL -'01:15' as INTERVAL MINUTE);
 ?column?
----------
 -75 mins

间隔到字符串

您可以如下所示将间隔转换为字符串：

CAST( (SELECT interval ) AS VARCHAR[(n)] )

例如：

=> SELECT CONCAT(
  'Tomorrow at this time: ',
  CAST((SELECT INTERVAL '24 hours') + CURRENT_TIMESTAMP(0) AS VARCHAR));
                    CONCAT
-----------------------------------------------
 Tomorrow at this time: 2016-08-17 08:41:23-04
(1 row)

3.4.3.8 - 间隔操作

如果用间隔除以间隔，您可以获得一个 FLOAT：

=> SELECT INTERVAL '28 days 3 hours' HOUR(4) / INTERVAL '27 days 3 hours' HOUR(4);
 ?column?
------------
 1.036866359447

FLOAT 除以 INTERVAL 会返回 INTERVAL：

=> SELECT INTERVAL '3' MINUTE / 1.5;
 ?column?
------------
 2 mins

INTERVAL MODULO （余数）INTERVAL 返回 INTERVAL：

=> SELECT INTERVAL '28 days 3 hours' HOUR % INTERVAL '27 days 3 hours' HOUR;
  ?column?
------------
 24 hours

如果添加 INTERVAL 和 TIME，则结果为 TIME，取模 24 小时：

=> SELECT INTERVAL '1' HOUR + TIME '1:30';
 ?column?
------------
 02:30:00

3.4.4 - SMALLDATETIME

SMALLDATETIME 是 TIMESTAMP/TIMESTAMPTZ 的别名。

3.4.5 - TIME/TIMETZ

存储一天中的指定时间。 TIMETZ 与 TIME WITH TIME ZONE 相同：两种数据类型都存储指定时间的 UTC 偏移量。

语法

TIME [ (p) ] [ { WITHOUT | WITH } TIME ZONE ] 'input‑string' [ AT TIME ZONE zone ]

参数

TIME 与 TIMETZ

TIMETZ 和 TIMESTAMPTZ 不是并行的 SQL 结构。 TIMESTAMPTZ 会记录从 转换的 GMT 时间和日期。TIME ZONE.TIMETZ 会以分钟数记录指定的时间和指定 GMT 时区。

限制

输入字符串

TIME 输入字符串可以设置为如下所示的任意格式：

数据类型强制转换

您可以将 TIME 或 TIMETZ 间隔转换为 TIMESTAMP。这将返回本地日期和时间，如下所示：

=> SELECT (TIME '3:01am')::TIMESTAMP;
       ?column?
---------------------
 2012-08-30 03:01:00
(1 row)

=> SELECT (TIMETZ '3:01am')::TIMESTAMP;
      ?column?
---------------------
 2012-08-22 03:01:00
(1 row)

将相同的 TIME 或 TIMETZ 间隔转换为 TIMESTAMPTZ，返回带 UTC 偏移量的本地日期和时间（在本例中为 -05）：

=> SELECT (TIME '3:01am')::TIMESTAMPTZ;
        ?column?
------------------------
 2016-12-08 03:01:00-05
(1 row)

3.4.6 - TIME AT TIME ZONE

将指定的 TIME 转换为另一个时区的时间。

语法

TIME [WITH TIME ZONE] 'input‑string' AT TIME ZONE 'zone'

参数

您可以通过两种方式指定时区：

  • 字符串字面量，例如 America/Chicago 或 PST

  • 指定 UTC 偏移量的时间间隔 — 例如， INTERVAL '‑08:00'

使用指示地理位置的字面量来指定时区通常是一种很好的做法。Vertica 会进行必要的季节性调整，从而避免结果不一致。例如，以下两个查询在夏令时生效时发出。因为白天的本地 UTC 偏移量是 ‑04，所以两个查询返回相同的结果：

=> SELECT CURRENT_TIME(0) "EDT";
     EDT
-------------
 12:34:35-04
(1 row)

=> SELECT CURRENT_TIME(0) AT TIME ZONE 'America/Denver' "Mountain Time";
 Mountain Time
---------------
 10:34:35-06
(1 row)
=> SELECT CURRENT_TIME(0) AT TIME ZONE INTERVAL '-06:00' "Mountain Time";
 Mountain Time
---------------
 10:34:35-06
(1 row)

如果您在标准时间生效时在类似查询中发出使用 UTC 偏移量，则必须相应调整 UTC 偏移量（对于丹佛时间，调整为 ‑07），否则 Vertica 会返回不同的（并且错误）结果：

=> SELECT CURRENT_TIME(0) "EST";
     EST
-------------
 14:18:22-05
(1 row)

=> SELECT CURRENT_TIME(0) AT TIME ZONE INTERVAL '-06:00' "Mountain Time";
 Mountain Time
---------------
 13:18:22-06
(1 row)

您可以分别使用 SHOW TIMEZONE 和 SET TIME ZONE 显示和设置会话的时区：

=> SHOW TIMEZONE;
   name   |     setting
----------+------------------
 timezone | America/New_York
(1 row)

=> SELECT CURRENT_TIME(0) "Eastern Daylight Time";
 Eastern Daylight Time
-----------------------
 12:18:24-04
(1 row)

=> SET TIMEZONE 'America/Los_Angeles';
SET

=> SELECT CURRENT_TIME(0) "Pacific Daylight Time";
 Pacific Daylight Time
-----------------------
 09:18:24-07
(1 row)

要查看默认的有效字面量列表，请参阅以下目录中的文件：

opt/vertica/share/timezonesets

例如：

$ cat Antarctica.txt
...
# src/timezone/tznames/Antarctica.txt
#

AWST    28800    # Australian Western Standard Time
                 #     (Antarctica/Casey)
                 #     (Australia/Perth)
...

NZST    43200    # New Zealand Standard Time
                 #     (Antarctica/McMurdo)
                 #     (Pacific/Auckland)
ROTT   -10800    # Rothera Time
                 #     (Antarctica/Rothera)
SYOT    10800    # Syowa Time
                 #     (Antarctica/Syowa)
VOST    21600    # Vostok time
                 #     (Antarctica/Vostok)

示例

以下示例假定本地时间为 EST（东部标准时间）。查询将指定时间转换为 MST（山地标准时间）：

=> SELECT CURRENT_TIME(0);
  timezone
-------------
 10:10:56-05
(1 row)

=> SELECT TIME '10:10:56' AT TIME ZONE 'America/Denver' "Denver Time";
 Denver Time
-------------
 08:10:56-07
(1 row)

下一个示例将时区字面量添加到输入字符串（在本例中为 Europe/Vilnius）并将时间转换为 MST：

=> SELECT TIME '09:56:13 Europe/Vilnius' AT TIME ZONE 'America/Denver';
 Denver Time
-------------
 00:56:13-07
(1 row)

另请参阅

3.4.7 - TIMESTAMP/TIMESTAMPTZ

存储指定的日期和时间。 TIMESTAMPTZ 与 TIMESTAMP WITH TIME ZONE 相同：两种数据类型都存储指定时间的 UTC 偏移量。

TIMESTAMP 是 DATETIME 和 SMALLDATETIME 的别名。

语法

TIMESTAMP [ (p) ] [ { WITHOUT | WITH } TIME ZONE ] 'input‑string' [AT TIME ZONE zone ]

TIMESTAMPTZ [ (p) ] 'input‑string' [ AT TIME ZONE zone ]

参数

限制

在下表中，所有值均为约略值。有关详细信息，请参阅日期/时间数据类型。

输入字符串

日期/时间输入字符串连接日期和时间。输入字符串可以包含一个时区，指定为诸如 America/Chicago 之类的字面量，或指定为 UTC 偏移量。

以下列表表示典型的日期/时间输入变体：

  • 1999-01-08 04:05:06

  • 1999-01-08 04:05:06 -8:00

  • January 8 04:05:06 1999 PST

输入字符串还可以指定日历年代，AD（默认）或 BC。如果您省略日历年代，则 Vertica 会假定当前日历年代 (AD)。日历年代通常遵循时区；但是，输入字符串可以将其包含在不同位置。例如，以下查询返回相同结果：

=> SELECT TIMESTAMP WITH TIME ZONE 'March 1, 44 12:00 CET BC ' "Caesar's Time of Death EST";
 Caesar's Time of Death EST
----------------------------
 0044-03-01 06:00:00-05 BC
(1 row)

=> SELECT TIMESTAMP WITH TIME ZONE 'March 1, 44 12:00 BC CET' "Caesar's Time of Death EST";
 Caesar's Time of Death EST
----------------------------
 0044-03-01 06:00:00-05 BC
(1 row)

示例

3.4.8 - TIMESTAMP AT TIME ZONE

将指定的 TIMESTAMP 或 TIMESTAMPTZ (TIMESTAMP WITH TIMEZONE) 转换为另一个时区。Vertica 以不同方式执行 AT TIME ZONE，具体取决于日期输入是 TIMESTAMP 还是 TIMESTAMPTZ。请参阅下面的 TIMESTAMP 与 TIMESTAMPTZ 行为。

语法

timestamp‑clause AT TIME ZONE 'zone'

参数

TIMESTAMP 与 TIMESTAMPTZ 行为

Vertica 如何解释 AT TIME ZONE 取决于日期输入是 TIMESTAMP 还是 TIMESTAMPTZ：

您可以通过两种方式指定时区：

  • 字符串字面量，例如 America/Chicago 或 PST

  • 指定 UTC 偏移量的时间间隔 — 例如， INTERVAL '‑08:00'

使用指示地理位置的字面量来指定时区通常是一种很好的做法。Vertica 会进行必要的季节性调整，从而避免结果不一致。例如，以下两个查询在夏令时生效时发出。因为白天的本地 UTC 偏移量是 ‑04，所以两个查询返回相同的结果：

=> SELECT TIMESTAMPTZ '2017-03-16 09:56:13' AT TIME ZONE 'America/Denver' "Denver Time";
     Denver Time
---------------------
 2017-03-16 07:56:13
(1 row)

=> SELECT TIMESTAMPTZ '2017-03-16 09:56:13' AT TIME ZONE INTERVAL '-06:00' "Denver Time";
     Denver Time
---------------------
 2017-03-16 07:56:13
(1 row)

如果您在标准时间生效时在类似查询中发出使用 UTC 偏移量，则必须相应调整 UTC 偏移量（对于丹佛时间，调整为 ‑07），否则 Vertica 会返回不同的（并且错误）结果：

=> SELECT TIMESTAMPTZ '2017-01-16 09:56:13' AT TIME ZONE 'America/Denver' "Denver Time";
     Denver Time
---------------------
 2017-0-16 07:56:13
(1 row)

=> SELECT TIMESTAMPTZ '2017-01-16 09:56:13' AT TIME ZONE INTERVAL '-06:00' "Denver Time";
     Denver Time
---------------------
 2017-01-16 08:56:13
(1 row)

您可以分别使用 SHOW TIMEZONE 和 SET TIME ZONE 显示和设置会话的时区：

=> SHOW TIMEZONE;
   name   |     setting
----------+------------------
 timezone | America/New_York
(1 row)

=> SELECT CURRENT_TIMESTAMP(0) "Eastern Daylight Time";
 Eastern Daylight Time
------------------------
 2017-03-20 12:18:24-04
(1 row)

=> SET TIMEZONE 'America/Los_Angeles';
SET

=> SELECT CURRENT_TIMESTAMP(0) "Pacific Daylight Time";
 Pacific Daylight Time
------------------------
 2017-03-20 09:18:24-07
(1 row)

要查看默认的有效字面量列表，请参阅以下目录中的文件：

opt/vertica/share/timezonesets

例如：

$ cat Antarctica.txt
...
# src/timezone/tznames/Antarctica.txt
#

AWST    28800    # Australian Western Standard Time
                 #     (Antarctica/Casey)
                 #     (Australia/Perth)
...

NZST    43200    # New Zealand Standard Time
                 #     (Antarctica/McMurdo)
                 #     (Pacific/Auckland)
ROTT   -10800    # Rothera Time
                 #     (Antarctica/Rothera)
SYOT    10800    # Syowa Time
                 #     (Antarctica/Syowa)
VOST    21600    # Vostok time
                 #     (Antarctica/Vostok)

另请参阅

3.5 - 长数据类型

存储数据高达 32000000 八位字节。Vertica 支持两种长数据类型：

  • LONG VARBINARY：可变长度的原始字节数据，如空间数据。 LONG VARBINARY 值不会扩展到整个列宽。

  • LONG VARCHAR：可变长度的字符串，如日志文件和非结构化数据。 LONG VARCHAR 值不会扩展到整个列宽。

仅当需要存储的数据超过 VARBINARY 和 VARCHAR 数据类型的最大大小 (65 KB) 时使用 LONG 数据类型。长数据可能包含非结构化数据、在线评论或邮件，或小的日志文件。

Flex 表具有默认的 LONG VARBINARY __raw__ 列，该列具有 NOT NULL 限制。有关详细信息，请参阅Flex 表。

语法

LONG VARBINARY [(max‑length)]

LONG VARCHAR [(octet‑length)]

参数

优化性能

为了 LONG 数据类型的最佳性能，Vertica 推荐您：

  • 将 LONG 数据类型用作仅存储容器；Vertica 支持对 LONG 数据类型的内容进行操作，但不支持 VARCHAR 和 VARBINARY 进行的所有操作。

  • 在可能情况下，使用 VARBINARY 和 VARCHAR 数据类型代替 LONG。 VARBINARY 和 VARCHAR 数据类型更灵活，且具有更广泛的操作。

  • 不要在 LONG 数据类型列上对投射进行排序、分段或分区。

  • 不要在任何 LONG VARBINARY 或 LONG VARCHAR 列上添加限制，例如主键。

  • 不要结合或聚类任何 LONG 数据类型列。

示例

下面的例子创建一个具有 user_comments 列的表 LONG VARCHAR，并在其中插入数据：

=> CREATE TABLE user_comments
                  (id INTEGER,
                  username VARCHAR(200),
                  time_posted TIMESTAMP,
                  comment_text LONG VARCHAR(200000));
=> INSERT INTO user_comments VALUES
                  (1,
                  'User1',
                  TIMESTAMP '2013-06-25 12:47:32.62',
                  'The weather tomorrow will be cold and rainy and then
                  on the day after, the sun will come and the temperature
                  will rise dramatically.');

3.6 - 数字数据类型

数字数据类型是存储在数据库列中的数字。这些数据类型通常按照下列方式分类：

  • 精确 数字类型，需要保存值的精度和标度。精确数字类型有 INTEGER、BIGINT、DECIMAL、NUMERIC、NUMBER 和 MONEY。

  • 近似 数字类型，需要保存值的精度，标度可浮动。近似数字类型有 DOUBLE PRECISION、FLOAT 和 REAL。

不支持从 INTEGER、FLOAT 和 NUMERIC 到 VARCHAR 的隐式转换。如果您需要该功能，可使用下列形式之一进行显式转换：

CAST(numeric-expression AS data-type)

numeric-expression::data-type

例如，您可以将浮点数转换为整数，如下所示：

=> SELECT(FLOAT '123.5')::INT;
 ?column?
----------
      124
(1 row)

字符串到数字的数据类型转换针对科学记数法、二进制记数法、十六进制和数字型字面量组合，接受带引号常数的格式：

  • 科学记数法:

    => SELECT FLOAT '1e10';
  ?column?
-------------
 10000000000
(1 row)

  • BINARY 缩放:

    => SELECT NUMERIC '1p10';
 ?column?
----------
     1024
(1 row)

  • 十六进制：

    => SELECT NUMERIC '0x0abc';
 ?column?
----------
     2748
(1 row)

3.6.1 - DOUBLE PRECISION (FLOAT)

Vertica 支持数字数据类型 DOUBLE PRECISION，此为 IEEE-754 8 位浮点类型，适用于大多数常规浮点运算。

语法

[ DOUBLE PRECISION | FLOAT | FLOAT(n) | FLOAT8 | REAL ]

参数

双精度是一种非精确、精度可变的数字类型。换言之，某些值无法精确表示，而是存储为近似值。因此，涉及双精度的输入和输出操作可能会有些许偏差。

  • 所有 DOUBLE PRECISION 数据类型都等同于 64 位 IEEE 浮点型。

  • FLOAT(n) 中的 n 必须介于 1 和 53 之间（包含），但始终使用 53 位小数。有关详细信息，请参阅 IEEE-754 标准。

  • 要进行精确的数字存储和计算（例如对于金钱），请使用 NUMERIC。

  • 浮点计算受限于底层处理器、操作系统和编译器的行为。

  • 比较两个浮点值是否相等，结果可能与预期不符。

  • 虽然 Vertica 在内部将十进制值视为 FLOAT，但如果将列定义为 FLOAT，则您无法从 ORC 和 Parquet 文件中读取十进制值。在这些格式中，FLOAT 和 DECIMAL 是不同的类型。

值

接受以下格式的浮点数据：

  • 前置空格（可选）

  • 加号 ("+") 或减号 ("-")（可选）

  • 十进制数、十六进制数、无穷大、NAN 或 NULL 值。

十进制数

十进制数由一组非空十进制数字序列组成，可能包含基点字符（小数点 "."），其后可跟十进制指数（可选）。十进制指数表示乘以 10 的若干次幂，其构成为：字母 E 或 e，后跟加号或减号（可选），之后跟一组非空十进制数字序列。

十六进制数

十六进制数由 "0x" 或 "0X" 后跟一组非空十六进制数字序列构成，可能包含基点字符，其后可跟二进制指数（可选）。二进制指数表示乘以 2 的若干次幂，其构成为：字母 "P" 或 "p" ，后跟加号或减号（可选），之后跟一组非空十进制数字序列。基点字符和二进制指数这两者必须至少出现一个。

无穷大

无穷大为 INF 或 INFINITY，表示忽略的情况。

NaN（非数值）

NaN 为 NAN（忽略的情况），其后可跟括在括号内的字符序列（可选）。字符串以实现相关的方式指定 NaN 的值。（在 x86 机器上，NAN 在 Vertica 内部表示为 0xfff8000000000000LL。）

将无穷大或 NAN 值作为常数写入 SQL 语句时，需加单引号。例如：

=> UPDATE table SET x = 'Infinity'

后面提供了 NaN 的一个示例。

=> SELECT CBRT('Nan'); -- cube root
 CBRT 
------
 NaN
(1 row)

=> SELECT 'Nan' > 1.0;
 ?column?
----------
 f
(1 row)

Null 值

Null 值的加载文件格式是用户定义的，如 COPY 命令中所述。Null 值在 Vertica 内部表示为 0x7fffffffffffffffLL。交互格式由 vsql 打印选项 null 控制。例如：

\pset null '(null)'

默认选项为不打印任何内容。

规则

  • -0 == +0

  • 1/0 = 无穷大

  • 0/0 == Nan

  • NaN != 任意值（甚至 NaN）

要搜索 NaN 列值，请使用以下谓词：

... WHERE column != column

这是必要的，因为根据定义，WHERE *column *= 'Nan' 不能为 true。

排序顺序（升序）

  • NAN

  • -Inf

  • 数字

  • +Inf

  • NULL

注意

  • NULL 按照升序在最后显示（最大值）。

  • 按照 IEEE 浮点标准，浮点数中的所有溢出均会生成 +/- 无穷大或 NaN。

3.6.2 - INTEGER

有符号的 8 字节 (64 位) 数据类型。

语法

[ INTEGER | INT | BIGINT | INT8 | SMALLINT | TINYINT ]

参数

INT、INTEGER、INT8、SMALLINT、TINYINT 以及 BIGINT 是针对同一种有符号 64 位整数数据类型的所有同义词。当不需要完整的 64 位时，可采用自动压缩技术来节省磁盘空间。

注意

  • 值的范围为 –2^63+1 到 2^63-1。

  • 2^63 = 9,223,372,036,854,775,808 (19 位数)。

  • –2^63 被保留，表示 NULL。

  • NULL 按升序最先显示（最小）。

  • Vertica 不具有显式 4 字节（32 位整数）或较小类型。Vertica 编码及自动压缩可以降低不足 64 位值的存储开销。

限制

  • JDBC 型 INTEGER 有 4 个字节，不受 Vertica 的支持。请改为使用 BIGINT。

  • Vertica 不支持 SQL/JDBC 型 NUMERIC、SMALLINT 或 TINYINT。

  • Vertica 不检查溢出（正或负），聚合函数 SUM() 除外。如果在使用 SUM 时遇到溢出问题，请使用 SUM_FLOAT() 将其转换为浮点。

另请参阅

数据类型强制转换表

3.6.3 - NUMERIC

数字数据类型存储定点数字数据。例如，价值 $123.45 可存储于 NUMERIC(5,2) 字段。请注意，第一个数字（精度）指定总位数。

语法

numeric‑type [ ( precision[, scale] ) ]

参数

默认精度和标度

NUMERIC、DECIMAL、NUMBER 和 MONEY 的默认精度和标度值不同：

支持的编码

Vertica 支持 数字数据类型的以下编码：

  • 精度 ≤ 18：AUTO、BLOCK_DICT、BLOCKDICT_COMP、COMMONDELTA_COMP、DELTAVAL、GCDDELTA 和 RLE

  • 精密 &gt；18：AUTO、BLOCK_DICT、BLOCKDICT_COMP、 RLE

有关详细信息，请参阅编码类型。

数字与整数和浮点数据类型

数字数据类型是存储具有特定精度和标度的值的精确数据类型，通过小数点前后的若干数字表示。这与 Vertica 整数和浮点数据类型形成对比：

  • DOUBLE PRECISION (FLOAT) 支持 ~15 数字、变指数，近似表示数字值。它可能不如 NUMERIC 数据类型精确。

  • INTEGER 支持 ~18 数字，仅限整数。

NUMERIC 数据类型是非整数常量的首选，因为其结果总是精确的。例如：

=> SELECT 1.1 + 2.2 = 3.3;
?column?
----------
 t
(1 row)

=>  SELECT 1.1::float + 2.2::float = 3.3::float;
 ?column?
----------
 f
(1 row)

数字操作

支持的数字操作如下：

  • NUMERIC 除数运算直接运行于数字值，不会转换为浮点数。运算结果具有至少 18 位，且四舍五入。

  • NUMERIC 模数运算（包括%）直接运行于数字值，不会转换为浮点数。结果与分子具有相同标度，无需四舍五入。

  • 一些使用数字数据类型复杂操作会导致隐式转换为 FLOAT。使用 SQRT、STDDEV、超越函数，例如 LOG 以及 TO_CHAR/TO_NUMBER 格式化时，结果总是 FLOAT。

示例

下面的一系列命令创建一个包含数字数据类型的表，并对数据执行一些数学运算。

=> CREATE TABLE num1 (id INTEGER, amount NUMERIC(8,2));

向表中插入一些值：

=> INSERT INTO num1 VALUES (1, 123456.78);

查询表：

=> SELECT * FROM num1;
  id  |  amount
------+-----------
    1 | 123456.78
(1 row)

下面的例子从表 num1 返回 NUMERIC 列、总数：

=> SELECT amount FROM num1;
  amount
-----------
 123456.78
(1 row)

下面的语法在总数上加一 (1)：

=> SELECT amount+1 AS 'amount' FROM num1;
  amount
-----------
 123457.78
(1 row)

下面的语法将总数列乘以 2：

=> SELECT amount*2 AS 'amount' FROM num1;
  amount
-----------
 246913.56
(1 row)

下面的语法为总数列返回负数：

=> SELECT -amount FROM num1;
?column?
------------
-123456.78
(1 row)

下面的语法返回总数实参的绝对值：

=> SELECT ABS(amount) FROM num1;
ABS
-----------
123456.78
(1 row)

下面的语法将 NUMERIC 总数转换为 FLOAT 数据类型：

=> SELECT amount::float FROM num1;
  amount
-----------
 123456.78
(1 row)

另请参阅

算数函数

3.6.4 - 数值数据类型溢出

Vertica 不检查溢出（正或负），聚合函数 SUM() 除外。如果在使用 SUM 时遇到溢出问题，请使用 SUM_FLOAT() 将其转换为浮点。

有关在将函数 SUM、SUM_FLOAT 和 AVG 用于数值数据类型时 Vertica 如何处理溢出的详细讨论，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。讨论中包括关于关闭静默数值溢出和设置数值数据类型精度的指令。 除以零会返回错误：

=> SELECT 0/0;
ERROR 3117:  Division by zero

=> SELECT 0.0/0;
ERROR 3117:  Division by zero

=> SELECT 0 // 0;
ERROR 3117:  Division by zero

=> SELECT 200.0/0;
ERROR 3117:  Division by zero

=> SELECT 116.43 // 0;
ERROR 3117:  Division by zero

将作为 FLOAT 的零除以零会返回 NaN：

=> SELECT 0.0::float/0;
 ?column?
----------
      NaN
=> SELECT 0.0::float//0;
 ?column?
----------
      NaN

将非零 FLOAT 除以零会返回 Infinity：

=> SELECT 2.0::float/0;
 ?column?
----------
Infinity
=> SELECT 200.0::float//0;
?column?
----------
Infinity

加法、减法和乘法运算忽略溢出。求和运算和求平均运算在内部使用 128 位算术。SUM() 会在最终结果溢出时报错，并建议使用 SUM_FLOAT(INT)，将 128 位总和转换为 FLOAT。例如：

=> CREATE TEMP TABLE t (i INT);
=> INSERT INTO t VALUES (1<<62);
=> INSERT INTO t VALUES (1<<62);
=> INSERT INTO t VALUES (1<<62);
=> INSERT INTO t VALUES (1<<62);
=> INSERT INTO t VALUES (1<<62);
=> SELECT SUM(i) FROM t;
   ERROR: sum() overflowed
   HINT: try sum_float() instead
=> SELECT SUM_FLOAT(i) FROM t;
     SUM_FLOAT
---------------------
 2.30584300921369e+19

3.6.5 - SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出

使用具有 NUMERIC 数据类型的函数 SUM、SUM_FLOAT 和 AVG 时，请注意可能会发生溢出以及 Vertica 如何响应溢出。

此讨论适用于聚合函数和分析函数。

对于查询，当使用具有 NUMERIC 数据类型的函数 SUM、SUM_FLOAT 和 AVG 时，如果超出指定的精度，Vertica 允许静默溢出。

将 SUM 或 SUM_FLOAT 函数与 LAP 一起使用时，Vertica 也允许数字溢出。

默认溢出处理

对于 NUMERIC 数据类型，Vertica 在内部使用 18 位数的倍数。如果您指定的精度小于 18（例如，x(12,0)），Vertica 允许溢出，最多包括 18 的第一个倍数。在某些情况下，如果对列 (SUM(x)) 求和，则可能会超过 Vertica 内部为结果保留的位数。在这种情况下，Vertica 允许静默溢出。

关闭静默数字溢出

您可以关闭静默数字溢出，并指示 Vertica 隐式包含额外的数字位数。通过指定额外的空格，Vertica 可以一致地返回预期结果，即使超出 DDL 中指定的精度。

您可以通过将参数 AllowNumericOverflow 设置为 0 (false) 来关闭静默数字溢出。

当您将该参数设置为 0 时，Vertica 会考虑相应参数 NumericSumExtraPrecisionDigits 的值。

NumericSumExtraPrecisionDigits 参数默认为 6，这意味着 Vertica 在内部添加了超出 DDL 指定精度的六位。添加额外的精度位数可让 Vertica 一致地返回溢出 DDL 指定精度的结果。但是，在内部超出 18 的第二个倍数可能会对性能产生影响。

示例：

  • 假设您的 DDL 指定 11（例如，x(11,0)），并且您接受默认值 NumericSumExtraPrecisionDigits (6)。在这种情况下，Vertica 在内部保持在 18 位数的第一个倍数内，不会产生额外的性能影响。

  • 在相同的示例中，如果将 NumericSumExtraPrecisionDigits 设置为 10，Vertica 会在内部超出阈值，进入 18 的第二个倍数。在性能方面，如果（假设）第一个示例是性能“a”，则第二个示例是“2a”，这大大增加了性能影响。超过 18 的第二个倍数后，性能影响仍然是“2a”。

此示例表示法显示，当您将 AllowNumericOverflow 设置为 0 (false) 时 Vertica 如何在内部做出响应。

如果您希望超过 DDL 中指定的精度，Vertica 建议您关闭静默数字溢出，并设置参数 NumericSumExtraPrecisionDigits。进入 18 的第二个倍数会影响性能。因此，在将 NumericSumExtraPrecisionDigits 设置为高于返回数字列的 SUM 所需的数字之前，请多加考虑。

请注意，如果您关闭 AllowNumericOverflow，并且超出由 NumericSumExtraPrecisionDigits 设置的额外精度位数，Vertica 将返回错误。

对实时聚合投影 (LAP) 的影响

对于 LAP，如果您的 LAP 使用 SUM 或 SUM_FLOAT 函数，Vertica 还允许静默数字溢出。要关闭 LAP 的静默数字溢出：

  1. 将参数 AllowNumericOverflow 设置为 0。

  2. 将参数 NumericSumExtraPrecisionDigits 设置为所需的隐式位数数值。或者，使用默认设置 6。

  3. 删除并重新创建您的 LAP。

如果您关闭静默数字溢出，请注意以下溢出导致回退或错误消息的情况。在这些示例中，AllowNumericOverflow 设置为 0 (false)，每个 LAP 使用 SUM 或 SUM_FLOAT 函数。

当数字溢出关闭时：

  • 负载可以在溢出时回退。

    Vertica 在加载到 LAP 之前聚合数据。如果您正在插入、复制或合并数据，并且在 Vertica 正在聚合数据的加载期间发生溢出，则 Vertica 会回退加载。

  • 加载后可能会发生溢出，因为 Vertica 会对现有数据求和。

    Vertica 对现有数据总和的计算与其在数据加载期间执行的计算是分开的。如果您的 LAP 使用 SUM 或 SUM_FLOAT 选择列并且发生溢出，Vertica 会生成错误消息。此响应的方式类似于 Vertica 使用 SUM 或 SUM_FLOAT 函数为查询生成错误的方式。

  • 在合并期间可能会发生溢出。

    如果 Vertica 在 Tuple Mover 操作期间计算最终总和时发生溢出，Vertica 会在合并期间记录一条消息。如果发生错误，Vertica 会将 LAP 标记为过期。Vertica 不再使用过期的 LAP 运行 Tuple Mover 操作。

3.7 - 空间数据类型

Vertica 支持两种空间数据类型。这些数据类型在表列中存储二维和三维空间对象：

  • GEOMETRY：在笛卡尔平面中定义的且坐标表示为 (x,y) 对的空间对象。所有计算均使用笛卡尔坐标。
  • GEOGRAPHY：在理想球体的表面或在 WGS84 坐标系中定义的空间对象。坐标表示为经度/纬度角度值，单位为度。所有的计算都以米为单位。对于理想球体计算，球体半径为 6371 千米，与地球形状近似。

GEOMETRY 或 GEOGRAPHY数据类型的最大大小为 10,000,000 字节 (10 MB)。不能将任何一种数据类型用作表的主键。

语法

GEOMETRY [ (length) ]

GEOGRAPHY [ (length) ]

参数

3.8 - UUID 数据类型

存储通用唯一标识符 (UUID)。UUID 是用于唯一标识记录的 16 字节（128 位）数字。为了生成 UUID，Vertica 提供了函数 UUID_GENERATE，该函数根据高质量随机性从 /dev/urandom 返回 UUID。

语法

UUID

UUID 输入和输出格式

UUID 支持输入不区分大小写的字符串字面量格式，如 RFC 4122 所指定。通常，UUID 被写为十六进制数字序列，在可选地由连字符分隔的几个组中，总共 32 个数字代表 128 位。

以下输入格式有效：

6bbf0744-74b4-46b9-bb05-53905d4538e7
{6bbf0744-74b4-46b9-bb05-53905d4538e7}
6BBF074474B446B9BB0553905D4538E7
6BBf-0744-74B4-46B9-BB05-5390-5D45-38E7

在输出时，Vertica 始终使用以下格式：

xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

例如，下表将列 cust_id 定义为 UUID：

=> CREATE TABLE public.Customers
(
    cust_id uuid,
    lname varchar(36),
    fname varchar(24)
);

cust_id 的以下输入使用了几种有效格式：

=>  COPY Customers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {cede66b7-3d29-4da6-b700-871fc0ac57be}|Kearney|Thomas
>> 34462732ed5649838f3be735b0c32d50|Pham|Duc
>> 9fb0-1de0-1d63-4d09-9415-90e0-b4e9-3b9a|Steinberg|Jeremy
>> \.

在查询此表时，Vertica 以相同的方式格式化所有 cust_id 数据：

=> SELECT cust_id, fname, lname FROM Customers;
                cust_id                | fname  |   lname
--------------------------------------+--------+-----------
 9fb01de0-1d63-4d09-9415-90e0b4e93b9a | Jeremy | Steinberg
 34462732-ed56-4983-8f3b-e735b0c32d50 | Duc    | Pham
 cede66b7-3d29-4da6-b700-871fc0ac57be | Thomas | Kearney
(3 rows)

生成 UUID

您可以使用 Vertica 函数 UUID_GENERATE 自动生成唯一标识表记录的 UUID。例如：

=> INSERT INTO Customers SELECT UUID_GENERATE(),'Rostova','Natasha';
 OUTPUT
--------
      1
(1 row)

=> COMMIT;
COMMIT
=> SELECT cust_id, fname, lname FROM Customers;
               cust_id                |  fname  |   lname
--------------------------------------+---------+-----------
 9fb01de0-1d63-4d09-9415-90e0b4e93b9a | Jeremy  | Steinberg
 34462732-ed56-4983-8f3b-e735b0c32d50 | Duc     | Pham
 cede66b7-3d29-4da6-b700-871fc0ac57be | Thomas  | Kearney
 9aad6757-fe1b-473a-a109-b89b7b358c69 | Natasha | Rostova
(4 rows)

NULL 输入和输出

以下字符串为 UUID 列保留为 NULL：

00000000-0000-0000-0000-000000000000

Vertica 始终将 NULL 呈现为空白。

以下 COPY 语句将 NULL 值显式和隐式插入到 UUID 列中：

=>  COPY Customers FROM STDIN NULL AS 'null';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> null|Doe|Jane
>> 00000000-0000-0000-0000-000000000000|Man|Nowhere
>> \.
=>  COPY Customers FROM STDIN;
>> |Doe|John
>> \.

在所有情况下，Vertica 都将 NULL 呈现为空白：

=> SELECT cust_id, fname, lname FROM Customers WHERE cust_id IS NULL;
 cust_id |  fname  | lname
---------+---------+-------
         | Nowhere | Man
         | Jane    | Doe
         | John    | Doe
(3 rows)

使用限制

UUID 数据类型仅支持也受 CHAR 和 VARCHAR 数据类型支持的关系运算符和函数，例如 MIN、 MAX 和 COUNT。UUID 数据类型不支持数学运算符或函数，例如 SUM 和 AVG。

3.9 - 数据类型强制转换

Vertica 支持两种数据类型转换：

  • 隐式转换：表达式自动将数据从一种类型转化成另一种类型。

  • 显式转换：SQL 语句指定转换的目标数据类型。

隐式转换

ANSI SQL-92 标准支持相似数据类型间的隐式转换：****

  • 数字类型

  • CHAR、VARCHAR、LONG VARCHAR

  • BINARY、VARBINARY、LONG VARBINARY

Vertica 支持两种类型的标量类型的非标准隐式转换：

  • 从 CHAR 到 FLOAT，以匹配从 VARCHAR 到 FLOAT 的值。以下示例将 CHAR '3' 隐式转换为 FLOAT，这样可以与第二个表达的数值 4.33 相加得到 FLOAT 类型结果。

    => SELECT '3'::CHAR + 4.33::FLOAT;
 ?column?
----------
   7.33
(1 row)

  • DATE 与 TIMESTAMP 之间的转换。以下示例将 DATE 转换为 TIMESTAMP，计算早于上午 12 点 6 时 6 分 6 秒的时间：

    => SELECT DATE('now') - INTERVAL '6:6:6';
      ?column?
---------------------
 2013-07-30 17:53:54
(1 row)

当表达式值的数据类型明确时，会隐式地强制转换，与预期数据类型相匹配。在以下语句中，带引号的字符串常数 '2’ 会隐式地强制转换为 INTEGER 值，使其可作为算术运算符的操作数（加法）：

=> SELECT 2 + '2';
 ?column?
----------
        4
(1 row)

串联运算显式地使用任何数据类型的实参。在以下示例中，串联运算隐式地将算术表达式 2 + 2 和 INTEGER 常数 2 强制转换为 VARCHAR 值，使其可以串联起来。

=> SELECT 2 + 2 || 2;
 ?column?
----------
 42
(1 row)

另一个示例是首先获取今天的日期：

=> SELECT DATE 'now';
  ?column?
------------
 2013-07-31
(1 row)

以下命令将 DATE 转换为 TIMESTAMP，并使用 INTERVAL 在结果中添加一天半：

=> SELECT DATE 'now' + INTERVAL '1 12:00:00';
      ?column?
---------------------
 2013-07-31 12:00:00
(1 row)

大多数隐式转换保留在相关系列中，由粗略到详细朝一个方向进行。例如：

  • DATE 到 TIMESTAMP/TZ

  • INTEGER 到 NUMERIC 再到 FLOAT

  • CHAR 到 FLOAT

  • CHAR 到 VARCHAR

  • CHAR 和/或 VARCHAR 到 FLOAT

  • CHAR 到 LONG VARCHAR

  • VARCHAR 到 LONG VARCHAR

  • BINARY 到 VARBINARY

  • BINARY 到 LONG VARBINARY

  • VARBINARY 到 LONG VARBINARY

更确切地说，数据类型强制转换以此方式在 Vertica 中进行：

没有其他类型转换为或转换自 LONGVARBINARY、VARBINARY 或 BINARY。在以下列表中，<any> 表示这些类型中的一种：INT8、FLOAT8、DATE、TIME、TIMETZ、TIMESTAMP、TIMESTAMPTZ、INTERVAL。

  • <any> -> VARCHAR 为隐式

  • VARCHAR -> <any> 为显式，但 VARCHAR->FLOAT 为隐式

  • <any> <-> CHAR 为显式

  • DATE -> TIMESTAMP/TZ 为隐式

  • TIMESTAMP/TZ -> DATE 为显式，丢失时间

  • TIME -> TIMETZ 为隐式，添加本地时区

  • TIMETZ -> TIME 为显式，丢失时区

  • TIME -> INTERVAL 为隐式，day to second with days=0

  • INTERVAL -> TIME 为显式，截断非时部分

  • TIMESTAMP <-> TIMESTAMPTZ为隐式，调整为本地时区

  • TIMESTAMP/TZ -> TIME 为显式，截断非时部分

  • TIMESTAMPTZ -> TIMETZ 为显式

  • VARBINARY -> LONG VARBINARY 为隐式

  • LONG VARBINARY -> VARBINARY 为显式

  • VARCHAR -> LONG VARCHAR 为隐式

  • LONG VARCHAR -> VARCHAR 为显式

字符串到数字的数据类型转换针对科学记数法、二进制记数法、十六进制和数字型字面量组合，接受带引号常数的格式：

  • 科学记数法:

    => SELECT FLOAT '1e10';
  ?column?
-------------
 10000000000
(1 row)

  • BINARY 缩放:

    => SELECT NUMERIC '1p10';
 ?column?
----------
     1024
(1 row)

  • 十六进制：

    => SELECT NUMERIC '0x0abc';
 ?column?
----------
     2748
(1 row)

复杂类型

集合（arrays 和 sets）可以隐式和显式转换。转换集合时，将转换集合的每个元素。例如，您可以将 ARRAY[VARCHAR] 转换为 ARRAY[INT]，也可以将 SET[DATE] 转换为 SET[TIMESTAMPTZ]。您可以在数组和集合之间进行转换。

当强制转换为有界原生数组时，会截断过长的输入。当转换为非原生数组（即：包含复杂数据类型的数组，其中包括其他数组）时，如果新边界对于数据而言太小，则转换失败

行（结构）既可以隐式转换，也可以显式转换。转换 ROW 时，将转换每个字段值。您可以在转换中指定新字段名称，或仅指定字段类型以使用现有字段名称。

转换可以增加列所需的存储空间。例如，如果将 INT 数组转换为 VARCHAR(50) 数组，则每个元素将占用更多空间，从而导致数组占用更多空间。如果差异非常大或数组有很多元素，这可能意味着数组无法再适合为该列分配的空间。在这种情况下，操作会报告错误并失败。

示例

以下示例将三个字符串转换为 NUMERIC：

=> SELECT NUMERIC '12.3e3', '12.3p10'::NUMERIC, CAST('0x12.3p-10e3' AS NUMERIC);
 ?column? | ?column? |     ?column?
----------+----------+-------------------
    12300 |  12595.2 | 17.76123046875000
(1 row)

以下示例将 VARBINARY 字符串转换为 LONG VARBINARY 数据类型：

=> SELECT B'101111000'::LONG VARBINARY;
 ?column?
----------
 \001x
(1 row)

以下示例将 CHAR 与 LONG VARCHAR 串联，得到 LONG VARCHAR：

=> \set s ''''`cat longfile.txt`''''
=> SELECT length ('a' || :s ::LONG VARCHAR);
 length
----------
 65002
(1 row)

以下示例将 NUMERIC 与 INTEGER 的数据组合转换为 NUMERIC 结果。

=> SELECT (18. + 3./16)/1024*1000;
                ?column?
-----------------------------------------
 17.761230468750000000000000000000000000
(1 row)

另请参阅

3.10 - 数据类型强制转换表

转换类型

下表定义了 Vertica 支持的所有可能的类型转换。该表第一列的数据类型是待转换的输入内容，第二个标题行所列的数据类型是结果赋值。

隐式和显式转换

Vertica 支持无显式转换的值的数据类型转换，例如 NUMERIC(10,6) -> NUMERIC(18,4)。将类型不同但相互兼容的值转换为目标列的数据类型时，进行隐式数据类型转换。例如，在添加值 (INTEGER + NUMERIC) 时，结果被隐式转换为 NUMERIC 类型以适应语句中的重要类型。根据输入数据的类型，可能会出现不同的精度和小数位数。

当源数据无法隐式转换为目标列的数据类型时，才可进行显式类型转换。

赋值转换

在数据赋值转换中，当赋值到 INSERT 或 UPDATE...SET 语句中的数据库列时，进行隐式强制转换。例如，在包括 INSERT...VALUES('2.5') 的语句中，目标列数据类型是 NUMERIC(18,5)，可推知从 VARCHAR 到列数据类型的转换。

在无数字意义的赋值中，该值需进行 CHAR/VARCHAR/LONG VARCHAR 的比较。

另请参阅

3.11 - 复杂类型

结构（也称为行）、数组和映射等复杂类型由基元类型组成，有时也由其他复杂类型组成。可以通过以下方式使用复杂类型：

  • 数组和行（任意组合）可用作原生和外部表中的列数据类型。

  • 基元元素类型集可用作原生和外部表中的列数据类型。

  • 数组和行（但不是它们的组合）可以创建为字面量，例如在查询表达式中使用。

MAP 类型是旧类型。要表示映射，请使用 ARRAY[ROW]。

如果 flex 表有一个使用复杂类型的实际列，则该列中的值不包含在 __raw__ 列中。有关详细信息，请参阅将数据加载到 Flex 表实际列。

3.11.1 - ARRAY

表示数组数据。Vertica 中有两种类型的数组：

  • 原生数组：基元类型的一维数组。原生数组在 TYPES 系统表中跟踪并在原生表中使用。

  • 非原生数组：所有其他受支持的数组，包括包含其他数组（多维数组）或结构 (ROW) 的数组。非原生数组的使用有一些限制。非原生数组在 COMPLEX_TYPES 系统表中跟踪。

两种数组类型的运行方式相同，但它们具有不同的 OID。

数组可以是有界的，这意味着它们指定了最大元素计数，也可以是无界的。无界数组具有最大二进制大小，可以显式设置或默认设置。请参阅元素计数和集合大小的限制。

选定的解析器支持使用 COPY 加载数组。有关详细信息，请参阅各个解析器的文档。

语法

在列定义中：


ARRAY[data_type, max_elements] |
ARRAY[data_type](max_size) |
ARRAY[data_type]

在字面量中：

ARRAY[value[, ...] ]

限制

  • 原生数组仅支持原始类型的数据，例如 int、UUID 等。

  • 强制执行数组维数。列不能包含不同维度的数组。例如，包含三维数组的列只能包含其他三维数组；它不能同时包含一个一维数组。但是，一列中的数组大小可能不同，其中一个数组可以包含四个元素，而另一个数组包含十个元素。

  • 如果指定了数组边界，则对所有加载或更改数据的操作强制执行。无界数组可能包含与分配的二进制大小一样多的元素。

  • 数组具有最大二进制大小。如果在定义数组时未设置此大小，则使用默认值。

  • 数组不支持 LONG 类型（如 LONG VARBINARY 或 LONG VARCHAR）或用户定义类型（如 Geometry）。

列定义的语法

列定义中使用的数组可以是有界或无界的。有界数组必须指定最大元素数。无界数组可以指定数组的最大二进制大小（以字节为单位），或者使用 DefaultArrayBinarySize 的值。您可以指定边界或二进制大小，但不能同时指定两者。有关这些值的更多信息，请参阅元素计数和集合大小限制。

以下示例使用无界数组为客户定义了一个表：

=> CREATE TABLE customers (id INT, name VARCHAR, email ARRAY[VARCHAR(50)]);

以下示例对客户电子邮件地址使用有界数组，对订单历史记录使用无界数组：

=> CREATE TABLE customers (id INT, name VARCHAR, email ARRAY[VARCHAR(50),5], orders ARRAY[INT]);

以下示例使用具有 ROW 元素的数组：

=> CREATE TABLE orders(
  orderid INT,
  accountid INT,
  shipments ARRAY[
    ROW(
      shipid INT,
      address ROW(
        street VARCHAR,
        city VARCHAR,
        zip INT
        ),
      shipdate DATE
    )
  ]
 );

要声明多维数组，请使用嵌套。例如，ARRAY[ARRAY[int]] 指定一个二维数组。

直接构造的语法（字面量）

使用 ARRAY 关键字构造数组值。下面的示例创建一个整数值数组。

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

您可以将一个数组嵌套在另一个数组中，如下例所示。

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

如果一系列数组不包含 null 元素且无函数调用，则可以缩写语法：

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

---not valid:
=> SELECT ARRAY[[1,2],null,[3,4]];

ERROR 4856:  Syntax error at or near "null" at character 20
LINE 1: SELECT ARRAY[[1,2],null,[3,4]];
                           ^

数组字面量可以包含所有标量类型（ROW 和 ARRAY）的元素。ROW 元素必须都具有相同的字段集：

=> SELECT ARRAY[ROW(1,2),ROW(1,3)];
               array
-----------------------------------
 [{"f0":1,"f1":2},{"f0":1,"f1":3}]
(1 row)

=> SELECT ARRAY[ROW(1,2),ROW(1,3,'abc')];
ERROR 3429:  For 'ARRAY', types ROW(int,int) and ROW(int,int,unknown) are inconsistent

因为在直接构造数组时元素是已知的，所以这些数组是隐式有界的。

您可以在比较中使用 ARRAY 字面量，如下例所示：

=> SELECT id.name, id.num, GPA FROM students
   WHERE major = ARRAY[ROW('Science','Physics')];
 name  | num | GPA
-------+-----+-----
 bob   | 121 | 3.3
 carol | 123 | 3.4
(2 rows)

输出格式

数组列的查询返回 JSON 格式，值显示在括号中的逗号分隔列表中。以下示例显示了一个包含数组列的查询。

=> SELECT cust_custkey,cust_custstaddress,cust_custcity,cust_custstate from cust;
cust_custkey |               cust_custstaddress                      |                cust_custcity                | cust_custstate
-------------+-------  ----------------------------------------------+---------------------------------------------+----------------
      342176 | ["668 SW New Lane","518 Main Ave","7040 Campfire Dr"] | ["Winchester","New Hyde Park","Massapequa"] | ["VA","NY","NY"]
      342799 | ["2400 Hearst Avenue","3 Cypress Street"]             | ["Berkeley","San Antonio"]                  | ["CA","TX"]
      342845 | ["336 Boylston Street","180 Clarkhill Rd"]            | ["Boston","Amherst"]                        | ["MA","MA"]
      342321 | ["95 Fawn Drive"]                                     | ["Allen Park"]                              | ["MI"]
      342989 | ["5 Thompson St"]                                     | ["Massillon"]                               | ["OH"]
(5 rows)

请注意，JSON 格式转义的一些字符在原生 VARCHAR 中不会转义。例如，如果您将 "c:\users\data" 插入到数组中，则该值的 JSON 输出为 "c:\\\users\\\data"。

元素访问

数组是从 0 开始索引的。第一个元素的序号位置为 0，第二个元素的序号位置为 1，依此类推。

您可以通过索引访问（取消引用）数组中的元素：

=> SELECT (ARRAY['a','b','c','d','e'])[1];
array
-------
b
(1 row)

要指定范围，请使用格式 start:end。不包括范围的结尾。

=> SELECT(ARRAY['a','b','c','d','e','f','g'])[1:4];
array
---------
["b","c","d"]
(1 row)

要从多维数组中取消引用某个元素，请将每个索引放在括号中：

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

超过边界的索引引用会返回 NULL。

元素计数和集合大小的限制

在为表列声明集合类型时，您可以限制元素的数量或集合的总二进制大小。在查询处理期间，Vertica 始终根据元素计数或二进制大小保留列所需的最大内存。如果此大小比您的数据实际需要的大得多，则设置这些限制之一可以通过减少必须为列保留的内存量来提高查询性能。

您可以通过强制转换来更改集合的边界，包括在有界和无界集合之间进行更改。请参阅 强制转换。

有界集合指定最大元素计数。有界集合列中的值可能包含较少的元素，但可能不会包含更多。任何将比声明的最大值更多的元素插入有界集合的尝试都是错误的。有界集合的二进制大小是数据类型大小和最大元素数的乘积，可能向上取整。

无界集合显式或隐式指定二进制大小（以字节为单位）。它可能包含尽可能多的元素，以适应该二进制大小。

如果嵌套数组为所有维度指定边界，Vertica 会设置一个边界，该边界是这些边界的乘积。在以下示例中，内部和外部数组的边界均为 10，但仅强制执行总元素计数 100。

ARRAY[ARRAY[INT,10],10]

如果嵌套数组仅指定外部集合的边界，则将其视为总边界。上一示例等效于以下示例：

ARRAY[ARRAY[INT],100]

您必须为所有嵌套集合指定边界或仅为外部集合指定边界。对于任何其他边界分布，Vertica 会将集合视为无界。

您可以为无界集合指定最大二进制大小，而不是指定边界。无论集合包含多少元素，二进制大小都是绝对限制。未指定最大二进制大小的集合使用 DefaultArrayBinarySize 的值。此大小在定义集合时设置，不受以后对 DefaultArrayBinarySize 值的更改的影响。

您不能为有界集合设置最大二进制大小，只能设置无界集合。

您可以使用 ALTER TABLE 更改数组列的边界或二进制大小，如下例所示：

=> ALTER TABLE cust ALTER COLUMN orders SET DATA TYPE ARRAY[INTEGER](100);

如果更改减少了集合的大小并导致数据丢失，则更改将失败。

比较

所有集合都支持相等 (=)、不等 (<>) 和 null 安全相等 (<=>)。一维集合还支持以下集合之间的比较运算符 (<、<=、>、>=) 相同的类型（数组或集合）。比较遵循以下规则：

  • 空集合最后排序。

  • 使用元素数据类型的排序规则逐个元素比较非空集合。第一对不相等元素的相对顺序决定了两个集合的顺序。

  • 如果两个集合中的所有元素都等于较短集合的长度，则较短集合在较长集合之前排序。

  • 如果两个集合中的所有元素相等且集合的长度相等，则集合相等。

NULL 处理

集合的空语义在大多数方面与普通列一致。有关空处理的更多信息，请参阅 NULL 排序顺序。

当集合为 null 而不是空时，空安全相等运算符 (<=>) 的行为与相等 (=) 不同。将集合严格地与 NULL 进行比较是未定义的。

=> SELECT ARRAY[1,3] = NULL;
?column?
----------

(1 row)

=> SELECT ARRAY[1,3] <=> NULL;
 ?column?
----------
 f
(1 row)

在以下示例中，表中的授予列对于员工 99 为 null。

=> SELECT grants = NULL FROM employees WHERE id=99;
 ?column?
----------

(1 row)

=> SELECT grants <=> NULL FROM employees WHERE id=99;
 ?column?
----------
 t
(1 row)

空集合不为 null 并且按预期运行。

=> SELECT ARRAY[]::ARRAY[INT] = ARRAY[]::ARRAY[INT];
 ?column?
----------
 t
(1 row)

集合逐个元素进行比较。如果比较依赖于 null 元素，则结果是未知的 (null)，而不是 false。例如，ARRAY[1,2,null]=ARRAY[1,2,null] 和 ARRAY[1,2,null]=ARRAY[1,2,3] 都返回 null，但 ARRAY[1,2,null]=ARRAY[1,4,null] 因为第二个元素不匹配而返回 false。

强制转换

转换一个数组会转换数组的每个元素。因此，您可以按照与标量值转换相同的规则在数据类型之间转换。

您可以显式地转换字面量数组和数组列：

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

您可以通过强制转换来更改数组或集的边界。当强制转换为有界原生数组时，会截断太长的输入。当转换为非原生数组（包含复杂数据类型（包括其他数组）的数组）时，如果新边界对于数据而言太小，则转换失败：

=> SELECT ARRAY[1,2,3]::ARRAY[VARCHAR,2];
   array
-----------
 ["1","2"]
(1 row)

=> SELECT ARRAY[ARRAY[1,2,3],ARRAY[4,5,6]]::ARRAY[ARRAY[VARCHAR,2],2];
ERROR 9227:  Output array isn't big enough
DETAIL:  Type limit is 4 elements, but value has 6 elements

如果转换为有界多维数组，则必须在所有级别指定边界：

=> SELECT ARRAY[ARRAY[1,2,3],ARRAY[4,5,6]]::ARRAY[ARRAY[VARCHAR,5],10];
             array
-------------------------------
 [["1","2","3"],["4","5","6"]]
(1 row)

=> SELECT ARRAY[ARRAY[1,2,3],ARRAY[4,5,6]]::ARRAY[ARRAY[VARCHAR,2]];
WARNING 9753:  Collection type bound will not be used
DETAIL:  A bound was provided for an inner dimension, but not for an outer dimension
             array
-------------------------------
 [["1","2","3"],["4","5","6"]]
(1 row)

赋值转换和隐式转换的工作方式与标量相同：

=> CREATE TABLE transactions (tid INT, prod_ids ARRAY[VARCHAR,100], quantities ARRAY[INT,100]);
CREATE TABLE

=> INSERT INTO transactions VALUES (12345, ARRAY['p1265', 'p4515'], ARRAY[15,2]);
 OUTPUT
--------
      1
(1 row)

=> CREATE TABLE txreport (prod_ids ARRAY[VARCHAR(12),100], quants ARRAY[VARCHAR(32),100]);
CREATE TABLE

=> INSERT INTO txreport SELECT prod_ids, quantities FROM transactions;
 OUTPUT
--------
      1
(1 row)

=> SELECT * FROM txreport;
     prod_ids      |   quants
-------------------+------------
 ["p1265","p4515"] | ["15","2"]
(1 row)

您可以在 ARRAY 和 SET 类型（仅限原生数组）之间执行显式转换，但不能执行隐式转换。如果集合是无界的且数据类型未更改，则保留二进制大小。例如，如果将 ARRAY[INT] 转换为 SET[INT]，则该集与数组具有相同的二进制大小。

如果从一种元素类型转换为另一种元素类型，则生成的集合使用默认二进制大小。如果这会导致数据不适合，则转换失败。

您不能从数组转换为具有不同维度的数组，例如从二维数组转换为一维数组。

函数和运算符

有关可用于操作数组和集合的函数的完整列表，请参阅 集合函数。

可以通过以下方式使用集合：

集合不能以下列方式使用：

  • 作为 IN 或 NOT IN 表达式的一部分。

  • 创建表时作为分区列。

  • 使用 ANALYZE_STATISTICS 或 TopK 预测。

  • 仅限非原生数组：ORDER BY、PARTITION BY、DEFAULT、SET USING 或约束。

3.11.2 - MAP

仅以 Parquet、ORC 和 Avro 格式表示外部表中的映射数据。MAP 只能使用基元类型，而且不能包含其他复杂类型。您可以在表定义中使用 MAP 类型来利用数据中的列，但不能查询这些列。

MAP 的更好替代方法是 ARRAY[ROW]。行数组可以使用所有受支持的复杂类型并且可以查询。这是 INFER_TABLE_DDL 建议的表示。对于 Avro 数据，ROW 必须具有名为 key 和 value 的字段。

在单个表中，您必须使用相同的方法（MAP 或 ARRAY[ROW]）定义所有映射列。

语法

在列定义中：

MAP<key,value>

列定义的映射输入格式

在外部表的列定义中，MAP 由指定为类型的键值对组成。以下示例中的表定义了产品 ID 到名称的映射。

=> CREATE EXTERNAL TABLE store (storeID INT, inventory MAP<INT,VARCHAR(100)>)
    AS COPY FROM '...' PARQUET;

3.11.3 - ROW

表示结构化数据（结构）。ROW 可以包含 Vertica 支持的任何基元类型或复杂类型的字段。

语法

在列定义中：

  • ROW([field] type[, ...])

    如果省略字段名称，Vertica 会生成以“f0”开头的名称。

  • 在字面量中：

    ROW(value [AS field] [, ...]) [AS name(field[, ...])]

列定义的语法

在列定义中，ROW 由一个或多个以逗号分隔的字段名和类型对组成。在以下示例中，Parquet 数据文件包含地址的结构，其在外部表中作为 ROW 读取：

=> CREATE EXTERNAL TABLE customers (name VARCHAR,
    address ROW(street VARCHAR, city VARCHAR, zipcode INT))
    AS COPY FROM '...' PARQUET;

ROW 可以嵌套；一个字段可以有一个 ROW 类型：

=> CREATE TABLE employees(
    employeeID INT,
    personal ROW(
      name VARCHAR,
      address ROW(street VARCHAR, city VARCHAR, zipcode INT),
      taxID INT),
    department VARCHAR);

ROW 可以包含数组：

=> CREATE TABLE customers(
  name VARCHAR,
  contact ROW(
    street VARCHAR,
    city VARCHAR,
    zipcode INT,
    email ARRAY[VARCHAR]
  ),
  accountid INT );

加载数据时，表定义中的基元类型必须与数据中的基元类型相匹配。ROW 结构也必须匹配；ROW 必须包含且仅包含数据中结构的所有字段。

ROW 列的限制

ROW 列有几个限制：

  • 最大嵌套深度为 100。

  • Vertica 表最多支持 9800 个列和字段。不计算 ROW 本身，只计算其字段。

  • ROW 列不能使用任何约束（例如 NOT NULL）或默认值。

  • ROW 字段不能是 auto_increment 或 setof。

  • ROW 定义必须至少包含一个字段。

  • “Row”是 ROW 定义中的保留关键字，但允许作为表或列的名称。

  • 不能使用 ALTER TABLE...ALTER COLUMN 修改 ROW 列。

  • 包含 ROW 列的表也不能包含标识、自动增量、默认、SET USING 或序列列。

直接构造的语法（字面量）

在字面量中，例如比较操作中的值，ROW 由一个或多个值组成。如果您在 ROW 表达式中省略字段名称，Vertica 会自动生成它们。如果您不强制转换类型，Vertica 会根据数据值推断类型。

=> SELECT ROW('Amy',2,false);
                row
--------------------------------------------
 {"f0":"Amy","f1":2,"f2":false}
(1 row)

您可以使用 AS 子句来命名 ROW 及其字段：

=> SELECT ROW('Amy',2,false) AS student(name, id, current);
               student
--------------------------------------------
 {"name":"Amy","id":2,"current":false}
(1 row)

您还可以使用 AS 命名单个字段。此查询产生的输出与之前的输出相同：

=> SELECT ROW('Amy' AS name, 2 AS id, false AS current) AS student;

您无需命名所有字段。

在 ROW 元素数组中，如果您使用 AS 命名字段且元素之间的名称不同，Vertica 会为所有元素使用最右边的名称：

=> SELECT ARRAY[ROW('Amy' AS name, 2 AS id),ROW('Fred' AS first_name, 4 AS id)];
                           array
------------------------------------------------------------
 [{"first_name":"Amy","id":2},{"first_name":"Fred","id":4}]
(1 row)

您可以显式强制转换类型：

=> SELECT ROW('Amy',2.5::int,false::varchar);
               row
------------------------------------------
 {"f0":"Amy","f1":3,"f2":"f"}
(1 row)

使用单引号转义字面量输入中的单引号，如以下示例所示：

=> SELECT ROW('Howard''s house',2,false);
                      row
---------------------------------------------------
 {"f0":"Howard's house","f1":2,"f2":false}
(1 row)

您可以使用所有标量类型、ROW 和 ARRAY 的字段，如以下示例所示：

=> SELECT id.name, major, GPA FROM students
   WHERE id = ROW('alice',119, ARRAY['alice@example.com','ap16@cs.example.edu']);
 name  |               major                | GPA
-------+------------------------------------+-----
 alice | [{"school":"Science","dept":"CS"}] | 3.8
(1 row)

输出格式

ROW 值以 JSON 格式输出，如以下示例所示。

=> CREATE EXTERNAL TABLE customers (name VARCHAR,
    address ROW(street VARCHAR, city VARCHAR, zipcode INT))
    AS COPY FROM '...' PARQUET;

=> SELECT address FROM customers WHERE address.city ='Pasadena';
                              address
--------------------------------------------------------------------
 {"street":"100 Main St Apt 4B","city":"Pasadena","zipcode":91001}
 {"street":"100 Main St Apt 4A","city":"Pasadena","zipcode":91001}
 {"street":"23 Fifth Ave Apt 8C","city":"Pasadena","zipcode":91001}
 {"street":"15 Raymond Dr","city":"Pasadena","zipcode":91003}
(4 rows)

下表指定了从 Vertica 数据类型到 JSON 数据类型的映射。

比较

ROW 支持在具有相同字段集的输入之间使用相等 (=)、不相等 (<>) 和空安全相等 (<=>)。仅包含基元类型的 ROW（包括基元类型的嵌套 ROW）也支持比较运算符（<、<=、>、>=）。

当且仅当所有字段都相等时，两个 ROW 相等。Vertica 按顺序比较字段，直到发现不相等或已比较了所有字段。第一个不相等字段的求值决定哪个 ROW 更大：

=> SELECT ROW(1, 'joe') > ROW(2, 'bob');
?column?
----------
f
(1 row)

具有不同架构的 ROW 之间的比较失败：

=> SELECT ROW(1, 'joe') > ROW(2, 'bob', 123);
ERROR 5162:  Unequal number of entries in row expressions

如果比较结果依赖于 null 字段，则结果为 null：

=>  select row(1, null, 3) = row(1, 2, 3);
 ?column?
----------

(1 row)

NULL 处理

如果结构存在但字段值为 null，Vertica 会将 NULL 作为其在 ROW 中的值。所有字段为 null 的结构被视为具有 null 字段的 ROW。如果结构本身为 null，Vertica 会将 ROW 读取为 NULL。

强制转换

转换 ROW 将转换每个字段。因此，您可以按照与标量值转换相同的规则在数据类型之间转换。

以下示例将转换客户表中的 contact ROW，将 zipcode 字段从 INT 更改为 VARCHAR 并向数组添加边界：

=> SELECT contact::ROW(VARCHAR,VARCHAR,VARCHAR,ARRAY[VARCHAR,20]) FROM customers;
                                                         contact

--------------------------------------------------------------------------------
-----------------------------------------
 {"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 contact::ROW(str VARCHAR, city VARCHAR, zip VARCHAR, email ARRAY[VARCHAR,
20]) FROM customers;
                                                     contact

--------------------------------------------------------------------------------
----------------------------------
 {"str":"911 San Marcos St","city":"Austin","zip":"73344","email":["missy@mit.edu","mcooper@cern.gov"]}
 {"str":"100 Main St Apt 4B","city":"Pasadena","zip":"91001","email":["shelly@meemaw.name","cooper@caltech.edu"]}
 {"str":"100 Main St Apt 4A","city":"Pasadena","zip":"91001","email":["hofstadter@caltech.edu"]}
 {"str":"23 Fifth Ave Apt 8C","city":"Pasadena","zip":"91001","email":[]}
 {"str":null,"city":"Pasadena","zip":"91001","email":["raj@available.com"]}
(6 rows)

支持的运算符和谓词

可以通过以下方式在查询中使用 ROW 值：

  • INNER 和 OUTER JOIN

  • 比较，IN、BETWEEN（仅限不可为空的筛选器）

  • IS NULL、IS NOT NULL

  • CASE

  • GROUP BY、ORDER BY

  • SELECT DISTINCT

  • 用户定义的标量、变换和分析函数的实参

ROW 值不支持以下运算符和谓词：

  • 数学运算符

  • 整行类型强制转换（支持字段值强制转换）

  • BITWISE、LIKE

  • MLA (ROLLUP, CUBE, GROUPING SETS)

  • 聚合函数，包括 MAX、MIN 和 SUM

  • 集运算符，包括 UNION、UNION ALL、MINUS 和 INTERSECT

从用户定义的标量函数返回的 ROW 不支持 COUNT，但 ROW 列和字面量支持 COUNT。

在比较操作（包括 ORDER BY 之类的隐式比较）中，ROW 字面量被视为其字段值的序列。例如，以下两个语句是等效的：

GROUP BY ROW(zipcode, city)
GROUP BY zipcode, city

在视图和子查询中使用行

您可以使用 ROW 列来构造视图和子查询。考虑具有以下定义的员工和客户表：

=> CREATE EXTERNAL TABLE customers(name VARCHAR,
        address ROW(street VARCHAR, city VARCHAR, zipcode INT), accountID INT)
    AS COPY FROM '...' PARQUET;

=> CREATE EXTERNAL TABLE employees(employeeID INT,
        personal ROW(name VARCHAR,
        address ROW(street VARCHAR, city VARCHAR, zipcode INT),
        taxID INT), department VARCHAR)
    AS COPY FROM '...' PARQUET;

以下示例将创建一个视图并对其进行查询。

=> CREATE VIEW neighbors (num_neighbors, area(city, zipcode))
AS SELECT count(*), ROW(address.city, address.zipcode)
FROM customers GROUP BY address.city, address.zipcode;
CREATE VIEW

=> SELECT employees.personal.name, neighbors.area FROM neighbors, employees
WHERE employees.personal.address.zipcode=neighbors.area.zipcode AND neighbors.nu
m_neighbors > 1;
        name        |                area
--------------------+-------------------------------------
 Sheldon Cooper     | {"city":"Pasadena","zipcode":91001}
 Leonard Hofstadter | {"city":"Pasadena","zipcode":91001}
(2 rows)

3.11.4 - SET

表示无序的、唯一元素的集合。集可能只包含基元类型。与数组不同，在集中，元素位置是没有意义的。

集不支持 LONG 类型（如 LONG VARBINARY 或 LONG VARCHAR）或用户定义类型（如 Geometry）。

如果您从数组填充集，Vertica 会对值进行排序并移除重复元素。如果您不关心元素位置并计划运行检查特定元素是否存在的查询（查找、包含），则使用集可以提高查询性能。

集可以是有界的（这意味着它们指定了最大元素计数），也可以是无界的。无界集具有最大二进制大小，可以显式设置或默认设置。请参阅元素计数和集合大小的限制。

语法

在列定义中：


SET[data_type, max_elements] |
SET[data_type](max_size) |
SET[data_type]

在字面量中：

SET[value[, ...] ]

限制

  • 集仅支持基元类型的数据，例如 int、UUID 等。

  • 如果指定了边界，则会对加载或更改数据的所有操作强制执行边界。无界集可以具有适合所分配的二进制大小的任意数量的元素。

  • 集具有最大二进制大小。如果在定义集时未设置此大小，则使用默认值。

列定义的语法

列定义中使用的集可以是有界或无界的。有界集必须指定最大元素数。无界集可以指定集的最大二进制大小，也可以使用 DefaultArrayBinarySize 的值。您可以指定边界或二进制大小，但不能同时指定两者。有关这些值的更多信息，请参阅元素计数和集合大小限制。

以下示例定义了一个具有无界集列的表。

=> CREATE TABLE users
(
user_id INTEGER,
display_name VARCHAR,
email_addrs SET[VARCHAR]
);

当您将数组数据加载到定义为集的列中时，数组数据会自动转换为集。

直接构造的语法（字面量）

使用 SET 关键字构造集值。字面量设置值包含在括号中。例如，要创建一个 INT 集，您将执行以下操作：

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

您可以通过转换将数组显式转换为集，如以下示例所示：

=> SELECT ARRAY[1, 5, 2, 6, 3, 0, 6, 4]::SET[INT];
     set
-----------------
[0,1,2,3,4,5,6]
(1 row)

请注意，重复元素已移除并且元素已排序。

因为在直接构造集时元素是已知的，所以这些集是隐式有界的。

输出格式

集以类似 JSON 的格式显示，括号中包含逗号分隔的元素（如数组）。在以下示例中，email_addrs 列是一个集。

=> SELECT custkey,email_addrs FROM customers LIMIT 4;
 custkey |                           email_addrs
---------+------------------------------------------------------------------------
 342176  | ["joe.smith@example.com"]
 342799  | ["bob@example,com","robert.jones@example.com"]
 342845  | ["br92@cs.example.edu"]
 342321  | ["789123@example-isp.com","sjohnson@eng.example.com","sara@johnson.example.name"]

元素计数和集合大小的限制

在为表列声明集合类型时，您可以限制元素的数量或集合的总二进制大小。在查询处理期间，Vertica 始终根据元素计数或二进制大小保留列所需的最大内存。如果此大小比您的数据实际需要的大得多，则设置这些限制之一可以通过减少必须为列保留的内存量来提高查询性能。

您可以通过强制转换来更改集合的边界，包括在有界和无界集合之间进行更改。请参阅 强制转换。

有界集合指定最大元素计数。有界集合列中的值可能包含较少的元素，但可能不会包含更多。任何将比声明的最大值更多的元素插入有界集合的尝试都是错误的。有界集合的二进制大小是数据类型大小和最大元素数的乘积，可能向上取整。

无界集合显式或隐式指定二进制大小（以字节为单位）。它可能包含尽可能多的元素，以适应该二进制大小。

您可以为无界集合指定最大二进制大小，而不是指定边界。无论集合包含多少元素，二进制大小都是绝对限制。未指定最大二进制大小的集合使用 DefaultArrayBinarySize 的值。此大小在定义集合时设置，不受以后对 DefaultArrayBinarySize 值的更改的影响。

您不能为有界集合设置最大二进制大小，只能设置无界集合。

比较

所有集合都支持相等 (=)、不等 (<>) 和 null 安全相等 (<=>)。一维集合还支持以下集合之间的比较运算符 (<、<=、>、>=) 相同的类型（数组或集合）。比较遵循以下规则：

  • 空集合最后排序。

  • 使用元素数据类型的排序规则逐个元素比较非空集合。第一对不相等元素的相对顺序决定了两个集合的顺序。

  • 如果两个集合中的所有元素都等于较短集合的长度，则较短集合在较长集合之前排序。

  • 如果两个集合中的所有元素相等且集合的长度相等，则集合相等。

Null 处理

集合的空语义在大多数方面与普通列一致。有关空处理的更多信息，请参阅 NULL 排序顺序。

当集合为 null 而不是空时，空安全相等运算符 (<=>) 的行为与相等 (=) 不同。将集合严格地与 NULL 进行比较是未定义的。

=> SELECT ARRAY[1,3] = NULL;
?column?
----------

(1 row)

=> SELECT ARRAY[1,3] <=> NULL;
 ?column?
----------
 f
(1 row)

在以下示例中，表中的授予列对于员工 99 为 null。

=> SELECT grants = NULL FROM employees WHERE id=99;
 ?column?
----------

(1 row)

=> SELECT grants <=> NULL FROM employees WHERE id=99;
 ?column?
----------
 t
(1 row)

空集合不为 null 并且按预期运行。

=> SELECT ARRAY[]::ARRAY[INT] = ARRAY[]::ARRAY[INT];
 ?column?
----------
 t
(1 row)

集合逐个元素进行比较。如果比较依赖于 null 元素，则结果是未知的 (null)，而不是 false。例如，ARRAY[1,2,null]=ARRAY[1,2,null] 和 ARRAY[1,2,null]=ARRAY[1,2,3] 都返回 null，但 ARRAY[1,2,null]=ARRAY[1,4,null] 因为第二个元素不匹配而返回 false。

强制转换

转换一个集会转换集的每个元素。因此，您可以按照与标量值转换相同的规则在数据类型之间转换。

您可以显式地转换字面量集和集列：

=> SELECT SET['1','2','3']::SET[INT];
   set
---------
[1,2,3]
(1 row)

=> CREATE TABLE transactions (tid INT, prod_ids SET[VARCHAR], quantities SET[VARCHAR(32)]);

=> INSERT INTO transactions VALUES (12345, SET['p1265', 'p4515'], SET['15','2']);

=> SELECT quantities :: SET[INT] FROM transactions;
 quantities
------------
   [15,2]
(1 row)

赋值转换和隐式转换的工作方式与标量相同。

您可以在 ARRAY 和 SET 类型之间执行显式转换，但不能执行隐式转换。如果集合是无界的且数据类型未更改，则保留二进制大小。例如，如果将 ARRAY[INT] 转换为 SET[INT]，则该集与数组具有相同的二进制大小。

在将数组转换为集时，Vertica 会首先转换每个元素，然后对集进行排序并移除重复项。如果将两个源值转换为相同的目标值，则其中一个将被移除。例如，如果您将 FLOAT 数组转换为一组 INT，则数组中的两个值可能会四舍五入为相同的整数，然后被视为重复项。如果数组包含多个转换为 NULL 的值，也会发生这种情况。

如果从一种元素类型转换为另一种元素类型，则生成的集合使用默认二进制大小。如果这会导致数据不适合，则转换失败。

函数和运算符

有关可用于操作数组和集合的函数的完整列表，请参阅 集合函数。

可以通过以下方式使用集合：

集合不能以下列方式使用：

  • 作为 IN 或 NOT IN 表达式的一部分。

  • 创建表时作为分区列。

  • 使用 ANALYZE_STATISTICS 或 TopK 预测。

  • 仅限非原生数组：ORDER BY、PARTITION BY、DEFAULT、SET USING 或约束。

3.12 - Vertica 和 Oracle 之间的数据类型映射

Oracle 对所有主要数据类型使用专用数据类型，例如 VARCHAR、INTEGER、FLOAT、DATE。在将数据库从 Oracle 迁移到 Vertica 之前，首先转换架构，以最大限度地减少错误和修复错误数据问题所花费的时间。

下表比较了 Oracle 数据类型与 Vertica 数据类型的行为。

4 - 函数

函数从数据库返回信息。此部分介绍 Vertica 支持的函数。除了元函数之外，您可以在任何允许表达式的地方使用函数。

元函数通常访问 Vertica 的内部状态。其只能在顶级 SELECT 语句中使用，并且该语句不能包含其他子句，例如 FROM 或 WHERE。元函数在其参考页面上进行标记。

每个参考页面上的“行为类型”部分将函数的返回行为分类为以下一项或多项：

  • 不可变（非变体）： 使用给定实参集运行时，不可变函数始终产生相同的结果，无论环境或会话设置（如区域设置）如何。
  • 稳定： 使用给定实参集运行时，稳定的函数会在单个查询或扫描操作中生成相同的结果。但是，在不同的环境下或者在不同的时间发布时，稳定的函数可能会生成不同的结果，例如在区域设置和时区发生变化—例如，SYSDATE。
  • 易变： 无论实参或环境如何，每次调用时，易变函数都能返回不同的结果，例如 UUID_GENERATE。

4.1 - Vertica 函数的字母表

以下列表按字母顺序显示了所有 Vertica 函数。

跳转到字母： A - B - C - D - E - F - G - H - I - J - K - L - M - N - O - P - Q - R - S - T - U - V - W - X - Y - Z

A

ABS
返回实参的绝对值。
ACOS
返回一个 DOUBLE PRECISION 值，该值表示实参的反三角余弦。
ADD_MONTHS
将指定的月份数添加到日期，并返回总和作为 DATE。
ADVANCE_EPOCH
手动关闭当前时期并开始新的时期。
AGE_IN_MONTHS
返回两个日期之间的月份差，以整数表示。
AGE_IN_YEARS
返回两个日期之间的年份差，以整数表示。
ALTER_LOCATION_LABEL
将标签添加到存储位置，或者更改或移除现有标签。
ALTER_LOCATION_SIZE
在子群集中的一个节点、所有节点或数据库中的所有节点上调整存储库的大小。
ALTER_LOCATION_USE
更改存储位置保存的数据类型。
ANALYZE_CONSTRAINTS
分析和报告指定范围内的约束违规。
ANALYZE_CORRELATIONS
分析紧密相关的列对的指定表。
ANALYZE_EXTERNAL_ROW_COUNT
计算外部表中的确切行数。
ANALYZE_STATISTICS
从存储指定表关联的投影的所有节点上收集并聚合数据示例和存储信息。此函数将跳过复杂数据类型列。
ANALYZE_STATISTICS_PARTITION
收集并聚合指定表中一系列分区的数据示例和存储信息。
ANALYZE_WORKLOAD
运行工作负载分析器，一个用于分析系统表中包含的系统信息的实用程序。
APPLY_AVG
返回 a 中具有数字值的所有元素的平均值。
APPLY_BISECTING_KMEANS
将已训练的二分 k-means 模型应用于输入关系，并将每个新数据点分配给已训练模型中最接近的匹配群集。
APPLY_COUNT (ARRAY_COUNT)
返回 a 中非空元素的总数。
APPLY_COUNT_ELEMENTS (ARRAY_LENGTH)
返回 a 中的元素总数，包括 NULL。
APPLY_INVERSE_PCA
将 APPLY_PCA 生成的转换变换回原始坐标系。
APPLY_INVERSE_SVD
将数据转换回原始域。
APPLY_KMEANS
按照已知 k-means 模型将输入关系的每一行分配给一个群集中心。
APPLY_MAX
返回 a 中最大的非空元素。
APPLY_MIN
返回 a 中最小的非空元素。
APPLY_NORMALIZE
UDTF 函数，用于将保存在模型中的标准化参数应用于一组指定的输入列。
APPLY_ONE_HOT_ENCODER
用户定义的转换函数 (UDTF)，用于加载独热编码器模型并写出包含编码列的表。
APPLY_PCA
使用 PCA 模型转换数据。
APPLY_SUM
计算 a 中数字值（INTEGER、FLOAT、NUMERIC 或 INTERVAL）的所有元素的总和。
APPLY_SVD
使用 SVD 模型转换数据。
APPROXIMATE_COUNT_DISTINCT
返回数据集中不同的非 NULL 值数量。
APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS
计算 APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 创建的概要对象中的非重复非 NULL 值的数量。
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS
汇总非重复的非 NULL 值的信息并将结果集实体化到 VARBINARY 或 LONG VARBINARY 概要对象中。
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS_MERGE
将多个概要聚合成一个新的概要。
APPROXIMATE_MEDIAN [Aggregate]
计算一组行中表达式的近似中间值。
APPROXIMATE_PERCENTILE [Aggregate]
计算一组行中表达式的近似百分值。
APPROXIMATE_QUANTILES
在用户指定的某些错误范围内，计算列的加权近似百分值数组。
ARGMAX [Analytic]
此函数是仿照数学函数 argmax(f(x)) 设计的，可返回使 f(x) 最大化的 x 值。
ARGMAX_AGG
接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。
ARGMIN [Analytic]
此函数是仿照数学函数 argmin(f(x)) 设计的，可返回使 f(x) 最小化的 x 值。
ARGMIN_AGG
接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。
ARRAY_CAT
连接元素类型和维度相同的两个数组。
ARRAY_CONTAINS
如果在数组中找到指定的元素，则返回 true，否则返回 false。
ARRAY_DIMS
返回输入数组的维度。
ARRAY_FIND
返回数组中指定元素的序号位置，如果未找到，则返回 -1。
ASCII
将 VARCHAR 数据类型的第一个字符转换为 INTEGER。
ASIN
返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正弦。
ATAN
返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正切。
ATAN2
返回一个 DOUBLE PRECISION 值，该值表示实参的算术被除数的三角反正切。
AUDIT
返回在审核数据库大小时计算的数据库、架构或表的原始数据大小（以字节为单位）。
AUDIT_FLEX
返回 raw 列的估算 ROS 大小，相当于审核对象中 flex 数据的导出大小。
AUDIT_LICENSE_SIZE
触发数据库大小的立即审核，以确定它是否符合 Vertica 许可证中的原始数据存储限额。
AUDIT_LICENSE_TERM
触发立即审核，以确定 Vertica 许可证是否已过期。
AUTOREGRESSOR
通过具有一致时间步长的平稳时间序列创建一个自回归 (AR) 模型，该模型随后可用于通过 PREDICT_AR 进行预测。
AVG [Aggregate]
计算一组行中表达式的平均值（算术平均值）。
AVG [Analytic]
计算窗口内一组中表达式的平均值。
AZURE_TOKEN_CACHE_CLEAR
清除 Azure 的缓存访问令牌。

B

BACKGROUND_DEPOT_WARMING
强制正在预热其存储库的节点开始处理查询，同时继续在后台预热其存储库。
BALANCE
根据 response_column 返回输入数据的平均分布视图。
BISECTING_KMEANS
对输入关系运行二分 k-means 算法。
BITCOUNT
在给定的 VARBINARY 值中返回一个二进制位数（有时称为设置位）。
BITSTRING_TO_BINARY
将给定的 VARCHAR 位字符串表示转换为 VARBINARY 值。
BIT_AND
采用所有非空输入值的按位 AND。
BIT_LENGTH
按位（字节数 * 8）返回字符串表达式的长度作为 INTEGER 数据类型。
BIT_OR
采用所有非空输入值的按位 OR。
BIT_XOR
采用所有非空输入值的按位 XOR。
BOOL_AND [Aggregate]
处理布尔值并返回布尔值结果。
BOOL_AND [Analytic]
返回窗口内某个表达式的布尔值。
BOOL_OR [Aggregate]
处理布尔值并返回布尔值结果。
BOOL_OR [Analytic]
返回窗口内某个表达式的布尔值。
BOOL_XOR [Aggregate]
处理布尔值并返回布尔值结果。
BOOL_XOR [Analytic]
返回窗口内某个表达式的布尔值。
BTRIM
从字符串的开头和结尾移除仅包含指定字符的最长字符串。
BUILD_FLEXTABLE_VIEW
创建或重新创建默认或用户定义键表的视图，忽略任何空键。

C

CALENDAR_HIERARCHY_DAY
指定将 DATE 分区键分组为年、月和日的层次结构。
CANCEL_DEPOT_WARMING
取消节点上的存储库预热。
CANCEL_REBALANCE_CLUSTER
停止任何正在进行中或正在等待执行的重新平衡任务。
CANCEL_REFRESH
取消由 START_REFRESH 和 REFRESH 发起的与刷新相关的内部操作。
CBRT
返回实参的立方根。
CEILING
将返回值向上舍入到下一个整数。
CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY
更改活动查询的运行时优先级。
CHANGE_RUNTIME_PRIORITY
更改主动运行查询的运行时优先级。
CHARACTER_LENGTH
CHARACTER_LENGTH() 函数。
CHR
将 INTEGER 数据类型的第一个字符转换为 VARCHAR。
CLEAN_COMMUNAL_STORAGE
将公共存储中的无效数据标记为待删除，通常是由于 Vertica 清理机制失败而泄露的数据。
CLEAR_CACHES
清除 Vertica 内部缓存文件。
CLEAR_DATA_COLLECTOR
清除数据收集器表和日志中的所有内存及磁盘记录，并重置系统表 DATA_COLLECTOR 中的收集统计信息。
CLEAR_DATA_DEPOT
删除指定的存储库数据。
CLEAR_DEPOT_PIN_POLICY_PARTITION
从指定的表或投影分区中清除存储库固定策略。
CLEAR_DEPOT_PIN_POLICY_PROJECTION
从指定的投影中清除存储库固定策略。
CLEAR_DEPOT_PIN_POLICY_TABLE
从指定的表中清除存储库固定策略。
CLEAR_FETCH_QUEUE
从公共存储中移除所有条目或数据获取请求队列中特定事务的条目。
CLEAR_HDFS_CACHES
清除从 HDFS 复制的配置信息和任何缓存的连接。
CLEAR_OBJECT_STORAGE_POLICY
从指定的数据库、架构或表中移除用户定义的存储策略。
CLEAR_PROFILING
从指定分析类型的内存数据中清除。
CLEAR_PROJECTION_REFRESHES
从系统表 PROJECTION_REFRESHES 中清除信息投影刷新历史记录。
CLEAR_RESOURCE_REJECTIONS
清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容。
CLOCK_TIMESTAMP
返回 TIMESTAMP WITH TIMEZONE 类型的值，该值表示当前系统时钟时间。
CLOSE_ALL_RESULTSETS
关闭多个活动结果集 (MARS) 中的所有结果集会话，并为其他结果集释放 MARS 存储。
CLOSE_ALL_SESSIONS
关闭所有外部会话（除发布此函数的外部会话以外）。
CLOSE_RESULTSET
关闭多个活动结果集 (MARS) 中的某一特定结果集，并释放其他结果集的 MARS 存储。
CLOSE_SESSION
中断指定的外部会话，回退当前事务（如果有），并关闭套接字。
CLOSE_USER_SESSIONS
停止用户会话，回退当前正在运行的任何事务，并关闭连接。
COALESCE
返回列表中第一个非空表达式的值。
COLLATION
可将一个排序规则应用于两个或更多字符串。
COMPACT_STORAGE
将现有数据 (.fdb) 和索引 (.pidx) 文件捆绑为 .gt 文件格式。
COMPUTE_FLEXTABLE_KEYS
计算来自 flex 表 VMap 数据的虚拟列（键和值）。
COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW
合并 BUILD_FLEXTABLE_VIEW 和 COMPUTE_FLEXTABLE_KEYS 的功能，以便计算来自 Flex 表 VMap 数据的虚拟列（键），并构建视图。
CONCAT
连接两个字符串并返回 varchar 数据类型。
CONDITIONAL_CHANGE_EVENT [Analytic]
从 0 开始向每个行分配一个事件窗口编号，并在当前行中评估参数表达式的结果与上一行不同时，以 1 为增量递增事件窗口编号。
CONDITIONAL_TRUE_EVENT [Analytic]
从 0 开始向每个行分配一个事件窗口编号，并在当 boolean 参数表达式的结果评估为 true 时，以 1 为增量递增事件窗口编号。
CONFUSION_MATRIX
使用响应变量的观察值和预测值计算表的混淆矩阵。
CONTAINS
如果在集合中找到指定的元素，则返回 true，否则返回 false。
COPY_PARTITIONS_TO_TABLE
将分区从一个表复制到另一个表中。
COPY_TABLE
将一个表复制到另一个表。
CORR
根据皮尔逊相关系数，返回一组表达式对的 DOUBLE PRECISION 相关系数。
CORR_MATRIX
接受包含数字列的输入关系，并计算每对输入列之间的皮尔逊相关系数。
COS
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角余弦。
COSH
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的双曲余弦。
COT
返回一个 DOUBLE PRECISION 值，该值表示实参的三角余切。
COUNT [Aggregate]
返回为 BIGINT，这是每个组中表达式不为 NULL 的行数。
COUNT [Analytic]
对窗口中某个组内的实例进行计数。
COVAR_POP
返回一组表达式对的总体方差。
COVAR_SAMP
返回一组表达式对的样本方差。
CROSS_VALIDATE
使用输入关系对学习算法执行 k-fold 交叉验证，并对超参数执行网格搜索。
CUME_DIST [Analytic]
计算窗口内同一分区中当前行的累计分布或相对于其他行的排序。
CURRENT_DATABASE
返回当前数据库的名称，等同于 DBNAME。
CURRENT_DATE
返回当前交易的开始日期（date-type 值）。
CURRENT_LOAD_SOURCE
在 COPY 语句的范围内调用时，返回用于加载的文件名。
CURRENT_SCHEMA
返回当前架构的名称。
CURRENT_TIME
返回一个 TIME WITH TIMEZONE 类型的值，该值表示当前事务的开始时间。
CURRENT_TIMESTAMP
返回一个 TIME WITH TIMEZONE 类型的值，该值表示当前事务的开始时间。
CURRENT_USER
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
CURRVAL
返回所有节点中的最后一个值，该值由当前会话中此序列的 NEXTVAL 进行设置。

D

DATA_COLLECTOR_HELP
返回有关数据收集器、V_MONITOR.DATA_COLLECTOR 系统表和数据收集器控制函数的在线使用说明。
DATE
将输入值转换为 DATE 数据类型。
DATEDIFF
以指定的间隔返回两个日期之间的时间跨度。
DATE_PART
从日期/时间表达式中提取子字段，例如年份或小时，等同于 SQL 标准函数 EXTRACT。
DATE_TRUNC
将日期和时间值截断为指定的精度。
DAY
以整数形式从输入值中返回日期。
DAYOFMONTH
以整数形式返回月份第几日。
DAYOFWEEK
以整数形式返回星期几，其中星期日是第 1 天。
DAYOFWEEK_ISO
以整数形式返回 ISO 8061 星期几，其中星期一是第 1 天。
DAYOFYEAR
以整数形式返回年份第几日，其中 1 月 1 日是第 1 天。
DAYS
返回指定日期的整数值，其中 1 AD 为 1。
DBNAME（函数）
返回当前数据库的名称，等同于 CURRENT_DATABASE。
DECODE
逐一比较每个搜索值的表达式。
DEGREES
将表达式从弧度转换为小数度，或从度、分钟和秒转换为小数度。
DELETE_TOKENIZER_CONFIG_FILE
删除分词器配置文件。
DEMOTE_SUBCLUSTER_TO_SECONDARY
将主子群集转换为辅助子群集。
DENSE_RANK [Analytic]
在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。
DESCRIBE_LOAD_BALANCE_DECISION
评估是否存在适用于给定 IP 地址的任何负载均衡路由规则，并描述如何处理客户端连接。
DESIGNER_ADD_DESIGN_QUERIES
读取并评估某个输入文件中的查询，并将其接受的查询添加到指定设计中。
DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS
执行指定的查询并评估以下列中的结果：
DESIGNER_ADD_DESIGN_QUERY
读取和解析指定的查询，如果已接受，将其添加到设计。
DESIGNER_ADD_DESIGN_TABLES
将指定表添加到设计中。
DESIGNER_CANCEL_POPULATE_DESIGN
如果指定设计当前正在运行，取消对指定设计的填充和部署操作。
DESIGNER_CREATE_DESIGN
使用指定名称创建设计。
DESIGNER_DESIGN_PROJECTION_ENCODINGS
在指定投影中分析编码，创建脚本以实施编码建议并选择性地部署建议。
DESIGNER_DROP_ALL_DESIGNS
移除所有与当前用户关联的 Database Designer 相关的架构。
DESIGNER_DROP_DESIGN
移除与指定设计及其所有内容相关联的架构。
DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS
在标准输出中显示定义设计投影的 DDL 语句。
DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT
在标准输出中显示指定设计的部署脚本。
DESIGNER_RESET_DESIGN
丢弃上一次 Database Designer 构建或部署的指定设计的所有运行特定信息，但会保留其配置。
DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY
填充设计并创建设计和部署脚本。
DESIGNER_SET_DESIGN_KSAFETY
为全面设计设置 K-safety 值并将 K-safety 值存储在 DESIGNS 表中。
DESIGNER_SET_DESIGN_TYPE
指定 Database Designer 是创建全面设计还是增量设计。
DESIGNER_SET_OPTIMIZATION_OBJECTIVE
仅对全面数据库设计有效，用于指定 Database Designer 使用的优化目标。
DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS
指定设计是否可以包括未分段的投影。
DESIGNER_SINGLE_RUN
评估在指定时间跨度内完成执行的所有查询，并返回可用于部署的设计。
DESIGNER_WAIT_FOR_DESIGN
等待正在填充和部署设计的操作完成。
DETECT_OUTLIERS
根据异常值阈值返回数据集中的异常值。
DISABLE_DUPLICATE_KEY_ERROR
禁止 Vertica 在运行时找到重复主键值或唯一键值的情况下传送错误消息（与未自动启用的键约束一起使用）。
DISABLE_LOCAL_SEGMENTS
禁用本地数据分段，本地数据分段会将节点上的投影分段拆分至可轻松移动到其他节点上的容器中。
DISABLE_PROFILING
禁止当前会话收集指定类型的分析数据。
DISPLAY_LICENSE
返回 Vertica 许可证的期限。
DISTANCE
返回两点之间的距离（以千米为单位）。
DISTANCEV
使用 Vincenty 公式返回两点之间的距离（以千米为单位）。
DO_TM_TASK
运行 Tuple Mover (TM) 操作并提交当前事务。
DROP_EXTERNAL_ROW_COUNT
移除由 ANALYZE_EXTERNAL_ROW_COUNT 编译的外部表行计数统计信息。
DROP_LICENSE
从全局编录中删除许可证密钥。
DROP_LOCATION
永久移除已停用的存储位置。
DROP_PARTITIONS
删除指定的表分区键。
DROP_STATISTICS
移除先前由 ANALYZE_STATISTICS 生成的数据库投影的统计数据。
DROP_STATISTICS_PARTITION
移除先前由 ANALYZE_STATISTICS_PARTITION 生成的数据库投影的统计数据。
DUMP_CATALOG
返回 Vertica 编录的内部表示。
DUMP_LOCKTABLE
返回关于死锁的客户端及其等待的资源的信息。
DUMP_PARTITION_KEYS
转储系统中所有投影的分区键。
DUMP_PROJECTION_PARTITION_KEYS
转储指定投影的分区键。
DUMP_TABLE_PARTITION_KEYS
转储指定表的所有投影的分区键。

E

EDIT_DISTANCE
计算并返回两个字符串之间的 Levenshtein 距离。
EMPTYMAP
构建一个有一行但无键值或数据的 VMap。
ENABLED_ROLE
检查是否启用了 Vertica 用户角色，并返回 true 或 false。
ENABLE_ELASTIC_CLUSTER
启用弹性群集调整，通过将一个节点的数据分段至可以轻松移动至其他主机的区块中，弹性群集调整可更为有效地扩大或缩小数据库群集的大小。
ENABLE_LOCAL_SEGMENTS
启用本地存储分段，本地存储分段可以将节点上的投影分段拆分到可以轻松移动至其他节点的容器中。
ENABLE_PROFILING
允许当前会话收集指定类型的分析数据。
ENFORCE_OBJECT_STORAGE_POLICY
立即应用指定对象的存储策略。
ERROR_RATE
使用输入表返回一个计算错误分类率并将其显示为 FLOAT 值的表。
EVALUATE_DELETE_PERFORMANCE
针对潜在的 DELETE 和 UPDATE 性能问题对投影进行评估。
EVENT_NAME
返回一个 VARCHAR 值，表示与行匹配事件的名称。
EXP
返回指数函数，即某个数字的 e 次幂。
EXPLODE
将集合（ARRAY 或 SET）中的一列或多列扩展为单独的表行，每个元素一行，并在查询中指定任何其他列。
EXPONENTIAL_MOVING_AVERAGE [Analytic]
使用平滑系数 X 计算表达式 E 的指数移动平均线 (EMA)。
EXPORT_CATALOG
生成 SQL 脚本，从而在其他群集上重新创建物理架构设计。
EXPORT_DIRECTED_QUERIES
生成 SQL，用于通过一组输入查询创建定向查询。
EXPORT_MODELS
导出机器学习模型。
EXPORT_OBJECTS
生成一个 SQL 脚本，可用于在其他群集上重新创建非虚拟编录对象。
EXPORT_STATISTICS
从之前通过 ANALYZE_STATISTICS 收集的数据中生成 XML 格式的统计信息。
EXPORT_STATISTICS_PARTITION
从之前通过 ANALYZE_STATISTICS_PARTITION 收集的数据中生成 XML 格式的分区级别统计信息。
EXPORT_TABLES
生成一个 SQL 脚本，可用于在其他群集上重新创建逻辑架构—架构、表、约束和视图。
EXTERNAL_CONFIG_CHECK
测试 Vertica 群集的 Hadoop 配置。
EXTRACT
从日期/时间值中检索子字段，例如年份或小时，然后返回类型为 NUMERIC 的值。

F

FINISH_FETCHING_FILES
将排队等待从公共存储下载的所有文件提取到存储库。
FIRST_VALUE [Analytic]
用于选择表或分区的第一个值（由 window-order-clause 决定），无需使用自联接。
FLOOR
将返回值向下舍入为前一个整数。
FLUSH_DATA_COLLECTOR
等待内存日志移至磁盘后，刷新数据收集器，同时将日志与磁盘存储同步。
FLUSH_REAPER_QUEUE
删除数据库中所有标记为待删除的数据。

G

GETDATE
返回当前语句的开始日期和时间，作为 TIMESTAMP 值。
GETUTCDATE
返回当前语句的开始日期和时间，作为 TIMESTAMP 值。
GET_AHM_EPOCH
返回 Ancient History Mark 所在的时期编号。
GET_AHM_TIME
返回代表 Ancient History Mark 的 TIMESTAMP 值。
GET_AUDIT_TIME
报告自动审核数据库大小的时间。
GET_CLIENT_LABEL
返回当前会话的客户端连接标签。
GET_COMPLIANCE_STATUS
显示您的数据库是否符合 Vertica 许可证协议要求。
GET_CONFIG_PARAMETER
获取指定级别的配置参数的值。
GET_CURRENT_EPOCH
当前正在将数据（COPY、INSERT、UPDATE 和 DELETE 操作）写入到的时期。
GET_DATA_COLLECTOR_NOTIFY_POLICY
列出在数据收集器组件上设置的所有通知策略。
GET_DATA_COLLECTOR_POLICY
检索与指定组件的保留政策有关的简短声明。
GET_LAST_GOOD_EPOCH
返回上一个完好的时期编号。
GET_METADATA
返回 Parquet 文件的元数据。
GET_MODEL_ATTRIBUTE
从模型中提取某个特定属性或从模型中提取所有属性。
GET_MODEL_SUMMARY
返回模型的摘要信息。
GET_NUM_ACCEPTED_ROWS
返回在当前会话的上一个已完成加载中加载到数据库的行数。
GET_NUM_REJECTED_ROWS
返回在当前会话的上一个已完成加载期间拒绝的行数。
GET_PRIVILEGES_DESCRIPTION
返回当前用户对于对象所拥有的有效权限，包括显式权限、隐式权限、继承的权限和基于角色的权限。
GET_PROJECTIONS
返回指定锚表的投影的上下文和投影信息。
GET_PROJECTION_SORT_ORDER
返回投影的 ORDER BY 子句中列的顺序。
GET_PROJECTION_STATUS
返回与投影状态相关的信息。
GET_TOKENIZER_PARAMETER
返回给定分词器的配置参数。
GREATEST
返回任何数据类型的表达式列表中的最大值。
GREATESTB
使用二进制排序返回任何数据类型的表达式列表中的最大值。
GROUPING
当具有多级别聚合的 GROUP BY 查询生成 NULL 值以确定分组列中的小计时，消除 NULL 值的使用。
GROUPING_ID
将 GROUPING 函数生成的布尔值集连接到位向量。
GROUP_ID
唯一标识返回重复分组集的重复 GROUP BY 查询集。

H

HADOOP_IMPERSONATION_CONFIG_CHECK
报告 Vertica 在访问 HDFS 中的 Kerberized 数据时将使用的委派令牌。
HASH
通过函数实参计算哈希值，从而产生位于范围 0 <= x < 263 内的值。
HASH_EXTERNAL_TOKEN
返回字符串令牌的哈希值，以与 HADOOP_IMPERSONATION_CONFIG_CHECK 结合使用。
HAS_ROLE
检查是否将 Vertica 用户角色授予了指定的用户或角色，并返回 true 或 false。
HAS_TABLE_PRIVILEGE
返回 true 或 false，以验证用户是否具有表的指定权限。
HCATALOGCONNECTOR_CONFIG_CHECK
测试使用 HCatalog 连接器访问 Hive 数据的 Vertica 群集的配置。
HDFS_CLUSTER_CONFIG_CHECK
测试使用 HDFS 的 Vertica 群集的配置。
HEX_TO_BINARY
将给定的 VARCHAR 十六进制表示方式转换为 VARBINARY 值。
HEX_TO_INTEGER
将给定的 VARCHAR 十六进制表示方式转换为 INTEGER 值。
HOUR
以整数形式返回指定日期的小时部分，其中 0 指 00:00 到 00:59。

I

IFNULL
返回列表中第一个非空表达式的值。
IMPLODE
接受任何标量类型的一列并返回一个无界数组。
IMPORT_DIRECTED_QUERIES
将定向查询从 EXPORT_DIRECTED_QUERIES 生成的 SQL 文件导入到数据库编录。
IMPORT_MODELS
将模型导入 Vertica，可以是使用 EXPORT_MODELS 导出的 Vertica 模型，也可以是预测模型标记语言 (PMML) 或 TensorFlow 格式的模型。
IMPORT_STATISTICS
从使用 EXPORT_STATISTICS 生成的 XML 文件中导入统计信息。
IMPUTE
根据每列中变量的观察值，使用平均值或众数估算数据集中的缺失值。
INET_ATON
将包含 IPv4 网络地址的点分表示的字符串转换为 INTEGER。
INET_NTOA
将 INTEGER 值转换为 IPv4 网络地址的 VARCHAR 点分表示。
INFER_EXTERNAL_TABLE_DDL
检查 Parquet、ORC 或 Avro 格式的文件，并返回可用于读取此文件的 CREATE EXTERNAL TABLE AS COPY 语句。
INFER_TABLE_DDL
检查 Parquet、ORC、JSON 或 Avro 格式的文件，并根据其内容返回 CREATE TABLE 或 CREATE EXTERNAL TABLE 语句。
INITCAP
使每个字母数字单词的首字母大写，并使其余字母小写。
INITCAPB
使每个字母数字单词的首字母大写，并使其余字母小写。
INSERT
将一个字符串插入另一个字符串的指定位置。
INSTALL_LICENSE
在全局编录中安装许可证密钥。
INSTR
搜索字符串中的子字符串，并返回一个整数，指示字符串中第一次出现的字符的位置。
INSTRB
搜索字符串中的子字符串，并返回一个整数，指示字符串中第一次出现的八位字节的位置。
INTERRUPT_STATEMENT
中断用户会话中的指定语句，回滚当前事务，把成功/失败消息写入日志文件。
ISFINITE
测试特殊的 TIMESTAMP 常量 INFINITY，并返回类型为 BOOLEAN 的值。
ISNULL
返回列表中第一个非空表达式的值。
ISUTF8
测试字符串是否是有效的 UTF-8 字符串。

J

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

K

KERBEROS_CONFIG_CHECK
测试 Vertica 群集的 Kerberos 配置。
KERBEROS_HDFS_CONFIG_CHECK
测试使用 HDFS 的 Vertica 群集的 Kerberos 配置。
KMEANS
对输入关系执行 k-means 算法。

L

LAG [Analytic]
在窗口内当前行之前按照给定的偏移量返回该输入表达式的值。
LAST_DAY
返回指定日期内月份的最后一天。
LAST_INSERT_ID
返回 AUTO_INCREMENT/IDENTITY 列的最后一个值。
LAST_VALUE [Analytic]
用于选择表或分区的最后一个值（由 window-order-clause 决定），无需使用自联接。
LDAP Link 函数
此部分包含与 Vertica LDAP Link 服务相关的函数。
LDAP_LINK_DRYRUN_CONNECT
将一组 LDAP Link 连接参数作为实参，并在 LDAP 服务器和 Vertica 之间开始试运行连接。
LDAP_LINK_DRYRUN_SEARCH
将一组 LDAP Link 连接和搜索参数作为实参，并开始试运行搜索将从 LDAP 服务器导入的用户和组。
LDAP_LINK_DRYRUN_SYNC
将一组 LDAP Link 连接和搜索参数作为实参，并在数据库和 LDAP 服务器之间开始试运行同步，此操作可将 LDAP 服务器的用户和组与其在 Vertica 中的等效项相互映射和同步。
LDAP_LINK_SYNC_CANCEL
取消 LDAP 服务器和 Vertica 之间正在进行的 LDAP Link 同步（包括通过 LDAP_LINK_DRYRUN_SYNC 启动的同步）。
LDAP_LINK_SYNC_START
立即开始 LDAP 服务器和 Vertica 之间的同步，而不是等待在 LDAPLinkInterval 中设置的时间间隔。
LEAD [Analytic]
返回值所在行是在窗口内当前行后面，这样可以同时访问表中多个行。
LEAST
返回任何数据类型的表达式列表中的最小值。
LEASTB
使用二进制排序返回任何数据类型的表达式列表中的最小值。
LEFT
返回字符串左侧指定字符。
LENGTH
返回字符串的长度。
LIFT_TABLE
返回一个对比机器学习模型的可预测质量的表。
LINEAR_REG
对输入关系执行线性回归，并返回线性回归模型。
LISTAGG
将一组行中的非空值转换为由逗号（默认）或可配置分隔符分隔的值列表。
LIST_ENABLED_CIPHERS
返回启用的密码套件列表，这些套件是用于保护 TLS/SSL 连接的算法集。
LN
返回实参的自然对数。
LOCALTIME
返回一个 TIME 类型的值，该值表示当前事务的开始时间。
LOCALTIMESTAMP
返回一个 TIMESTAMP/TIMESTAMPTZ 类型的值，该值表示当前事务的开始时间，且在事务关闭之前保持不变。
LOG
返回实参的指定底的对数。
LOG10
返回实参的以 10 为底的对数，也称为常用对数。
LOGISTIC_REG
对输入关系执行逻辑回归。
LOWER
接受一个字符串值并返回一个转换为小写的 VARCHAR 值。
LOWERB
返回一个所有 ASCII 字符都转换为小写的字符串。
LPAD
返回一个 VARCHAR 值，该值表示在左侧用特定字符填充的特定长度的字符串。
LTRIM
返回一个表示从左侧（前部）移除空格的字符串的 VARCHAR 值。

M

MAKEUTF8
通过移除或替换非 UTF-8 字符，将字符串强制转换为 UTF-8。
MAKE_AHM_NOW
将 Ancient History Mark (AHM) 设置为允许的最大值。
MAPAGGREGATE
返回从 VARCHAR 的两个输入列提供的具有键和值对的 LONG VARBINARY VMap。
MAPCONTAINSKEY
确定 VMap 是否含有虚拟列（键）。
MAPCONTAINSVALUE
确定 VMap 是否含有指定值。
MAPDELIMITEDEXTRACTOR
用分隔符和其他可选实参提取数据，并返回单一的 VMap 值。
MAPITEMS
返回关于 VMap 中各项目的信息。
MAPJSONEXTRACTOR
提取重复 JSON 数据对象（包括嵌套映射）或具有 JSON 元素外部列表的数据的内容。
MAPKEYS
返回任何 VMap 数据中存在的虚拟列（和值）。
MAPKEYSINFO
从给定映射中返回虚拟列信息。
MAPLOOKUP
从 VMAP 数据中返回单个键值。
MAPPUT
接受一个 VMap 和一个或多个键/值对，并返回一个添加了键/值对的新 VMap。
MAPREGEXEXTRACTOR
使用正则表达式提取数据，并以 VMap 的形式返回结果。
MAPSIZE
返回任何 VMap 数据中存在的虚拟列数。
MAPTOSTRING
递归地创建表示 VMap 数据的字符串，包括嵌套 JSON 映射。
MAPVALUES
返回表示来自 VMap 顶层值的字符串。
MAPVERSION
返回任何映射数据的版本或无效性。
MARK_DESIGN_KSAFE
如果出现故障，在您的环境中启用或禁用高可用性。
MATCH_COLUMNS
指定为 SELECT 列表中的元素，返回查询表中与指定模式匹配的所有列。
MATCH_ID
将成功模式匹配作为 INTEGER 值返回。
MATERIALIZE_FLEXTABLE_COLUMNS
将列出的虚拟列实体化为使用 COMPUTE_FLEXTABLE_KEYS 或 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 计算的 flextable_keys 表中的 key_names。
MAX [Aggregate]
返回一组行表达式的最大值。
MAX [Analytic]
返回窗口内某个表达式的最大值。
MD5
计算字符串的 MD5 哈希值，将结果以十六进制的 VARCHAR 字符串形式返回。
MEASURE_LOCATION_PERFORMANCE
测量存储位置的磁盘性能。
MEDIAN [Analytic]
对于每一行，返回每个分区内值集的中值。
MEMORY_TRIM
调用 glibc 函数 malloc_trim()，以从 malloc 中回收可用内存并将其返回给操作系统。
MICROSECOND
以整数形式返回指定日期的微秒部分。
MIDNIGHT_SECONDS
在指定日期内，返回午夜与日期时间部分之间的秒数。
MIGRATE_ENTERPRISE_TO_EON
将 Enterprise 数据库迁移到 Eon 模式数据库。
MIN [Aggregate]
返回一组行表达式的最小值。
MIN [Analytic]
返回窗口内某个表达式的最小值。
MINUTE
以整数形式返回指定日期的分钟部分。
MOD
返回除法运算的余数。
MONTH
以整数形式返回指定日期的月份部分。
MONTHS_BETWEEN
返回两个日期之间的月份数。
MOVE_PARTITIONS_TO_TABLE
将分区从一个表移至另一个表。
MOVE_STATEMENT_TO_RESOURCE_POOL
尝试将指定查询移动至指定目标池。
MOVING_AVERAGE
通过具有一致时间步长的稳定时间序列创建移动平均 (MA) 模型，该模型随后可用于通过 PREDICT_MOVING_AVERAGE 进行预测。
MSE
返回一个表，其中显示机器学习模型中预测和响应列的均方误差。

N

NAIVE_BAYES
对输入关系执行朴素贝叶斯算法，并返回朴素贝叶斯模型。
NEW_TIME
将时间戳值从一个时区转换为另一个时区并返回一个 TIMESTAMP。
NEXTVAL
返回序列中的下一个值。
NEXT_DAY
返回指定日期之后一周中特定一天的第一个实例的日期。
NORMALIZE
对输入关系运行标准化算法。
NORMALIZE_FIT
NORMALIZE_FIT 将计算输入关系中每个指定列的标准化参数。
NOTIFY
向 NOTIFIER 发送指定消息。
NOW [Date/Time]
返回一个 TIMESTAMP WITH TIME ZONE 类型的值，它表示当前事务的开始时间。
NTH_VALUE [Analytic]
在窗口的第 n 行（从第 1 行开始计数）上求值并返回求值结果。
NTILE [Analytic]
将有序数据集（分区）等分成窗口内的 {value} 个子集，通过参数 constant-value 中的值将其中的子集编号指定为 1。
NULLIF
比较两个表达式。
NULLIFZERO
如果列中的值为 0，则计算结果为 NULL。
NVL
返回列表中第一个非空表达式的值。
NVL2
接受三个实参。

O

OCTET_LENGTH
将一个实参作为输入，并返回所有字符串类型的字符串长度（八位字节）。
ONE_HOT_ENCODER_FIT
为要编码的每个功能生成每个类别级别的排序列表，并存储模型。
OVERLAPS
计算两个时间段，并在其重叠时返回 true，否则返回 false。
OVERLAY
将一个字符串的一部分替换为另一个字符串，并将新的字符串值以 VARCHAR 形式返回。
OVERLAYB
将一个字符串的一部分替换为另一个字符串，并将新的字符串以八位字节值的形式返回。

P

PARTITION_PROJECTION
拆分指定投影的 ROS 容器。
PARTITION_TABLE
调用 Tuple Mover，以根据需要重新组织 ROS 存储容器，以便符合当前分区策略。
PATTERN_ID
返回匹配模式实例的全分区唯一标识符整数值。
PATTERN_NAME
返回一个 VARCHAR 值，该值表示与行匹配的模式的名称。
PCA
通过输入表/视图计算主组件。
PERCENTILE_CONT [Analytic]
一个逆分布函数，在此函数中，对于每行，PERCENTILE_CONT 将返回窗口内每个分区中的一组值中落入指定百分位的值。
PERCENTILE_DISC [Analytic]
一个逆分布函数，在此函数中，对于每行，PERCENTILE_DISC 将返回窗口内每个分区中的一组值中落入指定百分位的值。
PERCENT_RANK [Analytic]
通过用行的排名（减去 1）除以分区中行的数量（也减去 1），计算在窗口内组中给定行的行相对排名。
PI
返回常数 pi (P)，即欧式几何中任何圆的周长与其直径的比值。返回类型为 DOUBLE PRECISION。
POSITION
返回示带字符串的特定子字符串的字符位置的 INTEGER 值表（从 1 开始计数）。
POSITIONB
返回一个 INTEGER 值，该值表示指定子字符串的八位字节在字符串中的位置（从 1 开始计数）。
POWER
返回一个 DOUBLE PRECISION 值，该值表示（一个数字）的（另外一个数字）次幂。
PRC
返回一个表，其中显示了接收器 Precision Recall (PR) 曲线上的点。
PREDICT_AUTOREGRESSOR
对输入关系应用自回归 (AR) 模型。
PREDICT_LINEAR_REG
对输入关系应用线性回归模型，并将预测值以 FLOAT 形式返回。
PREDICT_LOGISTIC_REG
对输入关系应用逻辑回归模型。
PREDICT_MOVING_AVERAGE
对输入关系应用使用 MOVING_AVERAGE 创建的移动平均 (MA) 模型。
PREDICT_NAIVE_BAYES
对输入关系应用朴素贝叶斯模型。
PREDICT_NAIVE_BAYES_CLASSES
对输入关系应用朴素贝叶斯模型，并返回类的概率值。
PREDICT_PMML
对输入关系应用导入的 PMML 模型。
PREDICT_RF_CLASSIFIER
对输入关系应用随机森林模型。
PREDICT_RF_CLASSIFIER_CLASSES
对输入关系应用随机森林模型，并返回类的概率值。
PREDICT_RF_REGRESSOR
对输入关系应用随机森林模型，并返回 FLOAT 数据类型，该数据类型用于指定随机森林模型的预测值，即森林中树木的平均预测值。
PREDICT_SVM_CLASSIFIER
使用 SVM 模型预测输入关系中样本的类标签，并将预测值以 FLOAT 数据类型返回。
PREDICT_SVM_REGRESSOR
使用 SVM 模型对输入关系中的样本执行回归，并将预测值以 FLOAT 数据类型返回。
PREDICT_TENSORFLOW
对输入关系应用 TensorFlow 模型，并返回编码模型类型的预期结果。
PREDICT_XGB_CLASSIFIER
对输入关系应用 XGBoost 分类器模型。
PREDICT_XGB_CLASSIFIER_CLASSES
对输入关系应用 XGBoost 分类器模型，并返回类的概率值。
PREDICT_XGB_REGRESSOR
对输入关系应用 XGBoost 回归模型。
PROMOTE_SUBCLUSTER_TO_PRIMARY
将辅助子群集转换为主子群集。
PURGE
从 ROS 存储容器中永久移除删除向量，以便可以重新使用磁盘空间。
PURGE_PARTITION
清除已删除行的表分区。
PURGE_PROJECTION
从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。
PURGE_TABLE
从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。

Q

QUARTER
以整数形式返回指定日期的日历季度，其中一月至三月的季度为 1。
QUOTE_IDENT
以所需的格式返回指定的字符串实参，以便将字符串用作 SQL 语句中的标识符。
QUOTE_LITERAL
返回以适当方式引用的给定字符串，以便用作 SQL 语句字符串中的一个字符串字面量。
QUOTE_NULLABLE
返回以适当方式引用的给定字符串，以便用作 SQL 语句字符串中的一个字符串字面量；或者如果实参为 null，则返回未引用的字符串 NULL。

R

RADIANS
返回一个 DOUBLE PRECISION 值，该值表示以弧度表示的角度。
RANDOM
返回均匀分布的随机 DOUBLE PRECISION 值 x，其中 0 <= x < 1。
RANDOMINT
接受并返回一个 INTEGER 值。
RANDOMINT_CRYPTO
接受并返回从 0 到指定函数实参 -1 之间的一组值中的一个 INTEGER 值。
RANK [Analytic]
在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。
READ_CONFIG_FILE
读取并返回给定分词器的所有参数的键值对。
READ_TREE
读取随机森林或 XGBoost 模型中树的内容。
REALIGN_CONTROL_NODES
启用大型群集时，导致 Vertica 重新评估群集或子群集中哪些节点是控制节点，以及哪些节点作为依赖节点分配给控制节点。
REBALANCE_CLUSTER
一个会话前台任务，将同步重新平衡数据库群集。
REBALANCE_SHARDS
在 Eon 模式下重新平衡子群集或整个群集中的分片分配。
REBALANCE_TABLE
同步重新平衡指定表中的数据。
REENABLE_DUPLICATE_KEY_ERROR
通过逆转 DISABLE_DUPLICATE_KEY_ERROR 的影响来恢复错误报告的默认行为。
REFRESH
在前台同步刷新一个或多个表投影，并更新 PROJECTION_REFRESHES 系统表。
REFRESH_COLUMNS
刷新使用约束 SET USING 或 DEFAULT USING 定义的表列。
REGEXP_COUNT
返回正则表达式与字符串匹配的次数。
REGEXP_ILIKE
如果字符串包含正则表达式的匹配项，则返回 True。
REGEXP_INSTR
返回字符串中正则表达式所匹配的开始或结束位置。
REGEXP_LIKE
如果字符串与正则表达式匹配，则返回 True。
REGEXP_NOT_ILIKE
如果字符串与不区分大小写的正则表达式不匹配，则返回 True。
REGEXP_NOT_LIKE
如果字符串不包含正则表达式的匹配项，则返回 True。
REGEXP_REPLACE
将所有与正则表达式匹配的子字符串实例替换为另一个子字符串。
REGEXP_SUBSTR
返回字符串内与正则表达式匹配的子字符串。
REGR_AVGX
返回表达式对中独立表达式的 DOUBLE PRECISION 平均值。
REGR_AVGY
返回表达式对中依赖表达式的 DOUBLE PRECISION 平均值。
REGR_COUNT
返回表达式对中所有行的计数。
REGR_INTERCEPT
返回由一组表达式对确定的回归线的 y 截距。
REGR_R2
返回一组表达式对的相关系数的平方。
REGR_SLOPE
返回由一组表达式对确定的回归线的斜率。
REGR_SXX
返回独立表达式 (expression2) 与其平均值之差的平方和。
REGR_SXY
返回依赖表达式 (expression1) 与其平均值之差和独立表达式 (expression2) 与其平均值之差的乘积之和。
REGR_SYY
返回依赖表达式 (expression1) 与其平均值之差的平方和。
RELEASE_JVM_MEMORY
终止 Java 虚拟机 (JVM)，使 JVM 所用的内存变为可用状态。
RELEASE_SYSTEM_TABLES_ACCESS
启用非超级用户对所有系统表的访问权限。
RELOAD_ADMINTOOLS_CONF
更新群集中每个 UP 节点上的 admintools.conf。
RELOAD_SPREAD
更新对编录的 Spread 配置文件的群集更改。
REPEAT
将字符串复制指定次数并连接复制的值作为单个字符串。
REPLACE
将字符串中的所有字符实例替换为另一组字符。
RESERVE_SESSION_RESOURCE
保留 General 资源池中的内存资源，以仅供 Vertica 备份和还原进程使用。
RESET_LOAD_BALANCE_POLICY
重置群集中的每个主机所维护的计数器，该计数器用于跟踪当本机连接负载均衡方案设置为 ROUNDROBIN 时将客户端指向的主机。
RESET_SESSION
将默认的连接字符串配置设置应用于当前会话。
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
恢复键表和视图。
RESTORE_LOCATION
恢复之前使用 RETIRE_LOCATION 停用的存储位置。
RESTRICT_SYSTEM_TABLES_ACCESS
检查系统表 SYSTEM_TABLES 以确定非超级用户可以访问哪些系统表。
RETIRE_LOCATION
停用指定的存储位置。
REVERSE_NORMALIZE
对标准化数据进行反向标准化转换，从而使标准化数据非标准化。
RF_CLASSIFIER
训练随机森林模型，以对输入关系进行分类。
RF_PREDICTOR_IMPORTANCE
使用平均减少杂质 (MDI) 方法衡量随机森林模型中预测工具的重要性。
RF_REGRESSOR
训练随机森林模型，以对输入关系执行回归。
RIGHT
从字符串右侧返回指定的字符。
ROC
返回表，其中显示了操作特征曲线的接收器上的点。
ROUND
将值四舍五入到指定的小数位数，保留原始精度和小数位数。
ROW_NUMBER [Analytic]
为窗口分区中的每行分配一个唯一的序列编号，从 1 开始。
RPAD
返回一个 VARCHAR 值，表示在右侧填充了特定字符的特定长度的字符串。
RSQUARED
返回一个表，其中包含回归模型中预测的 R 平方值。
RTRIM
返回 VARCHAR 值，表示已从右侧（末尾）移除尾随空格的字符串。
RUN_INDEX_TOOL
在 Vertica 数据库上运行索引工具以执行以下任务之一：

S

SECOND
以整数形式返回指定日期的秒部分。
SECURITY_CONFIG_CHECK
返回各种安全相关参数的状态。
SESSION_USER
返回 VARCHAR，其中包含发起当前数据库会话的用户的名称。
SET_AHM_EPOCH
将 Ancient History Mark (AHM) 设置为指定的时期。
SET_AHM_TIME
将 Ancient History Mark (AHM) 设置为与启动程序节点上的指定时间相应的时期。
SET_AUDIT_TIME
设置 Vertica 执行自动数据库大小审核的时间，以确定数据库大小是否符合 Vertica 许可证中的原始数据限额。
SET_CLIENT_LABEL
将标签分配到当前会话的客户端连接。
SET_CONFIG_PARAMETER
设置或清除指定级别的配置参数。
SET_CONTROL_SET_SIZE
设置启用大型群集时参与 spread 服务的控制节点的数量。
SET_DATA_COLLECTOR_NOTIFY_POLICY
为数据收集器组件创建/启用通知策略。
SET_DATA_COLLECTOR_POLICY
更新指定组件的以下保留策略属性：。
SET_DATA_COLLECTOR_TIME_POLICY
更新指定组件的保留策略属性 INTERVAL_TIME。
SET_DEPOT_PIN_POLICY_PARTITION
将表或投影的指定分区固定到子群集存储库或所有数据库存储库，以减少存储库逐出的风险。
SET_DEPOT_PIN_POLICY_PROJECTION
将投影固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。
SET_DEPOT_PIN_POLICY_TABLE
将表固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。
SET_LOAD_BALANCE_POLICY
设置本机连接负载均衡如何选择主机来处理客户端连接。
SET_LOCATION_PERFORMANCE
设置存储位置的磁盘性能。
SET_OBJECT_STORAGE_POLICY
通过为数据库对象分配一个标记存储位置来创建或更改其存储策略。
SET_SCALING_FACTOR
设置比例因子，比例因子决定在重新平衡数据库和启用了使用局部数据分段时，所使用的存储容器数量。
SET_SPREAD_OPTION
更改 spread 守护程序设置。
SET_TOKENIZER_PARAMETER
配置分词器参数。
SET_UNION
返回包含两个输入集的所有元素的 SET。
SHA1
使用美国安全哈希算法 1 计算字符串的 SHA1 哈希。
SHA224
使用美国安全哈希算法 2 计算字符串的 SHA224 哈希。
SHA256
使用美国安全哈希算法 2 计算字符串的 SHA256 哈希。
SHA384
使用美国安全哈希算法 2 计算字符串的 SHA384 哈希。
SHA512
使用美国安全哈希算法 2 计算字符串的 SHA512 哈希。
SHOW_PROFILING_CONFIG
显示是否启用分析。
SHUTDOWN
关闭 Vertica 数据库。
SHUTDOWN_SUBCLUSTER
关闭子群集。
SIGN
返回 DOUBLE PRECISION 值 -1、0 或 1，该值表示实参的算术符号。
SIN
返回 DOUBLE PRECISION 值，表示已传递参数的三角正弦。
SINH
返回 DOUBLE PRECISION 值，表示已传递参数的双曲正弦。
SLEEP
在执行另一个语句或命令之前等待指定的秒数。
SOUNDEX
接受一个 VARCHAR 实参并返回一个四字符代码，该代码可以将该实参与其他 SOUNDEX 编码的字符串进行比较，这些字符串的英语拼写不同，但在语音上相似。
SOUNDEX_MATCHES
比较两个字符串的 Soundex 编码。
SPACE
返回指定数量的空格，通常用于插入字符串。
SPLIT_PART
使用分隔符拆分字符串，并返回指定字段开头位置的字符串（从 1 开始计数）。
SPLIT_PARTB
使用分隔符拆分字符串，并返回指定字段开头位置的字符串（从 1 开始计数）。
SQRT
返回一个 DOUBLE PRECISION 值，该值表示实参的算术平方根。
START_REAPING_FILES
一个异步函数，在后台启动磁盘文件删除。
START_REBALANCE_CLUSTER()
一个后台任务，异步重新平衡数据库群集。
START_REFRESH
使用各自锚表的最新数据刷新当前架构中的投影。
STATEMENT_TIMESTAMP
类似于 TRANSACTION_TIMESTAMP，返回一个 TIMESTAMP WITH TIME ZONE 类型的值，表示当前语句的开始时间。
STDDEV [Aggregate]
求出组中每个成员的统计样本标准差。
STDDEV [Analytic]
计算当前行相对于窗口内组的统计样本标准偏差。
STDDEV_POP [Aggregate]
求出组中每个成员的统计总体标准差。
STDDEV_POP [Analytic]
计算统计总体标准差，并返回窗口内总体方差的平方根。
STDDEV_SAMP [Aggregate]
求出组中每个成员的统计样本标准差。
STDDEV_SAMP [Analytic]
计算当前行相对于窗口内组的统计样本标准偏差。
STRING_TO_ARRAY
拆分包含数组值的字符串并返回原生一维数组。
STRPOS
返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数）。
STRPOSB
返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数），其中字符串中的每个八位字节也被计算在内（与字符相反）。
STV_AsGeoJSON
返回 Javascript 几何对象表示法 (GeoJSON) 对象形式的几何或地理参数。
STV_Create_Index
对一组多边形创建空间索引，以加快与一组点的空间相交计算速度。
STV_DWithin
确定从一个空间对象的边界到另一个对象的边界的最短距离是否在指定的距离范围以内。
STV_Describe_Index
检索关于包含一组多边形的索引的信息。
STV_Drop_Index
删除空间索引。
STV_Export2Shapefile
将数据库表或子查询中的 GEOGRAPHY 或 GEOMETRY 数据导出到 shapefile 。
STV_Extent
返回一个包含所有输入数据的边界框。
STV_ForceLHR
更改空间对象的顶点顺序，使其遵循左手规则。
STV_Geography
将 GEOMETRY 对象转换为 GEOGRAPHY 对象。
STV_GeographyPoint
基于输入值，返回 GEOGRAPHY 点。
STV_Geometry
将 GEOGRAPHY 对象转换为 GEOMETRY 对象。
STV_GeometryPoint
基于输入值，返回 GEOMETRY 点。
STV_GetExportShapefileDirectory
返回导出目录的路径。
STV_Intersect Scalar Function
将一个点或多个点与一组多边形在空间上相交。
STV_Intersect Transform Function
将点与多边形在空间上相交。
STV_IsValidReason
确定空间对象的格式是否正确或其是否有效。
STV_LineStringPoint
检索线串或线串集合的顶点。
STV_MemSize
返回 INTEGER 类型的空间对象长度（以字节为单位）。
STV_NN
计算空间对象与参考对象之间的距离，并按照与参考对象的距离，以升序方式返回（对象，距离）对。
STV_PolygonPoint
将多边形的顶点作为个别点进行检索。
STV_Refresh_Index
将新添加或更新的多边形追加到现有的空间索引，以及从现有的空间索引中移除已删除的多边形。
STV_Rename_Index
为空间索引重命名。
STV_Reverse
反转空间对象顶点的顺序。
STV_SetExportShapefileDirectory
指定将 GEOMETRY 或 GEOGRAPHY 数据导出到 shapefile 的目录。
STV_ShpCreateTable
返回包含在指定的 shapefile 中找到的属性列和类型的 CREATE TABLE 语句。
STV_ShpSource 和 STV_ShpParser
这两个函数可与 COPY 配合使用，用于解析 shapefile 中的几何图形和属性并将其加载到 Vertica 表中，然后转换为合适的 GEOMETRY 数据类型。
ST_Area
计算空间对象的面积。
ST_AsBinary
创建空间对象的熟知二进制 (WKB) 表示。
ST_AsText
创建空间对象的熟知文本 (WKT) 表示。
ST_Boundary
计算指定 GEOMETRY 对象的边界。
ST_Buffer
创建与某个空间对象边界的距离大于或等于指定距离的 GEOMETRY 对象。
ST_Centroid
计算空间对象的几何中心（即质心）。
ST_Contains
确定空间对象是否完全在另一个空间对象内部，并且不仅仅在其边界上存在。
ST_ConvexHull
计算包含 GEOMETRY 对象的最小凸 GEOMETRY 对象。
ST_Crosses
确定一个 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上交叉。
ST_Difference
计算空间对象没有与另一个空间对象相交的部分。
ST_Disjoint
确定两个 GEOMETRY 对象是否未相交也未接触。
ST_Distance
计算两个空间对象之间的最短距离。
ST_Envelope
计算包含指定的 GEOMETRY 对象的最小边界矩形。
ST_Equals
确定两个空间对象在空间上是否等效。
ST_GeoHash
以指定的几何图形形状返回 GeoHash。
ST_GeographyFromText
将熟知文本 (WKT) 字符串转换为其对应的 GEOGRAPHY 对象。
ST_GeographyFromWKB
将熟知二进制 (WKB) 值转换为其对应的 GEOGRAPHY 对象。
ST_GeomFromGeoHash
以指定的 GeoHash 形状返回多边形。
ST_GeomFromGeoJSON
将标准格式的 GeoJSON 记录的几何图形部分转换为 GEOMETRY 对象。
ST_GeomFromText
将熟知文本 (WKT) 字符串转换为其对应的 GEOMETRY 对象。
ST_GeomFromWKB
将熟知二进制 (WKB) 值转换为其对应的 GEOMETRY 对象。
ST_GeometryN
返回几何图形对象内的第 n 个几何图形。
ST_GeometryType
确定空间对象的类。
ST_Intersection
计算两个 GEOMETRY 对象共有的点集。
ST_Intersects
确定两个 GEOMETRY 或 GEOGRAPHY 对象是否在一个点相交或接触。
ST_IsEmpty
确定空间对象是否表示空集。
ST_IsSimple
确定空间对象是否未与自身相交，也未接触其自身边界上的任何点。
ST_IsValid
确定空间对象的格式是否正确或其是否有效。
ST_Length
计算空间对象的长度。
ST_NumGeometries
返回空间对象内包含的几何图形数量。
ST_NumPoints
计算空间对象的顶点数，空对象则返回 NULL。
ST_Overlaps
确定 GEOMETRY 对象是否与另一个 GEOMETRY 对象共享空间但未完全包含在该对象范围内。
ST_PointFromGeoHash
返回指定 GeoHash 的中心点。
ST_PointN
查找空间对象的第 n 个点。
ST_Relate
基于指定的 DE-9IM 模式矩阵字符串，确定给定的 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上相关。
ST_SRID
确定随空间对象存储的空间参照系标识符 (SRID)。
ST_SymDifference
计算两个 GEOMETRY 对象中除它们共有的点之外的其他所有点，包括这两个对象的边界。
ST_Touches
确定两个 GEOMETRY 对象是否在一个点接触或沿边界接触，但没有内部相交。
ST_Transform
返回一个新的 GEOMETRY，其坐标转换为 srid 实参使用的空间参照系标识符 (SRID)。
ST_Union
计算两个空间对象中所有点的联合。
ST_Within
如果空间对象 g1 完全在空间对象 g2 内部，则 ST_Within 将返回 True。
ST_X
确定 GEOMETRY 点的 x 坐标或 GEOGRAPHY 点的经度值。
ST_XMax
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 x 坐标。
ST_XMin
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 x 坐标。
ST_Y
确定 GEOMETRY 点的 y 坐标或 GEOGRAPHY 点的纬度值。
ST_YMax
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 y 坐标。
ST_YMin
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 y 坐标。
SUBSTR
返回 VARCHAR 或 VARBINARY 值，表示指定字符串的子字符串。
SUBSTRB
返回一个八位字节值，表示指定字符串的子字符串。
SUBSTRING
给定值、位置和可选长度的条件下，返回表示指定字符串在给定位置的子字符串的值。
SUM [Aggregate]
基于行组计算表达式的总和
SUM [Analytic]
计算一个窗口内一组行的表达式总和。
SUMMARIZE_CATCOL
返回分类数据输入的统计摘要，分以下三列：
SUMMARIZE_NUMCOL
返回 Vertica 表中列的统计摘要。
SUM_FLOAT [Aggregate]
计算一组行的表达式总和并返回 DOUBLE PRECISION 值。
SVD
计算输入关系的 SVD 分解的奇异值（S 矩阵的对角线）和右奇异向量（V 矩阵）。
SVM_CLASSIFIER
针对输入关系训练 SVM 模型。
SVM_REGRESSOR
针对输入关系训练 SVM 模型。
SWAP_PARTITIONS_BETWEEN_TABLES
在两个表之间切换分区。
SYNC_CATALOG
将编录同步到公共存储，以便在编录快要崩溃时恢复当前编录版本。
SYNC_WITH_HCATALOG_SCHEMA
将通过 HCatalog 连接器可用的 Hive 数据库架构的结构复制到 Vertica 架构。
SYNC_WITH_HCATALOG_SCHEMA_TABLE
将通过 HCatalog 连接器可用的 Hive 数据库架构中的单个表结构复制到 Vertica 表。
SYSDATE
返回当前语句的开始日期和时间，作为 TIMESTAMP 值。

T

TAN
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角正切。
TANH
返回 DOUBLE PRECISION 值表示传递参数的双曲正切。
THROW_ERROR
返回用户定义的错误消息。
TIMEOFDAY
以文本字符串的形式返回时钟时间。
TIMESTAMPADD
将指定数量的间隔添加到 TIMESTAMP 或 TIMESTAMPTZ 值，并返回相同数据类型的结果。
TIMESTAMPDIFF
以指定的间隔返回两个 TIMESTAMP 或 TIMESTAMPTZ 值之间的时间跨度。
TIMESTAMP_ROUND
对指定的 TIMESTAMP 进行四舍五入。
TIMESTAMP_TRUNC
截断指定的 TIMESTAMP。
TIME_SLICE
按照不同的固定时间间隔聚合数据，并将向上舍入的输入 TIMESTAMP 值返回到与时间片间隔开始或结束时间相对应的值。
TO_BITSTRING
返回 VARCHAR，表示位字符串格式的给定 VARBINARY 值。
TO_CHAR
将日期/时间和数字值转换成文本字符串。
TO_DATE
转换字符串值为 DATE 类型。
TO_HEX
返回 VARCHAR 或 VARBINARY，表示等同于数值的十六进制值。
TO_JSON
返回复杂类型实参的 JSON 表示，包括混合和嵌套的复杂类型。
TO_NUMBER
转换字符串值为 DOUBLE PRECISION。
TO_TIMESTAMP
将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP 类型。
TO_TIMESTAMP_TZ
将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP WITH TIME ZONE 类型。
TRANSACTION_TIMESTAMP
返回一个 TIME WITH TIMEZONE 类型的值，该值表示当前事务的开始时间。
TRANSLATE
将 string_to_replace 中的单个字符替换为其他字符。
TRIM
将 BTRIM、LTRIM 和 RTRIM 函数合并为单个函数。
TRUNC
返回完全截断的表达式值（接近 0）。
TS_FIRST_VALUE
处理属于每个时间片的数据。
TS_LAST_VALUE
处理属于每个时间片的数据。

U

UPGRADE_MODEL
升级之前的 Vertica 版本中的模型。
UPPER
返回 VARCHAR 值，其中包含被转换为大写字母的实参。
UPPERB
返回一个字符串，其中所有 ASCII 字符都转换为大写。
URI_PERCENT_DECODE
根据 RFC 3986 标准，对百分比编码的通用资源标识符 (URI) 进行解码。
URI_PERCENT_ENCODE
根据百分比编码的 RFC 3986 标准，对通用资源标识符 (URI) 进行编码。
用户
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
USERNAME
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
UUID_GENERATE
返回基于 /dev/urandom 的高质量随机性生成的新通用唯一标识符 (UUID)。

V

V6_ATON
将包含以冒号分隔的 IPv6 网络地址的字符串转换为 VARBINARY 字符串。
V6_NTOA
将表示为变长二进制的 IPv6 地址转换为字符串。
V6_SUBNETA
从二进制或字母数字 IPv6 地址返回一个包含 CIDR（无类别域间路由）格式的子网地址的 VARCHAR。
V6_SUBNETN
从变长二进制或字母数字 IPv6 地址计算无类别域间路由 (CIDR) 格式的子网地址。
V6_TYPE
返回一个 INTEGER 值，该值对传递给它的网络地址的类型进行分类，如 IETF RFC 4291 第 2.4 节中所定义。
VALIDATE_STATISTICS
验证使用 EXPORT_STATISTICS 生成的 XML 文件中的统计信息。
VARIANCE [Aggregate]
求出组中每行的样本方差。
VARIANCE [Analytic]
返回窗口内组中每行的非 NULL 数字集（将忽略集中的 NULL）的样本方差。
VAR_POP [Aggregate]
求出组内每个成员的总体方差。
VAR_POP [Analytic]
返回窗口内组中非 null 数值集（将忽略 null 值）的统计总体方差。
VAR_SAMP [Aggregate]
求出组中每行的样本方差。
VAR_SAMP [Analytic]
返回窗口内组中每行的非 NULL 数字集（将忽略集中的 NULL）的样本方差。
VERIFY_HADOOP_CONF_DIR
验证用于访问 HDFS 的 Hadoop 配置在所有 Vertica 节点上是否有效。
VERSION
返回包含 Vertica 节点的版本信息的 VARCHAR。

W

WEEK
以整数形式返回指定日期为一年中的第几周，其中第一周从 1 月 1 日或之前的第一个星期日开始。
WEEK_ISO
以整数形式返回指定日期为一年中的第几周，其中第一周从星期一开始，包含 1 月 4 日。
WIDTH_BUCKET
构建等宽直方图，其中直方图的范围被分为相同大小的区间（存储桶）。
WITHIN GROUP ORDER BY 子句
指定如何对通过聚合函数分组的行进行排序，为以下几项之一：
工作负载管理函数
此部分包含 Vertica 专用的工作负载管理函数。

X

XGB_CLASSIFIER
训练 XGBoost 模型以对输入关系执行分类。
XGB_REGRESSOR
训练 XGBoost 模型以对输入关系执行回归。

Y

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

Z

ZEROIFNULL
如果列为 NULL，则计算为 0。

4.2 - 聚合函数

聚合函数通过行组汇总查询结果集的数据。这些组使用 GROUP BY 子句指定。其只允许出现在选择列表以及 SELECT 语句的 HAVING 和 ORDER BY 子句中（如 聚合表达式 中所述）。

注意

  • 如果未选择行，则这些函数将返回 null 值，COUNT 除外。尤其是，未选择行时 SUM 将返回 NULL，而不是零。

  • 在某些情况下，您可以将包含多个聚合的表达式替换为表达式的单个聚合。例如，SUM(x) + SUM(y) 可以表示为 SUM(x+y)（其中 x 和 y 为 NOT NULL）。

  • Vertica 不支持嵌套聚合函数。

还可以将某些简单的聚合函数用作分析（窗口）函数。有关详细信息，请参阅分析函数。另请参阅 SQL 分析。

4.2.1 - WITHIN GROUP ORDER BY 子句

指定如何对按聚合函数分组的行进行排序，为以下之一：

用户定义的聚合函数也支持此子句。

排序子句仅在每个组的结果集中指定顺序。查询可以有自己的 ORDER BY 子句，该子句优先于 WITHIN GROUP ORDER BY 指定的顺序，并对最终结果集进行排序。

语法

WITHIN GROUP (ORDER BY
  { column‑expression [ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] ]
  }[,...])

参数

column‑expression
列、常数或是针对列构成的任意表达式，用于对分组的行进行排序。
ASC | DESC
将排序顺序指定为升序（默认值）或降序。
NULLS {FIRST | LAST | AUTO}
指定是否将 null 值放在最前或最后。默认位置排放取决于排序顺序是升序还是降序：

  • 升序默认： NULLS LAST

  • 降序默认： NULLS FIRST

如果您指定了 NULLS AUTO，Vertica 选择对于此查询最有效的位置排放，即 NULLS FIRST 或 NULLS LAST。

如果您省略所有的排序限定符，Vertica 将使用 ASC NULLS LAST。

示例

有关使用示例，请参阅以下函数：

4.2.2 - APPROXIMATE_COUNT_DISTINCT

返回数据集中不同的非 NULL 值数量。

行为类型

不可变

语法

APPROXIMATE_COUNT_DISTINCT ( expression[, error-tolerance ] )

参数

表达式
要使用支持等式比较的任何数据类型评估的值。
error‑tolerance

表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。

您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。

如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。

限制

APPROXIMATE_COUNT_DISTINCT 和 DISTINCT 聚合不能在同一查询块中。

容错

APPROXIMATE_COUNT_DISTINCT(x, error‑tolerance) 返回的值等于 COUNT(DISTINCT x)，而误差以标准差呈对数正态分布。

参数 error‑tolerance 是可选参数。提供此实参以指定所需的标准偏差。error‑tolerance 被定义为 2.17 个标准偏差，对应 97% 的置信区间：

standard-deviation = error‑tolerance / 2.17

例如：

  • error‑tolerance = 1

    Default setting, corresponds to a standard deviation

    97 percent of the time, APPROXIMATE_COUNT_DISTINCT(x,5) returns a value between:

    • COUNT(DISTINCT x) * 0.99
    • COUNT(DISTINCT x) * 1.01
  • error‑tolerance = 5

    97% 的时间， APPROXIMATE_COUNT_DISTINCT(x) 返回介于以下两者之间的值：

    • COUNT(DISTINCT x) * 0.95
    • COUNT(DISTINCT x) * 1.05

99% 的置信区间对应 2.58 个标准偏差。要将 error-tolerance 设置为对应于 99%（而不是 97） 的置信水平，请将 error-tolerance 乘以 2.17 / 2.58 = 0.841。

例如，如果您将 error-tolerance 指定为 5 * 0.841 = 4.2，则 APPROXIMATE_COUNT_DISTINCT(x,4.2) 返回的值是介于以下结果之间的时间的 99%：

  • COUNT (DISTINCT x) * 0.95
  • COUNT (DISTINCT x) * 1.05

示例

计算表 store.store_sales_fact 的 product_key 列中不同值的总数：

=> SELECT COUNT(DISTINCT product_key) FROM store.store_sales_fact;

 COUNT
-------
 19982
(1 row)

计算具有不同容错值的 product_key 中不同值的近似值。容错值越小，近似值越接近实际值：


=> SELECT APPROXIMATE_COUNT_DISTINCT(product_key,5) AS five_pct_accuracy,
   APPROXIMATE_COUNT_DISTINCT(product_key,1) AS one_pct_accuracy,
   APPROXIMATE_COUNT_DISTINCT(product_key,.88) AS point_eighteight_pct_accuracy
   FROM store.store_sales_fact;


 five_pct_accuracy | one_pct_accuracy | point_eighteight_pct_accuracy
-------------------+------------------+-------------------------------
             19431 |            19921 |                         19921
(1 row)

另请参阅

近似计数区分函数

4.2.3 - APPROXIMATE_COUNT_DISTINCT_SYNOPSIS

汇总不同非 NULL 值的信息并将结果集实体化为 VARBINARY 或 LONG VARBINARY 概要对象。计算结果在规定的容错范围内。将概要对象保存在 Vertica 表中以供 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 使用。

行为类型

不可变

语法

APPROXIMATE_COUNT_DISTINCT_SYNOPSIS ( expression[, error‑tolerance] )

参数

表达式
使用支持等式比较的任何数据类型评估的值。
error‑tolerance

表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。

您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。

如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。

有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。

限制

APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 和 DISTINCT 聚合不能在同一查询块中。

示例

请参阅APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS。

另请参阅

近似计数区分函数

4.2.4 - APPROXIMATE_COUNT_DISTINCT_SYNOPSIS_MERGE

将多个概要聚合成一个新的概要。此函数类似于 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS，但返回一个概要而不是数量估计。此函数的优势是其在调用 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 时加快了最终估计。

例如，如果您需要在较长一段时间（例如几年）内定期估计不同用户的数量，您可以将天数的概要预先累积到一个一年的概要中。

行为类型

不可变

语法

APPROXIMATE_COUNT_DISTINCT_SYNOPSIS_MERGE ( synopsis-obj [, error‑tolerance] )

参数

synopsis-obj
可以评估为一个或多个概要的表达式。通常，synopsis-obj 由 APPROXIMATE_COUNT_DISTINCT 或 APPROXIMATE_COUNT_DISTINCT_SYNOPSIS_MERGE 函数生成为二进制字符串，并存储在类型为 VARBINARY 或 LONG VARBINARY 的表列中。
error‑tolerance

表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。

您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。

如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。

有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。

示例

请参阅近似计数区分函数。

4.2.5 - APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS

从由 APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 创建的概要对象中计算不同的非 NULL 值的数量。

行为类型

不可变

语法

APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS ( synopsis-obj[, error-tolerance ] )

参数

synopsis‑obj
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 创建的概要对象。
error‑tolerance

表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。

您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。

如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。

有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。

限制

APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 和 DISTINCT 聚合不能在同一查询块中。

示例

下例查看并比较获得表列中唯一值的数量的不同方法：

返回表 store.store_sales_fact 的 product_key 列中唯一值的确切数量：

=> \timing
Timing is on.
=> SELECT COUNT(DISTINCT product_key) from store.store_sales_fact;
 count
-------
 19982
(1 row)

Time: First fetch (1 row): 553.033 ms. All rows formatted: 553.075 ms

返回 product_key 列中唯一值的近似数量：

=> SELECT APPROXIMATE_COUNT_DISTINCT(product_key) as unique_product_keys
   FROM store.store_sales_fact;
 unique_product_keys
---------------------
               19921
(1 row)

Time: First fetch (1 row): 394.562 ms. All rows formatted: 394.600 ms

创建一个表示一组具有唯一 product_key 值的 store.store_sales_fact 数据的概要对象，将概要存储在新表 my_summary 中：


=> CREATE TABLE my_summary AS SELECT APPROXIMATE_COUNT_DISTINCT_SYNOPSIS (product_key) syn
   FROM store.store_sales_fact;
CREATE TABLE
Time: First fetch (0 rows): 582.662 ms. All rows formatted: 582.682 ms

从保存的概要返回数量：


=> SELECT APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS(syn) FROM my_summary;
 ApproxCountDistinctOfSynopsis
-------------------------------
                         19921
(1 row)

Time: First fetch (1 row): 105.295 ms. All rows formatted: 105.335 ms

另请参阅

近似计数区分函数

4.2.6 - APPROXIMATE_MEDIAN [聚合]

计算一组行中表达式的近似中间值。该函数返回一个 FLOAT 值。

APPROXIMATE_MEDIAN 是 APPROXIMATE_PERCENTILE [聚合] 的别名，参数为 0.5。

行为类型

不可变

语法

APPROXIMATE_MEDIAN ( expression )

参数

表达式
任意 FLOAT 或 INTEGER 数据类型。函数返回近似中值或排序后成为近似中值的内插值。计算中忽略空值。

示例

以下示例使用此表：

CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;

计算此表中所有销售额的近似中间值：

=> SELECT APPROXIMATE_MEDIAN (sales) FROM allsales;
APROXIMATE_MEDIAN
--------------------
                 20
(1 row)

您可以修改此查询，按州对销售进行分组，然后获取每组的近似中间值：

=> SELECT state, APPROXIMATE_MEDIAN(sales) FROM allsales GROUP BY state;
 state | APPROXIMATE_MEDIAN
-------+--------------------
 MA    |                 35
 NY    |                 20
(2 rows)

另请参阅

4.2.7 - APPROXIMATE_PERCENTILE [聚合]

计算一组行中表达式的近似百分值。此函数返回一个 FLOAT 值。

行为类型

不可变

语法

APPROXIMATE_PERCENTILE ( column-expression USING PARAMETERS percentiles='percentile-values' )

参数

column-expression
将计算其百分值的 FLOAT 或 INTEGER 数据类型的列。忽略 NULL 值。

参数

percentiles
一个或多个（最多 1000 个）逗号分隔的 FLOAT 常量，范围从 0 到 1（包含），指定要计算的百分值。

示例

以下示例使用此表：

=> CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;

=> SELECT * FROM allsales;
 state | name | sales
-------+------+-------
 MA    | A    |    60
 NY    | B    |    20
 NY    | C    |    15
 NY    | F    |    40
 MA    | D    |    20
 MA    | E    |    50
 MA    | G    |    10
(7 rows)

计算每个州的销售的近似百分值：

=> SELECT state, APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0.5') AS median
FROM allsales GROUP BY state;
 state | median
-------+--------
 MA    |     35
 NY    |     20
(2 rows)

计算每个州的销售的多个近似百分值：

=> SELECT state, APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0.5,1.0')
FROM allsales GROUP BY state;
 state | APPROXIMATE_PERCENTILE
-------+--------
 MA    |     [35.0,60.0]
 NY    |     [20.0,40.0]

(2 rows)

计算每个州的销售的多个近似百分值，并在单独的列中显示每个百分值的结果：

=> SELECT ps[0] as q0, ps[1] as q1, ps[2] as q2, ps[3] as q3, ps[4] as q4
FROM (SELECT APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0, 0.25, 0.5, 0.75, 1')
AS ps FROM allsales GROUP BY state) as s1;

  q0  |  q1  |  q2  |  q3  |  q4
------+------+------+------+------
 10.0 | 17.5 | 35.0 | 52.5 | 60.0
 15.0 | 17.5 | 20.0 | 30.0 | 40.0

(2 rows)

另请参阅

4.2.8 - APPROXIMATE_QUANTILES

在用户指定的某些错误范围内，计算列的加权近似百分值数组。此算法类似于 APPROXIMATE_PERCENTILE [聚合]（但其返回一个百分值）。

此函数的性能完全取决于指定的 epsilon 和所提供数组的大小。

此函数的 OVER 子句必须为空。

行为类型

不可变

语法

APPROXIMATE_QUANTILES ( column USING PARAMETERS [nquantiles=n], [epsilon=error] ) OVER() FROM table

参数

column
要计算百分值的 INTEGER 或 FLOAT 列。忽略 NULL 值。
n
指定返回数组中所需分位数数量的整数。

默认值： 11

error
返回的任何百分值的允许误差。具体来说，对于大小为 N 的数组，φ-分位数的指定误差 ε (epsilon) 保证返回值的排名 r 相对于精确值的排名 ⌊φN⌋ 是这样的：

⌊(φ-ε)N⌋ ≤ r ≤ ⌊(φ+ε)N⌋

对于 n 分位数，如果指定误差 ε，使得 ε > 1/n，此函数将返回非确定性结果。

默认值： 0.001

table
包含列的表。

示例

以下示例使用此表：

=> CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;

=> SELECT * FROM allsales;
 state | name | sales
-------+------+-------
 MA    | A    |    60
 NY    | B    |    20
 NY    | C    |    15
 NY    | F    |    40
 MA    | D    |    20
 MA    | E    |    50
 MA    | G    |    10
(7 rows)

对 APPROXIMATE_QUANTILES 的调用返回一个由近似百分值组成的 6 元素数组，每个分位数一个。每个分位数与百分值的关系为 100 倍。例如，输出中的第二个条目指示 15 是输入列的 0.2 分位数，因此 15 是输入列的第 20 个百分值。

=> SELECT APPROXIMATE_QUANTILES(sales USING PARAMETERS nquantiles=6) OVER() FROM allsales;
 Quantile | Value
----------+-------
        0 |    10
      0.2 |    15
      0.4 |    20
      0.6 |    40
      0.8 |    50
        1 |    60
(6 rows)

4.2.9 - ARGMAX_AGG

接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。ARGMAX_AGG 在 target 中查找具有最大非 null 值的行，并返回该行中的 arg 值。如果多行包含最高 target 值，则 ARGMAX_AGG 将返回它找到的第一行中的 arg。使用 WITHIN GROUP ORDER BY 子句控制 ARGMAX_AGG 先查找哪一行。

行为类型

不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在组内解析为唯一值的一列或一组列；否则为 易变。

语法

ARGMAX_AGG ( target, arg ) [ within‑group‑order‑by‑clause ]

参数

target, arg
查询数据集中的列。
within‑group‑order‑by‑clause
对每组行中的目标值进行排序： 
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])

sort‑qualifiers：

   { ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }

此子句用于确定当多行包含最高目标值时返回哪一行；否则，结果可能会随着同一查询的每次迭代而变化。

示例

以下示例在 WITH 子句 中调用 ARGMAX_AGG 以查找每个区域中的哪些员工已达到或接近退休年龄。如果每个区域内有多个员工的年龄相同，ARGMAX_AGG 会选择工资水平最高的员工并返回其 ID。主要查询返回有关从每个区域中选择的员工的详细信息：

=> WITH r AS (SELECT employee_region, ARGMAX_AGG(employee_age, employee_key)
       WITHIN GROUP (ORDER BY annual_salary DESC) emp_id
       FROM employee_dim GROUP BY employee_region ORDER BY employee_region)
    SELECT r.employee_region, ed.annual_salary AS highest_salary, employee_key,
       ed.employee_first_name||' '||ed.employee_last_name AS employee_name, ed.employee_age
       FROM r JOIN employee_dim ed ON r.emp_id = ed.employee_key ORDER BY ed.employee_region;
         employee_region          | highest_salary | employee_key |  employee_name   | employee_age
----------------------------------+----------------+--------------+------------------+--------------
 East                             |         927335 |           70 | Sally Gauthier   |           65
 MidWest                          |         177716 |          869 | Rebecca McCabe   |           65
 NorthWest                        |         100300 |         7597 | Kim Jefferson    |           65
 South                            |         196454 |          275 | Alexandra Harris |           65
 SouthWest                        |         198669 |         1043 | Seth Stein       |           65
 West                             |         197203 |          681 | Seth Jones       |           65
(6 rows)

另请参阅

ARGMIN_AGG

4.2.10 - ARGMIN_AGG

接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。ARGMIN_AGG 在 target 中查找具有最小非 null 值的行，并返回该行中的 arg 值。如果多行包含最低 target 值，则 ARGMIN_AGG 将返回它找到的第一行中的 arg。使用 WITHIN GROUP ORDER BY 子句控制 ARGMMIN_AGG 先查找哪一行。

行为类型

不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在组内解析为唯一值的一列或一组列；否则为 易变。

语法

ARGMIN_AGG ( target, arg ) [ within‑group‑order‑by‑clause ]

参数

target, arg
查询数据集中的列。
within‑group‑order‑by‑clause
对每组行中的目标值进行排序： 
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])

sort‑qualifiers：

   { ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }

此子句用于确定当多行包含最低目标值时返回哪一行；否则，结果可能会随着同一查询的每次迭代而变化。

示例

以下示例在 WITH 子句中调用 ARGMIN_AGG，以查找每个地区所有员工中的最低工资，并返回最低工资员工的 ID。主要查询返回工资金额和员工姓名：

=> WITH msr (employee_region, emp_id) AS
    (SELECT employee_region, argmin_agg(annual_salary, employee_key) lowest_paid_employee FROM employee_dim GROUP BY employee_region)
    SELECT msr.employee_region, ed.annual_salary AS lowest_salary, ed.employee_first_name||' '||ed.employee_last_name AS employee_name
     FROM msr JOIN employee_dim ed ON msr.emp_id = ed.employee_key ORDER BY annual_salary DESC;
         employee_region          | lowest_salary |  employee_name
----------------------------------+---------------+-----------------
 NorthWest                        |         20913 | Raja Garnett
 SouthWest                        |         20750 | Seth Moore
 West                             |         20443 | Midori Taylor
 South                            |         20363 | David Bauer
 East                             |         20306 | Craig Jefferson
 MidWest                          |         20264 | Dean Vu
(6 rows)

另请参阅

ARGMAX_AGG

4.2.11 - AVG [聚合]

计算一组行中表达式的平均值（算术平均值）。AVG 始终返回 DOUBLE PRECISION 值。

AVG 聚合函数与 AVG 分析函数不同，它计算一个 窗口内一组行中表达式的平均值。

行为类型

不可变

语法

AVG ( [ ALL | DISTINCT ] expression )

参数

ALL
调用组中所有行的聚合函数（默认）。
DISTINCT
调用组中发现的表达式中所有区分非空值的聚合函数。
表达式
在一组行中计算任何可以具有 DOUBLE PRECISION 结果的表达式的平均值的值。

溢出处理

默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

示例

以下查询返回客户表的平均收入：

=> SELECT AVG(annual_income) FROM customer_dimension;
     AVG
--------------
 2104270.6485
(1 row)

另请参阅

4.2.12 - BIT_AND

采用所有非空输入值的按位 AND。如果输入参数为 NULL，那么返回值也将为 NULL。

行为类型

不可变

语法

BIT_AND ( expression )

参数

表达式
要求值的 BINARY 或 VARBINARY 输入值。BIT_AND 以显式方式对 VARBINARY 类型进行操作，并通过 casts 以隐式方式对 BINARY 类型进行操作。

返回

BIT_AND 返回：

  • 与实参数据类型相同的值。

  • 1 — 对于比较的每个位，如果所有位为 1，否则为 0。

如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，BIT_AND 将忽略 null 值并将值 f 扩展为 f0。

示例

示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：

=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));

查询表 t 以查看列 c 输出：

=> SELECT TO_HEX(c) FROM t;
 TO_HEX
--------
 ff00
 ffff
 f00f
(3 rows)

查询表 t 以获取列 c 的 AND 值：

=> SELECT TO_HEX(BIT_AND(c)) FROM t;
 TO_HEX
--------
 f000
(1 row)

该函数将成对应用于组中的所有值，由此导致 f000，具体由以下条件确定：

  1. ff00 （记录 1）与 ffff（记录 2）进行比较，得到 ff00。

  2. 从上一比较中得到的结果与 f00f（记录 3）进行比较，得到 f000。

另请参阅

二进制数据类型（BINARY 和 VARBINARY）

4.2.13 - BIT_OR

采用所有非空输入值的按位 OR。如果输入参数为 NULL，那么返回值也将为 NULL。

行为类型

不可变

语法

BIT_OR ( expression )

参数

表达式
要求值的 BINARY 或 VARBINARY 输入值。BIT_OR 以显式方式对 VARBINARY 类型进行操作，并通过 casts 以隐式方式对 BINARY 类型进行操作。

返回

BIT_OR 返回：

  • 与实参数据类型相同的值。

  • 1 — 对于比较的每个位，如果任意位为 1，否则为 0。

如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，该函数将忽略 null 值并将值 f 扩展为 f0。

示例

示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：

=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));

查询表 t 以查看列 c 输出：

=> SELECT TO_HEX(c) FROM t;
 TO_HEX
--------
 ff00
 ffff
 f00f
(3 rows)

查询表t以获取列c的 OR 值：

=> SELECT TO_HEX(BIT_OR(c)) FROM t;
 TO_HEX
--------
 ffff
(1 row)

该函数将成对应用于组中的所有值，由此导致 ffff，具体由以下条件确定：

  1. ff00 （记录 1）与 ffff 进行比较，得到 ffff。

  2. 从上一比较中得到的 ff00 结果与 f00f（记录 3）进行比较，得到 ffff。

另请参阅

二进制数据类型（BINARY 和 VARBINARY）

4.2.14 - BIT_XOR

采用所有非空输入值的按位 XOR。如果输入参数为 NULL，那么返回值也将为 NULL。

行为类型

不可变

语法

BIT_XOR ( expression )

参数

表达式
需要求值的 BINARY 或 VARBINARY 输入值。 BIT_XOR 以显式方式对 VARBINARY 类型进行操作，并通过 casts 以隐式方式对 BINARY 类型进行操作。

返回

BIT_XOR 返回：

  • 与实参数据类型相同的值。

  • 1 — 对于比较的每个位，如果有奇数个实参包含设置位；否则为 0。

如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，该函数将忽略 null 值并将值 f 扩展为 f0。

示例

首先创建一个包含二进制列的示例表和投影：

示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：

=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));

查询表 t 以查看列 c 输出：

=> SELECT TO_HEX(c) FROM t;
 TO_HEX
--------
 ff00
 ffff
 f00f
(3 rows)

查询表 t 以获取列 c 的 XOR 值：

=> SELECT TO_HEX(BIT_XOR(c)) FROM t;
 TO_HEX
--------
 f0f0
(1 row)

另请参阅

二进制数据类型（BINARY 和 VARBINARY）

4.2.15 - BOOL_AND [聚合]

处理布尔值并返回布尔值结果。如果所有输入值都为 true，则 BOOL_AND 返回 t。否则返回 f (false)。

行为类型

不可变

语法

BOOL_AND ( expression )

参数

表达式
一个布尔数据类型或任何可隐式强制转换为布尔数据类型的非布尔数据类型。

示例

以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。

=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE

将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。

=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
 OUTPUT
--------
      8
(1 row)

查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。

=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;

    model     | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
 advanced     | f        | t               | t
 beginner     | f        | f               | f
 intermediate | t        | t               | f
 professional | f        | t               | t
(4 rows)

另请参阅

4.2.16 - BOOL_OR [聚合]

处理布尔值并返回布尔值结果。如果至少一个输入值为 true，则 BOOL_OR 返回 t。否则，它返回 f。

行为类型

不可变

语法

BOOL_OR ( expression )

参数

表达式
一个布尔数据类型或任何可隐式强制转换为布尔数据类型的非布尔数据类型。

示例

以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。

=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE

将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。

=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
 OUTPUT
--------
      8
(1 row)

查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。

=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;

    model     | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
 advanced     | f        | t               | t
 beginner     | f        | f               | f
 intermediate | t        | t               | f
 professional | f        | t               | t
(4 rows)

另请参阅

4.2.17 - BOOL_XOR [聚合]

处理布尔值并返回布尔值结果。特别是只有一个输入值为 true 时，BOOL_XOR 返回 t。否则，它返回 f。

行为类型

不可变

语法

BOOL_XOR ( expression )

参数

表达式
一个布尔数据类型或任何可隐式强制转换为布尔数据类型的非布尔数据类型。

示例

以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。

=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE

将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。

=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
 OUTPUT
--------
      8
(1 row)

查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。

=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;

    model     | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
 advanced     | f        | t               | t
 beginner     | f        | f               | f
 intermediate | t        | t               | f
 professional | f        | t               | t
(4 rows)

另请参阅

4.2.18 - CORR

根据 Pearson 相关系数，返回一组表达式对的 DOUBLE PRECISION 相关系数。 CORR 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。

语法

CORR ( expression1, expression2 )

参数

示例

=> SELECT CORR (Annual_salary, Employee_age) FROM employee_dimension;
         CORR
----------------------
 -0.00719153413192422
(1 row)

4.2.19 - COUNT [聚合]

返回为 BIGINT，这是每个组中表达式不为 NULL 的行数。如果查询没有 GROUP BY 子句，则 COUNT 返回表中的行数。

COUNT 聚合函数与 COUNT 分析函数不同，它返回 窗口中一组行的数量。

行为类型

不可变

语法

COUNT ( [ * ] [ ALL | DISTINCT ] expression )

参数

*
指定对指定的表或每个组中的所有行进行计数。
ALL | DISTINCT
指定在表达式具有非 NULL 值的情况下如何对行计数：

  • ALL （默认值）：在表达式计算结果为非 NULL 值的情况下对所有行计数。

  • DISTINCT：在表达式计算结果为不同的非 NULL 值的情况下对所有行计数。

表达式
对其非 NULL 值进行计数的列或表达式。

以下查询会返回 date_dimension 表的 date_key 列中不同值的数量：

=> SELECT COUNT (DISTINCT date_key) FROM date_dimension;


 COUNT
-------
  1826
(1 row)

此示例会返回对所有 inventory_fact 记录计算表达式 x+y 得到的所有不同值。

=> SELECT COUNT (DISTINCT date_key + product_key) FROM inventory_fact;


 COUNT
-------
 21560
(1 row)

可以使用 LIMIT 关键字限制返回的行数来创建等同的查询：

=> SELECT COUNT(date_key + product_key) FROM inventory_fact GROUP BY date_key LIMIT 10;


 COUNT
-------
   173
    31
   321
   113
   286
    84
   244
   238
   145
   202
(10 rows)

此查询会返回具有特定不同 date_key 值的所有记录中不同 product_key 值的数量。

=> SELECT product_key, COUNT (DISTINCT date_key)  FROM  inventory_fact
   GROUP BY product_key LIMIT 10;


 product_key | count
-------------+-------
           1 |    12
           2 |    18
           3 |    13
           4 |    17
           5 |    11
           6 |    14
           7 |    13
           8 |    17
           9 |    15
          10 |    12
(10 rows)

该查询通过常数 1 对 product_key 表中每个不同的 inventory_fact 值进行计数。

=> SELECT product_key, COUNT (DISTINCT product_key) FROM inventory_fact
   GROUP BY product_key LIMIT 10;


 product_key | count
-------------+-------
           1 |     1
           2 |     1
           3 |     1
           4 |     1
           5 |     1
           6 |     1
           7 |     1
           8 |     1
           9 |     1
          10 |     1
(10 rows)

该查询会选择每个不同的 date_key 值，并针对具有特定 product_key 值的所有记录为不同的product_key 值进行计数。然后，它会对具有特定 qty_in_stock 值的所有记录中的 product_key 值进行求和，并按照 date_key 对结果进行分组。

=> SELECT date_key, COUNT (DISTINCT product_key), SUM(qty_in_stock) FROM inventory_fact
   GROUP BY date_key LIMIT 10;


 date_key | count |  sum
----------+-------+--------
        1 |   173 |  88953
        2 |    31 |  16315
        3 |   318 | 156003
        4 |   113 |  53341
        5 |   285 | 148380
        6 |    84 |  42421
        7 |   241 | 119315
        8 |   238 | 122380
        9 |   142 |  70151
       10 |   202 |  95274
(10 rows)

该查询会选择每个不同的 product_key 值，然后针对具有特定 date_key 值的所有记录为不同的product_key 值进行计数。它还会对具有特定 warehouse_key 值的所有记录中的不同 product_key 值进行计数。

=> SELECT product_key, COUNT (DISTINCT date_key), COUNT (DISTINCT warehouse_key) FROM inventory_fact
   GROUP BY product_key LIMIT 15;


 product_key | count | count
-------------+-------+-------
           1 |    12 |    12
           2 |    18 |    18
           3 |    13 |    12
           4 |    17 |    18
           5 |    11 |     9
           6 |    14 |    13
           7 |    13 |    13
           8 |    17 |    15
           9 |    15 |    14
          10 |    12 |    12
          11 |    11 |    11
          12 |    13 |    12
          13 |     9 |     7
          14 |    13 |    13
          15 |    18 |    17
(15 rows)

该查询会选择每个不同的 product_key 值，为具有特定 date_key 值的所有记录的不同 warehouse_key 和 product_key 值进行计数，然后对具有特定 qty_in_stock 值的记录中的所有 product_key 值进行求和。然后，它会返回具有特定 product_version 值的记录中 product_key 值的数量。

=> SELECT product_key, COUNT (DISTINCT date_key),
      COUNT (DISTINCT warehouse_key),
      SUM (qty_in_stock),
      COUNT (product_version)
      FROM inventory_fact GROUP BY product_key LIMIT 15;


 product_key | count | count |  sum  | count
-------------+-------+-------+-------+-------
           1 |    12 |    12 |  5530 |    12
           2 |    18 |    18 |  9605 |    18
           3 |    13 |    12 |  8404 |    13
           4 |    17 |    18 | 10006 |    18
           5 |    11 |     9 |  4794 |    11
           6 |    14 |    13 |  7359 |    14
           7 |    13 |    13 |  7828 |    13
           8 |    17 |    15 |  9074 |    17
           9 |    15 |    14 |  7032 |    15
          10 |    12 |    12 |  5359 |    12
          11 |    11 |    11 |  6049 |    11
          12 |    13 |    12 |  6075 |    13
          13 |     9 |     7 |  3470 |     9
          14 |    13 |    13 |  5125 |    13
          15 |    18 |    17 |  9277 |    18
(15 rows)

以下示例会返回 warehouse 维度表中的仓库数。

=> SELECT COUNT(warehouse_name) FROM warehouse_dimension;


 COUNT
-------
   100
(1 row)

下一个示例会返回供应商总数：

=> SELECT COUNT(*) FROM vendor_dimension;


 COUNT
-------
    50
(1 row)

另请参阅

4.2.20 - COVAR_POP

返回一组表达式对的总体方差。返回值的类型为 DOUBLE PRECISION。 COVAR_POP 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。

语法

SELECT COVAR_POP ( expression1, expression2 )

参数

示例

=> SELECT COVAR_POP (Annual_salary, Employee_age)
      FROM employee_dimension;
     COVAR_POP
-------------------
 -9032.34810730019
(1 row)

4.2.21 - COVAR_SAMP

返回一组表达式对的样本方差。返回值的类型为 DOUBLE PRECISION。 COVAR_SAMP 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。

语法

SELECT COVAR_SAMP ( expression1, expression2 )

参数

示例

=> SELECT COVAR_SAMP (Annual_salary, Employee_age)
      FROM employee_dimension;
    COVAR_SAMP
-------------------
 -9033.25143244343
(1 row)

4.2.22 - GROUP_ID

唯一标识返回重复分组集的重复 GROUP BY 查询集。此函数返回一个或多个以零 (0) 开头的整数作为标识符。

对于特定分组的重复数量 n，GROUP_ID 返回一组连续的数字 0 到 n–1。对于它遇到的每个第一个唯一组，GROUP_ID 返回值 0。如果 GROUP_ID 再次发现了相同的分组，函数会返回 1，然后对下一个发现的分组返回 2，以此类推。

行为类型

不可变

语法

GROUP_ID ()

示例

此示例显示了 GROUP_ID 如何在查询产生重复分组时创建唯一标识符。对于费用表，以下查询按照费用类别和年份对结果进行分组，并 为这两个列计算汇总值。这些结果在类别和 NULL 方面具有重复分组。第一个分组的 GROUP_ID 为 0，第二个分组的 GROUP_ID 为 1。

=> SELECT Category, Year, SUM(Amount), GROUPING_ID(Category, Year),
   GROUP_ID() FROM expenses GROUP BY Category, ROLLUP(Category,Year)
   ORDER BY Category, Year, GROUPING_ID();
  Category   | Year |  SUM   | GROUPING_ID | GROUP_ID
-------------+------+--------+-------------+----------
 Books       | 2005 |  39.98 |           0 |        0
 Books       | 2007 |  29.99 |           0 |        0
 Books       | 2008 |  29.99 |           0 |        0
 Books       |      |  99.96 |           1 |        0
 Books       |      |  99.96 |           1 |        1
 Electricity | 2005 | 109.99 |           0 |        0
 Electricity | 2006 | 109.99 |           0 |        0
 Electricity | 2007 | 229.98 |           0 |        0
 Electricity |      | 449.96 |           1 |        1
 Electricity |      | 449.96 |           1 |        0

另请参阅

4.2.23 - GROUPING

当具有多级别聚合的 GROUP BY 查询生成 NULL 值以确定分组列中的小计时，消除 NULL 值的使用。这些来自于原始数据的 NULL 值也会发生在行中。 GROUPING 返回 1 — 在 expression 的值为以下值时：

  • NULL，表示聚合的值

  • 0 — 对任何其他值，包括行中的 NULL 值

行为类型

不可变

语法

GROUPING ( expression )

参数

表达式
GROUP BY 子句中的表达式

示例

以下查询使用 GROUPING 函数，将 GROUP BY 表达式之一作为实参。对于每一行，GROUPING 返回以下值之一：

  • 0：列是该行的组的一部分

  • 1：列不是该行的组的一部分

GROUPING(Year) 列中电力和书籍的值为 1，表示这些值是小计。GROUPING(Category) 和 GROUPING(Year) 最右边的列值为 1。此值表示两个列都不会成为 GROUP BY 的结果。最终行表示总销售量。

=> SELECT Category, Year, SUM(Amount),
   GROUPING(Category), GROUPING(Year) FROM expenses
   GROUP BY ROLLUP(Category, Year) ORDER BY Category, Year, GROUPING_ID();
   Category  | Year |  SUM   | GROUPING | GROUPING
-------------+------+--------+----------+----------
 Books       | 2005 |  39.98 |        0 |        0
 Books       | 2007 |  29.99 |        0 |        0
 Books       | 2008 |  29.99 |        0 |        0
 Books       |      |  99.96 |        0 |        1
 Electricity | 2005 | 109.99 |        0 |        0
 Electricity | 2006 | 109.99 |        0 |        0
 Electricity | 2007 | 229.98 |        0 |        0
 Electricity |      | 449.96 |        0 |        1
             |      | 549.92 |        1 |        1

另请参阅

4.2.24 - GROUPING_ID

将 GROUPING 函数生成的布尔值集连接到位向量。 GROUPING_ID 将位向量作为二进制数字进行处理，并将其作为可以确认分组集组合的十进制值返回。

通过使用 GROUPING_ID，不再需要多个单独的 GROUPING 函数。 GROUPING_ID 可以简化行筛选条件，因为使用 GROUPING_ID = n 的单一返回来确定感兴趣的行。使用 GROUPING_ID 确定分组组合。

行为类型

不可变

语法

GROUPING_ID ( [expression[,...] )
表达式
匹配 GROUP BY 子句中表达式之一的表达式。

如果 GROUP BY 子句包含表达式列表，GROUPING_ID 将会返回一个与关联到行的 GROUPING 位向量对应的数字。

示例

此示例显示如何调用 GROUPING_ID，示例中不使用返回与完整的多级别聚合表达式集关联的 GROUPING 位向量的表达式。GROUPING_ID 值与 GROUPING_ID(a,b) 差不多，因为 GROUPING_ID() 包括 GROUP BY ROLLUP 中的所有列：

=> SELECT a,b,COUNT(*), GROUPING_ID() FROM T GROUP BY ROLLUP(a,b);

在以下查询中，GROUPING(Category) 和 GROUPING(Year) 列具有三个组合：

  • 0,0

  • 0,1

  • 1,1

=> SELECT Category, Year, SUM(Amount),
   GROUPING(Category), GROUPING(Year) FROM expenses
   GROUP BY ROLLUP(Category, Year) ORDER BY Category, Year, GROUPING_ID();
  Category   | Year |  SUM   | GROUPING | GROUPING
-------------+------+--------+----------+----------
 Books       | 2005 |  39.98 |        0 |        0
 Books       | 2007 |  29.99 |        0 |        0
 Books       | 2008 |  29.99 |        0 |        0
 Books       |      |  99.96 |        0 |        1
 Electricity | 2005 | 109.99 |        0 |        0
 Electricity | 2006 | 109.99 |        0 |        0
 Electricity | 2007 | 229.98 |        0 |        0
 Electricity |      | 449.96 |        0 |        1
             |      | 549.92 |        1 |        1

GROUPING_ID 按照以下方式转换这些值：

二进制集值
十进制对等值
00
0
01
1
11
3
0
类别, 年份

以下查询返回 gr_id 列中显示的针对每个 GROUP BY 级别的单个数字：

=> SELECT Category, Year, SUM(Amount),
   GROUPING(Category),GROUPING(Year),GROUPING_ID(Category,Year) AS gr_id
   FROM expenses GROUP BY ROLLUP(Category, Year);
  Category   | Year |  SUM   | GROUPING | GROUPING | gr_id
-------------+------+--------+----------+----------+-------
 Books       | 2008 |  29.99 |        0 |        0 |     0
 Books       | 2005 |  39.98 |        0 |        0 |     0
 Electricity | 2007 | 229.98 |        0 |        0 |     0
 Books       | 2007 |  29.99 |        0 |        0 |     0
 Electricity | 2005 | 109.99 |        0 |        0 |     0
 Electricity |      | 449.96 |        0 |        1 |     1
             |      | 549.92 |        1 |        1 |     3
 Electricity | 2006 | 109.99 |        0 |        0 |     0
 Books       |      |  99.96 |        0 |        1 |     1

gr_id 值决定了每一行的 GROUP BY 级别：

GROUP BY 级别
GROUP BY 行级别
3
总计
1
类别
0
类别, 年份

您也可以通过单独比较每个搜索值，使用 DECODE 函数赋予这些值更多的含义。

=> SELECT Category, Year, SUM(AMOUNT), DECODE(GROUPING_ID(Category, Year),
       3, 'Total',
       1, 'Category',
       0, 'Category,Year')
   AS GROUP_NAME FROM expenses GROUP BY ROLLUP(Category, Year);
  Category   | Year |  SUM   |  GROUP_NAME
-------------+------+--------+---------------
 Electricity | 2006 | 109.99 | Category,Year
 Books       |      |  99.96 | Category
 Electricity | 2007 | 229.98 | Category,Year
 Books       | 2007 |  29.99 | Category,Year
 Electricity | 2005 | 109.99 | Category,Year
 Electricity |      | 449.96 | Category
             |      | 549.92 | Total
 Books       | 2005 |  39.98 | Category,Year
 Books       | 2008 |  29.99 | Category,Year

另请参阅

4.2.25 - LISTAGG

将一组行中的非空值转换为由逗号（默认）或可配置分隔符分隔的值列表。LISTAGG 可用于将行非标准化为串联值字符串。

行为类型

不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在聚合列表内解析为唯一值的一列或一组列；否则为 易变。

语法

LISTAGG ( aggregate‑expression [ USING PARAMETERS parameter=value][,...] ] ) [ within‑group‑order‑by‑clause ]

参数

aggregate‑expression
聚合一个或多个列或列表达式，以从源表或视图中选择。

LISTAGG 不直接支持空间数据类型。为了传递这种类型的列数据，使用地理空间函数 ST_AsText 将数据转换为字符串。

within‑group‑order‑by‑clause
对每组行中的聚合值进行排序，其中 column‑expression 通常是 aggregate‑expression 中的列： 
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])

sort‑qualifiers：

   { ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }

参数

特权

无

示例

在以下查询中，CityState 列中的聚合结果使用字符串“|”作为分隔符。外部的 GROUP BY 子句根据其 Region 值对输出行进行分组。在每个组中，根据 WITHIN GROUP ORDER BY 子句，聚合列表项根据其 city 值进行排序：

=> \x
Expanded display is on.
=> WITH cd AS (SELECT DISTINCT (customer_city) city, customer_state, customer_region FROM customer_dimension)
SELECT customer_region Region, LISTAGG(city||', '||customer_state USING PARAMETERS separator=' | ')
   WITHIN GROUP (ORDER BY city) CityAndState FROM cd GROUP BY region ORDER BY region;
-[ RECORD 1 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | East
CityAndState | Alexandria, VA | Allentown, PA | Baltimore, MD | Boston, MA | Cambridge, MA | Charlotte, NC | Clarksville, TN | Columbia, SC | Elizabeth, NJ | Erie, PA | Fayetteville, NC | Hartford, CT | Lowell, MA | Manchester, NH | Memphis, TN | Nashville, TN | New Haven, CT | New York, NY | Philadelphia, PA | Portsmouth, VA | Stamford, CT | Sterling Heights, MI | Washington, DC | Waterbury, CT
-[ RECORD 2 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | MidWest
CityAndState | Ann Arbor, MI | Cedar Rapids, IA | Chicago, IL | Columbus, OH | Detroit, MI | Evansville, IN | Flint, MI | Gary, IN | Green Bay, WI | Indianapolis, IN | Joliet, IL | Lansing, MI | Livonia, MI | Milwaukee, WI | Naperville, IL | Peoria, IL | Sioux Falls, SD | South Bend, IN | Springfield, IL
-[ RECORD 3 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | NorthWest
CityAndState | Bellevue, WA | Portland, OR | Seattle, WA
-[ RECORD 4 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | South
CityAndState | Abilene, TX | Athens, GA | Austin, TX | Beaumont, TX | Cape Coral, FL | Carrollton, TX | Clearwater, FL | Coral Springs, FL | Dallas, TX | El Paso, TX | Fort Worth, TX | Grand Prairie, TX | Houston, TX | Independence, MS | Jacksonville, FL | Lafayette, LA | McAllen, TX | Mesquite, TX | San Antonio, TX | Savannah, GA | Waco, TX | Wichita Falls, TX
-[ RECORD 5 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | SouthWest
CityAndState | Arvada, CO | Denver, CO | Fort Collins, CO | Gilbert, AZ | Las Vegas, NV | North Las Vegas, NV | Peoria, AZ | Phoenix, AZ | Pueblo, CO | Topeka, KS | Westminster, CO
-[ RECORD 6 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region       | West
CityAndState | Berkeley, CA | Burbank, CA | Concord, CA | Corona, CA | Costa Mesa, CA | Daly City, CA | Downey, CA | El Monte, CA | Escondido, CA | Fontana, CA | Fullerton, CA | Inglewood, CA | Lancaster, CA | Los Angeles, CA | Norwalk, CA | Orange, CA | Palmdale, CA | Pasadena, CA | Provo, UT | Rancho Cucamonga, CA | San Diego, CA | San Francisco, CA | San Jose, CA | Santa Clara, CA | Simi Valley, CA | Sunnyvale, CA | Thousand Oaks, CA | Vallejo, CA | Ventura, CA | West Covina, CA | West Valley City, UT

4.2.26 - MAX [聚合]

返回一组行表达式的最大值。返回值的类型与表达式数据类型相同。

MAX 分析函数与聚合函数的不同之处在于，它返回 窗口内一组行的表达式的最大值。

聚合函数 MIN 和 MAX 可以使用布尔值运行。MAX 可以执行布尔数据类型或可以隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN 返回 t (true)。否则返回 f。

行为类型

不可变

语法

MAX ( expression )

参数

表达式
计算其最大值的表达式，通常是列引用。

示例

以下查询返回列 sales_dollar_amount 中的最大值。

=> SELECT MAX(sales_dollar_amount) AS highest_sale FROM store.store_sales_fact;
 highest_sale
--------------
          600
(1 row)

以下示例显示了当您将 MIN 和 MAX 聚合函数与布尔值一起使用时，它们之间的区别。该示例创建一个表，添加两行数据，并显示 MIN 和 MAX 的示例输出。

另请参阅

数据聚合

4.2.27 - MIN [聚合]

返回一组行表达式的最小值。返回值的类型与表达式数据类型相同。

MIN分析函数与聚合函数的不同之处在于，它返回 窗口内一组行的表达式的最小值。

聚合函数 MIN 和 MAX 可以使用布尔值运行。MAX 可以执行布尔数据类型或可以隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN 返回 t (true)。否则返回 f。

行为类型

不可变

语法

MIN ( expression )

参数

表达式
为其计算最小值的任意表达式，通常为列引用。

示例

以下查询返回 employee 维度表的最低工资。

此示例说明如何查询以返回 employee 维度表的最低工资。

=> SELECT MIN(annual_salary) AS lowest_paid FROM employee_dimension;
 lowest_paid
-------------
        1200
(1 row)

以下示例显示了当您将 MIN 和 MAX 聚合函数与布尔值一起使用时，它们之间的区别。该示例创建一个表，添加两行数据，并显示 MIN 和 MAX 的示例输出。

另请参阅

数据聚合

4.2.28 - REGR_AVGX

返回表达式对中独立表达式的 DOUBLE PRECISION 平均值。 REGR_AVGX 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_AVGX 返回 NULL。

语法

SELECT REGR_AVGX ( expression1, expression2 )

参数

示例

=> SELECT REGR_AVGX (Annual_salary, Employee_age)
      FROM employee_dimension;
 REGR_AVGX
-----------
    39.321
(1 row)

4.2.29 - REGR_AVGY

返回表达式对中依赖表达式的 DOUBLE PRECISION 平均值。该函数消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。

语法

REGR_AVGY ( expression1, expression2 )

参数

示例

=> SELECT REGR_AVGY (Annual_salary, Employee_age)
      FROM employee_dimension;
 REGR_AVGY
------------
 58354.4913
(1 row)

4.2.30 - REGR_COUNT

返回表达式对中所有行的计数。该函数消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 0。

语法

SELECT REGR_COUNT ( expression1, expression2 )

参数

示例

=> SELECT REGR_COUNT (Annual_salary, Employee_age) FROM employee_dimension;
 REGR_COUNT
------------
      10000
(1 row)

4.2.31 - REGR_INTERCEPT

返回由一组表达式对确定的回归线的 y 截距。返回值的类型为 DOUBLE PRECISION。 REGR_INTERCEPT 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_INTERCEPT 返回 NULL。

语法

SELECT REGR_INTERCEPT ( expression1, expression2 )

参数

示例

=> SELECT REGR_INTERCEPT (Annual_salary, Employee_age) FROM employee_dimension;
  REGR_INTERCEPT
------------------
 59929.5490163437
(1 row)

4.2.32 - REGR_R2

返回一组表达式对的相关系数的平方。返回值的类型为 DOUBLE PRECISION。 REGR_R2 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_R2 返回 NULL。

语法

SELECT REGR_R2 ( expression1, expression2 )

参数

示例

=> SELECT REGR_R2 (Annual_salary, Employee_age) FROM employee_dimension;
       REGR_R2
----------------------
 5.17181631706311e-05
(1 row)

4.2.33 - REGR_SLOPE

返回由一组表达式对确定的回归线的斜率。返回值的类型为 DOUBLE PRECISION。 REGR_SLOPE 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SLOPE 返回 NULL。

语法

SELECT REGR_SLOPE ( expression1, expression2 )

参数

示例

=> SELECT REGR_SLOPE (Annual_salary, Employee_age) FROM employee_dimension;
    REGR_SLOPE
------------------
 -40.056400303749
(1 row)

4.2.34 - REGR_SXX

返回独立表达式 (expression2) 与其平均值之差的平方和。

即，REGR_SXX 返回： ∑[(expression2 - average(expression2)(expression2 - average(expression2)]

返回值的类型为 DOUBLE PRECISION。 REGR_SXX 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SXX 返回 NULL。

语法

SELECT REGR_SXX ( expression1, expression2 )

参数

示例

=> SELECT REGR_SXX (Annual_salary, Employee_age) FROM employee_dimension;
  REGR_SXX
------------
 2254907.59
(1 row)

4.2.35 - REGR_SXY

返回依赖表达式 (expression1) 与其平均值之间的差值以及独立表达式 (expression2) 与其平均值之间的差值的乘积之和。

即，REGR_SXY 返回： ∑[(expression1 - average(expression1)(expression2 - average(expression2))]

返回值的类型为 DOUBLE PRECISION。 REGR_SXY 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SXY 返回 NULL。

语法

SELECT REGR_SXY ( expression1, expression2 )

参数

示例

=> SELECT REGR_SXY (Annual_salary, Employee_age) FROM employee_dimension;
     REGR_SXY
-------------------
 -90323481.0730019
(1 row)

4.2.36 - REGR_SYY

返回依赖表达式 (expression1) 与其平均值之间的差值的平方和。

即，REGR_SYY 返回：∑[(expression1 - average(expression1)(expression1 - average(expression1)]

返回值的类型为 DOUBLE PRECISION。 REGR_SYY 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SYY 返回 NULL。

语法

SELECT REGR_SYY ( expression1, expression2 )

参数

示例

=> SELECT REGR_SYY (Annual_salary, Employee_age) FROM employee_dimension;
     REGR_SYY
------------------
 69956728794707.2
(1 row)

4.2.37 - STDDEV [聚合]

求出组中每个成员的统计样本标准差。返回值与 VAR_SAMP 的平方根相同：

STDDEV(expression) = SQRT(VAR_SAMP(expression))

行为类型

不可变

语法

STDDEV ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV 返回与 expression 相同的数据类型。

相关函数

  • 提供非标准函数 STDDEV，以便和其他数据库兼容。它在语义上与 STDDEV_SAMP 相同。

  • 此聚合函数与分析函数 STDDEV 不同，它计算当前行相对于 窗口内的一组行的统计样本标准偏差。

  • 当 VAR_SAMP 返回 NULL 时，STDDEV 返回 NULL。

示例

以下示例从 customer_dimension VMart 示例数据库表返回每个家庭 ID 的统计样本标准差：

=> SELECT STDDEV(household_id) FROM customer_dimension;
   STDDEV
-----------------
 8651.5084240071

4.2.38 - STDDEV_POP [聚合]

求出组中每个成员的统计总体标准差。

行为类型

不可变

语法

STDDEV_POP ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV_POP 返回与 expression 相同的数据类型。

相关函数

  • 此函数与分析函数 STDDEV_POP 不同，它计算 窗口内一组行中每个成员的统计总体标准差。

  • STDDEV_POP 返回与 VAR_POP 的平方根相同的值：

    STDDEV_POP(expression) = SQRT(VAR_POP(expression))

  • 当 VAR_SAMP 返回 NULL 时，此函数将返回 NULL。

示例

以下示例返回 customer 表中每个家庭 ID 的统计总体标准差。

=> SELECT STDDEV_POP(household_id) FROM customer_dimension;
   STDDEV_POP
------------------
 8651.41895973367
(1 row)

另请参阅

4.2.39 - STDDEV_SAMP [聚合]

求出组中每个成员的统计样本标准差。返回值与 VAR_SAMP 的平方根相同：

STDDEV_SAMP(expression) = SQRT(VAR_SAMP(expression))

行为类型

不可变

语法

STDDEV_SAMP ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV_SAMP 返回与 expression 相同的数据类型。

相关函数

  • STDDEV_SAMP 在语义上与非标准函数 STDDEV 相同，它是为了与其他数据库兼容而提供的。

  • 此聚合函数与分析函数 STDDEV_SAMP 不同，它计算当前行相对于 窗口内的一组行的统计样本标准偏差。

  • 当 VAR_SAMP 返回 NULL 时，STDDEV_SAMP 返回 NULL。

示例

以下示例从 customer 维度表返回每个家庭 ID 的统计样本标准差。

=> SELECT STDDEV_SAMP(household_id) FROM customer_dimension;
   stddev_samp
------------------
 8651.50842400771
(1 row)

4.2.40 - SUM [聚合]

基于行组计算表达式的总和 SUM 返回浮点表达式的 DOUBLE PRECISION 值。否则，返回值与表达式数据类型相同。

SUM 聚合函数与 SUM 分析函数不同，它计算一个 窗口内一组行的表达式总和。

行为类型

不可变

语法

SUM ( [ ALL | DISTINCT ] expression )

参数

ALL
调用组中所有行的聚合函数（默认）
DISTINCT
调用组中发现的所有表达式非重复非 Null 值的聚合函数
表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。

溢出处理

如果在使用 SUM() 时遇到数据溢出问题，请使用 SUM_FLOAT 将数据转换为浮点数。

默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

示例

以下查询返回 product_cost 列的总和。

=> SELECT SUM(product_cost) AS cost FROM product_dimension;
   cost
---------
 9042850
(1 row)

另请参阅

4.2.41 - SUM_FLOAT [聚合]

计算一组行的表达式的总和并返回 DOUBLE PRECISION 值。

行为类型

不可变

语法

SUM_FLOAT ( [ ALL | DISTINCT ] expression )

参数

ALL
调用组中所有行的聚合函数（默认）。
DISTINCT
调用组中发现的表达式中所有区分非空值的聚合函数。
表达式
任何表达式的结果都是 DOUBLE PRECISION 类型。

溢出处理

默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

示例

以下查询从产品表返回平均价格浮点总和：

=> SELECT SUM_FLOAT(average_competitor_price) AS cost FROM product_dimension;
   cost
----------
 18181102
(1 row)

4.2.42 - TS_FIRST_VALUE

处理属于每个时间片的数据。时序聚合 (TSA) 函数，TS_FIRST_VALUE 返回时间片开始时的值，其中插值方案在缺少时间片时应用，在这种情况下，根据常数（线性）插值方案由对应于上一个（和下一个）时间片的值来确定值。

TS_FIRST_VALUE 将为每个时间片返回一个输出行，如果指定了分区表达式，则为每个时间片的每个分区返回一个输出行。

行为类型

不可变

语法

TS_FIRST_VALUE ( expression [ IGNORE NULLS ] [, { 'CONST' | 'LINEAR' } ] )

参数

表达式
聚合和内插所基于的 INTEGER 或 FLOAT 表达式。
IGNORE NULLS
IGNORE NULLS 行为将根据 CONST 或 LINEAR 插值方案发生变化。有关详细信息，请参阅分析数据中的时序数据何时包含 NULL 值。
'CONST' | 'LINEAR'
将插值指定为常数或线性：

  • CONST （默认值）：基于以前的输入记录内插新值。

  • LINEAR：基于指定的时间片将值内插到线性斜率中。

要求

您必须将 ORDER BY 子句与 TIMESTAMP 列一起使用。

多个时序聚合函数

同一个查询可以调用多个时序聚合函数。按照 TIMESERIES 子句的定义，它们共享同一个空白填充策略；然而，每个时序聚合函数可以指定自己的插值策略。例如：

=> SELECT slice_time, symbol,
TS_FIRST_VALUE(bid, 'const') fv_c,
       TS_FIRST_VALUE(bid, 'linear') fv_l,
       TS_LAST_VALUE(bid, 'const') lv_c
FROM TickStore
TIMESERIES slice_time AS '3 seconds'
OVER(PARTITION BY symbol ORDER BY ts);

示例

请参阅分析数据中的空白填充和插值。

另请参阅

4.2.43 - TS_LAST_VALUE

处理属于每个时间片的数据。时序聚合 (TSA) 函数，TS_LAST_VALUE 返回时间片结束时的值，其中插值方案在缺少时间片时应用。在这种情况下，根据常数（线性）插值方案由对应于上一个（和下一个）时间片的值来确定值。

TS_LAST_VALUE 将为每个时间片返回一个输出行，如果指定了分区表达式，则为每个时间片的每个分区返回一个输出行。

行为类型

不可变

语法

TS_LAST_VALUE ( expression [ IGNORE NULLS ] [, { 'CONST' | 'LINEAR' } ] )

参数

表达式
聚合和内插所基于的 INTEGER 或 FLOAT 表达式。
IGNORE NULLS
IGNORE NULLS 行为将根据 CONST 或 LINEAR 插值方案发生变化。有关详细信息，请参阅分析数据中的时序数据何时包含 NULL 值。
'CONST' | 'LINEAR'
将插值指定为常数或线性：

  • CONST （默认值）：基于以前的输入记录内插新值。

  • LINEAR：基于指定的时间片将值内插到线性斜率中。

要求

您必须将 ORDER BY 子句与 TIMESTAMP 列一起使用。

多个时序聚合函数

同一个查询可以调用多个时序聚合函数。按照 TIMESERIES 子句的定义，它们共享同一个空白填充策略；然而，每个时序聚合函数可以指定自己的插值策略。例如：

=> SELECT slice_time, symbol,
TS_FIRST_VALUE(bid, 'const') fv_c,
       TS_FIRST_VALUE(bid, 'linear') fv_l,
       TS_LAST_VALUE(bid, 'const') lv_c
FROM TickStore
TIMESERIES slice_time AS '3 seconds'
OVER(PARTITION BY symbol ORDER BY ts);

示例

请参阅分析数据中的空白填充和插值。

另请参阅

4.2.44 - VAR_POP [聚合]

求出组内每个成员的总体方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数：

(SUM(expression*expression) - SUM(expression)*SUM(expression) / COUNT(expression)) / COUNT(expression)

行为类型

不可变

语法

VAR_POP ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VAR_POP 返回与 expression 相同的数据类型。

相关函数

此聚合函数与分析函数 VAR_POP 不同，它计算当前行相对于 窗口内的一组行的总体方差。

示例

下述示例返回 customer 表中每个 household ID 的总体方差。

=> SELECT VAR_POP(household_id) FROM customer_dimension;
    var_pop
------------------
 74847050.0168393
(1 row)

4.2.45 - VAR_SAMP [聚合]

求出组中每行的样本方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数减去 1：

(SUM(expression*expression) - SUM(expression) *SUM(expression) / COUNT(expression)) / (COUNT(expression) -1)

行为类型

不可变

语法

VAR_SAMP ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VAR_SAMP 返回与 expression 相同的数据类型。

相关函数

  • VAR_SAMP 在语义上与非标准函数 VARIANCE 相同，它是为了与其他数据库兼容而提供的。

  • 此聚合函数与分析函数 VAR_SAMP 不同，它计算当前行相对于 窗口内的一组行的样本方差。

示例

以下示例返回 customer 表中每个家庭 ID 的样本方差。

=> SELECT VAR_SAMP(household_id) FROM customer_dimension;
     var_samp
------------------
 74848598.0106764
(1 row)

另请参阅

VARIANCE [聚合]

4.2.46 - VARIANCE [聚合]

求出组中每行的样本方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数减去 1。

(SUM(expression*expression) - SUM(expression) *SUM(expression) /COUNT(expression)) / (COUNT(expression) -1)

行为类型

不可变

语法

VARIANCE ( expression )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VARIANCE 返回与 expression 相同的数据类型。

相关函数

提供非标准函数 VARIANCE，以便和其他数据库兼容。它在语义上与 VAR_SAMP 相同。

此聚合函数与分析函数 VARIANCE 不同，它计算当前行相对于 窗口内的一组行的样本方差。

示例

以下示例返回 customer 表中每个家庭 ID 的样本方差。

=> SELECT VARIANCE(household_id) FROM customer_dimension;
     variance
------------------
 74848598.0106764
(1 row)

另请参阅

4.3 - 分析函数

Vertica 分析是基于 ANSI 99 标准的 SQL 函数。这些函数用于处理复杂的分析和报告任务，例如：

  • 对处于特殊状态的合作时间最长的客户进行排序。

  • 计算指定的一段时间内零售额的移动平均值。

  • 查找同一年级所有学生的最高分数。

  • 对销售人员当前收到的销售奖金与其以前收到的销售奖金进行比较。

分析函数将返回聚合结果，但并不对结果集进行分组。它们会多次返回组值，每个记录一个组值。可以使用 window ORDER BY 子句排序组值或分区，但此顺序仅影响函数结果集，而不影响整个查询结果集。

语法

一般

analytic‑function(arguments) OVER(
  [ window-partition-clause ]
  [ window-order-clause [ window-frame-clause ] ]
)

对于指定窗口

analytic‑function(arguments) OVER(
  [ named‑window [ window‑frame‑clause ] ]
)

参数

analytic‑function(arguments)
Vertica 分析函数及其实参。
OVER
指定如何就当前行而言对窗口框架函数输入进行分区、排序。输入数据是查询在对 FROM、WHERE、GROUP BY 和 HAVING 子句求值之后返回的结果集。

空的 OVER 子句将提供单个节点中的单线程查询最佳性能。

window‑partition‑clause
根据一个或多个列或表达式对输入行进行分组。

如果忽略此子句，不会进行任何分组，分析函数将所有输入行作为一个分区处理。

window‑order‑clause
可以选择指定如何对提供给分析函数的行进行排序。如果 OVER 子句还包括分区子句，则在每个分区中对行进行排序。
window‑frame‑clause
仅对某些分析函数有效，指定为输入一组与分析函数当前正在评估的行相对的行。函数处理此行及其窗口之后，Vertica 会将当前行向前移动，并相应地调整窗口边界。
named‑window
您在同一个查询中用窗口名称子句定义的一个窗口的名称。此定义将封装窗口分区和排序。当查询调用多个具有类似的 OVER 子句的分析函数时，命名窗口很有用。

窗口名称子句不能指定窗口框架子句。然而，您可以用窗口框架子句将命名窗口限定在 OVER 子句中。

要求

以下要求适用于分析函数：

  • 全部需要 OVER 子句。每个函数都有自己的 OVER 子句要求。例如，您可以为一些分析聚合函数（如 SUM）提供一个空的 OVER 子句。对于其他函数，可能需要窗口框架和命令子句，也可能无效。

  • 只有查询的 SELECT 和 ORDER BY 子句才能调用分析函数。

  • 分析函数不可嵌套。例如，不允许下面的查询：

    => SELECT MEDIAN(RANK() OVER(ORDER BY sal) OVER()).

  • WHERE、GROUP BY 和 HAVING 运算符从技术上讲不是分析函数的一部分。不过，它们可以确定该函数的输入内容。

另请参阅

4.3.1 - 窗口分区子句

当指定了窗口分区子句时，它将基于用户提供的表达式拆分函数输入的行。如果没有提供表达式，分区子句可通过使用并行度来提升查询性能。

窗口分区与 GROUP BY 子句相似，区别在于它仅为每个输入行返回一个结果行。如果没有指定窗口分区子句，则会将所有输入行都视为一个分区。

当与分析函数一起使用时，将根据分区计算结果，并在下一个分区开始时重新开始。

语法

{ PARTITION BY expression[,...] | PARTITION BEST | PARTITION NODES }

参数

PARTITION BY expression
基于此表达式对分区进行排序，其中 expression 可以是列、常数或者针对列构成的任意表达式。对于带有特定分区要求的分析函数，使用 PARTITION BY 。
PARTITION BEST
使用并行度来提升多个节点中的多线程查询性能。

OVER(PARTITION BEST) 提供多个节点中的多线程查询最佳性能。

以下注意事项适用于使用 PARTITION BEST：

  • 对于无分区要求且线程安全的分析函数（如一对多转换），使用 PARTITION BEST。

  • 对于非线程安全的用户定义转换函数 (UDTF)，不要使用 PARTITION BEST。这样做会导致出现错误或不正确的结果。如果 UDTF 非线程安全，使用 PARTITION NODES 。

PARTITION NODES
使用并行度来提升多个节点中的单线程查询性能。

OVER(PARTITION NODES) 提供多个节点中的单线程查询最佳性能。

示例

请参阅窗口分区。

4.3.2 - 窗口顺序子句

指定如何对提供给分析函数的行进行排序。如果 OVER 子句也包含窗口分区子句，则会在每个分区中对行进行排序。

窗口顺序子句仅在窗口结果集中指定顺序。除 OVER 子句以外，查询可以拥有自己的 ORDER BY 子句。它优先于窗口顺序子句，并对最终结果集进行排序。

如果没有显式指定任何窗口框架，窗口顺序子句还会创建默认窗口框架。

语法

ORDER BY { expression [ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] ]
  }[,...]

参数

表达式
列、常数或是针对列构成的任意表达式，用于对输入列进行排序。
ASC | DESC
将排序顺序指定为升序（默认值）或降序。
NULLS {FIRST | LAST | AUTO}
指定是否将 null 值放在最前或最后。默认位置排放取决于排序顺序是升序还是降序：

  • 升序默认： NULLS LAST

  • 降序默认： NULLS FIRST

如果您指定了 NULLS AUTO，Vertica 选择对于此查询最有效的位置排放，即 NULLS FIRST 或 NULLS LAST。

如果您省略所有的排序限定符，Vertica 将使用 ASC NULLS LAST。

有关详细信息，请参阅：

示例

请参阅窗口排序。

4.3.3 - 窗口框架子句

指定窗口框架，其中包含一组与分析函数当前正在评估的行相对的行。函数处理此行及其窗口之后，Vertica 会将当前行向前移动，并相应地调整窗口边界。如果 OVER 子句还指定了分区，Vertica 也会检查窗口边界是否跨越了分区边界。此过程将不断重复，直到函数评估了最后一个分区的最后一个行。

语法

{ ROWS | RANGE } { BETWEEN start‑point AND end‑point } | start‑point

start-point / end‑point：

{ UNBOUNDED {PRECEDING | FOLLOWING}
  | CURRENT ROW
  | constant-value  {PRECEDING | FOLLOWING}}

参数

ROWS | RANGE
指定 Vertica 是否确定窗口框架大小为当前行的物理或逻辑偏移。有关详细信息，请参阅下方的 ROWS 与 RANGE。
BETWEEN start‑point AND end‑point
指定窗口的第一个行和最后一个行，其中 start‑point 和 end‑point 可以是以下之一（下文将详细讨论）：

  • UNBOUNDED {PRECEDING | FOLLOWING}

  • CURRENT ROW

  • constant-value {PRECEDING | FOLLOWING}

start-point 必须解析为小于或等于 end-point 的行或值。

UNBOUNDED PRECEDING
指定窗口框架扩展到当前分区的第一行。
start‑point
如果 ROWS 或 RANGE 仅指定了一个起点，Vertica 将使用当前行作为终点，并相应地创建窗口框架。在这种情况下，start-point 必须解析为小于或等于当前行的行。
UNBOUNDED FOLLOWING
指定窗口框架扩展到当前分区的最后一行。
CURRENT ROW
指定当前行或值为窗口的起点或终点。
constant‑value {PRECEDING | FOLLOWING}
指定常数值或评估为常数值的表达式。此值指定当前行的物理便宜或逻辑偏移，具体视您是否指定了 ROWS 或 RANGE 而定。

其他依赖项也适用，具体视您是否指定了 ROWS 和 RANGE 而定。有关详细信息，请参阅下方的 ROWS 与 RANGE。

要求

要指定窗口框架，OVER 还必须指定窗口顺序 (ORDER BY) 子句。如果 OVER 子句没有指定窗口框架，则函数会创建从当前分区的当前行扩展到第一行的默认窗口。它等同于以下子句：

RANGE UNBOUNDED PRECEDING AND CURRENT ROW

ROWS 与 RANGE

当前行的窗口框架偏移可能是物理或逻辑偏移：

  • ROWS 将窗口的 start‑point 和 end‑point 指定为相对于当前行的行数。如果 start-point 和 end-point 以常数值表示，则该值的计算结果必须为正整数。

  • RANGE 将窗口指定为逻辑偏移，比如时间。范围值必须与窗口顺序 (ORDER BY) 子句数据类型匹配：NUMERIC、DATE/TIME、FLOAT 或 INTEGER。

使用 ROWS 或 RANGE 对于将窗口起点和终点设置为常数值实施了特定要求：

为 ROWS 设置常数值
常数的计算结果必须为正 INTEGER。
为 RANGE 设置常数值
需要满足以下要求：

  • 常数的计算结果必须为正数值或 INTERVAL 字面量。

  • 如果常数的计算结果为 NUMERIC 值，则 ORDER BY 列类型必须为 NUMERIC 数据类型。

  • 如果常数的计算结果为 INTERVAL DAY TO SECOND 子类，则 ORDER BY 列类型必须为以下之一：TIMESTAMP、TIME、DATE 或 INTERVAL DAY TO SECOND。

  • 如果常数的计算结果为 INTERVAL YEAR TO MONTH，则 ORDER BY 列类型必须为以下之一：TIMESTAMP、DATE 或 INTERVAL YEAR TO MONTH。

  • 窗口顺序子句只可指定一个表达式。

示例

请参阅窗口框架。

4.3.4 - 窗口名称子句

定义命名窗口，为分析函数指定窗口分区和顺序子句。此窗口在函数的 OVER 子句中指定。当您编写通过类似的 OVER 子句调用多个分析函数的查询时——例如，它们使用相同的 (PARTITION BY) 分区子句，命名窗口非常有用。

语法

WINDOW window‑name AS ( window-partition-clause [window-order-clause] )

参数

WINDOW window‑name
指定窗口名称。在同一个查询中，所有窗口名称都必须是唯一的。
window‑partition‑clause [window‑order‑clause]
当 OVER 子句引用此窗口时调用的子句。

如果窗口忽略了窗口顺序子句，则 OVER 子句可以指定自己的顺序子句。

要求

  • WINDOW 子句不能包含窗口框架子句。

  • 同一个查询中的每个 WINDOW 子句都必须拥有唯一的名称。

  • WINDOW 子句可引用另一个已经命名的窗口。例如，下述查询先命名 w1，再命名 w2。因此，定义 WINDOW 的 w2 子句可引用 w1：

    => SELECT RANK() OVER(w1 ORDER BY sal DESC), RANK() OVER w2
   FROM EMP WINDOW w1 AS (PARTITION BY deptno), w2 AS (w1 ORDER BY sal);

示例

请参阅命名窗口。

另请参阅

分析函数

4.3.5 - ARGMAX [analytic]

此函数是仿照数学函数 argmax(f(x)) 设计的，返回可使 f(x) 成为最大值的 x 值。同样地，ARGMAX 使用两个实参 target 和 arg，这两个实参均为查询数据集中的列或列表达式。ARGMAX 在 target 中查找具有最大非 null 值的行，并返回该行中的 arg 值。如果有多行包含最大 target 值，ARGMAX 将返回其找到的第一行中的 arg 值。

行为类型

不可变

语法

ARGMAX ( target, arg )  OVER ( [ PARTITION BY expression[,...] ] [ window-order-clause ] )

参数

target, arg
查询数据集中的列。
OVER()
指定以下窗口子句：

  • PARTITION BY expression：根据 expression 中的值对输入行进行分组（分区），该 expression 解析为查询数据集中的一列或多列。如果忽略此子句，ARGMAX 会将所有输入行作为单分区处理。

  • window-order-clause：指定如何对输入行进行排序。如果 OVER 子句还包括分区子句，则会单独在每个分区中对行进行排序。

有关详细信息，请参阅分析函数。

示例

创建并填充表 service_info，其中包含有关各项服务、服务各自的开发组以及服务用户群的信息。users 列中的 NULL 表示该服务尚未发布，因此不会有用户。

=> CREATE TABLE service_info(dev_group VARCHAR(10), product_name VARCHAR(30), users INT);
=> COPY t FROM stdin NULL AS 'null';
>> iris|chat|48193
>> aspen|trading|3000
>> orchid|cloud|990322
>> iris|video call| 10203
>> daffodil|streaming|44123
>> hydrangea|password manager|null
>> hydrangea|totp|1837363
>> daffodil|clip share|3000
>> hydrangea|e2e sms|null
>> rose|crypto|null
>> iris|forum|48193
>> \.

ARGMAX 返回 product_name 列中的值，该值可使 users 列中的值最大。在此示例中，ARGMAX 将返回 totp，表示 totp 服务拥有最大的用户群：


=> SELECT dev_group, product_name, users, ARGMAX(users, product_name) OVER (ORDER BY dev_group ASC) FROM service_info;
 dev_group |   product_name   |  users  | ARGMAX
-----------+------------------+---------+--------
 aspen     | trading          |    3000 | totp
 daffodil  | clip share       |    3000 | totp
 daffodil  | streaming        |   44123 | totp
 hydrangea | e2e sms          |         | totp
 hydrangea | password manager |         | totp
 hydrangea | totp             | 1837363 | totp
 iris      | chat             |   48193 | totp
 iris      | forum            |   48193 | totp
 iris      | video call       |   10203 | totp
 orchid    | cloud            |  990322 | totp
 rose      | crypto           |         | totp
(11 rows)

下一个查询对 dev_group 上的数据进行分区，以确定每个开发组创建的最受欢迎的服务。如果分区的 users 列仅包含 NULL 值并使用分区顶部 product_name 中的第一个值打破关系，ARGMAX 将返回 NULL。


=> SELECT dev_group, product_name, users, ARGMAX(users, product_name) OVER (PARTITION BY dev_group ORDER BY product_name ASC) FROM service_info;
 dev_group |   product_name   |  users  |  ARGMAX
-----------+------------------+---------+-----------
 iris      | chat             |   48193 | chat
 iris      | forum            |   48193 | chat
 iris      | video call       |   10203 | chat
 orchid    | cloud            |  990322 | cloud
 aspen     | trading          |    3000 | trading
 daffodil  | clip share       |    3000 | streaming
 daffodil  | streaming        |   44123 | streaming
 rose      | crypto           |         |
 hydrangea | e2e sms          |         | totp
 hydrangea | password manager |         | totp
 hydrangea | totp             | 1837363 | totp
(11 rows)

另请参阅

ARGMIN [analytic]

4.3.6 - ARGMIN [analytic]

此函数是仿照数学函数 argmin(f(x)) 设计的，返回可使 f(x) 成为最小值的 x 值。同样地，ARGMIN 使用两个实参 target 和 arg，这两个实参均为查询数据集中的列或列表达式。ARGMIN 在 target 中查找具有最小非 null 值的行，并返回该行中的 arg 值。如果有多行包含最小 target 值，ARGMIN 将返回其找到的第一行中的 arg 值。

行为类型

不可变

语法

ARGMIN ( target, arg )  OVER ( [ PARTITION BY expression[,...] ] [ window-order-clause ] )

参数

target, arg
查询数据集中的列。
OVER()
指定以下窗口子句：

  • PARTITION BY expression：根据 expression 中的值对输入行进行分组（分区），该 expression 解析为查询数据集中的一列或多列。如果忽略此子句，ARGMIN 会将所有输入行作为单分区处理。

  • window-order-clause：指定如何对输入行进行排序。如果 OVER 子句还包括分区子句，则会单独在每个分区中对行进行排序。

有关详细信息，请参阅分析函数。

示例

创建并填充表 service_info，其中包含有关各项服务、服务各自的开发组以及服务用户群的信息。users 列中的 NULL 表示该服务尚未发布，因此不会有用户。

=> CREATE TABLE service_info(dev_group VARCHAR(10), product_name VARCHAR(30), users INT);
=> COPY t FROM stdin NULL AS 'null';
>> iris|chat|48193
>> aspen|trading|3000
>> orchid|cloud|990322
>> iris|video call| 10203
>> daffodil|streaming|44123
>> hydrangea|password manager|null
>> hydrangea|totp|1837363
>> daffodil|clip share|3000
>> hydrangea|e2e sms|null
>> rose|crypto|null
>> iris|forum|48193
>> \.

ARGMIN 返回 product_name 列中的值，该值可使 users 列中的值最小。在此示例中，ARGMIN 将返回 totp，表示 totp 服务具有最小的用户群：


=> SELECT dev_group, product_name, users, ARGMIN(users, product_name) OVER (ORDER BY dev_group ASC) FROM service_info;
 dev_group |   product_name   |  users  | ARGMIN
-----------+------------------+---------+---------
 aspen     | trading          |    3000 | trading
 daffodil  | clip share       |    3000 | trading
 daffodil  | streaming        |   44123 | trading
 hydrangea | e2e sms          |         | trading
 hydrangea | password manager |         | trading
 hydrangea | totp             | 1837363 | trading
 iris      | chat             |   48193 | trading
 iris      | forum            |   48193 | trading
 iris      | video call       |   10203 | trading
 orchid    | cloud            |  990322 | trading
 rose      | crypto           |         | trading
(11 rows)

下一个查询对 dev_group 上的数据进行分区，以确定每个开发组创建的最不受欢迎的服务。如果分区的 users 列仅包含 NULL 值并使用分区顶部 product_name 中的第一个值打破关系，ARGMIN 将返回 NULL。


=> SELECT dev_group, product_name, users, ARGMIN(users, product_name) OVER (PARTITION BY dev_group ORDER BY product_name ASC) FROM service_info;
 dev_group |   product_name   |  users  |   ARGMIN
-----------+------------------+---------+------------
 iris      | chat             |   48193 | video call
 iris      | forum            |   48193 | video call
 iris      | video call       |   10203 | video call
 orchid    | cloud            |  990322 | cloud
 aspen     | trading          |    3000 | trading
 daffodil  | clip share       |    3000 | clip share
 daffodil  | streaming        |   44123 | clip share
 rose      | crypto           |         |
 hydrangea | e2e sms          |         | totp
 hydrangea | password manager |         | totp
 hydrangea | totp             | 1837363 | totp
(11 rows)

另请参阅

ARGMAX [analytic]

4.3.7 - AVG [analytic]

计算 窗口内一组中表达式的平均值。 AVG 返回与表达式的数字数据类型相同的数据类型。

AVG 分析函数不同于 AVG 聚合函数，后者计算一组行中表达式的平均值。

行为类型

不可变

语法

AVG ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
可以隐式转换为数字数据类型的任何数据。
OVER()
请参阅分析函数。

溢出处理

默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

示例

以下查询查找该日历月的销售，并使用默认的 RANGE UNBOUNDED PRECEDING AND CURRENT ROW 窗口返回一个运行/累计平均值（有时称为移动平均值）：

=> SELECT calendar_month_number_in_year Mo, SUM(product_price) Sales,
   AVG(SUM(product_price)) OVER (ORDER BY calendar_month_number_in_year)::INTEGER Average
   FROM product_dimension pd, date_dimension dm, inventory_fact if
   WHERE dm.date_key = if.date_key AND pd.product_key = if.product_key GROUP BY Mo;
 Mo |  Sales   | Average
----+----------+----------
  1 | 23869547 | 23869547
  2 | 19604661 | 21737104
  3 | 22877913 | 22117374
  4 | 22901263 | 22313346
  5 | 23670676 | 22584812
  6 | 22507600 | 22571943
  7 | 21514089 | 22420821
  8 | 24860684 | 22725804
  9 | 21687795 | 22610470
 10 | 23648921 | 22714315
 11 | 21115910 | 22569005
 12 | 24708317 | 22747281
(12 rows)

要返回不是运行（累计）平均值的移动平均值，该窗口应指定 ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING：

=> SELECT calendar_month_number_in_year Mo, SUM(product_price) Sales,
   AVG(SUM(product_price)) OVER (ORDER BY calendar_month_number_in_year
     ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)::INTEGER Average
   FROM product_dimension pd, date_dimension dm, inventory_fact if
   WHERE dm.date_key = if.date_key AND pd.product_key = if.product_key GROUP BY Mo;
 Mo |  Sales   | Average
----+----------+----------
  1 | 23869547 | 22117374
  2 | 19604661 | 22313346
  3 | 22877913 | 22584812
  4 | 22901263 | 22312423
  5 | 23670676 | 22694308
  6 | 22507600 | 23090862
  7 | 21514089 | 22848169
  8 | 24860684 | 22843818
  9 | 21687795 | 22565480
 10 | 23648921 | 23204325
 11 | 21115910 | 22790236
 12 | 24708317 | 23157716
(12 rows)

另请参阅

4.3.8 - BOOL_AND [analytic]

返回 窗口内表达式的布尔值。如果所有输入值都为 true，则 BOOL_AND 返回 t。否则，它返回 f。

行为类型

不可变

语法

BOOL_AND ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
布尔数据类型 或任何可隐式转换为布尔数据类型的非布尔数据类型。此函数将返回一个布尔值。
OVER()
请参阅分析函数。

示例

以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。

=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE

将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。

=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
 OUTPUT
--------
     10
(1 row)

查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。

=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;


   emptype   | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
 contractor1 | t               | t                     | f
 contractor2 | f               | t                     | t
 contractor3 | f               | t                     | t
 contractor4 | t               | t                     | f
 contractor5 | f               | f                     | f
(5 rows)

另请参阅

4.3.9 - BOOL_OR [analytic]

返回 窗口内表达式的布尔值。如果至少一个输入值为 true，则 BOOL_OR 返回 t。否则，它返回 f。

行为类型

不可变

语法

BOOL_OR ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
布尔数据类型 或任何可隐式转换为布尔数据类型的非布尔数据类型。此函数将返回一个布尔值。
OVER()
请参阅分析函数。

示例

以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。

=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE

将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。

=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
 OUTPUT
--------
     10
(1 row)

查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。

=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;


   emptype   | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
 contractor1 | t               | t                     | f
 contractor2 | f               | t                     | t
 contractor3 | f               | t                     | t
 contractor4 | t               | t                     | f
 contractor5 | f               | f                     | f
(5 rows)

另请参阅

4.3.10 - BOOL_XOR [analytic]

返回 窗口内表达式的布尔值。如果只有一个输入值为真，BOOL_XOR 将返回 t。否则，它返回 f。

行为类型

不可变

语法

BOOL_XOR ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
布尔数据类型 或任何可隐式转换为布尔数据类型的非布尔数据类型。此函数将返回一个布尔值。
OVER()
请参阅分析函数。

示例

以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。

=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE

将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。

=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
 OUTPUT
--------
     10
(1 row)

查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。

=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;


   emptype   | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
 contractor1 | t               | t                     | f
 contractor2 | f               | t                     | t
 contractor3 | f               | t                     | t
 contractor4 | t               | t                     | f
 contractor5 | f               | f                     | f
(5 rows)

另请参阅

4.3.11 - CONDITIONAL_CHANGE_EVENT [analytic]

从 0 开始向每个行分配一个事件窗口编号，并在当前行中评估参数表达式的结果与上一行不同时，以 1 为增量递增事件窗口编号。

行为类型

不可变

语法

CONDITIONAL_CHANGE_EVENT ( expression ) OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

expression
在输入记录中评估的 SQL 标量表达式。expression 的结果可以是任何数据类型。
OVER()
请参阅分析函数。

注意

分析 window-order-clause 是必需的，但 window-partition-clause 是可选的。

示例

=> SELECT CONDITIONAL_CHANGE_EVENT(bid)
          OVER (PARTITION BY symbol ORDER BY ts) AS cce
   FROM TickStore;

没有 ORDER BY 子句时，系统将返回错误：

=> SELECT CONDITIONAL_CHANGE_EVENT(bid)
          OVER (PARTITION BY symbol) AS cce
   FROM TickStore;

ERROR:  conditional_change_event must contain an
ORDER BY clause within its analytic clause

有关更多示例，请参阅事件窗口。

另请参阅

4.3.12 - CONDITIONAL_TRUE_EVENT [analytic]

从 0 开始向每个行分配一个事件窗口编号，并在当 boolean 参数表达式的结果评估为 true 时，以 1 为增量递增事件窗口编号。例如，假定某列的值的顺序如下：

( 1, 2, 3, 4, 5, 6 )

CONDITIONAL_TRUE_EVENT(a > 3) returns 0, 0, 0, 1, 2, 3.

行为类型

不可变

语法

CONDITIONAL_TRUE_EVENT ( boolean-expression ) OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

boolean-expression
在输入记录中评估的 SQL 标量表达式，类型 BOOLEAN。
OVER()
请参阅分析函数。

注意

分析 window-order-clause 是必需的，但 window-partition-clause 是可选的。

示例

> SELECT CONDITIONAL_TRUE_EVENT(bid > 10.6)
     OVER(PARTITION BY bid ORDER BY ts) AS cte
   FROM Tickstore;

如果忽略 ORDER BY 子句，系统将返回错误：

> SELECT CONDITIONAL_TRUE_EVENT(bid > 10.6)
      OVER(PARTITION BY bid) AS cte
   FROM Tickstore;

ERROR:  conditional_true_event must contain an ORDER BY
clause within its analytic clause

有关更多示例，请参阅事件窗口。

另请参阅

4.3.13 - COUNT [analytic]

对 窗口中组内的出现次数进行计数。如果指定 * 或某个非 NULL 常数，COUNT() 会对所有行进行计数。

行为类型

不可变

语法

COUNT ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
返回其 expression 不为 null 的每个组中的行数。可以是生成 BIGINT 的任何表达式。
OVER()
请参阅分析函数。

示例

使用 窗口框架 中定义的架构时，以下 COUNT 函数将忽略窗口顺序子句和窗口框架子句；否则 Vertica 会将其视为窗口聚合。将报告聚合的窗口视为 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。

=> SELECT deptno, sal, empno, COUNT(sal)
     OVER (PARTITION BY deptno) AS count FROM emp;


 deptno | sal | empno | count
--------+-----+-------+-------
     10 | 101 |     1 |     2
     10 | 104 |     4 |     2
     20 | 110 |    10 |     6
     20 | 110 |     9 |     6
     20 | 109 |     7 |     6
     20 | 109 |     6 |     6
     20 | 109 |     8 |     6
     20 | 109 |    11 |     6
     30 | 105 |     5 |     3
     30 | 103 |     3 |     3
     30 | 102 |     2 |     3

使用 ORDER BY sal 会创建包含默认窗口的移动窗口查询： RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.

=> SELECT deptno, sal, empno, COUNT(sal)
     OVER (PARTITION BY deptno ORDER BY sal) AS count
   FROM emp;


 deptno | sal | empno | count
--------+-----+-------+-------
     10 | 101 |     1 |     1
     10 | 104 |     4 |     2
     20 | 100 |    11 |     1
     20 | 109 |     7 |     4
     20 | 109 |     6 |     4
     20 | 109 |     8 |     4
     20 | 110 |    10 |     6
     20 | 110 |     9 |     6
     30 | 102 |     2 |     1
     30 | 103 |     3 |     2
     30 | 105 |     5 |     3

使用 VMart 架构时，以下查询会查找其每小时工资小于或等于当前员工的员工数。该查询使用默认窗口 RANGE UNBOUNDED PRECEDING AND CURRENT ROW 返回运行/累计平均数（有时称为移动平均数）：

=> SELECT employee_last_name AS "last_name", hourly_rate, COUNT(*)
   OVER (ORDER BY hourly_rate) AS moving_count from employee_dimension;


 last_name  | hourly_rate | moving_count
------------+-------------+--------------
 Gauthier   |           6 |            4
 Taylor     |           6 |            4
 Jefferson  |           6 |            4
 Nielson    |           6 |            4
 McNulty    |        6.01 |           11
 Robinson   |        6.01 |           11
 Dobisz     |        6.01 |           11
 Williams   |        6.01 |           11
 Kramer     |        6.01 |           11
 Miller     |        6.01 |           11
 Wilson     |        6.01 |           11
 Vogel      |        6.02 |           14
 Moore      |        6.02 |           14
 Vogel      |        6.02 |           14
 Carcetti   |        6.03 |           19
...

要返回不是运行（累计）平均数的移动平均数，窗口应指定 ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING：

=> SELECT employee_last_name AS "last_name", hourly_rate, COUNT(*)
      OVER (ORDER BY hourly_rate ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
   AS moving_count from employee_dimension;

另请参阅

4.3.14 - CUME_DIST [analytic]

计算 窗口内同一分区中当前行的累计分布或相对于其他行的排序。

CUME_DIST() 返回大于 0 且小于等于 1 的数字，其中该数字表示指定行在由 n 行组成的组中的相对位置。对于第 x 行（假定 ASC 排序），CUME_DIST 的 x 为数值小于等于 x 的行数除以整个分区的总行数。例如，在由三行组成的组中，返回的累计分布值应为 1/3、2/3 和 3/3。

行为类型

不可变

语法

CUME_DIST ( ) OVER (
    [ window-partition-clause ]
    window-order-clause  )

参数

OVER()
请参阅分析函数。

示例

以下示例返回第一季度每月内不同交易类型销售额的累计分布。

=> SELECT calendar_month_name AS month, tender_type, SUM(sales_quantity),
       CUME_DIST()
   OVER (PARTITION BY calendar_month_name ORDER BY SUM(sales_quantity)) AS
CUME_DIST
   FROM store.store_sales_fact JOIN date_dimension
   USING(date_key) WHERE calendar_month_name IN ('January','February','March')
   AND tender_type NOT LIKE 'Other'
   GROUP BY calendar_month_name, tender_type;


  month   | tender_type |  SUM   | CUME_DIST
----------+-------------+--------+-----------
 March    | Credit      | 469858 |      0.25
 March    | Cash        | 470449 |       0.5
 March    | Check       | 473033 |      0.75
 March    | Debit       | 475103 |         1
 January  | Cash        | 441730 |      0.25
 January  | Debit       | 443922 |       0.5
 January  | Check       | 446297 |      0.75
 January  | Credit      | 450994 |         1
 February | Check       | 425665 |      0.25
 February | Debit       | 426726 |       0.5
 February | Credit      | 430010 |      0.75
 February | Cash        | 430767 |         1
(12 rows)

另请参阅

4.3.15 - DENSE_RANK [analytic]

在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。DENSE_RANK 函数返回无间隙的排名数字序列。

DENSE_RANK 按以下方式执行：

  1. 按 ORDER BY 子句指定的顺序对分区行进行排序。

  2. 比较前一行与当前行的 ORDER BY 值，并按以下方式对当前行进行排名：

    • 如果 ORDER BY 值相同，则当前行获得的排名与前一行相同。

    • 如果 ORDER BY 值不同，DENSE_RANK 会依据升序或降序的排序顺序，将当前行的排名增加或减少 1 个名次。

DENSE_RANK 始终将排名更改 1 个名次，因此排名序列中不会出现间隙。最大排名值是查询返回的唯一 ORDER BY 值的数量。

行为类型

不可变

语法

DENSE_RANK() OVER (
    [ window-partition-clause ]
    window-order-clause  )

参数

OVER()
请参阅分析函数。

请参阅分析函数

与 RANK 的对比

RANK 会在排名序列中留下间隙，而 DENSE_RANK 不会出现该情况。以下示例将两种函数的运算操作进行了比较。

示例

以下查询调用 RANK 和 DENSE_RANK，按照年收入对客户进行排名。两种函数返回了不同的排名，如下所示：

  • 如果 annual_salary 包含重复值，RANK() 会插入重复排名，然后跳过一个或多个值，例如从 4 跳到 6，从 7 跳到 9。

  • 在平行列 Dense Rank 中，DENSE_RANK() 也会插入重复排名，但不会在排名序列中留下间隙：

=>  SELECT employee_region region, employee_key, annual_salary,
     RANK() OVER (PARTITION BY employee_region ORDER BY annual_salary) Rank,
     DENSE_RANK() OVER (PARTITION BY employee_region ORDER BY annual_salary) "Dense Rank"
     FROM employee_dimension;
              region              | employee_key | annual_salary | Rank | Dense Rank
----------------------------------+--------------+---------------+------+------------
 West                             |         5248 |          1200 |    1 |          1
 West                             |         6880 |          1204 |    2 |          2
 West                             |         5700 |          1214 |    3 |          3
 West                             |         9857 |          1218 |    4 |          4
 West                             |         6014 |          1218 |    4 |          4
 West                             |         9221 |          1220 |    6 |          5
 West                             |         7646 |          1222 |    7 |          6
 West                             |         6621 |          1222 |    7 |          6
 West                             |         6488 |          1224 |    9 |          7
 West                             |         7659 |          1226 |   10 |          8
 West                             |         7432 |          1226 |   10 |          8
 West                             |         9905 |          1226 |   10 |          8
 West                             |         9021 |          1228 |   13 |          9
 ...
 West                             |           56 |        963104 | 2794 |       2152
 West                             |          100 |        992363 | 2795 |       2153
 East                             |         8353 |          1200 |    1 |          1
 East                             |         9743 |          1202 |    2 |          2
 East                             |         9975 |          1202 |    2 |          2
 East                             |         9205 |          1204 |    4 |          3
 East                             |         8894 |          1206 |    5 |          4
 East                             |         7740 |          1206 |    5 |          4
 East                             |         7324 |          1208 |    7 |          5
 East                             |         6505 |          1208 |    7 |          5
 East                             |         5404 |          1208 |    7 |          5
 East                             |         5010 |          1208 |    7 |          5
 East                             |         9114 |          1212 |   11 |          6
 ...

另请参阅

SQL 分析

4.3.16 - EXPONENTIAL_MOVING_AVERAGE [analytic]

使用平滑系数 X 计算表达式 E 的指数移动平均线 (EMA)。EMA 与简单移动平均线不同，它提供了更稳定的图像，可显示数据随时间的变化。

通过将上一个 EMA 值添加到按照平滑系数成比例变化的当前数据点，可以计算 EMA 值，如以下公式所示：

EMA = EMA0 + (X * (E - EMA0))

其中：

  • E 是当前数据点

  • EMA0 是上一行的 EMA 值。

  • X 是平滑系数。

此函数也可以在行级别工作。例如，EMA 假设给定列中的数据是按照均匀间隔取样的。如果用户的数据点是按照不均匀间隔取样的，则应该在 EMA() 之前运行时间序列空白填充和插值 (GFI) 操作

行为类型

不可变

语法

EXPONENTIAL_MOVING_AVERAGE ( E, X ) OVER (
    [ window-partition-clause ]
    window-order-clause  )

参数

E
其平均值基于一组行计算得出的值。可以是 INTEGER、FLOAT 或 NUMERIC 类型，并且必须是常数。
X
介于 0 和 1 之间的用作平滑系数的正 FLOAT 值。
OVER()
请参阅分析函数。

示例

以下示例首先在子查询中使用时间序列空白填充和插值 (GFI)，然后对子查询结果执行 EXPONENTIAL_MOVING_AVERAGE 操作。

创建一个简单的四列表：

=> CREATE TABLE ticker(
     time TIMESTAMP,
     symbol VARCHAR(8),
     bid1 FLOAT,
     bid2 FLOAT );

插入一些数据，包括 NULL，以便于 GFI 可以执行插值和空白填充：

=> INSERT INTO ticker VALUES ('2009-07-12 03:00:00', 'ABC', 60.45, 60.44);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:01', 'ABC', 60.49, 65.12);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:02', 'ABC', 57.78, 59.25);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:03', 'ABC', null, 65.12);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:04', 'ABC', 67.88, null);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:00', 'XYZ', 47.55, 40.15);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:01', 'XYZ', 44.35, 46.78);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:02', 'XYZ', 71.56, 75.78);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:03', 'XYZ', 85.55, 70.21);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:04', 'XYZ', 45.55, 58.65);
=> COMMIT;

查询您刚创建的表，以便于看到输出：

=> SELECT * FROM ticker;
        time         | symbol | bid1  | bid2
---------------------+--------+-------+-------
 2009-07-12 03:00:00 | ABC    | 60.45 | 60.44
 2009-07-12 03:00:01 | ABC    | 60.49 | 65.12
 2009-07-12 03:00:02 | ABC    | 57.78 | 59.25
 2009-07-12 03:00:03 | ABC    |       | 65.12
 2009-07-12 03:00:04 | ABC    | 67.88 |
 2009-07-12 03:00:00 | XYZ    | 47.55 | 40.15
 2009-07-12 03:00:01 | XYZ    | 44.35 | 46.78
 2009-07-12 03:00:02 | XYZ    | 71.56 | 75.78
 2009-07-12 03:00:03 | XYZ    | 85.55 | 70.21
 2009-07-12 03:00:04 | XYZ    | 45.55 | 58.65
(10 rows)

以下查询处理表 trades 的列 a 中的每个 2 秒时间片所包含的第一个和最后一个值。查询然后使用平滑系数 50% 计算表达式 fv 和 lv 的指数移动平均线：

=> SELECT symbol, slice_time, fv, lv,
     EXPONENTIAL_MOVING_AVERAGE(fv, 0.5)
       OVER (PARTITION BY symbol ORDER BY slice_time) AS ema_first,
   EXPONENTIAL_MOVING_AVERAGE(lv, 0.5)
       OVER (PARTITION BY symbol ORDER BY slice_time) AS ema_last
   FROM (
     SELECT symbol, slice_time,
        TS_FIRST_VALUE(bid1 IGNORE NULLS) as fv,
        TS_LAST_VALUE(bid2 IGNORE NULLS) AS lv
      FROM ticker TIMESERIES slice_time AS '2 seconds'
      OVER (PARTITION BY symbol ORDER BY time) ) AS sq;


 symbol |     slice_time      |  fv   |  lv   | ema_first | ema_last
--------+---------------------+-------+-------+-----------+----------
 ABC    | 2009-07-12 03:00:00 | 60.45 | 65.12 |     60.45 |    65.12
 ABC    | 2009-07-12 03:00:02 | 57.78 | 65.12 |    59.115 |    65.12
 ABC    | 2009-07-12 03:00:04 | 67.88 | 65.12 |   63.4975 |    65.12
 XYZ    | 2009-07-12 03:00:00 | 47.55 | 46.78 |     47.55 |    46.78
 XYZ    | 2009-07-12 03:00:02 | 71.56 | 70.21 |    59.555 |   58.495
 XYZ    | 2009-07-12 03:00:04 | 45.55 | 58.65 |   52.5525 |  58.5725
(6 rows)

另请参阅

4.3.17 - FIRST_VALUE [analytic]

用于选择表或分区的第一个值（由 window-order-clause 确定），无需使用自联接。当您希望使用第一个值作为计算的基线时，此函数很有用。

将 FIRST_VALUE() 与 window-order-clause 结合使用，以生成具有确定性的结果。如果没有为当前行指定 窗口，则默认窗口为 UNBOUNDED PRECEDING AND CURRENT ROW。

行为类型

不可变

语法

FIRST_VALUE ( expression [ IGNORE NULLS ] ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
要求值的表达式 - 例如常数、列、非分析函数、函数表达式或涉及任何这些项目的表达式。
IGNORE NULLS
指定返回集中的第一个非 NULL 值，或者如果所有值均为 NULL，则返回 NULL。如果忽略此选项，且集合中的第一个值为 NULL，函数将返回 NULL。
OVER()
请参阅分析函数。

示例

以下查询希望获得“在星期几进行分区”值集的第一个值，并说明 FIRST_VALUE() 的潜在不确定性：

=> SELECT calendar_year, date_key, day_of_week, full_date_description,
   FIRST_VALUE(full_date_description)
     OVER(PARTITION BY calendar_month_number_in_year ORDER BY day_of_week)
     AS "first_value"
   FROM date_dimension
   WHERE calendar_year=2003 AND calendar_month_number_in_year=1;

返回的第一个值为 2003 年 1 月 31 日；但是下次运行相同的查询时，第一个值可能是 1 月 24 日或 1 月 3 日，或 10 日或 17 日。这是因为分析 ORDER BY 列 day_of_week 会返回包含关系（多个星期五）的行。这些重复的值使 ORDER BY 求值结果具有不确定性，因为包含关系的行可以按照任何方式排序，这些行中的任何一个都符合称为 day_of_week 的第一个值的条件。

 calendar_year | date_key | day_of_week | full_date_description |    first_value
 --------------+----------+-------------+-----------------------+------------------
          2003 |       31 | Friday      | January 31, 2003      | January 31, 2003
          2003 |       24 | Friday      | January 24, 2003      | January 31, 2003
          2003 |        3 | Friday      | January 3, 2003       | January 31, 2003
          2003 |       10 | Friday      | January 10, 2003      | January 31, 2003
          2003 |       17 | Friday      | January 17, 2003      | January 31, 2003
          2003 |        6 | Monday      | January 6, 2003       | January 31, 2003
          2003 |       27 | Monday      | January 27, 2003      | January 31, 2003
          2003 |       13 | Monday      | January 13, 2003      | January 31, 2003
          2003 |       20 | Monday      | January 20, 2003      | January 31, 2003
          2003 |       11 | Saturday    | January 11, 2003      | January 31, 2003
          2003 |       18 | Saturday    | January 18, 2003      | January 31, 2003
          2003 |       25 | Saturday    | January 25, 2003      | January 31, 2003
          2003 |        4 | Saturday    | January 4, 2003       | January 31, 2003
          2003 |       12 | Sunday      | January 12, 2003      | January 31, 2003
          2003 |       26 | Sunday      | January 26, 2003      | January 31, 2003
          2003 |        5 | Sunday      | January 5, 2003       | January 31, 2003
          2003 |       19 | Sunday      | January 19, 2003      | January 31, 2003
          2003 |       23 | Thursday    | January 23, 2003      | January 31, 2003
          2003 |        2 | Thursday    | January 2, 2003       | January 31, 2003
          2003 |        9 | Thursday    | January 9, 2003       | January 31, 2003
          2003 |       16 | Thursday    | January 16, 2003      | January 31, 2003
          2003 |       30 | Thursday    | January 30, 2003      | January 31, 2003
          2003 |       21 | Tuesday     | January 21, 2003      | January 31, 2003
          2003 |       14 | Tuesday     | January 14, 2003      | January 31, 2003
          2003 |        7 | Tuesday     | January 7, 2003       | January 31, 2003
          2003 |       28 | Tuesday     | January 28, 2003      | January 31, 2003
          2003 |       22 | Wednesday   | January 22, 2003      | January 31, 2003
          2003 |       29 | Wednesday   | January 29, 2003      | January 31, 2003
          2003 |       15 | Wednesday   | January 15, 2003      | January 31, 2003
          2003 |        1 | Wednesday   | January 1, 2003       | January 31, 2003
          2003 |        8 | Wednesday   | January 8, 2003       | January 31, 2003
(31 rows)

要返回具有确定性的结果，请修改查询，使其对唯一 字段（如 date_key）执行分析 ORDER BY 操作：

=> SELECT calendar_year, date_key, day_of_week, full_date_description,
   FIRST_VALUE(full_date_description) OVER
     (PARTITION BY calendar_month_number_in_year ORDER BY date_key) AS "first_value"
   FROM date_dimension WHERE calendar_year=2003;

FIRST_VALUE() 针对一月份分区返回第一个值 1 月 1 日，针对二月份分区返回第一个值 2 月 1 日 。此外，full_date_description 列不包含关系：

 calendar_year | date_key | day_of_week | full_date_description | first_value
---------------+----------+-------------+-----------------------+------------
          2003 |        1 | Wednesday   | January 1, 2003       | January 1, 2003
          2003 |        2 | Thursday    | January 2, 2003       | January 1, 2003
          2003 |        3 | Friday      | January 3, 2003       | January 1, 2003
          2003 |        4 | Saturday    | January 4, 2003       | January 1, 2003
          2003 |        5 | Sunday      | January 5, 2003       | January 1, 2003
          2003 |        6 | Monday      | January 6, 2003       | January 1, 2003
          2003 |        7 | Tuesday     | January 7, 2003       | January 1, 2003
          2003 |        8 | Wednesday   | January 8, 2003       | January 1, 2003
          2003 |        9 | Thursday    | January 9, 2003       | January 1, 2003
          2003 |       10 | Friday      | January 10, 2003      | January 1, 2003
          2003 |       11 | Saturday    | January 11, 2003      | January 1, 2003
          2003 |       12 | Sunday      | January 12, 2003      | January 1, 2003
          2003 |       13 | Monday      | January 13, 2003      | January 1, 2003
          2003 |       14 | Tuesday     | January 14, 2003      | January 1, 2003
          2003 |       15 | Wednesday   | January 15, 2003      | January 1, 2003
          2003 |       16 | Thursday    | January 16, 2003      | January 1, 2003
          2003 |       17 | Friday      | January 17, 2003      | January 1, 2003
          2003 |       18 | Saturday    | January 18, 2003      | January 1, 2003
          2003 |       19 | Sunday      | January 19, 2003      | January 1, 2003
          2003 |       20 | Monday      | January 20, 2003      | January 1, 2003
          2003 |       21 | Tuesday     | January 21, 2003      | January 1, 2003
          2003 |       22 | Wednesday   | January 22, 2003      | January 1, 2003
          2003 |       23 | Thursday    | January 23, 2003      | January 1, 2003
          2003 |       24 | Friday      | January 24, 2003      | January 1, 2003
          2003 |       25 | Saturday    | January 25, 2003      | January 1, 2003
          2003 |       26 | Sunday      | January 26, 2003      | January 1, 2003
          2003 |       27 | Monday      | January 27, 2003      | January 1, 2003
          2003 |       28 | Tuesday     | January 28, 2003      | January 1, 2003
          2003 |       29 | Wednesday   | January 29, 2003      | January 1, 2003
          2003 |       30 | Thursday    | January 30, 2003      | January 1, 2003
          2003 |       31 | Friday      | January 31, 2003      | January 1, 2003
          2003 |       32 | Saturday    | February 1, 2003      | February 1, 2003
          2003 |       33 | Sunday      | February 2, 2003      | February 1,2003
      ...
(365 rows)

另请参阅

4.3.18 - LAG [analytic]

在 窗口内当前行之前按照给定的偏移量返回该输入表达式的值。此函数允许您同时访问表中的多行。这对于在可以可靠地知道行的相对位置时比较值很有用。借助它还可以避免成本较高的自联接，从而加快查询处理速度。

有关获取后续行的信息，请参阅 LEAD。

行为类型

不可变

语法

LAG ( expression[, offset ] [, default ] ) OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

表达式
要进行求值的表达式，例如常数、列、非统计函数、函数表达式或任何涉及以上内容的表达式。
offset
表示 lag 有多大。默认值为 1（前一行）。此参数的计算结果必须为常数正整数。
default
offset 超出表或分区的边界时返回的值。此值必须是一个常数值或者可以解析为常数的表达式；数据类型强制转换为第一个实参的类型。

示例

这个例子计算了表中按照日期所剩下的余额的总和，同时计算了最后一天的先前余额的总和。依照接下来的输入，数据满足以下条件：

  • 对于每个 some_id，每个由 month_date 表示的日期都有 1 个行。

  • 对于每个 some_id，日期都是连续的；也就是说，如果 2 月 24 号有一行，2 月 26 号有一行，则 2 月 25 号也有一行。

  • 每个 some_id 都有相同的一组日期。

    => CREATE TABLE balances (
       month_date DATE,
       current_bal INT,
       some_id INT);

    => INSERT INTO balances values ('2009-02-24', 10, 1);
=> INSERT INTO balances values ('2009-02-25', 10, 1);
=> INSERT INTO balances values ('2009-02-26', 10, 1);
=> INSERT INTO balances values ('2009-02-24', 20, 2);
=> INSERT INTO balances values ('2009-02-25', 20, 2);
=> INSERT INTO balances values ('2009-02-26', 20, 2);
=> INSERT INTO balances values ('2009-02-24', 30, 3);
=> INSERT INTO balances values ('2009-02-25', 20, 3);
=> INSERT INTO balances values ('2009-02-26', 30, 3);

现在使用 LAG 计算当前每一个日期的余额的总和，以及最后一天的先前余额的总和：

=> SELECT month_date,
     SUM(current_bal) as current_bal_sum,
     SUM(previous_bal) as previous_bal_sum FROM
       (SELECT month_date, current_bal,
     LAG(current_bal, 1, 0) OVER
       (PARTITION BY some_id ORDER BY month_date)
     AS previous_bal FROM balances) AS subQ
     GROUP BY month_date ORDER BY month_date;
month_date  | current_bal_sum | previous_bal_sum
------------+-----------------+------------------
 2009-02-24 |              60 |                0
 2009-02-25 |              50 |               60
 2009-02-26 |              60 |               50
(3 rows)

对于相同的示例数据来说，不可使用接下来的查询，原因是 LAG 嵌套在一个聚合函数中：

=> SELECT month_date,
    SUM(current_bal) as current_bal_sum,
   SUM(LAG(current_bal, 1, 0) OVER
      (PARTITION BY some_id ORDER BY month_date)) AS previous_bal_sum
   FROM some_table GROUP BY month_date ORDER BY month_date;

下面的示例使用了 VMart 数据库。LAG 首先返回前一行的年收入值，然后计算当前行收入与前一行收入的差：

=> SELECT occupation, customer_key, customer_name, annual_income,
   LAG(annual_income, 1, 0) OVER (PARTITION BY occupation
   ORDER BY annual_income) AS prev_income, annual_income -
   LAG(annual_income, 1, 0) OVER (PARTITION BY occupation
   ORDER BY annual_income) AS difference
   FROM customer_dimension ORDER BY occupation, customer_key LIMIT 20;
 occupation | customer_key |    customer_name     | annual_income | prev_income | difference
------------+--------------+----------------------+---------------+-------------+------------
 Accountant |           15 | Midori V. Peterson   |        692610 |      692535 |         75
 Accountant |           43 | Midori S. Rodriguez  |        282359 |      280976 |       1383
 Accountant |           93 | Robert P. Campbell   |        471722 |      471355 |        367
 Accountant |          102 | Sam T. McNulty       |        901636 |      901561 |         75
 Accountant |          134 | Martha B. Overstreet |        705146 |      704335 |        811
 Accountant |          165 | James C. Kramer      |        376841 |      376474 |        367
 Accountant |          225 | Ben W. Farmer        |         70574 |       70449 |        125
 Accountant |          270 | Jessica S. Lang      |        684204 |      682274 |       1930
 Accountant |          273 | Mark X. Lampert      |        723294 |      722737 |        557
 Accountant |          295 | Sharon K. Gauthier   |         29033 |       28412 |        621
 Accountant |          338 | Anna S. Jackson      |        816858 |      815557 |       1301
 Accountant |          377 | William I. Jones     |        915149 |      914872 |        277
 Accountant |          438 | Joanna A. McCabe     |        147396 |      144482 |       2914
 Accountant |          452 | Kim P. Brown         |        126023 |      124797 |       1226
 Accountant |          467 | Meghan K. Carcetti   |        810528 |      810284 |        244
 Accountant |          478 | Tanya E. Greenwood   |        639649 |      639029 |        620
 Accountant |          511 | Midori P. Vogel      |        187246 |      185539 |       1707
 Accountant |          525 | Alexander K. Moore   |        677433 |      677050 |        383
 Accountant |          550 | Sam P. Reyes         |        735691 |      735355 |        336
 Accountant |          577 | Robert U. Vu         |        616101 |      615439 |        662
(20 rows)

接下来的示例使用了 LEAD 和 LAG 返回了当前行工资后的第三行以及当前行工资之前的第五行：

=> SELECT hire_date, employee_key, employee_last_name,
   LEAD(hire_date, 1) OVER (ORDER BY hire_date) AS "next_hired" ,
   LAG(hire_date, 1) OVER (ORDER BY hire_date) AS "last_hired"
   FROM employee_dimension ORDER BY hire_date, employee_key;
 hire_date  | employee_key | employee_last_name | next_hired | last_hired
------------+--------------+--------------------+------------+------------
 1956-04-11 |         2694 | Farmer             | 1956-05-12 |
 1956-05-12 |         5486 | Winkler            | 1956-09-18 | 1956-04-11
 1956-09-18 |         5525 | McCabe             | 1957-01-15 | 1956-05-12
 1957-01-15 |          560 | Greenwood          | 1957-02-06 | 1956-09-18
 1957-02-06 |         9781 | Bauer              | 1957-05-25 | 1957-01-15
 1957-05-25 |         9506 | Webber             | 1957-07-04 | 1957-02-06
 1957-07-04 |         6723 | Kramer             | 1957-07-07 | 1957-05-25
 1957-07-07 |         5827 | Garnett            | 1957-11-11 | 1957-07-04
 1957-11-11 |          373 | Reyes              | 1957-11-21 | 1957-07-07
 1957-11-21 |         3874 | Martin             | 1958-02-06 | 1957-11-11
(10 rows)

另请参阅

4.3.19 - LAST_VALUE [analytic]

用于选择表或分区的最后一个值（由 window-order-clause 确定），无需使用自联接。 LAST_VALUE 在窗口顺序子句统计后，取分区的最后一个记录。然后此函数根据最后一个记录计算表达式，并返回结果。如果要使用最后值做为计算的基准，该函数非常有帮助。

将 LAST_VALUE() 与 window-order-clause 结合使用，以生成具有确定性的结果。如果没有为当前行指定 窗口，则默认窗口为 UNBOUNDED PRECEDING AND CURRENT ROW。

行为类型

不可变

语法

LAST_VALUE ( expression [ IGNORE NULLS ] ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
要求值的表达式，例如常数、列、非统计函数、函数表达式或任何涉及以上内容的表达式。
IGNORE NULLS
指定返回集中的最后一个非 NULL 值，或者如果所有值均为 NULL，则返回 NULL。如果忽略此选项且集合中的最后一个值为 NULL，则函数将返回 NULL。
OVER()
请参阅分析函数。

示例

如果在分析数据时使用在 窗口框架 中定义的架构，以下查询并不会按照部门显示最高工资数；它会按照部门和工资显示最高工资数。

=> SELECT deptno, sal, empno, LAST_VALUE(sal)
       OVER (PARTITION BY deptno ORDER BY sal) AS lv
   FROM emp;
 deptno | sal | empno |    lv
--------+-----+-------+--------
     10 | 101 |     1 |     101
     10 | 104 |     4 |     104
     20 | 100 |    11 |     100
     20 | 109 |     7 |     109
     20 | 109 |     6 |     109
     20 | 109 |     8 |     109
     20 | 110 |    10 |     110
     20 | 110 |     9 |     110
     30 | 102 |     2 |     102
     30 | 103 |     3 |     103
     30 | 105 |     5 |     105

如果包含了窗口框架子句 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING， LAST_VALUE() 按部门返回最高工资，是信息的准确表达。

=> SELECT deptno, sal, empno, LAST_VALUE(sal)
       OVER (PARTITION BY deptno ORDER BY sal
            ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS lv
   FROM emp;
 deptno | sal | empno |    lv
--------+-----+-------+--------
     10 | 101 |     1 |     104
     10 | 104 |     4 |     104
     20 | 100 |    11 |     110
     20 | 109 |     7 |     110
     20 | 109 |     6 |     110
     20 | 109 |     8 |     110
     20 | 110 |    10 |     110
     20 | 110 |     9 |     110
     30 | 102 |     2 |     105
     30 | 103 |     3 |     105
     30 | 105 |     5 |     105

更多示例，请访问 FIRST_VALUE()。

另请参阅

4.3.20 - LEAD [analytic]

从 窗口内当前行之后的行返回值，以便您可以同时访问表中的多行。这对于在可以可靠地知道行的相对位置时比较值很有用。借助它还可以避免成本较高的自联接，从而加快查询处理速度。

行为类型

不可变

语法

LEAD ( expression[, offset ] [, default ] ) OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

表达式
要进行求值的表达式，例如常数、列、非统计函数、函数表达式或任何涉及以上内容的表达式。
offset
是一个可选参数，默认值为 1（下一行）。此参数的计算结果必须为常数正整数。
default
offset 超出表或分区的边界时返回的值。此值必须是一个常数值或者可以解析为常数的表达式；数据类型强制转换为第一个实参的类型。

示例

LEAD 在当前行之后找到了员工的雇佣日期：


=> SELECT employee_region, hire_date, employee_key, employee_last_name,
   LEAD(hire_date, 1) OVER (PARTITION BY employee_region ORDER BY hire_date) AS "next_hired"
   FROM employee_dimension ORDER BY employee_region, hire_date, employee_key;
  employee_region  | hire_date  | employee_key | employee_last_name | next_hired
-------------------+------------+--------------+--------------------+------------
 East              | 1956-04-08 |         9218 | Harris             | 1957-02-06
 East              | 1957-02-06 |         7799 | Stein              | 1957-05-25
 East              | 1957-05-25 |         3687 | Farmer             | 1957-06-26
 East              | 1957-06-26 |         9474 | Bauer              | 1957-08-18
 East              | 1957-08-18 |          570 | Jefferson          | 1957-08-24
 East              | 1957-08-24 |         4363 | Wilson             | 1958-02-17
 East              | 1958-02-17 |         6457 | McCabe             | 1958-06-26
 East              | 1958-06-26 |         6196 | Li                 | 1958-07-16
 East              | 1958-07-16 |         7749 | Harris             | 1958-09-18
 East              | 1958-09-18 |         9678 | Sanchez            | 1958-11-10
(10 rows)

接下来的示例使用 LEAD 和 LAG 返回了当前行工资后的第三行以及当前行工资之前的第五行。

=> SELECT hire_date, employee_key, employee_last_name,
   LEAD(hire_date, 1) OVER (ORDER BY hire_date) AS "next_hired" ,
   LAG(hire_date, 1) OVER (ORDER BY hire_date) AS "last_hired"
   FROM employee_dimension ORDER BY hire_date, employee_key;
 hire_date  | employee_key | employee_last_name | next_hired | last_hired
------------+--------------+--------------------+------------+------------
 1956-04-11 |         2694 | Farmer             | 1956-05-12 |
 1956-05-12 |         5486 | Winkler            | 1956-09-18 | 1956-04-11
 1956-09-18 |         5525 | McCabe             | 1957-01-15 | 1956-05-12
 1957-01-15 |          560 | Greenwood          | 1957-02-06 | 1956-09-18
 1957-02-06 |         9781 | Bauer              | 1957-05-25 | 1957-01-15
 1957-05-25 |         9506 | Webber             | 1957-07-04 | 1957-02-06
 1957-07-04 |         6723 | Kramer             | 1957-07-07 | 1957-05-25
 1957-07-07 |         5827 | Garnett            | 1957-11-11 | 1957-07-04
 1957-11-11 |          373 | Reyes              | 1957-11-21 | 1957-07-07
 1957-11-21 |         3874 | Martin             | 1958-02-06 | 1957-11-11
(10 rows)

以下例子返回员工名和工资，以及最高工资和最低工资。

=> SELECT employee_last_name, annual_salary,
       NVL(LEAD(annual_salary) OVER (ORDER BY annual_salary),
         MIN(annual_salary) OVER()) "Next Highest",
       NVL(LAG(annual_salary) OVER (ORDER BY annual_salary),
         MAX(annual_salary)  OVER()) "Next Lowest"
   FROM employee_dimension;
 employee_last_name | annual_salary | Next Highest | Next Lowest
--------------------+---------------+--------------+-------------
 Nielson            |          1200 |         1200 |      995533
 Lewis              |          1200 |         1200 |        1200
 Harris             |          1200 |         1202 |        1200
 Robinson           |          1202 |         1202 |        1200
 Garnett            |          1202 |         1202 |        1202
 Weaver             |          1202 |         1202 |        1202
 Nielson            |          1202 |         1202 |        1202
 McNulty            |          1202 |         1204 |        1202
 Farmer             |          1204 |         1204 |        1202
 Martin             |          1204 |         1204 |        1204
(10 rows)

下一个例子在员工表中每一个助理总监，在当前行总监之后入职的总监的雇用日期。例如，Jackson 被雇佣日期是 2016/12/28，下一个雇佣的总监是 Bauer：

=> SELECT employee_last_name, hire_date,
       LEAD(hire_date, 1) OVER (ORDER BY hire_date DESC) as "NextHired"
   FROM employee_dimension WHERE job_title = 'Assistant Director';
 employee_last_name | hire_date  | NextHired
--------------------+------------+------------
 Jackson            | 2016-12-28 | 2016-12-26
 Bauer              | 2016-12-26 | 2016-12-11
 Miller             | 2016-12-11 | 2016-12-07
 Fortin             | 2016-12-07 | 2016-11-27
 Harris             | 2016-11-27 | 2016-11-15
 Goldberg           | 2016-11-15 |
(5 rows)

另请参阅

4.3.21 - MAX [analytic]

返回 窗口内某个表达式的最大值。返回值的类型与表达式数据类型相同。

分析函数 MIN() 和 MAX() 可以使用布尔值运行。MAX() 函数可以执行 布尔数据类型 或可隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX() 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN() 函数返回 t (true)。否则，它返回 f。

行为类型

不可变

语法


MAX ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
计算其最大值的表达式，通常是列引用。
OVER()
请参阅分析函数。

示例

下面的查询计算员工年薪与马萨诸塞州最高年薪之间的偏差。

=> SELECT employee_state, annual_salary,
     MAX(annual_salary)
       OVER(PARTITION BY employee_state ORDER BY employee_key) max,
          annual_salary- MAX(annual_salary)
       OVER(PARTITION BY employee_state ORDER BY employee_key) diff
   FROM employee_dimension
   WHERE employee_state = 'MA';
 employee_state | annual_salary |  max   |  diff
----------------+---------------+--------+---------
 MA             |          1918 | 995533 | -993615
 MA             |          2058 | 995533 | -993475
 MA             |          2586 | 995533 | -992947
 MA             |          2500 | 995533 | -993033
 MA             |          1318 | 995533 | -994215
 MA             |          2072 | 995533 | -993461
 MA             |          2656 | 995533 | -992877
 MA             |          2148 | 995533 | -993385
 MA             |          2366 | 995533 | -993167
 MA             |          2664 | 995533 | -992869
(10 rows)

以下示例显示了当您将 MIN 和 MAX 分析函数与布尔值一起使用时，它们之间的区别。该示例创建了一个包含两列的表，添加了两行数据，并显示了 MIN 和 MAX 的示例输出。

CREATE TABLE min_max_functions (emp VARCHAR, torf BOOL);

INSERT INTO min_max_functions VALUES ('emp1', 1);
INSERT INTO min_max_functions VALUES ('emp1', 0);

SELECT DISTINCT emp,
min(torf) OVER (PARTITION BY emp) AS worksasbooleanand,
Max(torf) OVER (PARTITION BY emp) AS worksasbooleanor
FROM min_max_functions;

 emp  | worksasbooleanand | worksasbooleanor
------+-------------------+------------------
 emp1 | f                 | t
(1 row)

另请参阅

4.3.22 - MEDIAN [analytic]

对于每一行，返回每个分区内值集的中值。 MEDIAN 用最高的数字优先级确定实参，将剩余实参隐式转换为该数据类型，并返回该数据类型。

MEDIAN 是实参为 0.5 (50%) 的 PERCENTILE_CONT [analytic] 的一个别名。

行为类型

不可变

语法

MEDIAN ( expression ) OVER ( [ window‑partition‑clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回中值或排序后成为中值的内插值。计算中忽略空值。
OVER()
如果 OVER 子句指定 window-partition-clause，MEDIAN 会根据一个或多个列或表达式对输入行进行分组。如果忽略此子句，则不会进行分组，且 MEDIAN 会将所有输入行作为单分区处理。

示例

请参阅 计算中间值

另请参阅

4.3.23 - MIN [analytic]

返回 窗口内某个表达式的最小值。返回值的类型与表达式数据类型相同。

分析函数 MIN() 和 MAX() 可以使用布尔值运行。MAX() 函数可以执行 布尔数据类型 或可隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX() 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN() 函数返回 t (true)。否则，它返回 f。

行为类型

不可变

语法


MIN ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
为其计算最小值的任意表达式，通常为列引用。
OVER()
请参阅分析函数。

示例

下面的示例显示了如何查询以确定员工年薪与马萨诸塞州最低年薪之间的偏差：

=> SELECT employee_state, annual_salary,
      MIN(annual_salary)
      OVER(PARTITION BY employee_state ORDER BY employee_key) min,
        annual_salary- MIN(annual_salary)
      OVER(PARTITION BY employee_state ORDER BY employee_key) diff
   FROM employee_dimension
   WHERE employee_state = 'MA';
 employee_state | annual_salary | min  | diff
----------------+---------------+------+------
 MA             |          1918 | 1204 |  714
 MA             |          2058 | 1204 |  854
 MA             |          2586 | 1204 | 1382
 MA             |          2500 | 1204 | 1296
 MA             |          1318 | 1204 |  114
 MA             |          2072 | 1204 |  868
 MA             |          2656 | 1204 | 1452
 MA             |          2148 | 1204 |  944
 MA             |          2366 | 1204 | 1162
 MA             |          2664 | 1204 | 1460
(10 rows)

以下示例显示了当您将 MIN 和 MAX 分析函数与布尔值一起使用时，它们之间的区别。该示例创建了一个包含两列的表，添加了两行数据，并显示了 MIN 和 MAX 的示例输出。

CREATE TABLE min_max_functions (emp VARCHAR, torf BOOL);

INSERT INTO min_max_functions VALUES ('emp1', 1);
INSERT INTO min_max_functions VALUES ('emp1', 0);

SELECT DISTINCT emp,
min(torf) OVER (PARTITION BY emp) AS worksasbooleanand,
Max(torf) OVER (PARTITION BY emp) AS worksasbooleanor
FROM min_max_functions;

 emp  | worksasbooleanand | worksasbooleanor
------+-------------------+------------------
 emp1 | f                 | t
(1 row)

另请参阅

4.3.24 - NTILE [analytic]

将有序数据集（分区）等分成 窗口内的 {value} 个子集，其中子集通过参数 constant‑value 编号为 1。例如，如果 constant-value= 4，且分区包含 20 行，则 NTILE 会将分区行分成四个相等的子集（每个子集包含五行）。 NTILE 为行指定一个从 1 到 4 的数字，然后将每一行分配给其中一个子集。为第一个子集中的行分配 1，为第二个子集中的五行分配 2，依此类推。

如果分区行数无法被子集数整除，则任何子集的行数不得比任何其他子集多超过 1，且最小的子集具有多余行数。例如，如果 constant-value = 4，且行数 = 21，则第一个子集有 6 行，第二个子集有 5 行，依此类推。

如果子集数大于行数，则对等同于行数的子集进行填充，剩余的子集留空。

行为类型

不可变

语法

NTILE ( constant‑value ) OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

constant‑value
指定子集的数目，其中 constant‑value 必须为每个分区分解成为正常数。
OVER()
请参阅分析函数。

示例

下面的查询将每个月的销售额分配至四个子集之一。

=> SELECT calendar_month_name AS MONTH, SUM(sales_quantity),
      NTILE(4) OVER (ORDER BY SUM(sales_quantity)) AS NTILE
   FROM store.store_sales_fact JOIN date_dimension
   USING(date_key)
   GROUP BY calendar_month_name
   ORDER BY NTILE;
   MONTH   |   SUM   | NTILE
-----------+---------+-------
 November  | 2040726 |     1
 June      | 2088528 |     1
 February  | 2134708 |     1
 April     | 2181767 |     2
 January   | 2229220 |     2
 October   | 2316363 |     2
 September | 2323914 |     3
 March     | 2354409 |     3
 August    | 2387017 |     3
 July      | 2417239 |     4
 May       | 2492182 |     4
 December  | 2531842 |     4
(12 rows)

另请参阅

4.3.25 - NTH_VALUE [analytic]

在窗口的第 n 行（从第 1 行开始计数）上求值并返回求值结果。如果指定的行不存在，NTH_VALUE 将返回 NULL。

行为类型

不可变

语法

NTH_VALUE ( expression, row‑number [ IGNORE NULLS ] ) OVER (
    [ window-frame-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
计算表达式。该表达式可以是常量、列名称、非解析函数、函数表达式或包含任意各项的表达式。
row‑number
指定要计算的行，其中 row‑number 计算结果为 ≥ 1 的整数。
IGNORE NULLS
指定返回集中第一个非NULL 值，如果所有值均为 NULL，则返回 NULL。
OVER()
请参阅分析函数。

示例

在以下示例中，对于表 t1 中的每个元组（当前行），窗口框架子句将窗口定义如下：

ORDER BY b ROWS BETWEEN 3 PRECEDING AND CURRENT ROW

对于每个窗口，第 n 个值中的 n 为 a+1。 a 是元组中列 a 的值。

NTH_VALUE 返回表达式 b+1 的结果，其中 b 是第 n 行（即窗口中的 a+1 行）中列 b 的值。

=> SELECT * FROM t1 ORDER BY a;
 a | b
---+----
 1 | 10
 2 | 20
 2 | 21
 3 | 30
 4 | 40
 5 | 50
 6 | 60
(7 rows)


=> SELECT NTH_VALUE(b+1, a+1) OVER
     (ORDER BY b ROWS BETWEEN 3 PRECEDING AND CURRENT ROW) FROM t1;
 ?column?
----------


       22
       31



(7 rows)

4.3.26 - PERCENT_RANK [analytic]

通过用行的排名（减去 1）除以分区中的行数（也减去 1），计算 窗口内组中给定行的行相对排名。PERCENT_RANK 始终返回 0 到 1 之间的值（包含）。任何集中的第一行具有为 0 的 PERCENT_RANK。返回值为 NUMBER。

( rank - 1 ) / ( [ rows ] - 1 )

在前面的公式中，rank 为组中行的排名位置，rows 为 OVER() 语句定义的分区中行的总数量。

行为类型

不可变

语法

PERCENT_RANK ( ) OVER (
    [ window-partition-clause ]
    window-order-clause  )

参数

OVER()
请参阅分析函数

示例

以下示例可得出第一季度每个月不同状态的毛利润百分比排名：

=> SELECT calendar_month_name AS MONTH, store_state,
      SUM(gross_profit_dollar_amount),
      PERCENT_RANK() OVER (PARTITION BY calendar_month_name
      ORDER BY SUM(gross_profit_dollar_amount)) AS PERCENT_RANK
   FROM store.store_sales_fact JOIN date_dimension
   USING(date_key)
   JOIN store.store_dimension
   USING (store_key)
   WHERE calendar_month_name IN ('January','February','March')
   AND store_state IN ('OR','IA','DC','NV','WI')
   GROUP BY calendar_month_name, store_state
   ORDER BY calendar_month_name, PERCENT_RANK;
  MONTH   | store_state |  SUM   | PERCENT_RANK
----------+-------------+--------+--------------
 February | IA          | 418490 |            0
 February | OR          | 460588 |         0.25
 February | DC          | 616553 |          0.5
 February | WI          | 619204 |         0.75
 February | NV          | 838039 |            1
 January  | OR          | 446528 |            0
 January  | IA          | 474501 |         0.25
 January  | DC          | 628496 |          0.5
 January  | WI          | 679382 |         0.75
 January  | NV          | 871824 |            1
 March    | IA          | 460282 |            0
 March    | OR          | 481935 |         0.25
 March    | DC          | 716063 |          0.5
 March    | WI          | 771575 |         0.75
 March    | NV          | 970878 |            1
(15 rows)

以下示例计算了不同职位每名员工的工资百分比排名。

=> SELECT job_title, employee_last_name, annual_salary,
       PERCENT_RANK()
      OVER (PARTITION BY job_title ORDER BY annual_salary DESC) AS percent_rank
   FROM employee_dimension
   ORDER BY percent_rank, annual_salary;
     job_title      | employee_last_name | annual_salary |    percent_rank
--------------------+--------------------+---------------+---------------------
 Cashier            | Fortin             |          3196 |                   0
 Delivery Person    | Garnett            |          3196 |                   0
 Cashier            | Vogel              |          3196 |                   0
 Customer Service   | Sanchez            |          3198 |                   0
 Shelf Stocker      | Jones              |          3198 |                   0
 Custodian          | Li                 |          3198 |                   0
 Customer Service   | Kramer             |          3198 |                   0
 Greeter            | McNulty            |          3198 |                   0
 Greeter            | Greenwood          |          3198 |                   0
 Shift Manager      | Miller             |         99817 |                   0
 Advertising        | Vu                 |         99853 |                   0
 Branch Manager     | Jackson            |         99858 |                   0
 Marketing          | Taylor             |         99928 |                   0
 Assistant Director | King               |         99973 |                   0
 Sales              | Kramer             |         99973 |                   0
 Head of PR         | Goldberg           |        199067 |                   0
 Regional Manager   | Gauthier           |        199744 |                   0
 Director of HR     | Moore              |        199896 |                   0
 Head of Marketing  | Overstreet         |        199955 |                   0
 VP of Advertising  | Meyer              |        199975 |                   0
 VP of Sales        | Sanchez            |        199992 |                   0
 Founder            | Gauthier           |        927335 |                   0
 CEO                | Taylor             |        953373 |                   0
 Investor           | Garnett            |        963104 |                   0
 Co-Founder         | Vu                 |        977716 |                   0
 CFO                | Vogel              |        983634 |                   0
 President          | Sanchez            |        992363 |                   0
 Delivery Person    | Li                 |          3194 | 0.00114155251141553
 Delivery Person    | Robinson           |          3194 | 0.00114155251141553
 Custodian          | McCabe             |          3192 | 0.00126582278481013
 Shelf Stocker      | Moore              |          3196 | 0.00128040973111396
 Branch Manager     | Moore              |         99716 | 0.00186567164179104
...

另请参阅

4.3.27 - PERCENTILE_CONT [analytic]

一个逆分布函数，在此函数中，对于每行，PERCENTILE_CONT 将返回 窗口内每个分区中的一组值中落入指定百分位的值。例如，如果函数的实参值为 0.5，则函数的结果为数据集的中间值（第 50 个百分位）。PERCENTILE_CONT 假设了连续分布的数据模型。忽略 NULL 值。

PERCENTILE_CONT 通过首先计算百分位存在的行的行数来计算百分位。例如：

row‑number = 1 + percentile‑value * (num‑partition‑rows -1)

如果 row‑number 为完整数（误差范围 0.00001），则百分位为行 row‑number 的值。

否则，Vertica 会在 CEILING(row‑number) 行的值和 FLOOR(row‑number) 行的值之间插入百分位值。换句话说，将按以下方式计算百分位：

  ( CEILING( row‑number) - row‑number ) * ( value of FLOOR(row‑number) row )
+ ( row‑number - FLOOR(row‑number) ) * ( value of CEILING(row‑number) row)

行为类型

不可变

语法

PERCENTILE_CONT ( percentile ) WITHIN GROUP ( ORDER BY expression [ ASC | DESC ] ) OVER ( [ window-partition-clause ] )

参数

percentile
百分位值，为 0 到 1（包含）范围内的 FLOAT 常数。
WITHIN GROUP (ORDER BY expression)
指定如何对每个组内的数据进行排序。ORDER BY 仅使用数据类型为 INTEGER、FLOAT、INTERVAL 或 NUMERIC 的列/表达式。NULL 值将被丢弃。

WITHIN GROUP(ORDER BY) 子句不能保证 SQL 结果的顺序。要对最终结果进行排序，请使用 SQL ORDER BY 子句集。

ASC | DESC
将排序顺序指定为升序（默认值）或降序。

只要 percentile 不是 0.5，在 WITHIN GROUP 子句中指定 ASC 或 DESC 会影响到结果。

OVER()
请参阅分析函数

示例

该查询会计算威斯康星和哥伦比亚区的前 300 位客户的每组的年收入中间值。

=> SELECT customer_state, customer_key, annual_income, PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY annual_income)
      OVER (PARTITION BY customer_state) AS PERCENTILE_CONT
   FROM customer_dimension WHERE customer_state IN ('DC','WI') AND customer_key < 300
   ORDER BY customer_state, customer_key;
 customer_state | customer_key | annual_income | PERCENTILE_CONT
----------------+--------------+---------------+-----------------
 DC             |           52 |        168312 |        483266.5
 DC             |          118 |        798221 |        483266.5
 WI             |           62 |        283043 |          377691
 WI             |          139 |        472339 |          377691
(4 rows)

该查询会计算威斯康星和哥伦比亚区全部客户的每组的年收入中间值。

=> SELECT customer_state, customer_key, annual_income, PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY annual_income)
      OVER (PARTITION BY customer_state) AS PERCENTILE_CONT
   FROM customer_dimension WHERE customer_state IN ('DC','WI') ORDER BY customer_state, customer_key;
 customer_state | customer_key | annual_income | PERCENTILE_CONT
----------------+--------------+---------------+-----------------
 DC             |           52 |        168312 |        483266.5
 DC             |          118 |        798221 |        483266.5
 DC             |          622 |        220782 |          555088
 DC             |          951 |        178453 |          555088
 DC             |          972 |        961582 |          555088
 DC             |         1286 |        760445 |          555088
 DC             |         1434 |         44836 |          555088
 ...


 WI             |           62 |        283043 |          377691
 WI             |          139 |        472339 |          377691
 WI             |          359 |         42242 |          517717
 WI             |          364 |        867543 |          517717
 WI             |          403 |        509031 |          517717
 WI             |          455 |         32000 |          517717
 WI             |          485 |        373129 |          517717
 ...


(1353 rows)

另请参阅

4.3.28 - PERCENTILE_DISC [analytic]

一个逆分布函数，在此函数中，对于每行，PERCENTILE_DISC 将返回 窗口内每个分区中的一组值中落入指定百分位的值。 PERCENTILE_DISC() 假设一个离散分布数据模型。 NULL 值将被忽略。

PERCENTILE_DISC 会检查每组中的累计离散值，直到找到大于或等于指定百分位的值。Vertica 会计算每一行的百分位，PERCENTILE_DISC 会输出 WITHIN GROUP(ORDER BY) 列的第一个值，其 CUME_DIST（累计离散）值大于等于实参 FLOAT 值（如 0.4）：

PERCENTILE_DIST(0.4) WITHIN GROUP (ORDER BY salary) OVER(PARTITION BY deptno)...

给定以下查询：

SELECT CUME_DIST() OVER(ORDER BY salary) FROM table-name;

最小的大于 0.4 的 CUME_DIST 值也为 PERCENTILE_DISC。

行为类型

不可变

语法

PERCENTILE_DISC ( percentile ) WITHIN GROUP (
    ORDER BY expression [ ASC | DESC ] ) OVER (
    [ window-partition-clause ] )

参数

percentile
百分位值，为 0 到 1（包含）范围内的 FLOAT 常数。
WITHIN GROUP(ORDER BY expression)
指定如何对每个组内的数据进行排序。 ORDER BY 仅使用数据类型为 INTEGER、FLOAT、INTERVAL 或 NUMERIC 的列/表达式。 NULL 值将被丢弃。

WITHIN GROUP(ORDER BY) 子句不能保证 SQL 结果的顺序。要对最终结果进行排序，请使用 SQL ORDER BY 子句集。

ASC | DESC
将排序顺序指定为升序（默认值）或降序。
OVER()
请参阅分析函数

示例

该查询会计算威斯康星和哥伦比亚区的前 300 位客户的每组的第 20 个百分值年收入。

=> SELECT customer_state, customer_key, annual_income,
      PERCENTILE_DISC(.2) WITHIN GROUP(ORDER BY annual_income)
      OVER (PARTITION BY customer_state) AS PERCENTILE_DISC
   FROM customer_dimension
   WHERE customer_state IN ('DC','WI')
   AND customer_key < 300
   ORDER BY customer_state, customer_key;
 customer_state | customer_key | annual_income | PERCENTILE_DISC
----------------+--------------+---------------+-----------------
 DC             |          104 |        658383 |          417092
 DC             |          168 |        417092 |          417092
 DC             |          245 |        670205 |          417092
 WI             |          106 |        227279 |          227279
 WI             |          127 |        703889 |          227279
 WI             |          209 |        458607 |          227279
(6 rows)

另请参阅

4.3.29 - RANK [analytic]

在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。

RANK 按以下方式执行：

  1. 按 ORDER BY 子句指定的顺序对分区行进行排序。

  2. 比较前一行与当前行的 ORDER BY 值，并按以下方式对当前行进行排名：

    • 如果 ORDER BY 值相同，则当前行获得的排名与前一行相同。

    • 如果 ORDER BY 值不同，DENSE_RANK 将按 1 递增或递减当前行的排名，再加上在其之前的行中的连续重复值数量。

最大排名值等于查询返回的总行数。

行为类型

不可变

语法

RANK() OVER (
    [ window-partition-clause ]
    window-order-clause )

参数

OVER()
请参阅分析函数

与 DENSE_RANK 比较

RANK 会在排名序列中留下间隙，而 DENSE_RANK 不会出现这种情况。

示例

以下查询按州对自 2007 年以来成为公司客户的所有客户进行排名。在 customer_since 日期相同的行中，RANK 将为这些行分配相同的排名。当 customer_since 日期发生更改时，RANK 会跳过一个或多个排名 — 例如，在 CA 内从第 12 名到跳到第 14 名，以及从第 17 名跳到第 19 名。

=> SELECT customer_state, customer_name, customer_since,
    RANK() OVER (PARTITION BY customer_state ORDER BY customer_since) AS rank
    FROM customer_dimension WHERE customer_type='Company' AND customer_since > '01/01/2007'
    ORDER BY customer_state;
  customer_state | customer_name | customer_since | rank
----------------+---------------+----------------+------
 AZ             | Foodshop      | 2007-01-20     |    1
 AZ             | Goldstar      | 2007-08-11     |    2
 CA             | Metahope      | 2007-01-05     |    1
 CA             | Foodgen       | 2007-02-05     |    2
 CA             | Infohope      | 2007-02-09     |    3
 CA             | Foodcom       | 2007-02-19     |    4
 CA             | Amerihope     | 2007-02-22     |    5
 CA             | Infostar      | 2007-03-05     |    6
 CA             | Intracare     | 2007-03-14     |    7
 CA             | Infocare      | 2007-04-07     |    8
 ...
 CO             | Goldtech      | 2007-02-19     |    1
 CT             | Foodmedia     | 2007-02-11     |    1
 CT             | Metatech      | 2007-02-20     |    2
 CT             | Infocorp      | 2007-04-10     |    3
 ...

另请参阅

SQL 分析

4.3.30 - ROW_NUMBER [analytic]

为 窗口分区中的每一行分配一系列唯一编号，从 1 开始。通常情况下，ROW_NUMBER 和 RANK 可以互换，但有以下区别：

  • ROW_NUMBER 为有序集中的每一行分配一个唯一的序号，从 1 开始。

  • ROW_NUMBER() 为 Vertica 扩展，而 RANK 符合 SQL-99 标准。

行为类型

不可变

语法

ROW_NUMBER () OVER (
    [ window-partition-clause ]
    [ window-order-clause ] )

参数

OVER()
请参阅分析函数

示例

以下 ROW_NUMBER 查询按 customer_region 对 VMart 表 customer_dimension 中的客户进行分区。在每个分区中，该函数按其窗口顺序子句指定的资历顺序对这些客户进行排名：

=> SELECT * FROM
    (SELECT ROW_NUMBER() OVER (PARTITION BY customer_region ORDER BY customer_since) AS most_senior,
     customer_region, customer_name, customer_since FROM public.customer_dimension WHERE customer_type = 'Individual') sq
   WHERE most_senior <= 5;
 most_senior | customer_region |    customer_name     | customer_since
-------------+-----------------+----------------------+----------------
           1 | West            | Jack Y. Perkins      | 1965-01-01
           2 | West            | Linda Q. Winkler     | 1965-01-02
           3 | West            | Marcus K. Li         | 1965-01-03
           4 | West            | Carla R. Jones       | 1965-01-07
           5 | West            | Seth P. Young        | 1965-01-09
           1 | East            | Kim O. Vu            | 1965-01-01
           2 | East            | Alexandra L. Weaver  | 1965-01-02
           3 | East            | Steve L. Webber      | 1965-01-04
           4 | East            | Thom Y. Li           | 1965-01-05
           5 | East            | Martha B. Farmer     | 1965-01-07
           1 | SouthWest       | Martha V. Gauthier   | 1965-01-01
           2 | SouthWest       | Jessica U. Goldberg  | 1965-01-07
           3 | SouthWest       | Robert O. Stein      | 1965-01-07
           4 | SouthWest       | Emily I. McCabe      | 1965-01-18
           5 | SouthWest       | Jack E. Miller       | 1965-01-25
           1 | NorthWest       | Julie O. Greenwood   | 1965-01-08
           2 | NorthWest       | Amy X. McNulty       | 1965-01-25
           3 | NorthWest       | Kevin S. Carcetti    | 1965-02-09
           4 | NorthWest       | Sam K. Carcetti      | 1965-03-16
           5 | NorthWest       | Alexandra X. Winkler | 1965-04-05
           1 | MidWest         | Michael Y. Meyer     | 1965-01-01
           2 | MidWest         | Joanna W. Bauer      | 1965-01-06
           3 | MidWest         | Amy E. Harris        | 1965-01-08
           4 | MidWest         | Julie W. McCabe      | 1965-01-09
           5 | MidWest         | William . Peterson   | 1965-01-09
           1 | South           | Dean . Martin        | 1965-01-01
           2 | South           | Ruth U. Williams     | 1965-01-02
           3 | South           | Steve Y. Farmer      | 1965-01-03
           4 | South           | Mark V. King         | 1965-01-08
           5 | South           | Lucas Y. Young       | 1965-01-10
(30 rows)

另请参阅

4.3.31 - STDDEV [analytic]

计算当前行相对于 窗口内组的统计样本标准偏差。 STDDEV_SAMP 返回值与为 VAR_SAMP 函数定义的方差的平方根相同：

STDDEV( expression ) = SQRT(VAR_SAMP( expression ))

当 VAR_SAMP 返回 NULL 时，此函数将返回 NULL。

行为类型

不可变

语法

STDDEV ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。
OVER()
请参阅分析函数

示例

以下示例返回雇员维度表中副经理的薪资标准差：

=> SELECT employee_last_name, annual_salary,
       STDDEV(annual_salary) OVER (ORDER BY hire_date) as "stddev"
   FROM employee_dimension
   WHERE job_title =  'Assistant Director';
 employee_last_name | annual_salary |      stddev
--------------------+---------------+------------------
 Bauer              |         85003 |              NaN
 Reyes              |         91051 | 4276.58181261624
 Overstreet         |         53296 | 20278.6923394976
 Gauthier           |         97216 | 19543.7184537642
 Jones              |         82320 | 16928.0764028285
 Fortin             |         56166 | 18400.2738421652
 Carcetti           |         71135 | 16968.9453554483
 Weaver             |         74419 | 15729.0709901852
 Stein              |         85689 | 15040.5909495309
 McNulty            |         69423 | 14401.1524291943
 Webber             |         99091 | 15256.3160166536
 Meyer              |         74774 | 14588.6126417355
 Garnett            |         82169 | 14008.7223268494
 Roy                |         76974 | 13466.1270356647
 Dobisz             |         83486 | 13040.4887828347
 Martin             |         99702 | 13637.6804131055
 Martin             |         73589 | 13299.2838158566
 ...

另请参阅

4.3.32 - STDDEV_POP [analytic]

计算统计总体标准差，并返回 窗口内总体方差的平方根。STDDEV_POP() 返回值与 VAR_POP() 函数的平方根相同：

STDDEV_POP( expression ) = SQRT(VAR_POP( expression ))

VAR_POP 返回 Null 时，STDDEV_POP 返回 Null。

行为类型

不可变

语法

STDDEV_POP ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。
OVER()
请参阅分析函数。

示例

以下示例返回雇员维度表中副经理的薪资总体标准差：

=> SELECT employee_last_name, annual_salary,
       STDDEV_POP(annual_salary) OVER (ORDER BY hire_date) as "stddev_pop"
   FROM employee_dimension WHERE job_title =  'Assistant Director';
 employee_last_name | annual_salary |    stddev_pop
--------------------+---------------+------------------
 Goldberg           |         61859 |                0
 Miller             |         79582 |           8861.5
 Goldberg           |         74236 | 7422.74712548456
 Campbell           |         66426 | 6850.22125098891
 Moore              |         66630 | 6322.08223926257
 Nguyen             |         53530 | 8356.55480080699
 Harris             |         74115 | 8122.72288970008
 Lang               |         59981 | 8053.54776538731
 Farmer             |         60597 | 7858.70140687825
 Nguyen             |         78941 | 8360.63150784682

另请参阅

4.3.33 - STDDEV_SAMP [analytic]

计算当前行相对于 窗口内组的统计样本标准偏差。STDDEV_SAM的返回值与为 VAR_SAMP 函数定义的方差的平方根相同：

STDDEV( expression ) = SQRT(VAR_SAMP( expression ))

当 VAR_SAMP 返回 NULL 时，STDDEV_SAMP 将返回 NULL。

行为类型

不可变

语法

STDDEV_SAMP ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回与实参数字数据类型相同的数据类型。
OVER()
请参阅分析函数

示例

以下示例返回 employee 维度表中副经理薪资的样本标准差：

=> SELECT employee_last_name, annual_salary,
      STDDEV(annual_salary) OVER (ORDER BY hire_date) as "stddev_samp"
      FROM employee_dimension WHERE job_title =  'Assistant Director';
 employee_last_name | annual_salary |   stddev_samp
--------------------+---------------+------------------
 Bauer              |         85003 |              NaN
 Reyes              |         91051 | 4276.58181261624
 Overstreet         |         53296 | 20278.6923394976
 Gauthier           |         97216 | 19543.7184537642
 Jones              |         82320 | 16928.0764028285
 Fortin             |         56166 | 18400.2738421652
 Carcetti           |         71135 | 16968.9453554483
 Weaver             |         74419 | 15729.0709901852
 Stein              |         85689 | 15040.5909495309
 McNulty            |         69423 | 14401.1524291943
 Webber             |         99091 | 15256.3160166536
 Meyer              |         74774 | 14588.6126417355
 Garnett            |         82169 | 14008.7223268494
 Roy                |         76974 | 13466.1270356647
 Dobisz             |         83486 | 13040.4887828347
 ...

另请参阅

4.3.34 - SUM [analytic]

计算 窗口内一组行的表达式总和。它将返回浮点表达式的 DOUBLE PRECISION 值。否则，返回值与表达式数据类型相同。

行为类型

不可变

语法

SUM ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。
OVER()
请参阅分析函数

溢出处理

如果在使用 SUM 时遇到数据溢出问题，请使用 SUM_FLOAT 将数据转换为浮点。

默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

示例

以下查询返回店面 1 月份所有收益的累计和：

=> SELECT calendar_month_name AS month, transaction_type, sales_quantity,
     SUM(sales_quantity)
     OVER (PARTITION BY calendar_month_name ORDER BY date_dimension.date_key) AS SUM
     FROM store.store_sales_fact JOIN date_dimension
     USING(date_key) WHERE calendar_month_name IN ('January')
     AND transaction_type= 'return';
  month  | transaction_type | sales_quantity | SUM
---------+------------------+----------------+------
 January | return           |              7 |  651
 January | return           |              3 |  651
 January | return           |              7 |  651
 January | return           |              7 |  651
 January | return           |              7 |  651
 January | return           |              3 |  651
 January | return           |              7 |  651
 January | return           |              5 |  651
 January | return           |              1 |  651
 January | return           |              6 |  651
 January | return           |              6 |  651
 January | return           |              3 |  651
 January | return           |              9 |  651
 January | return           |              7 |  651
 January | return           |              6 |  651
 January | return           |              8 |  651
 January | return           |              7 |  651
 January | return           |              2 |  651
 January | return           |              4 |  651
 January | return           |              5 |  651
 January | return           |              7 |  651
 January | return           |              8 |  651
 January | return           |              4 |  651
 January | return           |             10 |  651
 January | return           |              6 |  651
 ...

另请参阅

4.3.35 - VAR_POP [analytic]

返回 窗口内组中非 null 数字集（忽略 null 值）的统计总体方差。结果的计算方法为 expression 与 expression 均值之差的平方和除以剩余行数：

(SUM( expression * expression ) - SUM( expression  ) * SUM(  expression ) /   COUNT( expression )) / COUNT( expression )

行为类型

不可变

语法

VAR_POP ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同
OVER()
请参阅分析函数

示例

下述示例计算 2007 年 1 月商店销售事实表的累计总体方差：

=> SELECT date_ordered,
      VAR_POP(SUM(total_order_cost))
      OVER (ORDER BY date_ordered) "var_pop"
   FROM store.store_orders_fact s
   WHERE date_ordered BETWEEN '2007-01-01' AND '2007-01-31'
   GROUP BY s.date_ordered;
 date_ordered |     var_pop
--------------+------------------
 2007-01-01   |                0
 2007-01-02   |         89870400
 2007-01-03   |       3470302472
 2007-01-04   |  4466755450.6875
 2007-01-05   | 3816904780.80078
 2007-01-06   |   25438212385.25
 2007-01-07   | 22168747513.1016
 2007-01-08   | 23445191012.7344
 2007-01-09   | 39292879603.1113
 2007-01-10   | 48080574326.9609
(10 rows)

另请参阅

4.3.36 - VAR_SAMP [analytic]

为 窗口内组中的每行返回非 NULL 数字集（将忽略集中的 NULL 值）的样本方差。结果的计算方法如下所示：

(SUM( expression * expression ) - SUM( expression ) * SUM( expression ) / COUNT( expression ) )
/ (COUNT( expression ) - 1 )

此函数与 VARIANCE 在一个方面有所不同：对于某个元素的输入集，VARIANCE 返回 0，而 VAR_SAMP 返回 NULL。

行为类型

不可变

语法

VAR_SAMP ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同
OVER()
请参阅分析函数

Null 处理

  • VAR_SAMP 丢弃一组数字中的 NULL 值，然后返回剩余数据的样本方差。

  • 如果将此函数应用于空集，则会返回 NULL。

示例

下述示例计算 2007 年 12 月商店销售订单事实表的样本方差：

=> SELECT date_ordered,
      VAR_SAMP(SUM(total_order_cost))
      OVER (ORDER BY date_ordered) "var_samp"
   FROM store.store_orders_fact s
   WHERE date_ordered BETWEEN '2007-12-01' AND '2007-12-31'
   GROUP BY s.date_ordered;
 date_ordered |     var_samp
--------------+------------------
 2007-12-01   |              NaN
 2007-12-02   |      90642601088
 2007-12-03   | 48030548449.3359
 2007-12-04   | 32740062504.2461
 2007-12-05   | 32100319112.6992
 2007-12-06   |  26274166814.668
 2007-12-07   | 23017490251.9062
 2007-12-08   | 21099374085.1406
 2007-12-09   | 27462205977.9453
 2007-12-10   | 26288687564.1758
(10 rows)

另请参阅

4.3.37 - VARIANCE [analytic]

为 窗口内组中的每行返回非 NULL 数字集（将忽略集中的 NULL 值）的样本方差。结果的计算方法如下所示：

( SUM( expression * expression ) - SUM( expression ) * SUM( expression ) / COUNT( expression )) / (COUNT( expression ) - 1 )

VARIANCE 返回 expression 的方差，按以下方式计算：

  • 如果 expression 中行数等于 1，则为 0

  • VAR_SAMP 如果 expression 中行数大于 1

行为类型

不可变

语法

VAR_SAMP ( expression ) OVER (
    [ window-partition-clause ]
    [ window-order-clause ]
    [ window-frame-clause ] )

参数

表达式
任何 NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。
OVER()
请参阅分析函数

示例

下述示例计算 2007 年 12 月商店销售订单事实表的累计方差：

=> SELECT date_ordered,
      VARIANCE(SUM(total_order_cost))
      OVER (ORDER BY date_ordered) "variance"
   FROM store.store_orders_fact s
   WHERE date_ordered BETWEEN '2007-12-01' AND '2007-12-31'
   GROUP BY s.date_ordered;
 date_ordered |     variance
--------------+------------------
 2007-12-01   |              NaN
 2007-12-02   |       2259129762
 2007-12-03   | 1809012182.33301
 2007-12-04   |   35138165568.25
 2007-12-05   | 26644110029.3003
 2007-12-06   |      25943125234
 2007-12-07   | 23178202223.9048
 2007-12-08   | 21940268901.1431
 2007-12-09   | 21487676799.6108
 2007-12-10   | 21521358853.4331
(10 rows)

另请参阅

4.4 - 客户端连接函数

此部分包含 Vertica 专用的客户端连接管理函数。

4.4.1 - CLOSE_ALL_RESULTSETS

关闭多个活动结果集 (MARS) 中的所有结果集会话，并为其他结果集释放 MARS 存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT CLOSE_ALL_RESULTSETS ('session_id')

参数

session_id
指定多个活动结果集会话的字符串。

特权

无；但是，在不具备超级用户权限的情况下，您只能关闭您自己会话的结果。

示例

此示例显示了如何查看 MARS 结果集，然后关闭该结果集，再确认该结果集已被关闭。

查询 MARS 存储表。一个会话 ID 处于打开状态，并在输出中显示三个结果集。

=> SELECT * FROM SESSION_MARS_STORE;

    node_name     |            session_id             | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
 v_vmart_node0001 | server1.company.-83046:1y28gu9    | dbadmin   |            7 |    777460 |              776460 |   89692848
 v_vmart_node0001 | server1.company.-83046:1y28gu9    | dbadmin   |            8 |    324349 |              323349 |   81862010
 v_vmart_node0001 | server1.company.-83046:1y28gu9    | dbadmin   |            9 |    277947 |              276947 |   32978280
(1 row)

关闭会话 server1.company.-83046:1y28gu9 的所有结果集：

=> SELECT CLOSE_ALL_RESULTSETS('server1.company.-83046:1y28gu9');

             close_all_resultsets
-------------------------------------------------------------
 Closing all result sets from server1.company.-83046:1y28gu9
(1 row)

再次查询 MARS 存储表，以了解当前状态。您可以看到，该会话和结果集已被关闭：

=> SELECT * FROM SESSION_MARS_STORE;

    node_name     |            session_id             | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
(0 rows)

4.4.2 - CLOSE_RESULTSET

关闭多个活动结果集 (MARS) 中的某一特定结果集，并释放其他结果集的 MARS 存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT CLOSE_RESULTSET ('session_id', ResultSetID)

参数

session_id
指定包含要关闭的 ResultSetID 的多个活动结果集会话的字符串。
ResultSetID
指定要关闭哪些结果集的整数。

特权

无；但是，在不具备超级用户权限的情况下，您只能关闭您自己会话的结果。

示例

此示例显示了一个处于打开状态的 MARS 存储表。一个 session_id 目前处于打开状态，并在输出中显示一个结果集。

=> SELECT * FROM SESSION_MARS_STORE;

    node_name     |            session_id             | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
 v_vmart_node0001 | server1.company.-83046:1y28gu9    | dbadmin   |            1 |    318718 |              312718 |   80441904
(1 row)

关闭用户会话 server1.company.-83046:1y28gu9 和结果集 1：

=> SELECT CLOSE_RESULTSET('server1.company.-83046:1y28gu9', 1);

            close_resultset
-------------------------------------------------------------
 Closing result set 1 from server1.company.-83046:1y28gu9
(1 row)

再次查询 MARS 存储表，以了解当前状态。您可以看到，结果集 1 现已关闭：

SELECT * FROM SESSION_MARS_STORE;

    node_name     |            session_id             | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
(0 rows)

4.4.3 - DESCRIBE_LOAD_BALANCE_DECISION

评估是否有任何负载均衡路由规则适用于给定的 IP 地址和 描述如何处理客户端连接。当您评估已创建的连接负载均衡策略，以确保它们按您期望的方式工作时，此函数很有用。

您向此函数传递一个客户端连接的 IP 地址，它使用负载均衡路由规则来确定如何处理该连接。此函数使用的逻辑与 Vertica 负载均衡客户端连接时使用的逻辑相同，包括确定哪些节点可用于处理客户端连接。

此函数假定客户端连接已选择负载均衡。如果实际客户端未选择负载均衡，则不会重定向连接。 有关在客户端启用负载均衡的信息，请参阅 ADO.NET 中的负载均衡、JDBC 中的负载均衡和负载均衡。对于 vsql，使用 -C 命令行选项来启用负载均衡。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESCRIBE_LOAD_BALANCE_DECISION('ip_address')

参数

'ip_address'
要根据负载均衡规则测试的客户端连接的 IP 地址。它可以是 IPv4 或 IPv6 地址。

返回值

逐步描述如何评估负载均衡规则，包括最终决定选择数据库中的哪个节点来为连接提供服务。

特权

无。

示例

以下示例演示了使用三个不同的 IP 地址调用 DESCRIBE_LOAD_BALANCE_DECISION，其中两个由不同的路由规则处理，一个不由任何规则处理。

=> SELECT describe_load_balance_decision('192.168.1.25');
                        describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248] port [5433]

(1 row)

=> SELECT describe_load_balance_decision('192.168.2.25');
                        describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [192.168.2.25]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address does not match source ip filter for this rule.
Considered rule [subnet_192] source ip filter [192.0.0.0/8]... input address
matches this rule
Matched to load balance group [group_all] the group has policy [ROUNDROBIN]
number of addresses [3]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
(2) LB Address: [10.20.100.249]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248] port [5433]

(1 row)

=> SELECT describe_load_balance_decision('1.2.3.4');
                         describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [1.2.3.4]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address does not match source ip filter for this rule.
Considered rule [subnet_192] source ip filter [192.0.0.0/8]... input address
does not match source ip filter for this rule.
Routing table decision: No matching routing rules: input address does not match
any routing rule source filters. Details: [Tried some rules but no matching]
No rules matched. Falling back to classic load balancing.
Classic load balance decision: Classic load balancing considered, but either
the policy was NONE or no target was available. Details: [NONE or invalid]

(1 row)

以下示例演示了使用相同 IP 地址重复调用 DESCRIBE_LOAD_BALANCE_DECISION。您可以看到负载均衡组的 ROUNDROBIN 负载均衡策略让它在负载均衡组的两个节点之间切换：

=> SELECT describe_load_balance_decision('192.168.1.25');
                       describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248]
port [5433]

(1 row)

=> SELECT describe_load_balance_decision('192.168.1.25');
                        describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [0]
Routing table decision: Success. Load balance redirect to: [10.20.100.247]
port [5433]

(1 row)

=> SELECT describe_load_balance_decision('192.168.1.25');
                         describe_load_balance_decision
--------------------------------------------------------------------------------
 Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248]
port [5433]

(1 row)

另请参阅

4.4.4 - GET_CLIENT_LABEL

返回当前会话的客户端连接标签。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_CLIENT_LABEL()

特权

无

示例

返回当前的客户端连接标记：

=> SELECT GET_CLIENT_LABEL();
   GET_CLIENT_LABEL
-----------------------
 data_load_application
(1 row)

另请参阅

设置客户端连接标记

4.4.5 - RESET_LOAD_BALANCE_POLICY

重置群集中的每个主机所维护的计数器，该计数器用于跟踪当本机连接负载均衡方案设置为 ROUNDROBIN 时将客户端指向的主机。要重置计数器，请在所有群集节点上运行此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESET_LOAD_BALANCE_POLICY()

特权

超级用户

示例

=> SELECT RESET_LOAD_BALANCE_POLICY();


                        RESET_LOAD_BALANCE_POLICY
-------------------------------------------------------------------------
Successfully reset stateful client load balance policies: "roundrobin".
(1 row)

4.4.6 - SET_CLIENT_LABEL

将标签分配到当前会话的客户端连接。您可以使用此标签来区分客户端连接。

标签显示在 v_monitor.sessions 表中。但是，这些标签不会在 数据收集器表中更新，因为更改发生在 Vertica 建立连接之后。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_CLIENT_LABEL('label‑name')

参数

label‑name
分配到客户端连接标签的 VARCHAR 名称。

特权

无

示例

将标签 data_load_application 分配到当前客户端连接：

=> SELECT SET_CLIENT_LABEL('data_load_application');
             SET_CLIENT_LABEL
-------------------------------------------
 client_label set to data_load_application
(1 row)

另请参阅

设置客户端连接标记

4.4.7 - SET_LOAD_BALANCE_POLICY

设置本机连接负载均衡如何选择主机来处理客户端连接。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_LOAD_BALANCE_POLICY('policy')

参数

policy
要使用的负载均衡策略的名称，为以下几项之一：

  • NONE （默认值）：禁用本机连接负载均衡。

  • ROUNDROBIN：从群集中处于启动状态的主机循环列表中选择下一个主机。例如，在包含三节点的群集中，依次迭代节点 1、节点 2 和节点 3，然后返回到节点 1。群集中的每个主机都在循环链表中维护自己的指向下一个主机的指针，而不存在一个群集范围内的状态。

  • RANDOM：从群集中所有处于启动的主机中随机选择一个主机。

特权

超级用户

示例

以下示例演示了如何通过将负载均衡方案设置为 ROUNDROBIN 来在服务器上启用本机连接负载均衡：

=> SELECT SET_LOAD_BALANCE_POLICY('ROUNDROBIN');
                  SET_LOAD_BALANCE_POLICY
--------------------------------------------------------------------------------
Successfully changed the client initiator load balancing policy to: roundrobin
(1 row)

另请参阅

关于本机连接负载均衡

4.5 - 特定于数据类型的函数

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

4.5.1 - 集合函数

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

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

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

注意

  • 数组是从 0 开始索引的。第一个元素在 0 中的序号位置，第二个是 1，依此类推。索引对集合没有意义。

  • 除非另有说明，否则函数仅适用于一维 (1D) 集合。要使用多维数组，您必须首先取消对一维数组类型的引用。集合只能是一维的。

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

另请参阅

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

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

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

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

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

另请参阅

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

4.5.1.8 - ARRAY_CONTAINS

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

4.5.1.9 - ARRAY_DIMS

返回输入数组的维度。

行为类型

不可变

语法

ARRAY_DIMS(array)

参数

array
目标数组

示例

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

4.5.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。

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

另请参阅

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

4.5.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 } ] }

参数

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)

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

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

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

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

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

另请参阅

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

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

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

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

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

另请参阅

4.5.2.5 - CURRENT_DATE

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

行为类型

稳定

语法

CURRENT_DATE()

示例

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

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

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

4.5.2.8 - DATE_PART

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

DATE_PART ( 'field', date )

参数

field
一个常数值，指定要从 date 中提取的子字段（请参阅下文的字段值）。
date
要处理的日期，是求值结果具有以下一种数据类型的表达式：

字段值

注意

按照 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

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

另请参阅

4.5.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
日期所处的年周序号。

按照 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)
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)

4.5.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 返回负值。

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

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

例如，如果将开始日期设置为 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

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

4.5.2.13 - DAYOFMONTH

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

行为类型

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

  • 如果目标日期为 TIMESTAMPTZ，则是 稳定

语法

DAYOFMONTH ( date )

参数

date

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

示例

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

4.5.2.14 - DAYOFWEEK

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

行为类型

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

  • 如果目标日期为 TIMESTAMPTZ，则是 稳定

语法

DAYOFWEEK ( date )

参数

date

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

示例

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

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

另请参阅

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

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

4.5.2.18 - EXTRACT

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

EXTRACT ( field FROM date )

参数

field
一个常数值，指定要从 date 中提取的子字段（请参阅下文的字段值）。
date
要处理的日期，是求值结果具有以下一种数据类型的表达式：

字段值

示例

从当前 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)

4.5.2.19 - GETDATE

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

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

行为类型

稳定

语法

GETDATE()

示例

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

另请参阅

日期/时间表达式

4.5.2.20 - GETUTCDATE

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

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

行为类型

稳定

语法

GETUTCDATE()

示例

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

另请参阅

4.5.2.21 - HOUR

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

HOUR( date )

参数

date

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

示例

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

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

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

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

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

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

4.5.2.27 - MICROSECOND

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

MICROSECOND ( date )

参数

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

示例

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

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

4.5.2.29 - MINUTE

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

MINUTE ( date )

参数

date

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

示例

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

4.5.2.30 - MONTH

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

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

语法

MONTH ( date )

参数

date

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

示例

在下例中，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)

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

4.5.2.32 - NEW_TIME

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

行为类型

不可变

语法

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

参数

timestamp
要转换的时间戳符合以下格式之一：
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)

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

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

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

4.5.2.36 - QUARTER

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

语法

QUARTER ( date )

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

参数

date

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

示例

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

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

示例

五入到最近的小时：

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

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

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

另请参阅

4.5.2.40 - SYSDATE

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

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

行为类型

稳定

语法

SYSDATE()

示例

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

另请参阅

日期/时间表达式

4.5.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_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);

在下一个示例中，会对每个输入记录求一次 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;

另请参阅

4.5.2.42 - TIMEOFDAY

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

行为类型

易变

语法

TIMEOFDAY()

示例

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

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

4.5.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 的求值结果为以下数据类型之一：

如果 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

4.5.2.45 - TIMESTAMP_ROUND

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

行为类型

  • 如果目标日期为 TIMESTAMP，则是 不可变

  • 如果目标日期为 TIMESTAMPTZ，则是 稳定

语法

TIMESTAMP_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

示例

五入到最近的小时：

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

4.5.2.46 - TIMESTAMP_TRUNC

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

行为类型

  • 如果目标日期为 TIMESTAMP，则是 不可变

  • 如果目标日期为 TIMESTAMPTZ，则是 稳定

语法

TIMESTAMP_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

示例

截断到当前小时：

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

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

另请参阅

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

示例

截断到当前小时：

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

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

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

4.5.2.51 - YEAR

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

语法

YEAR( date )

行为类型

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

  • 如果指定的日期为 TIMESTAMPTZ，则是 稳定

参数

date

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

示例

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

另请参阅

YEAR_ISO

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

4.5.3 - IP 地址函数

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

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

另请参阅

4.5.3.2 - INET_NTOA

将 INTEGER 值转换为 IPv4 网络地址的 VARCHAR 点分表示。如果整数值为 NULL、负数或大于 232 (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)

另请参阅

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

另请参阅

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

另请参阅

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

另请参阅

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

另请参阅

4.5.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.5.4 - 序列函数

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

4.5.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.5.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

4.5.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）进行操作的其他函数，请参阅 正则表达式函数。

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

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

另请参阅

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

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

4.5.5.5 - BTRIM

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

行为类型

不可变

语法

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

参数

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

示例

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

另请参阅

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

另请参阅

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

4.5.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ß

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

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

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

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

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

  3. knittin → knitting （附加 g）

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

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

4.5.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"

另请参阅

4.5.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"

另请参阅

4.5.5.16 - INITCAP

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

行为类型

不可变

语法

INITCAP ( expression )

参数

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

注意

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

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

示例

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

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

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

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

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

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

另请参阅

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

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

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

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

4.5.5.25 - LENGTH

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

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

  • CHAR：去掉填充值。

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

行为类型

不可变

语法

LENGTH ( expression )

参数

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

示例

另请参阅

BIT_LENGTH

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

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

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

4.5.5.29 - LTRIM

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

行为类型

不可变

语法

LTRIM ( expression [ , characters ] )

参数

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

示例

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

另请参阅

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

4.5.5.31 - MD5

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

行为类型

不可变

语法

MD5 ( string )

参数

string
是实参字符串。

示例

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

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

另请参阅

4.5.5.32 - OCTET_LENGTH

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

行为类型

不可变

语法

OCTET_LENGTH ( expression )

参数

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

注意

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

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

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

示例

另请参阅

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

示例

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

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

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

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

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

另请参阅

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

另请参阅

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

另请参阅

字符字符串字面量

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

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

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

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

4.5.5.44 - RTRIM

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

行为类型

不可变

语法

RTRIM ( expression [ , characters ] )

参数

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

示例

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

另请参阅

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

另请参阅

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

另请参阅

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

另请参阅

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

另请参阅

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

另请参阅

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

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

4.5.5.52 - SPACE

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

行为类型

不可变

语法

SPACE(n)

参数

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

示例

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

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

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

另请参阅

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

另请参阅

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

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

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

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

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

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

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

另请参阅

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

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

4.5.6 - URI 函数

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

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

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

4.5.7 - UUID 函数

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

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

4.6 - Database Designer 函数

Database Designer 函数通常按以下顺序执行以下操作：

  1. 创建设计。

  2. 设置设计属性。

  3. 填充设计。

  4. 创建设计和部署脚本。

  5. 获取设计数据。

  6. 清理。

有关详细信息，请参阅 以编程方式运行 Database Designer 的工作流程。有关所需权限的信息，请参阅 运行 Database Designer 函数的权限

DESIGNER_CREATE_DESIGN 指示 Database Designer 创建设计。

设置设计属性

以下函数可让您指定设计属性：

填充设计

以下函数可用来向 Database Designer 设计中添加表和查询：

创建设计和部署脚本

以下函数将填充 Database Designer 工作区，并创建设计和部署脚本。您还可以分析统计信息，自动部署设计，以及在部署之后删除工作区：

重置设计

DESIGNER_RESET_DESIGN 会丢弃上一次 Database Designer 构建或部署的指定设计的所有运行特定信息，但会保留其配置。

获取设计数据

下列函数将显示有关 Database Designer 所创建的投影和脚本的信息：

清理

以下函数将取消任何正在运行的 Database Designer 操作或者删除 Database Designer 设计及其所有内容：

4.6.1 - DESIGNER_ADD_DESIGN_QUERIES

读取并评估某个输入文件中的查询，并将其接受的查询添加到指定设计中。所有接受的查询均分配了权重 1。

需要满足以下要求：

  • 所有查询的表都必须预先添加到包含 DESIGNER_ADD_DESIGN_TABLES 的设计中。

  • 如果设计类型为增量类型，Database Designer 将仅读取输入文件中的前 100 个查询，并忽略该数量以外的所有查询。

所有接受的查询都必须添加到系统表 DESIGN_QUERIES 中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_ADD_DESIGN_QUERIES ( 'design‑name', 'queries‑file' [, return‑results] )

参数

design‑name
目标设计的名称。
queries‑file
包含要评估的查询的文件的绝对路径和名称，位于连接会话的节点的本地文件系统上，或 Vertica 支持的其他文件系统或对象存储上。
return‑results
布尔值，选择性地指定是否将添加操作的结果返回到标准输出。如果设置为 true，Database Designer 将返回以下结果：

  • 已接受的查询数

  • 引用非设计表的查询数

  • 不受支持的查询数

  • 非法查询数

特权

非超级用户：设计创作者 具有执行 input‑file 中的查询所需的所有权限。

在以下情况下 Database Designer 会返回错误：

  • 查询包含非法语法。

  • 查询参考：

    • 仅限外部或系统表

    • 本地临时表或其他非设计表

  • DELETE 或 UPDATE 包含一个或多个子查询。

  • INSERT 查询不包含 SELECT 子句的。

  • Database Designer 无法优化查询。

示例

以下示例将来自 vmart_queries.sql 的查询添加到 VMART_DESIGN 设计中。该文件包含九个查询。该语句包含第三个实参 true，因此 Database Designer 将返回添加操作的结果：

=> SELECT DESIGNER_ADD_DESIGN_QUERIES ('VMART_DESIGN', '/tmp/examples/vmart_queries.sql', 'true');
...
 DESIGNER_ADD_DESIGN_QUERIES
----------------------------------------------------
 Number of accepted queries                      =9
 Number of queries referencing non-design tables =0
 Number of unsupported queries                   =0
 Number of illegal queries                       =0
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.2 - DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS

执行指定的查询并计算以下列中的结果：

  • QUERY_TEXT （必需）：潜在设计查询的文本。

  • QUERY_WEIGHT （可选）：分配给每个查询的权重，表示其相对于其他查询的重要性，为大于 0 且小于等于 1 的实数。Database Designer 在创建设计时使用此设置来确定查询的优先级。如果 DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS 返回任何忽略此值的结果，Database Designer 会将其权重设置为 1。

评估 QUERY_TEXT 中的查询之后，DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS 会将所有接受的查询添加到设计中。可以在设计中添加无数查询。

将查询添加到设计中之前，必须使用 DESIGNER_ADD_DESIGN_TABLES 添加查询表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS ( 'design‑name', 'query' )

参数

design‑name
目标设计的名称。
query
查询结果包含 QUERY_TEXT 和 QUERY_WEIGHT 列（可选）的有效 SQL 查询。

特权

非超级用户：设计创作者 具有执行指定查询以及此函数返回的所有查询所需的所有权限

在以下情况下 Database Designer 会返回错误：

  • 查询包含非法语法。

  • 查询参考：

    • 仅限外部或系统表

    • 本地临时表或其他非设计表

  • DELETE 或 UPDATE 包含一个或多个子查询。

  • INSERT 查询不包含 SELECT 子句的。

  • Database Designer 无法优化查询。

示例

以下示例将查询系统表 QUERY_REQUESTS 以获取所有运行时间较长（大于 100 万微秒）的查询，并将其添加到 VMART_DESIGN 设计中。该查询不返回有关查询权重的信息，因此为所有查询分配了权重 1：

=> SELECT DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS ('VMART_DESIGN',
   'SELECT request as query_text FROM query_requests where request_duration_ms > 1000000 AND request_type =
   ''QUERY'';');

另请参阅

通过编程方式运行 Database Designer

4.6.3 - DESIGNER_ADD_DESIGN_QUERY

读取和解析指定的查询，如果已接受，将其添加到设计。将查询添加到设计中之前，必须使用 DESIGNER_ADD_DESIGN_TABLES 添加查询表。

所有接受的查询均添加到系统表 DESIGN_QUERIES 中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_ADD_DESIGN_QUERY ( 'design‑name', 'design‑query' [, query‑weight] )

参数

design‑name
目标设计的名称。
design‑query
可执行的 SQL 查询。
query‑weight
（可选）为每个查询分配一个权重，表明其相对于其他查询的重要性，为大于 0 且小于等于 1 的实数。Database Designer 使用此设置来确定设计中查询的优先级。

如果忽略此参数，Database Designer 将分配权重 1。

特权

非超级用户：设计创作者 具有执行指定查询所需的所有权限

在以下情况下 Database Designer 会返回错误：

  • 查询包含非法语法。

  • 查询参考：

    • 仅限外部或系统表

    • 本地临时表或其他非设计表

  • DELETE 或 UPDATE 包含一个或多个子查询。

  • INSERT 查询不包含 SELECT 子句的。

  • Database Designer 无法优化查询。

示例

以下示例将指定的查询添加到 VMART_DESIGN 设计中，并为该查询分配 0.5 的权重：

=> SELECT DESIGNER_ADD_DESIGN_QUERY (
   'VMART_DESIGN',
   'SELECT customer_name, customer_type FROM customer_dimension ORDER BY customer_name ASC;', 0.5
   );

另请参阅

通过编程方式运行 Database Designer

4.6.4 - DESIGNER_ADD_DESIGN_TABLES

将指定表添加到设计中。将设计查询添加到设计中之前，必须先运行 DESIGNER_ADD_DESIGN_TABLES。如果未向设计中添加表，Vertica 将不接受设计查询。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_ADD_DESIGN_TABLES ( 'design‑name', '[ table‑spec[,...] ]' [, 'analyze‑statistics'] )

参数

design‑name
Database Designer 设计的名称。
table‑spec[,...]
一个或多个逗号分隔的实参，用于指定要添加到设计中的表，其中每个 table‑spec 实参可以按如下方式指定表：

  • [schema.]table
    将 table 添加到设计中。

  • schema.*
    添加 schema 中的所有表。

如果设置为空字符串，Vertica 会添加用户有权访问的数据库中的所有表。

analyze‑statistics
布尔值，选择性地指定在将指定的表添加到设计后是否运行 ANALYZE_STATISTICS，默认设置为 false。

准确的统计信息可帮助 Database Designer 优化压缩和查询性能。更新统计信息需要花费时间和资源。

特权

非超级用户：设计创作者 具有设计表架构的 USAGE 权限，且是设计表的所有者

示例

以下示例将架构 online_sales 和 store 中的所有表添加到设计 VMART_DESIGN 中，并分析这些表的统计信息：

=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN', 'online_sales.*, store.*','true');
 DESIGNER_ADD_DESIGN_TABLES
----------------------------
                          7
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.5 - DESIGNER_CANCEL_POPULATE_DESIGN

如果指定设计当前正在运行，取消对指定设计的填充和部署操作。取消部署时，Database Designer 将取消投影刷新操作。不会回退已部署或已刷新的投影。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_CANCEL_POPULATE_DESIGN ( 'design‑name' )

参数

design‑name
要取消的设计操作的名称。

特权

非超级用户：设计创作者

示例

以下示例取消了 VMART_DESIGN 当前正在运行的设计，然后删除该设计：

=> SELECT DESIGNER_CANCEL_POPULATE_DESIGN ('VMART_DESIGN');
=> SELECT DESIGNER_DROP_DESIGN ('VMART_DESIGN', 'true');

另请参阅

通过编程方式运行 Database Designer

4.6.6 - DESIGNER_CREATE_DESIGN

使用指定名称创建设计。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_CREATE_DESIGN ( 'design‑name' )

参数

design‑name
要创建的设计名称，只能包含字母数字和下划线 (_) 字符。

两个用户不能同时拥有名称相同的设计。

特权

  • 超级用户

  • 对 design-name 的存储位置具有 WRITE 权限的 DBDUSER。

Database Designer 系统视图

如果以前的设计中不存在以下任何 V_MONITOR 表，则 DESIGNER_CREATE_DESIGN 会创建它们：

示例

以下示例创建了设计 VMART_DESIGN：

=> SELECT DESIGNER_CREATE_DESIGN('VMART_DESIGN');
 DESIGNER_CREATE_DESIGN
------------------------
                      0
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.7 - DESIGNER_DESIGN_PROJECTION_ENCODINGS

在指定投影中分析编码，创建脚本以实施编码建议并选择性地部署建议。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_DESIGN_PROJECTION_ENCODINGS ( '[ proj‑spec[,... ] ]', '[destination]' [, 'deploy'] [, 'reanalyze-encodings'] )

参数

proj‑spec[,...]
要添加到设计中的一个或多个逗号分隔投影。可以通过以下方式之一指定每个投影：

  • [[schema.]table.]projection
    指定分析 projection。

  • schema.*
    指定分析命名架构中的所有投影。

  • [schema.]table
    指定分析命名表的所有投影。

如果设置为空字符串，Vertica 会分析数据库中用户有权访问的所有投影。

例如，以下语句指定分析架构 private 中的所有投影，并将结果发送到文件 encodings.sql：

=> SELECT DESIGNER_DESIGN_PROJECTION_ENCODINGS ('mydb.private.*','encodings.sql');
destination
指定发送输出的位置，为以下之一：

  • 空字符串 ('') 将脚本写入标准输出。

  • SQL 输出文件的路径名。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

deploy
BOOLEAN 值，指定是否部署编码更改。

默认值：false

reanalyze‑encodings
BOOLEAN 值，指定 DESIGNER_DESIGN_PROJECTION_ENCODINGS 是否分析所有列都已编码的投影中的编码：

  • false：如果所有列都已编码，则不分析任何列并且不生成任何建议。

  • true：忽略现有编码并生成建议。

默认值：false

特权

具有以下权限的超级用户或 DBDUSER：

  • 要分析的所有投影的 OWNER

  • 指定投影架构上的 USAGE 权限

示例

以下示例要求 Database Designer 分析表 online_sales.call_center_dimension 的编码：

  • 第二个参数 destination 设置为空字符串，因此脚本被发送到标准输出（如下截断所示）。

  • 最后两个参数 deploy 和 reanalyze-encodings 被忽略，因此 Database Designer 不会执行脚本或重新分析现有编码：

=> SELECT DESIGNER_DESIGN_PROJECTION_ENCODINGS ('online_sales.call_center_dimension','');

              DESIGNER_DESIGN_PROJECTION_ENCODINGS
----------------------------------------------------------------

CREATE PROJECTION call_center_dimension_DBD_1_seg_EncodingDesign /*+createtype(D)*/
(
 call_center_key ENCODING COMMONDELTA_COMP,
 cc_closed_date,
 cc_open_date,
 cc_name ENCODING ZSTD_HIGH_COMP,
 cc_class ENCODING ZSTD_HIGH_COMP,
 cc_employees,
 cc_hours ENCODING ZSTD_HIGH_COMP,
 cc_manager ENCODING ZSTD_HIGH_COMP,
 cc_address ENCODING ZSTD_HIGH_COMP,
 cc_city ENCODING ZSTD_COMP,
 cc_state ENCODING ZSTD_FAST_COMP,
 cc_region ENCODING ZSTD_HIGH_COMP
)
AS
 SELECT call_center_dimension.call_center_key,
        call_center_dimension.cc_closed_date,
        call_center_dimension.cc_open_date,
        call_center_dimension.cc_name,
        call_center_dimension.cc_class,
        call_center_dimension.cc_employees,
        call_center_dimension.cc_hours,
        call_center_dimension.cc_manager,
        call_center_dimension.cc_address,
        call_center_dimension.cc_city,
        call_center_dimension.cc_state,
        call_center_dimension.cc_region
 FROM online_sales.call_center_dimension
 ORDER BY call_center_dimension.call_center_key
SEGMENTED BY hash(call_center_dimension.call_center_key) ALL NODES KSAFE 1;

select refresh('online_sales.call_center_dimension');

select make_ahm_now();

DROP PROJECTION online_sales.call_center_dimension CASCADE;

ALTER PROJECTION online_sales.call_center_dimension_DBD_1_seg_EncodingDesign RENAME TO call_center_dimension;
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.8 - DESIGNER_DROP_ALL_DESIGNS

移除所有与当前用户关联的 Database Designer 相关的架构。在一个或多个 Database Designer 会话完成执行后，使用此函数移除数据库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_DROP_ALL_DESIGNS()

参数

无。

特权

非超级用户：设计创作者

示例

以下示例将移除所有架构以及和当前用户相关的内容。 DESIGNER_DROP_ALL_DESIGNS 返回已删除设计的数量：

=> SELECT DESIGNER_DROP_ALL_DESIGNS();
 DESIGNER_DROP_ALL_DESIGNS
---------------------------
                         2
(1 row)

另请参阅

4.6.9 - DESIGNER_DROP_DESIGN

移除与指定设计及其所有内容相关联的架构。在 Database Designer 设计或部署成功完成后使用 DESIGNER_DROP_DESIGN。您还必须使用它来删除一个设计，然后再以相同的名称创建另一个设计。

要删除您创建的所有设计，请使用 DESIGNER_DROP_ALL_DESIGNS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_DROP_DESIGN ( 'design‑name' [, force‑drop ] )

参数

design‑name
要删除的设计的名称。
force‑drop
覆盖任何会阻止 Vertica 执行此函数的依赖项的 Boolean 值 - 例如，设计正在被使用或当前正在部署。如果忽略此参数，Vertica 会将其设置为 false。

特权

非超级用户：设计创作者

示例

以下示例删除了 Database Designer 设计 VMART_DESIGN 及其所有内容：

=> SELECT DESIGNER_DROP_DESIGN ('VMART_DESIGN');

另请参阅

通过编程方式运行 Database Designer

4.6.10 - DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS

在标准输出中显示定义设计投影的 DDL 语句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS ( 'design‑name' )

参数

design‑name
目标设计的名称。

特权

超级用户或 DBDUSER

示例

以下示例返回了 vmart_design 的设计投射 DDL 语句：

=> SELECT DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS('vmart_design');
CREATE PROJECTION customer_dimension_DBD_1_rep_VMART_DESIGN /*+createtype(D)*/
(
 customer_key ENCODING DELTAVAL,
 customer_type ENCODING AUTO,
 customer_name ENCODING AUTO,
 customer_gender ENCODING REL,
 title ENCODING AUTO,
 household_id ENCODING DELTAVAL,
 customer_address ENCODING AUTO,
 customer_city ENCODING AUTO,
 customer_state ENCODING AUTO,
 customer_region ENCODING AUTO,
 marital_status ENCODING AUTO,
 customer_age ENCODING DELTAVAL,
 number_of_children ENCODING BLOCKDICT_COMP,
 annual_income ENCODING DELTARANGE_COMP,
 occupation ENCODING AUTO,
 largest_bill_amount ENCODING DELTAVAL,
 store_membership_card ENCODING BLOCKDICT_COMP,
 customer_since ENCODING DELTAVAL,
 deal_stage ENCODING AUTO,
 deal_size ENCODING DELTARANGE_COMP,
 last_deal_update ENCODING DELTARANGE_COMP
)
AS
 SELECT customer_key,
        customer_type,
        customer_name,
        customer_gender,
        title,
        household_id,
        customer_address,
        customer_city,
        customer_state,
        customer_region,
        marital_status,
        customer_age,
        number_of_children,
        annual_income,
        occupation,
        largest_bill_amount,
        store_membership_card,
        customer_since,
        deal_stage,
        deal_size,
        last_deal_update
 FROM public.customer_dimension
 ORDER BY customer_gender,
          annual_income
UNSEGMENTED ALL NODES;
CREATE PROJECTION product_dimension_DBD_2_rep_VMART_DESIGN /*+createtype(D)*/
(
...

另请参阅

DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT

4.6.11 - DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT

在标准输出中显示指定设计的部署脚本。如果设计已部署，Vertica 将忽略此函数。

要在设计脚本中仅输出 CREATE PROJECTION 命令，请使用 DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT ( 'design‑name' )

参数

design‑name
目标设计的名称。

特权

非超级用户：设计创作者

示例

以下示例显示了 VMART_DESIGN 的部署脚本：

=> SELECT DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT('VMART_DESIGN');
CREATE PROJECTION customer_dimension_DBD_1_rep_VMART_DESIGN /*+createtype(D)*/
...
CREATE PROJECTION product_dimension_DBD_2_rep_VMART_DESIGN /*+createtype(D)*/
...
select refresh('public.customer_dimension,
                public.product_dimension,
                public.promotion.dimension,
                public.date_dimension');
select make_ahm_now();
DROP PROJECTION public.customer_dimension_super CASCADE;
DROP PROJECTION public.product_dimension_super CASCADE;
...

另请参阅

DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS

4.6.12 - DESIGNER_RESET_DESIGN

丢弃上一次 Database Designer 构建或部署的指定设计的所有运行特定信息，但会保留其配置。您可以根据需要对设计进行更改，例如，在重新运行设计之前更改参数或添加更多表和/或查询。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_RESET_DESIGN ( 'design‑name' )

参数

design‑name
要重置的设计名称。

特权

非超级用户：设计创作者

示例

以下示例重置了 Database Designer 设计 VMART_DESIGN：

=> SELECT DESIGNER_RESET_DESIGN ('VMART_DESIGN');

4.6.13 - DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY

填充设计并创建设计和部署脚本。DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY 还可以分析统计信息，部署设计，以及在部署之后删除工作空间。

此函数输出的文件具有 666 或 rw-rw-rw- 权限，允许节点上的任何 Linux 用户对其进行读取或写入。强烈建议您将文件保存在安全的目录中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法


DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY (
    'design‑name',
    'output‑design‑file',
    'output‑deployment‑file'
    [ , 'analyze‑statistics']
    [ , 'deploy']
    [ , 'drop‑design‑workspace']
    [ , 'continue‑after‑error']
    )

参数

design‑name
要填充和部署的设计名称。
output‑design‑filename
包含创建设计投影的 DDL 语句的文件的绝对路径和名称，位于连接会话的节点的本地文件系统上，或 Vertica 支持的其他文件系统或对象存储上。
output‑deployment‑filename
包含部署脚本的文件的绝对路径和名称，位于连接会话的节点的本地文件系统上，或 Vertica 支持的其他文件系统或对象存储上。
analyze‑statistics
指定在填充设计之前是否收集或刷新表格统计信息。如果设置为 true，Vertica 会调用 ANALYZE_STATISTICS。准确的统计信息可帮助 Database Designer 优化压缩和查询性能。然而，更新统计信息需要时间和资源。

默认值：false

deploy
指定是否使用该函数创建的部署脚本部署 Database Designer 设计。

默认值： true

drop‑design‑workspace
指定在部署设计后是否删除设计工作空间。

默认值： true

continue‑after‑error
指定出现错误后，DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY 是否继续运行。默认情况下，错误会导致该函数终止。

默认值：false

特权

非超级用户：设计创作者 对设计和部署脚本的存储位置具有 WRITE 权限

要求

调用此函数之前，您必须：

  • 创建设计或带表格的逻辑架构。

  • 将表与设计相关联。

  • 加载设计查询。

  • 设置设计属性（K-安全级别、模式和策略）。

示例

以下示例为 VMART_DESIGN 创建投射并部署该设计，同时分析有关设计表的统计信息。

=> SELECT DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY (
   'VMART_DESIGN',
   '/tmp/examples/vmart_design_files/design_projections.sql',
   '/tmp/examples/vmart_design_files/design_deploy.sql',
   'true',
   'true',
   'false',
   'false'
   );

另请参阅

通过编程方式运行 Database Designer

4.6.14 - DESIGNER_SET_DESIGN_KSAFETY

为全面设计设置 K-safety 并将 K-safety 值存储在 DESIGNS 表中。对于增量设计，Database Designer 会忽略此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_SET_DESIGN_KSAFETY ( 'design‑name' [, k‑level ] )

参数

design‑name
要为其设置 K-safety 值的设计名称，VARCHAR 类型。
k‑level
介于 0 和 2 之间的整数，用于指定目标设计的 K-safety 级别。此值必须与数据库群集中的节点数兼容：

  • k‑level = 0：≥ 1 个节点

  • k‑level = 1：≥ 3 个节点

  • k‑level = 2：≥ 5 个节点

如果忽略此参数，Vertica 会根据节点数将此设计的 K-safety 设置为 0 或 1：如果群集包含 ≥ 3 个节点，则为 1，否则为 0。

如果您是 DBADMIN 用户并且 k-level 与系统 K-safety 不同，Vertica 会按如下方式更改系统 K-safety：

  • 如果 k-level 小于系统 K-safety，Vertica 会在部署设计后将系统 K-safety 更改为较低级别。

  • 如果 k-level 大于系统 K-safety 并且对数据库群集有效，Vertica 会为此设计中的表创建所需数量的伙伴实例投影。如果设计适用于所有数据库表，或者数据库中的所有表都具有所需数量的伙伴实例投影，则 Database Designer 将系统 K-safety 更改为 k-level。

    如果设计排除了一些数据库表并且它们的伙伴实例投影数量小于 k-level，Database Designer 将系统 K-safety 保持不变。它会返回警告并指出哪些表需要新的伙伴实例投影以调整系统 K-safety。

如果您是 DBDUSER，Vertica 会忽略此参数。

特权

非超级用户：设计创作者

示例

以下示例将 VMART_DESIGN 设计的 K-safety 设置为 1：

=> SELECT DESIGNER_SET_DESIGN_KSAFETY('VMART_DESIGN', 1);

另请参阅

通过编程方式运行 Database Designer

4.6.15 - DESIGNER_SET_DESIGN_TYPE

指定 Database Designer 是创建全面设计还是增量设计。 DESIGNER_SET_DESIGN_TYPE 将设计模式存储在 DESIGNS 表中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_SET_DESIGN_TYPE ( 'design‑name', 'mode' )

参数

design‑name
目标设计的名称。
mode
Database Designer 在设计数据库时应使用的模式的名称，为以下之一：

  • COMPREHENSIVE：为指定架构中的所有表创建初始或替换设计。您通常为新数据库创建全面设计。

  • INCREMENTAL：使用针对新查询或修改后的查询进行优化的附加投影来修改现有设计。

有关详细信息，请参阅设计类型。

特权

非超级用户：设计创作者

示例

以下示例显示了 VMART_DESIGN 设计的两种设计模式选项：

=> SELECT DESIGNER_SET_DESIGN_TYPE(
    'VMART_DESIGN',
    'COMPREHENSIVE');

DESIGNER_SET_DESIGN_TYPE
--------------------------
                        0
(1 row)
=> SELECT DESIGNER_SET_DESIGN_TYPE(
    'VMART_DESIGN',
    'INCREMENTAL');
 DESIGNER_SET_DESIGN_TYPE
--------------------------
                        0
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.16 - DESIGNER_SET_OPTIMIZATION_OBJECTIVE

仅对全面数据库设计有效，用于指定 Database Designer 使用的优化目标。对于增量设计，Database Designer 会忽略此函数。

DESIGNER_SET_OPTIMIZATION_OBJECTIVE 将优化目标存储在 DESIGNS 表中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_SET_OPTIMIZATION_OBJECTIVE ( 'design‑name', 'policy' )

参数

design‑name
目标设计的名称。
policy
指定设计的优化策略，为以下之一：

  • QUERY：优化查询性能。此操作会导致数据库存储占用空间增大，因为可能会创建更多投影。

  • LOAD：优化加载性能，以便最大限度缩小数据库大小。此操作会导致查询性能下降。

  • BALANCED：平衡查询性能和数据库大小的设计。

特权

非超级用户：设计创作者

示例

以下示例将 VMART_DESIGN 设计的优化目标选项设置为 QUERY：


=> SELECT DESIGNER_SET_OPTIMIZATION_OBJECTIVE(  'VMART_DESIGN', 'QUERY');
 DESIGNER_SET_OPTIMIZATION_OBJECTIVE
------------------------------------
                                  0
(1 row)

另请参阅

通过编程方式运行 Database Designer

4.6.17 - DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS

指定设计是否可以包含未分段的投影。Vertica 在单节点群集上忽略此函数，其中所有投影都必须不分段。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS ( 'design‑name', unsegmented )

参数

design‑name
目标设计的名称。
unsegmented
Boolean 值，指定 Database Designer 是否可以为此设计中的表建议未分段的投影。创建设计时，此设计的系统表 DESIGNS 中的 propose_unsegmented_projections 值设置为 true。如果 DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS 将此值设置为 false，则 Database Designer 仅建议分段的投影。

特权

非超级用户：设计创作者

示例

以下示例指定 Database Designer 只能为设计 VMART_DESIGN 中的表建议分段的投影：

=> SELECT DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS('VMART_DESIGN', false);

另请参阅

通过编程方式运行 Database Designer

4.6.18 - DESIGNER_SINGLE_RUN

评估在指定时间跨度内完成执行的所有查询，并返回可用于部署的设计。此设计包含建议用于优化评估查询的投影。除非您重定向输出，否则 DESIGNER_SINGLE_RUN 会将设计返回到 STDOUT。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_SINGLE_RUN ('interval')
interval
指定元函数调用之前的时间间隔。Database Designer 评估在指定时间间隔内运行完成的所有查询。

特权

超级用户或 DBUSER

示例

-----------------------------------------------------------------------
-- SSBM dataset test
-----------------------------------------------------------------------
-- create ssbm schema
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_schema.sql' > /dev/null 2>&1
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_constraints.sql' > /dev/null 2>&1
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_funcdeps.sql' > /dev/null 2>&1

-- run these queries
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_queries.sql' > /dev/null 2>&1
-- Run single API
select designer_single_run('1 minute');

...
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                designer_single_run
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 CREATE PROJECTION public.part_DBD_1_rep_SingleDesign /*+createtype(D)*/
(
 p_partkey ENCODING AUTO,
 p_name ENCODING AUTO,
 p_mfgr ENCODING AUTO,
 p_category ENCODING AUTO,
 p_brand1 ENCODING AUTO,
 p_color ENCODING AUTO,
 p_type ENCODING AUTO,
 p_size ENCODING AUTO,
 p_container ENCODING AUTO
)
AS
 SELECT p_partkey,
        p_name,
        p_mfgr,
        p_category,
        p_brand1,
        p_color,
        p_type,
        p_size,
        p_container
 FROM public.part
 ORDER BY p_partkey
UNSEGMENTED ALL NODES;

CREATE PROJECTION public.supplier_DBD_2_rep_SingleDesign /*+createtype(D)*/
(
 s_suppkey ENCODING AUTO,
 s_name ENCODING AUTO,
 s_address ENCODING AUTO,
 s_city ENCODING AUTO,
 s_nation ENCODING AUTO,
 s_region ENCODING AUTO,
 s_phone ENCODING AUTO
)
AS
 SELECT s_suppkey,
        s_name,
        s_address,
        s_city,
        s_nation,
        s_region,
        s_phone
 FROM public.supplier
 ORDER BY s_suppkey
UNSEGMENTED ALL NODES;

CREATE PROJECTION public.customer_DBD_3_rep_SingleDesign /*+createtype(D)*/
(
 c_custkey ENCODING AUTO,
 c_name ENCODING AUTO,
 c_address ENCODING AUTO,
 c_city ENCODING AUTO,
 c_nation ENCODING AUTO,
 c_region ENCODING AUTO,
 c_phone ENCODING AUTO,
 c_mktsegment ENCODING AUTO
)
AS
 SELECT c_custkey,
        c_name,
        c_address,
        c_city,
        c_nation,
        c_region,
        c_phone,
        c_mktsegment
 FROM public.customer
 ORDER BY c_custkey
UNSEGMENTED ALL NODES;

CREATE PROJECTION public.dwdate_DBD_4_rep_SingleDesign /*+createtype(D)*/
(
 d_datekey ENCODING AUTO,
 d_date ENCODING AUTO,
 d_dayofweek ENCODING AUTO,
 d_month ENCODING AUTO,
 d_year ENCODING AUTO,
 d_yearmonthnum ENCODING AUTO,
 d_yearmonth ENCODING AUTO,
 d_daynuminweek ENCODING AUTO,
 d_daynuminmonth ENCODING AUTO,
 d_daynuminyear ENCODING AUTO,
 d_monthnuminyear ENCODING AUTO,
 d_weeknuminyear ENCODING AUTO,
 d_sellingseason ENCODING AUTO,
 d_lastdayinweekfl ENCODING AUTO,
 d_lastdayinmonthfl ENCODING AUTO,
 d_holidayfl ENCODING AUTO,
 d_weekdayfl ENCODING AUTO
)
AS
 SELECT d_datekey,
        d_date,
        d_dayofweek,
        d_month,
        d_year,
        d_yearmonthnum,
        d_yearmonth,
        d_daynuminweek,
        d_daynuminmonth,
        d_daynuminyear,
        d_monthnuminyear,
        d_weeknuminyear,
        d_sellingseason,
        d_lastdayinweekfl,
        d_lastdayinmonthfl,
        d_holidayfl,
        d_weekdayfl
 FROM public.dwdate
 ORDER BY d_datekey
UNSEGMENTED ALL NODES;

CREATE PROJECTION public.lineorder_DBD_5_rep_SingleDesign /*+createtype(D)*/
(
 lo_orderkey ENCODING AUTO,
 lo_linenumber ENCODING AUTO,
 lo_custkey ENCODING AUTO,
 lo_partkey ENCODING AUTO,
 lo_suppkey ENCODING AUTO,
 lo_orderdate ENCODING AUTO,
 lo_orderpriority ENCODING AUTO,
 lo_shippriority ENCODING AUTO,
 lo_quantity ENCODING AUTO,
 lo_extendedprice ENCODING AUTO,
 lo_ordertotalprice ENCODING AUTO,
 lo_discount ENCODING AUTO,
 lo_revenue ENCODING AUTO,
 lo_supplycost ENCODING AUTO,
 lo_tax ENCODING AUTO,
 lo_commitdate ENCODING AUTO,
 lo_shipmode ENCODING AUTO
)
AS
 SELECT lo_orderkey,
        lo_linenumber,
        lo_custkey,
        lo_partkey,
        lo_suppkey,
        lo_orderdate,
        lo_orderpriority,
        lo_shippriority,
        lo_quantity,
        lo_extendedprice,
        lo_ordertotalprice,
        lo_discount,
        lo_revenue,
        lo_supplycost,
        lo_tax,
        lo_commitdate,
        lo_shipmode
 FROM public.lineorder
 ORDER BY lo_suppkey
UNSEGMENTED ALL NODES;

(1 row)

4.6.19 - DESIGNER_WAIT_FOR_DESIGN

等待正在填充和部署设计的操作完成。Ctrl+C 会取消此操作并将控制权返回给用户。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DESIGNER_WAIT_FOR_DESIGN ( 'design‑name' )

参数

design‑name
运行设计的名称。

特权

拥有设计架构 USAGE 权限的超级用户或 DBDUSER

示例

以下示例要求等待当前正在运行的 VMART_DESIGN 设计完成：

=> SELECT DESIGNER_WAIT_FOR_DESIGN ('VMART_DESIGN');

另请参阅

4.7 - 定向查询函数

以下元函数可用于将查询计划作为定向查询从一个 Vertica 数据库批量导出，并将这些定向查询导入其他数据库。

4.7.1 - EXPORT_DIRECTED_QUERIES

生成 SQL，用于通过一组输入查询创建定向查询。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_DIRECTED_QUERIES('input-file', '[output-file]')

参数

input‑file
包含一个或多个输入查询的 SQL 文件。有关格式要求的详细信息，请参阅下文的输入格式。
output‑file
指定将生成的用于创建定向查询的 SQL 写入何处。如果 output‑file 已存在，则 EXPORT_DIRECTED_QUERIES 返回错误。如果您提供的是空字符串，则 Vertica 会将 SQL 写入标准输出。有关详细信息，请参阅下文的输出格式。

特权

超级用户

输入格式

您提供给 EXPORT_DIRECTED_QUERIES 的输入文件包含一个或多个输入查询。对于每个输入查询，您可以选择指定两个字段，这两个字段将用于生成的定向查询中：

  • DirQueryName 提供了定向查询的唯一标识符，即一个符合标识符中所述惯例的字符串。

  • DirQueryComment 指定了一个最多 128 个字符并以引号分隔的字符串。

您可以按如下方式设置每个输入查询的格式：

--DirQueryName=query-name
--DirQueryComment='comment'
input-query

输出格式

EXPORT_DIRECTED_QUERIES 会将生成用于创建定向查询的 SQL，并将此 SQL 写入到指定文件或标准输出中。对于这两种情况，输出都遵循以下格式：

/* Query: directed-query-name */
/* Comment: directed-query-comment */
SAVE QUERY input-query;
CREATE DIRECTED QUERY CUSTOM 'directed-query-name'
COMMENT 'directed-query-comment'
OPTVER 'vertica-release-num'
PSDATE 'timestamp'
annotated-query

如果给定的输入查询省略了 DirQueryName 和 DirQueryComment 字段，则 EXPORT_DIRECTED_QUERIES 会自动生成以下输出：

  • /* Query: Autoname:时间戳 .n */，其中 n 为基于零的整数索引，用于确保具有相同时间戳的自动生成名称具有唯一性。

  • /* Comment: Optimizer-generated directed query */

错误处理

如果在执行 EXPORT_DIRECTED_QUERIES 期间发生任何错误或警告，它会返回一条类似于以下内容的消息：

1 queries successfully exported.
1 warning message was generated.
Queries exported to /home/dbadmin/outputQueries.
See error report, /home/dbadmin/outputQueries.err for details.

EXPORT_DIRECTED_QUERIES 会将所有错误或警告都写入到一个在与输出文件相同的路径下所创建的文件中，并使用输出文件的基名。

例如：

---------------------------------------------------------------------------------------------------
WARNING: Name field not supplied. Using auto-generated name: 'Autoname:2016-04-25 15:03:32.115317.0'
Input Query: SELECT employee_dimension.employee_first_name, employee_dimension.employee_last_name, employee_dimension.job_title FROM public.employee_dimension WHERE (employee_dimension.employee_city = 'Boston'::varchar(6)) ORDER BY employee_dimension.job_title;
END WARNING

示例

请参阅导出定向查询。

另请参阅

4.7.2 - IMPORT_DIRECTED_QUERIES

从 EXPORT_DIRECTED_QUERIES 生成的 SQL 文件导入到数据库编录定向查询。如果未指定定向查询，Vertica 将列出 SQL 文件中的所有定向查询。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

IMPORT_DIRECTED_QUERIES( 'export-file'[, 'directed-query-name'[,...] ] )

参数

export‑file
由 EXPORT_DIRECTED_QUERIES 生成的 SQL 文件。运行文件时，Vertica 在当前数据库编录中创建指定的定向查询。
directed‑query‑name
在 export‑file 中定义的定向查询的名称。您可以指定多个以逗号分隔的定向查询名称。

如果省略此参数，Vertica 将列出 export‑file 中所有定向查询的名称。

特权

超级用户

示例

请参阅导入定向查询。

另请参阅

批量导出查询计划

4.8 - 错误处理函数

错误处理函数接受字符串并在执行查询时返回该字符串。

4.8.1 - THROW_ERROR

返回用户定义的错误消息。

在多节点群集中，很少会导致错误消息的顺序不同。

行为类型

不可变

语法

THROW_ERROR ( message )

参数

message
要返回的 VARCHAR 字符串。

示例

遇到 CASE 语句时，返回错误消息：

=> CREATE TABLE pitcher_err (some_text varchar);
CREATE TABLE
=> COPY pitcher_err FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> big foo value
>> bigger foo other value
>> bar another foo value
>> \.
=> SELECT (CASE WHEN true THEN THROW_ERROR('Failure!!!') ELSE some_text END) FROM pitcher_err;
ERROR 7137:  USER GENERATED ERROR: Failure!!!

遇到使用 REGEXP_LIKE 的 CASE 语句时，返回错误消息：


=> SELECT (CASE WHEN REGEXP_LIKE(some_text, 'other') THEN THROW_ERROR('Failure at "' || some_text || '"') END) FROM pitcher_err;
ERROR 4566:  USER GENERATED ERROR: Failure at "bar another foo value"

4.9 - Flex 函数

此部分包含用于处理复杂类型的 Flex 表和 Flex 列的 Helper 函数。您可以将这些函数与 Flex 表和其关联的 flex_table_keys 表和 flex_table_view 视图以及外部表中的 Flex 列配合使用。这些函数不适用于其他表。

有关 Flex 表的详细信息，请参阅 Flex 表。有关复杂类型的 Flex 列的详细信息，请参阅 可变复杂类型。

Flex 函数可用于管理和查询 Flex 表。也可以使用映射函数来查询非 Flex 表中的复杂类型 Flex 列。

4.9.1 - Flex 数据函数

Flex 表数据 Helper 函数提供了直接在 Flex 表中查询数据所需的信息。计算键并利用原始数据创建视图之后，可直接在查询中使用字段名称，而不是使用映射函数提取数据。

Flex 表依赖项

每个 Flex 表具有两个依赖对象，一个键表和一个视图。虽然这两个对象均依赖于其父表，您可以独立删除其中任一对象。删除父表将同时移除这两个依赖项，而无需使用层叠 (CASCADE) 选项。

关联 Flex 表和视图

如果 Helper 函数与父表在内部相链接，则其可自动使用相关的表和视图。当您创建 Flex 表时，也将同时创建上述两项。您可以删除键表或视图，然后重新创建同名的对象。但如果您执行此操作，新的对象不会与父 Flex 表在内部相链接。

在这种情况下，您可以恢复这些对象到父表的内部链接。为此，请在调用 RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW 函数之前删除键表和视图。调用此函数可重新创建键表和视图。

其余 Helper 函数执行本节所述的任务。

4.9.1.1 - BUILD_FLEXTABLE_VIEW

创建或重新创建默认或用户定义键表的视图，忽略任何空键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

BUILD_FLEXTABLE_VIEW ('[[database.]schema.]flex-table'
    [ [,'view-name'] [,'user-keys-table'] ])

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

flex-table
弹性表名称。默认情况下，该函数使用关联的 flex_table_keys 表的当前内容构建或重建输入表的视图。
view-name
自定义视图名称。使用此选项可以用您指定的名称构建 flex-table 的新视图。
user-keys-table
要从中创建视图的键表的名称。如果从 Flex 表（而不是 flex_table_keys 默认表）映射数据创建一个自定义键表，则使用此选项。函数从 user_keys 中（而不是从 flex_table_keys 中）的键构建视图。

示例

下面的示例显示如何用 1、2 或 3 实参调用 BUILD_FLEXTABLE_VIEW。

要创建或重新创建一个默认视图：

  1. 使用输入 Flex 表调用函数：

    => SELECT BUILD_FLEXTABLE_VIEW('darkdata');
                  build_flextable_view
-----------------------------------------------------
 The view public.darkdata_view is ready for querying
(1 row)

    函数从 darkdata_keys 表创建具有默认名称 (darkdata_view) 的视图。

  2. 从新视图或更新视图查询键名：

    => SELECT "user.id" FROM darkdata_view;
  user.id
-----------
 340857907
 727774963
 390498773
 288187825
 164464905
 125434448
 601328899
 352494946
(12 rows)

要使用自定义名称创建或重建视图：

  1. 用两个实参、一个输入弹性表 darkdata以及要创建的视图名称 dd_view 调用函数：

    => SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view');
            build_flextable_view
-----------------------------------------------
 The view public.dd_view is ready for querying
(1 row)

  2. 从新视图或更新视图 (user.lang) 查询键名 (dd_view)：

    => SELECT "user.lang" FROM dd_view;
 user.lang
-----------
 tr
 en
 es
 en
 en
 it
 es
 en
(12 rows)

要使用 BUILD_FLEXTABLE_VIEW 从自定义键表创建一个视图，此自定义表必须具有与默认表 (darkdata_keys) 相同的架构和表定义。使用下面三种方法中的任何一种创建一个自定义键表：

  • 使用弹性表 (darkdata_keys) 的默认键表中的所有键创建一个柱状表：

    => CREATE TABLE new_darkdata_keys AS SELECT * FROMdarkdata_keys;
CREATE TABLE

  • 从弹性表 (LIMIT 0) 的默认键表创建一个不含内容的柱状表 (darkdata_keys)：

    => CREATE TABLE new_darkdata_keys AS SELECT * FROM darkdata_keys LIMIT 0;
CREATE TABLE
kdb=> SELECT * FROM new_darkdata_keys;
 key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)

  • 从默认键表创建一个不含内容的柱状表 (LIMIT 0)，并将两个值 ('user.lang', 'user.name') 插入 key_name 列：

    => CREATE TABLE dd_keys AS SELECT * FROM darkdata_keys limit 0;
CREATE TABLE
=> INSERT INTO dd_keys (key_name) values ('user.lang');
 OUTPUT
--------
      1
(1 row)
=> INSERT INTO dd_keys (key_name) values ('user.name');
 OUTPUT
--------
      1
(1 row)
=> SELECT * FROM dd_keys;
 key_name  | frequency | data_type_guess
-----------+-----------+-----------------
 user.lang |           |
 user.name |           |
(2 rows)

创建一个自定义键表后，用所有实参（输入 Flex 表、新视图名称、自定义键表）调用 BUILD_FLEXTABLE_VIEW：

=> SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view', 'dd_keys');
            build_flextable_view
-----------------------------------------------
 The view public.dd_view is ready for querying
(1 row)

查询新视图：

=> SELECT * FROM dd_view;

另请参阅

4.9.1.2 - COMPUTE_FLEXTABLE_KEYS

计算来自 flex 表 VMap 数据的虚拟列（键和值）。使用此函数可计算键，而不必创建关联的表视图。如需生成视图，请使用 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW。

函数将其结果存储到关联的 Flex 键表 ( flexTableName_keys)，其中包含以下列：

  • key_name

  • frequency

  • data_type_guess

有关详细信息，请参阅计算 Flex 表键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COMPUTE_FLEXTABLE_KEYS ('[[database.]schema.]flex-table')

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

flex-table
Flex 表的名称。

使用数据类型猜测

data_type_guess 列中的结果取决于 EnableBetterFlexTypeGuessing 配置参数。默认情况下，参数为 1 (ON)。此设置会导致函数采用以下类型之一（以及 数据类型 中列出的其他类型）返回 data_type_guess 列中的所有非字符串键：

  • BOOLEAN

  • INTEGER

  • FLOAT

  • TIMESTAMP

  • DATE

将配置参数设置为 0 (OFF) 会导致函数仅返回键表 data_type_guess 列中所有值的字符串类型 ([LONG]VARCHAR) 或 ([LONG] VARBINARY)。

使用此部分中的示例 CSV 数据来比较使用或不使用 EnableBetterFlexTypeGuessing 配置参数的结果。当参数为 ON 时，该函数可以更准确地确定地图数据中的关键非字符串数据类型。该参数的默认值为 1 (ON)。

Year,Quarter,Region,Species,Grade,Pond Value,Number of Quotes,Available
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,1P,$615.12 ,12,No
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,SM,$610.78 ,12,Yes
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,2S,$596.00 ,20,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,P,$520.00 ,6,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,SM,$510.00 ,6,No
2015,1,2 - Northwest Oregon & Willamette,Hemlock,2S,$490.00 ,14,No

要比较数据类型分配结果，请完成以下步骤：

  1. 保存此 CSV 数据文件（此处保存为 trees.csv）。

  2. 创建 Flex 表 (trees) 并使用 fcsvparser 加载 trees.csv：

    => CREATE FLEX TABLE trees();
=> COPY trees FROM '/home/dbadmin/tempdat/trees.csv' PARSER fcsvparser();

  3. 将 COMPUTE_FLEXTABLE_KEYS 用于 trees Flex 表。

    => SELECT COMPUTE_FLEXTABLE_KEYS('trees');
            COMPUTE_FLEXTABLE_KEYS
-----------------------------------------------
 Please see public.trees_keys for updated keys
(1 row)

  4. 查询 trees_keys 表输出：

    => SELECT * FROM trees_keys;
     key_name     | frequency | data_type_guess
------------------+-----------+-----------------
 Year             |         6 | Integer
 Quarter          |         6 | Integer
 Region           |         6 | Varchar(66)
 Available        |         6 | Boolean
 Number of Quotes |         6 | Integer
 Grade            |         6 | Varchar(20)
 Species          |         6 | Varchar(22)
 Pond Value       |         6 | Numeric(8,3)
(8 rows)

  5. 将 EnableBetterFlexTypeGuessing 参数设置为 0（OFF）。

  6. 再次使用 trees Flex 表调用 COMPUTE_FLEXTABLE_KEYS。

  7. 查询 trees_keys 表，将 data_type_guess 的值与之前的结果进行比较。如果没有配置参数集，所有非字符串数据类型都是各种长度的 VARCHARS：

    
=> SELECT * FROM trees_keys;
    key_name     | frequency | data_type_guess
------------------+-----------+-----------------
 Year             |         6 | varchar(20)
 Quarter          |         6 | varchar(20)
 Region           |         6 | varchar(66)
 Available        |         6 | varchar(20)
 Grade            |         6 | varchar(20)
 Number of Quotes |         6 | varchar(20)
 Pond Value       |         6 | varchar(20)
 Species          |         6 | varchar(22)
(8 rows)

  8. 要保持非字符串数据类型的准确结果，请将 EnableBetterFlexTypeGuessing 参数重新设置为 1 (ON)。

有关 EnableBetterFlexTypeGuessing 配置参数的详细信息，请参阅 EnableBetterFlexTypeGuessing。

另请参阅

4.9.1.3 - COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW

可合并 BUILD_FLEXTABLE_VIEW 和 COMPUTE_FLEXTABLE_KEYS 的功能，以便计算来自 Flex 表 Vmap 数据的虚拟列（键），并构建视图。使用此函数创建视图将忽略空键。如果不需要一起执行这两项操作，请改为使用单操作函数之一。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW ('flex-table')

参数

flex-table
Flex 表的名称

示例

此示例显示如何调用 darkdata Flex 表的函数。

=> SELECT COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW('darkdata');
               compute_flextable_keys_and_build_view
-----------------------------------------------------------------------
 Please see public.darkdata_keys for updated keys
The view public.darkdata_view is ready for querying
(1 row)

另请参阅

4.9.1.4 - MATERIALIZE_FLEXTABLE_COLUMNS

使用 COMPUTE_FLEXTABLE_KEYS 或 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 实体化执行计算的 flextable_keys 表中作为 key_names 列出的虚拟列。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MATERIALIZE_FLEXTABLE_COLUMNS ('[[database.]schema.]flex-table' [, n-columns [, keys-table-name] ])

实参

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

flex-table
具有需要实体化的列的 flex 表的名称。函数：

  • 跳过已实体化的任何列

  • 忽略所有空键

n-列
要实体化的列数，最多为 9800。函数尝试实体化键表中的列数，跳过所有已经实体化的列。按频率降序排列实体化结果。如果未指定，则默认为最多 50 列。
keys-table-name
要从中实体化列的键的名称。函数：

  • 实体化键表中的 n-columns 列

  • 跳过已实体化的任何列

  • 按频率降序排列实体化结果

示例

以下示例显示了如何调用 MATERIALIZE_FLEXTABLE_COLUMNS 实体化列。首先，将 tweets 样本文件 (tweets_10000.json) 载入 flex 表 twitter_r。加载数据并计算样本 Flex 表的键以后，调用 MATERIALIZE_FLEXTABLE_COLUMNS，实体化前四列：

=> COPY twitter_r FROM '/home/release/KData/tweets_10000.json' parser fjsonparser();
 Rows Loaded
-------------
       10000
(1 row)

=> SELECT compute_flextable_keys ('twitter_r');
              compute_flextable_keys
---------------------------------------------------
 Please see public.twitter_r_keys for updated keys
(1 row)

=> SELECT MATERIALIZE_FLEXTABLE_COLUMNS('twitter_r', 4);
    MATERIALIZE_FLEXTABLE_COLUMNS
-------------------------------------------------------------------------------
 The following columns were added to the table public.twitter_r:
        contributors
        entities.hashtags
        entities.urls
For more details, run the following query:
SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';

(1 row)

例子的最后一条消息推荐查询 MATERIALIZE_FLEXTABLE_COLUMNS_RESULTS 系统表，查看列实体化的结果，如下所示：

=> SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';
table_id           | table_schema | table_name |      creation_time           |     key_name      | status |    message
-------------------+--------------+------------+------------------------------+-------------------+--------+---------------------
 45035996273733172 | public       | twitter_r  | 2013-11-20 17:00:27.945484-05| contributors      | ADDED  | Added successfully
 45035996273733172 | public       | twitter_r  | 2013-11-20 17:00:27.94551-05 | entities.hashtags | ADDED  | Added successfully
 45035996273733172 | public       | twitter_r  | 2013-11-20 17:00:27.945519-05| entities.urls     | ADDED  | Added successfully
 45035996273733172 | public       | twitter_r  | 2013-11-20 17:00:27.945532-05| created_at        | EXISTS | Column of same name already
(4 rows)

另请参阅

4.9.1.5 - RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW

恢复键表和视图。无论删除任一表，函数还会将键表与其关联的 Flex 表链接起来。该函数还会指示其恢复了一个对象还是同时恢复了两个对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW ('flex-table')

参数

flex-table
Flex 表的名称

示例

此示例显示如何使用现有的 Flex 表调用此函数，还原键表和视图：

=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
                     RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
----------------------------------------------------------------------------------
The keys table public.darkdata_keys was restored successfully.
The view public.darkdata_view was restored successfully.
(1 row)

此示例描述函数恢复了 darkdata_view，但不需要恢复 darkdata_keys：

=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
                    RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
------------------------------------------------------------------------------------
 The keys table public.darkdata_keys already exists and is linked to darkdata.
 The view public.darkdata_view was restored successfully.
(1 row)

还原键表之后，其中没有任何内容。要填充 Flex 键，请调用 COMPUTE_FLEXTABLE_KEYS 函数。

=> SELECT * FROM darkdata_keys;
 key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)

另请参阅

4.9.2 - Flex Extractor 函数

Flex Extractor 标量函数可处理多结构数据。每个函数均接受以下输入数据：

  • 现有数据库内容

  • 表

  • 从表达式返回

  • 直接输入

这些函数不解析来自外部文件源的数据。所有函数均返回单一 VMap 值。Extractor 函数可以返回带 NULL 指定列的数据。

4.9.2.1 - MAPDELIMITEDEXTRACTOR

用分隔符和其他可选实参提取数据，并返回单一的 VMap 值。

语法

MAPDELIMITEDEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])

参数

record-value
包含要对其应用表达式的 JSON 或分隔符格式记录的字符串。

参数

delimiter
单个分隔符。

默认值： |

header_names
列标题名称的分隔符分隔列表。

默认值： ucoln，其中 n 为列偏移数，第一列以 0 开头。

trim
布尔值，从标题名和字段值中去掉空格。

默认值： true

treat_empty_val_as_null
布尔值，将空字段设置为 NULL 而不是空字符串 ('')。

默认值： true

示例

这些示例使用了一个简短的分隔数据集：

Name|CITY|New city|State|zip
Tom|BOSTON|boston|MA|01
Eric|Burlington|BURLINGTON|MA|02
Jamie|cambridge|CAMBRIDGE|MA|08

首先，将此数据保存为 delim.dat。

  1. 创建一个 Flex 表 dflex：

    => CREATE FLEX TABLE dflex();
CREATE TABLE

  2. 使用 COPY 加载 delim.dat 文件。使用 Flex 表 fdelimitedparser 的 header='false' 选项：

    => COPY dflex FROM '/home/release/kmm/flextables/delim.dat' parser fdelimitedparser(header='false');
 Rows Loaded
-------------
         4
(1 row)

  3. 创建列式表 dtab，它具有一个表示身份的 id 列、一个 delim 列和一个用于存储 VMap 的 vmap 列：

    => CREATE TABLE dtab (id IDENTITY(1,1), delim varchar(128), vmap long varbinary(512));
CREATE TABLE

  4. 使用 COPY 将 delim.dat 文件加载到 dtab 表中。MAPDELIMITEDEXTRACTOR 使用 header_names 参数以及 delimiter '!' 为示例数据指定标题行：

    => COPY dtab(delim, vmap AS MAPDELIMITEDEXTRACTOR (delim
   USING PARAMETERS header_names='Name|CITY|New City|State|Zip')) FROM '/home/dbadmin/data/delim.dat'
DELIMITER '!';

    
 Rows Loaded
-------------
           4
(1 row)

  5. 将 MAPTOSTRING 用于 Flex 表 dflex，以查看 __raw__ 列内容。请注意使用中的默认标题名 (ucol0 – ucol4)，因为您在加载 Flex 表时指定 header='false'：

    => SELECT MAPTOSTRING(__raw__) FROM dflex limit 10;
                              maptostring
-------------------------------------------------------------------------------------
 {
   "ucol0" : "Jamie",
   "ucol1" : "cambridge",
   "ucol2" : "CAMBRIDGE",
   "ucol3" : "MA",
   "ucol4" : "08"
}

 {
   "ucol0" : "Name",
   "ucol1" : "CITY",
   "ucol2" : "New city",
   "ucol3" : "State",
   "ucol4" : "zip"
}

 {
   "ucol0" : "Tom",
   "ucol1" : "BOSTON",
   "ucol2" : "boston",
   "ucol3" : "MA",
   "ucol4" : "01"
}

 {
   "ucol0" : "Eric",
   "ucol1" : "Burlington",
   "ucol2" : "BURLINGTON",
   "ucol3" : "MA",
   "ucol4" : "02"
}

(4 rows)

  6. 再次使用 MAPTOSTRING，这次将其用于 dtab 表的 vmap 列。将此输出的结果与 Flex 表的结果进行比较。请注意，MAPTOSTRING 返回了您在加载数据时指定的 header_name 参数值：

    => SELECT MAPTOSTRING(vmap) FROM dtab;
                                                      maptostring
------------------------------------------------------------------------------------------------------------------------
 {
   "CITY" : "CITY",
   "Name" : "Name",
   "New City" : "New city",
   "State" : "State",
   "Zip" : "zip"
}

 {
   "CITY" : "BOSTON",
   "Name" : "Tom",
   "New City" : "boston",
   "State" : "MA",
   "Zip" : "02121"
}

 {
   "CITY" : "Burlington",
   "Name" : "Eric",
   "New City" : "BURLINGTON",
   "State" : "MA",
   "Zip" : "02482"
}

 {
   "CITY" : "cambridge",
   "Name" : "Jamie",
   "New City" : "CAMBRIDGE",
   "State" : "MA",
   "Zip" : "02811"
}

(4 rows)

  7. 查询 delim 列，以不同的方式查看其内容：

    => SELECT delim FROM dtab;
                delim
-------------------------------------
 Name|CITY|New city|State|zip
 Tom|BOSTON|boston|MA|02121
 Eric|Burlington|BURLINGTON|MA|02482
 Jamie|cambridge|CAMBRIDGE|MA|02811
(4 rows)

另请参阅

4.9.2.2 - MAPJSONEXTRACTOR

提取重复 JSON 数据对象（包括嵌套映射）或具有 JSON 元素外部列表的数据的内容。您可以设置一个或多个可选参数来控制提取过程。

语法

MAPJSONEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])

参数

record-value
包含要对其应用表达式的 JSON 或包含分隔符格式记录的字符串。

参数

flatten_maps
布尔值，将 JSON 数据中的子映射平展，以句点 (.) 分隔映射层级。

默认值： true

flatten_arrays
布尔值，将列表转换为带有整数键的子映射。默认不对列表进行平展。

默认值： false

reject_on_duplicate
布尔值，忽略重复记录 (false)，或拒绝重复记录 (true)。在任何一种情况下，加载都不受影响。

默认值： false

reject_on_empty_key
布尔值，拒绝任何包含不带值的键的行。

默认值： false

omit_empty_keys
布尔值，从加载数据中省略任何没有值的键。

默认值： false

start_point
JSON 加载数据中用作解析起点的键的名称。解析器忽略 start_point 值之前的所有数据。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。

默认值： 无

示例

这些示例使用以下示例 JSON 数据：

{ "id": "5001", "type": "None" }
{ "id": "5002", "type": "Glazed" }
{ "id": "5005", "type": "Sugar" }
{ "id": "5007", "type": "Powdered Sugar" }
{ "id": "5004", "type": "Maple" }

将此示例数据保存为 bake_single.json，然后加载该文件。

  1. 创建一个 Flex 表 flexjson：

    => CREATE FLEX TABLE flexjson();
CREATE TABLE

  2. 通过 fjsonparser 解析器，使用 COPY 加载 bake_single.json 文件：

    => COPY flexjson FROM '/home/dbadmin/data/bake_single.json' parser fjsonparser();
 Rows Loaded
-------------
           5
(1 row)

  3. 创建列式表 coljson，它具有一个身份列 (id)、一个 json 列和一个用于存储 VMap 的 vmap 列：

    => CREATE TABLE coljson(id IDENTITY(1,1), json varchar(128), vmap long varbinary(10000));
CREATE TABLE

  4. 利用 MAPJSONEXTRACTOR，使用 COPY 将 bake_single.json 文件加载到 coljson 表中：

    => COPY coljson (json, vmap AS MapJSONExtractor(json)) FROM '/home/dbadmin/data/bake_single.json';
 Rows Loaded
-------------
           5
(1 row)

  5. 将 MAPTOSTRING 函数用于 Flex 表 flexjson 以将 __raw__ 列的内容输出为字符串：

    => SELECT MAPTOSTRING(__raw__) FROM flexjson limit 5;
                     maptostring
-----------------------------------------------------
 {
   "id" : "5001",
   "type" : "None"
}

 {
   "id" : "5002",
   "type" : "Glazed"
}

 {
   "id" : "5005",
   "type" : "Sugar"
}

 {
   "id" : "5007",
   "type" : "Powdered Sugar"
}

 {
   "id" : "5004",
   "type" : "Maple"
}

(5 rows)

  6. 再次使用 MAPTOSTRING，这次将其用于 coljson 表的 vmap 列，并比较结果。元素顺序有所不同：

    => SELECT MAPTOSTRING(vmap) FROM coljson limit 5;
                     maptostring
-----------------------------------------------------
 {
   "id" : "5001",
   "type" : "None"
}

 {
   "id" : "5002",
   "type" : "Glazed"
}

 {
   "id" : "5004",
   "type" : "Maple"
}

 {
   "id" : "5005",
   "type" : "Sugar"
}

 {
   "id" : "5007",
   "type" : "Powdered Sugar"
}

(5 rows)

另请参阅

4.9.2.3 - MAPREGEXEXTRACTOR

使用正则表达式提取数据，并以 VMap 的形式返回结果。

语法

MAPREGEXEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])

参数

record-value
包含要对其应用正则表达式的 JSON 或分隔符格式记录的字符串。

参数

pattern
用于提取所需数据的正则表达式。

默认值： 空字符串 ('')

use_jit
布尔值，在解析正则表达式时使用实时编译。

默认值： false

record_terminator
用于分隔输入记录的字符。

默认值： \n

logline_column
包含与正则表达式相匹配的完整字符串的目标列。

默认值： 空字符串 ('')

示例

这些示例使用以下正则表达式，它们搜索包括 timestamp、date、thread_name 和 thread_id 字符串的信息。

此示例表达式加载任何 thread_id 十六进制值，无论其是否包含 0x 前缀 (<thread_id>(?:0x)?[0-9a-f]+)。

'^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

为了方便显示，以下示例可能包含换行符。

  1. 创建一个 Flex 表 flogs：

    => CREATE FLEX TABLE flogs();
CREATE TABLE

  2. 使用 Flex 表 fregexparser 时，利用 COPY 加载示例日志文件 (vertica.log)。请注意，此示例包括为显示长文本行而添加的行字符。

    => COPY flogs FROM '/home/dbadmin/tempdat/vertica.log' PARSER FREGEXPARSER(pattern='
^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+) (?<thread_name>[A-Za-z ]+):
(?<thread_id>(?:0x)?[0-9a-f])-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )?(?<text>.*)');
Rows Loaded
-------------
81399
(1 row)

  3. 用于返回通过正则表达式调用 MAPREGEXEXTRACTOR 的结果。输出以字符串格式返回函数的结果。

    => SELECT MAPTOSTRING(MapregexExtractor(E'2014-04-02 04:02:51.011
TM Moveout:0x2aab9000f860-a0000000002067 [Txn] <INFO>
Begin Txn: a0000000002067 \'Moveout: Tuple Mover\'' using PARAMETERS
pattern=
    '^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

    

    
)) FROM flogs where __identity__=13;

    maptostring
--------------------------------------------------------------------------------------------------
{
"component" : "Txn",
"level" : "INFO",
"text" : "Begin Txn: a0000000002067 'Moveout: Tuple Mover'",
"thread_id" : "0x2aab9000f860",
"thread_name" : "TM Moveout",
"time" : "2014-04-02 04:02:51.011",
"transaction_id" : "a0000000002067"
}
(1 row)

另请参阅

4.9.3 - Flex 映射函数

Flex 映射函数允许您提取和操作嵌套映射数据。

所有 Flex 映射函数的第一个实参（EMPTYMAP 和 MAPAGGREGATE 除外）均包含 VMap。VMap 可以源自 Flex 表中的 __raw__ 列，或从映射或提取函数返回。

所有映射函数（EMPTYMAP 和 MAPAGGREGATE 除外）均接受 LONG VARBINARY 或 LONG VARCHAR 映射实参。

在以下示例中，外部 MAPLOOKUP 函数对从内部 MAPLOOKUP 函数返回的 VMap 数据进行操作：

=> MAPLOOKUP(MAPLOOKUP(ret_map, 'batch'), 'scripts')

您可以将 Flex 映射函数专门用于：

  • Flex 表

  • 关联的 _keys 表和 _view 视图

  • 复杂类型 Flex 列

4.9.3.1 - EMPTYMAP

构建一个有一行但无键值或数据的 VMap。使用此转换函数可填充映射，而无需使用 flex 解析器。但可以使用来自 SQL 查询或存储于数据库中其他位置的映射数据。

语法

EMPTYMAP()

示例

创建空映射

=> SELECT EMPTYMAP();
                             emptymap
------------------------------------------------------------------
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(1 row)

从现有 Flex 表创建空映射

如果从现有 flex 表创建空映射，则新映射的行数与用于创建该映射的表相同。

此示例展示了从 darkdata 表创建空映射将得到的结果，表中包含 12 行 JSON 数据：

=> SELECT EMPTYMAP() FROM darkdata;
                             emptymap
------------------------------------------------------------------
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
 \001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(12 rows)

另请参阅

4.9.3.2 - MAPAGGREGATE

返回从 VARCHAR 的两个输入列提供的具有键和值对的 LONG VARBINARY VMap。此函数需要 OVER 子句。

语法

MAPAGGREGATE (keys-column1, values-column2 [USING PARAMETERS param=value[,...]])

参数

keys-column
包含返回的 VMap 数据的键/值对的键的表列。值为 NULL 的键排除在外。如果存在重复键，则使用查询结果中最先出现的重复键和值，省略其他重复键和值。
values-column
包含返回的 VMap 数据的键/值对的值的表列。

参数

max_vmap_length
VMap 结果的最大字节长度，介于 1-32000000（包含）之间的整数。

默认值： 130000

on_overflow
VMap 结果大于 max_vmap_length 时的溢出行为。值必须为以下字符串之一：
  • "ERROR"：发生溢出时返回错误。
  • "TRUNCATE"：如果结果超过 max_vmap_length，则停止键/值对聚合。执行查询但生成的 VMap 未包含所有键/值对。当提供的 max_vmap_length 不足以存储空 VMap 时，返回的结果为 NULL。请注意，需要在 OVER 子句中指定顺序条件才能获得一致的结果。
  • 'RETURN_NULL'：如果发生溢出，则返回 NULL。

默认值： 'ERROR'

示例

以下示例使用此输入表：

=> SELECT * FROM inventory;
  product     | stock
--------------+--------
  Planes      | 100
  Trains      | 50
  Automobiles | 200
(3 rows)

按如下所述的方法调用 MAPAGGREGATE，返回生成的 VMap 的 raw_map 数据：


=> SELECT raw_map FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM inventory) inventory;
raw_map
------------------------------------------------------------------------------------------------------------
\001\000\000\000\030\000\000\000\003\000\000\000\020\000\000\000\023\000\000\000\026\000\000\00020010050\003
\000\000\000\020\000\000\000\033\000\000\000!\000\000\000AutomobilesPlanesTrains
(1 row)

要将返回的 raw_map 数据转换为字符串表示形式，请使用具有 MAPTOSTRING 的 MAPAGGREGATE：


=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM
inventory) inventory;
MAPTOSTRING
--------------------------------------------------------------
{
  "Automobiles": "200",
  "Planes": "100",
  "Trains": "50"
}
(1 row)

如果运行上述查询时将 on_overflow 保留为默认值且 max_vmap_length 小于返回的 VMap 大小，则函数返回错误消息，表示需要增加 VMap长度：


=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60)
OVER(ORDER BY product) FROM inventory) inventory;
----------------------------------------------------------------------------------------------------------
ERROR 5861:  Error calling processPartition() in User Function MapAggregate at [/data/jenkins/workspace
/RE-PrimaryBuilds/RE-Build-Master_2/server/udx/supported/flextable/Dict.cpp:1324], error code: 0, message:
Exception while finalizing map aggregation: Output VMap length is too small [60]. HINT: Set the parameter
max_vmap_length=71 and retry your query

切换 on_overflow 的值可更改 MAPAGGREGATE 在溢出情况下的行为方式。例如，将 on_overflow 改为 'RETURN_NULL' 可执行上述查询并返回 NULL：


SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='RETURN_NULL') OVER(ORDER BY product) FROM inventory) inventory;
?column?
----------
t
(1 row)

如果 on_overflow 设置为 'TRUNCATE'，则生成的 VMap 有足够的空间容纳两个键/值对，但必须删除第三个键/值对：


SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='TRUNCATE') OVER(ORDER BY product) FROM inventory) inventory;
MAPTOSTRING
---------------------------------------------
{
  "Automobiles": "200",
  "Planes": "100"
}
(1 row)

另请参阅

4.9.3.3 - MAPCONTAINSKEY

确定 VMap 是否含有虚拟列（键）。如果存在虚拟列，此标量函数返回 true (t)；如果不存在，则返回 false (f) 。调用 maplookup() 前确定键的存在可区分 NULL 返回。maplookup() 函数用于非存在键和具有 NULL 值的存在键。

语法

MAPCONTAINSKEY (VMap-data, 'virtual-column-name')

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

virtual-column-name
要检查的键的名称。

示例

本例显示如何使用 mapcontainskey() 函数和 maplookup()。查看两个函数返回的结果。检查 maplookup() 返回的空字段是表示行 (t) 的 NULL 值还是无值 (f)：

您可以在调用 maplookup() 之前使用 mapcontainskey( ) 确定键的存在。maplookup() 函数使用 NULL 返回和具有 NULL 值的存在键，表示一个不存在的键。

=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
 maplookup | mapcontainskey
-----------+----------------
           | t
           | t
           | t
           | t
 Chile     | t
 Narnia    | t
 Uptown..  | t
 chicago   | t
           | f
           | f
           | f
           | f


(12 rows)

另请参阅

4.9.3.4 - MAPCONTAINSVALUE

确定 VMap 是否含有指定值。如果值存在，则使用此标量函数返回 true (t)，否则返回 false (f)。

语法

MAPCONTAINSVALUE (VMap-data, 'virtual-column-value')

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

virtual-column-value
要确认的值。

示例

本例显示如何使用 mapcontainsvalue() 确定虚拟列是否含有特定值。创建一个 flex 表 (ftest)，填充一些虚拟列和值。为虚拟列 one命名：

=> CREATE FLEX TABLE ftest();
CREATE TABLE
=> copy ftest from stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"one":1, "two":2}
>> {"one":"one","2":"2"}
>> \.

在 mapcontainsvalue() 映射数据上调用 ftest 。查询对第一个虚拟列返回 false (f) ，对含有值 t的第二个返回 true (one)。


=> SELECT MAPCONTAINSVALUE(__raw__, 'one') FROM ftest;
mapcontainsvalue
------------------
f
t
(2 rows)

另请参阅

4.9.3.5 - MAPITEMS

返回关于 VMap 中各项目的信息。使用具有一个或多个可选自变量的转换函数访问 VMap 数据中的聚结构值。该函数需要 over() 子句。

语法

MAPITEMS (VMap-data [, passthrough-arg[,...] ])

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

max_key_length
在 __raw__ 列中，确定函数可以返回的键的最大长度。长度超过 max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。
max_value_length
在 __raw__ 列中，确定函数可以返回的值的最大长度。大于 max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。
passthrough-arg
表示 VMap-data 映射数据中键的一个或多个实参。

示例

以下示例说明如何使用带有 over(PARTITION BEST) 子句的 MAPITEMS()。

此示例使用标记为 darkmountain 的 Flex 表确定映射数据中的虚拟列数。使用 count() 函数查询返回映射数据中的虚拟列数：

=> SELECT COUNT(keys) FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM
 darkmountain) AS a;
 count
-------
    19
(1 row)

下一个示例确定映射数据中存在哪些项：

=> SELECT * FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
    keys     |    values
-------------+---------------
 hike_safety | 50.6
 name        | Mt Washington
 type        | mountain
 height      | 17000
 hike_safety | 12.2
 name        | Denali
 type        | mountain
 height      | 29029
 hike_safety | 34.1
 name        | Everest
 type        | mountain
 height      | 14000
 hike_safety | 22.8
 name        | Kilimanjaro
 type        | mountain
 height      | 29029
 hike_safety | 15.4
 name        | Mt St Helens
 type        | volcano
(19 rows)

以下示例显示如何将返回值的长度限制为 100000：

=> SELECT LENGTH(keys), LENGTH(values) FROM (SELECT MAPITEMS(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM t1) x;
 LENGTH | LENGTH
--------+--------
      9 | 98899
(1 row)

在 VMap 中直接查询关键值

查看以下 JSON 输入文件 simple.json。特别注意 three_Array 队列及其四个值：

{
  "one": "one",
  "two": 2,
  "three_Array":
  [
    "three_One",
    "three_Two",
    3,
    "three_Four"
  ],
  "four": 4,
  "five_Map":
  {
    "five_One": 51,
    "five_Two": "Fifty-two",
    "five_Three": "fifty three",
    "five_Four": 54,
    "five_Five": "5 x 5"
  },
  "six": 6
}

  1. 创建 flex 表，映射：

    => CREATE FLEX TABLE mapper();
CREATE TABLE

    将 simple.json 载入 flex 表映射：

    => COPY mapper FROM '/home/dbadmin/data/simple.json' parser fjsonparser (flatten_arrays=false,
flatten_maps=false);
 Rows Loaded
-------------
           1
(1 row)

    在 Flex 表的 __raw__ 列上调用 MAPKEYS，查看 Flex 表的键，但不是键子映射。返回值显示 three_Array 是虚拟列之一：

    => SELECT MAPKEYS(__raw__) OVER() FROM mapper;
    keys
-------------
 five_Map
 four
 one
 six
 three_Array
 two
(6 rows)

    在 Flex 表 mapper 上调用 mapitems，将 three_Array 作为函数的传递实参。调用返回这些队列值：

    => SELECT __identity__, MAPITEMS(three_Array) OVER(PARTITION BY __identity__) FROM mapper;
 __identity__ | keys |   values
--------------+------+------------
            1 | 0    | three_One
            1 | 1    | three_Two
            1 | 2    | 3
            1 | 3    | three_Four
(4 rows)

另请参阅

4.9.3.6 - MAPKEYS

返回任何 VMap 数据中存在的虚拟列（和值）。此转换函数需要 OVER(PARTITION BEST) 子句。

语法

MAPKEYS (VMap-data)

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

max_key_length
在 __raw__ 列中，指定函数可以返回的键的最大长度。长度超过 max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。

示例

确定映射数据的虚拟列数

本例显示如何创建查询，使用 over(PARTITION BEST) 子句和 flex 表、 darkdata ，查找映射数据的虚拟列数。使用 JSON tweet 数据填充表。

=> SELECT COUNT(keys) FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;

 count
-------
   550
(1 row)

查询映射中所有虚拟列的有序列表

本例显示您查询映射中所有虚拟列的有序列表时，返回数据的片段。

=> SELECT * FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;

    keys
-------------------------------------
 contributors
 coordinates
 created_ at
 delete.status.id
 delete.status.id_str
 delete.status.user_id
 delete.status.user_id_str
 entities.hashtags
 entities.media
 entities.urls
 entities.user_mentions
 favorited
 geo
 id
.
.
.
 user.statuses_count
 user.time_zone
 user.url
 user.utc_offset
 user.verified
(125 rows)

指定 MAPKEYS 可以返回的键的最大长度

=> SELECT MAPKEYS(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
    keys
-------------
 five_Map
 four
 one
 six
 three_Array
 two
(6 rows)

另请参阅

4.9.3.7 - MAPKEYSINFO

从给定映射中返回虚拟列信息。此转换函数需要 OVER(PARTITION BEST) 子句。

语法

MAPKEYSINFO (VMap-data)

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

max_key_length
在 __raw__ 列中，确定函数可以返回的键的最大长度。长度超过 max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。

返回

此函数是 MAPKEYS() 函数的超集。返回下列关于每个虚拟列的信息：

示例

本例显示您查询映射中所有虚拟列的有序列表时接收到的返回数据的片段。

=> SELECT * FROM (SELECT MAPKEYSINFO(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
                          keys                           | length | type_oid | row_num | field_num
----------------------------------------------------------+--------+----------+---------+-----------
 contributors                                             |      0 |      116 |       1 |         0
 coordinates                                              |      0 |      116 |       1 |         1
 created_at                                               |     30 |      116 |       1 |         2
 entities.hashtags                                        |     93 |      199 |       1 |         3
 entities.media                                           |    772 |      199 |       1 |         4
 entities.urls                                            |     16 |      199 |       1 |         5
 entities.user_mentions                                   |     16 |      199 |       1 |         6
 favorited                                                |      1 |      116 |       1 |         7
 geo                                                      |      0 |      116 |       1 |         8
 id                                                       |     18 |      116 |       1 |         9
 id_str                                                   |     18 |      116 |       1 |        10
.
.
.
 delete.status.id                                         |     18 |      116 |      11 |         0
 delete.status.id_str                                     |     18 |      116 |      11 |         1
 delete.status.user_id                                    |      9 |      116 |      11 |         2
 delete.status.user_id_str                                |      9 |      116 |      11 |         3
 delete.status.id                                         |     18 |      116 |      12 |         0
 delete.status.id_str                                     |     18 |      116 |      12 |         1
 delete.status.user_id                                    |      9 |      116 |      12 |         2
 delete.status.user_id_str                                |      9 |      116 |      12 |         3
(550 rows)

指定 MAPKEYSINFO 可以返回的键的最大长度

=> SELECT MAPKEYSINFO(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
    keys
-------------
 five_Map
 four
 one
 six
 three_Array
 two
(6 rows)

另请参阅

4.9.3.8 - MAPLOOKUP

从 VMAP 数据中返回单个键值。如果具有值，此标量函数返回 LONG VARCHAR；如果虚拟列没有值，则返回 NULL。

对于虚拟列名，使用 maplookup 不区分大小写。为了避免加载同名值，请在数据加载时将 fjsonparser 解析器 reject_on_duplicate 参数设置为 true。

通过 fjsonparser 或 favroparser 分析器及其 flatten-arrays 实参加载数据时，您可以控制 VMAP 中非标量值（例如数组）的行为。请参阅 JSON 数据 和 FJSONPARSER 参考。

有关使用 maplookup() 访问嵌套 JSON 数据的信息，请参阅查询嵌套数据。

语法

MAPLOOKUP (VMap-data, 'virtual-column-name' [USING PARAMETERS [case_sensitive={false | true}] [, buffer_size=n] ] )

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

virtual-column-name
此函数返回值的虚拟列名称。
buffer_size
[可选参数] 指定每个返回 virtual-column-name 值的最大长度（以字节为单位）。为了返回所有 virtual-column-name 值，指定一个大于等于 (buffer_size) 任何返回值字节数的 =>。所有长度大于 buffer_size 的返回值将被拒绝。

默认值： 0（buffer_size 无限制）

case_sensitive
[可选参数]

如果键在不同情况下存在，指定是否返回 virtual-column-name 的值。

示例：

(... USING PARAMETERS case_sensitive=true)

默认值： false

示例

此示例返回一个虚拟列 user.location 的值：

=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata ORDER BY 1;
 maplookup
-----------
 Chile
 Nesnia
 Uptown
 .
 .
 chicago
(12 rows)

使用 maplookup buffer_size

使用 buffer_size= 参数表示映射查询为指定虚拟列返回的任何值的最大长度。如果返回键值均不大于 n 字节，则使用该参数分配 n 字节作为 buffer_size。

对于下一个示例，将此 JSON 数据保存到文件 simple_name.json：

{
  "name": "sierra",
  "age": "63",
  "eyes": "brown",
  "weapon": "doggie"
}
{
  "name": "janis",
  "age": "10",
  "eyes": "blue",
  "weapon": "humor"
}
{
  "name": "ben",
  "age": "43",
  "eyes": "blue",
  "weapon": "sword"
}
{
  "name": "jen",
  "age": "38",
  "eyes": "green",
  "weapon": "shopping"
}

  1. 创建 flex 表 logs。

  2. 使用 simple_name.json 将 logs 数据载入 fjsonparser。指定 flatten_arrays 选项作为 True：

    => COPY logs FROM '/home/dbadmin/data/simple_name.json'
  PARSER fjsonparser(flatten_arrays=True);

  3. 对 maplookup 表的 buffer_size=0 键使用 logs 的 name 。此查询返回所有值：

    => SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=0) FROM logs;
 MapLookup
-----------
 sierra
 ben
 janis
 jen
(4 rows)

  4. 接下来，调用 maplookup() 3次，将 buffer_size 参数分别指定为 3、5 和 6。现在，maplookup() 返回字节长度小于或等于 (<=) buffer_size 的值：

    => SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=3) FROM logs;
 MapLookup
-----------

 ben

 jen
(4 rows)
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=5) FROM logs;
 MapLookup
-----------

 janis
 jen
 ben
(4 rows)

    => SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=6) FROM logs;
 MapLookup
-----------
 sierra
 janis
 jen
 ben
(4 rows)

消除空输出行的歧义

此示例展示如何解释空行。如果在没有首先检查密钥是否存在的情况下使用 maplookup，则可能产生歧义。查看下列输出（12 个空行）时，您无法确定 user.location 键是否具有：

  • 非 NULL 值

  • NULL 值

  • 无值

=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata;
 maplookup
-----------












(12 rows)

消除空输出行，使用 mapcontainskey() 函数和 maplookup()。当 maplookup 返回空字段时，mapcontainskey 的相应值使用 t 表示 NULL 或其他值，或使用 f 表示无值。

以下使用全部两个函数的示例输出将具有 NULL 或名称值的行列为 t，将没有值的行列为 f：

=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
 maplookup | mapcontainskey
-----------+----------------
           | t
           | t
           | t
           | t
 Chile     | t
 Nesnia    | t
 Uptown    | t
 chicago   | t
           | f >>>>>>>>>>No value
           | f >>>>>>>>>>No value
           | f >>>>>>>>>>No value
           | f >>>>>>>>>>No value
(12 rows)

检查区分大小写的虚拟列

在键名称不同的情况下，您可以使用具有 maplookup() 参数的 case_sensitive 返回结果。

  1. 将下列实例内容保存为 JSON 文件。本例将文件保存为 repeated_key_name.json：

    {
  "test": "lower1"
}
{
  "TEST": "upper1"
}
{
  "TEst": "half1"
}
{
  "test": "lower2",
  "TEst": "half2"
}
{
  "TEST": "upper2",
  "TEst": "half3"
}
{
  "test": "lower3",
  "TEST": "upper3"
}
{
  "TEst": "half4",
  "test": "lower4",
  "TEST": "upper4"
}
{
  "TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttest":"1",
    "TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttestTest12345":"2"
}

  2. 创建 Flex 表 dupe，并加载 JSON 文件：

    => CREATE FLEX TABLE dupe();
CREATE TABLE
dbt=> COPY dupe FROM '/home/release/KData/repeated_key_name.json' parser fjsonparser();
 Rows Loaded
-------------
           8
(1 row)

另请参阅

4.9.3.9 - MAPPUT

接受一个 VMap 和一个或多个键/值对，并返回一个添加了键/值对的新 VMap。键必须使用辅助函数 SetMapKeys() 设置，并且只能是常量字符串。如果 VMap 有任何新的输入键，则原始值将被新的值替换。

语法

MAPPUT (VMap-data, value[,...] USING PARAMETERS keys=SetMapKeys('key'[,...])

参数

VMap-data
任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从 MAPLOOKUP 等映射函数返回的数据。

  • 其他数据库内容

value[,...]
要添加到 VMap-data 中指定的 VMap 的一个或多个值。

参数

keys
SetMapKeys() 的结果。 SetMapKeys() 接受一个或多个常量字符串实参。

以下示例展示了如何创建 Flex 表并使用 COPY 输入一些基本的 JSON 数据。创建第二个 Flex 表后，插入来自 mapput() 的新 VMap 结果，以及附加的键/值对。

  1. 创建样本表：

    => CREATE FLEX TABLE vmapdata1();
CREATE TABLE

  2. 从 STDIN 加载样本 JSON 数据：

    => COPY vmapdata1 FROM stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"aaa": 1, "bbb": 2, "ccc": 3}
>> \.

  3. 创建另一个 Flex 表并使用该函数将数据插入其中： => CREATE FLEX TABLE vmapdata2(); => INSERT INTO vmapdata2 SELECT MAPPUT(__raw__, '7','8','9' using parameters keys=SetMapKeys('xxx','yyy','zzz')) from vmapdata1;

  4. 查看原始 Flex 表和新 Flex 表之间的差异：

    => SELECT MAPTOSTRING(__raw__) FROM vmapdata1;
                     maptostring
-----------------------------------------------------
 {
   "aaa" : "1",
   "bbb" : "2",
   "ccc" : "3"
 }
 (1 row)

=> SELECT MAPTOSTRING(__raw__) from vmapdata2;
                     maptostring
-------------------------------------------------------
 {
   "mapput" : {
      "aaa" : "1",
      "bbb" : "2",
      "ccc" : "3",
      "xxx" : "7",
      "yyy" : "8",
      "zzz" : "9"
   }
 }

另请参阅

4.9.3.10 - MAPSIZE

返回任何 VMap 数据中存在的虚拟列数。使用标量函数确定键的大小。

语法

MAPSIZE (VMap-data)

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

示例

本例显示从 flex 表 darkmountain 中返回键数的大小：

=> SELECT MAPSIZE(__raw__) FROM darkmountain;
 mapsize
---------
       3
       4
       4
       4
       4
(5 rows)

另请参阅

4.9.3.11 - MAPTOSTRING

递归地构建 VMap 数据的字符串表示形式，包括嵌套 JSON 映射。使用此转换函数以 LONG VARCHAR 格式显示 VMap 内容。在使用 MAPVALUES 查询虚拟列之前，您可以使用 MAPTOSTRING 查看映射数据是如何嵌套的。

语法

MAPTOSTRING ( VMap-data [ USING PARAMETERS param=value ] )

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

参数

canonical_json
布尔值，是否生成规范化 JSON 格式，使用映射数据中任何重复键的第一个实例。如果为 false，则该函数返回重复键及其值。

默认值： true

示例

以下示例使用此表定义和示例数据：

=> CREATE FLEX TABLE darkdata();
CREATE TABLE

=> COPY darkdata FROM stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"aaa": 1, "aaa": 2, "AAA": 3, "bbb": "aaa\"bbb"}
>> \.

使用默认值 canonical_json 调用 MAPTOSTRING 仅返回重复键的第一个实例：

=> SELECT MAPTOSTRING (__raw__) FROM darkdata;
                        maptostring
------------------------------------------------------------
 {
   "AAA" : "3",
   "aaa" : "1",
   "bbb" : "aaa\"bbb"
}
(1 row)

canonical_json 设置为 false，函数返回所有键，包括重复键：

=> SELECT MAPTOSTRING(__raw__ using parameters canonical_json=false) FROM darkdata;
                          maptostring
---------------------------------------------------------------
 {
        "aaa":  "1",
        "aaa":  "2",
        "AAA":  "3",
        "bbb":  "aaa"bbb"
 }
(1 row)

另请参阅

4.9.3.12 - MAPVALUES

返回表示来自 VMap 顶层值的字符串。此转换函数需要 OVER() 子句。

语法

MAPVALUES (VMap-data)

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

max_value_length
在 __raw__ 列中，指定函数可以返回的值的最大长度。大于 max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。

示例

下面的例子显示如何使用具有 darkmountain 的 over() 子句查询 over(PARTITION BEST) flex 表（在本例中使用 mapvalues() 子句）。

=> SELECT * FROM (SELECT MAPVALUES(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
    values
---------------
 29029
 34.1
 Everest
 mountain
 29029
 15.4
 Mt St Helens
 volcano
 17000
 12.2
 Denali
 mountain
 14000
 22.8
 Kilimanjaro
 mountain
 50.6
 Mt Washington
 mountain
(19 rows)

指定 MAPVALUES 可以返回的值的最大长度

=> SELECT MAPVALUES(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM mapper;
    keys
-------------
 five_Map
 four
 one
 six
 three_Array
 two
(6 rows)

另请参阅

4.9.3.13 - MAPVERSION

返回任何映射数据的版本或无效性。本标量函数返回映射版本（如 1），如果映射数据无效，则返回 -1。

语法

MAPVERSION (VMap-data)

参数

VMap-data

任何 Vmap 数据。Vmap 的存在形式可以是：

  • Flex 表的 __raw__ 列

  • 从映射函数返回的数据（示例） MAPLOOKUP

  • 其他数据库内容

示例

下面的例子显示如何使用 mapversion() 和 darkmountain flex 表，返回 flex 表映射数据的 mapversion 1。

=> SELECT MAPVERSION(__raw__) FROM darkmountain;
 mapversion
------------
          1
          1
          1
          1
          1
(5 rows)

另请参阅

4.10 - 格式化函数

格式化函数是一个强大的工具集，可以将各种数据类型 (DATE/TIME, INTEGER, FLOATING POINT) 转换为格式化的字符串，以及将格式化的字符串转换为特定数据类型。

4.10.1 - TO_BITSTRING

返回 VARCHAR，表示位字符串格式的给定 VARBINARY 值。此函数是 BITSTRING_TO_BINARY 的反函数。

行为类型

不可变

语法

TO_BITSTRING ( expression )

参数

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

示例

=> SELECT TO_BITSTRING('ab'::BINARY(2));
   to_bitstring
------------------
 0110000101100010
(1 row)

=> SELECT TO_BITSTRING(HEX_TO_BINARY('0x10'));
 to_bitstring
--------------
00010000
(1 row)

=> SELECT TO_BITSTRING(HEX_TO_BINARY('0xF0'));
 to_bitstring
--------------
11110000
(1 row)

另请参阅

BITCOUNT

4.10.2 - TO_CHAR

将日期/时间和数字值转换成文本字符串。

行为类型

稳定

语法

TO_CHAR ( expression [, pattern ] )

参数

表达式
指定要转换的值，为以下数据类型之一：

存在以下限制：

  • TO_CHAR 不支持二进制数据类型 BINARY 和 VARBINARY

  • TO_CHAR 不支持将 V 与小数点结合使用，例如， 99.9V99

模式
指定输出模式字符串的 CHAR 或 VARCHAR。请参阅用于日期/时间格式化的模板模式。

注意

  • Vertica 使用前置空格填充 TO_CHAR 输出，因此正值和负值具有相同的长度。要抑制填充，请使用 FM 前缀。

  • 如果您将 TIME 显式转换为 TIMESTAMP 并将 TIMETZ 转换为 TIMESTAMPTZ，则 TO_CHAR 接受 TIME 和 TIMETZ 数据类型作为输入。

    => SELECT TO_CHAR(TIME '14:34:06.4','HH12:MI am'), TO_CHAR(TIMETZ '14:34:06.4+6','HH12:MI am');
 TO_CHAR  | TO_CHAR
----------+----------
 02:34 pm | 04:34 am
(1 row)

  • 您可以从 TIMETZ 提取时区小时：

    => SELECT EXTRACT(timezone_hour FROM TIMETZ '10:30+13:30');
 date_part
-----------
        13
(1 row)

  • 普通字面量允许用于 TO_CHAR 模板，并且将当做字面量输出。您可以将子字符串放入双引号中，以强制它转换为字面量，即使包含模式关键词。在以下示例中，YYYY 被替换为年份数据，但 Year 中的 Y 不是：

    => SELECT to_char(CURRENT_TIMESTAMP, '"Hello Year " YYYY');
     to_char
------------------
 Hello Year  2021
(1 row)

  • TO_CHAR 使用与 EXTRACT 不同的星期编号（请参阅 D 模板模式）。

  • 如果规定 INTERVAL 类型，TO_CHAR 以 HH 和 HH12 作为一天的小时数，而 HH24 可输出超过一天的小时数，例如 >24。

  • 要在输出中包含双引号 (") 字符，请在其前面加上双反斜杠 (\\)。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\"YYYY Month\\"'

  • 四舍五入时，如果数字正好是两者的中间值，舍入表示形式的最后一位数应选择偶数。

示例

另请参阅

DATE_PART

4.10.3 - TO_DATE

转换字符串值为 DATE 类型。

行为类型

稳定

语法

TO_DATE ( expression , pattern )

参数

表达式
指定要转换的字符串值，CHAR 或 VARCHAR。
模式
指定输出模式字符串的 CHAR 或 VARCHAR。请参阅：

输入值注意事项

TO_DATE 需要 CHAR 或 VARCHAR 表达式。对于其他输入类型，请先使用 TO_CHAR 来执行显式强制转换为 CHAR 或 VARCHAR，才能使用此函数。

注意

  • 要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'

  • TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：

    • TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。

    • TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。

  • 如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：

    => SELECT TO_DATE('200001131','YYYYMMDD');
  TO_DATE
------------
 2000-01-13
(1 row)

    应在年份后使用非数字分隔符。例如：

    => SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
   TO_DATE
-------------
 20000-12-01
(1 row)

  • 在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。

示例

=> SELECT TO_DATE('13 Feb 2000', 'DD Mon YYYY');
  to_date
------------
 2000-02-13
(1 row)

另请参阅

日期/时间函数

4.10.4 - TO_HEX

返回 VARCHAR 或 VARBINARY，表示等同于数值的十六进制值。此函数是 HEX_TO_BINARY 的反转函数。

行为类型

不可变

语法

TO_HEX ( number )

参数

number
要转换为十六进制的 INTEGER 或 VARBINARY 值。如果您提供 VARBINARY 实参，则函数的返回值没有 0x 前缀。

示例

=> SELECT TO_HEX(123456789);
 TO_HEX
---------
 75bcd15
(1 row)

对于 VARBINARY 输入，返回值没有 0x 前缀。例如：

=> SELECT TO_HEX('ab'::binary(2));
 TO_HEX
--------
 6162
(1 row)

4.10.5 - TO_TIMESTAMP

将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP 类型。

行为类型

稳定

语法

TO_TIMESTAMP ( { expression, pattern } | unix‑epoch )

参数

表达式
指定要转换的字符串值，类型为 CHAR 或 VARCHAR。
模式
指定输出模式字符串的 CHAR 或 VARCHAR。请参阅：
unix‑epoch
DOUBLE PRECISION 值，指定自 1970 年 1 月 1 日午夜 (UTC) 以来经过的秒数，不包括闰秒。INTEGER 值被隐式转换为 DOUBLE PRECISION。

注意

  • 在从字符串到 TIMESTAMP 的转换中，毫秒 (MS) 和微秒 (US) 值用作秒小数点后面的部分。例如 TO_TIMESTAMP('12:3', 'SS:MS') 不是指 3 毫秒，而是指 300 毫秒，因为转换将其算作 12 + 0.3 秒。这意味着，对于 SS:MS 格式而言，输入值 12:3、12:30 和 12:300 指定的是相同的毫秒数。要得到 3 毫秒，请使用 12:003，转换将其算作 12 + 0.003 = 12.003 秒。

    下面是一个更为复杂的示例： TO_TIMESTAMP('15:12:02.020.001230', 'HH:MI:SS.MS.US') 表示 15 小时 12 分钟零 2 秒 + 20 毫秒 + 1230 微秒 = 2.021230 秒。

  • 要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'

  • TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：

    • TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。

    • TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。

  • 如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：

    => SELECT TO_DATE('200001131','YYYYMMDD');
  TO_DATE
------------
 2000-01-13
(1 row)

    应在年份后使用非数字分隔符。例如：

    => SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
   TO_DATE
-------------
 20000-12-01
(1 row)

  • 在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。

示例

=> SELECT TO_TIMESTAMP('13 Feb 2009', 'DD Mon YYYY');
    TO_TIMESTAMP
---------------------
 1200-02-13 00:00:00
(1 row)

=> SELECT TO_TIMESTAMP(200120400);
    TO_TIMESTAMP
---------------------
 1976-05-05 01:00:00
(1 row)

另请参阅

日期/时间函数

4.10.6 - TO_TIMESTAMP_TZ

将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP WITH TIME ZONE 类型。

行为类型

不可变（如果是单实参形式）；否则为 稳定。

语法

TO_TIMESTAMP_TZ ( { expression, pattern } | unix‑epoch )

参数

表达式
指定要转换的字符串值，类型为 CHAR 或 VARCHAR。
模式
指定输出模式字符串的 CHAR 或 VARCHAR。请参阅：
unix‑epoch
DOUBLE PRECISION 值，指定自 1970 年 1 月 1 日午夜 (UTC) 以来经过的秒数，不包括闰秒。INTEGER 值被隐式转换为 DOUBLE PRECISION。

注意

  • 在从字符串到 TIMESTAMP 的转换中，毫秒 (MS) 和微秒 (US) 值用作秒小数点后面的部分。例如 TO_TIMESTAMP('12:3', 'SS:MS') 不是指 3 毫秒，而是指 300 毫秒，因为转换将其算作 12 + 0.3 秒。这意味着，对于 SS:MS 格式而言，输入值 12:3、12:30 和 12:300 指定的是相同的毫秒数。要得到 3 毫秒，请使用 12:003，转换将其算作 12 + 0.003 = 12.003 秒。

    下面是一个更为复杂的示例： TO_TIMESTAMP('15:12:02.020.001230', 'HH:MI:SS.MS.US') 表示 15 小时 12 分钟零 2 秒 + 20 毫秒 + 1230 微秒 = 2.021230 秒。

  • 要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'

  • TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：

    • TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。

    • TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。

  • 如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：

    => SELECT TO_DATE('200001131','YYYYMMDD');
  TO_DATE
------------
 2000-01-13
(1 row)

    应在年份后使用非数字分隔符。例如：

    => SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
   TO_DATE
-------------
 20000-12-01
(1 row)

  • 在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。

示例

=> SELECT TO_TIMESTAMP_TZ('13 Feb 2009', 'DD Mon YYY');
    TO_TIMESTAMP_TZ
------------------------
 1200-02-13 00:00:00-05
(1 row)


=> SELECT TO_TIMESTAMP_TZ(200120400);
    TO_TIMESTAMP_TZ
------------------------
 1976-05-05 01:00:00-04
(1 row)

另请参阅

日期/时间函数

4.10.7 - TO_NUMBER

转换字符串值为 DOUBLE PRECISION。

行为类型

稳定

语法

TO_NUMBER ( expression, [ pattern ] )

参数

表达式
指定要转换的字符串值，CHAR 或 VARCHAR。
模式
字符串值，CHAR 或 VARCHAR，它使用支持的 用于数字格式化的模板模式 之一指定输出模式字符串。如果忽略此参数，TO_NUMBER 返回浮点数。

注意

要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'

示例

=> SELECT TO_NUMBER('MCML', 'rn');
TO_NUMBER
-----------
1950
(1 row)

如果省略了 pattern 参数，则函数返回浮点。例如：

=> SELECT TO_NUMBER('-123.456e-01');
 TO_NUMBER
-----------
  -12.3456

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

在输出模板字符串（用于 TO_CHAR）中，某些得到确认的模式会以待格式化值的合适格式化数据替代。非模板模式的文本将逐字复制。同样，在输入模板字符串（用于除 TO_CHAR 之外的任何情形）中，模板模式会识别待查看的输入数据字符串部分，以及要找到的值。

模板模式修饰符

某些修饰符可应用于任何日期/时间模板模式以改变其行为。例如，FMMonth 是带 Month 修饰符的 FM 模式。

示例

使用 TO_TIMESTAMP 来转换使用模式 'YYY MON' 的表达式：

=> SELECT TO_TIMESTAMP('2017 JUN', 'YYYY MON');
    TO_TIMESTAMP
---------------------
 2017-06-01 00:00:00
(1 row)

使用 TO_DATE 来转换使用模式 'YYY-MMDD' 的表达式：

=> SELECT TO_DATE('2017-1231', 'YYYY-MMDD');
  TO_DATE
------------
 2017-12-31
(1 row)

4.10.9 - 用于数字格式化的模板模式

使用

  • 使用 SG、PL 或 MI 格式化的符号不能锚定在数字上。例如：

    => SELECT to_char(-12, 'S9999'), to_char(-12, 'MI9999');
 to_char | to_char
---------+---------
   -12   | -  12
(1 row)

    • TO_CHAR(-12, 'S9999') 生成 ' -12'

    • TO_CHAR(-12, 'MI9999') 生成 '- 12'

  • 由于有 9 个 S，因此会生成 9 个相同位数的值。如果一个数字不可用，则会输出一个空格。

  • TH 不会转换小于 0 的值，而且不会转换分数。

  • V 表示使用输入值乘以 10^n，其中 n 是 V 后面的数字位数。TO_CHAR 不支持使用 V 结合小数点。例如：99.9V99。

4.11 - 地理空间函数

地理空间函数处理复杂的二维空间对象，并根据开放地理空间联盟 (OGC) 标准将它们存储在数据库中。

函数命名约定

地理空间函数使用以下命名约定：

  • 大多数 ST_function‑name 函数符合最新 OGC 标准 OGC SFA-SQL 版本 1.2.1（参考编号为 OGC 06-104r4，日期：2010 年 8 月 4 日）。当前，一些 ST_function‑name 函数可能不支持所有数据类型。每个函数页包含了关于支持的数据类型的详细信息。

  • STV_function‑name 函数专门用于 Vertica 并且不符合 OGC 标准。每个函数页详细说明了其功能。

验证空间对象有效性

许多空间函数不会验证其参数。如果将无效的空间对象传递给 ST_ 或 STV_ 函数，函数可能会返回错误或生成错误的结果。

为避免这种问题，Vertica 建议您首先对所有空间对象运行 ST_IsValid 以验证参数。如果对象无效，则运行 STV_IsValidReason 以获取关于无效性原因的信息。

4.11.1 - ST_AsText

创建空间对象的熟知文本 (WKT) 表示。当需要指定 ASCII 形式的空间对象时可使用此函数。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范定义了 WKT 字符串的格式。

行为类型

不可变

语法

ST_AsText( g )

参数

g
需要获取 WKT 字符串的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

LONG VARCHAR

支持的数据类型

示例

以下示例显示了 ST_AsText 的用法。

检索 WKB 和 WKT 表示：

=> CREATE TABLE locations (id INTEGER, name VARCHAR(100), geom1 GEOMETRY(800),
   geom2 GEOGRAPHY);
CREATE TABLE
=> COPY locations
    (id, geom1x FILLER LONG VARCHAR(800), geom1 AS ST_GeomFromText(geom1x), geom2x FILLER LONG VARCHAR (800),
     geom2 AS ST_GeographyFromText(geom2x))
    FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(2 3)|
>> 2|LINESTRING(2 4,1 5)|
>> 3||POLYGON((-70.96 43.27,-70.67 42.95,-66.90 44.74,-67.81 46.08,-67.81 47.20,-69.22 47.43,-71.09 45.25,-70.96 43.27))
>> \\.
=> SELECT id, ST_AsText(geom1),ST_AsText(geom2) FROM locations ORDER BY id ASC;
 id |       ST_AsText       |                 ST_AsText
----+-----------------------+---------------------------------------------
  1 | POINT (2 3)           |
  2 | LINESTRING (2 4, 1 5) |
  3 |                       | POLYGON ((-70.96 43.27, -70.67 42.95, -66.9 44.74, -67.81 46.08, -67.81 47.2, -69.22 47.43, -71.09 45.25, -70.96 43.27))
(3 rows)

使用 Vertica SQL 函数 LENGTH 计算 WKT 的长度：

=> SELECT LENGTH(ST_AsText(St_GeomFromText('POLYGON ((-1 2, 0 3, 1 2,
                                                      0 1, -1 2))')));
 LENGTH
--------
     37
(1 row)

另请参阅

4.11.2 - ST_Area

计算空间对象的面积。

单位为：

  • GEOMETRY 对象：空间参照系标识符 (SRID) 单位

  • GEOGRAPHY 对象：平方米

行为类型

不可变

语法

ST_Area( g )

参数

g
需要计算面积的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_Area 的用法。

计算多边形的面积：

=> SELECT ST_Area(ST_GeomFromText('POLYGON((0 0,1 0,1 1,0 1,0 0))'));
 ST_Area
---------
       1
(1 row)

计算多边形集合的面积：


=> SELECT ST_Area(ST_GeomFromText('MultiPolygon(((0 0,1 0,1 1,0 1,0 0)),
   ((2 2,2 3,4 6,3 3,2 2)))'));
 ST_Area
---------
     3
(1 row)

如下图所示，假定多边形包含一个孔。

计算不包括孔面积在内的面积：

=> SELECT ST_Area(ST_GeomFromText('POLYGON((2 2,5 5,8 2,2 2),
   (4 3,5 4,6 3,4 3))'));
 ST_Area
---------
       8
(1 row)

计算几何图形集合的面积：

=> SELECT ST_Area(ST_GeomFromText('GEOMETRYCOLLECTION(POLYGON((20.5 20.45,
   20.51 20.52,20.69 20.32,20.5 20.45)),POLYGON((10 20,30 40,25 50,10 20)))'));
 ST_Area
----------
 150.0073
(1 row)

计算地理对象的面积：

=> SELECT ST_Area(ST_GeographyFromText('POLYGON((20.5 20.45,20.51 20.52,
   20.69 20.32,20.5 20.45))'));
     ST_Area
------------------
 84627437.116037
(1 row)

4.11.3 - ST_AsBinary

创建空间对象的熟知二进制 (WKB) 表示。当需要将对象转换为二进制格式以便与其他应用程序移植空间数据时，可使用此函数。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范定义了 WKB 表示的格式。

行为类型

不可变

语法

ST_AsBinary( g )

参数

g
需要获取 WKB 的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

LONG VARBINARY

支持的数据类型

示例

以下示例显示了 ST_AsBinary 的用法。

检索 WKB 和 WKT 表示：

=> CREATE TABLE locations (id INTEGER, name VARCHAR(100), geom1 GEOMETRY(800), geom2 GEOGRAPHY);
CREATE TABLE
=> COPY locations
    (id, geom1x FILLER LONG VARCHAR(800), geom1 AS ST_GeomFromText(geom1x), geom2x FILLER LONG VARCHAR (800),
     geom2 AS ST_GeographyFromText(geom2x))
   FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(2 3)|
>> 2|LINESTRING(2 4,1 5)|
>> 3||POLYGON((-70.96 43.27,-70.67 42.95,-66.90 44.74,-67.81 46.08,-67.81 47.20,-69.22 47.43,-71.09 45.25,-70.96 43.27))
>> \\.
=> SELECT id, ST_AsText(geom1),ST_AsText(geom2) FROM locations ORDER BY id ASC;
 id |       ST_AsText       |                 ST_AsText
----+-----------------------+---------------------------------------------
  1 | POINT (2 3)           |
  2 | LINESTRING (2 4, 1 5) |
  3 |                       | POLYGON ((-70.96 43.27, -70.67 42.95, -66.9 44.74, -67.81 46.08, -67.81 47.2, -69.22 47.43, -71.09 45.25, -70.96 43.27))
=> SELECT id, ST_AsBinary(geom1),ST_AsBinary(geom2) FROM locations ORDER BY id ASC;
.
.
.
(3 rows)

使用 Vertica SQL 函数 LENGTH 计算 WKB 的长度：

=> SELECT LENGTH(ST_AsBinary(St_GeomFromText('POLYGON ((-1 2, 0 3, 1 2,
                                                        0 1, -1 2))')));
 LENGTH
--------
     93
(1 row)

另请参阅

ST_AsText

4.11.4 - ST_Boundary

计算指定 GEOMETRY 对象的边界。对象边界是指定义对象限制的点集。

对于线串，边界是起点和终点。对于多边形，边界是在同一点开始和结束的线串。

行为类型

不可变

语法

ST_Boundary( g )

参数

g
需要计算边界的空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
否

示例

以下示例显示了 ST_Boundary 的用法。

返回表示边界的线串：

=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON((-1 -1,2 2,
   0 1,-1 -1))')));
 ST_AsText
--------------
LINESTRING(-1 -1, 2 2, 0 1, -1 -1)
(1 row)

返回包含两个多边形边界的线串集合：

=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON((2 2,5 5,8 2,2 2),
   (4 3,5 4,6 3,4 3))')));
                            ST_AsText
------------------------------------------------------------------
 MULTILINESTRING ((2 2, 5 5, 8 2, 2 2), (4 3, 5 4, 6 3, 4 3))
(1 row)

线串的边界是其起点和终点：

=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText(
   'LINESTRING(1 1,2 2,3 3,4 4)')));
       ST_AsText
-----------------------
 MULTIPOINT (1 1, 4 4)
(1 row)

封闭的线串没有边界，因为它没有起点和终点：

=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText(
   'LINESTRING(1 1,2 2,3 3,4 4,1 1)')));
    ST_AsText
------------------
 MULTIPOINT EMPTY
(1 row)

4.11.5 - ST_Buffer

创建与某个空间对象边界的距离大于或等于指定距离的 GEOMETRY 对象。该距离使用笛卡尔坐标单位测量。ST_Buffer 不接受大于 +1e15 或小于 –1e15 的距离大小。

行为类型

不可变

语法

ST_Buffer( g, d )

参数

g
需要计算缓冲区的空间对象，类型为 GEOMETRY
d
与对象之间的距离（以笛卡尔坐标单位为单位），类型为 FLOAT

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

使用提示

  • 如果指定正距离，则 ST_Buffer 将返回表示对象外部距离小于或等于指定距离的点的多边形。如果指定负距离，则 ST_Buffer 将返回表示对象内部距离小于或等于指定距离的点的多边形。

  • 对于点、多点、线串和多线串，如果指定负距离，ST_Buffer 将返回空多边形。

  • Vertica Place 版本的 ST_Buffer 将返回多边形形式的缓冲区，因此缓冲区对象在其顶点处包含拐角。它不包含圆角。

示例

以下示例显示了 ST_Buffer 的用法。

返回 GEOMETRY 对象：

=> SELECT ST_AsText(ST_Buffer(ST_GeomFromText('POLYGON((0 1,1 4,4 3,0 1))'),1));
                                  ST_AsText
------------------------------------------------------------------------------
POLYGON ((-0.188847498856 -0.159920845081, -1.12155598386 0.649012935089, 0.290814745534 4.76344136152,
 0.814758063466 5.02541302048, 4.95372324225 3.68665254814, 5.04124517538 2.45512549204, -0.188847498856 -0.159920845081))
(1 row)

4.11.6 - ST_Centroid

计算空间对象的几何中心（即质心）。如果几何图形除多边形外还存在点、线串或同时存在此二者，则质心计算仅考虑多边形。类似地，如果除线串外还存在点，则质心计算不考虑点。

要计算 GEOGRAPHY 对象的质心，请参阅 STV_Geometry 和 STV_Geography 的示例。

行为类型

不可变

语法

ST_Centroid( g )

参数

g
需要计算质心的空间对象，类型为 GEOMETRY

返回

GEOMETRY（仅 POINT）

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Centroid 的用法。

计算多边形的质心：

=> SELECT ST_AsText(ST_Centroid(ST_GeomFromText('POLYGON((-1 -1,2 2,-1 2,
   -1 -1))')));
  ST_AsText
------------
 POINT (-0 1)
(1 row)

计算多边形集合的质心：

=> SELECT ST_AsText(ST_Centroid(ST_GeomFromText('MULTIPOLYGON(((1 0,2 1,2 0,
   1 0)),((-1 -1,2 2,-1 2,-1 -1)))')));
               ST_AsText
--------------------------------------
 POINT (0.166666666667 0.933333333333)
(1 row)

此图显示了多边形集合的质心。

4.11.7 - ST_Contains

确定空间对象是否完全在另一个空间对象内部，并且不仅仅在其边界上存在。两个参数必须是相同的空间数据类型。要么指定两个 GEOMETRY 对象，要么指定两个 GEOGRAPHY 对象。

如果某个对象（例如点或线串）仅沿空间对象的边界存在，则 ST_Contains 将返回 False。线串的内部是线串上除起点和终点以外的所有点。

ST_Contains(g1, g2) 在功能上等同于 ST_Within(g2, g1)。

不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。

行为类型

不可变

语法

ST_Contains( g1, g2
                        [USING PARAMETERS spheroid={true | false}] )

参数

g1
空间对象，类型为 GEOMETRY 或 GEOGRAPHY
g2
空间对象，类型为 GEOMETRY 或 GEOGRAPHY

参数

spheroid = {true | false}

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

示例

以下示例显示了 ST_Contains 的用法。

第一个多边形未完全包含第二个多边形：

=> SELECT ST_Contains(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'),
   ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))'));
 ST_Contains
-------------
 f
(1 row)

如果点在线串上，但不在终点上：

=> SELECT ST_Contains(ST_GeomFromText('LINESTRING(20 20,30 30)'),
   ST_GeomFromText('POINT(25 25)'));
 ST_Contains
--------------
 t
(1 row)

如果点在多边形的边界上：

=> SELECT ST_Contains(ST_GeographyFromText('POLYGON((20 20,30 30,30 25,20 20))'),
   ST_GeographyFromText('POINT(20 20)'));
 ST_Contains
--------------
 f
(1 row)

两个在空间上等效的多边形：

=> SELECT ST_Contains (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
   ST_GeomFromText('POLYGON((0 3, -1 2, 0 1, 0 3))'));
 ST_Contains
--------------
 t
(1 row)

另请参阅

4.11.8 - ST_ConvexHull

计算包含 GEOMETRY 对象的最小凸 GEOMETRY 对象。

行为类型

不可变

语法

ST_ConvexHull( g )

参数

g
需要求取凸包的空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_ConvexHull 的用法。

对于几何图形集合中的点对：

=> SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText('GEOMETRYCOLLECTION(
   POINT(1 1),POINT(0 0))')));
       ST_AsText
-----------------------
 LINESTRING (1 1, 0 0)
(1 row)

对于几何图形集合：

=> SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText('GEOMETRYCOLLECTION(
   LINESTRING(2.5 3,-2 1.5), POLYGON((0 1,1 3,1 -2,0 1)))')));
                  ST_AsText
---------------------------------------------
 POLYGON ((1 -2, -2 1.5, 1 3, 2.5 3, 1 -2))
(1 row)

实线表示原始几何图形集合，虚线表示凸包。

4.11.9 - ST_Crosses

确定一个 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上交叉。如果两个对象仅在边界上接触，则 ST_Crosses 将返回 FALSE。

如果以下两项均成立，则表示两个对象在空间上交叉：

  • 两个对象具有部分但非全部的公共内点。

  • 它们的相交结果的尺寸小于两个对象的最大尺寸。

行为类型

不可变

语法

ST_Crosses( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

BOOLEAN

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Crosses 的用法。

=> SELECT ST_Crosses(ST_GeomFromText('LINESTRING(-1 3,1 4)'),
   ST_GeomFromText('LINESTRING(-1 4,1 3)'));
 ST_Crosses
------------
 t
(1 row)


=> SELECT ST_Crosses(ST_GeomFromText('LINESTRING(-1 1,1 2)'),
   ST_GeomFromText('POLYGON((1 1,0 -1,3 -1,2 1,1 1))'));
 ST_Crosses
------------
 f
(1 row)


=> SELECT ST_Crosses(ST_GeomFromText('POINT(-1 4)'),
   ST_GeomFromText('LINESTRING(-1 4,1 3)'));
ST_ Crosses
------------
 f
(1 row)

4.11.10 - ST_Difference

计算空间对象没有与另一个空间对象相交的部分。

行为类型

不可变

语法

ST_Difference( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Difference 的用法。

两个重叠的线串：

=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('LINESTRING(0 0,0 2)'),
   ST_GeomFromText('LINESTRING(0 1,0 2)')));
       ST_AsText
-----------------------
 LINESTRING (0 0, 0 1)
(1 row)
=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('LINESTRING(0 0,0 3)'),
   ST_GeomFromText('LINESTRING(0 1,0 2)')));
                ST_AsText
------------------------------------------
 MULTILINESTRING ((0 0, 0 1), (0 2, 0 3))
(1 row)

两个重叠的多边形：

=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('POLYGON((0 1,0 3,2 3,2 1,0 1))'),
   ST_GeomFromText('POLYGON((0 0,0 2,2 2,2 0,0 0))')));
            ST_AsText
-------------------------------------
 POLYGON ((0 2, 0 3, 2 3, 2 2, 0 2))
(1 row)

两个未相交的多边形：

=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('POLYGON((1 1,1 3,3 3,3 1,
   1 1))'),ST_GeomFromText('POLYGON((1 5,1 7,-1 7,-1 5,1 5))')));
              ST_AsText
-------------------------------------
 POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))
(1 row)

4.11.11 - ST_Disjoint

确定两个 GEOMETRY 对象是否未相交也未接触。

如果 ST_Disjoint 针对一对 GEOMETRY 对象返回 TRUE，则 ST_Intersects 将针对这两个相同的对象返回 FALSE。

不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。

行为类型

不可变

语法

ST_Disjoint( g1, g2
                         [USING PARAMETERS spheroid={true | false}] )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

参数

spheroid = {true | false}

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

数据类型
GEOGRAPHY (WGS84)
Point-Point
否
Linestring-Point
否
Polygon-Point
是
Multipolygon-Point
否

示例

以下示例显示了 ST_Disjoint 的用法。

两个未相交或接触的多边形：

=> SELECT ST_Disjoint (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((1 0, 1 1, 2 2, 1 0))'));
 ST_Disjoint
-------------
 t
(1 row)

两个相交的线串：

=> SELECT ST_Disjoint(ST_GeomFromText('LINESTRING(-1 2,0 3)'),
   ST_GeomFromText('LINESTRING(0 2,-1 3)'));
 ST_Disjoint
-------------
 f
(1 row)

两个在一个点接触的多边形：

=> SELECT ST_Disjoint (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
   ST_GeomFromText('POLYGON((0 2, 1 1, 1 2, 0 2))'));
 ST_Disjoint
--------------
 f
(1 row)

另请参阅

4.11.12 - ST_Distance

计算两个空间对象之间的最短距离。对于 GEOMETRY 对象，距离使用笛卡尔坐标单位测量。对于 GEOGRAPHY 对象，距离以米为单位测量。

g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。

行为类型

不可变

语法

ST_Distance( g1, g2
        [USING PARAMETERS spheroid={ true | false } ] )

参数

g1
空间对象，类型为 GEOMETRY 或 GEOGRAPHY
g2
空间对象，类型为 GEOMETRY 或 GEOGRAPHY

参数

spheroid = { true | false }

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

FLOAT

支持的数据类型

兼容的 GEOGRAPHY 对：

建议

Vertica 建议在使用 ST_Distance 之前裁剪无效的数据。无效的地理值可能返回无保证的结果。

示例

以下示例显示了 ST_Distance 的用法。

两个多边形之间的距离：

=> SELECT ST_Distance(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
                      ST_GeomFromText('POLYGON((5 2,7 4,5 5,5 2))'));
 ST_Distance
-------------
           3
(1 row)

点和线串之间的距离（以米为单位）：

=> SELECT ST_Distance(ST_GeographyFromText('POINT(31.75 31.25)'),
    ST_GeographyFromText('LINESTRING(32 32,32 35,40.5 35,32 35,32 32)'));
   ST_Distance
------------------
 86690.3950562969
(1 row)

4.11.13 - ST_Envelope

计算包含指定的 GEOMETRY 对象的最小边界矩形。

行为类型

不可变

语法

ST_Envelope( g )

参数

g
需要求取最小边界矩形的空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Envelope 的用法。

返回最小边界矩形：

=> SELECT ST_AsText(ST_Envelope(ST_GeomFromText('POLYGON((0 0,1 1,1 2,2 2,
   2 1,3 0,1.5 -1.5,0 0))')));
                 ST_AsText
-------------------------------------------
 POLYGON ((0 -1.5, 3 -1.5, 3 2, 0 2, 0 -1.5))
(1 row)

4.11.14 - ST_Equals

确定两个空间对象在空间上是否等效。ST_Equals 的两个对象的坐标及其 WKT/WKB 表示必须完全匹配才能返回 TRUE。

在确定空间等价关系时点的顺序不重要：

  • LINESTRING(1 2, 4 3) 等于 LINESTRING(4 3, 1 2)。

  • POLYGON ((0 0, 1 1, 1 2, 2 2, 2 1, 3 0, 1.5 -1.5, 0 0)) 等于 POLYGON((1 1 , 1 2, 2 2, 2 1, 3 0, 1.5 -1.5, 0 0, 1 1))。

  • MULTILINESTRING((1 2, 4 3),(0 0, -1 -4)) 等于 MULTILINESTRING((0 0, -1 -4),(1 2, 4 3))。

坐标存储为 FLOAT 类型。因此，在导入熟知文本 (WKT) 值时，由于浮点数表示的限制，预期会出现舍入误差。

g1 和 g2 必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。此外，g1 和 g2 不能都是 GeometryCollection 类型。

行为类型

不可变

语法

ST_Equals( g1, g2 )

参数

g1
要与 g2 相比的空间对象，类型为 GEOMETRY 或 GEOGRAPHY
g2
要与 g1 相比的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

BOOLEAN

支持的数据类型

示例

以下示例显示了 ST_Equals 的用法。

两个线串：

=> SELECT ST_Equals (ST_GeomFromText('LINESTRING(-1 2, 0 3)'),
   ST_GeomFromText('LINESTRING(0 3, -1 2)'));
 ST_Equals
--------------
 t
(1 row)

两个多边形：

=> SELECT ST_Equals (ST_GeographyFromText('POLYGON((43.22 42.21,40.3 39.88,
   42.1 50.03,43.22 42.21))'),ST_GeographyFromText('POLYGON((43.22 42.21,
   40.3 39.88,42.1 50.31,43.22 42.21))'));
 ST_Equals
--------------
 f
(1 row)

4.11.15 - ST_GeographyFromText

将熟知文本 (WKT) 字符串转换为其对应的 GEOGRAPHY 对象。使用此函数可将 WKT 字符串转换为 Vertica Place 函数所需的格式。

GEOGRAPHY 对象是在地球表面使用坐标 (longitude, latitude) 定义的空间对象。坐标使用划分地球的参考平面的度数（经度、纬度）表示。

GEOGRAPHY 对象的最大大小为 10 MB。如果将 WKT 传递给 ST_GeographyFromText 并且生成大小超过 10 MB 的空间对象，ST_GeographyFromText 将会返回错误。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 7 节定义了 WKT 字符串的格式。

行为类型

不可变

语法

ST_GeographyFromText( wkt [ USING PARAMETERS ignore_errors={'y'|'n'} ] )

参数

wkt
GEOGRAPHY 对象的熟知文本 (WKT) 字符串，类型为 LONG VARCHAR
ignore_errors
（可选）ST_GeographyFromText 将基于提供的参数返回以下结果：

  • NULL—如果 wkt 无效并且 ignore_errors='y'。

  • Error—如果 wkt 无效并且 ignore_errors='n' 或未指定。

返回

GEOGRAPHY

支持的数据类型

示例

以下示例显示了 ST_GeographyFromText 的用法。

将 WKT 转换为 GEOGRAPHY 对象：

=> CREATE TABLE wkt_ex (g GEOGRAPHY);
 CREATE TABLE
=> INSERT INTO wkt_ex VALUES(ST_GeographyFromText('POLYGON((1 2,3 4,2 3,1 2))'));
 OUTPUT
--------
      1
(1 row)

4.11.16 - ST_GeographyFromWKB

将熟知二进制 (WKB) 值转换为其对应的 GEOGRAPHY 对象。使用此函数可将 WKB 转换为 Vertica Place 函数所需的格式。

GEOGRAPHY 对象是在地球表面定义的空间对象。坐标使用划分地球的参考平面的度数（经度、纬度）表示。所有的计算都以米为单位。

GEOGRAPHY 对象的最大大小为 10 MB。如果将 WKB 传递给 ST_GeographyFromWKB 并且生成大小超过 10 MB 的空间对象，ST_GeographyFromWKB 将会返回错误。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 8 节定义了 WKB 表示的格式。

行为类型

不可变

语法

ST_GeographyFromWKB( wkb [ USING PARAMETERS ignore_errors={'y'|'n'} ] )

参数

wkb
GEOGRAPHY 对象的熟知二进制 (WKB) 值，类型为 LONG VARBINARY
ignore_errors
（可选）ST_GeographyFromWKB 基于提供的参数返回以下结果：

  • NULL—如果 wkb 无效并且 ignore_errors='y'。

  • Error—如果 wkb 无效并且 ignore_errors='n' 或未指定。

返回

GEOGRAPHY

支持的数据类型

示例

以下示例显示了 ST_GeographyFromWKB 的用法。

将 WKB 转换为 GEOGRAPHY 对象：

=> CREATE TABLE wkb_ex (g GEOGRAPHY);
CREATE TABLE
=> INSERT INTO wkb_ex VALUES(ST_GeographyFromWKB(X'0103000000010000000 ... );
 OUTPUT
--------
      1
(1 row)

4.11.17 - ST_GeoHash

以指定的几何图形形状返回 GeoHash。

行为类型

不可变

语法

ST_GeoHash( SpatialObject [ USING PARAMETERS numchars=n] )

参数

Spatial object
GEOMETRY 或 GEOGRAPHY 空间对象。对于给定几何图形内的所有点，输入必须采用极坐标（-180 <= x <= 180 和 -90 <= y <= 90）。
n
指定返回的 GeoHash 的长度（以字符为单位）。

返回

GEOHASH

支持的数据类型

示例

以下示例显示了如何使用 ST_PointFromGeoHash。

为指定几何图形生成全精度 GeoHash：

=> SELECT ST_GeoHash(ST_GeographyFromText('POINT(3.14 -1.34)'));
ST_GeoHash
----------------------
kpf0rkn3zmcswks75010
(1 row)

根据指定几何图形的前五个字符生成 GeoHash：

=>  select ST_GeoHash(ST_GeographyFromText('POINT(3.14 -1.34)')USING PARAMETERS numchars=5);
ST_GeoHash
------------
kpf0r
(1 row)

4.11.18 - ST_GeometryN

返回几何图形对象内的第 n 个几何图形。

如果 n 超出索引范围，则返回 NULL。

行为类型

不可变

语法

ST_GeometryN( g , n )

参数

g
GEOMETRY 类型的空间对象。
n
几何图形的索引号，从 1 开始。

返回

GEOMETRY

支持的数据类型

示例

以下示例显示了 ST_GeometryN 的用法。

返回多边形集合中的第二个几何图形：

=> CREATE TABLE multipolygon_geom (gid int, geom GEOMETRY(1000));
CREATE TABLE
=> COPY multipolygon_geom(gid, gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>9|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\.
=> SELECT gid, ST_AsText(ST_GeometryN(geom, 2)) FROM multipolygon_geom;
 gid |           ST_AsText
-----+--------------------------------
   9 | POLYGON ((0 0, 0 5, 1 0, 0 0))
(1 row)

返回多边形集合内的所有几何图形：


=> CREATE TABLE multipolygon_geom (gid int, geom GEOMETRY(1000));
CREATE TABLE
=> COPY multipolygon_geom(gid, gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>9|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\.
=> CREATE TABLE series_numbers (numbs int);
CREATE TABLE
=> COPY series_numbers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1
>> 2
>> 3
>> 4
>> 5
>> \.
=> SELECT numbs, ST_AsText(ST_GeometryN(geom, numbs))
   FROM multipolygon_geom, series_numbers
   WHERE ST_AsText(ST_GeometryN(geom, numbs)) IS NOT NULL
   ORDER BY numbs ASC;
 numbs |                ST_AsText
-------+------------------------------------------
     1 | POLYGON ((2 6, 2 9, 6 9, 7 7, 4 6, 2 6))
     2 | POLYGON ((0 0, 0 5, 1 0, 0 0))
     3 | POLYGON ((0 2, 2 5, 4 5, 0 2))
(3 rows)

另请参阅

ST_NumGeometries

4.11.19 - ST_GeometryType

确定空间对象的类。

行为类型

不可变

语法

ST_GeometryType( g )

参数

g
需要确定类的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

VARCHAR

支持的数据类型

示例

以下示例显示了 ST_GeometryType 的用法。

返回空间类：

=> SELECT ST_GeometryType(ST_GeomFromText('GEOMETRYCOLLECTION(LINESTRING(1 1,
   2 2), POLYGON((1 3,4 5,2 2,1 3)))'));
    ST_GeometryType
-----------------------
 ST_GeometryCollection
(1 row)

4.11.20 - ST_GeomFromGeoHash

以指定的 GeoHash 形状返回多边形。

行为类型

不可变

语法

ST_GeomFromGeoHash(GeoHash)

参数

GeoHash
任意长度的有效 GeoHash 字符串。

返回

GEOGRAPHY

示例

以下示例显示了如何使用 ST_GeomFromGeoHash。

将 GeoHash 字符串转换为 Geography 对象并转换回 GeoHash

=>  SELECT ST_GeoHash(ST_GeomFromGeoHash(‘vert1c9’));
ST_GeoHash
--------------------
vert1c9
(1 row)

返回指定 GeoHash 的多边形并使用 ST_AsText 将多边形、矩形图块转换为熟知文本：

=>  SELECT ST_AsText(ST_GeomFromGeoHash('drt3jj9n4dpcbcdef'));
ST_AsText
------------------------------------------------------------------------------------------------------------------------------------------------------------------
POLYGON ((-71.1459699298 42.3945346513, -71.1459699297 42.3945346513, -71.1459699297 42.3945346513, -71.1459699298 42.3945346513, -71.1459699298 42.3945346513))
(1 row)

返回指定 GeoHash 的多个多边形及其面积。高级 GeoHash (1234) 的多边形面积很大，而低级 GeoHash (1234567890bcdefhjkmn) 的面积为零。

=>  SELECT ST_Area(short) short_area, ST_AsText(short) short_WKT, ST_Area(long) long_area, ST_AsText(long) long_WKT from (SELECT ST_GeomFromGeoHash('1234') short, ST_GeomFromGeoHash('1234567890bcdefhjkmn') long) as foo;
-[ RECORD 1 ]---------------------------------------------------------------------------------------------------------------------------------------------------------------------
short_area | 24609762.8991076
short_WKT  | POLYGON ((-122.34375 -88.2421875, -121.9921875 -88.2421875, -121.9921875 -88.06640625, -122.34375 -88.06640625, -122.34375 -88.2421875))
long_area  | 0
long_WKT   | POLYGON ((-122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551))

4.11.21 - ST_GeomFromGeoJSON

将标准格式的 GeoJSON 记录的几何图形部分转换为 GEOMETRY 对象。当您提供 GeoJSON 功能或 FeatureCollection 对象时，此函数会返回错误。

行为类型

不可变

语法

ST_GeomFromGeoJSON( geojson [, srid] [ USING PARAMETERS param=value[,...] ] );

参数

geojson
包含 GeoJSON GEOMETRY 对象的字符串，类型为 LONG VARCHAR。

Vertica 接受以下 GeoJSON 键值：

  • 类型

  • 坐标

  • 几何形状

其他键值被忽略。

srid

GEOMETRY 对象的空间参照系标识符 (SRID)，类型为 INTEGER。

SRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。

该实参在不执行操作时是可选的。

参数

ignore_3d
（可选）布尔值，是从返回的 GEOMETRY 对象中静默移除 3D 和更高维数据还是返回错误，取决于以下值：

  • true：从返回的 GEOMETRY 对象中移除 3D 和更高维数据。

  • false（默认值）：当 GeoJSON 包含 3D 或更高维数据时返回错误。

ignore_errors
（可选）布尔值，是忽略无效 GeoJSON 对象上的错误还是返回错误，取决于以下值：

  • true：在 GeoJSON 解析期间忽略错误并返回 NULL。

  • false（默认值）：如果 GeoJSON 解析失败，则返回错误。

返回

GEOMETRY

支持的数据类型

  • Point

  • Multipoint

  • Linestring

  • Multilinestring

  • Polygon

  • Multipolygon

  • GeometryCollection

示例

以下示例显示了如何使用 ST_GeomFromGeoJSON。

验证单个记录

以下示例使用 ST_IsValid 验证 ST_GeomFromGeoJSON 语句。该语句包含 SRID 4326 以指示点数据类型表示纬度和经度坐标，并将 ignore_3d 设置为 true 以忽略表示高度的最后一个值：

=> SELECT ST_IsValid(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[35.3606, 138.7274, 29032]}', 4326 USING PARAMETERS ignore_3d=true));
 ST_IsValid
------------
 t
(1 row)

将数据加载到表中

以下示例处理来自 STDIN 的 GeoJSON 类型并将它们存储在 GEOMETRY 数据类型表列中：

  1. 创建一个名为 polygons 的表，用于存储 GEOMETRY 空间类型：

    => CREATE TABLE polygons(geom GEOMETRY(1000));
CREATE TABLE

  2. 使用 COPY 从 STDIN 读取支持的 GEOMETRY 数据类型并将它们存储在名为 geom 的对象中：

    => COPY polygons(geojson filler VARCHAR(1000), geom as ST_GeomFromGeoJSON(geojson)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> { "type": "Polygon", "coordinates": [ [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ] ] }
>> { "type": "Point", "coordinates": [1, 2] }
>> { "type": "Polygon", "coordinates": [ [ [1, 3], [3, 2], [1, 1], [3, 0], [1, 0], [1, 3] ] ] }
>> \.

  3. 查询 polygons 表。下面的示例使用 ST_AsText 返回 geom 对象的 熟知文本 (WKT) 表示形式，并且使用 ST_IsValid 来验证每个对象：

    => SELECT ST_AsText(geom), ST_IsValid(geom) FROM polygons;
                   ST_AsText                   | ST_IsValid
-----------------------------------------------+------------
 POINT (1 2)                                   | t
 POLYGON ((1 3, 3 2, 1 1, 3 0, 1 0, 1 3))      | f
 POLYGON ((100 0, 101 0, 101 1, 100 1, 100 0)) | t
(3 rows)

4.11.22 - ST_GeomFromText

将熟知文本 (WKT) 字符串转换为其对应的 GEOMETRY 对象。使用此函数可将 WKT 字符串转换为 Vertica Place 函数所需的格式。

GEOMETRY 对象是按平面坐标定义的空间对象。坐标表示为笛卡尔平面上的点 (x,y)。SRID 值为 0 至 232-1 是有效的。超出此范围的 SRID 值将会生成错误。

GEOMETRY 对象的最大大小为 10 MB。如果将 WKT 传递给 ST_GeomFromText 并且生成大小超过 10 MB 的空间对象，ST_GeomFromText 将会返回错误。

开放地理空间联盟 (OGC) 定义了 WKT 表示的格式。请参见 简易功能访问第 1 部分 - 通用架构规范第 7 节。

行为类型

不可变

语法

ST_GeomFromText( wkt [, srid] [ USING PARAMETERS ignore_errors={'y'|'n'} ])

参数

wkt
GEOMETRY 对象的熟知文本 (WKT) 字符串，类型为 LONG VARCHAR。
srid
（不执行操作时可选）

GEOMETRY 对象的空间参照系标识符 (SRID)，类型为 INTEGER。

SRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。

ignore_errors
（可选）ST_GeomFromText 将基于提供的参数返回以下结果：

  • NULL—如果 wkt 无效并且 ignore_errors='y'。

  • Error—如果 wkt 无效并且 ignore_errors='n' 或未指定。

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
否

示例

以下示例显示了 ST_GeomFromText 的用法。

将 WKT 转换为 GEOMETRY 对象：


=> SELECT ST_Area(ST_GeomFromText('POLYGON((1 1,2 3,3 5,0 5,1 -2,0 0,1 1))'));
 ST_Area
---------
       6
(1 row)

4.11.23 - ST_GeomFromWKB

将熟知二进制 (WKB) 值转换为其对应的 GEOMETRY 对象。使用此函数可将 WKB 转换为许多 Vertica Place 函数所需的格式。

GEOMETRY 对象是在笛卡尔平面中定义的使用 (x,y) 坐标的空间对象。

GEOMETRY 对象的最大大小为 10 MB。如果将 WKB 传递给 ST_GeomFromWKB 并且生成大小超过 10 MB 的空间对象，ST_GeomFromWKB 将会返回错误。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 8 节定义了 WKB 表示的格式。

行为类型

不可变

语法

ST_GeomFromWKB( wkb[, srid] [ USING PARAMETERS ignore_errors={'y'|'n'} ])

参数

wkb
GEOMETRY 对象的熟知二进制 (WKB) 值，类型为 LONG VARBINARY
srid
（可选）GEOMETRY 对象的空间参照系标识符 (SRID)，类型为 INTEGER。

SRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。

ignore_errors
（可选）ST_GeomFromWKB 将基于提供的参数返回以下结果：

  • NULL—如果 wkb 无效并且 ignore_errors='y'。

  • Error—如果 wkb 无效并且 ignore_errors='n' 或未指定。

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_GeomFromWKB 的用法。

将 GEOMETRY 转换为 WKT：

=> CREATE TABLE t(g GEOMETRY);
CREATE TABLE
=> INSERT INTO t VALUES(
ST_GeomFromWKB(X'0103000000010000000400000000000000000000000000000000000000000000000000f
               03f0000000000000000f64ae1c7022db544000000000000f03f00000000000000000000000000000000'));
 OUTPUT
--------
      1
(1 row)
=> SELECT ST_AsText(g) from t;
             ST_AsText
------------------------------------
 POLYGON ((0 0, 1 0, 1e+23 1, 0 0))
(1 row)

4.11.24 - ST_Intersection

计算两个 GEOMETRY 对象共有的点集。

行为类型

不可变

语法

ST_Intersection( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Intersection 的用法。

两个多边形相交于一个点：

=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,
   0 2))'),ST_GeomFromText('POLYGON((-1 2,0 0,-2 0,-1 2))')));
    ST_AsText
-----------------
 POINT(0 0)
(1 row)

两个多边形：

=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('POLYGON((1 2,1 5,4 5,
   4 2,1 2))'), ST_GeomFromText('POLYGON((3 1,3 3,5 3,5 1,3 1))')));
 ST_AsText
------------------
POLYGON ((4 3, 4 2, 3 2, 3 3, 4 3))
(1 row)

两个未相交的线串：

=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('LINESTRING(1 1,1 3,3 3)'),
   ST_GeomFromText('LINESTRING(1 5,1 7,-1 7)')));
        ST_AsText
--------------------------
 GEOMETRYCOLLECTION EMPTY
(1 row)

4.11.25 - ST_Intersects

确定两个 GEOMETRY 或 GEOGRAPHY 对象是否在一个点相交或接触。对于相同的 GEOMETRY 或 GEOGRAPHY 对象，如果 ST_Disjoint 返回 TRUE，则 ST_Intersects 将返回 FALSE。

不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。

行为类型

不可变

语法

ST_Intersects( g1, g2
                  [USING PARAMETERS bbox={true | false}, spheroid={true | false}])

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

参数

bbox = {true | false}
Boolean。与 g1 和 g2 的边界框相交。

默认值： False

spheroid = {true | false}

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

数据类型
GEOGRAPHY (WGS84)
Point-Point
否
Linestring-Point
否
Polygon-Point
是
Multipolygon-Point
否

示例

以下示例显示了 ST_Intersects 的用法。

两个多边形未相交或接触：

=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((1 0,1 1,2 2,1 0))'));
 ST_Intersects
--------------
 f
(1 row)

两个多边形在一个点接触：

=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((1 0,1 1,0 1,1 0))'));
 ST_Intersects
--------------
 t
(1 row)

两个多边形相交：

=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
   ST_GeomFromText('POLYGON((0 2, -1 3, -2 0, 0 2))'));
 ST_Intersects
--------------
 t
(1 row)

另请参阅

ST_Disjoint

4.11.26 - ST_IsEmpty

确定空间对象是否表示空集。空对象没有维度。

行为类型

不可变

语法

ST_IsEmpty( g )

参数

g
空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

BOOLEAN

支持的数据类型

示例

以下示例显示了 ST_IsEmpty 的用法。

空多边形：

=> SELECT ST_IsEmpty(ST_GeomFromText('GeometryCollection EMPTY'));
 ST_IsEmpty
------------
 t
(1 row)

4.11.27 - ST_IsSimple

确定空间对象是否未与自身相交，也未接触其自身边界上的任何点。

行为类型

不可变

语法

ST_IsSimple( g )

参数

g
空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

BOOLEAN

支持的数据类型

示例

以下示例显示了 ST_IsSimple 的用法。

多边形未与自身相交：

=> SELECT ST_IsSimple(ST_GeomFromText('POLYGON((-1 2,0 3,1 2,1 -2,-1 2))'));
 ST_IsSimple
--------------
 t
(1 row)

线串与自身相交：

=> SELECT ST_IsSimple(ST_GeographyFromText('LINESTRING(10 10,25 25,26 34.5,
   10 30,10 20,20 10)'));
 St_IsSimple
-------------
 f
(1 row)

线串在一个或多个位置接触其内部：

=> SELECT ST_IsSimple(ST_GeomFromText('LINESTRING(0 0,0 1,1 0,2 1,2 0,0 0)'));
 ST_IsSimple
-------------
 f
(1 row)

4.11.28 - ST_IsValid

确定空间对象的格式是否正确或其是否有效。如果对象有效，则 ST_IsValid 返回 TRUE；否则它将返回 FALSE。使用 STV_IsValidReason 以确定无效性原因。

空间有效性仅适用于多边形和多边形集合。如果以下所有项均成立，则多边形或多边形集合是有效的：

  • 多边形是封闭的；其起点与终点相同。

  • 其边界是一组线串。

  • 边界不触及或穿越本身。

  • 内部的任何多边形都未接触外部多边形边界除顶点以外的任何位置。

开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 6.1.11.1 节定义了多边形的有效性。

如果不确定多边形是否有效，请先运行 ST_IsValid。如果将无效的空间对象传递给 Vertica Place 函数，函数将会失败或返回错误的结果。

行为类型

不可变

语法

ST_IsValid( g )

参数

g
用于测试有效性的地理空间对象，其值类型为 GEOMETRY 或 GEOGRAPHY (WGS84)。

返回

BOOLEAN

支持的数据类型

示例

以下示例显示了 ST_IsValid 的用法。

有效的多边形：

=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,1 3,3 3,3 1,1 1))'));
 ST_IsValid
------------
 t
(1 row)

无效的多边形：

=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 3,3 2,1 1,3 0,1 0,1 3))'));
 ST_IsValid
------------
 f
(1 row)

无效的多边形：

=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((0 0,2 2,0 2,2 0,0 0))'));
 ST_IsValid
------------
 f
(1 row)

无效的多边形集合：

=> SELECT ST_IsValid(ST_GeomFromText('MULTIPOLYGON(((0 0, 0 1, 1 1, 0 0)),
   ((0.5 0.5, 0.7 0.5, 0.7 0.7, 0.5 0.7, 0.5 0.5)))'));
 ST_IsValid
------------
 f
(1 row)

包含孔的有效多边形：

=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,3 3,6 -1,0.5 -1,1 1),
   (1 1,3 1,2 0,1 1))'));
 ST_IsValid
------------
 t
(1 row)

包含孔的无效多边形：

=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,3 3,6 -1,0.5 -1,1 1),
   (1 1,4.5 1,2 0,1 1))'));
 ST_IsValid
------------
 f
(1 row)

4.11.29 - ST_Length

计算空间对象的长度。对于 GEOMETRY 对象，长度使用笛卡尔坐标单位测量。对于 GEOGRAPHY 对象，长度以米为单位测量。

按以下方法计算长度：

  • 点或点集合对象的长度为 0。

  • 线串的长度是每个线段的长度之和；而线段的长度是起点到终点的距离。

  • 多边形的长度是外部边界和任何内部边界的长度之和。

  • 线串集合、多边形集合或 geometrycollection 的长度是它所包含的所有对象的长度之和。

行为类型

不可变

语法

ST_Length( g )

参数

g
需要计算长度的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_Length 的用法。

返回以笛卡尔坐标单位为单位的长度：

=> SELECT ST_Length(ST_GeomFromText('LINESTRING(-1 -1,2 2,4 5,6 7)'));
    ST_Length
------------------
 10.6766190873295
(1 row)

返回以米为单位的长度：

=> SELECT ST_Length(ST_GeographyFromText('LINESTRING(-56.12 38.26,-57.51 39.78,
   -56.37 45.24)'));
    ST_Length
------------------
 821580.025733461
(1 row)

4.11.30 - ST_NumGeometries

返回空间对象内包含的几何图形数量。单个 GEOMETRY 或 GEOGRAPHY 对象将返回 1，空对象将返回 NULL。

行为类型

不可变

语法

ST_NumGeometries( g )

参数

g

GEOMETRY 或 GEOGRAPHY 类型的空间对象

返回

INTEGER

支持的数据类型

示例

以下示例显示了 ST_NumGeometries 的用法。

返回几何图形的数量：


=> SELECT ST_NumGeometries(ST_GeomFromText('MULTILINESTRING ((1 5, 2 4, 5 3, 6 6), (3 5, 3 7))'));
 ST_NumGeometries
------------------
                2
(1 row)

另请参阅

ST_GeometryN

4.11.31 - ST_NumPoints

计算空间对象的顶点数，空对象则返回 NULL。

多边形和多边形集合的第一个顶点和最后一个顶点单独计数。

行为类型

不可变

语法

ST_NumPoints( g )

参数

g
需要计数顶点的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

INTEGER

支持的数据类型

示例

以下示例显示了 ST_NumPoints 的用法。

返回线串中的顶点数：

=> SELECT ST_NumPoints(ST_GeomFromText('LINESTRING(1.33 1.56,2.31 3.4,2.78 5.82,
   3.76 3.9,4.11 3.27,5.85 4.34,6.9 4.231,7.61 5.77)'));
 ST_NumPoints
--------------
            8
(1 row)

使用 ST_Boundary 和 ST_NumPoints 返回多边形的顶点数：

=> SELECT ST_NumPoints(ST_Boundary(ST_GeomFromText('POLYGON((1 2,1 4,
   2 5,3 6,4 6,5 5,4 4,3 3,1 2))')));
 ST_NumPoints
--------------
            9
(1 row)

4.11.32 - ST_Overlaps

确定 GEOMETRY 对象是否与另一个 GEOMETRY 对象共享空间但未完全包含在该对象范围内。它们必须在其内部重叠。如果两个对象在单个点接触，或仅仅沿边界相交，则二者没有重叠。两个参数必须具有相同的维度；否则 ST_Overlaps 将返回 FALSE。

行为类型

不可变

语法

ST_Overlaps ( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

BOOLEAN

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Overlaps 的用法。

Polygon_1 与 Polygon_2 重叠但未完全包含 Polygon_2：

=> SELECT ST_Overlaps(ST_GeomFromText('POLYGON((0 0, 0 1, 1 1, 0 0))'),
   ST_GeomFromText('POLYGON((0.5 0.5, 0.7 0.5, 0.7 0.7, 0.5 0.7, 0.5 0.5))'));
 ST_Overlaps
-------------
 t
(1 row)

具有不同维度的两个对象：

=> SELECT ST_Overlaps(ST_GeomFromText('LINESTRING(2 2,4 4)'),
   ST_GeomFromText('POINT(3 3)'));
 ST_Overlaps
-------------
 f
(1 row)

4.11.33 - ST_PointFromGeoHash

返回指定 GeoHash 的中心点。

行为类型

不可变

语法

ST_PointFromGeoHash(GeoHash)

参数

GeoHash
任意长度的有效 GeoHash 字符串。

返回

GEOGRAPHY POINT

示例

以下示例显示了如何使用 ST_PointFromGeoHash。

返回高级 GeoHash 的地理点并使用 ST_AsText 将该点转换为熟知文本：

=>  SELECT ST_AsText(ST_PointFromGeoHash('dr'));
ST_AsText
-------------------------
POINT (-73.125 42.1875)
(1 row)

返回详细 GeoHash 的地理点并使用 ST_AsText 将该点转换为熟知文本：

=>  SELECT ST_AsText(ST_PointFromGeoHash('1234567890bcdefhjkmn'));
ST_AsText
---------------------------------------
POINT (-122.196077187 -88.2297377551)
(1 row)

4.11.34 - ST_PointN

查找空间对象的第 n 个点。如果传递负数、零或大于线串上的总点数的数字，ST_PointN 将返回 NULL。

顶点顺序基于空间对象的熟知文本 (WKT) 表示。

行为类型

不可变

语法

ST_PointN( g, n )

参数

g
要搜索的空间对象，类型为 GEOMETRY 或 GEOGRAPHY
n
将要返回的空间对象中的点。索引从一开始，类型为 INTEGER

返回

GEOMETRY 或 GEOGRAPHY

支持的数据类型

示例

以下示例显示了 ST_PointN 的用法。

返回第 5 个点：

=> SELECT ST_AsText(ST_PointN(ST_GeomFromText('
          POLYGON(( 2 6, 2 9, 6 9, 7 7, 4 6, 2 6))'), 5));
  ST_AsText
-------------
 POINT (4 6)
(1 row)

返回第 2 个点：

=> SELECT ST_AsText(ST_PointN(ST_GeographyFromText('
          LINESTRING(23.41 24.93,34.2 32.98,40.7 41.19)'), 2));
     ST_AsText
--------------------
 POINT (34.2 32.98)
(1 row)

4.11.35 - ST_Relate

基于指定的 DE-9IM 模式矩阵字符串，确定给定的 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上相关。

DE-9IM 标准确定了两个对象彼此在空间上的相关性。

行为类型

不可变

语法

ST_Relate( g1, g2, matrix )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY
matrix
DE-9IM 模式矩阵字符串，类型为 CHAR(9)。此字符串表示 3 x 3 限制矩阵，对应两个几何图形各自的内部、边界和外部交集的维度限制。必须恰好包含 9 个以下字符：

  • T

  • F

  • 0

  • 1

  • 2

  • *

返回

BOOLEAN

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Relate 的用法。

“等于”对应的 DE-9IM 模式为'T*F**FFF2'：

=> SELECT ST_Relate(ST_GeomFromText('LINESTRING(0 1,2 2)'),
   ST_GeomFromText('LINESTRING(2 2,0 1)'), 'T*F**FFF2');
 ST_Relate
--------------
 t
(1 row)

“重叠”对应的 DE-9IM 模式为'T*T***T**'：

=> SELECT ST_Relate(ST_GeomFromText('POLYGON((-1 -1,0 1,2 2,-1 -1))'),
   ST_GeomFromText('POLYGON((0 1,1 -1,1 1,0 1))'), 'T*T***T**');
 ST_Relate
-----------
 t
(1 row)

4.11.36 - ST_SRID

确定随空间对象存储的空间参照系标识符 (SRID)。

将 SRID 传递给 ST_GeomFromText 或 ST_GeomFromWKB 后才能确定 GEOMETRY 对象的 SRID。ST_SRID 将返回此存储值。SRID 值为 0 至 232-1 是有效的。

行为类型

不可变

语法

ST_SRID( g )

参数

g
需要 SRID 的空间对象，类型为 GEOMETRY 或 GEOGRAPHY

返回

INTEGER

支持的数据类型

示例

以下示例显示了 ST_SRID 的用法。

GEOMETRY 对象的默认 SRID 为 0：

=> SELECT ST_SRID(ST_GeomFromText(
      'POLYGON((-1 -1,2 2,0 1,-1 -1))'));
 ST_SRID
---------
 0
(1 row)

GEOGRAPHY 对象的默认 SRID 为 4326：

=> SELECT ST_SRID(ST_GeographyFromText(
      'POLYGON((22 35,24 35,26 32,22 35))'));
 ST_SRID
---------
 4326
(1 row)

4.11.37 - ST_SymDifference

计算两个 GEOMETRY 对象中除它们共有的点之外的其他所有点，包括这两个对象的边界。

该结果被称为对称差，在数学上表示为： Closure (*g1 *– g2) È Closure (*g2 *– g1)

行为类型

不可变

语法

ST_SymDifference( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_SymDifference 的用法。

返回两个线串：

=> SELECT ST_AsText(ST_SymDifference(ST_GeomFromText('LINESTRING(30 40,
   30 55)'),ST_GeomFromText('LINESTRING(30 32.5,30 47.5)')));
    ST_AsText
-----------------
MULTILINESTRING ((30 47.5, 30 55),(30 32.5,30 40))
(1 row)

返回四个正方形：

=> SELECT ST_AsText(ST_SymDifference(ST_GeomFromText('POLYGON((2 1,2 4,3 4,
   3 1,2 1))'),ST_GeomFromText('POLYGON((1 2,1 3,4 3,4 2,1 2))')));
                                ST_AsText
-------------------------------------------------------------------------
 MULTIPOLYGON (((2 1, 2 2, 3 2, 3 1, 2 1)), ((1 2, 1 3, 2 3, 2 2, 1 2)),
 ((2 3, 2 4, 3 4, 3 3, 2 3)), ((3 2, 3 3, 4 3, 4 2, 3 2)))
(1 row)

4.11.38 - ST_Touches

确定两个 GEOMETRY 对象是否在一个点接触或沿边界接触，但没有内部相交。

不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。

行为类型

不可变

语法

ST_Touches( g1, g2
                        [USING PARAMETERS spheroid={true | false}] )

参数

g1
空间对象，类型为 GEOMETRY 的值
g2
空间对象，类型为 GEOMETRY 的值

参数

spheroid = {true | false}

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

数据类型
GEOGRAPHY (WGS84)
Point-Point
否
Linestring-Point
否
Polygon-Point
是
Multipolygon-Point
否

示例

以下示例显示了 ST_Touches 的用法。

两个多边形在一个点接触：

=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((1 3,0 3,1 2,1 3))'));
 ST_Touches
------------
 t
(1 row)

两个多边形仅在沿部分边界接触：

=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((1 2,0 3,0 1,1 2))'));
 ST_Touches
------------
 t
(1 row)

两个多边形未在任何点接触：

=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
   ST_GeomFromText('POLYGON((0 2,-1 3,-2 0,0 2))'));
 ST_Touches
------------
 f
(1 row)

4.11.39 - ST_Transform

返回一个新的 GEOMETRY，其坐标转换为 srid 实参使用的空间参考系统标识符 (SRID)。

此函数支持以下转换：

  • EPSG 4326 (WGS84) 到 EPSG 3857 (Web Mercator)

  • EPSG 3857 (Web Mercator) 到 EPSG 4326 (WGS84)

对于 EPSG 4326 (WGS84)，除非坐标处于以下范围内，否则转换会失败：

  • 经度限制：-572 到 +572
  • 纬度限制：-89.9999999 到 +89.9999999

行为类型

不可变

语法

ST_Transform( g1, srid )

参数

g1
GEOMETRY 类型的空间对象。
srid
要将空间对象转换到的空间参考系统标识符 (SRID)，类型为 INTEGER。

返回

GEOMETRY

支持的数据类型

示例

以下示例显示了如何将数据从 Web Mercator (3857) 转换为 WGS84 (4326)：

=> SELECT ST_AsText(ST_Transform(STV_GeometryPoint(7910240.56433, 5215074.23966, 3857), 4326));
        ST_AsText
-------------------------
 POINT (71.0589 42.3601)
(1 row)

以下示例显示了如何将表中的线串数据从 WGS84 (4326) 转换为 Web Mercator (3857)：

=> CREATE TABLE transform_line_example (g GEOMETRY);
CREATE TABLE
=> COPY transform_line_example (gx FILLER LONG VARCHAR, g AS ST_GeomFromText(gx, 4326)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> LINESTRING(0 0, 1 1, 2 2, 3 4)
>> \.
=> SELECT ST_AsText(ST_Transform(g, 3857)) FROM transform_line_example;
                                                        ST_AsText
-------------------------------------------------------------------------------------------------------------------------
 LINESTRING (0 -7.08115455161e-10, 111319.490793 111325.142866, 222638.981587 222684.208506, 333958.47238 445640.109656)
(1 row)

以下示例显示了如何将表中的点数据从 WGS84 (4326) 转换为 Web Mercator (3857)：

=> CREATE TABLE transform_example (x FLOAT, y FLOAT, srid INT);
CREATE TABLE
=> COPY transform_example FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42.3601|71.0589|4326
>> 122.4194|37.7749|4326
>> 94.5786|39.0997|4326
>> \.
=> SELECT ST_AsText(ST_Transform(STV_GeometryPoint(x, y, srid), 3857)) FROM transform_example;
              ST_AsText
-------------------------------------
 POINT (4715504.76195 11422441.5961)
 POINT (13627665.2712 4547675.35434)
 POINT (10528441.5919 4735962.8206)
(3 rows)

4.11.40 - ST_Union

计算两个空间对象中所有点的联合。

该结果在数学上表示为：g1 È *g2 *

行为类型

不可变

语法

ST_Union( g1, g2 )

参数

g1
空间对象，类型为 GEOMETRY
g2
空间对象，类型为 GEOMETRY

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了 ST_Union 的用法。

返回表示这两个多边形中包含的所有点的多边形：

=> SELECT ST_AsText(ST_Union(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,-1 1,0 2))'),
   ST_GeomFromText('POLYGON((-1 2, 0 0, -2 0, -1 2))')));
                                     ST_AsText
------------------------------------------------------------------------------
 POLYGON ((0 2, 1 1, 0 -1, -0.5 0, -2 0, -1 2, -0.666666666667 1.33333333333, 0 2))
(1 row)

4.11.41 - ST_Within

如果空间对象 g1 完全在空间对象 g2 内部，则 ST_Within 将返回 True。两个参数必须是相同的空间数据类型。要么指定两个 GEOMETRY 对象，要么指定两个 GEOGRAPHY 对象。

如果某个对象（例如点或线串）仅沿多边形边界存在，则 ST_Within 将返回 False。线串的内部是线串上除起点和终点以外的所有点。

ST_Within(g``g is functionally equivalent to ST_Contains(g``g.

不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。

行为类型

不可变

语法

ST_Within( g1, g2
                      [USING PARAMETERS spheroid={true | false}] )

参数

g1
空间对象，类型为 GEOMETRY 或 GEOGRAPHY
g2
空间对象，类型为 GEOMETRY 或 GEOGRAPHY

参数

spheroid = {true | false}

（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。

默认值：False

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

示例

以下示例显示了 ST_Within 的用法。

第一个多边形完全包含在第二个多边形范围内：

=> SELECT ST_Within(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'),
   ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))'));
 ST_Within
-----------
 t
(1 row)

点位于多边形顶点之上但不在其内部：

=> SELECT ST_Within (ST_GeographyFromText('POINT(30 25)'),
   ST_GeographyFromText('POLYGON((25 25,25 35,32.2 35,30 25,25 25))'));
 ST_Within
-----------
 f
(1 row)

两个多边形在空间上等效：

=> SELECT ST_Within (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
   ST_GeomFromText('POLYGON((0 3, -1 2, 0 1, 0 3))'));
 ST_Within
-----------
 t
(1 row)

另请参阅

4.11.42 - ST_X

确定 GEOMETRY 点的 x 坐标或 GEOGRAPHY 点的经度值。

行为类型

不可变

语法

ST_X( g )

参数

g
类型为 GEOMETRY 或 GEOGRAPHY 的点

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_X 的用法。

返回 x 坐标：

=> SELECT ST_X(ST_GeomFromText('POINT(3.4 1.25)'));
 ST_X
-----
 3.4
(1 row)

返回经度值：

=> SELECT ST_X(ST_GeographyFromText('POINT(25.34 45.67)'));
 ST_X
-------
 25.34
(1 row)

4.11.43 - ST_XMax

返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 x 坐标。

对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (MAX(longitude), ST_YMin(GEOGRAPHY)) 到 (MAX(longitude), ST_YMax(GEOGRAPHY)) 的大圆弧的最大经度来计算最大坐标。这种情况下，MAX(longitude) 是地理对象的最大经度值。

如果纬度或经度超出范围，ST_XMax 将返回地理对象的最大普通值。

行为类型

不可变

语法

ST_XMax( g )

参数

g
需要求取最大 x 坐标的空间对象，类型为 GEOMETRY 或 GEOGRAPHY。

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_XMax 的用法。

返回矩形范围内的最大 x 坐标：

=> SELECT ST_XMax(ST_GeomFromText('POLYGON((0 1,0 2,1 2,1 1,0 1))'));
  ST_XMax
-----------
     1
(1 row)

返回矩形范围内的最大经度值：

=> SELECT ST_XMax(ST_GeographyFromText(
    'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
  ST_XMax
---------
     -71
(1 row)

4.11.44 - ST_XMin

返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 x 坐标。

对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (MIN(longitude), ST_YMin(GEOGRAPHY)) 到 (MIN(longitude), ST_YMax(GEOGRAPHY)) 的大圆弧的最小经度来计算最小坐标。这种情况下，MIN(longitude) 表示地理对象的最小经度值。

如果纬度或经度超出范围，ST_XMin 将返回地理对象的最小普通值。

行为类型

不可变

语法

ST_XMin( g )

参数

g
需要求取最小 x 坐标的空间对象，类型为 GEOMETRY 或 GEOGRAPHY。

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_XMin 的用法。

返回矩形范围内的最小 x 坐标：

=> SELECT ST_XMin(ST_GeomFromText('POLYGON((0 1,0 2,1 2,1 1,0 1))'));
  ST_XMin
----------
       0
(1 row)

返回矩形范围内的最小经度值：

=> SELECT ST_XMin(ST_GeographyFromText(
    'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
  ST_XMin
----------
    -71.5
(1 row)

4.11.45 - ST_YMax

返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 y 坐标。

对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (ST_XMin(GEOGRAPHY), MAX(latitude)) 到 (ST_XMax(GEOGRAPHY), MAX(latitude)) 的大圆弧的最大纬度来计算最大坐标。这种情况下，MAX(latitude) 是地理对象的最大纬度值。

如果纬度或经度超出范围，ST_YMax 将返回地理对象的最大普通值。

行为类型

不可变

语法

ST_YMax( g )

参数

g
需要求取最大 y 坐标的空间对象，类型为 GEOMETRY 或 GEOGRAPHY。

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_YMax 的用法。

返回矩形范围内的最大 y 坐标：

=> SELECT ST_YMax(ST_GeomFromText('POLYGON((0 1,0 4,1 4,1 1,0 1))'));
  ST_YMax
-----------
     4
(1 row)

返回矩形范围内的最大纬度值：

=> SELECT ST_YMax(ST_GeographyFromText(
    'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
   ST_YMax
------------------
 42.3802715689979
(1 row)

4.11.46 - ST_YMin

返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 y 坐标。

对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (ST_XMin(GEOGRAPHY), MIN(latitude)) 到 (ST_XMax(GEOGRAPHY), MIN(latitude)) 的大圆弧的最小纬度来计算最小坐标。这种情况下，MIN(latitude) 表示地理对象的最小纬度值。

如果纬度或经度超出范围，ST_YMin 将返回地理对象的最小普通值。

行为类型

不可变

语法

ST_YMin( g )

参数

g
需要求取最小 y 坐标的空间对象，类型为 GEOMETRY 或 GEOGRAPHY。

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_YMin 的用法。

返回矩形范围内的最小 y 坐标：

=> SELECT ST_YMin(ST_GeomFromText('POLYGON((0 1,0 4,1 4,1 1,0 1))'));
  ST_YMin
-----------
     1
(1 row)

返回矩形范围内的最小纬度值：

=> SELECT ST_YMin(ST_GeographyFromText(
    'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
  ST_YMin
------------------
 42.35
(1 row)

4.11.47 - ST_Y

确定 GEOMETRY 点的 y 坐标或 GEOGRAPHY 点的纬度值。

行为类型

不可变

语法

ST_Y( g )

参数

g
类型为 GEOMETRY 或 GEOGRAPHY 的点

返回

FLOAT

支持的数据类型

示例

以下示例显示了 ST_Y 的用法。

返回 y 坐标：

=> SELECT ST_Y(ST_GeomFromText('POINT(3 5.25)'));
 ST_Y
------
 5.25
(1 row)

返回纬度值：

=> SELECT ST_Y(ST_GeographyFromText('POINT(35.44 51.04)'));
 ST_Y
-------
 51.04
(1 row)

4.11.48 - STV_AsGeoJSON

返回 Javascript 几何对象表示法 (GeoJSON) 对象形式的几何或地理参数。

行为类型

不可变

语法

STV_AsGeoJSON( g, [USING PARAMETERS maxdecimals=[dec_value]])

参数

g

GEOMETRY 或 GEOGRAPHY 类型的空间对象

maxdecimals = dec_value
（可选）整型值。确定浮点坐标小数点后输出的最大位数。

有效值 ： 在 0 到 15 之间。

默认 值 **：**6

返回

LONG VARCHAR

支持的数据类型

示例

以下示例显示了 STV_AsGeoJSON 的用法。

将几何多边形转换为 GeoJSON：

=> SELECT STV_AsGeoJSON(ST_GeomFromText('POLYGON((3 2, 4 3, 5 1, 3 2), (3.5 2, 4 2.5, 4.5 1.5, 3.5 2))'));
                                            STV_AsGeoJSON
--------------------------------------------------------------------------------------------------
 {"type":"Polygon","coordinates":[[[3,2],[4,3],[5,1],[3,2]],[[3.5,2],[4,2.5],[4.5,1.5],[3.5,2]]]}
(1 row)

将地理点转换为 GeoJSON：

=> SELECT STV_AsGeoJSON(ST_GeographyFromText('POINT(42.36011 71.05899)') USING PARAMETERS maxdecimals=4);
                   STV_AsGeoJSON
-------------------------------------------------
 {"type":"Point","coordinates":[42.3601,71.059]}
(1 row)

4.11.49 - STV_Create_Index

对一组多边形创建空间索引，以加快与一组点的空间相交计算速度。

利用一个输入多边形集（可以是查询的结果），可以创建空间索引。空间索引是在全局命名空间中创建的。每当跨群集的节点对输入表或投影分段时，Vertica 会采用分布式计划。

OVER() 子句必须为空。

行为类型

不可变

语法

STV_Create_Index( gid, g
                   USING PARAMETERS index='index_name'
                                    [, overwrite={ true | false } ]
                                    [, max_mem_mb=maxmem_value]
                     [, skip_nonindexable_polygons={true | false } ] )
                 OVER()
                    [ AS (polygons, srid, min_x, min_y, max_x, max_y, info) ]

实参

gid
唯一标识多边形的 Integer 列的名称。Gid 不能为 NULL。
g
包含多边形或多边形集合的几何或地理 (WGS84) 列或表达式的名称。只能对多边形和多边形集合编制索引。将从索引中排除其他图形类型。

参数

index = 'index_name'
索引的名称，类型为 VARCHAR。索引名称不能超过 110 个字符。索引名称中不允许使用斜杠、反斜杠和制表符。
overwrite = [ true | false ]

用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。

默认值： False

max_mem_mb = maxmem_value
用于为 STV_Create_Index 在索引构建期间可分配的内存量指定限制（以 MB 为单位）的正整数。在多节点数据库上，它是每个节点的内存限制。默认值为 256。不要分配高于 GENERAL 资源池中的内存量的值。有关该池的详细信息，请参阅监控资源池。

如果为 max_mem_mb 设置的值等于或接近节点上的最大可用内存，则可能给系统性能造成不利影响。例如，它可能导致在索引构建期间，其他查询由于等待内存资源而发生超时。

skip_nonindexable_polygons = [ true | false ]

（可选）BOOLEAN

在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。这些多边形被视为不可编制索引。当设置为 False 时，不可编制索引的多边形会导致创建索引失败。当设置为 True 时，可通过从索引中排除不可编制索引的多边形成功创建索引。

要审查无法编制索引的多边形，请配合参数 list_polygon 使用 STV_Describe_Index。

默认值：False

返回

polygons
已编制索引的多边形数量。
SRID
空间参照系标识符。
min_x, min_y, max_x, max_y
已编制索引的几何图形的最小边界矩形 (MBR) 的坐标。(min_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。
info
列出从索引中排除的空间对象数量及其类型。

支持的数据类型

特权

任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。

建议

  • 对跨多个节点的大型多边形表进行分段。通过表分段可以并行运行索引创建操作，从而充分利用 Vertica 中的大规模并行处理 (MPP) 架构。这会显著缩短大型表的执行时间。

    对于需要构建索引的表，如果多边形总数较大，Vertica 建议对其进行分段。

  • STV_Create_Index 可能占用大量处理时间和内存。

    首次为新数据编制索引时，Vertica 建议监视内存使用情况，以确保其保持在安全限制以内。内存使用情况取决于多边形数量、顶点数量以及多边形之间的重叠量。

  • STV_Create_Index 会在开始创建索引之前尝试分配内存。如果无法分配足够的内存，函数将会失败。如果没有足够的可用内存，请尝试以下解决方案：

    • 在系统负载较小时创建索引。

    • 避免并发创建索引。

    • 尝试跨群集节点对输入表进行分段。

  • 确保您计划索引的所有多边形都是有效的多边形。STV_Create_Index 和 STV_Refresh_Index 在构建索引时不检查多边形的有效性。

    有关详细信息，请参阅创建或刷新索引之前确保多边形的有效性。

限制

  • 12.0.x 版之前创建的任何索引都需要重新创建。

  • 如果 WGS84 多边形的顶点位于国际日期变更线 (IDL) 或北极和南极，则索引创建失败。

  • 索引名称中不允许使用反斜杠或制表符。

  • 索引名称不能超过 110 个字符。

  • 以下几何图形不包含在索引中：

    • 非多边形

    • 具有 NULL 标识符的几何图形

    • NULL 多边形（集合）

    • EMPTY 多边形（集合）

    • 无效多边形（集合）

  • 以下地形不包含在索引中：

    • 带孔的多边形
    • 跨越国际日期变更线的多边形
    • 覆盖北极或南极的多边形
    • 对跖多边形

使用提示

  • 要取消运行 STV_Create_Index，请使用 Ctrl + C。

  • 如果 Geometry 列没有有效的多边形，STV_Create_Index 将在 vertica.log 中报告错误并停止创建索引。

  • 如果创建索引时使用了大量内存，请考虑对数据进行分段，以便并行创建索引。

示例

以下示例显示了 STV_Create_Index 的用法。

使用单个字面参数创建索引：


=> SELECT STV_Create_Index(1, ST_GeomFromText('POLYGON((0 0,0 15.2,3.9 15.2,3.9 0,0 0))')
     USING PARAMETERS index='my_polygon') OVER();
polygons  | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
        1 |    0 |     0 |     0 |   3.9 |  15.2 |
(1 row)

从表创建索引：

=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|POLYGON((10 20,15 60,20 45,46 15,10 20))
>> 4|POLYGON((5 20,9 30,20 45,36 35,5 20))
>> 5|POLYGON((12 23,9 30,20 45,36 35,37 67,45 80,50 20,12 23))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
    max_mem_mb=256) OVER() FROM pols;
 polygons | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
        5 |    0 |   -38 |    13 |    50 |    80 |
(1 row)

从已分区的表并行创建索引：

=> CREATE TABLE pols (p INT, gid INT, geom GEOMETRY(1000)) SEGMENTED BY HASH(p) ALL NODES;
CREATE TABLE
=> COPY pols (p, gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|10|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 1|11|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|12|POLYGON((-12 42,-12 42,27 48,14 26,-12 42))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true,
    max_mem_mb=256) OVER() FROM pols;
 polygons | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
        3 |    0 |   -38 |    13 |    27 |    74 |
(1 row)

另请参阅

4.11.50 - STV_Describe_Index

检索关于包含一组多边形的索引的信息。如果没有传递任何参数，STV_Describe_Index 将返回所有已定义的索引。

OVER() 子句必须为空。

行为类型

不可变

语法

STV_Describe_Index ( [ USING PARAMETERS [index='index_name']
                                        [, list_polygons={true | false } ]] ) OVER ()

实参

index = 'index_name'
索引的名称，类型为 VARCHAR。索引名称不能超过 110 个字符。索引名称中不允许使用斜杠、反斜杠和制表符。
list_polygon
（可选）用于指定是否列出索引中的多边形的 BOOLEAN 值。索引参数必须与此参数配合使用。

返回

polygons
已编制索引的多边形数量。
SRID
空间参照系标识符。
min_x, min_y, max_x, max_y
已编制索引的几何图形的最小边界矩形 (MBR) 的坐标。(min_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。
name
空间索引的名称。
gid
唯一标识多边形的 Integer 列的名称。Gid 不能为 NULL。
state
索引中的空间对象的状态。可能的值为：

  • INDEXED - 空间对象已成功编制索引。

  • SELF_INTERSECT -（仅限 WGS84）空间对象未编制索引，因为其一个边与自身的另一个边相交。

  • EDGE_CROSS_IDL -（仅限 WGS84）空间对象未编制索引，因为其一个边与国际日期变更线交叉。

  • EDGE_HALF_CIRCLE -（仅限 WGS84）空间对象未编制索引，因为包含两个对跖的相邻顶点。

  • NON_INDEXABLE - 空间对象无法编制索引。

geography

空间对象的熟知二进制 (WKB) 表示。

geometry

空间对象的熟知二进制 (WKB) 表示。

特权

任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。

限制

如果索引是使用 12.0.x 或更早版本创建的，一些功能将会要求重建索引。

示例

以下示例显示了 STV_Describe_Index 的用法。

检索关于索引的信息：

=> SELECT STV_Describe_Index (USING PARAMETERS index='my_polygons') OVER ();
   type   | polygons | SRID | min_x | min_y | max_x | max_y
----------+----------+------+-------+-------+-------+-------
 GEOMETRY |        4 |    0 |    -1 |    -1 |    12 |    12


(1 row)

返回所有已定义的索引的名称：

=> SELECT STV_Describe_Index() OVER ();
       name
------------------
MA_counties_index
my_polygons
NY_counties_index
US_States_Index
(4 rows)

返回索引中包含的多边形：

=> SELECT STV_Describe_Index(USING PARAMETERS index='my_polygons', list_polygons=TRUE) OVER ();
 gid |     state     |            geometry
-----+---------------+----------------------------------
  12 | INDEXED       | \260\000\000\000\000\000\000\ ...
  14 | INDEXED       | \200\000\000\000\000\000\000\ ...
  10 | NON_INDEXABLE | \274\000\000\000\000\000\000\ ...
  11 | INDEXED       | \260\000\000\000\000\000\000\ ...
(4 rows)

另请参阅

4.11.51 - STV_Drop_Index

删除空间索引。如果 STV_Drop_Index 找不到指定的空间索引，它将返回错误。

OVER 子句必须为空。

行为类型

不可变

语法

STV_Drop_Index( USING PARAMETERS index = 'index_name' ) OVER ()

参数

index = 'index_name'
索引的名称，类型为 VARCHAR。索引名称不能超过 110 个字符。索引名称中不允许使用斜杠、反斜杠和制表符。

示例

以下示例显示了 STV_Drop_Index 的用法。

删除索引：

=> SELECT STV_Drop_Index(USING PARAMETERS index ='my_polygons') OVER ();
 drop_index
------------
 Index dropped
(1 row)

另请参阅

4.11.52 - STV_DWithin

确定从一个空间对象的边界到另一个对象的边界的最短距离是否在指定的距离范围以内。

g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。

行为类型

不可变

语法

STV_DWithin( g1, g2, d )

参数

g1

GEOMETRY 或 GEOGRAPHY 类型的空间对象

g2

GEOMETRY 或 GEOGRAPHY 类型的空间对象

d
表示距离的 FLOAT 类型的值。对于 GEOMETRY 对象，距离使用笛卡尔坐标单位测量。对于 GEOGRAPHY 对象，距离以米为单位测量。

返回

BOOLEAN

支持的数据类型

兼容的 GEOGRAPHY 对：

数据类型
GEOGRAPHY (Perfect Sphere)
Point-Point
是
Point-Linestring
是
Point-Polygon
是
Point-Multilinestring
是
Point-Multipolygon
是

示例

以下示例显示了 STV_DWithin 的用法。

两个几何图形彼此在最接近的点的距离为一个笛卡尔坐标单位：

=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
   ST_GeomFromText('POLYGON((4 3,2 3,4 5,4 3))'),1);
 STV_DWithin
-------------
 t
(1 row)

如果将该距离缩小为 0.99 个单位：

=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
   ST_GeomFromText('POLYGON((4 3,2 3,4 5,4 3))'),0.99);
 STV_DWithin
-------------
 f
(1 row)

第一个多边形将会接触到第二个多边形：

=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
   ST_GeomFromText('POLYGON((1 1,2 3,4 5,1 1))'),0.00001);
 STV_DWithin
-------------
 t
(1 row)

第一个多边形不在第二个多边形的 1000 米距离范围以内：

=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((45.2 40,50.65 51.29,
   55.67 47.6,50 47.6,45.2 40))'),ST_GeomFromText('POLYGON((25 25,25 30,
   30 30,30 25,25 25))'), 1000);
 STV_DWithin
--------------
 t
(1 row)

4.11.53 - STV_Export2Shapefile

将数据库表或子查询中的 GEOGRAPHY 或 GEOMETRY 数据导出到 shapefile 。输出被写入使用 STV_SetExportShapefileDirectory 指定的目录。

行为类型

不可变

语法

STV_Export2Shapefile( columns USING PARAMETERS shapefile = 'shapefile-name'
   [, overwrite = boolean ]
   [, shape = 'spatial-class'] )
OVER()

参数

columns
导出到 shapefile 的列。

星号 (*) 值等同于列出 FROM 子句的所有列。

参数

shapefile
shapefile 组件名称的前缀。需要满足以下要求：

  • 必须以文件扩展名 .shp 结尾。

  • 长度限制为 128 个八位字节，例如 city-data.shp。

如果要将 shapefile 保存到子目录，可通过将子目录连接到 shapefile-name 来实现，例如， visualizations/city-data.shp。

您还可以将 shapefile 导出到您具有读写权限的挂载 S3 目录。使用语法 bucketname/path/filename。

overwrite

用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。

默认值： False

shape
以下空间类之一：

  • Point

  • Polygon

  • Linestring

  • Multipoint

  • Multipolygon

  • Multilinestring

多边形和多边形集合始终为顺时针方向。

默认值： Polygon

返回

shapefile 导出目录中的三个文件，扩展名为 .shp、.shx 和 .dbf。

限制

  • 如果多边形集合、线串集合或点集合仅包含一个元素，则分别被写为多边形、线或点。

  • 超过 10 个字符的列名称会被截短。

  • 不能导出空的 POINTS。

  • 会跳过所有包含 NULL 几何或地理数据的列。

  • 不支持或无效的日期将被替换为 NULL。

  • 数字值在导出时可能会损失精度。发生精度损失的原因是，.dbf 文件中的目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位。

  • shapefile 的大小不能超过 4GB。如果您的 shapefile 过大，请尝试拆分数据并导出到多个 shapefile。

示例

以下示例显示了如何使用 STV_Export2Shapefile 将表 geo_data 的所有列导出到名为 city-data.shp 的 shapefile：

=> SELECT STV_Export2Shapefile(*
            USING PARAMETERS shapefile = 'visualizations/city-data.shp',
                             overwrite = true, shape = 'Point')
            OVER()
            FROM geo_data
            WHERE REVENUE > 25000;
 Rows Exported |                          File Path
---------------+--------------------------------------------------------------
       6442892 | v_geo-db_node0001: /home/geo/temp/visualizations/city-data.shp
(1 row)

4.11.54 - STV_Extent

返回一个包含所有输入数据的边界框。

在嵌套查询中使用 STV_Extent 以获得最佳结果。OVER 子句必须为空。

行为类型

不可变

语法

STV_Extent( g )

参数

g
空间对象，类型为 GEOMETRY。

返回

GEOMETRY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
是

示例

以下示例显示了如何使用 STV_Extent。

返回线串的边界框，并验证它是否是有效的多边形：

=> SELECT ST_AsText(geom) AS bounding_box, ST_IsValid(geom)
   FROM (SELECT STV_Extent(ST_GeomFromText('LineString(0 0, 1 1)')) OVER() AS geom) AS g;
            bounding_box             | ST_IsValid
-------------------------------------+------------
 POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)) | t
(1 row)

返回表中空间对象的边界框：

=> CREATE TABLE misc_geo_shapes (id IDENTITY, geom GEOMETRY);
CREATE TABLE
=> COPY misc_geo_shapes (gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> POINT(-71.03 42.37)
>> LINESTRING(-71.058849 42.367501, -71.062240 42.371276, -71.067938 42.371246)
>> POLYGON((-71.066030 42.380617, -71.055827 42.376734, -71.060811 42.376011, -71.066030 42.380617))
>> \\.
=> SELECT ST_AsText(geom_col) AS bounding_box
   FROM (SELECT STV_Extent(geom) OVER() AS geom_col FROM misc_geo_shapes) AS g;
                                                   bounding_box
------------------------------------------------------------------------------------------------------------------
 POLYGON ((-71.067938 42.367501, -71.03 42.367501, -71.03 42.380617, -71.067938 42.380617, -71.067938 42.367501))
(1 row)

4.11.55 - STV_ForceLHR

更改空间对象的顶点顺序，使其遵循左手规则。

行为类型

不可变

语法

STV_ForceLHR( g, [USING PARAMETERS skip_nonreorientable_polygons={true | false} ])

参数

g
空间对象，类型为 GEOGRAPHY。
skip_nonreorientable_polygons = { true | false }

（可选）Boolean

当设置为 False 时，不可定向的多边形将会生成错误。例如，如果将 STV_ForceLHR 或 STV_Reverse 与设置为 False 的 skip_nonorientable_polygons 配合使用，则包含孔的地理多边形将会生成错误。当设置为 True 时，返回的结果将是传递给 API 的未经更改的多边形。

此实参可帮助从包含无法重新定向的多边形的表创建索引。

Vertica Place 将以下多边形视为不可定向：

  • 包含孔的多边形

  • 多边形集合

  • 包含孔的多边形集合

默认值：False

返回

GEOGRAPHY

支持的数据类型

示例

以下示例显示了 STV_ForceLHR 的用法。

将地理多边形的方向调整为左手方向：

=> SELECT ST_AsText(STV_ForceLHR(ST_GeographyFromText('Polygon((1 1, 3 1, 2 2, 1 1))')));
            ST_AsText
--------------------------------
 POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)

通过强制执行左手方向来反转地理多边形的方向：

=> SELECT ST_AsText(STV_ForceLHR(ST_GeographyFromText('Polygon((1 1, 2 2, 3 1, 1 1))')));
           ST_AsText
--------------------------------
 POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)

另请参阅

STV_Reverse

4.11.56 - STV_Geography

将 GEOMETRY 对象转换为 GEOGRAPHY 对象。SRID 值不影响 Vertica Place 查询的结果。

STV_Geography 在将 GEOMETRY 对象转换为 GEOGRAPHY 对象时，会将其 SRID 设为 4326。

行为类型

不可变

语法

STV_Geography( geom )

参数

geom
要转换为 GEOGRAPHY 对象的空间对象，类型为 GEOMETRY

返回

GEOGRAPHY

支持的数据类型

数据类型
GEOMETRY
Point
是
Multipoint
是
Linestring
是
Multilinestring
是
Polygon
是
Multipolygon
是
GeometryCollection
否

示例

以下示例显示了 STV_Geography 的用法。

要计算 GEOGRAPHY 对象的质心，请将其转换为 GEOMETRY 对象，然后转换回 GEOGRAPHY 对象：

=> CREATE TABLE geogs(g GEOGRAPHY);
CREATE TABLE
=> COPY geogs(gx filler LONG VARCHAR, geog AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> MULTIPOINT(-108.619726 45.000284,-107.866813 45.00107,-106.363711 44.994223,-70.847746 41.205814)
>> \\.
=> SELECT ST_AsText(STV_Geography(ST_Centroid(STV_Geometry(g)))) FROM geogs;
           ST_AsText
--------------------------------
 POINT (-98.424499 44.05034775)
(1 row)

4.11.57 - STV_GeographyPoint

基于输入值，返回 GEOGRAPHY 点。

这是将原始坐标转换为 GEOGRAPHY 点的最佳方法。

行为类型

不可变

语法

STV_GeographyPoint( x, y )

参数

x
X 坐标或经度，FLOAT。
y
y 坐标或纬度，FLOAT。

返回

GEOGRAPHY

示例

以下示例显示了 STV_GeographyPoint 的用法。

返回 GEOGRAPHY 点：


=> SELECT ST_AsText(STV_GeographyPoint(-114.101588, 47.909677));
           ST_AsText
-------------------------------
 POINT (-114.101588 47.909677)
(1 row)

使用两列返回 GEOGRAPHY 点：


=> CREATE TABLE geog_data (id IDENTITY, x FLOAT, y FLOAT);
CREATE TABLE
=> COPY geog_data FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> -114.101588|47.909677
>> -111.532377|46.430753
>> \.
=> SELECT id, ST_AsText(STV_GeographyPoint(x, y)) FROM geog_data;
 id |           ST_AsText
----+-------------------------------
  1 | POINT (-114.101588 47.909677)
  2 | POINT (-111.532377 46.430753)
(2 rows)

在加载期间通过操纵数据源列来创建 GEOGRAPHY 点：

=> CREATE TABLE geog_data_load (id IDENTITY, geog GEOGRAPHY);
CREATE TABLE
=> COPY geog_data_load (lon FILLER FLOAT,
                        lat FILLER FLOAT,
                        geog AS STV_GeographyPoint(lon, lat))
   FROM 'test_coords.csv' DELIMITER ',';
 Rows Loaded
-------------
           2
(1 row)
=> SELECT id, ST_AsText(geog) FROM geog_data_load;
 id |             ST_AsText
----+------------------------------------
  1 | POINT (-75.101654451 43.363830536)
  2 | POINT (-75.106444487 43.367093798)
(2 rows)

另请参阅

STV_GeometryPoint

4.11.58 - STV_Geometry

将 GEOGRAPHY 对象转换为 GEOMETRY 对象。

SRID 值不影响 Vertica Place 查询的结果。

行为类型

不可变

语法

STV_Geometry( geog )

参数

geog
要转换为 GEOMETRY 对象的空间对象，类型为 GEOGRAPHY

返回

GEOMETRY

支持的数据类型

示例

以下示例显示了 STV_Geometry 的用法。

将 GEOGRAPHY 值转换为 GEOMETRY 值，然后将结果转换回 GEOGRAPHY 类型：

=> CREATE TABLE geogs(g GEOGRAPHY);
CREATE TABLE
=> COPY geogs(gx filler LONG VARCHAR, geog AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> MULTIPOINT(-108.619726 45.000284,-107.866813 45.00107,-106.363711 44.994223,-70.847746 41.205814)
>> \\.
=> SELECT ST_AsText(STV_Geography(ST_Centroid(STV_Geometry(g)))) FROM geogs;
           ST_AsText
--------------------------------
 POINT (-98.424499 44.05034775)

4.11.59 - STV_GeometryPoint

基于输入值，返回 GEOMETRY 点。

这是将原始坐标转换为 GEOMETRY 点的最佳方法。

行为类型

不可变

语法

STV_GeometryPoint( x, y [, srid] )

参数

x
X 坐标或经度，FLOAT。
y
y 坐标或纬度，FLOAT。
srid
（可选）分配给点的空间参照标识符 (SRID)，类型为 INTEGER。

返回

GEOMETRY

示例

以下示例显示了 STV_GeometryPoint 的用法。

返回包含 SRID 的 GEOMETRY 点：


=> SELECT ST_AsText(STV_GeometryPoint(71.148562, 42.989374, 4326));
          ST_AsText
-----------------------------
 POINT (-71.148562 42.989374)
(1 row)

使用两列返回 GEOMETRY 点：


=> CREATE TABLE geom_data (id IDENTITY, x FLOAT, y FLOAT, SRID int);
CREATE TABLE
=> COPY geom_data FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42.36383053600048|-71.10165445099966|4326
>> 42.3670937980005|-71.10644448699964|4326
>> \\.
=> SELECT id, ST_AsText(STV_GeometryPoint(x, y, SRID)) FROM geom_data;
 id |             ST_AsText
----+------------------------------------
  1 | POINT (-71.101654451 42.363830536)
  2 | POINT (-71.106444487 42.367093798)
(2 rows)

在加载期间通过操纵数据源列来创建 GEOMETRY 点：

=> CREATE TABLE geom_data_load (id IDENTITY, geom GEOMETRY);
CREATE TABLE
=> COPY geom_data_load (lon FILLER FLOAT,
                        lat FILLER FLOAT,
                        geom AS STV_GeometryPoint(lon, lat))
   FROM 'test_coords.csv' DELIMITER ',';
 Rows Loaded
-------------
           2
(1 row)
=> SELECT id, ST_AsText(geom) FROM geom_data_load;
 id |             ST_AsText
----+------------------------------------
  1 | POINT (-75.101654451 43.363830536)
  2 | POINT (-75.106444487 43.367093798)
(2 rows)

另请参阅

STV_GeographyPoint

4.11.60 - STV_GetExportShapefileDirectory

返回导出目录的路径。

行为类型

不可变

语法

STV_GetExportShapefileDirectory( )

返回

图形文件导出目录的路径。

示例

以下示例显示了如何使用 STV_GetExportShapefileDirectory 来查询 shapefile 导出目录的路径：

=> SELECT STV_GetExportShapefileDirectory();
        STV_GetExportShapefileDirectory
-----------------------------------------------
 Shapefile export directory: [/home/user/temp]
(1 row)

4.11.61 - STV_Intersect 标量函数

将一个点或多个点与一组多边形在空间上相交。STV_Intersect 标量函数将返回与相交多边形关联的标识符。

行为类型

不可变

语法

STV_Intersect(  { g | x , y }
                  USING PARAMETERS index= 'index_name')

参数

g
包含点的几何或地理 (WGS84) 列。*g *列只能包含点几何图形或地理图形。如果该列包含其他几何或地理类型，STV_Intersect 将会终止并提示错误。
x
X 坐标或经度，FLOAT。
y
y 坐标或纬度，FLOAT。

参数

index = 'index_name'
空间索引的名称，类型为 VARCHAR。

返回

匹配多边形的标识符。如果点没有与索引中的任何多边形相交，则 STV_Intersect 标量函数将返回 NULL。

示例

以下示例显示了如何使用 STV_Intersect 标量。

使用两个浮点数，返回匹配多边形的 gid 或 NULL：

=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((31 74,8 70,8 50,36 53,31 74))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
                            max_mem_mb=256) OVER() FROM pols;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        1 |    0 |     8 |    50 |    36 |    74 |
(1 row)

=> SELECT STV_Intersect(12.5683, 55.6761 USING PARAMETERS index = 'my_polygons_1');
 STV_Intersect
---------------
            1
(1 row)

使用 GEOMETRY 列，返回匹配多边形的 gid 或 NULL：


=> CREATE TABLE polygons (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY polygons (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|POLYGON((-18 42,-10 65,27 48,14 26,-18 42))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true,
     max_mem_mb=256) OVER() FROM polygons;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        3 |    0 |   -38 |    13 |    27 |    74 |
(1 row)


=> CREATE TABLE points (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY points (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 100|POINT(-1 52)
>> 101|POINT(-20 0)
>> 102|POINT(-8 25)
>> 103|POINT(0 0)
>> 104|POINT(1 5)
>> 105|POINT(20 45)
>> 106|POINT(-20 5)
>> 107|POINT(-20 1)
>> \.
=> SELECT gid AS pt_gid, STV_Intersect(geom USING PARAMETERS index='my_polygons') AS pol_gid
       FROM points ORDER BY pt_gid;
 pt_gid | pol_gid
--------+---------
    100 |       1
    101 |
    102 |       2
    103 |
    104 |
    105 |       3
    106 |
    107 |
(8 rows)

另请参阅

4.11.62 - STV_Intersect 变换函数

将点与多边形在空间上相交。STV_Intersect 变换函数返回包含匹配的点/多边形对的元组。对于每个点，Vertica 返回一个或多个匹配的多边形。

在多个节点上并行计算 STV_Intersect 变换函数可以提高性能。要执行并行计算，请使用 OVER(PARTITION BEST) 子句。

行为类型

不可变

语法

STV_Intersect ( { gid | i }, { g | x , y }
         USING PARAMETERS index='index_name')
         OVER() AS (pt_gid, pol_gid)

参数

gid | i
用于唯一标识 g 或 x 和 y 的空间对象的整数列或整数。
g
包含点的几何或地理 (WGS84) 列。*g *列只能包含点几何图形或地理图形。如果该列包含其他几何或地理类型，STV_Intersect 将会终止并提示错误。
x
X 坐标或经度，FLOAT。
y
y 坐标或纬度，FLOAT。

参数

index = 'index_name'
空间索引的名称，类型为 VARCHAR。

返回

pt_gid
几何或地理点的唯一标识符，类型为 INTEGER。
pol_gid
几何或地理多边形的唯一标识符，类型为 INTEGER。

示例

以下示例显示了如何使用 STV_Intersect 变换函数。

使用两个浮点数，返回匹配的点-多边形对。

=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((31 74,8 70,8 50,36 53,31 74))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
                            max_mem_mb=256) OVER() FROM pols;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        1 |    0 |     8 |    50 |    36 |    74 |
(1 row)

=> SELECT STV_Intersect(56, 12.5683, 55.6761 USING PARAMETERS index = 'my_polygons_1') OVER();
 pt_gid | pol_gid
--------+---------
     56 |       1
(1 row)

使用 GEOMETRY 列，返回匹配的点-多边形对。

=> CREATE TABLE polygons (gid int, geom GEOMETRY(700));
CREATE TABLE
=> COPY polygons (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 10|POLYGON((5 5, 5 10, 10 10, 10 5, 5 5))
>> 11|POLYGON((0 0, 0 2, 2 2, 2 0, 0 0))
>> 12|POLYGON((1 1, 1 3, 3 3, 3 1, 1 1))
>> 14|POLYGON((-1 -1, -1 12, 12 12, 12 -1, -1 -1))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true, max_mem_mb=256)
      OVER() FROM polygons;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        4 |    0 |    -1 |    -1 |    12 |    12 |
(1 row)


=> CREATE TABLE points (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY points (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(9 9)
>> 2|POINT(0 1)
>> 3|POINT(2.5 2.5)
>> 4|POINT(0 0)
>> 5|POINT(1 5)
>> 6|POINT(1.5 1.5)
>> \\.
=> SELECT STV_Intersect(gid, geom USING PARAMETERS index='my_polygons') OVER (PARTITION BEST)
     AS (point_id, polygon_gid)
        FROM points;
 point_id | polygon_gid
----------+-------------
        5 |          14
        1 |          14
        1 |          10
        4 |          14
        4 |          11
        6 |          12
        6 |          14
        6 |          11
        2 |          14
        2 |          11
        3 |          12
        3 |          14
(12 rows)

可通过在 WHERE 子句中使用 STV_Intersect 变换函数来提高查询性能。由于此语法会消除未与索引中的多边形相交的点，因此能够提高性能。

返回与 gid = 14 的多边形相交的点计数：

=> SELECT COUNT(pt_id) FROM
    (SELECT STV_Intersect(gid, geom USING PARAMETERS index='my_polygons')
     OVER (PARTITION BEST) AS (pt_id, pol_id) FROM points)
        AS T WHERE pol_id = 14;
 COUNT
-------
     6
(1 row)

另请参阅

4.11.63 - STV_IsValidReason

确定空间对象的格式是否正确或其是否有效。如果对象无效，STV_IsValidReason 将返回说明无效性原因的字符串。

如果以下所有项均成立，则多边形或多边形集合是有效的：

  • 多边形是封闭的；其起点与终点相同。

  • 其边界是一组线串。

  • 边界不触及或穿越本身。

  • 与外部多边形边界的接触点不超过一个的任何内部多边形。

如果将无效的对象传递给 Vertica Place 函数，函数将会失败或返回错误的结果。要确定多边形是否有效，请先运行 ST_IsValid。如果多边形有效，ST_IsValid 将返回 TRUE，否则将返回 FALSE。

行为类型

不可变

语法

STV_IsValidReason( g )

参数

g
用于测试有效性的地理空间对象，其值类型为 GEOMETRY 或 GEOGRAPHY (WGS84)。

返回

LONG VARCHAR

支持的数据类型

示例

以下示例显示了 STV_IsValidReason 的用法。

返回描述多边形无效位置的字符串：

=> SELECT STV_IsValidReason(ST_GeomFromText('POLYGON((1 3,3 2,1 1,
   3 0,1 0,1 3))'));
               STV_IsValidReason
-----------------------------------------------
 Ring Self-intersection at or near POINT (1 1)
(1 row)

另请参阅

ST_IsValid

4.11.64 - STV_LineStringPoint

检索线串或线串集合的顶点。 根据输入对象的类型，返回的值为 GEOMETRY 或 GEOGRAPHY 类型的点。GEOMETRY 点将继承输入对象的 SRID。

STV_LineStringPoint 为分析函数。有关详细信息，请参阅分析函数。

行为类型

不可变

语法

STV_LineStringPoint( g )
    OVER( [PARTITION NODES] ) AS

参数

g
线串或线串集合，GEOMETRY 或 GEOGRAPHY 类型的值

返回

GEOMETRY 或 GEOGRAPHY

支持的数据类型

示例

以下示例显示了 STV_LineStringPoint 的用法。

返回几何线串的顶点及其 SRID：

=> SELECT ST_AsText(Point), ST_SRID(Point)
     FROM (SELECT STV_LineStringPoint(
           ST_GeomFromText('MULTILINESTRING((1 2, 2 3, 3 1, 4 2),
                  (10 20, 20 30, 30 10, 40 20))', 4269)) OVER () AS Point) AS foo;
    ST_AsText   | ST_SRID
 ---------------+---------
  POINT (1 2)   |    4269
  POINT (2 3)   |    4269
  POINT (3 1)   |    4269
  POINT (4 2)   |    4269
  POINT (10 20) |    4269
  POINT (20 30) |    4269
  POINT (30 10) |    4269
  POINT (40 20) |    4269
 (8 rows)

返回地理线串的顶点：


=> SELECT ST_AsText(g)
     FROM (SELECT STV_LineStringPoint(
       ST_GeographyFromText('MULTILINESTRING ((42.1 71.0, 41.4 70.0, 41.3 72.9),
           (42.99 71.46, 44.47 73.21)', 4269)) OVER () AS g) AS line_geog_points;
      ST_AsText
---------------------
 POINT (42.1 71.0)
 POINT (41.4 70.0)
 POINT (41.3 72.9)
 POINT (42.99 71.46)
 POINT (44.47 73.21)
(5 rows)

另请参阅

STV_PolygonPoint

4.11.65 - STV_MemSize

返回 INTEGER 类型的空间对象长度（以字节为单位）。

使用此函数确定空间数据的最优列宽。

行为类型

不可变

语法

STV_MemSize( g )

参数

g
空间对象，类型为 GEOMETRY 或 GEOGRAPHY 的值

返回

INTEGER

示例

以下示例显示了如何通过将 GEOMETRY 或 GEOGRAPHY 列大小调整为 STV_MemSize 所返回的最大值来对表进行优化：

=> CREATE TABLE mem_size_table (id int, geom geometry(800));
CREATE TABLE
=> COPY mem_size_table (id, gx filler LONG VARCHAR, geom as ST_GeomFromText(gx)) FROM STDIN DELIMITER '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>1|POINT(3 5)
>>2|MULTILINESTRING((1 5, 2 4, 5 3, 6 6),(3 5, 3 7))
>>3|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\\.
=> SELECT max(STV_MemSize(geom)) FROM mem_size_table;
 max
-----
 336
(1 row)

=> CREATE TABLE production_table(id int, geom geometry(336));
CREATE TABLE
=> INSERT INTO production_table SELECT * FROM mem_size_table;
 OUTPUT
--------
      3
(1 row)
=> DROP mem_size_table;
DROP TABLE

4.11.66 - STV_NN

计算空间对象与参考对象之间的距离，并按照与参考对象的距离，以升序方式返回（对象，距离）对。

g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。

STV_NN 为分析函数。有关详细信息，请参阅分析函数。

行为类型

不可变

语法

STV_NN( g, ref_obj, k ) OVER()

参数

g
空间对象，类型为 GEOMETRY 或 GEOGRAPHY 的值
ref_obj
参考对象，类型为 GEOMETRY 或 GEOGRAPHY
k
返回的行数，类型为 INTEGER

返回

按距离以升序方式返回（对象，距离）对。如果某个参数为 EMPTY 或 NULL，则返回 0 行。

支持的数据类型

示例

以下示例显示了 STV_NN 的用法。

创建表并插入 9 个 GEOGRAPHY 点：

=> CREATE TABLE points (g geography);
CREATE TABLE
=> COPY points (gx filler LONG VARCHAR, g AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> POINT (21.5 18.4)
>> POINT (21.5 19.2)
>> POINT (21.5 20.7)
>> POINT (22.5 16.4)
>> POINT (22.5 17.15)
>> POINT (22.5 18.33)
>> POINT (23.5 13.68)
>> POINT (23.5 15.9)
>> POINT (23.5 18.4)
>> \\.

计算表 points 中的对象与 GEOGRAPHY 点 (23.5, 20) 的距离（以米为单位）。

返回与该点距离最近的 5 个对象：

=> SELECT ST_AsText(nn), dist FROM (SELECT STV_NN(g,
   ST_GeographyFromText('POINT(23.5 20)'),5) OVER() AS (nn,dist) FROM points) AS example;
     ST_AsText      |       dist
--------------------+------------------
 POINT (23.5 18.4)  |  177912.12757541
 POINT (22.5 18.33) | 213339.210738322
 POINT (21.5 20.7)  |  222561.43679943
 POINT (21.5 19.2)  | 227604.371833335
 POINT (21.5 18.4)  | 275239.416790128
(5 rows)

4.11.67 - STV_PolygonPoint

将多边形的顶点作为个别点进行检索。 根据输入对象的类型，返回的值为 GEOMETRY 或 GEOGRAPHY 类型的点。GEOMETRY 点将继承输入对象的 SRID。

STV_PolygonPoint 为分析函数。有关详细信息，请参阅分析函数。

行为类型

不可变

语法

STV_PolygonPoint( g )
    OVER( [PARTITION NODES] ) AS

参数

g
多边形，GEOMETRY 或 GEOGRAPHY 类型的值

返回

GEOMETRY 或 GEOGRAPHY

支持的数据类型

示例

以下示例显示了 STV_PolygonPoint 的用法。

返回几何多边形的顶点：


=> SELECT ST_AsText(g) FROM (SELECT STV_PolygonPoint(ST_GeomFromText('POLYGON((1 2, 2 3, 3 1, 1 2))'))
     OVER (PARTITION NODES) AS g) AS poly_points;
  ST_AsText
-------------
 POINT (1 2)
 POINT (2 3)
 POINT (3 1)
 POINT (1 2)
(4 rows)

返回地理多边形的顶点：


=> SELECT ST_AsText(g) FROM (SELECT STV_PolygonPoint(ST_GeographyFromText('
              POLYGON((25.5 28.76, 28.83 29.13, 27.2 30.99, 25.5 28.76))'))
   OVER (PARTITION NODES) AS g) AS poly_points;
      ST_AsText
---------------------
 POINT (25.5 28.76)
 POINT (28.83 29.13)
 POINT (27.2 30.99)
 POINT (25.5 28.76)
(4 rows)

另请参阅

STV_LineStringPoint

4.11.68 - STV_Reverse

反转空间对象顶点的顺序。

行为类型

不可变

语法

STV_Reverse( g, [USING PARAMETERS skip_nonreorientable_polygons={true | false} ])

参数

g
空间对象，类型为 GEOGRAPHY。
skip_nonreorientable_polygons = { true | false }

（可选）Boolean

当设置为 False 时，不可定向的多边形将会生成错误。例如，如果将 STV_ForceLHR 或 STV_Reverse 与设置为 False 的 skip_nonorientable_polygons 配合使用，则包含孔的地理多边形将会生成错误。当设置为 True 时，返回的结果将是传递给 API 的未经更改的多边形。

此实参可帮助从包含无法重新定向的多边形的表创建索引。

Vertica Place 将以下多边形视为不可定向：

  • 包含孔的多边形

  • 多边形集合

  • 包含孔的多边形集合

默认值：False

返回

GEOGRAPHY

支持的数据类型

示例

以下示例显示了 STV_Reverse 的用法。

反转地理多边形的顶点：

=> SELECT ST_AsText(STV_Reverse(ST_GeographyFromText('Polygon((1 1, 3 1, 2 2, 1 1))')));
            ST_AsText
--------------------------------
 POLYGON ((1 1, 2 2, 3 1, 1 1))
(1 row)

强制多边形反转方向：

=> SELECT ST_AsText(STV_Reverse(ST_GeographyFromText('Polygon((1 1, 2 2, 3 1, 1 1))')));
ST_AsText
--------------------------------
 POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)

另请参阅

STV_ForceLHR

4.11.69 - STV_Rename_Index

为空间索引重命名。如果索引格式过期，则不能为索引重命名。

利用一个输入多边形集（可以是查询的结果），可以创建空间索引。空间索引是在全局命名空间中创建的。每当跨群集的节点对输入表或投影分段时，Vertica 会采用分布式计划。

OVER() 子句必须为空。

行为类型

不可变

语法

STV_Rename_Index( USING PARAMETERS
                  source = 'old_index_name',
                  dest = 'new_index_name',
                  overwrite = [ 'true' | 'false' ]
                )
                 OVER ()

参数

source = 'old_index_name'
空间索引的当前名称，类型为 VARCHAR。
dest = 'new_index_name'
空间索引的新名称，类型为 VARCHAR。
overwrite = [ 'true' | 'false' ]

用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。

默认值： False

特权

任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。

限制

  • 索引名称不能超过 110 个字符。

  • 索引名称中不允许使用反斜杠或制表符。

示例

以下示例显示了 STV_Rename_Index 的用法。

为索引重命名：

=> SELECT STV_Rename_Index (
       USING PARAMETERS
       source = 'my_polygons',
       dest = 'US_states',
       overwrite = 'false'
       )
       OVER ();
 rename_index
---------------
 Index renamed
(1 Row)

4.11.70 - STV_Refresh_Index

将新添加或更新的多边形追加到现有的空间索引，以及从现有的空间索引中移除已删除的多边形。

OVER() 子句必须为空。

行为类型

可变

语法

STV_Refresh_Index( gid, g
                   USING PARAMETERS index='index_name'
                    [, skip_nonindexable_polygons={ true | false } ] )


                 OVER()
                    [ AS (type, polygons, srid, min_x, min_y, max_x, max_y, info,
               indexed, appended, updated, deleted) ]

参数

gid
唯一标识多边形的 Integer 列的名称。Gid 不能为 NULL。
g
包含多边形或多边形集合的几何或地理 (WGS84) 列或表达式的名称。只能对多边形和多边形集合编制索引。将从索引中排除其他图形类型。

参数

index = 'index_name'
索引的名称，类型为 VARCHAR。索引名称不能超过 110 个字符。索引名称中不允许使用斜杠、反斜杠和制表符。
skip_nonindexable_polygons = { true | false }

（可选）BOOLEAN

在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。这些多边形被视为不可编制索引。当设置为 False 时，不可编制索引的多边形会导致创建索引失败。当设置为 True 时，可通过从索引中排除不可编制索引的多边形成功创建索引。

要审查无法编制索引的多边形，请配合参数 list_polygon 使用 STV_Describe_Index。

默认值：False

返回

type
索引的空间对象类型。
polygons
已编制索引的多边形数量。
SRID
空间参照系标识符。
min_x, min_y, max_x, max_y
已编制索引的几何图形的最小边界矩形 (MBR) 的坐标。(min_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。
info
列出从索引中排除的空间对象数量及其类型。
indexed
在操作期间编制索引的多边形数量。
appended
追加的多边形数量。
updated
更新的多边形数量。
deleted
删除的多边形数量。

支持的数据类型

特权

任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。

限制

  • 在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。请参见参数 skip_nonindexable_polygons。

  • 如果将源表中的有效多边形替换为无效的多边形，STV_Refresh_Index 将会忽略无效的多边形。因此，原来已编制索引的多边形仍保留在索引中。

  • 无法索引以下几何图形：

    • 非多边形

    • NULL gid

    • NULL 多边形（集合）

    • EMPTY 多边形（集合）

    • 无效多边形（集合）

  • 以下地形不包含在索引中：

    • 带孔的多边形
    • 跨越国际日期变更线的多边形
    • 覆盖北极或南极的多边形
    • 对跖多边形

使用提示

  • 要取消运行 STV_Refresh_Index，请使用 Ctrl + C。

  • 如果使用之前没有与索引关联的源数据，则会覆盖索引。

  • 如果 STV_Refresh_Index 没有足够的内存处理该查询，则将使用 STV_Create_Index 重建索引。

  • 如果 Geometry 列没有有效的多边形，STV_Refresh_Index 将在 vertica.log 中报告错误并停止刷新索引。

  • 确保您计划索引的所有多边形都是有效的多边形。STV_Create_Index 和 STV_Refresh_Index 在构建索引时不检查多边形的有效性。

    有关详细信息，请参阅创建或刷新索引之前确保多边形的有效性。

示例

以下示例显示了 STV_Refresh_Index 的用法。

使用单个字面参数刷新索引：

=> SELECT STV_Create_Index(1, ST_GeomFromText('POLYGON((0 0,0 15.2,3.9 15.2,3.9 0,0 0))')
     USING PARAMETERS index='my_polygon') OVER();
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        1 |    0 |     0 |     0 |   3.9 |  15.2 |
(1 row)


=> SELECT STV_Refresh_Index(2, ST_GeomFromText('POLYGON((0 0,0 13.2,3.9 18.2,3.9 0,0 0))')
     USING PARAMETERS index='my_polygon') OVER();
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info | indexed | appended | updated | deleted
----------+----------+------+-------+-------+-------+-------+------+---------+----------+---------+---------
 GEOMETRY |        1 |    0 |     0 |     0 |   3.9 |  18.2 |      |       1 |        1 |       0 |       1
(1 row)

刷新表索引：

=> CREATE TABLE pols (gid INT, geom GEOMETRY);
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((5 20,9 30,20 45,36 35,5 20))
>> 3|POLYGON((12 23,9 30,20 45,36 35,37 67,45 80,50 20,12 23))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true)
     OVER() FROM pols;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
 GEOMETRY |        3 |    0 |   -36 |    20 |    50 |    80 |
(1 row)


=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 6|POLYGON((-32 74,8 70,8 50,-36 53,-32 74))
>> \\.
=> SELECT STV_Refresh_Index(gid, geom USING PARAMETERS index='my_polygons_1') OVER() FROM pols;
   type   | polygons | SRID | min_x | min_y | max_x | max_y | info | indexed | appended | updated | deleted
----------+----------+------+-------+-------+-------+-------+------+---------+----------+---------+---------
 GEOMETRY |        4 |    0 |   -36 |    20 |    50 |    80 |      |       1 |        1 |       0 |       0
(1 row)

另请参阅

4.11.71 - STV_SetExportShapefileDirectory

指定将 GEOMETRY 或 GEOGRAPHY 数据导出到 shapefile 的目录。不检查路径的有效性，并且路径不能为空。

行为类型

不可变

语法

STV_SetExportShapefileDirectory( USING PARAMETERS path='shapefile_path' )

参数

path = ' shapefile_path '
需要将 shapefile 导出到的路径。例如“/home/user/temp”。您还可以使用约定“<bucketname>/path”导出到您具有读写权限的挂载 S3 目录。

返回

图形文件导出目录的路径。

特权

只有 超级用户才能使用此函数。

示例

以下示例显示了如何使用 STV_SetExportShapefileDirectory 将 shapefile 导出目录设为 /home/user/temp：

=> SELECT STV_SetExportShapefileDirectory(USING PARAMETERS path = '/home/user/temp');
              STV_SetExportShapefileDirectory
------------------------------------------------------------
 SUCCESS. Set shapefile export directory: [/home/user/temp]
(1 row)

4.11.72 - STV_ShpSource 和 STV_ShpParser

这两个函数与 COPY 配合使用，解析 shapefile 中的几何图形和属性并将其加载到 Vertica 表，然后转换为适当的 GEOMETRY 数据类型。必须将这两个函数一起使用。

存在以下限制：

  • 无法从 shapefile 加载空的点集合或无效的多边形集合。

  • 如果 shapefile 的 .dbf 组件包含数字属性，则在 Vertica Place shapefile 加载程序将此字段加载到表中时，此字段的值可能会损失精度。因为目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位；而在 .dbf 文件中，数字字段最多可达 30 位。

被拒绝的记录保存在 Vertica 编录目录下的 CopyErrorLogs 子目录。

行为类型

不可变

语法

COPY table( columnslist )
     WITH SOURCE STV_ShpSource
          ( file = 'filename'[[, SRID=spatial‑reference‑identifier] [, flatten_2d={true | false }] ] )
     PARSER STV_ShpParser()

参数

表
向其中加载几何数据的表名称。
columnslist
表中与外部文件中的字段相匹配的列名称的逗号分隔列表。运行 STV_ShpCreateTable 创建的 CREATE TABLE 命令。执行此操作时，这些列将对应第二列到倒数第二列。
file = 'pathname'
指定 .dbf、.shp 或 .shx 文件的完全限定路径。

您还可以从存储在您具有读取和写入权限的挂载 S3 目录中的 shapefile 加载。在这种情况下，请使用以下语法：

bucketname/path/filename
SRID=spatial‑reference‑identifier
指定与形状文件关联的整数空间参照标识符 (SRID)。
flatten_2d
指定在 COPY 命令期间排除 3D 或 4D 坐标的 BOOLEAN 实参：

  • true：在 COPY 命令之前排除具有 3D 或 4D 坐标的几何图形。

  • false：如果找到具有 3D 或 4D 坐标的几何图形，则会导致加载失败。

默认值： false

特权

  • 源 shapefile：读取

  • shapefile 目录：执行

COPY 错误

COPY 命令在以下任一情况下会失败：

  • 找不到或无法打开 shapefile。

  • STV_ShpParser 创建的列数或列数据类型与目标表中的列不匹配。使用 STV_ShpCreateTable 生成相应的 CREATE TABLE 命令。

  • 缺失或无法打开其中一个必要文件。打开 shapefile 时，您必须拥有三个文件：.dbf、.shp 和 .shx。

STV_ShpSource 文件损坏处理

  • 如果 .shp 和 .shx 文件已损坏，STV_ShpSource 将返回错误。

  • 如果 .shp 和 .shx 文件有效，但 .dbf 文件已损坏，STV_ShpSource 将忽略 .dbf 文件并且不创建该数据对应的列。

示例


=> COPY tl_2010_us_state10 WITH SOURCE
STV_ShpSource(file='/shapefiles/tl_2010_us_state10.shp', SRID=4269) PARSER STV_ShpParser();


 Rows loaded
-------------
          52

4.11.73 - STV_ShpCreateTable

返回包含在指定的 shapefile 中找到的属性列和类型的 CREATE TABLE 语句。

列类型将根据 shapefile 元数据调整大小。列大小基于在 shapefile 中找到的最大几何图形。表中的第一列是 gid，它是自动递增的 IDENTITY 主关键字列。缓存值默认设为 64。最后一列是用于存储实际几何数据的 GEOMETRY 数据类型。

行为类型

不可变

语法

STV_ShpCreateTable (USING PARAMETERS file='filename') OVER()

参数

file = 'filename'
.dbf、.shp 或 .shx 文件的完全限定路径（文件扩展名可选）。

您还可以使用存储在您具有读取和写入权限的挂载 S3 目录中的 shapefile 创建表。使用以下语法：

bucketname/path/filename

返回

与指定的 shapefile 相匹配的 CREATE TABLE 语句

使用提示

  • STV_ShpCreateTable 会返回 CREATE TABLE 语句；但它不会创建表。根据需要修改 CREATE TABLE 语句，在将 shapefile 加载到表中之前创建该表。

  • 要使用字母数字和下划线 (_) 字符之外的其他字符创建表，必须指定双引号括起的表名称，例如"counties%NY"。

  • 表名称与 shapefile 的名称相同（不包括目录名称或扩展名）。

  • 必须可以从启动节点访问 shapefile。

  • 如果 .shp 和 .shx 文件已损坏，STV_ShpCreateTable 将返回错误。如果 .shp 和 .shx 文件有效，但 .dbf 文件已损坏，STV_ShpCreateTable 将忽略 .dbf 文件并且不创建该数据对应的列。

  • 所有必要文件（.dbf、.shp、.shx）必须在同一个目录中。否则，STV_ShpCreateTable 将会返回错误。

  • 如果 shapefile 的 .dbf 组件包含数字属性，则在 Vertica shapefile 加载程序将此字段加载到表中时，此字段的值可能会损失精度。因为目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位。而在 .dbf 文件中，数字字段最多可达 30 位。

    Vertica 会在 vertica.log 文件中记录所有太长的 shapefile 值实例。

示例

以下示例显示了 STV_ShpCreateTable 的用法。

返回 CREATE TABLE 语句：


=> SELECT STV_ShpCreateTable
      (USING PARAMETERS file='/shapefiles/tl_2010_us_state10.shp')
      OVER() as create_table_states;
      create_table_states
 ----------------------------------
CREATE TABLE tl_2010_us_state10(
   gid IDENTITY(64) PRIMARY KEY,
   REGION10 VARCHAR(2),
   DIVISION10 VARCHAR(2),
   STATEFP10 VARCHAR(2),
   STATENS10 VARCHAR(8),
   GEOID10 VARCHAR(2),
   STUSPS10 VARCHAR(2),
   NAME10 VARCHAR(100),
   LSAD10 VARCHAR(2),
   MTFCC10 VARCHAR(5),
   FUNCSTAT10 VARCHAR(1),
   ALAND10 INT8,
   AWATER10 INT8,
   INTPTLAT10 VARCHAR(11),
   INTPTLON10 VARCHAR(12),
   geom GEOMETRY(940845)
);
(18 rows)

另请参阅

4.12 - Hadoop 函数

此部分包含用于管理与 Hadoop 交互的函数。

4.12.1 - CLEAR_HDFS_CACHES

清除从 HDFS 复制的配置信息和任何缓存的连接。

此函数通过以下方式影响使用 hdfs 方案的读取：

  • 此函数刷新从 Hadoop 复制的配置文件（例如 core-site.xml）加载的信息。这些文件位于 HadoopConfDir 配置参数设置的路径中。

  • 此函数刷新有关在高可用性 (HA) Hadoop 群集中哪个 NameNode 处于活动状态的信息。因此，调用此函数后对 Hadoop 的第一次请求比预期的要慢。

Vertica 维护与 NameNode 的打开连接的缓存以减少延迟。此函数刷新该缓存。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_HDFS_CACHES ( )

超级用户

示例

以下示例清除了 Hadoop 配置信息：

=> SELECT CLEAR_HDFS_CACHES();
 CLEAR_HDFS_CACHES
--------------
 Cleared
(1 row)

另请参阅

Hadoop 参数

4.12.2 - EXTERNAL_CONFIG_CHECK

测试 Vertica 群集的 Hadoop 配置。该函数测试 HDFS 配置文件、HCatalog 连接器配置和 Kerberos 配置。

该函数调用以下函数：

如果使用一个实参调用此函数，它会将此实参传递给它调用的函数，这些函数也接受一个实参。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXTERNAL_CONFIG_CHECK( ['what_to_test' ] )

参数

what_to_test
字符串，指定要测试的权限、名称服务和/或 HCatalog 架构。格式是“键=值”对的逗号分隔列表，其中键为 "authority"、"nameservice" 和 "schema"。值传递给所有子函数；有关如何解释值的详细信息，请参阅这些参考页面。

特权

此函数不需要权限。

示例

以下示例仅测试名为“ns1”的名称服务的配置。由于长度原因，输出已被忽略。

=> SELECT EXTERNAL_CONFIG_CHECK('nameservice=ns1');

4.12.3 - GET_METADATA

返回 Parquet 文件的元数据。元数据包括行组的数量和大小、列名以及有关块和压缩的信息。元数据以 JSON 形式返回。

此函数检查一个文件。Parquet 数据通常跨越单个目录中的多个文件；选择一个。该函数不接受目录名称作为实参。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_METADATA( 'filename' )

参数

filename
Parquet 文件的名称。任何对 COPY 有效的路径都对该函数有效。此函数不对其他格式的文件进行操作。

特权

在 USER 可访问的存储位置上具有 READ 权限的超级用户或非超级用户（请参阅 GRANT（存储位置））。

示例

您必须使用单个文件而不是目录或 glob 调用此函数：

=> SELECT GET_METADATA('/data/emp-row.parquet');
                GET_METADATA
----------------------------------------------------------------------------------------------------
 schema:
required group field_id=-1 spark_schema {
  optional int32 field_id=-1 employeeID;
  optional group field_id=-1 personal {
    optional binary field_id=-1 name (String);
    optional group field_id=-1 address {
      optional binary field_id=-1 street (String);
      optional binary field_id=-1 city (String);
      optional int32 field_id=-1 zipcode;
    }
    optional int32 field_id=-1 taxID;
  }
  optional binary field_id=-1 department (String);
}

 data page version:
  data page v1

 metadata:
{
  "FileName": "/data/emp-row.parquet",
  "FileFormat": "Parquet",
  "Version": "1.0",
  "CreatedBy": "parquet-mr version 1.10.1 (build a89df8f9932b6ef6633d06069e50c9b7970bebd1)",
  "TotalRows": "4",
  "NumberOfRowGroups": "1",
  "NumberOfRealColumns": "3",
  "NumberOfColumns": "7",
  "Columns": [
     { "Id": "0", "Name": "employeeID", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
     { "Id": "1", "Name": "personal.name", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
     { "Id": "2", "Name": "personal.address.street", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
     { "Id": "3", "Name": "personal.address.city", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
     { "Id": "4", "Name": "personal.address.zipcode", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
     { "Id": "5", "Name": "personal.taxID", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
     { "Id": "6", "Name": "department", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} }
  ],
  "RowGroups": [
     {
       "Id": "0",  "TotalBytes": "642",  "TotalCompressedBytes": "0",  "Rows": "4",
       "ColumnChunks": [
          {"Id": "0", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "51513", "Min": "17103" },
           "Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "67", "CompressedSize": "69" },
          {"Id": "1", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Sheldon Cooper", "Min": "Howard Wolowitz" },
           "Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "142", "CompressedSize": "145" },
          {"Id": "2", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "52 Broad St", "Min": "100 Main St Apt 4A" },
           "Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "139", "CompressedSize": "123" },
          {"Id": "3", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Pasadena", "Min": "Pasadena" },
           "Compression": "SNAPPY", "Encodings": "RLE PLAIN_DICTIONARY BIT_PACKED ", "UncompressedSize": "95", "CompressedSize": "99" },
          {"Id": "4", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "91021", "Min": "91001" },
           "Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "68", "CompressedSize": "70" },
          {"Id": "5", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "4", "DistinctValues": "0", "Max": "0", "Min": "0" },
           "Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "28", "CompressedSize": "30" },
          {"Id": "6", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Physics", "Min": "Astronomy" },
           "Compression": "SNAPPY", "Encodings": "RLE PLAIN_DICTIONARY BIT_PACKED ", "UncompressedSize": "103", "CompressedSize": "107" }
        ]
     }
  ]
}

(1 row)

4.12.4 - HADOOP_IMPERSONATION_CONFIG_CHECK

报告 Vertica 在访问 HDFS 中的 Kerberized 数据时将使用的委派令牌。HadoopImpersonationConfig 配置参数指定一个或多个权限、名称服务和 HCatalog 架构及其关联的令牌。对于每个测试值，该函数会报告 Vertica 将使用什么 doAs 用户或委派令牌进行访问。使用此函数确认您已按预期定义了您的委派令牌。

您可以使用实参调用此函数来指定要测试的权限、名称服务或 HCatalog 架构，或者不使用实参来测试所有配置的值。

此函数不检查您是否可以使用这些委派令牌访问 HDFS。

有关模拟的详细信息，请参阅 代理用户和委托令牌。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

HADOOP_IMPERSONATION_CONFIG_CHECK( ['what_to_test' ] )

参数

what_to_test
字符串，指定要测试的权限、名称服务和/或 HCatalog 架构。例如，“nameservice=ns1”的值意味着该函数仅测试对名称服务“ns1”的访问，而忽略任何其他权限和架构。'nameservice=ns1, schema=hcat1' 的值表示该函数测试一个名称服务和一个 HCatalog 架构。

如果您不指定此实参，该函数将测试 HadoopImpersonationConfig 中定义的所有权限、名称服务和架构。

特权

此函数不需要权限。

示例

考虑 HadoopImpersonationConfig 的以下定义：

[{
        "nameservice": "ns1",
        "token": "RANDOM-TOKEN-STRING"
    },
    {
        "nameservice": "*",
        "doAs": "Paul"
    },
    {
        "schema": "hcat1",
        "doAs": "Fred"
    }
]

以下查询仅测试“ns1”名称服务：

=> SELECT HADOOP_IMPERSONATION_CONFIG_CHECK('nameservice=ns1');

-- hadoop_impersonation_config_check --
Connections to nameservice [ns1] will use a delegation token with hash [b3dd9e71cd695d91]

出于安全原因，此函数返回令牌的哈希值。您可以使用预期值调用 HASH_EXTERNAL_TOKEN 并将该哈希值与此函数输出中的哈希值进行比较。

不带实参的查询会测试所有值：

=> SELECT HADOOP_IMPERSONATION_CONFIG_CHECK();

-- hadoop_impersonation_config_check --
Connections to nameservice [ns1] will use a delegation token with hash [b3dd9e71cd695d91]
JDBC connections for HCatalog schema [hcat1] will doAs [Fred]
[!] hadoop_impersonation_config_check : [PASS]

4.12.5 - HASH_EXTERNAL_TOKEN

返回字符串令牌的哈希值，用于 HADOOP_IMPERSONATION_CONFIG_CHECK。使用您希望 Vertica 使用的委派令牌调用 HASH_EXTERNAL_TOKEN，并将其与 HADOOP_IMPERSONATION_CONFIG_CHECK 输出中的哈希值进行比较。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

HASH_EXTERNAL_TOKEN( 'token' )

参数

token
指定要哈希的令牌的字符串。令牌在 HadoopImpersonationConfig 参数中配置。

特权

此函数不需要权限。

示例

以下查询测试 HADOOP_IMPERSONATION_CONFIG_CHECK 参考页面上示例中显示的预期值。

=> SELECT HASH_EXTERNAL_TOKEN('RANDOM-TOKEN-STRING');
hash_external_token
---------------------
b3dd9e71cd695d91
(1 row)

4.12.6 - HCATALOGCONNECTOR_CONFIG_CHECK

测试使用 HCatalog 连接器访问 Hive 数据的 Vertica 群集的配置。该函数首先验证 HCatalog 连接器是否已正确安装并报告几个相关配置参数的值。然后它使用 HiveServer2 测试连接。此函数不支持 WebHCat 服务器。

如果您指定 HCatalog 架构，并且您已为该架构定义了委派令牌，则此函数使用委派令牌。否则，该函数使用没有委派令牌的默认端点。

有关委派令牌的详细信息，请参阅代理用户和委托令牌。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

HCATALOGCONNECTOR_CONFIG_CHECK( ['what_to_test' ] )

参数

what_to_test
字符串，指定要测试的 HCatalog 架构。例如，“schema=hcat1”的值意味着该函数仅测试“hcat1”架构并忽略找到的任何其他架构。

特权

此函数不需要权限。

示例

以下查询使用默认端点和无委派令牌进行测试。

=> SELECT HCATALOGCONNECTOR_CONFIG_CHECK();

-- hcatalogconnector_config_check --

    HCatalogConnectorUseHiveServer2 : [1]
    EnableHCatImpersonation : [1]
    HCatalogConnectorUseORCReader : [1]
    HCatalogConnectorUseParquetReader : [1]
    HCatalogConnectorUseTxtReader : [0]
  [INFO] Vertica is not configured to use its internal parsers for delimited files.
  [INFO] This is off by default, but will be changed in a future release.
    HCatalogConnectorUseLibHDFSPP : [1]

  [OK] HCatalog connector library is properly installed.
  [INFO] Creating JDBC connection as session user.
  [OK] Successful JDBC connection to HiveServer2 as user [USER].

  [!] hcatalogconnector_config_check : [PASS]

要使用配置的委派令牌进行测试，请将架构作为实参传递：

=> SELECT HCATALOGCONNECTOR_CONFIG_CHECK('schema=hcat1');

4.12.7 - HDFS_CLUSTER_CONFIG_CHECK

测试使用 HDFS 的 Vertica 群集的配置。该函数扫描在 HadoopConfDir 中找到的 Hadoop 配置文件，并对它找到的每个群集执行配置检查。如果您配置了多个群集，您可以指定测试哪一个而不是测试所有群集。

对于每个 Hadoop 群集，它报告的属性包括：

  • 名称服务名称和关联的 NameNode

  • 高可用性状态

  • RPC 加密状态

  • Kerberos 身份验证状态

  • HTTP(S) 状态

然后，它使用 http(s)、hdfs 和 webhdfs URL 方案测试连接。它使用 Vertica 和会话用户测试后两者。

有关配置文件和 HadoopConfDir 的信息，请参阅配置 HDFS 访问。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

HDFS_CLUSTER_CONFIG_CHECK( ['what_to_test' ] )

参数

what_to_test
字符串，指定要测试的权限或名称服务。例如，“nameservice=ns1”的值表示该函数仅测试“ns1”群集。如果您同时指定了权限和名称服务，则权限必须是指定名称服务中的 NameNode 才能通过检查。

如果您不指定此实参，该函数将测试在 HadoopConfDir 中找到的所有群集配置。

特权

此函数不需要权限。

示例

以下示例测试所有群集。

=> SELECT HDFS_CLUSTER_CONFIG_CHECK();

-- hdfs_cluster_config_check --

    Hadoop Conf Path : [/conf/hadoop_conf]
  [OK] HadoopConfDir verified on all nodes
    Connection Timeout (seconds) : [60]
    Token Refresh Frequency (seconds) : [0]
    HadoopFSBlockSizeBytes (MiB) : [64]

  [OK] Found [1] hadoop cluster configurations

------------- Cluster 1 -------------
    Is DefaultFS : [true]
    Nameservice : [vmns]
    Namenodes : [node1.example.com:8020, node2.example.com:8020]
    High Availability : [true]
    RPC Encryption : [false]
    Kerberos Authentication : [true]
    HTTPS Only : [false]
  [INFO] Checking connections to [hdfs:///]
    vertica : [OK]
    dbuser : [OK]

  [INFO] Checking connections to [http://node1.example.com:50070]
  [INFO] Node is in standby
  [INFO] Checking connections to [http://node2.example.com:50070]
  [OK] Can make authenticated external curl connection
  [INFO] Checking webhdfs
    vertica : [OK]
    USER : [OK]

  [!] hdfs_cluster_config_check : [PASS]

4.12.8 - KERBEROS_HDFS_CONFIG_CHECK

测试使用 HDFS 的 Vertica 群集的 Kerberos 配置。如果该函数可以同时使用 Vertica keytab 文件和会话用户访问 HDFS，则该函数成功，否则报告错误。该函数是 KERBEROS_CONFIG_CHECK 的一个更具体的版本。

如果当前会话没有 Kerberos 化，该函数将不能使用安全的 HDFS 连接并且会失败。

您可以使用实参调用此函数来指定要测试的 HDFS 配置，也可以不使用实参。如果你不使用实参调用此函数，该函数会读取 HDFS 配置文件，如果没有找到它们就会失败。请参阅配置 HDFS 访问。如果它找到配置文件，它会测试所有配置的名称服务。

该函数按顺序执行以下测试：

  • 是否提供 Kerberos 服务？

  • 是否存在 keytab 文件，是否在数据库中设置了 Kerberos 和 HDFS 配置参数？

  • Vertica 是否可以读取并使用密钥调用 kinit 以向 HDFS 进行身份验证并获取数据库 Kerberos 票证？

  • Vertica 能否同时使用数据库 Kerberos 票证和当前会话的用户可转发票证来执行 hdfs 和 webhdfs 操作？

  • Vertica 是否可以连接到 HiveServer2？（此函数不支持 WebHCat。）

如果任何测试失败，该函数将返回描述性错误消息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

KERBEROS_HDFS_CONFIG_CHECK( ['hdfsHost:hdfsPort',
  'webhdfsHost:webhdfsPort', 'webhcatHost' ] )

参数

hdfsHost, hdfsPort
HDFS NameNode 的主机名或 IP 地址和端口。Vertica 使用此服务器访问通过 hdfs URL 指定的数据。如果值为 ' '，则函数跳过这部分检查。
webhdfsHost, webhdfsPort
WebHDFS 服务器的主机名或 IP 地址和端口。Vertica 使用此服务器访问通过 webhdfs URL 指定的数据。如果值为 ' '，则函数跳过这部分检查。
webhcatHost
在此位置传递任何值。WebHCat 已弃用，此值被忽略但必须存在。

特权

此函数不需要权限。

4.12.9 - SYNC_WITH_HCATALOG_SCHEMA

将通过 HCatalog 连接器可用的 Hive 数据库架构的结构复制到 Vertica 架构。如果 HCatalog 架构和目标 Vertica 架构具有匹配的表名，SYNC_WITH_HCATALOG_SCHEMA 将覆盖 Vertica 表。

该函数可以直接同步 HCatalog 架构。在这种情况下，对 vertica_schema 和 hcatalog_schema 参数使用相同的架构名称调用该函数。该函数还可以将不同的架构同步到 HCatalog 架构。

如果更改 HCatalog 连接器配置参数的设置，必须再次调用该函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SYNC_WITH_HCATALOG_SCHEMA( vertica_schema, hcatalog_schema, [drop_non_existent] )

参数

vertica_schema
用于存储复制的 HCatalog 架构元数据的目标 Vertica 架构。这可以是与 hcatalog_schema 相同的架构，也可以是使用 CREATE SCHEMA 创建的单独架构。
hcatalog_schema
要复制的 HCatalog 架构，使用 CREATE HCATALOG SCHEMA
创建drop_non_existent
如果 true，请删除 vertica_schema 中与 hcatalog_schema 中的表不对应的任何表

特权

非超级用户：vertica_schema 上的 CREATE 权限。

用户还需要 Hive 数据的以下访问权限之一：

  • hcat_schema 的使用权限（如果 Hive 不使用授权服务来管理访问权限）。

  • 通过授权服务（Sentry 或 Ranger）进行管理的权限，以及 HDFS 中的底层文件的访问权限。（Sentry 可以通过 ACL 同步提供该访问权限。）

  • dbadmin 用户权限（有/无授权服务）。

数据类型匹配

在 Vertica 中，Hive STRING 和 BINARY 数据类型与 VARCHAR(65000) 和 VARBINARY(65000) 类型相匹配。创建架构后，根据需要使用 ALTER TABLE调整数据类型。Vertica 中的 VARCHAR 或 VARBINARY 的最大大小为 65000，但您可以使用 LONG VARCHAR 和 LONG VARBINARY 指定更大的值。

Hive 和 Vertica 以不同的方式定义字符串长度。在 Hive 中，长度是指字符的数量；在 Vertica 中，长度是指字节的数量。因此，使用多个字节的字符编码（例如 Unicode）可能会导致两者之间不匹配。为避免数据截断，请根据字节而不是字符设置 Vertica 中的值。

如果数据大小超出列大小，Vertica 将在读取时间在 QUERY_EVENTS 系统表中记录一个事件。

示例

以下示例使用 SYNC_WITH_HCATALOG_SCHEMA 同步名为 hcat 的 HCatalog 架构：

=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
   HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat', 'hcat');
sync_with_hcatalog_schema
----------------------------------------
Schema hcat synchronized with hcat
tables in hcat = 56
tables altered in hcat = 0
tables created in hcat = 56
stale tables in hcat = 0
table changes erred in hcat = 0
(1 row)

=> -- Use vsql's \d command to describe a table in the synced schema

=> \d hcat.messages
List of Fields by Tables
  Schema   |   Table  | Column  |      Type      | Size  | Default | Not Null | Primary Key | Foreign Key
-----------+----------+---------+----------------+-------+---------+----------+-------------+-------------
hcat       | messages | id      | int            |     8 |         | f        | f           |
hcat       | messages | userid  | varchar(65000) | 65000 |         | f        | f           |
hcat       | messages | "time"  | varchar(65000) | 65000 |         | f        | f           |
hcat       | messages | message | varchar(65000) | 65000 |         | f        | f           |
(4 rows)

以下示例使用 SYNC_WITH_HCATALOG_SCHEMA 后跟 ALTER TABLE 来调整列值：

=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
-> HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat', 'hcat');
...
=> ALTER TABLE hcat.t ALTER COLUMN a1 SET DATA TYPE long varchar(1000000);
=> ALTER TABLE hcat.t ALTER COLUMN a2 SET DATA TYPE long varbinary(1000000);

以下示例使用带本地（非 HCatalog）架构的 SYNC_WITH_HCATALOG_SCHEMA：

=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
-> HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> CREATE SCHEMA hcat_local;
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat_local', 'hcat');

4.12.10 - SYNC_WITH_HCATALOG_SCHEMA_TABLE

将通过 HCatalog 连接器可用的 Hive 数据库架构中的单个表结构复制到 Vertica 表。

该函数可以直接同步 HCatalog 架构。在这种情况下，对 vertica_schema 和 hcatalog_schema 参数使用相同的架构名称调用该函数。该函数还可以将不同的架构同步到 HCatalog 架构。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SYNC_WITH_HCATALOG_SCHEMA_TABLE( vertica_schema, hcatalog_schema, table_name )

参数

vertica_schema
用于存储复制的 HCatalog 架构元数据的现有 Vertica 架构。这可以是与 hcatalog_schema 相同的架构，也可以是使用 CREATE SCHEMA 创建的单独架构。
hcatalog_schema
要复制的 HCatalog 架构，使用 CREATE HCATALOG SCHEMA 创建。
table_name
hcatalog_schema 中要复制的表。如果 vertica_schema 中已经存在 table_name，该函数将会覆盖它。

特权

非超级用户：vertica_schema 上的 CREATE 权限。

用户还需要 Hive 数据的以下访问权限之一：

  • hcat_schema 的使用权限（如果 Hive 不使用授权服务来管理访问权限）。

  • 通过授权服务（Sentry 或 Ranger）进行管理的权限，以及 HDFS 中的底层文件的访问权限。（Sentry 可以通过 ACL 同步提供该访问权限。）

  • dbadmin 用户权限（有/无授权服务）。

数据类型匹配

在 Vertica 中，Hive STRING 和 BINARY 数据类型与 VARCHAR(65000) 和 VARBINARY(65000) 类型相匹配。创建架构后，根据需要使用 ALTER TABLE调整数据类型。Vertica 中的 VARCHAR 或 VARBINARY 的最大大小为 65000，但您可以使用 LONG VARCHAR 和 LONG VARBINARY 指定更大的值。

Hive 和 Vertica 以不同的方式定义字符串长度。在 Hive 中，长度是指字符的数量；在 Vertica 中，长度是指字节的数量。因此，使用多个字节的字符编码（例如 Unicode）可能会导致两者之间不匹配。为避免数据截断，请根据字节而不是字符设置 Vertica 中的值。

如果数据大小超出列大小，Vertica 将在读取时间在 QUERY_EVENTS 系统表中记录一个事件。

示例

以下示例使用 SYNC_WITH_HCATALOG_SCHEMA_TABLE 来同步 "nation" 表：

=> CREATE SCHEMA 'hcat_local';
CREATE SCHEMA

=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='hcat'
   HCATALOG_USER='hcatuser';
CREATE SCHEMA

=> SELECT sync_with_hcatalog_schema_table('hcat_local', 'hcat', 'nation');
sync_with_hcatalog_schema_table
-----------------------------------------------------------------------------
    Schema hcat_local synchronized with hcat for table nation
    table nation is created in schema hcat_local
    (1 row)

以下示例显示本地架构中已存在 "nation" 表时的行为：

=> SELECT sync_with_hcatalog_schema_table('hcat_local','hcat','nation');
sync_with_hcatalog_schema_table
-----------------------------------------------------------------------------
    Schema hcat_local synchronized with hcat for table nation
    table nation is altered in schema hcat_local
    (1 row)

4.12.11 - VERIFY_HADOOP_CONF_DIR

验证用于访问 HDFS 的 Hadoop 配置在所有 Vertica 节点上是否有效。配置在以下情况下有效：

  • 所有必需的配置文件位于 HadoopConfDir 配置参数定义的路径中

  • Vertica 所需的所有属性都在这些文件中设置

此函数不会尝试验证这些属性的设置；它仅验证它们是否具有值。

Hadoop 配置可能在某些节点上有效而在其他节点上无效。如果值在任何节点上无效，该函数将报告验证失败；输出的其余部分报告详细信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

VERIFY_HADOOP_CONF_DIR( )

参数

此函数没有参数。

特权

此函数不需要权限。

示例

以下示例显示了 Hadoop 配置有效时的结果。

=> SELECT VERIFY_HADOOP_CONF_DIR();
    verify_hadoop_conf_dir
-------------------------------------------------------------------
Validation Success
v_vmart_node0001: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0002: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0003: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0004: HadoopConfDir [PG_TESTOUT/config] is valid
    (1 row)

在以下示例中，Hadoop 配置在一个节点上有效，但在其他节点上缺少所需的值。

=> SELECT VERIFY_HADOOP_CONF_DIR();
    verify_hadoop_conf_dir
-------------------------------------------------------------------
Validation Failure
v_vmart_node0001: HadoopConfDir [PG_TESTOUT/test_configs/config] is valid
v_vmart_node0002: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
v_vmart_node0003: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
v_vmart_node0004: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
    (1 row)

4.13 - 机器学习函数

利用机器学习函数可以处理数据分析过程不同阶段的数据集：

  • 准备模型

  • 训练模型

  • 评估模型

  • 应用模型

  • 管理模型

一些 Vertica 机器学习函数作为 Vertica UDx 函数实施，另一些函数则作为元函数实施：

  • UDx 函数接受来自 FROM 子句的输入关系名称。调用函数的 SELECT 语句可组合 — 可用作其他 SELECT 语句的子查询。

  • 元函数接受将输入关系名称作为单引号字符串传递，以作为实参或命名参数。SELECT 语句返回的数据不能用于子查询。机器学习元函数不支持临时表。

所有机器学习函数都会自动将 NUMERIC 实参转换为 FLOAT。

4.13.1 - 数据准备

Vertica 支持机器学习函数，可在对数据进行分析之前根据需要准备数据。

4.13.1.1 - BALANCE

根据 response_column 返回输入数据的平均分布视图。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

BALANCE ( 'output‑view', 'input‑relation', 'response‑column', 'balance‑method'
       [ USING PARAMETERS sampling_ratio=ratio ] )

参数

output‑view
Vertica 保存来自输入关系的平衡数据的视图的名称。
input‑relation
包含函数用于创建更平衡的数据集的数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示 VARCHAR 或 INTEGER 类型的因变量输入列的名称。
balance‑method
指定从少数类和多数类中选择数据的方法，为以下之一。

  • hybrid_sampling：对不同类执行过采样和欠采样，因此平等展现每个类。

  • over_sampling：对所有类过采样，多数类除外，适用于多数类的基数。

  • under_sampling：对所有类欠采样，少数类除外，适用于少数类的基数。

  • weighted_sampling：under_sampling 的别名。

参数

ratio
多数类与少数类之间的理想比例。与 balance 方法 hybrid_sampling 配合使用时，此值无效。

默认值： 1.0

特权

非超级用户：

  • 对输入关系的 SELECT 权限

  • 输出视图架构的 CREATE 权限

示例

=> CREATE TABLE backyard_bugs (id identity, bug_type int, finder varchar(20));
CREATE TABLE

=> COPY backyard_bugs FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|Ants
>> 1|Beetles
>> 3|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 3|Caterpillars
>> 2|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 1|Ladybugs
>> 3|Ladybugs
>> \.

=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs GROUP BY bug_type;
 bug_type | COUNT
----------+-------
        2 |     1
        1 |     3
        3 |     7
(3 rows)

=> SELECT BALANCE('backyard_bugs_balanced', 'backyard_bugs', 'bug_type', 'under_sampling');
         BALANCE
--------------------------
 Finished in 1 iteration

(1 row)

=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs_balanced GROUP BY bug_type;
----------+-------
        2 |     1
        1 |     2
        3 |     1
(3 rows)

另请参阅

4.13.1.2 - CORR_MATRIX

采用数字列的输入关系，计算其每对输入列之间的皮尔逊相关系数。函数作为多阶段转换函数实施。

语法

CORR_MATRIX ( input-columns ) OVER()

参数

input-columns
输入表中的列的逗号分隔列表。输入列可为任何数字类型或 BOOL，但将在内部转换为 FLOAT。输入列数必须大于 1 但不得大于 1600。

返回

CORR_MATRIX 以三元组格式返回关联矩阵。也就是说，每个成对关联通过三个返回的列标识：第一个变量的名称、第二个变量的名称和每对输入列的关联值。函数还会返回两个额外的列： number_of_ignored_input_rows 和 number_of_processed_input_rows。第四/五列的值表示输入中忽略/用于计算相应关联值的行数。任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。

关联矩阵对称，所有对角元素的值均为 1；因此，只能返回对角线以上元素的值 — 即上三角。尽管如此，函数返回整个矩阵以简化任何后续操作。因此，输出行数为：

(#input‑columns)^2

前两个输出列为 VARCHAR(128) 类型，第三个输出列为 FLOAT 类型，最后两个输出列为 INT 类型。

注意

  • OVER 子句的内容必须为空。

  • 当输入表为空时，函数不会返回任何行。

  • 当 X_i 和 Y_i 中的任何一个为 NULL、Inf 或 NaN 时，该对将不纳入 CORR(X, Y) 计算。也就是说，任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。

  • 对于 (X,X) 对，无论 X 的内容如何：CORR(X,X) = 1、number_of_ignored_input_rows = 0 且 number_of_processed_input_rows = #input_rows。

  • 当 (NSUMX2 == SUMXSUMX) 或 (NSUMY2 == SUMYSUMY) 时，则 CORR(X, Y) 的值将为 NULL。理论上，可能发生在具有常数值的列的情况；然而，由于舍入误差，可能无法始终观察到。

  • 在特殊情况下，即 (X_i,Y_i) 的所有对值均包含 NULL、inf 或 NaN 且 X != Y：CORR(X,Y)=NULL。

示例

下面的示例使用 iris 数据集。*

4.13.1.3 - DETECT_OUTLIERS

根据异常值阈值返回数据集中的异常值。输出为包含异常值的表。 DETECT_OUTLIERS 使用检测方法 robust_szcore 使每个输入列实现标准化。然后，函数将包含大于默认或指定阈值的标准化值的所有行标识为异常值。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DETECT_OUTLIERS ( 'output‑table', 'input‑relation','input‑columns', 'detection‑method'
        [ USING PARAMETERS
              [outlier_threshold = threshold]
              [, exclude_columns = 'excluded‑columns']
              [, partition_columns = 'partition‑columns'] ] )

参数

output‑table
Vertica 保存所选 input_columns 的异常值行的表的名称。所有列均存在于此表中。
input‑relation
包含异常数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列的类型必须为 数字。
detection‑method
要使用的异常值检测方法，设置为 robust_zscore。

参数

outlier_threshold
用于将该行标识为异常值的行中的最小标准化值。

默认值： 3.0

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

partition_columns
定义分区的输入表或视图中的列名的逗号分隔列表。 DETECT_OUTLIERS 分别检测每个分区中的异常值。

默认值： 空列表

特权

非超级用户：

  • 对输入关系的 SELECT 权限

  • 对输出表的 CREATE 权限

示例

以下示例显示了 DETECT_OUTLIERS 的用法：

=> CREATE TABLE baseball_roster (id identity, last_name varchar(30), hr int, avg float);
CREATE TABLE

=> COPY baseball_roster FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Polo|7|.233
>> Gloss|45|.170
>> Gus|12|.345
>> Gee|1|.125
>> Laus|3|.095
>> Hilltop|16|.222
>> Wicker|78|.333
>> Scooter|0|.121
>> Hank|999999|.8888
>> Popup|35|.378
>> \.


=> SELECT * FROM baseball_roster;
 id | last_name |   hr   |  avg
----+-----------+--------+--------
  3 | Gus       |     12 |  0.345
  4 | Gee       |      1 |  0.125
  6 | Hilltop   |     16 |  0.222
 10 | Popup     |     35 |  0.378
  1 | Polo      |      7 |  0.233
  7 | Wicker    |     78 |  0.333
  9 | Hank      | 999999 | 0.8888
  2 | Gloss     |     45 |   0.17
  5 | Laus      |      3 |  0.095
  8 | Scooter   |      0 |  0.121
(10 rows)

=> SELECT DETECT_OUTLIERS('baseball_outliers', 'baseball_roster', 'id, hr, avg', 'robust_zscore' USING PARAMETERS
outlier_threshold=3.0);

     DETECT_OUTLIERS
--------------------------
 Detected 2 outliers

(1 row)

=> SELECT * FROM baseball_outliers;
 id | last_name | hr         | avg
----+-----------+------------+-------------
  7 | Wicker    |         78 |       0.333
  9 | Hank      |     999999 |      0.8888
(2 rows)

4.13.1.4 - IFOREST

训练并返回隔离森林 (iForest) 模型。训练模型后，可以使用 APPLY_IFOREST 函数预测输入关系中的异常值。

有关 iForest 算法工作原理的详细信息，请参阅隔离森林。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

IFOREST( 'model‑name', 'input‑relation', 'input‑columns' [ USING PARAMETERS param=value[,...] ] )

参数

model-name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 IFOREST 的输入数据的表或视图。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 列类型必须为 CHAR、VARCHAR、BOOL、INT 或 FLOAT。

CHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。

参数

exclude_columns
input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

默认值： 空字符串 ('')

ntree
[1, 1000] 范围内的整数，指定森林中树的数量。

默认值： 100

sampling_size
(0.0, 1.0] 范围内的浮点数，指定随机挑选的部分输入数据集，不做替换，用于对每个树进行训练。

默认值： 0.632

col_sample_by_tree
(0.0, 1.0] 范围内的浮点数，指定为训练每个树而随机挑选的部分列。

默认值： 1.0

max_depth
[1, 100] 范围内的整数，指定生长每个树的最大深度。

默认值： 10

nbins
[2, 1000] 范围内的整数，指定用于离散连续特征的 bin 数量。

默认值： 32

模型属性

details
有关函数预测变量列的详细信息，包括：

  • predictor：预测变量的名称与训练模型时指定的顺序相同。

  • type：预测变量的类型的顺序与其名称在 predictor 中的顺序相同。

tree_count
模型中的树的数量。
rejected_row_count
input-relation 中因包含无效值而被跳过的行数。
accepted_row_count
input-relation 中的总行数减去 rejected_row_count。
call_string
调用函数时指定的所有输入实参的值。

特权

非超级用户：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

示例

在以下示例中，函数的输入数据包含 INT、VARCHAR 和 FLOAT 类型的列：

=> SELECT IFOREST('baseball_anomalies','baseball','team, hr, hits, avg, salary' USING PARAMETERS ntree=75, sampling_size=0.7,
max_depth=15);
IFOREST
----------
Finished
(1 row)

您可以通过调用 GET_MODEL_SUMMARY 并检查详细信息部分来验证是否正确读取所有输入列：

=> SELECT GET_MODEL_SUMMARY(USING PARAMETERS model_name='baseball_anomalies');
GET_MODEL_SUMMARY
-------------------------------------------------------------------------------------------------------------------------------------

===========
call_string
===========
SELECT iforest('public.baseball_anomalies', 'baseball', 'team, hr, hits, avg, salary' USING PARAMETERS exclude_columns='', ntree=75,
sampling_size=0.7, col_sample_by_tree=1, max_depth=15, nbins=32);

=======
details
=======
predictor|      type
---------+----------------
  team   |char or varchar
   hr    |      int
  hits   |      int
   avg   |float or numeric
 salary  |float or numeric


===============
Additional Info
===============
       Name       |Value
------------------+-----
    tree_count    | 75
rejected_row_count|  0
accepted_row_count|1000

(1 row)

另请参阅

4.13.1.5 - IMPUTE

根据每列中变量的观察值，使用平均值或众数估算数据集中的缺失值。此函数支持数字和分类数据类型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

IMPUTE( 'output‑view', 'input‑relation', 'input‑columns', 'method'
        [ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, partition_columns = 'partition‑columns'] ] )

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

参数

output‑view
显示输入表的视图的名称，其中包含估算值而不是缺失值。在此视图中，不含缺失值的行保持不变，而含缺失值的行则根据指定方法进行修改。
input‑relation
包含缺失值插补数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
将替换缺失值的输入列的逗号分隔列表，或使用星号 (*) 指定所有列。所有列的类型必须为数字或布尔值。
method
计算缺失值替换的方法，为以下之一：

  • mean：每列中的缺失值将替换为该列的平均值。此方法仅适用于数字数据。

  • mode：每列中的缺失值将替换为该列中出现频率最高的值。此方法仅适用于分类数据。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

partition_columns
定义分区的输入关系中的列名的逗号分隔列表。

特权

非超级用户：

  • 对输入关系的 SELECT 权限

  • 输出视图架构的 CREATE 权限

示例

在 small_input_impute 表上执行 IMPUTE，指定平均值方法：

=> SELECT impute('output_view','small_input_impute', 'pid, x1,x2,x3,x4','mean'
USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)

执行IMPUTE，指定模式方法：

=> SELECT impute('output_view3','small_input_impute', 'pid, x5,x6','mode' USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)

另请参阅

估算缺失值

4.13.1.6 - NORMALIZE

对输入关系运行标准化算法。输出是具有标准化数据的视图。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

NORMALIZE ( 'output‑view', 'input‑relation', 'input‑columns', 'normalization‑method'
           [ USING PARAMETERS exclude_columns = 'excluded‑columns' ] )

参数

output‑view
显示输入关系的视图的名称，其中标准化数据替换了指定的输入列。 .
input‑relation
包含需要标准化的数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
数字输入列的逗号分隔列表，其中包含要标准化的值，或用于选择所有列的星号 (*)。
normalization‑method
要使用的标准化方法，为以下之一：

  • minmax

  • zscore

  • robust_zscore

如果表中出现无穷大值，该方法将自动忽略这些值。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

特权

非超级用户：

  • 对输入关系的 SELECT 权限

  • 输出视图架构的 CREATE 权限

示例

这些示例显示了如何在 mtcars 表的 wt 和 hp 列上使用 NORMALIZE 函数。

执行 NORMALIZE 函数，并指定 minmax 方法：

=> SELECT NORMALIZE('mtcars_norm', 'mtcars',
                    'wt, hp', 'minmax');
        NORMALIZE
--------------------------
 Finished in 1 iteration

(1 row)

执行 NORMALIZE 函数，并指定 zscore 方法：

=> SELECT NORMALIZE('mtcars_normz','mtcars',
                    'wt, hp', 'zscore');
        NORMALIZE
--------------------------
 Finished in 1 iteration

(1 row)

执行 NORMALIZE 函数，并指定 robust_zscore 方法：

=> SELECT NORMALIZE('mtcars_normz', 'mtcars',
                    'wt, hp', 'robust_zscore');
        NORMALIZE
--------------------------
 Finished in 1 iteration

(1 row)

另请参阅

标准化数据

4.13.1.7 - NORMALIZE_FIT

NORMALIZE_FIT 计算输入关系中每个指定列的标准化参数。生成的模型将存储标准化参数。例如，对于 MinMax 标准化，每列的最小值和最大值都存储在模型中。生成的模型用作函数 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的输入。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

NORMALIZE_FIT ( 'model‑name', 'input‑relation', 'input‑columns', 'normalization‑method'
        [ USING PARAMETERS  [exclude_columns = 'excluded‑columns'] [, output_view = 'output‑view'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含需要标准化的数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列的数据类型必须为数字。
normalization‑method
要使用的标准化方法，为以下之一：

  • minmax

  • zscore

  • robust_zscore

如果指定 robust_zscore，则 NORMALIZE_FIT 使用函数 APPROXIMATE_MEDIAN [聚合]。

所有标准化方法都将忽略输入关系中的无穷大、负无穷大或 NULL 值。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

output_view
包含输入关系中所有列的视图的名称，其中指定输入列已标准化。

模型属性

data
标准化方法设置为 minmax：

  • colNames：模型列名称

  • mins：每列的最小值

  • maxes：每列的最大值

特权

非超级用户：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

  • 输出视图架构的 CREATE 权限

示例

以下示例使用表 mtcars 中的 wt 和 hp 列创建具有 NORMALIZE_FIT 的模型，然后在对 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的连续调用中使用此模型。

=> SELECT NORMALIZE_FIT('mtcars_normfit', 'mtcars', 'wt,hp', 'minmax');
NORMALIZE_FIT
---------------
Success
(1 row)

以下对 APPLY_NORMALIZE 的调用指定表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型中，而 cyl 不在标准化模型中：

=> CREATE TABLE mtcars_normalized AS SELECT APPLY_NORMALIZE (hp, cyl USING PARAMETERS model_name = 'mtcars_normfit') FROM mtcars;
CREATE TABLE
=> SELECT * FROM mtcars_normalized;
          hp        | cyl
--------------------+-----
  0.434628975265018 | 8
  0.681978798586572 | 8
  0.434628975265018 | 6
                  1 | 8
  0.540636042402827 | 8
                  0 | 4
  0.681978798586572 | 8
 0.0459363957597173 | 4
  0.434628975265018 | 8
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.204946996466431 | 6
  0.201413427561837 | 4
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.215547703180212 | 4
 0.0353356890459364 | 4
  0.187279151943463 | 6
  0.452296819787986 | 8
  0.628975265017668 | 8
  0.346289752650177 | 8
  0.137809187279152 | 4
  0.749116607773852 | 8
  0.144876325088339 | 4
  0.151943462897526 | 4
  0.452296819787986 | 8
  0.452296819787986 | 8
  0.575971731448763 | 8
  0.159010600706714 | 4
  0.346289752650177 | 8
(32 rows)

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
  hp | cyl
-----+-----
 175 | 8
 245 | 8
 175 | 6
 335 | 8
 205 | 8
  52 | 4
 245 | 8
  65 | 4
 175 | 8
 110 | 6
 123 | 6
  66 | 4
 110 | 6
 109 | 4
 110 | 6
 123 | 6
  66 | 4
 113 | 4
  62 | 4
 105 | 6
 180 | 8
 230 | 8
 150 | 8
  91 | 4
 264 | 8
  93 | 4
  95 | 4
 180 | 8
 180 | 8
 215 | 8
  97 | 4
 150 | 8
(32 rows)

以下对 REVERSE_NORMALIZE 的调用还指定了表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型 mtcars_normfit 中，而 cyl 不在标准化模型中。

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
       hp        | cyl
-----------------+-----
205.000005722046 |   8
150.000000357628 |   8
150.000000357628 |   8
93.0000016987324 |   4
 174.99999666214 |   8
94.9999992102385 |   4
214.999997496605 |   8
97.0000009387732 |   4
245.000006556511 |   8
 174.99999666214 |   6
             335 |   8
245.000006556511 |   8
62.0000002086163 |   4
 174.99999666214 |   8
230.000002026558 |   8
              52 |   4
263.999997675419 |   8
109.999999523163 |   6
123.000002324581 |   6
64.9999996386468 |   4
66.0000005029142 |   4
112.999997898936 |   4
109.999999523163 |   6
180.000000983477 |   8
180.000000983477 |   8
108.999998658895 |   4
109.999999523163 |   6
104.999999418855 |   6
123.000002324581 |   6
180.000000983477 |   8
66.0000005029142 |   4
90.9999999701977 |   4
(32 rows)

另请参阅

标准化数据

4.13.1.8 - ONE_HOT_ENCODER_FIT

为要编码的每个功能生成每个类别级别的排序列表，并存储模型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ONE_HOT_ENCODER_FIT ( 'model‑name', 'input‑relation','input‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, output_view = 'output‑view']
              [, extra_levels = 'category‑levels'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含用于独热编码的数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列必须为 INTEGER、BOOLEAN、VARCHAR 或日期。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

output_view
存储输入关系和独热编码的视图的名称。按照列在输入关系中出现的顺序返回列，独热编码列附加在原始列之后。
extra_levels
每个类别中不属于输入关系的附加级别。此参数应作为符合 JSON 标准的字符串传递，将类别名称作为键，将每个类别中的附加级别列表作为值。

模型属性

call_string
在调用函数时指定的所有输入实参的值。
varchar_categories integer_categories boolean_categories date_categories
以下参数的设置：

  • category_name：列名称

  • category_level：类别的级别，按类别排序

  • category_level_index：此分类级别在类别级别的排序列表中的索引。

特权

非超级用户：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

  • 输出视图架构的 CREATE 权限

示例

=> SELECT ONE_HOT_ENCODER_FIT ('one_hot_encoder_model','mtcars','*'
USING PARAMETERS exclude_columns='mpg,disp,drat,wt,qsec,vs,am');
ONE_HOT_ENCODER_FIT
--------------------
Success
(1 row)

另请参阅

4.13.1.9 - PCA

通过输入表/视图计算主组件。结果保存在 PCA 模型中。在内部，PCA 使用基于输入日期构建的协方差矩阵的 SVD 来查找组件。该分解的奇异值也保存在 PCA 模型中，作为其一部分。可以在不同的运行中同时翻转一个主组件的所有元素符号。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PCA ( 'model‑name', 'input‑relation', 'input‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, num_components = num‑components]
              [, scale = is‑scaled]
              [, method = 'method'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 PCA 输入数据的表或视图。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 所有输入列都必须为数字数据类型。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

num_components
要保留在模型中的组件的数量。如果未提供此值，则保留所有组件。组件的最大数量是内部调用 SVD 返回的非零奇异值的数量。该数字小于或等于 SVD（列数，行数）。
scale
一个布尔值，指定是否在准备步骤中标准化列：

  • True：使用相关系数矩阵，而非协方差矩阵。

  • False （默认值）

method
用于计算 PCA 的方法，可以设置为 LAPACK。

模型属性

columns
用于创建 PCA 模型的输入关系中的列信息：

  • index

  • name

singular_values
找到的奇异值信息。这些值按降序排列：

  • index

  • value

  • explain_variance：对应于该奇异值的数据方差的百分比

  • accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比

principal_components
上述奇异值对应的主组件：

  • index：各组件中元素的索引

  • PC1

  • PC2

  • ...

counters
在训练模型期间收集的信息，以名称-值对形式存储：

  • counter_name

    • Accepted_row_count：数据中有效行的数量

    • denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量

    • iteration_count：迭代次数，对于当前的 PCA 操作，始终为 1

  • counter_value

call_string
创建模型的函数调用。

特权

非超级用户：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

示例


=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96  Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE

=> SELECT * FROM worldPCA;
HDI   |       country       |       col1
------+---------------------+-------------------
0.886 | Belgium             |  79002.2946705704
0.699 | Belize              | -25631.6670012556
0.427 | Benin               | -40373.4104598122
0.805 | Chile               | -16805.7940082156
0.687 | China               | -37279.2893141103
0.744 | Costa Rica          | -19505.5631231635
0.4   | Cote d'Ivoire       | -38058.2060339272
0.776 | Cuba                | -23724.5779612041
0.895 | Denmark             |  117325.594028813
0.644 | Egypt               | -34609.9941604549
...
(96 rows)

=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
    USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
    key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI  |       country       |      em1970       |      em1971       |      em1972      |      em1973      |
      em1974      |      em1975       |      em1976|      em1977      |      em1978       |      em1979
   |      em1980       |      em1981      |      em1982       |      em1983       |      em1984       |em1985
|      em1986       |      em1987       |      em1988       |      em1989      |      em1990      |      em1991
|      em1992       |      em1993|      em1994      |      em1995       |      em1996       |      em1997
    |      em1998       |      em1999       |      em2000       |      em2001       |em2002       |
em2003      |      em2004       |      em2005      |      em2006       |      em2007       |      em2008
|      em2009      |      em2010       |     gdp1970      |     gdp1971      |     gdp1972      |     gdp1973
|     gdp1974      |     gdp1975      |     gdp1976      |     gdp1977      |gdp1978      |     gdp1979
 |     gdp1980      |     gdp1981      |     gdp1982      |     gdp1983      |     gdp1984      |     gdp1985
      |     gdp1986|    gdp1987      |     gdp1988      |     gdp1989      |     gdp1990      |     gdp1991
     |     gdp1992      |     gdp1993      |     gdp1994      |     gdp1995      |     gdp1996      |
gdp1997      |     gdp1998      |     gdp1999      |     gdp2000      |     gdp2001      |     gdp2002
|     gdp2003      |gdp2004      |     gdp2005      |     gdp2006      |     gdp2007      |     gdp2008
  |     gdp2009      |     gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium             |  18585.6613572407 | -16145.6374560074 |  26938.956253415 | 8094.30475779595 |
 12073.5461203817 | -11069.0567600181 | 19133.8584911727|   5500.312894949 | -4227.94863799987 |  6265.77925410752
|  -10884.749295608 | 30929.4669575201 | -7831.49439429977 |  3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 |   1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 |  18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 |   1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
|  6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
|  5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 |  5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 |  8718.3731386891
...
(96 rows)

另请参阅

4.13.1.10 - SUMMARIZE_CATCOL

分三列返回分类数据输入的统计摘要：

  • CATEGORY：分类级别，与汇总列具有相同的 SQL 数据类型

  • COUNT：类别级别的数量，类型为 INTEGER

  • PERCENT：表示类别百分比，类型为 FLOAT

语法

SUMMARIZE_CATCOL (target‑column
        [ USING PARAMETERS TOPK = topk‑value [, WITH_TOTALCOUNT = show‑total] ] )
OVER()

参数

target‑column
要汇总的输入列的名称，为以下数据类型之一：

  • BOOLEAN

  • FLOAT

  • INTEGER

  • DATE

  • CHAR/VARCHAR

参数

TOPK
整数，指定要在输出中包含的最频繁行的数量。
WITH_TOTALCOUNT
一个布尔值，指定表是否一个标题行，其中显示目标列中所示的总行数，且百分比等于 100。

默认值： true

示例

此示例显示了 salary_data 表中 current_salary 列的分类摘要。查询输出中显示列类别、计数和百分比。第一列列出分类级别，其与输入列具有相同的 SQL 数据类型，第二列列出该值的计数，第三列列出百分比。

=> SELECT SUMMARIZE_CATCOL (current_salary USING PARAMETERS TOPK = 5) OVER() FROM salary_data;
CATEGORY | COUNT | PERCENT
---------+-------+---------
         |  1000 |     100
   39004 |     2 |     0.2
   35321 |     1 |     0.1
   36313 |     1 |     0.1
   36538 |     1 |     0.1
   36562 |     1 |     0.1
(6 rows)

4.13.1.11 - SUMMARIZE_NUMCOL

返回 Vertica 表中列的统计摘要：

  • Count

  • 平均值

  • 标准偏差

  • 最小值/最大值

  • 近似百分位

  • 中间值

除了计数为 INTEGER 类型，所有汇总值均为 FLOAT 数据类型。

语法

SUMMARIZE_NUMCOL (input‑columns [ USING PARAMETERS exclude_columns = 'excluded‑columns'] ) OVER()

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 所有列都必须为数字数据类型。如果选择所有列，SUMMARIZE_NUMCOL 将标准化模型中的所有列

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

示例

显示 employee 表中 age 和 salary 列的统计摘要：

=> SELECT SUMMARIZE_NUMCOL(* USING PARAMETERS exclude_columns='id,name,gender,title') OVER() FROM employee;
COLUMN         | COUNT |    MEAN    |      STDDEV      |  MIN    | PERC25  | MEDIAN  |  PERC75   |  MAX
---------------+-------+------------+------------------+---------+---------+---------+-----------+--------
age            |     5 |    63.4    | 19.3209730603818 |      44 |      45 |      67 |      71   |     90
salary         |     5 | 3456.76    | 1756.78754300285 | 1234.56 | 2345.67 | 3456.78 | 4567.89   | 5678.9
(2 rows)

4.13.1.12 - SVD

计算输入关系的 SVD 分解的奇异值（S 矩阵的对角线）和右奇异向量（V 矩阵）。结果将保存为 SVD 模型。可以在不同的运行中同时翻转 SVD 中奇异向量的所有元素符号。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SVD ( 'model‑name', 'input‑relation', 'input‑columns'
     [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, num_components = num‑components]
              [, method = 'method'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 SVD 输入数据的表或视图。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列必须为数字数据类型。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

num_components
要保留在模型中的组件的数量。组件的最大数量为计算的非零奇异值的数量，小于或等于最小值（列数，行数）。如果忽略此参数，则保留所有组件。
method
用于计算 SVD 的方法，可以设置为 LAPACK。

模型属性

columns
用于创建 SVD 模型的输入关系中的列信息：

  • index

  • name

singular_values
找到的奇异值信息。这些值按降序排列：

  • index

  • value

  • explain_variance：对应于该奇异值的数据方差的百分比

  • accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比

right_singular_vectors
上述奇异值对应的右奇异向量：

  • index：每个向量中元素的索引

  • vector1

  • vector2

  • ...

counters
在训练模型期间收集的信息，以名称-值对形式存储：

  • counter_name

    • Accepted_row_count：数据中有效行的数量

    • denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量

    • iteration_count：迭代次数，对于当前的 SVD 操作，始终为 1

  • counter_value

call_string
创建模型的函数调用。

特权

非超级用户：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

示例

=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8  Rejected Rows: 0
(1 row)

=> CREATE TABLE transform_svd AS SELECT
     APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
     OVER () FROM small_svd;
CREATE TABLE

=> SELECT * FROM transform_svd;
id  |       col1        |        col2         |        col3         |        col4
----+-------------------+---------------------+---------------------+--------------------
4   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
6   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
1   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
2   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
3   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
5   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
8   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
7   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
(8 rows)

=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id  |        x1        |        x2        |        x3        |        x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)

另请参阅

4.13.2 - 机器学习算法

Vertica 支持各种机器学习函数，这些函数使用一组数据训练模型，并返回可进行保存以用于稍后执行的模型。

这些函数要求非超级用户具有以下权限：

  • 对创建模型的架构的 CREATE 权限

  • 对输入关系的 SELECT 权限

4.13.2.1 - AUTOREGRESSOR

通过具有一致时间步长的平稳时间序列创建自回归 (AR) 模型，此模型可用于通过 PREDICT_AUTOREGRESSOR 进行预测。

自动回归模型将根据先前的值来预测时间序列的未来值。更具体地说，用户指定的 lag 决定了该模型在计算过程中要考虑多少个先前的时间段，且预测值为每个 lag 的线性组合。

由于输入数据必须按时间戳排序，因此，此算法为单线程算法。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUTOREGRESSOR ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
        [ USING PARAMETERS
              [ p = lags ]
              [, missing = "imputation‑method" ]
              [, regularization = "regularization‑method" ]
              [, lambda = regularization‑value ]
              [, compute_mse = boolean ]
        ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 timestamp‑column 的表或视图。

该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。

data‑column
包含因变量或结果的 NUMERIC 类型的输入列。
timestamp‑column
表示时间戳变量的 INTEGER、FLOAT 或 TIMESTAMP 列。时间步长必须一致。

参数

p
[1, 1999] 范围内的 INTEGER，表示计算中要考虑的滞后数。较大的 p 值会削弱相关性。

默认值： 3

missing
用于处理缺失值的方法，为以下之一：

  • drop：忽略缺失值。

  • error：缺失值会引发错误。

  • zero：将缺失值替换为 0。

  • linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。

默认值： linear_interpolation

regularization
拟合数据时使用的正则化方法，为以下之一：

  • 无

  • L2：权重正则化项，即惩罚权重的平方值

默认值： 无

lambda
[0, 100000] 范围内的 FLOAT，正则化值 lambda。

默认值： 1.0

compute_mse
BOOLEAN，是否计算并输出均方误差 (MSE)。

默认值： False

示例

请参阅自回归模型示例。

另请参阅

4.13.2.2 - BISECTING_KMEANS

对输入关系运行二分 k-means 算法。结果将生成一个具有群集中心层次结构的已训练模型，其包含一系列 k 值，每个值都可用于预测。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

BISECTING_KMEANS('model-name', 'input-relation', 'input-columns', 'num-clusters'
           [ USING PARAMETERS
                 [exclude_columns = 'exclude-columns']
                 [, bisection_iterations = bisection-iterations]
                 [, split_method = 'split-method']
                 [, min_divisible_cluster_size = min-cluster-size]
                 [, kmeans_max_iterations = kmeans-max-iterations]
                 [, kmeans_epsilon = kmeans-epsilon]
                 [, kmeans_center_init_method = 'kmeans-init-method']
                 [, distance_method = 'distance-method']
                 [, output_view = 'output-view']
                 [, key_columns = 'key-columns'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 k 均值输入数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列的数据类型必须为数字。
num‑clusters
要创建的群集数，为 ≤ 10,000 的整数。此实参表示 k 均值中的 k。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

bisection_iterations
1 - 1MM（包含）之间的整数，指定二等分 k 均值算法对每个二等分步骤执行的迭代次数。其对应于独立 k 均值算法在每个二等分步骤中运行的次数。

如果设置为 >1，则允许算法运行并选择在每个二等分步骤中运行的最佳 k 均值。如果使用 kmeanspp，bisection_iterations 的值始终为 1，因为 kmeanspp 的运行成本更高（但也好过替代方案），因此它不需要多次运行。

默认值： 1

split_method
用于选择要进行二等分/拆分的群集的方法，为以下之一：

  • size：选择最大群集进行二等分。

  • sum_squares：选择群集内平方和最大的群集进行二等分。

默认值： sum_squares

min_divisible_cluster_size
≥ 2 的整数，指定可分群集中点的最小数量。

默认值： 2

kmeans_max_iterations
1 和 1MM（包含）之间的整数，指定 k 均值算法执行的最大迭代数。如果该值小于收敛所需要的迭代数，则算法无法进行收敛。

默认值： 10

kmeans_epsilon
1 和 1MM（包含）之间的整数，确定 k 均值算法是否已收敛。自上一次迭代后，如果中心移动的距离小于 epsilon，则认为该算法已收敛。

默认值： 1e-4

kmeans_center_init_method
用于找到初始群集中心的 k 均值方法，为以下之一：

  • kmeanspp （默认）：kmeans++ 算法

  • pseudo：使用 Spark 所用的“伪中心”方法，将给定中心二等分，但不迭代点

distance_method
两个数据点之间的距离测量。目前仅支持欧氏距离。

默认值： euclidean

output_view
保存分配到群集的每个点的视图名称。您必须对视图架构具有 CREATE 权限。
key_columns
用于标识输出行的列名称的逗号分隔列表。列必须位于 input-columns 实参列表中。要防止算法使用这些和其他输入列，请将其列在参数 exclude_columns 中。

模型属性

centers
K 个质心的中心列表。
hierarchy
K 个群集的层次结构，包括：

  • ParentCluster：每个质心的父群集质心 — 即基于其通过二等分得到一个群集的群集质心。

  • LeftChildCluster：每个质心的左子群集质心 — 即将一个群集二等分后得到的第一个子群集的质心。

  • RightChildCluster：每个质心的右子群集质心 — 即将一个群集二等分得到的第二个子群集的质心。

  • BisectionLevel：指定通过其得到一个群集的二等分步骤。

  • WithinSS：当前群集的群集内平方和

  • TotalWithinSS：迄今为止获得的叶群集的群集内总平方和。

metrics
与群集质量相关的几个指标，包括

  • 总平方和

  • 群集内总平方和

  • 群集间总平方和

  • 群集间平方和/总平方和

  • 群集 x、center_id y[...] 的平方和

示例

SELECT BISECTING_KMEANS('myModel', 'iris1', '*', '5'
       USING PARAMETERS exclude_columns = 'Species,id', split_method ='sum_squares', output_view = 'myBKmeansView');

另请参阅

4.13.2.3 - KMEANS

对输入关系执行 k-means 算法。结果是包含群集中心列表的模型。

您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的 k 均值模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练 k 均值模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

KMEANS ( 'model‑name', 'input‑relation', 'input‑columns', 'num‑clusters'
        [ USING PARAMETERS
           [exclude_columns = 'excluded‑columns']
           [, max_iterations = max‑iterations]
           [, epsilon = epsilon‑value]
           [, { init_method = 'init‑method' } | { initial_centers_table = 'init‑table' } ]
           [, output_view = 'output‑view']
           [, key_columns = 'key‑columns'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 k 均值输入数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列的数据类型必须为数字。
num‑clusters
要创建的群集数，为 ≤10,000 的整数。此实参表示 k 均值中的 k。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

max_iterations
算法执行的最大迭代数。如果该值小于收敛所需要的迭代数，则算法无法进行收敛。

默认值： 10

epsilon
确定算法是否收敛。自上一次迭代后，如果中心移动的距离小于
'epsilon'，则认为该算法已收敛。

默认值： 1e-4

init_method
用于找到初始群集中心的方法，为以下之一：

  • random

  • kmeanspp （默认）：kmeans++ 算法

    如果 k 值过高，可能会占用大量内存。如果函数返回错误，提示可用内存不足，请减小 k 值或使用 random 方法。

initial_centers_table
包含要使用的初始群集中心的表。知晓要使用的初始群集中心而不需要 Vertica 找到初始群集中心时提供这个值。
output_view
保存分配到群集的每个点的视图名称。您必须对保存视图的架构具有 CREATE 权限。
key_columns
input-columns 中列名称的逗号分隔列表，将显示为 output_view 的列。应选择这些列，以便其内容可以标识每个输入数据点。此参数仅在指定 output_view 时使用。input‑columns 中所列的仅用作 key_columns 而不用于训练的列应在 exclude_columns 中列出。

模型属性

centers
包含每个群集中心的列表。
metrics
与群集质量相关的几个指标的字符串摘要。

示例

以下示例创建 k-means 模型 myKmeansModel 并将其应用于输入表 iris1。APPLY_KMEANS 的调用混合了列名和常量。当传递一个常量代替列名称时，该常量将替换该列在所有行中的值：

=> SELECT KMEANS('myKmeansModel', 'iris1', '*', 5
USING PARAMETERS max_iterations=20, output_view='myKmeansView', key_columns='id', exclude_columns='Species, id');
           KMEANS
----------------------------
 Finished in 12 iterations

(1 row)
=> SELECT id, APPLY_KMEANS(Sepal_Length, 2.2, 1.3, Petal_Width
USING PARAMETERS model_name='myKmeansModel', match_by_pos='true') FROM iris2;
 id  | APPLY_KMEANS
-----+--------------
   5 |            1
  10 |            1
  14 |            1
  15 |            1
  21 |            1
  22 |            1
  24 |            1
  25 |            1
  32 |            1
  33 |            1
  34 |            1
  35 |            1
  38 |            1
  39 |            1
  42 |            1
...
 (60 rows)

另请参阅

4.13.2.4 - LINEAR_REG

对输入关系执行线性回归，并返回线性回归模型。

您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的线性回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练线性回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LINEAR_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, optimizer = 'optimizer‑method']
              [, regularization = 'regularization‑method']
              [, epsilon = epsilon‑value]
              [, max_iterations = iterations]
              [, lambda = lamda‑value]
              [, alpha = alpha‑value]
              [, fit_intercept = boolean‑value] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含用于构建模型的训练数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量或结果的输入列的名称。此列中的所有值必须为数字，否则模型将无效。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
optimizer
用于训练模型的优化器方法，为以下之一：
  • 牛顿
  • BFGS
  • CGD

默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。

regularization
正则化方法，为以下之一：

  • None （默认值）

  • L1

  • L2

  • ENet

epsilon

在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。

默认值： 1e-6

max_iterations

(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。

默认值： 100

lambda
≥ 0 的整数，指定 regularization 参数的值。

默认值： 1

alpha
≥ 0 的整数，指定 ENET regularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。

值范围： [0,1]

默认值： 0.5

fit_intercept
布尔值，指定模型是否包含截距。如果设置为 false，在训练模型时将不使用截距。请注意，将 fit_intercept 设置为 false 不适用于 BFGS 优化器。

默认值： True

模型属性

示例

=> SELECT LINEAR_REG('myLinearRegModel', 'faithful', 'eruptions', 'waiting'
                      USING PARAMETERS optimizer='BFGS', fit_intercept=true);
         LINEAR_REG
----------------------------
 Finished in 10 iterations

(1 row)

另请参阅

4.13.2.5 - LOGISTIC_REG

对输入关系执行逻辑回归。结果是一个逻辑回归模型。

您可以以 VERTICA_MODELS 或 PMML 格式导出生成的逻辑回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练逻辑回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LOGISTIC_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS [exclude_columns = 'excluded‑columns']
              [, optimizer = 'optimizer‑method']
              [, regularization = 'regularization‑method']
              [, epsilon = epsilon‑value]
              [, max_iterations = iterations]
              [, lambda = lamda‑value]
              [, alpha = alpha‑value]
              [, fit_intercept = boolean‑value] ] )

实参

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含用于构建模型的训练数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量或结果的输入列。列值必须为 0 或 1，类型为数字或 BOOLEAN。该函数自动跳过所有其他值。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
optimizer
用于训练模型的优化器方法，为以下之一：
  • Newton
  • BFGS
  • CGD

默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。

regularization
正则化方法，为以下之一：

  • None （默认值）

  • L1

  • L2

  • ENet

epsilon

在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。

默认值： 1e-6

max_iterations

(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。

默认值： 100

lambda
≥ 0 的整数，指定 regularization 参数的值。

默认值： 1

alpha
≥ 0 的整数，指定 ENET regularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。

值范围： [0,1]

默认值： 0.5

fit_intercept
布尔值，指定模型是否包含截距。如果设置为 false，在训练模型时将不使用截距。请注意，将 fit_intercept 设置为 false 不适用于 BFGS 优化器。

默认值： True

模型属性

特权

超级用户，或对输入关系的 SELECT 权限

示例

=> SELECT LOGISTIC_REG('myLogisticRegModel', 'mtcars', 'am',
                       'mpg, cyl, disp, hp, drat, wt, qsec, vs, gear, carb'
                        USING PARAMETERS exclude_columns='hp', optimizer='BFGS', fit_intercept=true);
        LOGISTIC_REG
----------------------------
 Finished in 20 iterations

(1 row)

另请参阅

4.13.2.6 - MOVING_AVERAGE

通过具有一致时间步长的平稳时间序列创建移动平均 (MA) 模型，此模型随后可用于通过 PREDICT_MOVING_AVERAGE 进行预测。

移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的 lag 决定了它在计算过程中要考虑多少先前的预测和错误。

由于输入数据必须按时间戳排序，因此，此算法为单线程算法。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVING_AVERAGE ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
        [ USING PARAMETERS
              [ q = lags ]
              [, missing = "imputation‑method" ]
              [, regularization = "regularization‑method" ]
              [, lambda = regularization‑value ]
              [, compute_mse = boolean ]
        ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含 timestamp‑column 的表或视图。

该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。

data‑column
包含因变量或结果的 NUMERIC 类型的输入列。
timestamp‑column
表示时间戳变量的 INTEGER、FLOAT 或 TIMESTAMP 列。时间步长必须一致。

参数

q
[1, 67) 范围内的 INTEGER，表示计算中要考虑的滞后数。

默认值： 1

missing
用于处理缺失值的方法，为以下之一：

  • drop：忽略缺失值。

  • error：缺失值会引发错误。

  • zero：将缺失值替换为 0。

  • linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。

默认值： linear_interpolation

regularization
拟合数据时使用的正则化方法，为以下之一：

  • 无

  • L2：权重正则化项，即惩罚权重的平方值

默认值： 无

lambda
[0, 100000] 范围内的 FLOAT，正则化值 lambda。

默认值： 1.0

compute_mse
BOOLEAN，是否计算并输出均方误差 (MSE)。

此参数仅接受“true”或“false”，不接受 BOOLEAN 的标准字面量等效项，如 1 或 0。

默认值： False

示例

请参阅移动平均模型示例。

另请参阅

4.13.2.7 - NAIVE_BAYES

对输入关系执行朴素贝叶斯算法，并返回朴素贝叶斯模型。

根据数据类型处理列：

  • FLOAT：假定值遵循某种高斯分布。

  • INTEGER：假定值属于一个多项分布。

  • CHAR/VARCHAR：假定值遵循某种分类分布。这些列中存储的字符串值不得超过 128 个字符。

  • BOOLEAN：值被视为具有两个值的分类值。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

NAIVE_BAYES ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, alpha = alpha-value] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含用于构建模型的训练数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量或结果的输入列的名称。此列必须包含代表不同类标签的离散标签。

响应列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。

predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。BOOLEAN 列值在训练前转换为 FLOAT 值：0 表示 false，1 表示 true。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
alpha
浮点数，如果事件模型为分类式、多项式或伯努利式，则指定使用拉普拉斯平滑。

默认值： 1.0

模型属性

colsInfo
训练中使用的响应和预测变量列的信息：

  • index：训练中提供的列的索引（从 0 开始）。索引 0 用于响应列。

  • name：列的名称。

  • type：用于响应的标签，其值为 Gaussian、Multinominal、Categorical 或 Bernoulli。

alpha
平滑参数值。
prior
每个类在所有训练样本中的百分比：

  • label：类标签。

  • value：每个类的百分比。

nRowsTotal
数据集中接受用于训练的样本数。
nRowsRejected
拒绝用于训练的样本数。
callStr
用于复制训练的 SQL 语句。
Gaussian
高斯模型取决于由 class_name 指示的类：

  • index：预测变量列的索引。

  • mu：模型的平均值。

  • sigmaSq：模型的标准差平方。

Multinominal
多项式模型取决于由 class_name 指示的类：

  • index：预测变量列的索引。

  • prob：概率取决于由 class_name 指示的类。

Bernoulli
伯努利模型取决于由 class_name 指示的类：

  • index：预测变量列的索引。

  • probTrue：此预测变量列中值为 TRUE 的概率。

Categorical
高斯模型取决于由 class_name 指示的类：

  • category：预测变量名称中的值。

  • <class_name>：具有该值的概率取决于由 class_name 指示的类。

特权

超级用户或输入关系的 SELECT 权限。

示例

=> SELECT NAIVE_BAYES('naive_house84_model', 'house84_train', 'party', '*'
                      USING PARAMETERS exclude_columns='party, id');
                                  NAIVE_BAYES
--------------------------------------------------
 Finished. Accepted Rows: 324  Rejected Rows: 0
(1 row)

另请参阅

4.13.2.8 - RF_CLASSIFIER

训练随机森林模型，以对输入关系进行分类。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RF_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, ntree = num‑trees]
              [, mtry = num‑features]
              [, sampling_size = sampling‑size]
              [, max_depth = depth]
              [, max_breadth = breadth]
              [, min_leaf_size = leaf-size]
              [, min_info_gain = threshold]
              [, nbins = num‑bins] ] )

参数

model‑name
标识作为训练结果存储的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含训练样本的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
数字、CHAR/VARCHAR 或 BOOLEAN 类型的输入列，表示因变量。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。

Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

ntree

[1，1000] 范围内的整数，指森林中的树木数量。

默认值： 20

mtry
[1, number‑predictors] 范围内的整数，随机选择的特征数，从中选择最佳特征以在给定的树节点上进行拆分。

默认值： 预测变量总数的平方根

sampling_size

在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。

默认值： 0.632

max_depth

[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。

默认值： 5

max_breadth

[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。

默认值： 32

min_leaf_size

[1, 1e6] 范围内的整数，拆分节点后每个分支必须具有的最小样本数。在其左分支或右分支中导致较少剩余样本的拆分将被丢弃，并且该节点被视为叶节点。

默认值： 1

min_info_gain

在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。

默认值： 0.0

nbins

[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。

默认值： 32

模型属性

示例

=> SELECT RF_CLASSIFIER ('myRFModel', 'iris', 'Species', 'Sepal_Length, Sepal_Width,
Petal_Length, Petal_Width' USING PARAMETERS ntree=100, sampling_size=0.3);


RF_CLASSIFIER
--------------------------------------------------
Finished training
(1 row)

另请参阅

4.13.2.9 - RF_REGRESSOR

训练随机森林模型，以对输入关系执行回归。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RF_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, ntree = num‑trees]
              [, mtry = num‑features]
              [, sampling_size = sampling‑size]
              [, max_depth = depth]
              [, max_breadth = breadth]
              [, min_leaf_size = leaf-size]
              [, min_info_gain = threshold]
              [, nbins = num‑bins] ] )

参数

model‑name
作为训练结果存储的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含训练样本的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量的数字输入列。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。

Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
ntree

[1，1000] 范围内的整数，指森林中的树木数量。

默认值： 20

mtry
[1, number‑predictors] 范围内的整数，在拆分树节点时要考虑的特征数。

默认值： 预测变量总数的三分之一

sampling_size

在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。

默认值： 0.632

max_depth

[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。

默认值： 5

max_breadth

[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。

默认值： 32

min_leaf_size
[1, 1e6] 范围内的整数，拆分节点后每个分支必须具有的最小样本数。在其左分支或右分支中导致较少剩余样本的拆分将被丢弃，并且该节点被视为叶节点。

此参数的默认值与 sklearn 等库中的类似参数不同，因此会产生一个预测值与原始响应值不同的模型。

默认值： 5

min_info_gain

在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。

默认值： 0.0

nbins

[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。

默认值： 32

模型属性

示例

=> SELECT RF_REGRESSOR ('myRFRegressorModel', 'mtcars', 'carb', 'mpg, cyl, hp, drat, wt' USING PARAMETERS
ntree=100, sampling_size=0.3);
RF_REGRESSOR
--------------
Finished
(1 row)

另请参阅

4.13.2.10 - SVM_CLASSIFIER

针对输入关系训练 SVM 模型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SVM_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, C = 'cost']
              [, epsilon = 'epsilon‑value']
              [, max_iterations = 'max‑iterations']
              [, class_weights = 'weight']
              [, intercept_mode = 'intercept‑mode']
              [, intercept_scaling = 'scale'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含训练数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量或结果的输入列。列值必须为 0 或 1，类型为数字 或 BOOLEAN，否则函数返回错误。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
C
错误分类成本的权重。该算法最大限度降低了正则化成本和误分类成本。

默认值： 1.0

epsilon
用于控制精度。

默认值： 1e-3

max_iterations
算法执行的最大迭代数。

默认值： 100

class_weights
指定如何确定两个类的权重，选择以下方式之一：

  • None （默认值）：不使用权重

  • value0、value1：两个逗号分隔的字符串，指定两个正 FLOAT 值，其中 value0 将权重分配给类 0，value1 将权重分配给类 1。

  • auto：根据样本数量对每个类别进行加权。

intercept_mode
指定如何处理截距，选择以下方式之一：

  • regularized （默认值）：适合截距并对其应用正则化。

  • unregularized：适合截距，但不包括在正则化中。

intercept_scaling
浮点值，用作虚拟特征的值，Vertica 使用其系数计算模型截距。因为虚拟特征不在训练数据中，所以它的值被设置为一个常数，默认为 1。

模型属性

示例

以下示例在 mtcars 表上使用 SVM_CLASSIFIER：


=> SELECT SVM_CLASSIFIER(
       'mySvmClassModel', 'mtcars', 'am', 'mpg,cyl,disp,hp,drat,wt,qsec,vs,gear,carb'
       USING PARAMETERS exclude_columns = 'hp,drat');
SVM_CLASSIFIER
----------------------------------------------------------------
Finished in 15 iterations.
Accepted Rows: 32  Rejected Rows: 0
(1 row)

另请参阅

4.13.2.11 - SVM_REGRESSOR

针对输入关系训练 SVM 模型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SVM_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
              [, error_tolerance = error-tolerance]
              [, C = cost]
              [, epsilon = epsilon‑value]
              [, max_iterations = max‑iterations]
              [, intercept_mode = 'mode']
              [, intercept_scaling = 'scale'] ] )

参数

model‑name
标识要创建的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
input‑relation
包含训练数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
表示因变量或结果的输入列。该列必须为数字数据类型。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
error_tolerance
定义可接受的误差范围。此区域之外的任何数据点都会为成本函数增加罚分。

默认值： 0.1

C
错误分类成本的权重。该算法最大限度降低了正则化成本和误分类成本。

默认值： 1.0

epsilon
用于控制精度。

默认值： 1e-3

max_iterations
算法执行的最大迭代数。

默认值： 100

intercept_mode
指定如何处理截距的字符串，为以下之一

  • regularized （默认值）：适合截距并对其应用正则化。

  • unregularized：适合截距，但不包括在正则化中。

intercept_scaling
FLOAT 值用作虚拟特征的值，Vertica 使用其系数计算模型截距。因为虚拟特征不在训练数据中，所以它的值被设置为一个常数，默认设置为 1。

模型属性

示例


=> SELECT SVM_REGRESSOR('mySvmRegModel', 'faithful', 'eruptions', 'waiting'
                          USING PARAMETERS error_tolerance=0.1, max_iterations=100);
SVM_REGRESSOR
----------------------------------------------------------------
Finished in 5 iterations.
Accepted Rows: 272  Rejected Rows: 0
(1 row)

另请参阅

4.13.2.12 - XGB_CLASSIFIER

训练 XGBoost 模型以对输入关系执行分类。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

XGB_CLASSIFIER ('model-name', 'input-relation', 'response-column', 'predictor-columns'
        [ USING PARAMETERS
              [ exclude_columns = 'excluded-columns' ]
              [, max_ntree = max-trees ]
              [, max_depth = max-depth ]
              [, objective = 'optimization-strategy' ]
              [, learning_rate = learning-rate ]
              [, min_split_loss = minimum ]
              [, weight_reg = regularization ]
              [, nbins = num-bins ]
              [, sampling_size = fraction-of-rows ]
              [, col_sample_by_tree = sample-ratio-per-tree ]
              [, col_sample_by_node = sample-ratio-per-node ]
        ] )

参数

model-name

模型的名称（不区分大小写）。

input-relation
包含训练样本的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response-column
CHAR 或 VARCHAR 类型的输入列，用来表示因变量或结果。
predictor-columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 列的数据类型必须为 CHAR、VARCHAR、BOOL、INT 或 FLOAT。

CHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。

Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

max_ntree
[1,1000] 区间内的整数，用来设置要创建的树的最大个数。

默认值： 10

max_depth
[1,20] 区间内的整数，用来指定每个树的最大深度。

默认值： 6

objective
用来以迭代方式改进模型的目标/损失函数。目前，'crossentropy' 是唯一选项。

默认值： 'crossentropy'

split_proposal_method
指定近似拆分策略，为以下几项之一：

  • global：/*describe */

  • local: /describe/

默认值： global

learning_rate
(0,1] 区间内的浮点数，用来指定每个树的预测权重。设置此参数可以减少每个树所造成的的影响，从而防止早期树以牺牲后期树的贡献为代价独占改进量。

默认值： 0.3

min_split_loss
[0,1000] 区间内的浮点数，用来指定为了避免修剪模型的目标函数值而必须针对该值实现的最小改进量。

如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。

默认值： 0.0（禁用）

weight_reg
[0,1000] 区间内的浮点数，用来指定应用于分类树叶权重的正则化项。设置的值越大，权重越稀疏或越平滑，这有助于防止过度拟合。

默认值： 1.0

nbins
(1,1000] 区间内的整数，用来指定要用于在每列中查找拆分的 bin 数。bin 越多，运行时间越长，但粒度更细，拆分效果越好。

默认值： 32

sampling_size
(0,1] 区间内的浮点数，用来指定要在每次训练迭代中使用的行的比例。

值 1 表示使用所有行。

默认值： 1.0

col_sample_by_tree
(0,1] 区间内的浮点数，指定在构建每个树时随机选择的列（特征）的比例。

值 1 表示使用所有列。

col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。

此算法始终对至少一列进行采样。

默认值： 1

col_sample_by_node
(0,1] 区间内的浮点数，指定在评估每个拆分时随机选择的列（特征）的比例。

值 1 表示使用所有列。

col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。

此算法始终对至少一列进行采样。

默认值： 1

示例

请参阅XGBoost 用于分类。

4.13.2.13 - XGB_REGRESSOR

训练 XGBoost 模型以对输入关系执行回归。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

XGB_REGRESSOR ('model-name', 'input-relation', 'response-column', 'predictor-columns'
        [ USING PARAMETERS
              [ exclude_columns = 'excluded-columns' ]
              [, max_ntree = max-trees ]
              [, max_depth = max-depth ]
              [, objective = 'optimization-strategy' ]
              [, learning_rate = learning-rate ]
              [, min_split_loss = minimum ]
              [, weight_reg = regularization ]
              [, nbins = num-bins ]
              [, sampling_size = fraction-of-rows ]
              [, col_sample_by_tree = sample-ratio-per-tree ]
              [, col_sample_by_node = sample-ratio-per-node ]
        ] )

参数

model-name

模型的名称（不区分大小写）。

input-relation
包含训练样本的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response-column
INTEGER 或 FLOAT 类型的输入列，用来表示因变量或结果。
predictor-columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 列的数据类型必须为 CHAR、VARCHAR、BOOL、INT 或 FLOAT。

CHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。

Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。

参数

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

max_ntree
[1,1000] 区间内的整数，用来设置要创建的树的最大个数。

默认值： 10

max_depth
[1,20] 区间内的整数，用来指定每个树的最大深度。

默认值： 6

objective
用来以迭代方式改进模型的目标/损失函数。目前，'squarederror' 是唯一的选项。

默认值： 'squarederror'

split_proposal_method
指定近似拆分策略，为以下几项之一：

  • global：/*describe */

  • local: /describe/

默认值： global

learning_rate
(0,1] 区间内的浮点数，用来指定每个树的预测权重。设置此参数可以减少每个树所造成的的影响，从而防止早期树以牺牲后期树的贡献为代价独占改进量。

默认值： 0.3

min_split_loss
[0,1000] 区间内的浮点数，用来指定为了避免修剪模型的目标函数值而必须针对该值实现的最小改进量。

如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。

默认值： 0.0（禁用）

weight_reg
[0,1000] 区间内的浮点数，用来指定应用于分类树叶权重的正则化项。设置的值越大，权重越稀疏或越平滑，这有助于防止过度拟合。

默认值： 1.0

nbins
(1,1000] 区间内的整数，用来指定要用于在每列中查找拆分的 bin 数。bin 越多，运行时间越长，但粒度更细，拆分效果越好。

默认值： 32

sampling_size
(0,1] 区间内的浮点数，用来指定要在每次训练迭代中使用的行的比例。

值 1 表示使用所有行。

默认值： 1.0

col_sample_by_tree
(0,1] 区间内的浮点数，指定在构建每个树时随机选择的列（特征）的比例。

值 1 表示使用所有列。

col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。

此算法始终对至少一列进行采样。

默认值： 1

col_sample_by_node
(0,1] 区间内的浮点数，指定在评估每个拆分时随机选择的列（特征）的比例。

值 1 表示使用所有列。

col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。

此算法始终对至少一列进行采样。

默认值： 1

示例

请参阅用于回归的 XGBoost。

4.13.3 - 转换函数

机器学习 API 包括一组 UDx 函数，这些函数将每个输入行的列转换为一个或多个对应的输出列。这些转换遵循之前创建的模型中定义的规则。例如， APPLY_SVD 使用 SVD 模型来转换输入数据。

除非另有说明，否则这些函数要求非超级用户具有以下权限：

  • 模型上的 USAGE 权限

  • 对输入关系的 SELECT 权限

通常，给定无效的输入行，这些函数的返回值为 NULL。

4.13.3.1 - APPLY_BISECTING_KMEANS

将已训练的二分 k-means 模型应用于输入关系，并将每个新数据点分配给已训练模型中最接近的匹配群集。

语法

SELECT APPLY_BISECTING_KMEANS( 'input-columns'
        USING PARAMETERS model_name = 'model-name'
            [, num_clusters = 'num-clusters']
            [, match_by_pos = match‑by‑position] ] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 输入列的数据类型必须为数字。

参数

model_name

模型的名称（不区分大小写）。

num_clusters
介于 1 和 k 之间的整数（包含），其中 k 为模型中的中心数，指定用于预测的群集数。

默认值： 模型为 k 指定的值

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

特权

非超级用户：模型所有者或模型的使用权限

4.13.3.2 - APPLY_IFOREST

将隔离森林 (iForest) 模型应用于输入关系。对于每个输入行，该函数返回包含两个字段的输出行：

  • anomaly_score：浮点值，表示模型中所有树的平均路径长度，按训练样本大小标准化。
  • is_anomaly：布尔值，指示输入行是否异常。当 anomaly_score 等于或大于给定阈值时，此值为 true；否则，此值为 false。

语法

APPLY_IFOREST( input‑columns USING PARAMETERS param=value[,...] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 列类型必须与 model_name 中的预测变量类型匹配。

参数

model_name

模型的名称（不区分大小写）。

threshold
可选。(0.0, 1.0) 范围内的浮点数，指定确定数据点是否为异常的阈值。如果一个数据点的 anomaly_score 等于或大于 threshold 的值，则该数据点被标记为异常值。

或者，您可以指定一个 contamination 值，该值设置一个阈值，其中标记为异常值的训练数据点的百分比约等于 contamination 的值。您不能在同一个函数调用中同时设置 contamination 和 threshold。

默认值： 0.7

match_by_pos
可选。指定输入列如何与模型列匹配的布尔值：

  • false：按名称匹配。

  • true：按输入列列表中列的位置匹配。

默认值：false

contamination
可选。(0.0, 1.0) 范围内的浮点数，训练数据中被标记为异常值的数据点的近似比率。该函数根据此 contamination 值计算阈值。如果不设置此参数，该函数将使用指定或默认的 threshold 值标记异常值。

您不能在同一个函数调用中同时设置 contamination 和 threshold。

特权

非超级用户：

  • 模型上的 USAGE 权限

  • 对输入关系的 SELECT 权限

示例

以下示例演示了不同的 threshold 值如何影响对输入关系的异常值检测：

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   threshold=0.75) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+-------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
(1 row)

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   threshold=0.55) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)

您还可以使用不同的 contamination 值来更改异常值阈值：

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   contamination = 0.1) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Marie      | Fields    | {"anomaly_score":0.5307715717521868,"is_anomaly":true}
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(4 rows)

=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
   contamination = 0.01) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
 first_name | last_name |                      predictions
------------+-----------+--------------------------------------------------------
 Jacqueline | Richards  | {"anomaly_score":0.777757463074347,"is_anomaly":true}
 Debra      | Hall      | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
 Gerald     | Fuller    | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)

另请参阅

4.13.3.3 - APPLY_INVERSE_PCA

将 APPLY_PCA 生成的转换反转回原始坐标系。

语法

APPLY_INVERSE_PCA ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 需要满足以下要求：

  • 所有列都必须为数字数据类型。

  • 如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns
来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

以下示例显示了如何使用 APPLY_INVERSE_PCA 函数。它显示了第一条记录的输出。


=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96  Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE

=> SELECT * FROM worldPCA;
HDI   |       country       |       col1
------+---------------------+-------------------
0.886 | Belgium             |  79002.2946705704
0.699 | Belize              | -25631.6670012556
0.427 | Benin               | -40373.4104598122
0.805 | Chile               | -16805.7940082156
0.687 | China               | -37279.2893141103
0.744 | Costa Rica          | -19505.5631231635
0.4   | Cote d'Ivoire       | -38058.2060339272
0.776 | Cuba                | -23724.5779612041
0.895 | Denmark             |  117325.594028813
0.644 | Egypt               | -34609.9941604549
...
(96 rows)

=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
    USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
    key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI  |       country       |      em1970       |      em1971       |      em1972      |      em1973      |
      em1974      |      em1975       |      em1976|      em1977      |      em1978       |      em1979
   |      em1980       |      em1981      |      em1982       |      em1983       |      em1984       |em1985
|      em1986       |      em1987       |      em1988       |      em1989      |      em1990      |      em1991
|      em1992       |      em1993|      em1994      |      em1995       |      em1996       |      em1997
    |      em1998       |      em1999       |      em2000       |      em2001       |em2002       |
em2003      |      em2004       |      em2005      |      em2006       |      em2007       |      em2008
|      em2009      |      em2010       |     gdp1970      |     gdp1971      |     gdp1972      |     gdp1973
|     gdp1974      |     gdp1975      |     gdp1976      |     gdp1977      |gdp1978      |     gdp1979
 |     gdp1980      |     gdp1981      |     gdp1982      |     gdp1983      |     gdp1984      |     gdp1985
      |     gdp1986|    gdp1987      |     gdp1988      |     gdp1989      |     gdp1990      |     gdp1991
     |     gdp1992      |     gdp1993      |     gdp1994      |     gdp1995      |     gdp1996      |
gdp1997      |     gdp1998      |     gdp1999      |     gdp2000      |     gdp2001      |     gdp2002
|     gdp2003      |gdp2004      |     gdp2005      |     gdp2006      |     gdp2007      |     gdp2008
  |     gdp2009      |     gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium             |  18585.6613572407 | -16145.6374560074 |  26938.956253415 | 8094.30475779595 |
 12073.5461203817 | -11069.0567600181 | 19133.8584911727|   5500.312894949 | -4227.94863799987 |  6265.77925410752
|  -10884.749295608 | 30929.4669575201 | -7831.49439429977 |  3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 |   1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 |  18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 |   1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
|  6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
|  5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 |  5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 |  8718.3731386891
...
(96 rows)

另请参阅

4.13.3.4 - APPLY_INVERSE_SVD

将数据转换回原始域。这实质上是通过将三个矩阵相乘来计算原始数据的近似版本：矩阵 U（此函数的输入）、矩阵 S 和 V（存储在模型中）。

语法

APPLY_INVERSE_SVD ( 'input‑columns'
        USING PARAMETERS model_name = 'model‑name'
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 需要满足以下要求：

  • 所有列都必须为数字数据类型。

  • 如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns
来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8  Rejected Rows: 0
(1 row)

=> CREATE TABLE transform_svd AS SELECT
     APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
     OVER () FROM small_svd;
CREATE TABLE

=> SELECT * FROM transform_svd;
id  |       col1        |        col2         |        col3         |        col4
----+-------------------+---------------------+---------------------+--------------------
4   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
6   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
1   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
2   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
3   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
5   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
8   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
7   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
(8 rows)

=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id  |        x1        |        x2        |        x3        |        x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)

另请参阅

4.13.3.5 - APPLY_KMEANS

按照已知 k-means 模型将输入关系的每一行分配给一个群集中心。

语法

APPLY_KMEANS ( input‑columns
       USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

特权

非超级用户：模型所有者或模型的使用权限

示例

以下示例创建 k-means 模型 myKmeansModel 并将其应用于输入表 iris1。APPLY_KMEANS 的调用混合了列名和常量。当传递一个常量代替列名称时，该常量将替换该列在所有行中的值：

=> SELECT KMEANS('myKmeansModel', 'iris1', '*', 5
USING PARAMETERS max_iterations=20, output_view='myKmeansView', key_columns='id', exclude_columns='Species, id');
           KMEANS
----------------------------
 Finished in 12 iterations

(1 row)
=> SELECT id, APPLY_KMEANS(Sepal_Length, 2.2, 1.3, Petal_Width
USING PARAMETERS model_name='myKmeansModel', match_by_pos='true') FROM iris2;
 id  | APPLY_KMEANS
-----+--------------
   5 |            1
  10 |            1
  14 |            1
  15 |            1
  21 |            1
  22 |            1
  24 |            1
  25 |            1
  32 |            1
  33 |            1
  34 |            1
  35 |            1
  38 |            1
  39 |            1
  42 |            1
...
 (60 rows)

另请参阅

4.13.3.6 - APPLY_NORMALIZE

UDTF 函数，用于将保存在模型中的标准化参数应用于一组指定的输入列。如果函数中指定的任何列不在模型中，则其数据都会原封不动地传递到 APPLY_NORMALIZE。

语法

APPLY_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name');

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。 如果您提供星号，APPLY_NORMALIZE 会规范化模型中的所有列。

参数

model_name

模型的名称（不区分大小写）。

示例

以下示例使用表 mtcars 中的 wt 和 hp 列创建具有 NORMALIZE_FIT 的模型，然后在对 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的连续调用中使用此模型。

=> SELECT NORMALIZE_FIT('mtcars_normfit', 'mtcars', 'wt,hp', 'minmax');
NORMALIZE_FIT
---------------
Success
(1 row)

以下对 APPLY_NORMALIZE 的调用指定表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型中，而 cyl 不在标准化模型中：

=> CREATE TABLE mtcars_normalized AS SELECT APPLY_NORMALIZE (hp, cyl USING PARAMETERS model_name = 'mtcars_normfit') FROM mtcars;
CREATE TABLE
=> SELECT * FROM mtcars_normalized;
          hp        | cyl
--------------------+-----
  0.434628975265018 | 8
  0.681978798586572 | 8
  0.434628975265018 | 6
                  1 | 8
  0.540636042402827 | 8
                  0 | 4
  0.681978798586572 | 8
 0.0459363957597173 | 4
  0.434628975265018 | 8
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.204946996466431 | 6
  0.201413427561837 | 4
  0.204946996466431 | 6
  0.250883392226148 | 6
  0.049469964664311 | 4
  0.215547703180212 | 4
 0.0353356890459364 | 4
  0.187279151943463 | 6
  0.452296819787986 | 8
  0.628975265017668 | 8
  0.346289752650177 | 8
  0.137809187279152 | 4
  0.749116607773852 | 8
  0.144876325088339 | 4
  0.151943462897526 | 4
  0.452296819787986 | 8
  0.452296819787986 | 8
  0.575971731448763 | 8
  0.159010600706714 | 4
  0.346289752650177 | 8
(32 rows)

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
  hp | cyl
-----+-----
 175 | 8
 245 | 8
 175 | 6
 335 | 8
 205 | 8
  52 | 4
 245 | 8
  65 | 4
 175 | 8
 110 | 6
 123 | 6
  66 | 4
 110 | 6
 109 | 4
 110 | 6
 123 | 6
  66 | 4
 113 | 4
  62 | 4
 105 | 6
 180 | 8
 230 | 8
 150 | 8
  91 | 4
 264 | 8
  93 | 4
  95 | 4
 180 | 8
 180 | 8
 215 | 8
  97 | 4
 150 | 8
(32 rows)

以下对 REVERSE_NORMALIZE 的调用还指定了表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型 mtcars_normfit 中，而 cyl 不在标准化模型中。

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
       hp        | cyl
-----------------+-----
205.000005722046 |   8
150.000000357628 |   8
150.000000357628 |   8
93.0000016987324 |   4
 174.99999666214 |   8
94.9999992102385 |   4
214.999997496605 |   8
97.0000009387732 |   4
245.000006556511 |   8
 174.99999666214 |   6
             335 |   8
245.000006556511 |   8
62.0000002086163 |   4
 174.99999666214 |   8
230.000002026558 |   8
              52 |   4
263.999997675419 |   8
109.999999523163 |   6
123.000002324581 |   6
64.9999996386468 |   4
66.0000005029142 |   4
112.999997898936 |   4
109.999999523163 |   6
180.000000983477 |   8
180.000000983477 |   8
108.999998658895 |   4
109.999999523163 |   6
104.999999418855 |   6
123.000002324581 |   6
180.000000983477 |   8
66.0000005029142 |   4
90.9999999701977 |   4
(32 rows)

另请参阅

4.13.3.7 - APPLY_ONE_HOT_ENCODER

用户定义的转换函数 (UDTF)，用于加载独热编码器模型并写出包含编码列的表。

语法

APPLY_ONE_HOT_ENCODER( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, drop_first = 'is‑first']
            [, ignore_null = 'ignore']
            [, separator = 'separator‑character']
            [, column_naming = 'name‑output']
            [, null_column_name = 'null‑column‑name'] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

存储类别及其对应的级别。
drop_first
布尔值，可以是以下值之一：

  • true （默认值）：将分类变量的第一个级别视为引用级别。

  • false：分类变量的每个级别都在输出视图中具有对应的列

ignore_null
布尔值，可以是以下值之一：

  • true （默认值）：Null 值将所有对应的 one-hot 二进制列设置为 null。

  • false：将 input-columns 中的 Null 值视为分类级别

separator
在输出表中用于分隔输入变量名称和指示变量级别的字符。要避免使用任何分隔符，可将此参数设置为 null 值。

默认值： 下划线 (_)

column_naming
根据指定的方法将分类级别附加到列名：

  • indices （默认值）：使用整数索引来表示分类级别。

  • values/values_relaxed：两种方法都使用分类级别名称。如果出现重复的列名称，该函数会尝试通过附加 _n 来消除其歧义，其中 n 是从零开始的整数索引（_0、_1、...）。

    如果该函数无法生成唯一的列名称，它将根据所选的方法来处理：

    • values 返回错误。

    • values_relaxed 恢复使用索引。

null_column_name
用于命名 null 值指示列的字符串，仅在 ignore_null 设置为 false 且 column_naming 设置为 values 或 values_relaxed 时使用。

默认值： null

示例

=> SELECT APPLY_ONE_HOT_ENCODER(cyl USING PARAMETERS model_name='one_hot_encoder_model',
drop_first='true', ignore_null='false') FROM mtcars;
cyl | cyl_1 | cyl_2
----+-------+-------
8   |     0 |     1
4   |     0 |     0
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
8   |     0 |     1
6   |     1 |     0
4   |     0 |     0
4   |     0 |     0
6   |     1 |     0
6   |     1 |     0
8   |     0 |     1
8   |     0 |     1
4   |     0 |     0
4   |     0 |     0
6   |     1 |     0
8   |     0 |     1
8   |     0 |     1
6   |     1 |     0
4   |     0 |     0
8   |     0 |     1
8   |     0 |     1
8   |     0 |     1
6   |     1 |     0
6   |     1 |     0
4   |     0 |     0
4   |     0 |     0
(32 rows)

另请参阅

4.13.3.8 - APPLY_PCA

使用 PCA 模型转换数据。该函数将返回每个数据点的新坐标。

语法

APPLY_PCA ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, num_components = num‑components]
            [, cutoff = cutoff‑value]
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns
包含数据矩阵的列的逗号分隔列表，或星号 (*) 以选择所有列。需要满足以下要求：

  • 所有列都必须为数字数据类型。

  • 如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

num_components
要保留在模型中的组件的数量。这是将生成的输出列数。如果忽略此参数和 cutoff 参数，则保留所有模型组件。
cutoff
设置为 1，指定最小累积解释方差。如果累积解释方差未达到该值，将使用组件。
match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns
来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例


=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96  Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE

=> SELECT * FROM worldPCA;
HDI   |       country       |       col1
------+---------------------+-------------------
0.886 | Belgium             |  79002.2946705704
0.699 | Belize              | -25631.6670012556
0.427 | Benin               | -40373.4104598122
0.805 | Chile               | -16805.7940082156
0.687 | China               | -37279.2893141103
0.744 | Costa Rica          | -19505.5631231635
0.4   | Cote d'Ivoire       | -38058.2060339272
0.776 | Cuba                | -23724.5779612041
0.895 | Denmark             |  117325.594028813
0.644 | Egypt               | -34609.9941604549
...
(96 rows)

=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
    USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
    key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI  |       country       |      em1970       |      em1971       |      em1972      |      em1973      |
      em1974      |      em1975       |      em1976|      em1977      |      em1978       |      em1979
   |      em1980       |      em1981      |      em1982       |      em1983       |      em1984       |em1985
|      em1986       |      em1987       |      em1988       |      em1989      |      em1990      |      em1991
|      em1992       |      em1993|      em1994      |      em1995       |      em1996       |      em1997
    |      em1998       |      em1999       |      em2000       |      em2001       |em2002       |
em2003      |      em2004       |      em2005      |      em2006       |      em2007       |      em2008
|      em2009      |      em2010       |     gdp1970      |     gdp1971      |     gdp1972      |     gdp1973
|     gdp1974      |     gdp1975      |     gdp1976      |     gdp1977      |gdp1978      |     gdp1979
 |     gdp1980      |     gdp1981      |     gdp1982      |     gdp1983      |     gdp1984      |     gdp1985
      |     gdp1986|    gdp1987      |     gdp1988      |     gdp1989      |     gdp1990      |     gdp1991
     |     gdp1992      |     gdp1993      |     gdp1994      |     gdp1995      |     gdp1996      |
gdp1997      |     gdp1998      |     gdp1999      |     gdp2000      |     gdp2001      |     gdp2002
|     gdp2003      |gdp2004      |     gdp2005      |     gdp2006      |     gdp2007      |     gdp2008
  |     gdp2009      |     gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium             |  18585.6613572407 | -16145.6374560074 |  26938.956253415 | 8094.30475779595 |
 12073.5461203817 | -11069.0567600181 | 19133.8584911727|   5500.312894949 | -4227.94863799987 |  6265.77925410752
|  -10884.749295608 | 30929.4669575201 | -7831.49439429977 |  3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 |   1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 |  18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 |   1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
|  6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
|  5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 |  5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 |  8718.3731386891
...
(96 rows)

另请参阅

4.13.3.9 - APPLY_SVD

使用 SVD 模型转换数据。可计算 SVD 分解的矩阵 U。

语法

APPLY_SVD ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, num_components = num-components]
            [, cutoff = cutoff‑value]
            [, match_by_pos = match‑by‑position]
            [, exclude_columns = 'excluded‑columns']
            [, key_columns = 'key‑columns'] )

参数

input‑columns
包含数据矩阵的列的逗号分隔列表，或星号 (*) 以选择所有列。需要满足以下要求：

  • 所有列都必须为数字数据类型。

  • 如果列名包含特殊字符，请用双引号将其括起来。

参数

model_name

模型的名称（不区分大小写）。

num_components
要保留在模型中的组件的数量。这是将生成的输出列数。如果既未提供此参数，也未提供 cutoff 参数，则保留模型中的所有组件。
cutoff
设置为 1，指定最小累积解释方差。如果累积解释方差未达到该值，将使用组件。如果忽略此参数和 num_components 参数，则保留所有模型组件。
match_by_pos
指定输入列如何与模型列匹配的布尔值：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

exclude_columns

input-columns 中要排除在处理范围之外的列名的逗号分隔列表。

key_columns
来自 input‑columns 的列名称的逗号分隔列表，用于标识其数据行。这些列包含在输出表中。

示例

=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8  Rejected Rows: 0
(1 row)

=> CREATE TABLE transform_svd AS SELECT
     APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
     OVER () FROM small_svd;
CREATE TABLE

=> SELECT * FROM transform_svd;
id  |       col1        |        col2         |        col3         |        col4
----+-------------------+---------------------+---------------------+--------------------
4   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
6   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
1   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
2   |  0.17652411036246 | -0.0753183783382909 |  -0.678196192333598 | 0.0567124770173372
3   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
5   | 0.494871802886819 |   0.161721379259287 |  0.0712816417153664 | -0.473145877877408
8   |  0.44849499240202 |  -0.347260956311326 |   0.186958376368345 |  0.378561270493651
7   | 0.150974762654569 |   0.589561842046029 | 0.00392654610109522 |  0.360011163271921
(8 rows)

=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id  |        x1        |        x2        |        x3        |        x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 |  6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 |  107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)

另请参阅

4.13.3.10 - PREDICT_AUTOREGRESSOR

对输入关系应用自回归 (AR) 模型。

自回归模型使用以前的值进行预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期时间步长数量，而预测值则是这些滞后的线性组合。

语法

PREDICT_AUTOREGRESSOR ( 'timeseries‑column'
        USING PARAMETERS
            model‑name = 'model-name'
            [, start = starting‑index]
            [, npredictions = npredictions]
            [, missing = "imputation‑method" ] )
        OVER (ORDER BY 'timestamp‑column')
        FROM input‑relation

参数

timeseries‑column
用于进行预测的时间序列列（仅使用模型创建期间指定的最后一个 p 值）。
timestamp‑column
用于进行预测的时间戳列，时间步长一致。
input‑relation
包含 timeseries-column 和 timestamp-column 的输入关系。

请注意，input‑relation 在 start 之前的任何 p（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。

参数

model_name

模型的名称（不区分大小写）。

start
INTEGER >p 或 ≤0，预测的起始 input-relation 索引（行）。如果省略，则从 input-relation 末尾开始预测。

如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。

如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。

对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-p)，以其中较大者为准。

默认： input‑relation 的末尾

npredictions
INTEGER ≥1，预测时间戳的数量。

默认值： 10

missing
用于处理缺失值的方法，为以下之一：

  • drop：忽略缺失值。

  • error：缺失值会引发错误。

  • zero：将缺失值替换为 0。

  • linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。

默认值： linear_interpolation

示例

请参阅自回归模型示例。

另请参阅

4.13.3.11 - PREDICT_LINEAR_REG

对输入关系应用线性回归模型，并将预测值以 FLOAT 形式返回。

语法

PREDICT_LINEAR_REG ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_LINEAR_REG(waiting USING PARAMETERS model_name='myLinearRegModel')FROM
faithful ORDER BY id;


 PREDICT_LINEAR_REG
--------------------
   4.15403481386324
   2.18505296804024
   3.76023844469864
    2.8151271587036
   4.62659045686076
   2.26381224187316
   4.86286827835952
   4.62659045686076
   1.94877514654148
   4.62659045686076
   2.18505296804024
...
 (272 rows)

以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LINEAR_REG 函数。请注意，您可以将 column 实参替换为不同于输入列的常量：

=> SELECT PREDICT_LINEAR_REG(55 USING PARAMETERS model_name='linear_reg_faithful',
                     match_by_pos='true')FROM faithful ORDER BY id;
 PREDICT_LINEAR_REG
--------------------
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
...
 (272 rows)

4.13.3.12 - PREDICT_LOGISTIC_REG

对输入关系应用逻辑回归模型。

PREDICT_LOGISTIC_REG 以 FLOAT 形式返回预测类或预测类的概率，具体取决于 type 参数的设置方式。当返回值位于预测类的概率范围之内时，您可以将返回值转换为 INTEGER 或其他 numeric 类型。

语法

PREDICT_LOGISTIC_REG ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = 'prediction‑type']
            [, cutoff = probability‑cutoff]
            [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type
逻辑回归的预测类型，为以下之一：

  • response （默认值）：预测值为 0 或 1。

  • probability：输出是预测类别为 1 的概率。

cutoff
与 type 参数一起使用，FLOAT 介于 0 和 1 之间且专用。当 type 设置为 response 时，如果相应概率大于或等于 cutoff 的值，则预测返回值为 1；否则，返回值为 0。

默认值： 0.5

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

=> SELECT car_model,
            PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
                                 USING PARAMETERS model_name='myLogisticRegModel')
          FROM mtcars;
      car_model      | PREDICT_LOGISTIC_REG
---------------------+----------------------
 Camaro Z28          |                    0
 Fiat 128            |                    1
 Fiat X1-9           |                    1
 Ford Pantera L      |                    1
 Merc 450SE          |                    0
 Merc 450SL          |                    0
 Toyota Corona       |                    0
 AMC Javelin         |                    0
 Cadillac Fleetwood  |                    0
 Datsun 710          |                    1
 Dodge Challenger    |                    0
 Hornet 4 Drive      |                    0
 Lotus Europa        |                    1
 Merc 230            |                    0
 Merc 280            |                    0
 Merc 280C           |                    0
 Merc 450SLC         |                    0
 Pontiac Firebird    |                    0
 Porsche 914-2       |                    1
 Toyota Corolla      |                    1
 Valiant             |                    0
 Chrysler Imperial   |                    0
 Duster 360          |                    0
 Ferrari Dino        |                    1
 Honda Civic         |                    1
 Hornet Sportabout   |                    0
 Lincoln Continental |                    0
 Maserati Bora       |                    1
 Mazda RX4           |                    1
 Mazda RX4 Wag       |                    1
 Merc 240D           |                    0
 Volvo 142E          |                    1
(32 rows)

以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LOGISTIC_REG。请注意，您可以将任何列输入替换为不同于输入列的常量。在此示例中，列 mpg 被替换为常量 20：

=> SELECT car_model,
            PREDICT_LOGISTIC_REG(20, cyl, disp, drat, wt, qsec, vs, gear, carb
                                 USING PARAMETERS model_name='myLogisticRegModel', match_by_pos='true')
          FROM mtcars;
      car_model     | PREDICT_LOGISTIC_REG
--------------------+----------------------
AMC Javelin         |                    0
Cadillac Fleetwood  |                    0
Camaro Z28          |                    0
Chrysler Imperial   |                    0
Datsun 710          |                    1
Dodge Challenger    |                    0
Duster 360          |                    0
Ferrari Dino        |                    1
Fiat 128            |                    1
Fiat X1-9           |                    1
Ford Pantera L      |                    1
Honda Civic         |                    1
Hornet 4 Drive      |                    0
Hornet Sportabout   |                    0
Lincoln Continental |                    0
Lotus Europa        |                    1
Maserati Bora       |                    1
Mazda RX4           |                    1
Mazda RX4 Wag       |                    1
Merc 230            |                    0
Merc 240D           |                    0
Merc 280            |                    0
Merc 280C           |                    0
Merc 450SE          |                    0
Merc 450SL          |                    0
Merc 450SLC         |                    0
Pontiac Firebird    |                    0
Porsche 914-2       |                    1
Toyota Corolla      |                    1
Toyota Corona       |                    0
Valiant             |                    0
Volvo 142E          |                    1
(32 rows)

4.13.3.13 - PREDICT_MOVING_AVERAGE

将由 MOVING_AVERAGE 创建的移动平均值 (MA) 模型应用于输入关系。

移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期预测和错误数量。

语法

PREDICT_MOVING_AVERAGE ( 'timeseries‑column'
        USING PARAMETERS
            model_name = 'model‑name'
            [, start = starting‑index]
            [, npredictions = npredictions]
            [, missing = "imputation‑method" ] )
        OVER (ORDER BY 'timestamp‑column')
        FROM input‑relation

参数

timeseries‑column
用于进行预测的时间序列列（仅使用模型创建期间指定的最后一个 q 值）。
timestamp‑column
用于进行预测的时间戳列，时间步长一致。
input‑relation
包含 timeseries-column 和 timestamp-column 的输入关系。

请注意，input‑relation 在 start 之前的任何 q（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。

参数

model_name

模型的名称（不区分大小写）。

start
INTEGER >q 或 ≤0，预测的起始 input-relation 索引（行）。如果省略，则从 input-relation 末尾开始预测。

如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。

如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。

对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-q)，以其中较大者为准。

默认： input‑relation 的末尾

npredictions
INTEGER ≥1，预测时间戳的数量。

默认值： 10

missing
用于处理缺失值的方法，为以下之一：

  • drop：忽略缺失值。

  • error：缺失值会引发错误。

  • zero：将缺失值替换为 0。

  • linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。

默认值： linear_interpolation

示例

请参阅移动平均模型示例。

另请参阅

4.13.3.14 - PREDICT_NAIVE_BAYES

对输入关系应用朴素贝叶斯模型。

PREDICT_NAIVE_BAYES 返回指定预测类或预测类概率的 VARCHAR，具体取决于 type 参数的设置方式。如果函数返回概率，您可以将返回值转换为 INTEGER 或其他 numeric 数据类型。

语法

PREDICT_NAIVE_BAYES ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = ' return‑type ']
            [, class = 'user‑input‑class']
            [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type
以下几项之一：

  • response （默认值）：返回概率最高的类。

  • probability：仅当设置 class 参数的情况下才有效，返回属于指定类实参的概率。

class
如果 type 参数设置为 probability，则是必需的。如果省略此参数，“PREDICT_NAIVE_BAYES”返回经预测概率最高的类。
match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

=> SELECT party, PREDICT_NAIVE_BAYES (vote1, vote2, vote3
                                        USING PARAMETERS model_name='naive_house84_model',
                                                         type='response')
                                        AS Predicted_Party
                                        FROM house84_test;
   party    | Predicted_Party
------------+-----------------
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 republican | republican
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 republican | republican
 democrat   | democrat
 democrat   | democrat
 democrat   | democrat
 democrat   | republican
 republican | republican
 democrat   | democrat
 republican | republican
...
(99 rows)

另请参阅

4.13.3.15 - PREDICT_NAIVE_BAYES_CLASSES

对输入关系应用 Naive Bayes 模型并返回类的概率：

  • VARCHAR predicted 列包含概率最高的类标签。

  • 多个 FLOAT 列，其中第一个 probability 列包含预测列中指定的类的概率。其他列包含属于 classes 参数中指定的每个类的概率。

语法

PREDICT_NAIVE_BAYES_CLASSES ( predictor‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns]
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )

参数

predictor‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
classes
以逗号分隔的模型类标签列表。分类器预测属于此给定类的概率。值区分大小写。
match_by_pos
布尔值，指定预测指标列如何匹配模型特征：

  • false （默认值）：按名称匹配。

  • true：按预测指标列列表中列的位置匹配。

示例

=> SELECT PREDICT_NAIVE_BAYES_CLASSES (id, vote1, vote2 USING PARAMETERS
model_name='naive_house84_model',key_columns='id',exclude_columns='id',
classes='democrat, republican', match_by_pos='false')
        OVER() FROM house84_test;
 id  | Predicted  |    Probability    |     democrat      |    republican
-----+------------+-------------------+-------------------+-------------------
  21 | democrat   | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
  28 | democrat   | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
  83 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 102 | democrat   | 0.779889432167111 | 0.779889432167111 | 0.220110567832889
 107 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 125 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 132 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 136 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
 155 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
 174 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
...
(1 row)

另请参阅

4.13.3.16 - PREDICT_PMML

对输入关系应用导入的 PMML 模型。函数返回采用 PMML 模型编码的模型类型预期的结果。

在以下情况下，PREDICT_PMML 返回 NULL：

  • 预测指标为无效值或 NULL 值

  • 分类预测指标属于未知类

语法

PREDICT_PMML ( input‑columns
        USING PARAMETERS model_name = 'model-name' [, match_by_pos = match-by-position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name
模型的名称（不区分大小写）。函数支持对以下模型类型进行编码的 PMML 模型：

  • K-means

  • 线性回归

  • 逻辑回归

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

在此示例中，函数调用使用表中的所有列作为预测指标，同时使用 PMML 格式的 "my_kmeans" 模型预测值：

SELECT PREDICT_PMML(* USING PARAMETERS model_name='my_kmeans') AS predicted_label FROM table;

在此示例中，函数调用仅将列 col1, col2 作为预测指标，使用架构 "my_schema" 中的模型 "my_kmeans" 预测每一行的值：

SELECT PREDICT_PMML(col1, col2 USING PARAMETERS model_name='my_schema.my_kmeans') AS predicted_label FROM table;

在此示例中，函数调用返回的错误既非 schema 也非 model-name，可以接受 * 作为值：

SELECT PREDICT_PMML(* USING PARAMETERS model_name='*.*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='models.*') AS predicted_label FROM table;

另请参阅

4.13.3.17 - PREDICT_RF_CLASSIFIER

对输入关系应用随机森林模型。PREDICT_RF_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：

  • 预测类（基于公民投票）

  • 每个输入实例的类概率。

语法

PREDICT_RF_CLASSIFIER ( input‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, type = 'prediction‑type']
            [, class = 'user‑input‑class']
            [, match_by_pos = match‑by‑position] )

参数

input-columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type
要返回的预测类型，为以下之一：

  • response （默认值）：所有可能的类中概率最高的类。

  • probability：仅当设置 class 参数的情况下才有效，返回指定类的概率。

class
当 type 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 公民投票排名最高的类。因此，预测函数返回输入实例属于其预测类的概率。
match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
       USING PARAMETERS model_name='myRFModel') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)

此示例显示了如何通过 match_by_pos 参数使用 PREDICT_RF_CLASSIFIER 函数：

=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                                USING PARAMETERS model_name='myRFModel', match_by_pos='true') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)

另请参阅

4.13.3.18 - PREDICT_RF_CLASSIFIER_CLASSES

对输入关系应用随机森林模型并返回类的概率：

  • VARCHAR predicted 列包含投票（公民投票）排名最高的类标签。

  • 多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。

  • 与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。

语法

PREDICT_RF_CLASSIFIER_CLASSES ( predictor‑columns
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns']
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )

参数

predictor‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
classes
以逗号分隔的模型类标签列表。分类器预测属于此给定类的概率。值区分大小写。
match_by_pos
布尔值，指定预测指标列如何匹配模型特征：

  • false （默认值）：按名称匹配。

  • true：按预测指标列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                               USING PARAMETERS model_name='myRFModel') OVER () FROM iris;
predicted  |    probability
-----------+-------------------
setosa     |                 1
setosa     |              0.99
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |              0.97
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |              0.99
...
(150 rows)

此示例显示了如何通过 match_by_pos 参数使用函数 PREDICT_RF_CLASSIFIER_CLASSES：

=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
                          USING PARAMETERS model_name='myRFModel', match_by_pos='true') OVER () FROM iris;
predicted  |    probability
-----------+-------------------
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
setosa     |                 1
...
(150 rows)s

另请参阅

4.13.3.19 - PREDICT_RF_REGRESSOR

对输入关系应用随机森林模型，并返回 FLOAT 数据类型，该数据类型用于指定随机森林模型的预测值，即森林中树木的平均预测值。

语法

PREDICT_RF_REGRESSOR ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

=> SELECT PREDICT_RF_REGRESSOR (mpg,cyl,hp,drat,wt
USING PARAMETERS model_name='myRFRegressorModel')FROM mtcars;
PREDICT_RF_REGRESSOR
----------------------
2.94774203574204
2.6954087024087
2.6954087024087
2.89906346431346
2.97688489288489
2.97688489288489
2.7086587024087
2.92078965478965
2.97688489288489
2.7086587024087
2.95621822621823
2.82255155955156
2.7086587024087
2.7086587024087
2.85650394050394
2.85650394050394
2.97688489288489
2.95621822621823
2.6954087024087
2.6954087024087
2.84493251193251
2.97688489288489
2.97688489288489
2.8856467976468
2.6954087024087
2.92078965478965
2.97688489288489
2.97688489288489
2.7934087024087
2.7934087024087
2.7086587024087
2.72469441669442
(32 rows)

另请参阅

4.13.3.20 - PREDICT_SVM_CLASSIFIER

使用 SVM 模型预测输入关系中样本的类标签，并将预测值以 FLOAT 数据类型返回。

语法

PREDICT_SVM_CLASSIFIER (input‑columns
     USING PARAMETERS model_name = 'model‑name'
            [, match_by_pos = match‑by‑position]
            [, type = 'return‑type']
            [, cutoff = 'cutoff‑value'] ] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

type
一个字符串，指定针对每个输入行返回的输出，为以下之一：

  • response：输出 0 或 1 的预测类。

  • probability：输出位于 (0,1) 范围内的值，即使用逻辑函数转换的预测得分。

cutoff
仅当 type 参数设置为 probability 的情况下才有效，这是一个 FLOAT 值，用于与转换的预测得分进行比较以确定预测类。

默认值： 0

示例


=> SELECT PREDICT_SVM_CLASSIFIER (mpg,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
1
0
0
1
1
1
1
0
0
1
0
0
1
0
0
0
0
0
0
1
1
0
0
1
1
1
1
0
0
0
(32 rows)

此示例显示了如何通过 match_by_pos 参数对 mtcars 表使用 PREDICT_SVM_CLASSIFIER。在此示例中，列 mpg 被替换为常量 40：


=> SELECT PREDICT_SVM_CLASSIFIER (40,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel', match_by_pos ='true') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
0
0
1
0
0
1
1
1
1
1
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
1
1
0
0
1
(32 rows)

另请参阅

4.13.3.21 - PREDICT_SVM_REGRESSOR

使用 SVM 模型对输入关系中的样本执行回归，并将预测值以 FLOAT 数据类型返回。

语法

PREDICT_SVM_REGRESSOR(input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例


=> SELECT PREDICT_SVM_REGRESSOR(waiting USING PARAMETERS model_name='mySvmRegModel')
           FROM faithful ORDER BY id;
 PREDICT_SVM_REGRESSOR
--------------------
   4.06488248694445
   2.30392277646291
   3.71269054484815
   2.867429883817
   4.48751281746003
   2.37436116488217
   4.69882798271781
   4.48751281746003
   2.09260761120512
...
 (272 rows)

此示例显示了如何通过 match_by_pos 参数对有信心的表使用 PREDICT_SVM_REGRESSOR 函数。在此示例中，等待列被替换为常量 40：


=> SELECT PREDICT_SVM_REGRESSOR(40 USING PARAMETERS model_name='mySvmRegModel', match_by_pos='true')
           FROM faithful ORDER BY id;
 PREDICT_SVM_REGRESSOR
--------------------
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
   1.31778533859324
...
 (272 rows)

另请参阅

4.13.3.22 - PREDICT_TENSORFLOW

对输入关系应用 TensorFlow 模型，并返回编码模型类型的预期结果。

语法

PREDICT_TENSORFLOW ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, num_passthru_cols = 'n-first-columns-to-ignore'] )
OVER( [window-partition-clause] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

num_passthru_cols
指定要跳过的输入列数的整数。

示例

使用 PREDICT_TENSORFLOW 和 num_passthru_cols 跳过前两个输入列：


SELECT PREDICT_TENSORFLOW ( pid,label,x1,x2
        USING PARAMETERS model_name='spiral_demo', num_passthru_cols=2 )
OVER(PARTITION BEST) as predicted_class FROM points;

--example output, the skipped columns are displayed as the first columns of the output
  pid  | label |         col0         |         col1
-------+-------+----------------------+----------------------
     0 |     0 |    0.990638732910156 |  0.00936129689216614
     1 |     0 |    0.999036073684692 | 0.000963933940511197
     2 |     1 |   0.0103802494704723 | 0.989619791507721

另请参阅

4.13.3.23 - PREDICT_XGB_CLASSIFIER

对输入关系应用 XGBoost 分类器模型。 PREDICT_XGB_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：

  • 预测类（基于概率得分）

  • 每个输入实例的类概率。

语法

PREDICT_XGB_CLASSIFIER ( input‑columns
          USING PARAMETERS model_name = 'model‑name'
              [, type = 'prediction-type' ]
              [, class = 'user‑input‑class' ]
              [, match_by_pos = 'match‑by‑position' ]
              [, probability_normalization = 'prob-normalization' ] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

type
要返回的预测类型，为以下之一：

  • response （默认值）：所有可能的类中概率最高的类。

  • probability：仅当设置 class 参数的情况下才有效，针对每个输入实例返回指定类或预测类的概率。

class
当 type 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 概率得分最高的类别。因此，预测函数返回输入实例属于指定类或预测类的概率。
match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

probability_normalization

分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。

示例

使用 PREDICT_XGB_CLASSIFIER 将分类器应用于测试数据：

=> SELECT PREDICT_XGB_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris', probability_normalization='logit') FROM iris1;
PREDICT_XGB_CLASSIFIER
------------------------
setosa
setosa
setosa
.
.
.
versicolor
versicolor
versicolor
.
.
.
virginica
virginica
virginica
.
.
.

(90 rows)

有关更多示例，请参阅 XGBoost 用于分类。

4.13.3.24 - PREDICT_XGB_CLASSIFIER_CLASSES

对输入关系应用 XGBoost 分类器模型并返回类的概率：

  • VARCHAR predicted 列包含概率最高的类标签。

  • 多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。

  • 与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。

所有树都会影响每个响应类的预测概率，选择概率最高的类。

语法

PREDICT_XGB_CLASSIFIER_CLASSES ( predictor‑columns)
        USING PARAMETERS model_name = 'model‑name'
            [, key_columns = 'key‑columns']
            [, exclude_columns = 'excluded‑columns']
            [, classes = 'classes']
            [, match_by_pos = match‑by‑position]
            [, probability_normalization = 'prob-normalization' ] )
OVER( [window-partition-clause] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

key_columns

用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
classes
以逗号分隔的模型类标签列表。分类器预测属于每个给定类的概率。值区分大小写。
match_by_pos
布尔值，指定预测指标列如何匹配模型特征：

  • false （默认值）：按名称匹配。

  • true：按预测指标列列表中列的位置匹配。

probability_normalization

分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。

示例

使用 XGB_CLASSIFIER 创建 XGBoost 分类器模型后，您可以使用 PREDICT_XGB_CLASSIFIER_CLASSES 查看每个分类的概率。在此示例中，XGBoost 分类器模型 "xgb_iris" 用于预测给定花属于“鸢尾 (iris)”属的概率：

=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris') OVER (PARTITION BEST) FROM iris1;
  predicted  |    probability
------------+-------------------
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     | 0.999911552783011
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 setosa     |   0.9999650465368
 versicolor |  0.99991871763563
 .
 .
 .
(90 rows)

您还可以指定其他类。在此示例中，PREDICT_XGB_CLASSIFIER_CLASSES 与上一个示例进行相同的预测，但同样返回花属于指定的 classes“北美车前 (virginica)”和“花叶芦竹 (versicolor)”的概率：

=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
    USING PARAMETERS model_name='xgb_iris', classes='virginica,versicolor', probability_normalization='logit') OVER (PARTITION BEST) FROM iris1;
 predicted  |    probability    |      virginica       |      versicolor
------------+-------------------+----------------------+----------------------
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 setosa     |   0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
 .
 .
 .
 versicolor |  0.99991871763563 | 6.45697562080953e-05 |     0.99991871763563
 versicolor | 0.999967282051702 | 1.60052775404199e-05 |    0.999967282051702
 versicolor | 0.999648819964864 |  0.00028366342010669 |    0.999648819964864
 .
 .
 .
 virginica  | 0.999977039257386 |    0.999977039257386 | 1.13305901169304e-05
 virginica  | 0.999977085131063 |    0.999977085131063 | 1.12847163501674e-05
 virginica  | 0.999977039257386 |    0.999977039257386 | 1.13305901169304e-05
(90 rows)

4.13.3.25 - PREDICT_XGB_REGRESSOR

对输入关系应用 XGBoost 回归模型。 PREDICT_XGB_REGRESSOR 返回 FLOAT 数据类型，指定 XGBoost 模型的预测值：模型中每个树的贡献加权总和。

语法

PREDICT_XGB_REGRESSOR ( input‑columns
        USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )

参数

input‑columns
输入关系中要使用的列的逗号分隔列表，或者使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

match_by_pos

该布尔值指定输入列如何与模型特征匹配：

  • false （默认值）：按名称匹配。

  • true：按输入列列表中列的位置匹配。

示例

请参阅用于回归的 XGBoost。

4.13.3.26 - REVERSE_NORMALIZE

对标准化数据进行反向标准化转换，从而使标准化数据非标准化。如果您指定的列并非位于指定模型，则 REVERSE_NORMALIZE 会按原样返回该列。

语法

REVERSE_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name' );

参数

input‑columns
使用输入关系中的列，或使用星号 (*) 选择所有列。

参数

model_name

模型的名称（不区分大小写）。

示例

对表 mtcars 中的 hp 和 cyl 列使用 REVERSE_NORMALIZE，其中 hp 位于标准化模型 mtcars_normfit，cyl 并非位于标准化模型。

=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars;
hp    | cyl
------+-----
42502 |   8
58067 |   8
26371 |   4
42502 |   8
31182 |   6
32031 |   4
26937 |   4
34861 |   6
34861 |   6
50992 |   8
50992 |   8
49577 |   8
25805 |   4
18447 |   4
29767 |   6
65142 |   8
69387 |   8
14768 |   4
49577 |   8
60897 |   8
94857 |   8
31182 |   6
31182 |   6
30899 |   4
69387 |   8
49577 |   6
18730 |   4
18730 |   4
74764 |   8
17598 |   4
50992 |   8
27503 |   4
(32 rows)

另请参阅

4.13.4 - 模型评估

一组 Vertica 机器学习函数评估训练模型生成的预测数据，或返回有关模型本身的信息。

4.13.4.1 - CONFUSION_MATRIX

使用响应变量的观察值和预测值计算表的混淆矩阵。 CONFUSION_MATRIX 生成具有以下尺寸的表格：

  • 行：类的数量

  • 列：类的数量 + 2

语法

CONFUSION_MATRIX ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] OVER()

参数

实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：

  • INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。

  • BOOLEAN：“是”或“否”

  • CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。

参数

num_classes

一个整数 > 1，指定要传递给该函数的类数。

如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：

  • INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。

  • BOOLEAN：默认设置为 2，不能设置为任何其他值。

示例

此示例计算逻辑回归模型的混淆矩阵，该模型将 mtcars 数据集中的汽车分为自动档或手动档。观察值在输入列 obs 中，而预测值在输入列 pred 中。因为这是一个二元分类问题，所以所有值都是 0 或 1。

在返回的表中，列 am 中值为 0 的所有 19 辆汽车都被 PREDICT_LOGISTIC_REGRESSION 正确预测其值为 0。在 am 列中值为 1 的 13 辆汽车中，12 辆被正确预测其值为 1，而 1 辆汽车被错误地分类为值 0：

=> SELECT CONFUSION_MATRIX(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
    FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp,drat, wt, qsec, vs, gear, carb
             USING PARAMETERS model_name='myLogisticRegModel')AS PRED
             FROM mtcars) AS prediction_output;

actual_class | predicted_0 | predicted_1 |        comment
-------------+-------------+-------------+------------------------------------------
0            |          19 |           0 |
1            |           0 |          13 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)

4.13.4.2 - CROSS_VALIDATE

使用输入关系对学习算法执行 k-fold 交叉验证，并对超参数执行网格搜索。输出是所选算法的平均性能指标。该函数支持 SVM 分类、朴素贝叶斯和逻辑回归。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CROSS_VALIDATE ( 'algorithm', 'input‑relation', 'response‑column', 'predictor‑columns'
        [ USING PARAMETERS
              [exclude_columns = 'excluded‑columns']
           [, cv_model_name = 'model']
           [, cv_metrics = 'metrics']
           [, cv_fold_count = num‑folds]
           [, cv_hyperparams = 'hyperparams']
           [, cv_prediction_cutoff = prediction‑cutoff] ] )

参数

算法
算法训练函数的名称，为以下之一：
input‑relation
包含用于训练和测试的数据的表或视图。 如果输入关系在 Hive 中定义，请使用 SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。
response‑column
包含响应的输入列的名称。
predictor‑columns

输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。

参数

exclude_columns
要从处理中排除来自 predictor‑columns 列的逗号分隔列表。
cv_model_name
允许您检索交叉验证过程结果的模型的名称。如果忽略此参数，则显示结果但不保存。如果将此参数设置为模型名称，则可以使用摘要函数 GET_MODEL_ATTRIBUTE 和 GET_MODEL_SUMMARY 检索结果
cv_metrics
用于评估算法的指标，指定为指标名称的逗号分隔列表或 JSON 数组。在这两种情况下，您都需要指定以下一个或多个指标名称：

  • accuracy （默认值）

  • error_rate

  • TP：真阳性，预测为 1 类的 1 类案例数

  • FP：假阳性，预测为 1 类的 0 类案例数

  • TN：真阴性，预测为 0 类的 0 类案例数

  • FN：假阴性，预测 0 类的 1 类案例数

  • TPR 或 recall：真阳性率，1 类中的正确预测

  • FPR：假阳性率，0 类中的错误预测

  • TNR：真阴性率，0 类中的正确预测

  • FNR：假阴性率，1 类中的错误预测

  • PPV 或 precision：阳性预测值，预测为 1 类案例中的正确预测

  • NPV：阴性预测值，预测为 0 类案例中的正确预测

  • MSE：均方误差

     ![](/images/machine-learning/mean-squared-error.png)

  • MAE：平均绝对误差

     ![](/images/machine-learning/mean-absolute-error.png)

  • rsquared：决定系数

     ![](/images/machine-learning/rsquared.png)

  • explained_variance

    ![](/images/machine-learning/explained-variance.png)

  • fscore 

    (1 + beta˄2) * precison * recall / (beta˄2 * precision + recall)

    beta 默认等于 1

  • auc_roc：使用指定数量 bin 的 ROC 的 AUC，默认为 100

  • auc_prc：使用指定数量 bin 的 PRC 的 AUC，默认为 100

  • counts：解析为其他四个指标的快捷方式：TP、FP、TN 和 FN

  • count：仅在 JSON 语法中有效，计算由一个类 (case-class-label) 标记但预测为另一类 (predicted-class-label) 的案例数：

    cv_metrics='[{"count":[case-class-label, predicted-class-label]}]'
cv_fold_count
拆分数据的折叠数。

默认值： 5

cv_hyperparams
JSON 字符串，描述用于超参数网格搜索的参数组合。JSON 字符串包含成对的超参数名称。每个超参数的值可以指定为数组或序列。例如： 
{"param1":[value1,value2,...], "param2":{"first":first_value, "step":step_size, "count":number_of_values} }

应使用 JSON 标准引用超参数名称和字符串值。这些参数被传递给训练函数。

cv_prediction_cutoff
传递给逻辑回归预测阶段的临界阈值，介于 0 和 1（不含）之间的 FLOAT

默认值： 0.5

模型属性

call_string
在调用 CROSS_VALIDATE 时指定的所有输入实参的值。
run_average
参数 cv_metrics 中指定的所有指标的所有折叠的平均值（如果指定）；否则为平均精度。
fold_info
每个折叠的行数：

  • fold_id：折叠的索引。

  • row_count：折叠中为测试而保留的行数。

counters
该函数的所有计数器，包括：

  • accepted_row_count：input_relation 中的总行数减去拒绝的行数。

  • rejected_row_count：因包含无效值而跳过的 input_relation 行数。

  • feature_count：输入到机器学习模型的特征数量。

run_details
有关每次运行的信息，其中运行意味着训练一个模型，然后在一个保留的折叠上测试该模型：

  • fold_id：保留用于测试的折叠的索引。

  • iteration_count：在非保留折叠的模型训练中使用的迭代数。

  • accuracy：参数 cv_metrics 中指定的所有指标，或精度（如果未提供 cv_metrics）。

  • error_rate：参数 cv_metrics 中指定的所有指标，或精度（如果忽略该参数）。

特权

非超级用户：

  • 对输入关系的 SELECT 权限

  • 机器学习算法在其中生成模型的默认架构的 CREATE 和 USAGE 权限。如果提供了 cv_model_name，则交叉验证结果将作为模型保存在同一架构中。

在 JSON 中指定指标

参数 cv_metrics 可以将指标指定为 JSON 对象 的数组，其中每个对象指定一个指标名称。例如，以下表达式将 cv_metrics 设置为指定为 JSON 对象的两个指标，即 accuracy 和 error_rate：

cv_metrics='["accuracy", "error_rate"]'

在下一个示例中，cv_metrics 设置为两个指标，即 accuracy 和 TPR（真阳性率）。此处，TPR 指标被指定为一个 JSON 对象，它接受一个包含两个类标签实参（即 2 和 3）的数组：

cv_metrics='[ "accuracy", {"TPR":[2,3] } ]'

指定为 JSON 对象的指标可以接受参数。在以下示例中，fscore 指标指定参数 beta，该参数设置为 0.5：

cv_metrics='[ {"fscore":{"beta":0.5} } ]'

参数支持对于某些指标特别有用。例如，指标 auc_roc 和 auc_prc 构建一条曲线，然后计算该曲线下的面积。对于 ROC，曲线是通过绘制指标 TPR 与 FPR 而成的；对于 PRC，通过绘制指标 PPV (precision) 与 TPR (recall) 而成。通过将参数 num_bins 设置为大于默认值 100 的值，可以提高此类曲线的精度。例如，以下表达式计算使用 1000 个 bin 构建的 ROC 曲线的 AUC：

cv_metrics='[{"auc_roc":{"num_bins":1000}}]'

将指标用于多类分类器函数

所有支持的指标均为二元分类器函数 LOGISTIC_REG 和 SVM_CLASSIFIER 而定义。对于 NAIVE_BAYES 等多类分类器函数，可以针对每个 one-versus-the-rest 二元分类器计算这些指标。使用实参请求每个分类器的指标。例如，如果训练数据具有整数类标签，您可以使用 precision (PPV) 指标设置 cv_metrics，如下所示：

cv_metrics='[{"precision":[0,4]}]'

此设置指定返回为两个分类器计算精度的两列：

  • 第 1 列：对 0 与非 0 进行分类

  • 第 2 列：对 4 与非 4 进行分类

如果忽略类标签实参，则使用索引为 1 的类。不是为单个 one-versus-the-rest 分类器计算指标，而是以下列方式之一计算平均值：macro、micro 或 weighted（默认）。例如，以下 cv_metrics 设置返回按类大小加权的平均值：

cv_metrics='[{"precision":{"avg":"weighted"}}]'

可以采用类似方式为多类分类器定义 AUC 类型的指标。例如，以下 cv_metrics 设置计算每个 one-versus-the-rest 分类器的 ROC 曲线下面积，然后返回按类大小加权的平均值。

cv_metrics='[{"auc_roc":{"avg":"weighted", "num_bins":1000}}]'

示例

=> SELECT CROSS_VALIDATE('svm_classifier', 'mtcars', 'am', 'mpg'
      USING PARAMETERS cv_fold_count= 6,
                       cv_hyperparams='{"C":[1,5]}',
                       cv_model_name='cv_svm',
                       cv_metrics='accuracy, error_rate');
         CROSS_VALIDATE
----------------------------
 Finished

===========
run_average
===========
C  |accuracy      |error_rate
---+--------------+----------
1 | 0.75556       |  0.24444
5 | 0.78333       |  0.21667
(1 row)

4.13.4.3 - ERROR_RATE

使用输入表返回一个计算错误分类率并将其显示为 FLOAT 值的表。 ERROR_RATE 返回具有以下维度的表：

  • 行：类数加上包含跨类总错误率的一行

  • 列：2

语法

ERROR_RATE ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] ) OVER()

参数

实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：

  • INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。

  • BOOLEAN：“是”或“否”

  • CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。

参数

num_classes

一个整数 > 1，指定要传递给该函数的类数。

如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：

  • INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。

  • BOOLEAN：默认设置为 2，不能设置为任何其他值。

特权

非超级用户：模型所有者或模型的使用权限

示例

此示例说明如何对名为 mtcars 的输入表执行 ERROR_RATE 函数。obs 列中显示响应变量，而 pred 列中显示预测值。由于该示例是一个分类问题，因此所有的响应变量值和预测变量值都是 0 或 1，表示二元分类。

在函数返回的表中，第一列显示类 ID 列。第二列显示该类 ID 的相应错误率。第三列表示该函数成功使用了多少行以及是否忽略了任何行。

=> SELECT ERROR_RATE(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
    FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
                USING PARAMETERS model_name='myLogisticRegModel', type='response') AS pred
             FROM mtcars) AS prediction_output;
 class |     error_rate     |                   comment
-------+--------------------+---------------------------------------------
     0 |                  0 |
     1 | 0.0769230797886848 |
       |            0.03125 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)

4.13.4.4 - LIFT_TABLE

返回一个对比机器学习模型的可预测质量的表。此函数也被称为提升图。

语法

LIFT_TABLE ( targets, probabilities
        [ USING PARAMETERS [num_bins = num‑bins] [, main_class = class‑name ] ] )
OVER()

参数

参数

num_bins

该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。

默认值：100

main_class

仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。

示例

对输入表 mtcars 执行 LIFT_TABLE。

=> SELECT LIFT_TABLE(obs::int, prob::float USING PARAMETERS num_bins=2) OVER()
    FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
                                                    USING PARAMETERS model_name='myLogisticRegModel',
                                                    type='probability') AS prob
             FROM mtcars) AS prediction_output;

 decision_boundary | positive_prediction_ratio |       lift       |                   comment
-------------------+---------------------------+------------------+---------------------------------------------
                 1 |                         0 |              NaN |
               0.5 |                   0.40625 | 2.46153846153846 |
                 0 |                         1 |                1 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)

第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，对于每行，如果 prob 大于或等于 decision_boundary，将响应值分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。

第二列中，positive_prediction_ratio 表示分类 1 中使用相应 decision_boundary 值进行争取分类的样本比例。

第三列中，lift 函数用正确或错误分类为类 1 的行百分比来除 positive_prediction_ratio。

4.13.4.5 - MSE

返回一个表，其中显示机器学习模型中预测和响应列的均方误差。

语法

MSE ( targets, predictions ) OVER()

参数

targets
FLOAT 类型的模型响应变量。
predictions
包含响应变量预测值的 FLOAT 输入列。

示例

对输入表 faithful_testing 执行 MSE 函数。obs 列中显示响应变量，而 prediction 列中显示预测值。

=> SELECT MSE(obs, prediction) OVER()
   FROM (SELECT eruptions AS obs,
                PREDICT_LINEAR_REG (waiting USING PARAMETERS model_name='myLinearRegModel') AS prediction
         FROM faithful_testing) AS prediction_output;
        mse        |                   Comments
-------------------+-----------------------------------------------
 0.252925741352641 | Of 110 rows, 110 were used and 0 were ignored
(1 row)

4.13.4.6 - PRC

返回一个表，其中显示了接收器 Precision Recall (PR) 曲线上的点。

语法

PRC ( targets, probabilities
       [ USING PARAMETERS
             [num_bins = num‑bins]
             [, f1_score = return‑score ]
             [, main_class = class‑name ] )
OVER()

参数

参数

num_bins

该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。

默认值：100

f1_score
一个布尔值，指定是否返回包含 f1 分数的列 - 精度和召回度量的调和平均值，其中 F1 分数在 1 处达到其最佳值（完美的精度和召回率），在 0 处达到最差值。

默认值：false

main_class

仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。

示例

对名为 mtcars 的输入表执行 PRC 函数。obs 列中显示响应变量，而 pred 列中显示预测变量。

=> SELECT PRC(obs::int, prob::float USING PARAMETERS num_bins=2, f1_score=true) OVER()
    FROM (SELECT am AS obs,
                    PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
                          USING PARAMETERS model_name='myLogisticRegModel',
                                           type='probability') AS prob
             FROM mtcars) AS prediction_output;
decision_boundary | recall | precision |     f1_score      |     comment
------------------+--------+-----------+-------------------+--------------------------------------------
0                 |      1 |   0.40625 | 0.577777777777778 |
0.5               |      1 |         1 |                 1 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)

第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，在每行中，如果概率等于或大于 decision_boundary，则将响应分类为 1。如果概率小于 decision_boundary，则将响应分类为 0。

4.13.4.7 - READ_TREE

读取随机森林或 XGBoost 模型中树的内容。

语法

READ_TREE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] [, format = 'format'] )

参数

model_name
标识作为训练结果存储的模型，其中 model‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
tree_id
树标识符，0 到 n-1 之间的整数，其中 n 为随机森林或 XGBoost 模型中的树数。如果忽略此参数，则返回所有树。
format
返回树的输出格式，为以下之一：

  • tabular：返回包含 12 个输出列的表。

  • graphviz：返回可以传递给 graphviz 工具并呈现树的图形可视化的 DOT 语言源。

特权

非超级用户：模型上的 USAGE 权限

示例

从 READ_TREE 获取随机森林模型的表格格式输出：

=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'tabular') LIMIT 2;
-[ RECORD 1 ]-------------+-------------------
tree_id                   | 1
node_id                   | 1
node_depth                | 0
is_leaf                   | f
is_categorical_split      | f
split_predictor           | petal_length
split_value               | 1.921875
weighted_information_gain | 0.111242236024845
left_child_id             | 2
right_child_id            | 3
prediction                |
probability/variance      |

-[ RECORD 2 ]-------------+-------------------
tree_id                   | 1
node_id                   | 2
node_depth                | 1
is_leaf                   | t
is_categorical_split      |
split_predictor           |
split_value               |
weighted_information_gain |
left_child_id             |
right_child_id            |
prediction                | setosa
probability/variance      | 1

从 READ_TREE 获取 graphviz 格式的输出：

=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'graphviz')LIMIT 1;

-[ RECORD 1 ]+-------------------------------------------------------------------
---------------------------------------------------------------------------------
tree_id      | 1
tree_digraph | digraph Tree{
1 [label="petal_length < 1.921875 ?", color="blue"];
1 -> 2 [label="yes", color="black"];
1 -> 3 [label="no", color="black"];
2 [label="prediction: setosa, probability: 1", color="red"];
3 [label="petal_length < 4.871875 ?", color="blue"];
3 -> 6 [label="yes", color="black"];
3 -> 7 [label="no", color="black"];
6 [label="prediction: versicolor, probability: 1", color="red"];
7 [label="prediction: virginica, probability: 1", color="red"];
}

此输入呈现如下：

另请参阅

4.13.4.8 - RF_PREDICTOR_IMPORTANCE

使用平均减少杂质 (MDI) 方法衡量随机森林模型中预测工具的重要性。重要性向量被规范化为总和为 1。

语法

RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] )

参数

model_name
标识作为训练结果存储的模型，其中 model‑name 必须为 rf_classifier 或 rf_regressor 类型。
tree_id
标识要处理的树，0 到 n-1 之间的整数，其中 n 为森林中树的数量。如果忽略此参数，该函数将使用所有树来测量重要性值。

特权

非超级用户：模型上的 USAGE 权限

示例

此示例说明如何使用 RF_PREDICTOR_IMPORTANCE 函数。

=> SELECT RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'myRFModel');
 predictor_index | predictor_name | importance_value
-----------------+----------------+--------------------
               0 | sepal.length   | 0.106763318092655
               1 | sepal.width    | 0.0279536658041994
               2 | petal.length   | 0.499198722346586
               3 | petal.width    | 0.366084293756561
(4 rows)

另请参阅

4.13.4.9 - ROC

返回表，其中显示了操作特征曲线的接收器上的点。在提高模型的鉴别阈值时，ROC 函数会告知分类模型的精度。

语法

ROC ( targets, probabilities
        [ USING PARAMETERS
              [num_bins = num‑bins]
              [, AUC = output]
              [, main_class = class‑name ] ) ] )
OVER()

参数

参数

num_bins

该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。

默认值：100

更大的值会产生更精确的 AUC 近似值。

AUC
一个布尔值，指定是否输出曲线下面积 (AUC) 值。

默认值： True

main_class

仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。

示例

对输入表 mtcars 执行 ROC。观察到的类标签在 obs 列中，预测类标签在 prob 列中：

=> SELECT ROC(obs::int, prob::float USING PARAMETERS num_bins=5, AUC = True) OVER()
    FROM (SELECT am AS obs,
          PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
               USING PARAMETERS
                  model_name='myLogisticRegModel', type='probability') AS prob
   FROM mtcars) AS prediction_output;

 decision_boundary | false_positive_rate | true_positive_rate | AUC |comment
-------------------+---------------------+--------------------+-----+-----------------------------------
0                  |                   1 |                  1 |     |
0.5                |                   0 |                  1 |     |
1                  |                   0 |                  0 |   1 | Of 32 rows,32 were used and 0 were ignoreded
(3 rows)

该函数会返回包含以下结果的表：

  • decision_boundary 指示是否将响应分类为 0 或 1 的分界点。在每行中，如果 prob 等于或大于 decision_boundary，则将响应分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。

  • false_positive_rate 显示了相应 decision_boundary 中的误报（当 0 被分类为 1 时）百分比。

  • true_positive_rate 显示了分类为 1 并且还属于类 1 的行的百分比。

4.13.4.10 - RSQUARED

返回一个表，其中包含回归模型中预测的 R 平方值。

语法

RSQUARED ( targets, predictions ) OVER()

参数

targets
模型的 FLOAT 响应变量。
predictions
一个 FLOAT 输入列，其中包含响应变量的预测值。

示例

此示例演示了如何对名为 faithful_testing 的输入表执行 RSQUARED 函数。obs 列中显示响应变量的观测值，而 pred 列中显示响应变量的预测值。

=> SELECT RSQUARED(obs, prediction) OVER()
     FROM (SELECT eruptions AS obs,
                  PREDICT_LINEAR_REG (waiting
                                       USING PARAMETERS model_name='myLinearRegModel') AS prediction
           FROM faithful_testing) AS prediction_output;
        rsq        |                    comment
-------------------+-----------------------------------------------
 0.801392981147911 | Of 110 rows, 110 were used and 0 were ignored
(1 row)

4.13.5 - 模型管理

Vertica 提供了管理模型的多种函数。

4.13.5.1 - EXPORT_MODELS

导出机器学习模型。Vertica 支持三种模型格式：

  • 原生 Vertica (VERTICA_MODELS)

  • PMML

  • TensorFlow

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_MODELS ( 'output-dir', 'export-target' [ USING PARAMETERS category = 'model-category' ] )

参数

output-dir
用于存储导出模型的输出目录的绝对路径。
export-target
指定要导出的模型，如下所示： 
 [schema.]{ model‑name | * }

其中 schema 指定从指定的架构导出模型（可选）。如果忽略，EXPORT_MODELS 使用默认架构。提供 *（星号）以从架构中导出所有模型。

参数

category
要导出的模型类别，为以下之一：

  • VERTICA_MODELS

  • PMML

  • TENSORFLOW

EXPORT_MODELS 根据导出操作的范围导出指定类别的模型，即应用于单个模型，还是应用于架构中的所有模型。请参阅下面的导出范围和类别处理。

下文导出的文件描述了 EXPORT_MODELS 为每个类别导出的文件。

如果忽略此参数，EXPORT_MODELS 将根据模型类型导出模型或指定架构中的模型。

特权

超级用户

导出范围和类别处理

EXPORT_MODELS 根据以下参数设置执行：

  • 导出操作的范围：单个模型，或给定架构中的所有模型

  • 指定或忽略的类别

下表显示了这两个参数如何控制导出过程：

导出的文件

EXPORT_MODELS 为每个模型类别导出以下文件：

类别和兼容模型

如果 EXPORT_MODELS 指定单个模型并且还设置了 category 参数，则如果模型类型和类别兼容，则函数成功；否则，它会返回错误：

如果 EXPORT_MODELS 指定从架构中导出所有模型并设置类别，它会针对与该类别不兼容的每个模型发出警告消息。该函数随后继续处理该架构中的剩余模型。

EXPORT_MODELS 在 output-dir/export_log.json 中记录所有错误和警告。

示例

导出模型而不更改其类别：

  • 导出模型 myschema.mykmeansmodel 而不更改其类别：

    => SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.mykmeansmodel');
EXPORT_MODELS
----------------
Success
(1 row)

  • 导出架构 myschema 中的所有模型而不更改其类别：

    => SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.*');
EXPORT_MODELS
----------------
Success
(1 row)

导出与指定类别兼容的模型：

  • 类别设置为 PMML。PMML 和 VERTICA_MODELS 类型的模型与 PMML 类别兼容，因此如果 my_keans 属于任一类型，则导出操作成功：

    => SELECT EXPORT_MODELS ('/tmp/', 'my_kmeans' USING PARAMETERS category='PMML');

  • 类别设置为 VERTICA_MODELS。只有 VERTICA_MODELS 类型的模型与 VERTICA_MODELS 类别兼容，因此只有当 my_keans 属于该类型时，导出操作才会成功：

    => SELECT EXPORT_MODELS ('/tmp/', 'public.my_kmeans' USING PARAMETERS category='VERTICA_MODELS');

  • 类别设置为 TENSORFLOW。只有 TensorFlow 类型的模型与 TENSORFLOW 类别兼容，因此模型 tf_mnist_keras 必须为 TensorFlow 类型：

    => SELECT EXPORT_MODELS ('/tmp/', 'tf_mnist_keras', USING PARAMETERS category='TENSORFLOW');
export_models
---------------
Success
(1 row)

导出 TensorFlow 模型 tf_mnist_keras 后，列出导出的文件：

$ ls tf_mnist_keras/
crc.json  metadata.json  mnist_keras.pb  model.json  tf_model_desc.json

另请参阅

IMPORT_MODELS

4.13.5.2 - GET_MODEL_ATTRIBUTE

从模型中提取某个特定属性或从模型中提取所有属性。使用此函数可查看属性列表和行数，或查看有关单个属性的详细信息。GET_MODEL_ATTRIBUTE 的输出是一种表格格式，用户可以在其中选择特定的列或行。

语法

GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name = 'model‑name' [, attr_name = 'attribute' ] )

参数

model_name

模型的名称（不区分大小写）。

attr_name
要提取的模型属性的名称。如果忽略，该函数将显示所有可用属性。属性名称区分大小写。

特权

非超级用户：模型所有者或模型的使用权限

示例

此示例返回所有模型属性的摘要。

=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel');
attr_name          |                attr_fields                        | #_of_rows
-------------------+---------------------------------------------------+-----------
details            | predictor, coefficient, std_err, t_value, p_value |         2
regularization     | type, lambda                                      |         1
iteration_count    | iteration_count                                   |         1
rejected_row_count | rejected_row_count                                |         1
accepted_row_count | accepted_row_count                                |         1
call_string        | call_string                                       |         1
(6 rows)

此示例从 myLinearRegModel 模型中提取 details 属性。

=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel', attr_name='details');
coeffNames |       coeff        |       stdErr        |      zValue       |        pValue
-----------+--------------------+---------------------+-------------------+-----------------------
Intercept  |  -1.87401598641074 |   0.160143331525544 | -11.7021169008952 |   7.3592939615234e-26
waiting    | 0.0756279479518627 | 0.00221854185633525 |  34.0890336307608 | 8.13028381124448e-100
(2 rows)

4.13.5.3 - GET_MODEL_SUMMARY

返回模型的摘要信息。

语法

GET_MODEL_SUMMARY ( USING PARAMETERS model_name = 'model‑name' )

参数

model_name

模型的名称（不区分大小写）。

特权

非超级用户：模型所有者或模型的使用权限

示例

此示例说明如何查看线性回归模型的摘要。

=> SELECT GET_MODEL_SUMMARY( USING PARAMETERS model_name='myLinearRegModel');

--------------------------------------------------------------------------------
=======
details
=======
predictor|coefficient|std_err |t_value |p_value
---------+-----------+--------+--------+--------
Intercept| -2.06795  | 0.21063|-9.81782| 0.00000
waiting  |  0.07876  | 0.00292|26.96925| 0.00000

==============
regularization
==============
type| lambda
----+--------
none| 1.00000

===========
call_string
===========
linear_reg('public.linear_reg_faithful', 'faithful_training', '"eruptions"', 'waiting'
USING PARAMETERS optimizer='bfgs', epsilon=1e-06, max_iterations=100,
regularization='none', lambda=1)

===============
Additional Info
===============
Name              |Value
------------------+-----
iteration_count   |  3
rejected_row_count|  0
accepted_row_count| 162
(1 row)

4.13.5.4 - IMPORT_MODELS

将以下模型导入 Vertica：通过 EXPORT_MODELS 导出的 Vertica 模型，或预测模型标记语言 (PMML) 或 TensorFlow 格式的模型。您可以使用此函数在 Vertica 群集之间移动模型，或导入在其他地方训练的 PMML 和 TensorFlow 模型。

GET_MODEL_SUMMARY 和 GET_MODEL_ATTRIBUTE 等其他 Vertica 模型管理操作支持导入的模型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

IMPORT_MODELS ( 'source'
           [ USING PARAMETERS [ new_schema = 'schema‑name' ] [, category = 'model-category' ] ] )

参数

源
导入模型的位置的绝对路径，为以下之一：

  • 单个模型的目录：

    path/model-directory

  • 多个模型目录的父目录：

    parent-dir-path/*

参数

new_schema
导入机器学习模型的现有架构。如果忽略，模型将被导入默认架构。

IMPORT_MODELS 从其 metadata.json 文件中提取导入模型的名称（如果存在）。否则，该函数使用模型目录的名称。

category
指定要导入的模型的类别，为以下之一：

  • VERTICA_MODELS

  • PMML

  • TENSORFLOW

如果模型目录没有 metadata.json 文件，则需要此参数。如果以下情况之一为 true，则 IMPORT_MODELS 返回错误：

  • 未指定类别且模型目录没有 metadata.json。

  • 指定的类别与模型类型不匹配。

特权

超级用户

要求和限制

以下要求和限制适用：

  • 如果您导出模型，然后再次导入，则导出和导入模型目录名称必须匹配。如果发生命名冲突，请使用 new_schema 参数将模型导入不同的架构，然后重命名该模型。

  • 机器学习配置参数 MaxModelSizeKB 设置可以导入 Vertica 的模型的最大大小。

  • 目前不支持某些 PMML 功能和属性。有关详细信息，请参阅PMML 特征和属性。

  • 如果您导入带有 metadata.json 和 crc.json 文件的 PMML 模型，则 CRC 文件必须包含元数据文件的 CRC 值。否则，导入操作会返回错误。

示例

将模型导入指定的架构：

在这两个示例中，都没有指定模型类别，因此 IMPORT_MODEL 使用模型的 metadata.json 文件来确定其类别：

  • 将单个模型 mykmeansmodel 导入到 newschema 架构中：

    => SELECT IMPORT_MODELS ('/home/dbadmin/myschema/mykmeansmodel' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)

  • 将 myschema 目录中的所有模型导入到 newschema 架构中：

    => SELECT IMPORT_MODELS ('/home/dbadmin/myschema/*' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)

指定要导入的模型类别：

在前两个示例中，IMPORT_MODELS 只有在指定的模型和类别匹配时才返回成功；否则，它会返回错误：

  • 导入 kmeans_pmml 作为 PMML 模型：

    SELECT IMPORT_MODELS ('/root/user/kmeans_pmml' USING PARAMETERS category='PMML')
 import_models
---------------
 Success
(1 row)

  • 导入 tf_mnist_estimator 作为 TensorFlow 模型：

    => SELECT IMPORT_MODELS ( '/path/tf_models/tf_mnist_estimator' USING PARAMETERS category='TENSORFLOW');
 import_models
---------------
 Success
(1 row)

  • 从指定目录导入所有 TensorFlow 模型：

    => SELECT IMPORT_MODELS ( '/path/tf_models/*' USING PARAMETERS category='TENSORFLOW');
 import_models
---------------
 Success
(1 row)

另请参阅

EXPORT_MODELS

4.13.5.5 - UPGRADE_MODEL

升级之前的 Vertica 版本中的模型。如果您运行 IMPORT_MODELS 函数，Vertica 会在数据库升级期间自动运行此函数。备份或还原后手动调用该函数升级模型。

如果 UPGRADE_MODEL 未能升级模型并且模型属于 VERTICA_MODELS 类别，则它不能用于数据库内评分，也不能作为 PMML 模型导出。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

UPGRADE_MODEL ( [ USING PARAMETERS [model_name = 'model‑name'] ] )

参数

model_name
要升级的模型的名称。如果您忽略此参数，Vertica 会升级您拥有权限的所有模型。

特权

非超级用户：仅升级用户拥有的模型。

示例

升级模型 myLogisticRegModel：

=> SELECT UPGRADE_MODEL( USING PARAMETERS model_name = 'myLogisticRegModel');
        UPGRADE_MODEL
----------------------------
 1 model(s) upgrade

(1 row)

升级用户拥有的所有模型：

=> SELECT UPGRADE_MODEL();
        UPGRADE_MODEL
----------------------------
 20 model(s) upgrade

(1 row)

4.14 - 管理函数

Vertica 具有管理数据库操作各个方面的函数，例如会话、权限、投影和编录。

4.14.1 - 编录函数

此部分包含特定于 Vertica 的编录管理函数。

4.14.1.1 - DROP_LICENSE

从全局编录中删除许可证密钥。删除过期的密钥是可选的。如果安装了有效的备用许可证密钥，Vertica 会自动忽略过期的许可证密钥。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_LICENSE( 'license-name' )

参数

license‑name
要删除的许可证的名称。使用系统表 LICENSES 的 NAME 列中的名称（或长许可证密钥）。

超级用户

示例

=> SELECT DROP_LICENSE('9b2d81e2-aab1-4cfb-bc07-fa9a696e8f5e');

另请参阅

管理许可证

4.14.1.2 - DUMP_CATALOG

返回 Vertica 编录的内部表示。此函数用于诊断目的。

DUMP_CATALOG 仅返回用户可见的对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_CATALOG()

特权

无

示例

以下查询获取 Vertica 编录的内部表示：

=> SELECT DUMP_CATALOG();

输出写入指定文件：

\o /tmp/catalog.txt
SELECT DUMP_CATALOG();
\o

4.14.1.3 - EXPORT_CATALOG

生成 SQL 脚本，从而在其他群集上重新创建物理架构设计。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

  • 如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_CATALOG ( [ '[destination]' [, 'scope'] ] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串，将脚本写入标准输出。

  • SQL 输出文件的路径和名称，仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
确定要导出的内容。在指定范围内，EXPORT_CATALOG 导出您有权访问的所有对象：

  • DESIGN：导出所有编录对象，包括架构、表、约束、视图、访问策略、投影、SQL 宏和存储过程。

  • DESIGN_ALL：已弃用。

  • TABLES：导出所有表及其访问策略。另请参阅 EXPORT_TABLES。

  • DIRECTED_QUERIES：导出所有存储在数据库中的定向查询。有关详细信息，请参阅管理定向查询。

默认值： DESIGN

特权

无

示例

请参阅导出编录。

另请参阅

4.14.1.4 - EXPORT_OBJECTS

生成一个 SQL 脚本，可用于在其他群集上重新创建非虚拟编录对象。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

  • 如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_OBJECTS( ['[destination]' [, '[scope]'] [, 'mark-ksafe']] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串 ('') 将脚本写入标准输出。

  • SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
指定要导出为逗号分隔列表的一个或多个对象： 
{ [database.]schema[.object] | [[database.]schema]object }[,...]

  • 如果设置为空字符串，Vertica 会导出用户有权访问的所有对象。

  • 如果您仅指定一个架构，Vertica 会导出该架构中的所有对象。

  • 如果指定一个数据库，它必须是当前数据库。

mark-ksafe
Boolean 实参，指定生成的脚本是否调用 Vertica 函数 MARK_DESIGN_KSAFE。如果设置为 true（默认），MARK_DESIGN_KSAFE 为当前数据库使用正确的 K-safe 实参。

特权

无

示例

请参阅导出对象。

另请参阅

4.14.1.5 - EXPORT_TABLES

生成一个 SQL 脚本，可用于在其他群集上重新创建逻辑架构—架构、表、约束和视图。EXPORT_TABLES 仅导出用户有权访问的对象。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果一个表引用了一个命名序列，则 CREATE SEQUENCE 语句在 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_TABLES( ['[destination]' [, '[scope]']] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串 ('') 将脚本写入标准输出。

  • SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
指定要导出的一个或多个表，如下所示： 
[database.]schema[.table][,...]
  • 如果设置为空字符串，Vertica 会导出您有权访问的所有非虚拟表对象，包括表架构、序列和约束。
  • 如果您指定架构，Vertica 会导出该架构中的所有非虚拟表对象。
  • 如果指定一个数据库，它必须是当前数据库。

特权

无

示例

请参阅导出表。

另请参阅

4.14.1.6 - INSTALL_LICENSE

在全局编录中安装许可证密钥。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INSTALL_LICENSE( 'filename' )

参数

filename
有效许可证文件的绝对路径名称。

超级用户

示例

=> SELECT INSTALL_LICENSE('/tmp/vlicense.dat');

另请参阅

管理许可证

4.14.1.7 - MARK_DESIGN_KSAFE

如果出现故障，在您的环境中启用或禁用高可用性。启用恢复以前， MARK_DESIGN_KSAFE 查询编录，确定群集物理模式设计是否满足下列要求：

  • 在所有节点上复制小的、未分段的表。

  • 大型表 超投影被分段，每个分段在不同的节点上。

  • 对于 K-safety=1，每个大型表投影至少有一个 伙伴实例投影（或者对于 K-safety=2，具有两个伙伴实例投影）。

    伙伴投影也在各数据库节点上进行分段，但对分配进行了修改，使包含相同数据的分段分配在不同节点上。请参阅使用投影的高可用性。

MARK_DESIGN_KSAFE 不改变物理架构。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MARK_DESIGN_KSAFE ( k )

参数

k
指定 K-safety 等级，是以下之一：

  • 2：如果架构设计满足 K-safety=2 的要求，则启用高可用性

  • 1：如果架构设计满足 K-safety=1 的要求，则启用高可用性

  • 0：禁用高可用性

超级用户

返回消息

如果您指定一个 1 或 2 的 k 值，Vertica 返回下列消息之一。

成功：

 Marked design n-safe

失败：

 The schema does not meet requirements for K=n.
 Fact table projection projection-name
 has insufficient "buddy" projections.

这里，n 是一个 K-safety 设置。

注意

  • 数据库内部恢复状态会在整个数据库启动过程中持续，但未在启动时检查。

  • 当标有 K-safe=1 的系统上的一个节点失败，其余节点仍可用于 DML 操作。

示例

=> SELECT MARK_DESIGN_KSAFE(1);
  mark_design_ksafe
----------------------
 Marked design 1-safe
(1 row)

如果物理模式设计不是 K-safe，消息显示不具有伙伴的投影：

=> SELECT MARK_DESIGN_KSAFE(1);
The given K value is not correct;
the schema is 0-safe
Projection pp1 has 0 buddies,
which is smaller that the given K of 1
Projection pp2 has 0 buddies,
which is smaller that the given K of 1
.
.
.
(1 row)

另请参阅

4.14.1.8 - RELOAD_ADMINTOOLS_CONF

更新群集中每个 UP 节点上的 admintools.conf。更新包括：

  • IP 地址和编录路径

  • 当前数据库中所有节点的节点名称

此函数提供了一种手动方法来指示服务器更新所有 UP 节点上的 admintools.conf。例如，如果您重启一个节点，调用此函数来确认它的 admintools.conf 文件是准确的。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELOAD_ADMINTOOLS_CONF()

特权

超级用户

示例

更新群集中每个 UP 节点上的 admintools.conf：

=> SELECT RELOAD_ADMINTOOLS_CONF();
  RELOAD_ADMINTOOLS_CONF
--------------------------
 admintools.conf reloaded
(1 row)

4.14.2 - 云函数

此部分包含管理云集成的函数。对于 HDFS，另请参阅 Hadoop 函数。

4.14.2.1 - AZURE_TOKEN_CACHE_CLEAR

清除 Azure 的缓存访问令牌。在更改 Azure 托管身份的配置后调用此函数。

Azure 对象存储可以支持和管理多个身份。如果正在使用多个身份，Vertica 会查找键为 VerticaManagedIdentityClientId 的 Azure 标记，其值必须是要使用的托管身份的 client_id 属性。如果 Azure 配置发生变化，请使用此函数清除缓存。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AZURE_TOKEN_CACHE_CLEAR ( )

超级用户

4.14.3 - 群集函数

此部分包含管理大型分布式数据库群集上的 spread 部署的函数以及控制群集如何组织数据以进行重新平衡的函数。

4.14.3.1 - CANCEL_REBALANCE_CLUSTER

停止任何正在进行中或正在等待执行的重新平衡任务。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_REBALANCE_CLUSTER()

超级用户

示例

=> SELECT CANCEL_REBALANCE_CLUSTER();
 CANCEL_REBALANCE_CLUSTER
--------------------------
 CANCELED
(1 row)

另请参阅

4.14.3.2 - DISABLE_LOCAL_SEGMENTS

禁用本地数据分段，本地数据分段会将节点上的投影分段拆分至可轻松移动到其他节点上的容器中。有关详细信息，请参阅局部数据分段。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISABLE_LOCAL_SEGMENTS()

超级用户

示例

=> SELECT DISABLE_LOCAL_SEGMENTS();
 DISABLE_LOCAL_SEGMENTS
------------------------
 DISABLED
(1 row)

4.14.3.3 - ENABLE_LOCAL_SEGMENTS

启用本地存储分段，本地存储分段可以将节点上的投影分段拆分到可以轻松移动至其他节点的容器中。有关详细信息，请参阅局部数据分段。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLE_LOCAL_SEGMENTS()

超级用户

示例

=> SELECT ENABLE_LOCAL_SEGMENTS();
 ENABLE_LOCAL_SEGMENTS
-----------------------
 ENABLED
(1 row)

4.14.3.4 - ENABLE_ELASTIC_CLUSTER

启用弹性群集调整，通过将一个节点的数据分段至可以轻松移动至其他主机的区块中，弹性群集调整可更为有效地扩大或缩小数据库群集的大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLE_ELASTIC_CLUSTER()

超级用户

示例

=> SELECT ENABLE_ELASTIC_CLUSTER();
 ENABLE_ELASTIC_CLUSTER
------------------------
 ENABLED
(1 row)

4.14.3.5 - REALIGN_CONTROL_NODES

启用大型群集时，使得 Vertica 重新评估群集或子群集中的哪些节点为 控制节点，以及哪些节点被分配给它们作为从属节点。在更改企业模式数据库中的故障组或更改任一数据库模式中的控制节点数后调用此函数。调用此函数后，查询 V_CATALOG.CLUSTER_LAYOUT 系统表以查看建议的群集中节点的新布局。在新的控制节点分配生效之前，您还必须采取其他步骤。有关详细信息，请参阅更改控制节点的数量并重新对齐。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

在 ** Enterprise 模式 下：**

REALIGN_CONTROL_NODES()

在 ** Eon 模式 下：**

REALIGN_CONTROL_NODES('subcluster_name')

参数

subcluster_name
要在其中重新调整控制节点的子群集的名称。只有该子群集中的节点受到影响。其他子群集不受影响。仅当数据库在 Eon 模式下运行时才允许。

特权

超级用户

示例

在 Enterprise 模式数据库中，从所有节点中选择控制节点，并将剩余节点分配给一个控制节点：

=> SELECT REALIGN_CONTROL_NODES();

在 Eon 模式数据库中，重新评估名为 analytics 的子群集中的控制节点分配：

=> SELECT REALIGN_CONTROL_NODES('analytics');

另请参阅

4.14.3.6 - REBALANCE_CLUSTER

一个会话前台任务，将同步重新平衡数据库群集。REBALANCE_CLUSTER 仅在重新平衡操作完成后返回。如果当前会话结束，则操作立即中止。要将群集重新平衡为后台任务，请调用 START_REBALANCE_CLUSTER()。

在大型群集排列中，您通常在流中调用 REBALANCE_CLUSTER（请参阅更改控制节点的数量并重新对齐）。在更改控制节点（spread 主机）的数量和分布后，运行 REBALANCE_CLUSTER 以实现容错。

有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_CLUSTER()

超级用户

示例

=> SELECT REBALANCE_CLUSTER();
REBALANCE_CLUSTER
-------------------
 REBALANCED
(1 row)

4.14.3.7 - RELOAD_SPREAD

更新对编录的 Spread 配置文件的群集更改。这些更改包括：

  • 新的或重新调整的控制节点

  • 新的 Spread 主机或容错组

  • 新的或删除的群集节点

此函数通常在多步进程中用于较大的弹性群集排列。调用此函数可能需要您重新启动数据库。然后，您必须重新平衡群集以实现容错。有关详细信息，请参阅定义和重新调整控制节点。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELOAD_SPREAD( true )

参数

true
将与控制消息责任相关的群集更改更新到 Spread 配置文件。

特权

超级用户

示例

使用更改来更新群集以控制消息传送：

=> SELECT reload_spread(true);
 reload_spread
---------------
 reloaded

(1 row)

另请参阅

REBALANCE_CLUSTER

4.14.3.8 - SET_CONTROL_SET_SIZE

设置启用大型群集时参与 spread 服务的 控制节点数。如果数据库在 Enterprise 模式下运行，该函数设置整个数据库群集的控制节点数。如果数据库在 Eon 模式下运行，则此函数设置您指定的子群集中的控制节点数。有关详细信息，请参阅大型群集。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

在 Enterprise 模式下：

SET_CONTROL_SET_SIZE( control_nodes )

在 Eon 模式下：

SET_CONTROL_SET_SIZE('subcluster_name', control_nodes )

参数

subcluster_name
要在其中设置控制节点数的子群集的名称。仅当数据库在 Eon 模式下运行时才允许。
control_nodes
分配给群集（在 Enterprise 模式下）或子群集（在 Eon 模式下）的控制节点数。值可以是以下之一：

  • 正整数值：Vertica 将您指定的控制节点数分配给群集或子群集。该值可以大于当前节点数。该值不能大于 120（数据库的最大控制节点数）。在 Eon 模式下，该值加上为所有其他子群集设置的控制节点数的总和不能超过 120。

  • -1：使群集或子群集中的每个节点都成为控制节点。该值可有效禁用群集或子群集的大型群集。

特权

超级用户

示例

在 Enterprise 模式数据库中，将整个群集的控制节点数设置为 5：

=> SELECT set_control_set_size(5);
 SET_CONTROL_SET_SIZE
----------------------
 Control size set
(1 row)

另请参阅

4.14.3.9 - SET_SCALING_FACTOR

设置比例因子，比例因子决定在重新平衡数据库和启用了使用局部数据分段时，所使用的存储容器数量。有关详细信息，请参阅群集扩展。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_SCALING_FACTOR( factor )

参数

factor
1 至 32 之间的整数值。Vertica 使用此值来计算进行重新平衡或启用了局部数据分段时，每个投影分解到多少个存储容器中。

超级用户

最佳实践

比例因子决定了在启用局部分段时，Vertica 在重新平衡期间用于跨数据库存储每个投影的存储容器的数量。在设置比例因子时，请遵循以下准则：

  • 存储容器的数量应大于或等于分区数量与本地分段数量的积：

    num‑storage‑containers >= ( num‑partitions * num‑local‑segments )

  • 若将比例因子设置得足够高，以便重新平衡可以传输本地分段以满足偏移阈值，但将值设置得很小，以便存储容器数量将不会产生过多的 ROS 容器，并导致 ROS 推回）。ROS 容器的最大数量（默认为 1024）由配置参数 ContainersPerProjectionLimit 设置。

示例

=> SELECT SET_SCALING_FACTOR(12);
 SET_SCALING_FACTOR
--------------------
 SET
(1 row)

4.14.3.10 - START_REBALANCE_CLUSTER()

一个后台任务，异步重新平衡数据库群集。此函数在重新平衡操作完成后立即返回。即使您关闭当前会话或数据库关闭，重新平衡也会持续到操作完成。在关闭的情况下，重新平衡会在群集重新启动后恢复。要停止重新平衡操作，请调用 CANCEL_REBALANCE_CLUSTER。

有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REBALANCE_CLUSTER()

超级用户

示例

=> SELECT START_REBALANCE_CLUSTER();
 START_REBALANCE_CLUSTER
-------------------------
 REBALANCING
(1 row)

另请参阅

REBALANCE_CLUSTER

4.14.4 - 数据收集器函数

Vertica 数据收集器是一款实用程序，通过提供记录事件的框架来扩展系统表的功能。该实用程序收集并保留有关数据库群集的监控信息，同时在系统表中提供这些信息，需要的配置参数调整很少，对性能的影响微乎其微。

收集的数据存储在磁盘 Vertica/catalog 路径下的 DataCollector 目录中。可使用数据收集器所保留的信息查询系统表的过去状态并提取聚合信息，还可以执行以下操作：

  • 查看用户已采取哪些操作

  • 找出性能瓶颈

  • 确定 Vertica 配置的潜在改进

数据收集器与名为工作负载分析器的顾问工具搭配使用，后者可以智能监控 SQL 查询和工作负载的性能，并通过观察实际工作负载的历史记录来建议优化操作。

默认情况下，数据收集器处于开启状态并保留所有会话的信息。如果出现性能问题，超级用户可以通过将设置配置参数 EnableDataCollector 设置为 0 来禁用数据收集器。

4.14.4.1 - CLEAR_DATA_COLLECTOR

从数据收集器表和日志中清除所有内存及磁盘记录，并重置系统表 DATA_COLLECTOR 中的收集统计信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DATA_COLLECTOR( [ 'component' ] )

参数

component
清除指定组件的内存和磁盘记录。如果您未提供实参，则该函数将清除所有组件的内存和磁盘记录。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

超级用户

示例

以下命令将清除 ResourceAcquisitions 组件的内存和磁盘记录：

=> SELECT clear_data_collector('ResourceAcquisitions');
 clear_data_collector
----------------------
 CLEAR
(1 row)

以下命令将清除所有组件的数据收集：

=> SELECT clear_data_collector();
 clear_data_collector
----------------------
 CLEAR
(1 row)

另请参阅

数据收集器实用程序

4.14.4.2 - DATA_COLLECTOR_HELP

返回有关数据收集器、 DATA_COLLECTOR 系统表和数据收集器控制函数的在线使用说明。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DATA_COLLECTOR_HELP()

特权

无

返回

DATA_COLLECTOR_HELP() 函数将返回以下信息：

=> SELECT DATA_COLLECTOR_HELP();

-----------------------------------------------------------------------------
Usage Data Collector
The data collector retains history of important system activities.
   This data can be used as a reference of what actions have been taken
      by users, but it can also be used to locate performance bottlenecks,
      or identify potential improvements to the Vertica configuration.
   This data is queryable via Vertica system tables.

Acccess a list of data collector components, and some statistics, by running:
   SELECT * FROM v_monitor.data_collector;

The amount of data retained by size and time can be controlled with several
functions.
   To just set the size amount:
      set_data_collector_policy(<component>,
                                <memory retention (KB)>,
                                <disk retention (KB)>);

   To set both the size and time amounts (the smaller one will dominate):
      set_data_collector_policy(<component>,
                                <memory retention (KB)>,
                                <disk retention (KB)>,
                                <interval>);

   To set just the time amount:
      set_data_collector_time_policy(<component>,
                                     <interval>);

   To set the time amount for all tables:
      set_data_collector_time_policy(<interval>);

The current retention policy for a component can be queried with:
   get_data_collector_policy(<component>);

Data on disk is kept in the "DataCollector" directory under the Vertica
\catalog path. This directory also contains instructions on how to load
the monitoring data into another Vertica database.

To move the data collector logs and instructions to other storage locations,
create labeled storage locations using add_location and then use:

   set_data_collector_storage_location(<storage_label>);

Additional commands can be used to configure the data collection logs.

The log can be cleared with:

clear_data_collector([<optional component>]);

The log can be synchronized with the disk storage using:

flush_data_collector([<optional component>]);

另请参阅

4.14.4.3 - FLUSH_DATA_COLLECTOR

等待内存日志移至磁盘后，刷新数据收集器，同时将日志与磁盘存储同步。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FLUSH_DATA_COLLECTOR( [ 'component' ] )

参数

component
刷新指定组件的数据。如果忽略此实参，则函数将刷新所有组件的数据。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

超级用户

示例

以下命令刷新 ResourceAcquisitions 组件的数据收集器。

=> SELECT flush_data_collector('ResourceAcquisitions');
 flush_data_collector
----------------------
 FLUSH
(1 row)

以下命令刷新所有组件的数据收集器。

=> SELECT flush_data_collector();
 flush_data_collector
----------------------
 FLUSH
(1 row)

另请参阅

数据收集器实用程序

4.14.4.4 - GET_DATA_COLLECTOR_POLICY

检索与指定组件的保留政策有关的简短声明。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_DATA_COLLECTOR_POLICY( 'component' )

参数

component
返回指定组件的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

特权

无

示例

以下查询通过指定 ResourceAcquisitions 组件返回所有资源获取的历史记录。

=> SELECT get_data_collector_policy('ResourceAcquisitions');
          get_data_collector_policy
----------------------------------------------
 1000KB kept in memory, 10000KB kept on disk.
(1 row)

另请参阅

4.14.4.5 - SET_DATA_COLLECTOR_POLICY

更新指定组件的以下保留策略属性：

  • MEMORY_BUFFER_SIZE_KB

  • DISK_SIZE_KB

  • INTERVAL_TIME

在更改保留策略之前，可通过查询系统表 DATA_COLLECTOR 或调用元函数 GET_DATA_COLLECTOR_POLICY 查看其当前设置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_POLICY('component', 'memory‑buffer‑size', 'disk‑size' [,'interval‑time']  )

参数

component
指定要更新的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
memory‑buffer‑size
指定在将数据移动到磁盘之前在内存中缓冲的最大数据量（以 KB 为单位）。策略保留策略属性 MEMORY_BUFFER_SIZE_KB 根据此值进行设置。

在以下情况下，请考虑将此参数设置为较高的值：

  • 异常高级别的数据收集。如果将 memory‑buffer‑size 设置为过低的值，数据收集器可能无法以足够快的速度将缓冲数据刷新到磁盘以与活动级别保持一致，这可能会导致内存中的数据丢失。

  • 非常大的数据收集器记录 — 例如，具有非常长的查询字符串的记录。数据收集器使用双缓冲，因此它无法在内存中保留比 memory‑buffer‑size 大 50% 以上的记录。

disk‑size
指定为此组件的数据收集器表分配的最大磁盘空间（以 KB 为单位）。策略保留策略属性 DISK_SIZE_KB 根据此值进行设置。如果设置为 0，数据收集器将仅保留其可以在内存中缓冲的组件数据，大小由 memory‑buffer‑size 指定。
interval‑time

INTERVAL 一种数据类型，用于指定给定组件的数据在该组件的数据收集器表中保留的时间。保留策略属性 INTERVAL_TIME 是根据该值设置的。如果将此参数设置为正值，它还会将策略属性 INTERVAL_SET 更改为 t (true)。

例如，如果指定组件 TupleMoverEvents 并将 interval-time 设置为两天的时间间隔 ('2 days'::interval)，则数据收集器 dc_tuple_mover_events 会保留过去 48 小时的 Tuple Mover 活动记录。旧 Tuple Mover 数据会自动从该表中删除。

要禁用 INTERVAL_TIME 策略属性，请将此参数设置为负整数。这样做会将两个保留策略属性恢复为其默认设置：

  • INTERVAL_SET：f

  • INTERVAL_TIME：0

如此设置这两个属性后，组件的数据收集器表将保留所有组件事件的数据，直到达到其最大限制，如保留策略属性 DISK_SIZE_KB 设置的那样。

超级用户

示例

请参阅配置数据保留策略。

4.14.4.6 - SET_DATA_COLLECTOR_TIME_POLICY

更新指定组件的保留策略属性 INTERVAL_TIME。调用此函数不会影响同一组件的其他属性。您可以使用此函数更新所有组件保留策略的 INTERVAL_TIME 属性。

要设置其他保留策略属性，请调用 SET_DATA_COLLECTOR_POLICY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_TIME_POLICY( ['component',] 'interval‑time' )

参数

component
指定要更新的保留策略。如果忽略此实参，Vertica 会更新所有数据收集器组件的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
interval‑time

INTERVAL 一种数据类型，用于指定给定组件的数据在该组件的数据收集器表中保留的时间。保留策略属性 INTERVAL_TIME 是根据该值设置的。如果将此参数设置为正值，它还会将策略属性 INTERVAL_SET 更改为 t (true)。

例如，如果指定组件 TupleMoverEvents 并将 interval-time 设置为两天的时间间隔 ('2 days'::interval)，则数据收集器 dc_tuple_mover_events 会保留过去 48 小时的 Tuple Mover 活动记录。旧 Tuple Mover 数据会自动从该表中删除。

要禁用 INTERVAL_TIME 策略属性，请将此参数设置为负整数。这样做会将两个保留策略属性恢复为其默认设置：

  • INTERVAL_SET：f

  • INTERVAL_TIME：0

如此设置这两个属性后，组件的数据收集器表将保留所有组件事件的数据，直到达到其最大限制，如保留策略属性 DISK_SIZE_KB 设置的那样。

超级用户

示例

请参阅配置数据保留策略。

4.14.5 - 数据库函数

此部分包含特定于 Vertica 的数据库管理函数。

4.14.5.1 - CLEAR_RESOURCE_REJECTIONS

清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容。通常，只能在节点重新启动期间清除这些表。通过此函数，您可以在需要时随时清除这些表。例如，您可能想在解决导致磁盘资源拒绝的磁盘空间问题后清除系统表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

不可变

语法

CLEAR_RESOURCE_REJECTIONS();

超级用户

示例

以下命令可以清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容：

=> SELECT clear_resource_rejections();
clear_resource_rejections
---------------------------
 OK
(1 row)

另请参阅

4.14.5.2 - COMPACT_STORAGE

将现有数据 (.fdb) 和索引 (.pidx) 文件捆绑为 .gt 文件格式。默认情况下，为使用 7.2 或更高版本创建的数据文件启用 .gt 格式。如果要升级早期版本的数据库，请使用 COMPACT_STORAGE 将存储文件捆绑为 .gt 格式。您的数据库可以继续以混合文件存储格式运行。

如果为 COMPACT_STORAGE 指定的设置与在配置参数 MaxBundleableROSSizeKB 中指定的限值不同，则 Vertica 不会更改自动创建的捆绑包的大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT COMPACT_STORAGE ('[[[database.]schema.]object‑name]', min‑ros‑filesize‑kb, 'small‑or‑all‑files', 'simulate');

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

object‑name
指定要捆绑的表或投影。如果设置为空字符串，COMPACT_STORAGE 将评估数据库中所有投影的数据以进行捆绑。
min‑ros‑filesize‑kb
整数 ≥ 1，指定独立 ROS 文件的最小大小（以 KB 为单位）。COMPACT_STORAGE 可将低于此大小的存储容器 ROS 文件捆绑成一个文件。
small‑or‑all‑files
以下几项之一：

  • small：仅捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件

  • all：捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件，并捆绑大型存储容器的 .fdb 和 .pidx 文件。

simulate
指定是否模拟存储设置并生成描述这些设置的影响的报告。

  • true：生成有关指定捆绑包设置（未实际捆绑存储文件）的影响的报告。

  • false：按指定执行捆绑。

特权

超级用户

存储和性能影响

捆绑可使文件系统中的文件数至少减少 50%，并提高文件密集型操作的性能。增强的操作包括备份、还原以及合并。

Vertica 创建小文件的原因包括以下几点：

  • 表包含数百列。

  • 分区范围较小（按分钟分区）。

  • 启用了局部分段且系数设置为较高的值。

示例

以下示例描述了捆绑表 EMPLOYEES 的影响：

=> SELECT COMPACT_STORAGE('employees', 1024,'small','true');
Task: compact_storage

On node v_vmart_node0001:
Projection Name :public.employees_b0 | selected_storage_containers :0 |
selected_files_to_compact :0 | files_after_compact : 0 | modified_storage_KB :0

On node v_vmart_node0002:
Projection Name :public.employees_b0 | selected_storage_containers :1 |
selected_files_to_compact :6 | files_after_compact : 1 | modified_storage_KB :0

On node v_vmart_node0003:
Projection Name :public.employees_b0 | selected_storage_containers :2 |
selected_files_to_compact :12 | files_after_compact : 2 | modified_storage_KB :0

On node v_vmart_node0001:
Projection Name :public.employees_b1 | selected_storage_containers :2 |
selected_files_to_compact :12 | files_after_compact : 2 | modified_storage_KB :0

On node v_vmart_node0002:
Projection Name :public.employees_b1 | selected_storage_containers :0 |
selected_files_to_compact :0 | files_after_compact : 0 | modified_storage_KB :0

On node v_vmart_node0003:
Projection Name :public.employees_b1 | selected_storage_containers :1 |
selected_files_to_compact :6 | files_after_compact : 1 | modified_storage_KB :0

Success

(1 row)

4.14.5.3 - DUMP_LOCKTABLE

返回关于死锁的客户端及其等待的资源的信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_LOCKTABLE()

特权

无

注意

如果 Vertica 失去响应，请使用 DUMP_LOCKTABLE：

  1. 打开其他 vsql 连接。

  2. 执行查询：

    => SELECT DUMP_LOCKTABLE();

    输出被写入到 vsql。请参阅监控日志文件。

您还可以使用以下命令查看连接方：

=> SELECT * FROM SESSIONS;

使用以下命令关闭所有会话：

=> SELECT CLOSE_ALL_SESSIONS();

使用以下命令关闭单个会话：

=> SELECT CLOSE_SESSION('session_id');

您可以从 V_MONITOR.SESSIONS 系统表中获取到 session_id 值。

另请参阅

4.14.5.4 - DUMP_PARTITION_KEYS

转储系统中所有投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_PARTITION_KEYS( )

特权

用户必须具有表的选择权限或架构的使用权限。

示例

=> SELECT DUMP_PARTITION_KEYS( );
Partition keys on node v_vmart_node0001
  Projection 'states_b0'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: NH
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: MA
  Projection 'states_b1'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: VT
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: ME
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: CT

另请参阅

4.14.5.5 - GET_CONFIG_PARAMETER

获取指定级别的配置参数的值。如果在该级别未设置任何值，此函数将返回一个空行。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_CONFIG_PARAMETER( 'parameter-name' [, 'level' | NULL] )

参数

parameter‑name
要获取的配置参数值的名称。
级别
要获取的 parameter‑name 设置的级别，为以下字符串值之一：

  • user：当前用户

  • session：当前会话

  • node-name：数据库节点的名称

如果 level 被忽略或设置为 NULL，则 GET_CONFIG_PARAMETER 将返回数据库设置。

特权

无

示例

获取数据库级别的 AnalyzeRowCountInterval 参数：

=> SELECT GET_CONFIG_PARAMETER ('AnalyzeRowCountInterval');
 GET_CONFIG_PARAMETER
----------------------
 3600

获取会话级别的 MaxSessionUDParameterSize 参数：

=> SELECT GET_CONFIG_PARAMETER ('MaxSessionUDParameterSize','session');
 GET_CONFIG_PARAMETER
----------------------
 2000
(1 row)

获取用户级别的 UseDepotForReads 参数：

=> SELECT GET_CONFIG_PARAMETER ('UseDepotForReads', 'user');
 GET_CONFIG_PARAMETER
----------------------
 1
(1 row)

另请参阅

4.14.5.6 - KERBEROS_CONFIG_CHECK

测试 Vertica 群集的 Kerberos 配置。如果此函数可以同时使用 keytab 文件和当前用户的凭据调用 kinit，则此函数将成功，否则将报告错误。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

KERBEROS_CONFIG_CHECK( )

参数

此函数没有参数。

特权

此函数不需要权限。

示例

以下示例显示了 Kerberos 配置有效时的结果。

=> SELECT KERBEROS_CONFIG_CHECK();
    kerberos_config_check
-----------------------------------------------------------------------------
 ok: krb5 exists at [/etc/krb5.conf]
 ok: Vertica Keytab file is set to [/etc/vertica.keytab]
 ok: Vertica Keytab file exists at [/etc/vertica.keytab]
[INFO] KerberosCredentialCache [/tmp/vertica_D4/vertica450676899262134963.cc]
 Kerberos configuration parameters set in the database
        KerberosServiceName : [vertica]
        KerberosHostname : [data.hadoop.com]
        KerberosRealm : [EXAMPLE.COM]
        KerberosKeytabFile : [/etc/vertica.keytab]
 Vertica Principal: [vertica/data.hadoop.com@EXAMPLE.COM]
 [OK] Vertica can kinit using keytab file
 [OK] User [bob] has valid client authentication for kerberos principal [bob@EXAMPLE.COM]]

(1 row)

4.14.5.7 - MEMORY_TRIM

调用 glibc 函数 malloc_trim()，以从 malloc 中回收可用内存并将其返回给操作系统。删除操作的详细信息将被写入系统表 MEMORY_EVENTS。

除非关闭内存轮询，否则 Vertica 会自动检测 glibc 在其分配区域中积累过量可用内存的情况。发生这种情况时，Vertica 会整合大部分内存并将其返回给操作系统。如果禁用内存轮询并希望手动减少 glibc 分配的内存，请调用此函数。

有关详细信息，请参阅内存修剪。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MEMORY_TRIM()

特权

超级用户

示例

=> SELECT memory_trim();
                           memory_trim
-----------------------------------------------------------------
 Pre-RSS: [378822656] Post-RSS: [372129792] Benefit: [0.0176675]
(1 row)

4.14.5.8 - RUN_INDEX_TOOL

在 Vertica 数据库上运行索引工具以执行以下任务之一：

  • 对数据存储运行每块循环冗余检查 (CRC)，以验证数据完整性。

  • 检查 ROS 容器中的排列顺序是否正确。

此函数会将有关其操作的摘要信息写入标准输出；将结果的详细信息记录在当前节点的 vertica.log 中。有关评估工具输出的详细信息，请参阅：

您还可以通过 Linux 命令行对已关闭的数据库运行索引工具。有关详细信息，请参阅CRC 和排序顺序检查。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RUN_INDEX_TOOL ( 'taskType', global, '[projFilter]' [, numThreads ] );

参数

taskType
指定要运行的操作，为以下之一：

  • checkcrc：对现有数据存储上的每个块运行循环冗余检查 (CRC)，以检查 ROS 数据块的数据完整性。

  • checksort：评估每个 ROS 行，以确定其排序是否正确。如果 ROS 数据未按投影的顺序正确排序，则依赖于已排序数据的查询结果就会不正确。

global
布尔值，指定在所有节点 (true) 还是当前节点 (false) 上运行指定任务。
projFilter
指定操作的范围：

  • 空字符串 ('')：对所有投影运行检查。

  • 一个字符串，指定一个或多个投影，如下所示：

    • projection‑name：对此投影运行检查

    • projection‑prefix*：对所有以字符串 projection‑prefix 开头的投影运行检查。

numThreads
一个无符号（正）或带符号（负）整数，指定用于运行此操作的线程数：

  • n：线程数，≥1

  • -n：负整数，表示所有 CPU 内核的一部分，如下所示：

    num‑cores / n

    因此，-1 表示所有内核，-2 表示一半内核，-3 表示所有内核的三分之一，依此类推。

    默认值： 1

特权

超级用户

优化性能

您可以通过设置以下两个参数来优化元函数性能：

  • projFilter：将操作范围缩小到一个或多个投影。

  • numThreads：指定用于执行函数的线程数。

4.14.5.9 - PURGE

从 ROS 存储容器中永久移除删除向量，以便可以重新使用磁盘空间。 PURGE 移除 Ancient History Mark 时期（含）之前的所有历史数据。

PURGE 不会删除临时表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT PURGE()

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

从 Vertica 表中删除数据后，该数据将被标记为删除。要查看标记为待删除的数据，请查询 DELETE_VECTORS 系统表。

运行 PURGE 以从 ROS 容器中移除删除向量。

=> SELECT * FROM test1;
 number
--------
      3
     12
     33
     87
     43
     99
(6 rows)

=> DELETE FROM test1 WHERE number > 50;
 OUTPUT
--------
      2
(1 row)

=> SELECT * FROM test1;
 number
--------
     43
      3
     12
     33
(4 rows)
=> SELECT node_name, projection_name, deleted_row_count FROM DELETE_VECTORS;
    node_name     | projection_name | deleted_row_count
------------------+-----------------+-------------------
 v_vmart_node0002 | test1_b1        |                 1
 v_vmart_node0001 | test1_b1        |                 1
 v_vmart_node0001 | test1_b0        |                 1
 v_vmart_node0003 | test1_b0        |                 1
(4 rows)

=> SELECT PURGE();
...
(Table: public.test1) (Projection: public.test1_b0)
(Table: public.test1) (Projection: public.test1_b1)
...
(4 rows)

Ancient History Mark (AHM) 推进后：

=> SELECT * FROM DELETE_VECTORS;
 (No rows)

另请参阅

4.14.5.10 - SECURITY_CONFIG_CHECK

返回各种安全相关参数的状态。使用此函数可验证您的 TLS 配置的完整性。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SECURITY_CONFIG_CHECK( 'db-component' )

参数

db-component
要检查的组件。目前，NETWORK 是唯一受支持的组件。

NETWORK：返回 spread 加密、节点间 TLS 和客户端-服务器 TLS 的状态和参数。

示例

在此示例中，SECURITY_CONFIG_CHECK 显示已禁用 spread 加密和数据通道 TLS，因为 EncryptSpreadComm 已禁用且未配置 data_channel TLS CONFIGURATION。

同样，客户端-服务器 TLS 也被禁用，因为 TLS CONFIGURATION“服务器”具有服务器证书，但其 TLSMODE 被禁用。将 TLSMODE 设置为“Enable”可启用服务器模式客户端-服务器 TLS。有关详细信息，请参阅TLS 协议。

=> SELECT SECURITY_CONFIG_CHECK('NETWORK');
                                            SECURITY_CONFIG_CHECK
----------------------------------------------------------------------------------------------------------------------
Spread security details:
* EncryptSpreadComm = []
Spread encryption is disabled
It is NOT safe to set/change other security config parameters while spread is not encrypted!
Please set EncryptSpreadComm to enable spread encryption first

Data Channel security details:
 TLS Configuration 'data_channel' TLSMODE is DISABLE
TLS on the data channel is disabled
Please set EncryptSpreadComm and configure TLS Configuration 'data_channel' to enable TLS on the data channel

Client-Server network security details:
* TLS Configuration 'server' TLSMODE is DISABLE
* TLS Configuration 'server' has a certificate set
Client-Server TLS is disabled
To enable Client-Server TLS set a certificate on TLS Configuration 'server' and/or set the tlsmode to 'ENABLE' or higher

(1 row)

另请参阅

4.14.5.11 - SET_CONFIG_PARAMETER

在指定级别设置或清除配置参数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_CONFIG_PARAMETER( 'param‑name', { param‑value | NULL}, ['level'| NULL])

参数

param‑name
要设置的配置参数的名称。
param‑value
要为 param‑name 设置的值，可以是字符串，也可以是整数。如果是字符串，则用单引号括起来；如果是整数，则单引号是可选的。

要在指定级别清除 param‑name，请将其设置为 NULL。

级别
要设置 param‑name 的级别，为以下字符串值之一：

  • user：当前用户。

  • session：当前会话，将覆盖数据库设置。

  • node-name：数据库节点的名称，将覆盖会话和数据库设置。

如果 level 被忽略或设置为 NULL，则会在数据库级别设置 param‑name。

特权

超级用户

示例

在数据库级别将 AnalyzeRowCountInterval 参数设置为 3600：

=> SELECT SET_CONFIG_PARAMETER('AnalyzeRowCountInterval',3600);
    SET_CONFIG_PARAMETER
----------------------------
 Parameter set successfully
(1 row)

在会话级别将 MaxSessionUDParameterSize 参数设置为 2000。

=> SELECT SET_CONFIG_PARAMETER('MaxSessionUDParameterSize',2000,'SESSION');
    SET_CONFIG_PARAMETER
----------------------------
 Parameter set successfully
(1 row)

另请参阅

4.14.5.12 - SET_SPREAD_OPTION

更改 spread 守护程序设置。此函数主要用于设置 spread 假设节点出现故障之前的超时。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_SPREAD_OPTION( option‑name, option‑value )

参数

option‑name
包含要更改的 spread 守护程序设置的字符串。

目前，此函数仅支持一个选项： TokenTimeout. 此设置控制 spread 在假设消息丢失之前等待节点响应消息的时间。有关详细信息，请参阅调整虚拟环境的 Spread 守护程序超时。

option‑value
option‑name 的新设置。

示例

=> SELECT SET_SPREAD_OPTION( 'TokenTimeout', '35000');
NOTICE 9003:  Spread has been notified about the change
                   SET_SPREAD_OPTION
--------------------------------------------------------
 Spread option 'TokenTimeout' has been set to '35000'.

(1 row)

=> SELECT * FROM V_MONITOR.SPREAD_STATE;
    node_name     | token_timeout
------------------+---------------
 v_vmart_node0001 |         35000
 v_vmart_node0002 |         35000
 v_vmart_node0003 |         35000
(3 rows);

另请参阅

4.14.5.13 - SHUTDOWN

关闭 Vertica 数据库。默认情况下，如果有任何用户连接，则关闭失败。您可以在 vertica.log 文件中查看关闭操作的状态。

在 Eon 模式下，您可以调用 SHUTDOWN_WITH_DRAIN 来执行优雅关闭，此操作会排空客户端连接，然后关闭数据库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN ( [ 'false' | 'true' ] )

参数

false
默认，如果用户已连接并中止关闭，则返回消息。
true
强制数据库关闭，以禁用其他连接。

超级用户

示例

以下命令尝试关闭数据库。由于用户已连接，命令失败：

=> SELECT SHUTDOWN('false');
NOTICE:  Cannot shut down while users are connected
          SHUTDOWN
-----------------------------
 Shutdown: aborting shutdown
(1 row)

另请参阅

SESSIONS

4.14.6 - Eon 模式函数

以下函数适用于 Eon 模式。

4.14.6.1 - ALTER_LOCATION_SIZE

仅限 Eon 模式

调整子群集中一个节点或所有节点或者数据库中所有节点的 存储库大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

不可变

语法

ALTER_LOCATION_SIZE( 'location', '[target]', 'size')

参数

location
指定要调整大小的位置，为以下之一：

  • depot：调整节点当前存储库的大小。

  • 存储库在 Linux 文件系统中的绝对路径。如果更改多个节点上的存储库大小并指定路径，则所有受影响节点上的路径必须相同。默认情况下，并非如此，因为节点的名称通常是此路径。例如，verticadb 数据库中节点 1 的默认存储库路径为 /vertica/data/verticadb/v_verticadb_node0001_depot。

目标值
要更改存储库的一个或多个节点，为以下之一：

  • 节点名称：调整指定节点的大小。

  • 子群集名称：调整指定子群集中所有节点的存储库大小。

  • 空字符串：调整数据库中所有存储库的大小。

size

仅当存储位置使用类型设置为 DEPOT 时才有效，指定存储库可以从存储位置的文件系统中分配的最大磁盘空间量。

您可以通过两种方式指定 size：

  • integer%：存储位置的磁盘大小所占的百分比。

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的存储位置的磁盘大小。

特权

超级用户

示例

将所有节点的存储库大小增加到文件系统的 80%：

=> SELECT node_name, location_label, location_path, max_size, disk_percent FROM storage_locations WHERE location_usage = 'DEPOT' ORDER BY node_name;
    node_name     | location_label  |      location_path      |  max_size   | disk_percent
------------------+-----------------+-------------------------+-------------+--------------
 v_vmart_node0001 | auto-data-depot | /home/dbadmin/verticadb | 36060108800 | 70%
 v_vmart_node0002 | auto-data-depot | /home/dbadmin/verticadb | 36059377664 | 70%
 v_vmart_node0003 | auto-data-depot | /home/dbadmin/verticadb | 36060108800 | 70%
(3 rows)

=> SELECT alter_location_size('depot', '','80%');
 alter_location_size
---------------------
 depotSize changed.
(1 row)

=> SELECT node_name, location_label, location_path, max_size, disk_percent FROM storage_locations WHERE location_usage = 'DEPOT' ORDER BY node_name;
    node_name     | location_label  |      location_path      |  max_size   | disk_percent
------------------+-----------------+-------------------------+-------------+--------------
 v_vmart_node0001 | auto-data-depot | /home/dbadmin/verticadb | 41211552768 | 80%
 v_vmart_node0002 | auto-data-depot | /home/dbadmin/verticadb | 41210717184 | 80%
 v_vmart_node0003 | auto-data-depot | /home/dbadmin/verticadb | 41211552768 | 80%
(3 rows)

将 analytics 子群集中所有节点的存储库大小更改为文件系统大小的 75%：

=> SELECT subcluster_name, subclusters.node_name, storage_locations.max_size, storage_locations.disk_percent FROM subclusters INNER JOIN storage_locations ON subclusters.node_name = storage_locations.node_name WHERE storage_locations.location_usage='DEPOT';
  subcluster_name   |      node_name       |   max_size  | disk_percent
--------------------+----------------------+----------------------------
 default_subcluster | v_verticadb_node0001 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0002 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0003 | 25264737485 | 60%
 analytics          | v_verticadb_node0004 | 25264737485 | 60%
 analytics          | v_verticadb_node0005 | 25264737485 | 60%
 analytics          | v_verticadb_node0006 | 25264737485 | 60%
 analytics          | v_verticadb_node0007 | 25264737485 | 60%
 analytics          | v_verticadb_node0008 | 25264737485 | 60%
 analytics          | v_verticadb_node0009 | 25264737485 | 60%
(9 rows)

=> SELECT ALTER_LOCATION_SIZE('depot','analytics','75%');
 ALTER_LOCATION_SIZE
---------------------
 depotSize changed.
(1 row)

=> SELECT subcluster_name, subclusters.node_name, storage_locations.max_size, storage_locations.disk_percent FROM subclusters INNER JOIN storage_locations ON subclusters.node_name = storage_locations.node_name WHERE storage_locations.location_usage='DEPOT';
  subcluster_name   |      node_name       |   max_size  | disk_percent
--------------------+----------------------+----------------------------
 default_subcluster | v_verticadb_node0001 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0002 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0003 | 25264737485 | 60%
 analytics          | v_verticadb_node0004 | 31580921856 | 75%
 analytics          | v_verticadb_node0005 | 31580921856 | 75%
 analytics          | v_verticadb_node0006 | 31580921856 | 75%
 analytics          | v_verticadb_node0007 | 31580921856 | 75%
 analytics          | v_verticadb_node0008 | 31580921856 | 75%
 analytics          | v_verticadb_node0009 | 31580921856 | 75%
(9 rows)

另请参阅

Eon 模式体系结构

4.14.6.2 - BACKGROUND_DEPOT_WARMING

仅限 Eon 模式

强制正在预热其存储库的节点开始处理查询，同时继续在后台预热其存储库。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。此函数仅在以下情况下有效：

  • 数据库在 Eon 模式下运行。

  • 节点当前正在预热其存储库。

  • 该节点正在从公共存储中预热其存储库。当 UseCommunalStorageForBatchDepotWarming 配置参数设置为默认值 1 时就是这种情况。有关此参数的详细信息，请参阅 Eon 模式参数。

调用此函数后，节点在参与查询时将在后台对其存储库进行预热。

此函数对未预热其存储库的节点没有影响。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

BACKGROUND_DEPOT_WARMING('node-name' [, 'subscription-name'])

参数

node-name
您要在后台预热其存储库的节点的名称。
订购名称
节点订购的分片的名称，您希望节点在后台预热。您可以在 NODE_SUBSCRIPTIONS 系统表的 SHARD_NAME 列中找到节点订阅的分片的名称。

返回值

指示节点预热将在后台继续的消息。

特权

用户必须是 超级用户。

示例

以下示例演示了 verticadb 数据库的节点 6 在后台对其存储库进行预热：


=> SELECT BACKGROUND_DEPOT_WARMING('v_verticadb_node0006');
                          BACKGROUND_DEPOT_WARMING
----------------------------------------------------------------------------
 Depot warming running in background. Check monitoring tables for progress.
(1 row)

另请参阅

4.14.6.3 - CANCEL_DEPOT_WARMING

仅限 Eon 模式

取消节点上的存储库预热。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。您可以选择取消节点上的所有预热，或者取消特定分片订阅的预热。节点将结束其当前执行的任何数据传输，以对其存储库进行预热，并从其队列中移除与预热相关的待执行传输。它将保留已加载到其存储库中的所有数据。当取消对特定订阅的预热时，如果所有其他订阅都已预热，则将停止预热存储库。如果其他订阅未预热，节点会继续预热其他订阅。

此函数仅在以下情况下有效：

  • 数据库在 Eon 模式下运行。

  • 节点当前正在预热其存储库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_DEPOT_WARMING('node-name' [, 'subscription-name'])

参数

'node-name'
要取消其存储库预热的节点的名称。
'subscription-name'
希望节点停止预热的节点订阅的分片的名称。您可以在 NODE_SUBSCRIPTIONS 系统表的 SHARD_NAME 列中找到节点订阅的分片的名称。

返回值

返回一条消息，表明预热已被取消。

特权

用户必须是 超级用户。

用法注意事项

取消存储库预热会对查询的性能产生负面影响。具有冷存储库的节点可能需要从公共存储中检索其大部分数据，这比访问存储库要慢。

示例

下面演示了如何取消节点 7 上的存储库预热：


=> SELECT CANCEL_DEPOT_WARMING('v_verticadb_node0007');
   CANCEL_DEPOT_WARMING
--------------------------
 Depot warming cancelled.
(1 row)

另请参阅

4.14.6.4 - CANCEL_DRAIN_SUBCLUSTER

仅限 Eon 模式

取消一个或多个子群集的排空操作。此函数可以取消由 START_DRAIN_SUBCLUSTER 或 SHUTDOWN_WITH_DRAIN 函数的排空部分启动的排空操作。CANCEL_DRAIN_SUBCLUSTER 将指定子群集中的所有节点标记为未排空。先前排空的节点再次接受新的客户端连接以及从负载均衡重定向的连接。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_DRAIN_SUBCLUSTER( 'subcluster-name' )

参数

subcluster-name
要取消排空操作的子群集的名称。输入空字符串可取消对所有子群集的排空操作。

特权

超级用户

示例

以下示例演示了如何取消对子群集的排空操作。

首先，您可以查询 DRAINING_STATUS 系统表以查看当前正在排空哪些子群集：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | t
verticadb_node0005 | analytics          | t
verticadb_node0006 | analytics          | t

以下函数调用将取消 analytics 子群集的排空操作：


=> SELECT CANCEL_DRAIN_SUBCLUSTER('analytics');
             CANCEL_DRAIN_SUBCLUSTER
--------------------------------------------------------
Targeted subcluster: 'analytics'
Action: CANCEL DRAIN

(1 row)

要确认子群集不再进行排空，您可以再次查询 DRAINING_STATUS 系统表：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | f
verticadb_node0005 | analytics          | f
verticadb_node0006 | analytics          | f
(6 rows)

另请参阅

4.14.6.5 - CLEAN_COMMUNAL_STORAGE

仅限 Eon 模式

将公共存储中的无效数据标记为待删除，通常是由于 Vertica 清理机制失败而泄露的数据。需要调用此函数的事件包括：

  • 节点故障

  • 从 Enterprise 数据库到 Eon 数据库的迁移中断

  • 从备份中恢复对象

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAN_COMMUNAL_STORAGE ( ['actually‑delete'] )

参数

actually‑delete
BOOLEAN，指定是否将数据文件添加到删除队列中：

  • true （默认值）：将文件添加到 reaper 队列中并立即返回。排队的文件将通过 reaper 服务自动移除，或者可以通过调用 FLUSH_REAPER_QUEUE 手动移除。

  • false：报告有关额外文件的信息，但不会将其添加到删除排队中。

特权

超级用户

示例

=> SELECT CLEAN_COMMUNAL_STORAGE('true')
CLEAN_COMMUNAL_STORAGE
------------------------------------------------------------------
CLEAN COMMUNAL STORAGE
Task was canceled.
Total leaked files: 9265
Total size: 4236501526
Files have been queued for deletion.
Check communal_cleanup_records for more information.
(1 row)

4.14.6.6 - CLEAR_DATA_DEPOT

仅限 Eon 模式

删除指定的存储库数据。您可以从一个子群集、单个节点或整个数据库群集中清除单个表或所有表的存储库数据。清除存储库数据不会影响公共存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DATA_DEPOT( [ '[table‑name]' [, '[target-depots]'] ] )

参数

table‑name
要从目标存储库中删除的表的名称。如果忽略表名称或提供空字符串，则会从目标库中删除所有表的数据。
target-depots
指定此实参以清除指定存储库中的所有数据，为以下之一：

  • subcluster‑name：清除指定子群集中的存储库数据。

  • node-name：清除指定节点中的存储库数据。同一子群集中其他节点上的存储库数据不受影响。

（可选）此实参限定 table-name 的实参。如果忽略此实参或提供空字符串，Vertica 将清除数据库群集中的所有存储库数据。

特权

超级用户

示例

从子群集 subcluster_1 的存储库中清除表 t1 的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('t1', 'subcluster_1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除子群集 subcluster_1 中的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('', 'subcluster_1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除单个节点的所有存储库数据：

=> select clear_data_depot('','v_vmart_node0001');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除数据库群集中表 t1 的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('t1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除数据库群集中的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT();
 clear_data_depot
------------------
 Depot cleared
(1 row)

4.14.6.7 - CLEAR_DEPOT_PIN_POLICY_PARTITION

仅限 Eon 模式

从指定的表或投影分区中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。.

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_PARTITION( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, subcluster ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

object‑name
具有要清除的分区固定策略的表或投影。
min‑range‑value max‑range‑value
从 table 中指定的分区键范围内清除固定策略，其中 min-range-value 必须 ≤ max‑range‑value。如果策略适用于单个分区，则 min‑range‑value 和 max‑range‑value 必须相等。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

4.14.6.8 - CLEAR_DEPOT_PIN_POLICY_PROJECTION

仅限 Eon 模式

从指定的投影中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_PROJECTION( '[[database.]schema.]projection' [, 'subcluster' ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
具有要清除的固定策略的投影。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

4.14.6.9 - CLEAR_DEPOT_PIN_POLICY_TABLE

仅限 Eon 模式

从指定的表中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_TABLE( '[[database.]schema.]table' [, 'subcluster' ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
具有要清除的固定策略的表。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

4.14.6.10 - CLEAR_FETCH_QUEUE

仅限 Eon 模式

从公共存储中移除所有条目或数据获取请求队列中特定事务的条目。您可以通过查询 DEPOT_FETCH_QUEUE 系统表来查看提取队列。此函数会同步移除所有排队的请求。并会在所有提取都从队列中移除后返回。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_FETCH_QUEUE([transaction_id])

参数

transaction_id
将从队列中清除其提取的事务的 ID。如果未指定此值，则从提取队列中移除所有提取。

示例

此示例将清除所有事务的提取队列。

=> SELECT CLEAR_FETCH_QUEUE();

    CLEAR_FETCH_QUEUE

--------------------------

Cleared the fetch queue.

(1 row)

此示例将清除特定事务的提取队列。

=> SELECT node_name,transaction_id FROM depot_fetch_queue;
      node_name       |  transaction_id
----------------------+-------------------
 v_verticadb_node0001 | 45035996273719510
 v_verticadb_node0003 | 45035996273719510
 v_verticadb_node0002 | 45035996273719510
 v_verticadb_node0001 | 45035996273719777
 v_verticadb_node0003 | 45035996273719777
 v_verticadb_node0002 | 45035996273719777

(6 rows)

=> SELECT clear_fetch_queue(45035996273719510);
    clear_fetch_queue
--------------------------
 Cleared the fetch queue.
(1 row)

=> SELECT node_name,transaction_id from depot_fetch_queue;
      node_name       |  transaction_id
----------------------+-------------------
 v_verticadb_node0001 | 45035996273719777
 v_verticadb_node0003 | 45035996273719777
 v_verticadb_node0002 | 45035996273719777

(3 rows)

4.14.6.11 - DEMOTE_SUBCLUSTER_TO_SECONDARY

仅限 Eon 模式

将一个 主子群集转换为 辅助子群集。

如果以下任一情况为真，Vertica 将不允许对主子群集降级：

  • 子群集包含一个 关键节点。

  • 子群集是数据库中唯一的主子群集。您必须至少有一个主子群集。

  • 启动程序节点是指您尝试降级的子群集的成员。您必须从另一个子群集调用 DEMOTE_SUBCLUSTER_TO_SECONDARY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DEMOTE_SUBCLUSTER_TO_SECONDARY('subcluster-name')

参数

subcluster‑name
要降级为辅助子群集的主子群集的名称。

特权

超级用户

示例

以下示例将子群集 analytics_cluster 降级为辅助子群集：

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | t
 load_subcluster   | t
(2 rows)

=> SELECT DEMOTE_SUBCLUSTER_TO_SECONDARY('analytics_cluster');
 DEMOTE_SUBCLUSTER_TO_SECONDARY
--------------------------------
 DEMOTE SUBCLUSTER TO SECONDARY
(1 row)

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | f
 load_subcluster   | t
(2 rows)

尝试将包含启动程序节点的子群集降级会导致错误：

=> SELECT node_name FROM sessions WHERE user_name = 'dbadmin'
   AND client_type = 'vsql';
      node_name
----------------------
 v_verticadb_node0004
(1 row)

=> SELECT node_name, is_primary FROM subclusters WHERE subcluster_name = 'analytics';
      node_name       | is_primary
----------------------+------------
 v_verticadb_node0004 | t
 v_verticadb_node0005 | t
 v_verticadb_node0006 | t
(3 rows)

=> SELECT DEMOTE_SUBCLUSTER_TO_SECONDARY('analytics');
ERROR 9204:  Cannot promote or demote subcluster including the initiator node
HINT:  Run this command on another subcluster

另请参阅

4.14.6.12 - FINISH_FETCHING_FILES

仅限 Eon 模式

将排队等待从公共存储下载的所有文件提取到存储库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FINISH_FETCHING_FILES()

特权

超级用户

示例

获取所有排队下载的文件：

=> SELECT FINISH_FETCHING_FILES();
      FINISH_FETCHING_FILES
---------------------------------
 Finished fetching all the files
(1 row)

另请参阅

Eon 模式概念

4.14.6.13 - FLUSH_REAPER_QUEUE

仅限 Eon 模式

删除数据库中所有标记为待删除的数据。使用此函数可在 reaper 服务删除磁盘文件之前移除所有标记为待删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FLUSH_REAPER_QUEUE( [sync‑catalog] )

参数

sync‑catalog
指定在函数执行之前在所有节点的数据库编录中同步元数据：

  • true （默认值）：同步数据库编录

  • false：在未同步的情况下运行。

特权

超级用户

示例

移除所有标记为待删除的文件：

=> SELECT FLUSH_REAPER_QUEUE();
                 FLUSH_REAPER_QUEUE
-----------------------------------------------------
 Sync'd catalog and deleted all files in the reaper queue.
(1 row)

另请参阅

CLEAN_COMMUNAL_STORAGE

4.14.6.14 - MIGRATE_ENTERPRISE_TO_EON

仅限企业模式

将 Enterprise 数据库迁移到 Eon 模式数据库。MIGRATE_ENTERPRISE_TO_EON 在返回之前在前台运行；无论其返回成功或错误，它都会阻止源 Enterprise 数据库中同一会话中的所有操作。如果成功，MIGRATE_ENTERPRISE_TO_EON 将返回并显示迁移数据库中的节点列表。

如果迁移在元函数返回之前被中断，例如，客户端断开连接，或者发生网络中断，则迁移将返回错误。在这种情况下，请再次调用 MIGRATE_ENTERPRISE_TO_EON 以重新开始迁移。有关详细信息，请参阅处理中断迁移。

您可以多次重复迁移到同一个公共存储位置，以捕获上一次迁移期间源数据库中的更改。有关详细信息，请参阅重复迁移。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MIGRATE_ENTERPRISE_TO_EON ( 'communal‑storage‑location', 'depot‑location' [, is‑dry‑run] )
communal‑storage‑location
公共存储位置的 URI。有关每个受支持架构的 URI 语法示例，请参阅文件系统和对象存储。
depot‑location
Eon 存储库位置的路径，通常为： 
/vertica/depot
catalog‑location
/*pushed out to as yet unspecified release (http://jira.verticacorp.com:8080/jira/browse/VER-72507) */

Vertica 编录位置的完整路径。默认设置为：

communal‑storage‑location/metadata/database‑name/nodes/node‑name/Catalog/
is‑dry‑run
Boolean。如果设置为 true，MIGRATE_ENTERPRISE_TO_EON 将仅检查 Enterprise 源数据库是否符合所有迁移先决条件。如果元函数发现任何合规性问题，它会将这些问题写入数据库目录中的迁移错误日志 migrate_enterprise_to_eon_error.log 中。

默认值：false

特权

超级用户

示例

将 Enterprise 数据库迁移到 AWS 的 Eon 模式：

=> SELECT MIGRATE_ENTERPRISE_TO_EON ('s3://verticadbbucket', '/vertica/depot');
                      migrate_enterprise_to_eon
---------------------------------------------------------------------
 v_vmart_node0001,v_vmart_node0002,v_vmart_node0003,v_vmart_node0004
(1 row)

另请参阅

将企业数据库迁移到 Eon 模式

4.14.6.15 - PROMOTE_SUBCLUSTER_TO_PRIMARY

仅限 Eon 模式

将辅助子群集转换为 主子群集。不能使用此函数来提升包含 启动程序节点的子群集。必须在连接到另一个子群集中的节点时调用此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PROMOTE_SUBCLUSTER_TO_PRIMARY('subcluster-name')

参数

subcluster‑name
要提升为主子群集的辅助群集的名称。

特权

超级用户

示例

以下示例将名为 analytics_cluster 的子群集提升为主群集：

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | f
 load_subcluster   | t
(2 rows)


=> SELECT PROMOTE_SUBCLUSTER_TO_PRIMARY('analytics_cluster');
 PROMOTE_SUBCLUSTER_TO_PRIMARY
-------------------------------
 PROMOTE SUBCLUSTER TO PRIMARY
(1 row)


=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | t
 load_subcluster   | t
(2 rows)

另请参阅

4.14.6.16 - REBALANCE_SHARDS

仅限 Eon 模式

在 Eon 模式下重新平衡子群集或整个群集中的分片分配。如果当前会话结束，则操作立即中止。根据数据库中对象的数量，重新平衡分片所需的时间以大致线性的方式增加。

在使用 ALTER NODE 修改群集或将节点添加到子群集后运行 REBALANCE_SHARDS。

重新平衡分片后，您将无法再从重新平衡之前的备份中还原对象。（始终可以执行完整备份。）重新平衡后，执行完整备份，以便将来能够从中还原对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_SHARDS(['subcluster-name'])

参数

subcluster‑name
将重新平衡分片的子群集的名称。如果您未提供此参数，则数据库中的所有子群集均会重新平衡其分片。

特权

超级用户

示例

以下示例显示新添加的 analytics 子群集中的节点尚未有分片订阅。然后它将调用 REBALANCE_SHARDS 来更新节点的订阅：

=> SELECT subcluster_name, n.node_name, shard_name, subscription_state FROM
   v_catalog.nodes n LEFT JOIN v_catalog.node_subscriptions ns ON (n.node_name
   = ns.node_name) ORDER BY 1,2,3;

   subcluster_name    |      node_name       | shard_name  | subscription_state
----------------------+----------------------+-------------+--------------------
 analytics_subcluster | v_verticadb_node0004 |             |
 analytics_subcluster | v_verticadb_node0005 |             |
 analytics_subcluster | v_verticadb_node0006 |             |
 default_subcluster   | v_verticadb_node0001 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0003 | ACTIVE
(12 rows)


=> SELECT REBALANCE_SHARDS('analytics_subcluster');
 REBALANCE_SHARDS
-------------------
 REBALANCED SHARDS
(1 row)

=> SELECT subcluster_name, n.node_name, shard_name, subscription_state FROM
   v_catalog.nodes n LEFT JOIN v_catalog.node_subscriptions ns ON (n.node_name
   = ns.node_name) ORDER BY 1,2,3;

   subcluster_name    |      node_name       | shard_name  | subscription_state
----------------------+----------------------+-------------+--------------------
 analytics_subcluster | v_verticadb_node0004 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0004 | segment0001 | ACTIVE
 analytics_subcluster | v_verticadb_node0004 | segment0003 | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | segment0001 | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | segment0002 | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | segment0002 | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0003 | ACTIVE
(18 rows)

另请参阅

4.14.6.17 - RESHARD_DATABASE

仅限 Eon 模式

更改数据库中分片的数量。此函数在运行时需要使用全局编录锁 (GCLX)。运行时取决于编录的大小。

RESHARD_DATABASE 不会立即影响公共存储中的存储容器。重新分片后，新的分片仍然指向现有容器。如果增加数据库中分片的数量，多个分片将指向同一个存储容器。最终，Tuple Mover (TM) 合并任务会将存储容器与新的分片分段边界重新对齐。如果希望 TM 立即重新对齐存储容器，请调用 DO_TM_TASK 来运行“RESHARDMERGEOUT”任务。

此函数不会中断大多数查询。但是，全局编录锁可能会影响数据加载和 DDL 语句。

语法

RESHARD_DATABASE(shard-count)

参数

shard-count
一个正整数，即重新分片数据库中分片的数量。有关选择合适的 shard-count 的信息，请参阅选择分片数量和初始节点计数。

特权

超级用户

示例

请参阅更改数据库中的分片数。

4.14.6.18 - SET_DEPOT_PIN_POLICY_PARTITION

仅限 Eon 模式

将表或投影的指定分区固定到子群集存储库或所有数据库存储库，以减少存储库逐出的风险。

仅当组内的所有分区都单独固定时，才能固定分区组。如果更改或移除表分区，Vertica 会删除该表的所有分区固定策略。表的固定策略（如有）不受影响。

有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_PARTITION ( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, 'subcluster' ] [, 'download' ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

object-name
要固定的表或投影。如果指定一个投影，则该投影必须存储分区键。
min‑range‑value
max‑range‑value
要固定的 object-name 中分区键的最小值和最大值，其中 min-range-value 必须 ≤ max‑range‑value。要指定单个分区，min‑range‑value 和 max‑range‑value 必须相等。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_PARTITION 会立即将指定的分区添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

固定策略的优先级

一般来说，涉及两个分区表的分区管理函数的优先级高于目标表的固定策略，如下所示：

例如，以下语句将分区从表 foo 复制到表 bar：

=> SELECT COPY_PARTITIONS_TO_TABLE('foo', '1', '5', 'bar');

在这种情况下，将应用以下逻辑：

  • 如果两个表具有不同的分区固定策略，则应用目标表 bar 的分区键 1-5 的固定策略。

  • 如果表 bar 不存在，Vertica 将基于表 foo 进行创建，并复制 foo 的分区键 1- 5 的策略。随后，如果从任一表中清除分区固定策略，该固定策略也会从另一个表中清除。

另请参阅

4.14.6.19 - SET_DEPOT_PIN_POLICY_PROJECTION

仅限 Eon 模式

将投影固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_PROJECTION ( '[[database.]schema.]projection' [, 'subcluster' ] [, download ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要固定的投影。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_PROJECTION 会立即将指定的投影添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

另请参阅

4.14.6.20 - SET_DEPOT_PIN_POLICY_TABLE

仅限 Eon 模式

将表固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_TABLE ( '[[database.]schema.]table' [, 'subcluster' ] [, download ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要固定的表。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_TABLE 会立即将指定的表添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

另请参阅

4.14.6.21 - SHUTDOWN_SUBCLUSTER

仅限 Eon 模式

关闭子群集。此函数将同步关闭子群集，并在关闭完成后返回子群集已关闭消息。如果子群集已关闭，此函数将不返回错误。

如果有活动用户会话连接到子群集，则停止子群集不会发出警告。此行为与停止单个节点相同。在停止子群集之前，确认没有用户连接到它。

如果想在关闭子群集之前排空客户端连接，则可以使用 SHUTDOWN_WITH_DRAIN 优雅地关闭子群集。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN_SUBCLUSTER('subcluster‑name')

参数

subcluster‑name
要关闭的子群集的名称。

特权

超级用户

示例

以下示例演示了如何关闭子群集 analytics：

=> SELECT subcluster_name, node_name, node_state FROM nodes order by 1,2;
  subcluster_name   |      node_name       | node_state
--------------------+----------------------+------------
 analytics          | v_verticadb_node0004 | UP
 analytics          | v_verticadb_node0005 | UP
 analytics          | v_verticadb_node0006 | UP
 default_subcluster | v_verticadb_node0001 | UP
 default_subcluster | v_verticadb_node0002 | UP
 default_subcluster | v_verticadb_node0003 | UP
(6 rows)

=> SELECT SHUTDOWN_SUBCLUSTER('analytics');
WARNING 4539:  Received no response from v_verticadb_node0004 in stop subcluster
WARNING 4539:  Received no response from v_verticadb_node0005 in stop subcluster
WARNING 4539:  Received no response from v_verticadb_node0006 in stop subcluster
 SHUTDOWN_SUBCLUSTER
---------------------
 Subcluster shutdown
(1 row)

=> SELECT subcluster_name, node_name, node_state FROM nodes order by 1,2;
  subcluster_name   |      node_name       | node_state
--------------------+----------------------+------------
 analytics          | v_verticadb_node0004 | DOWN
 analytics          | v_verticadb_node0005 | DOWN
 analytics          | v_verticadb_node0006 | DOWN
 default_subcluster | v_verticadb_node0001 | UP
 default_subcluster | v_verticadb_node0002 | UP
 default_subcluster | v_verticadb_node0003 | UP
(6 rows)

另请参阅

4.14.6.22 - SHUTDOWN_WITH_DRAIN

仅限 Eon 模式

优雅地关闭一个或多个子群集。此函数会排空子群集节点上的客户端连接，然后关闭子群集。这是关闭消息发送到子群集后返回的同步函数。

现有用户会话中的工作继续在正在清空的节点上进行，但节点拒绝新的客户端连接，并被排除在负载均衡操作之外。dbadmin 仍然可以连接到正在清空的节点。

现有连接完成其工作并关闭，或达到用户指定的超时后，将开始排空节点。一旦满足这些条件之一，此函数会立即继续关闭子群集。

有关正常关闭过程的详细信息，请参阅正常关闭。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN_WITH_DRAIN( 'subcluster-name', timeout-seconds )

参数

subcluster-name
要关闭的子群集的名称。输入空字符串以关闭数据库中的所有子群集。
timeout-seconds
在强制关闭 subcluster-name 的客户端连接并关闭子群集之前等待的秒数。行为取决于 timeout-seconds 的符号：
  • 正整数：此函数会等到运行时达到 timeout-seconds 或客户端连接完成工作并关闭才开始运行。一旦满足这两个条件之一，此函数会立即继续关闭子群集。
  • 零：此函数会立即关闭任何打开的客户端连接并关闭子群集。
  • 负整数：此函数将子群集标记为排空，并无限期地等待关闭子群集，直到所有活动用户会话断开连接。

特权

超级用户

示例

在以下示例中，此函数将名为 analytics 的子群集标记为排空，然后在现有客户端连接关闭或 300 秒后立即将其关闭：

=> SELECT SHUTDOWN_WITH_DRAIN('analytics', 120);
NOTICE 0:  Draining has started on subcluster (analytics)
NOTICE 0:  Begin shutdown of subcluster (analytics)
                              SHUTDOWN_WITH_DRAIN
--------------------------------------------------------------------------------------------------------------------
Set subcluster (analytics) to draining state
Waited for 3 nodes to drain
Shutdown message sent to subcluster (analytics)

(1 row)

您可以查询 DC_DRAINING_EVENTS 表，以查看有关排空和关闭事件的详细信息，例如是否存在任何用户会话被强制关闭。开始关闭后，此子群集有一个活动用户会话，但其会在达到超时之前关闭：

=> SELECT event_type, event_type_name, event_description, event_result, event_result_name FROM dc_draining_events;
 event_type |       event_type_name        |                          event_description                          | event_result | event_result_name
------------+------------------------------+---------------------------------------------------------------------+--------------+-------------------
          0 | START_DRAIN_SUBCLUSTER       | START_DRAIN for SHUTDOWN of subcluster (analytics)                  |            0 | SUCCESS
          2 | START_WAIT_FOR_NODE_DRAIN    | Wait timeout is 120 seconds                                         |            4 | INFORMATIONAL
          4 | INTERVAL_WAIT_FOR_NODE_DRAIN | 1 sessions remain after 0 seconds                                   |            4 | INFORMATIONAL
          4 | INTERVAL_WAIT_FOR_NODE_DRAIN | 1 sessions remain after 30 seconds                                  |            4 | INFORMATIONAL
          3 | END_WAIT_FOR_NODE_DRAIN      | Wait for drain ended with 0 sessions remaining                      |            0 | SUCCESS
          5 | BEGIN_SHUTDOWN_AFTER_DRAIN   | Starting shutdown of subcluster (analytics) following drain         |            4 | INFORMATIONAL
(6 rows)

另请参阅

4.14.6.23 - START_DRAIN_SUBCLUSTER

仅限 Eon 模式

排空一个或多个子群集。此函数将指定子群集中的所有节点标记为排空。现有用户会话继续在排空节点上运行，但这些节点拒绝新的客户端连接，且被排除在负载均衡操作之外。但 dbadmin 仍然可以连接到排空节点。

在优雅关闭的过程中，要排空子群集上的连接，可调用 SHUTDOWN_WITH_DRAIN。有关详细信息，请参阅优雅关闭。

要取消对子群集的排空操作，请调用 CANCEL_DRAIN_SUBCLUSTER。如果停止子群集中的所有节点排空操作，则会在重新启动时将这些节点标记为未排空。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_DRAIN_SUBCLUSTER( 'subcluster-name' )

参数

subcluster-name
要排空的子群集的名称。输入空字符串将排空数据库中的所有子群集。

特权

超级用户

示例

以下示例演示了如何排空名为 analytics 的子群集：

=> SELECT subcluster_name, node_name, node_state FROM nodes;
subcluster_name    |      node_name     | node_state
-------------------+--------------------+------------
default_subcluster | verticadb_node0001 | UP
default_subcluster | verticadb_node0002 | UP
default_subcluster | verticadb_node0003 | UP
analytics          | verticadb_node0004 | UP
analytics          | verticadb_node0005 | UP
analytics          | verticadb_node0006 | UP
(6 rows)

=> SELECT START_DRAIN_SUBCLUSTER('analytics');
               START_DRAIN_SUBCLUSTER
-------------------------------------------------------
Targeted subcluster: 'analytics'
Action: START DRAIN
(1 row)

您可以通过查询 DRAINING_STATUS 系统表来确认子群集正在排空：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | t
verticadb_node0005 | analytics          | t
verticadb_node0006 | analytics          | t

另请参阅

4.14.6.24 - START_REAPING_FILES

仅限 Eon 模式

一个异步函数，在后台启动磁盘文件删除。默认情况下，此元函数会在开始删除之前同步编录。磁盘文件删除由 FLUSH_REAPER_QUEUE 在前台处理。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REAPING_FILES( [sync‑catalog] )

参数

sync‑catalog
指定在函数执行之前在所有节点的数据库编录中同步元数据：

  • true （默认值）：同步数据库编录

  • false：在未同步的情况下运行。

特权

超级用户

示例

启动 reaper 服务：

=> SELECT START_REAPING_FILES();

启动 reaper 服务并跳过初始编录同步：

=> SELECT START_REAPING_FILES(false);

4.14.6.25 - SYNC_CATALOG

仅限 Eon 模式

将编录同步到公共存储，以便在编录快要崩溃时恢复当前编录版本。Vertica 将所有待处理的检查点和事务日志同步到公共存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SYNC_CATALOG( [ 'node‑name' ] )

参数

node‑name
要同步的节点。如果忽略此实参，Vertica 会同步所有节点上的编录。

特权

超级用户

示例

同步所有节点上的编录：

=> SELECT SYNC_CATALOG();

同步一个节点上的编录：

=> SELECT SYNC_CATALOG( 'node001' );

4.14.7 - 时期函数

此部分包含 Vertica 专用的时期管理函数。

4.14.7.1 - ADVANCE_EPOCH

手动关闭当前时期并开始新的时期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ADVANCE_EPOCH ( [ integer ] )

参数

integer
指定要推进的时期数。

超级用户

注意

维护此函数主要是为了实现与 Vertica 较早版本的向后兼容性。

示例

以下命令将以 1 为增量递增时期编号：

=> SELECT ADVANCE_EPOCH(1);

4.14.7.2 - GET_AHM_EPOCH

返回 Ancient History Mark 所在 时期的编号。可以从物理存储中清除截至 AHM 时期（包括该时期）删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AHM_EPOCH()

特权

无

示例

=> SELECT GET_AHM_EPOCH();
    GET_AHM_EPOCH
----------------------
 Current AHM epoch: 0
(1 row)

4.14.7.3 - GET_AHM_TIME

返回代表 Ancient History Mark 的 TIMESTAMP 值。可以从物理存储中清除截至 AHM 时期（包括该时期）删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AHM_TIME()

特权

无

示例

=> SELECT GET_AHM_TIME();
                  GET_AHM_TIME
-------------------------------------------------
 Current AHM Time: 2010-05-13 12:48:10.532332-04
(1 row)

4.14.7.4 - GET_CURRENT_EPOCH

当前正在将数据（COPY、INSERT、UPDATE 和 DELETE 操作）写入到的时期。

返回当前时期的编号。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_CURRENT_EPOCH()

特权

无

示例

=> SELECT GET_CURRENT_EPOCH();
 GET_CURRENT_EPOCH
-------------------
               683
(1 row)

4.14.7.5 - GET_LAST_GOOD_EPOCH

返回 上一个完好的时期的编号。如果数据库没有投影，此函数将返回错误。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_LAST_GOOD_EPOCH()

特权

无

示例

=> SELECT GET_LAST_GOOD_EPOCH();
 GET_LAST_GOOD_EPOCH
---------------------
                 682
(1 row)

4.14.7.6 - MAKE_AHM_NOW

将 Ancient History Mark (AHM) 设置为允许的最大值。这使您可以清除所有已删除的数据。

MAKE_AHM_NOW 执行以下操作：

  • 推进时间。

  • 将 AHM 设置为 上一个完好的时期 (LGE)，至少设置为执行 MAKE_AHM_NOW 时的当前时期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MAKE_AHM_NOW ( [ true ] )

参数

true
当以下条件之一为 true 时，允许 AHM 推进：

  • 一个或多个节点发生故障。

  • 一个投影正在通过另一个投影进行刷新（保留刷新）。

在这两种情况下，必须将此实参提供给 MAKE_AHM_NOW，否则 Vertica 会返回错误。如果在保留刷新期间执行 MAKE_AHM_NOW(true)，Vertica 将回滚刷新操作并推进 AHM。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 MAKE_AHM_NOW；否则，函数将返回错误。

在以下示例中，即使节点发生故障，MAKE_AHM_NOW 仍会推进 AHM：

=> SELECT MAKE_AHM_NOW(true);
WARNING:  Received no response from v_vmartdb_node0002 in get cluster LGE
WARNING:  Received no response from v_vmartdb_node0002 in get cluster LGE
WARNING:  Received no response from v_vmartdb_node0002 in set AHM
         MAKE_AHM_NOW
------------------------------
 AHM set (New AHM Epoch: 684)
(1 row)

另请参阅

4.14.7.7 - SET_AHM_EPOCH

将 Ancient History Mark (AHM) 设置为指定的时期。此函数允许从物理存储中清除已删除数据，包括 AHM 时期。

SET_AHM_EPOCH 通常用于测试。相反，请考虑使用 SET_AHM_TIME，此函数更易于使用。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AHM_EPOCH ( epoch, [ true ] )

参数

epoch
指定下列内容之一：

  • 设置 AHM 所在的时期数

  • 零 (0)（默认值）表示禁用 PURGE

true
允许 AHM 在节点关闭时推进。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 SET_AHM_EPOCH；否则，函数将返回错误。

示例

以下命令可将 AHM 设置为数量为 12 的指定时期：

=> SELECT SET_AHM_EPOCH(12);

以下命令可将 AHM 设置为数量为 2 的指定时期，并且允许在节点发生故障时推进：

=> SELECT SET_AHM_EPOCH(2, true);

另请参阅

4.14.7.8 - SET_AHM_TIME

将 Ancient History Mark (AHM) 设置为与启动程序节点上指定时间相对应的时期。此函数允许从物理存储中清除历史数据，包括 AHM 时期。 SET_AHM_TIME 返回一个表示 AHM 时期终点的 TIMESTAMPTZ。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AHM_TIME ( time, [ true ] )

参数

time
会自动转换为相应时期数的 TIMESTAMP/TIMESTAMPTZ 值。
true
允许 AHM 在节点关闭时推进。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 SET_AHM_TIME；否则，函数将返回错误。

示例

时期取决于配置的时期推进间隔。如果一个时期包含三分钟的时间范围，则清除操作仅精确到指定时间戳前三分钟内：

=> SELECT SET_AHM_TIME('2008-02-27 18:13');
           set_ahm_time
------------------------------------
 AHM set to '2008-02-27 18:11:50-05'
(1 row)

在上一示例中，AHM 时期实际于 18:11:50 结束，大约是指定时间戳前一分钟。这是因为 SET_AHM_TIME 选择了在指定时间戳或之前结束的时期。它没有选择在指定时间戳之后结束的时期，因为这样会清除 AHM 之后三分钟的已删除数据。

例如，在仅使用小时和分钟的情况下，假设时期 9000 从 08:50 运行至 11:50，时期 9001 从 11:50 运行至 15:50。 SET_AHM_TIME('11:51') 选择时期 9000，因为要在指定时间戳前一分钟左右结束。

在下一个示例中，假设某个节点在 2017 年 1 月 1 日上午 11:00:00 发生故障。中午，您将 AHM 推进到 11:15:00，但节点仍处于故障状态。

假设您尝试使用以下命令设置 AHM：

=> SELECT SET_AHM_TIME('2017-01-01 11:15:00');

然后您将收到一条错误消息。Vertica 会阻止您将 AHM 移动到超过节点出现故障的位置。Vertica 返回此错误以防止将 AHM 推进到超过故障节点的上一个完好的时期。您可以通过提供可选的其他参数来强制执行 AHM 推进：

=> SELECT SET_AHM_TIME('2017-01-01 11:15:00', true);

但是，如果强制 AHM 超过上一个完好的时期，则故障节点将不得不从头开始恢复。

另请参阅

4.14.8 - LDAP Link 函数

此部分包含与 Vertica LDAP Link 服务相关的函数。

4.14.8.1 - LDAP_LINK_DRYRUN_CONNECT

将一组 LDAP Link 连接参数作为实参，并开始在 LDAP 服务器和 Vertica 之间进行试运行连接。

通过为 LDAPLinkBindPswd 实参提供空字符串，您还可以执行匿名绑定（如果 LDAP 服务器允许未经身份验证的绑定）。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_CONNECT (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd'
)

特权

超级用户

示例

这将测试 CN=amir,OU=QA,DC=dc,DC=com 中 DN 为 ldap://example.dc.com 的 LDAP 服务器连接。

=> SELECT LDAP_LINK_DRYRUN_CONNECT('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','password');

                ldap_link_dryrun_connect
---------------------------------------------------------------------------------
Dry Run Connect Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查绑定的结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, role_name, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp       |       event_type      |      entry_name      | link_scope | search_base
------------------------------+-----------------------+----------------------+------------+-------------
2019-12-09 15:41:43.589398-05 | BIND_STARTED          | -------------------- | ---------- | -----------
2019-12-09 15:41:43.590504-05 | BIND_FINISHED         | -------------------- | ---------- | -----------

另请参阅

4.14.8.2 - LDAP_LINK_DRYRUN_SEARCH

将一组 LDAP Link 连接和搜索参数作为实参，并开始试运行搜索将从 LDAP 服务器导入的用户和组。

通过为 LDAPLinkBindPswd 实参提供空字符串，您还可以执行匿名搜索（如果 LDAP 服务器的访问控制列表 (ACL) 配置为允许未经身份验证的搜索）。允许匿名绑定的设置与允许匿名搜索的 ACL 设置不同。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_SEARCH (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd',
    'LDAPLinkSearchBase',
    'LDAPLinkScope',
    'LDAPLinkFilterUser',
    'LDAPLinkFilterGroup',
    'LDAPLinkUserName',
    'LDAPLinkGroupName',
    'LDAPLinkGroupMembers',
    [LDAPLinkSearchTimeout],
    ['LDAPLinkJoinAttr']
)

特权

超级用户

示例

这将在 LDAP 服务器中搜索用户和组。在这种情况下，LDAPLinkSearchBase 参数指定了 dc.com 域和子范围，它复制了 DN 下的整个子树。

为了进一步筛选结果，该函数将检查 objectClass 属性为 person 和 group 的用户和组。然后，它将搜索组属性 cn，使用 member 属性识别该组的成员，然后使用属性 uid 识别其中的个人用户。

=> SELECT LDAP_LINK_DRYRUN_SEARCH('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','$vertica$','dc=DC,dc=com','sub',
'(objectClass=person)','(objectClass=group)','uid','cn','member',10,'dn');

                ldap_link_dryrun_search
--------------------------------------------------------------------------------
Dry Run Search Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查搜索结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, ldapurihash, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp          |    event_type    |       entry_name       | ldapurihash | link_scope | search_base
---------------------------------+------------------+------------------------+-------------+------------+--------------
2020-01-03 21:03:26.411753+05:30 | BIND_STARTED     | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422188+05:30 | BIND_FINISHED    | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422223+05:30 | SYNC_STARTED     | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422229+05:30 | SEARCH_STARTED   | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043107+05:30 | LDAP_GROUP_FOUND | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.04312+05:30  | LDAP_GROUP_FOUND | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043182+05:30 | LDAP_USER_FOUND  | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043186+05:30 | LDAP_USER_FOUND  | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.04319+05:30  | SEARCH_FINISHED  | **********             |           0 | sub        | dc=DC,dc=com

另请参阅

4.14.8.3 - LDAP_LINK_DRYRUN_SYNC

将一组 LDAP Link 连接和搜索参数作为实参，并在数据库和 LDAP 服务器之间开始试运行同步，此操作可将 LDAP 服务器的用户和组与其在 Vertica 中的等效项进行映射和同步。此元函数还可以对 Vertica 中用户和角色的创建和孤立执行试运行。

您可以在系统表 LDAP_LINK_DRYRUN_EVENTS 中查看试运行的结果。

要取消正在进行的同步，请使用 LDAP_LINK_SYNC_CANCEL。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_SYNC (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd',
    'LDAPLinkSearchBase',
    'LDAPLinkScope',
    'LDAPLinkFilterUser',
    'LDAPLinkFilterGroup',
    'LDAPLinkUserName',
    'LDAPLinkGroupName',
    'LDAPLinkGroupMembers',
    [LDAPLinkSearchTimeout],
    ['LDAPLinkJoinAttr']
)

特权

超级用户

示例

要执行试运行以映射从 LDAP_LINK_DRYRUN_SEARCH 返回的用户和组，请将相同的参数作为实参传递给 LDAP_LINK_DRYRUN_SYNC。

=> SELECT LDAP_LINK_DRYRUN_SYNC('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','$vertica$','dc=DC,dc=com','sub',
'(objectClass=person)','(objectClass=group)','uid','cn','member',10,'dn');

                          LDAP_LINK_DRYRUN_SYNC
------------------------------------------------------------------------------------------
Dry Run Connect and Sync Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查同步结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, ldapurihash, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp          |     event_type      |       entry_name       | ldapurihash | link_scope | search_base
---------------------------------+---------------------+------------------------+-------------+------------+--------------
2020-01-03 21:08:30.883783+05:30 | BIND_STARTED        | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890574+05:30 | BIND_FINISHED       | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890602+05:30 | SYNC_STARTED        | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890605+05:30 | SEARCH_STARTED      | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939369+05:30 | LDAP_GROUP_FOUND    | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939395+05:30 | LDAP_GROUP_FOUND    | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939461+05:30 | LDAP_USER_FOUND     | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939463+05:30 | LDAP_USER_FOUND     | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939468+05:30 | SEARCH_FINISHED     | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939718+05:30 | PROCESSING_STARTED  | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939887+05:30 | USER_CREATED        | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939895+05:30 | USER_CREATED        | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939949+05:30 | ROLE_CREATED        | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939959+05:30 | ROLE_CREATED        | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.940603+05:30 | PROCESSING_FINISHED | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.940613+05:30 | SYNC_FINISHED       | ---------------------- |           0 | sub        | dc=DC,dc=com

另请参阅

4.14.8.4 - LDAP_LINK_SYNC_START

立即开始 LDAP 服务器和 Vertica 之间的同步，而不是等待在 LDAPLinkInterval 中设置的时间间隔。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ldap_link_sync_start()

特权

必须是 dbaadmin 用户。

示例

=> SELECT ldap_link_sync_start();

另请参阅

LDAP Link 参数

4.14.8.5 - LDAP_LINK_SYNC_CANCEL

取消 LDAP 服务器和 Vertica 之间正在进行的 LDAP Link 同步（包括由 LDAP_LINK_DRYRUN_SYNC 启动的同步）。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ldap_link_sync_cancel()

特权

必须是 dbaadmin 用户。

示例

=> SELECT ldap_link_sync_cancel();

另请参阅

4.14.9 - 许可证函数

此部分包含用于监控 Vertica 许可证状态和合规性的函数。

4.14.9.1 - AUDIT

返回在审核数据库大小时计算的数据库、架构或表的原始数据大小（以字节为单位）。除非指定容错为 0，置信水平为 100%，否则 AUDIT 将仅返回可能随多次迭代不断变化的近似结果。

AUDIT 使用与 Vertica 相同的数据采样方法估计 Vertica 表中的数据大小，以确定数据库是否符合许可的数据库大小限额。Vertica 不使用这些结果来确定数据库的大小是否符合 Vertica 许可证的数据限额。有关详细信息，请参阅审核数据库大小。

对于基于 ORC 或 Parquet 格式存储在外部表中的数据，AUDIT 使用数据文件的总大小。永远不会估计此值，此值是从存储 ORC 或 Parquet 文件的文件系统（或者 Vertica 节点的本地文件系统、S3 或 HDFS）中读取的。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT('[[[database.]schema.]scope ]'[, 'granularity'] [, error‑tolerance[, confidence‑level]] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

scope
指定审核范围：

  • 空字符串 ('') 将审核整个数据库。

  • 要审核的架构或表的名称。

要审核的架构或表。要审核数据库，请将此参数设置为空字符串。

granularity
审核报告其结果的级别，为以下字符串之一：

  • database

  • schema

  • table

粒度级别必须等于或小于 scope 的粒度。如果忽略此参数，粒度将设置为与 scope 相同的级别。因此，如果 online_sales 为架构，则以下语句相同：

AUDIT('online_sales', 'schema');
AUDIT('online_sales');

如果 AUDIT 将粒度设置为低于目标对象的级别，则会返回一条消息，推荐您使用系统表 USER_AUDITS。有关详细信息，请参阅下文的查询 V_CATALOG.USER_AUDITS。

error‑tolerance
指定审核评估中允许的误差幅度百分比。以 0 与 100 之间的十进制数输入一个公差值。对于 5% 的误差幅度，默认值为 5。

此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。

将此值设置为 0 将导致全面数据库审核，由于 AUDIT 会分析整个数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。

confidence‑level
指定估计的统计置信水平百分比。以 0 与 100 之间的十进制数输入置信值。默认值为 99，表示置信水平为 99%。

此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。

置信度值越高，执行的数据采样越多，函数使用的资源也会越多。将此值设置为 100 将导致全面数据库审核，由于该函数会分析所有数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。

特权

超级用户，或以下权限：

  • 对目标表的 SELECT 权限

  • 对目标架构的 USAGE 权限

查询 V_CATALOG.USER_AUDITS

如果 AUDIT 将粒度设置为低于目标对象的级别，则会返回一条消息，推荐您使用系统表 USER_AUDITS。要获取指定粒度对象的审核数据，请查询该表。例如，以下查询试图审核 store 架构中的所有表：

=> SELECT AUDIT('store', 'table');
                           AUDIT
-----------------------------------------------------------
 See table sizes in v_catalog.user_audits for schema store
(1 row)

下一个查询将查询 USER_AUDITS 并获取这些表的最新审核结果：


=> SELECT object_name, AVG(size_bytes)::int size_bytes, MAX(audit_start_timestamp::date) audit_start
      FROM user_audits WHERE object_schema='store'
      GROUP BY rollup(object_name) HAVING GROUPING_ID(object_name) < 1 ORDER BY GROUPING_ID();
    object_name    | size_bytes | audit_start
-------------------+------------+-------------
 store_dimension   |      22067 | 2017-10-26
 store_orders_fact |   27201312 | 2017-10-26
 store_sales_fact  |  301260170 | 2017-10-26
(3 rows)

示例

请参阅审核数据库大小。

4.14.9.2 - AUDIT_FLEX

返回 __raw__ 列的估计 ROS 大小，等同于审核对象中 Flex 数据的导出大小。您可以审核数据库中的所有 Flex 数据，或将审核范围缩小到特定的 Flex 表、投影或架构。Vertica 将审核结果存储在系统表 USER_AUDITS 中。

审核不包括以下内容：

  • Flex 键

  • 审核表中的其他列。

  • 临时 Flex 表

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_FLEX ('[scope]')

参数

scope
指定审核范围：

  • 空字符串 ('') 表示将审核数据库中的所有 Flex 表。

  • 架构、投影或 Flex 表的名称。

特权

超级用户，或以下权限：

  • 对目标表的 SELECT 权限

  • 对目标架构的 USAGE 权限

示例

审核当前数据库中的所有 Flex 表：

dbs=> select audit_flex('');
 audit_flex
------------
 8567679
(1 row)

审核架构 public 中的 Flex 表：


dbs=> select audit_flex('public');
audit_flex
------------
8567679
(1 row)

审核投影 bakery_b0 中的 Flex 数据：

dbs=> select audit_flex('bakery_b0');
 audit_flex
------------
 8566723
(1 row)

审核 Flex 表 bakery：

dbs=> select audit_flex('bakery');
 audit_flex
------------
 8566723
(1 row)

为了报告 USER_AUDITS 中保存的所有审核的结果，下面显示系统表中的扩展显示部分，其中显示在名为 test 的架构以及整个数据库 dbs 上运行的审核：

dbs=> \x
Expanded display is on.

dbs=> select * from user_audits;
-[ RECORD 1 ]-------------------------+------------------------------
size_bytes                            | 0
user_id                               | 45035996273704962
user_name                             | release
object_id                             | 45035996273736664
object_type                           | SCHEMA
object_schema                         |
object_name                           | test
audit_start_timestamp                 | 2014-02-04 14:52:15.126592-05
audit_end_timestamp                   | 2014-02-04 14:52:15.139475-05
confidence_level_percent              | 99
error_tolerance_percent               | 5
used_sampling                         | f
confidence_interval_lower_bound_bytes | 0
confidence_interval_upper_bound_bytes | 0
sample_count                          | 0
cell_count                            | 0
-[ RECORD 2 ]-------------------------+------------------------------
size_bytes                            | 38051
user_id                               | 45035996273704962
user_name                             | release
object_id                             | 45035996273704974
object_type                           | DATABASE
object_schema                         |
object_name                           | dbs
audit_start_timestamp                 | 2014-02-05 13:44:41.11926-05
audit_end_timestamp                   | 2014-02-05 13:44:41.227035-05
confidence_level_percent              | 99
error_tolerance_percent               | 5
used_sampling                         | f
confidence_interval_lower_bound_bytes | 38051
confidence_interval_upper_bound_bytes | 38051
sample_count                          | 0
cell_count                            | 0
-[ RECORD 3 ]-------------------------+------------------------------
...

4.14.9.3 - AUDIT_LICENSE_SIZE

触发数据库大小的立即审核，以确定它是否符合 Vertica 许可证中的原始数据存储限额。

如果使用存储在 HDFS 中的 ORC 或 Parquet 数据，则仅当您以有权访问所有 HDFS 数据的用户身份运行此函数时，结果才准确。使用对所有此类数据具有读取权限的主体，或使用授予此访问权限的 Hadoop 委派令牌运行查询。有关使用委派令牌的详细信息，请参阅访问已进行 Kerberize 的 HDFS 数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_LICENSE_SIZE()

超级用户

示例

=> SELECT audit_license_size();
 audit_license_size
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

4.14.9.4 - AUDIT_LICENSE_TERM

触发立即审核，以确定 Vertica 许可证是否已过期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_LICENSE_TERM()

超级用户

示例

=> SELECT audit_license_term();
 audit_license_term
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

4.14.9.5 - DISPLAY_LICENSE

返回 Vertica 许可证的期限。此函数显示的信息为：

  • 许可证的有效期开始日期和结束日期（如果许可证没有到期日，则显示“永久”(Perpetual)）。

  • 许可证期限到期后，可继续使用 Vertica 的天数（宽限期）

  • 在许可证包含数据限额的情况下，数据库可以存储的数据量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISPLAY_LICENSE()

特权

无

示例

=> SELECT DISPLAY_LICENSE();
                  DISPLAY_LICENSE
---------------------------------------------------
 Vertica Systems, Inc.
2007-08-03
Perpetual
500GB

(1 row)

4.14.9.6 - GET_AUDIT_TIME

报告自动审核数据库大小的时间。如果您的 Vertica 许可证包含数据大小限额，Vertica 将执行此审核。有关此审核的详细信息，请参阅《管理员指南》中的管理许可证。要更改审核运行的时间，请使用 SET_AUDIT_TIME 函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AUDIT_TIME()

特权

无

示例

=> SELECT get_audit_time();
get_audit_time
-----------------------------------------------------
 The audit is scheduled to run at 11:59 PM each day.
(1 row)

4.14.9.7 - GET_COMPLIANCE_STATUS

显示您的数据库是否符合 Vertica 许可证协议要求。此信息包括 Vertica 最近对数据库大小的审核结果（如果您的许可证条款中具有数据限额）、许可证期限（如果您的许可证具有结束日期）和节点数（如果您的许可证具有节点限制）。

GET_COMPLIANCE_STATUS 按 TB 衡量数据限额（其中 1 TB 等于 10244 字节）。

GET_COMPLIANCE_STATUS 显示的信息包括：

  • 数据库的估计大小（有关大小估计的说明，请参阅审核数据库大小）。

  • Vertica 许可证所允许的原始数据大小。

  • 您的数据库目前使用的限额百分比。

  • 节点数和许可证限制。

  • 上次审核的日期和时间。

  • 您的数据库是否符合许可证协议的数据限额条款。

  • 许可证的结束日期。

  • 许可证到期之前的天数。

如果审核显示您的许可证不符合数据限额要求，应该删除数据以使数据库大小低于许可的数量，或升级您的许可证。如果您的许可证已到期，应该立即联系 Vertica 以续订许可证。有关更多详细信息，请参阅管理许可证。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_COMPLIANCE_STATUS()

特权

无

示例

=> SELECT GET_COMPLIANCE_STATUS();
 get_compliance_status
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

以下示例显示了 Vertica for SQL on Apache Hadoop 群集的输出。

=> SELECT GET_COMPLIANCE_STATUS();
 get_compliance_status
--------------------
Node count : 4
License Node limit : 5
No size-compliance concerns for an Unlimited license

No expiration date for a Perpetual license
(1 row)

4.14.9.8 - SET_AUDIT_TIME

设置 Vertica 执行自动数据库大小审核的时间，以确定数据库大小是否符合 Vertica 许可证中的原始数据限额。如果当前计划在数据库活动高峰期进行审核，请使用此函数。这通常不是问题，因为自动审核对数据库性能几乎没有影响。

审核是由上一次审核计划的，因此更改审核时间不会影响下一次计划的审核。例如，如果您计划在晚上 11:59 进行下一次审核，然后您使用 SET_AUDIT_TIME 将审核计划更改为凌晨 3 点，则之前计划的晚上 11:59 的审核仍会运行。该审核完成后，它将计划在凌晨 3 点进行下一次审核。

即使使用 SET_AUDIT_TIME 更改审核时间，然后通过发出语句 SELECT AUDIT_LICENSE_SIZE 触发自动审核，Vertica 也会始终执行下一次计划的审核。只有在下一次计划的审核完成之后，Vertica 才会在您使用 SET_AUDIT_TIME 设置的新时间开始审核。此后，Vertica 在新时间进行审核。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AUDIT_TIME(time)
time
包含 'HH:MM AM/PM' 格式的时间的字符串（例如，'1:00 AM'），表示审核每天的运行时间。

超级用户

示例

=> SELECT SET_AUDIT_TIME('3:00 AM');
                            SET_AUDIT_TIME
-----------------------------------------------------------------------
 The scheduled audit time will be set to 3:00 AM after the next audit.
(1 row)

4.14.10 - 通知程序函数

此部分包含用于使用和管理通知程序的函数。

4.14.10.1 - GET_DATA_COLLECTOR_NOTIFY_POLICY

列出在 数据收集器组件上设置的所有通知策略。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_DATA_COLLECTOR_NOTIFY_POLICY('component')
component
要检查其通知策略的数据收集器组件的名称。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

示例

=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
                   GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------------------------------------------
 Notifiable;  Notifier: vertica_stats; Channel: vertica_notifications
(1 row)

以下示例显示了当组件未设置通知策略时函数的输出：


=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
 GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 Not notifiable;
(1 row)

另请参阅

4.14.10.2 - NOTIFY

向 NOTIFIER 发送指定消息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

NOTIFY ( 'message', 'notifier', 'target‑topic' )

参数

message
要发送到端点的消息。
notifier
NOTIFIER 的名称。
target‑topic
基于 notifier 类型指定以下内容之一的字符串：

  • Kafka：消息的现有目标 Kafka 主题的名称。

  • Syslog：ProblemDescription 主题和 channel 值。

超级用户

示例

发送消息以确认 ETL 作业已完成：

=> SELECT NOTIFY('ETL Done!', 'my_notifier', 'DB_activity_topic');

4.14.10.3 - SET_DATA_COLLECTOR_NOTIFY_POLICY

为 数据收集器组件创建/启用通知策略。当某些事件发生时，通知策略会自动向指定的 NOTIFIER 发送消息。

要查看数据收集器组件上的现有通知策略，请参阅 GET_DATA_COLLECTOR_NOTIFY_POLICY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_NOTIFY_POLICY('component','notifier', 'topic', enabled)
component
将通过通知程序报告其更改的组件的名称。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
notifier
将发送消息的通知程序的名称。
topic
以下几项之一：

  • Kafka：将接收通知消息的 Kafka 主题的名称。

  • Syslog：字段 ProblemDescription 的主题。

enabled
布尔值，指定是否启用此策略。设置为 TRUE 表示启用报告组件更改。设置为 FALSE 表示禁用通知程序。

示例

Kafka 通知程序

要在登录尝试失败时收到通知，您可以创建一个通知程序，使其在 DC 组件 LoginFailures 更新时发送通知。TLSMODE 'verify-ca’ 将验证服务器的证书是否由受信任的 CA 签名。

=> CREATE NOTIFIER vertica_stats ACTION 'kafka://kafka01.example.com:9092' MAXMEMORYSIZE '10M' TLSMODE 'verify-ca';
CREATE NOTIFIER
=> SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','vertica_stats', 'vertica_notifications', true);
SET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 SET
(1 row)

以下示例显示如何禁用在上一个示例中创建的策略：

=> SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','vertica_stats', 'vertica_notifications', false);
 SET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 SET
(1 row)


=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
 GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 Not notifiable;
(1 row)

Syslog 通知程序

以下示例创建了一个通知程序，当 数据收集器 (DC) 组件 LoginFailures 更新时，它会向 syslog 写入一条消息：

  1. 为当前数据库启用 syslog 通知程序：

    => ALTER DATABASE DEFAULT SET SyslogEnabled = 1;

  2. 创建并启用系统日志通知程序 v_syslog_notifier：

    => CREATE NOTIFIER v_syslog_notifier ACTION 'syslog'
    ENABLE
    MAXMEMORYSIZE '10M'
    IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
    PARAMETERS 'eventSeverity = 5';

  3. 配置 syslog 通知程序 v_syslog_notifier 以更新具有 SET_DATA_COLLECTOR_NOTIFY_POLICY 的 LoginFailures DC 组件：

    => SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','v_syslog_notifier', 'Login failed!', true);

    当用户未能以用户 Bob 身份进行身份验证时，此通知程序将以下消息写入 syslog（默认位置：/var/log/messages）：Apr 25 16:04:58 vertica_host_01 vertica： Event Posted: Event Code:21 Event Id:0 Event Severity: Notice [5] PostedTimestamp: 2022-04-25 16:04:58.083063 ExpirationTimestamp: 2022-04-25 16:04:58.083063 EventCodeDescription: Notifier ProblemDescription: (Login failed!) { "_db":"VMart", "_schema":"v_internal", "_table":"dc_login_failures", "_uuid":"f8b0278a-3282-4e1a-9c86-e0f3f042a971", "authentication_method":"Reject", "client_authentication_name":"default: Reject", "client_hostname":"::1", "client_label":"", "client_os_user_name":"dbadmin", "client_pid":523418, "client_version":"", "database_name":"dbadmin", "effective_protocol":"3.8", "node_name":"v_vmart_node0001", "reason":"REJECT", "requested_protocol":"3.8", "ssl_client_fingerprint":"", "ssl_client_subject":"", "time":"2022-04-25 16:04:58.082568-05", "user_name":"Bob" }#012 DatabaseName: VMart Hostname: vertica_host_01

另请参阅

4.14.11 - 分区函数

此部分包含 Vertica 专用的分区管理函数。

4.14.11.1 - CALENDAR_HIERARCHY_DAY

指定将 DATE 分区键分成年、月和日的层次结构。Vertica Tuple Mover 会定期根据当前日期评估分区键，并根据需要将分区合并到相应的年份和月份分区组中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CALENDAR_HIERARCHY_DAY( partition‑expression[, active‑months[, active‑years] ] )

参数

partition‑expression
用于对分区键分组的 DATE 表达式，必须与表的 PARTITION BY 表达式相同。
active‑months
一个 ≥ 0 的整数，指定将 MONTH(CURRENT_DATE) 前多少个月的唯一分区键存储在单独的分区中。

如果指定为 1，则只将当月的分区键存储在单独的分区中。

如果指定为 0，则将当月的所有分区键合并到该月的分区组中。

有关详细信息，请参阅分层分区。

默认值： 2

active‑years
一个 ≥ 0 的整数，指定将 YEAR(CURRENT_DATE) 前多少年的分区键按月份分组到单独的分区中。

如果指定为 1，则只将当年的分区键存储在月份分区组中。

如果指定为 0，则将当前和以前年份的所有分区键合并到年份分区组中。

有关详细信息，请参阅分层分区。

默认值： 2

使用

在表分区子句中指定此函数，作为其 GROUP BY 表达式：

PARTITION BY partition‑expression
  GROUP BY CALENDAR_HIERARCHY_DAY(
     group‑expression
      [, active‑months[, active‑years] ] )

例如：

=> CREATE TABLE public.store_orders
(
    order_no int,
    order_date timestamp NOT NULL,
    shipper varchar(20),
    ship_date date
);
...
=> ALTER TABLE public.store_orders
      PARTITION BY order_date::DATE
      GROUP BY CALENDAR_HIERARCHY_DAY(order_date::DATE, 3, 2) REORGANIZE;

有关用法的详细信息，请参阅分层分区。

另请参阅

分层分区

4.14.11.2 - COPY_PARTITIONS_TO_TABLE

将分区从一个表复制到另一个表中。这种轻型分区复制可通过在两个表之间初始共享同一个存储来提高性能。完成复制操作后，各表彼此独立。用户对每个表执行操作时不会影响另一个表。这些操作可增加两个表所需的存储总量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COPY_PARTITIONS_TO_TABLE (
    '[[database.]schema.]source‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target‑table'
     [, 'force‑split']
)

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

source‑table
要复制的分区的源表。
min‑range‑value max‑range‑value
要复制的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要复制某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
要复制的分区的目标表。 如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 对源表的 TRUNCATE 权限（如果 force-split 为 true）和 SELECT 权限，对目标表的 INSERT 权限

如果目标表不存在，则必须在目标架构上具有 CREATE 权限以启用表创建。

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

如果调用 COPY_PARTITIONS_TO_TABLE 且目标表不存在，该函数将自动创建此表。在以下示例中，目标表 partn_backup.tradfes_200801 不存在。 COPY_PARTITIONS_TO_TABLE 创建该表并复制分区。Vertica 还会复制与源表关联的所有约束，外键约束除外。

=> SELECT COPY_PARTITIONS_TO_TABLE (
          'prod_trades',
          '200801',
          '200801',
          'partn_backup.trades_200801');
COPY_PARTITIONS_TO_TABLE
-------------------------------------------------
 1 distinct partition values copied at epoch 15.
(1 row)

另请参阅

存档分区

4.14.11.3 - DROP_PARTITIONS

删除指定的表分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_PARTITIONS (
    '[[database.]schema.]table‑name',
    'min‑range‑value',
    'max‑range‑value'
    [, 'force‑split']
)

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
目标表。此表不能用作预联接投影中的维度表，且不能包含过期（未刷新）的投影。
min‑range‑value max‑range‑value
要删除的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要删除某个分区键，min‑range‑value 和 max‑range‑value 必须相等。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

以下几项之一：

  • DBADMIN

  • 表所有者

  • 对表架构的 USAGE 权限和对表的 TRUNCATE 权限

示例

请参阅删除分区。

另请参阅

PARTITION_TABLE

4.14.11.4 - DUMP_PROJECTION_PARTITION_KEYS

转储指定投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_PROJECTION_PARTITION_KEYS( '[[database.]schema.]projection-name')

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection‑name
投影名称

特权

非超级用户：对锚表的 TRUNCATE 权限

示例

下列语句将分别创建表和投影 online_sales.online_sales_fact 和 online_sales.online_sales_fact_rep，并将按列 call_center_key 对表数据进行分区：

=> CREATE TABLE online_sales.online_sales_fact
(
    sale_date_key int NOT NULL,
    ship_date_key int NOT NULL,
    product_key int NOT NULL,
    product_version int NOT NULL,
    customer_key int NOT NULL,
    call_center_key int NOT NULL,
    online_page_key int NOT NULL,
    shipping_key int NOT NULL,
    warehouse_key int NOT NULL,
    promotion_key int NOT NULL,
    pos_transaction_number int NOT NULL,
    sales_quantity int,
    sales_dollar_amount float,
    ship_dollar_amount float,
    net_dollar_amount float,
    cost_dollar_amount float,
    gross_profit_dollar_amount float,
    transaction_type varchar(16)
)
PARTITION BY (online_sales_fact.call_center_key);

=> CREATE PROJECTION online_sales.online_sales_fact_rep AS SELECT * from online_sales.online_sales_fact unsegmented all nodes;

下列 DUMP_PROJECTION_PARTITION_KEYS 语句将转储投影 online_sales.online_sales_fact_rep 中的分区键：

=> SELECT DUMP_PROJECTION_PARTITION_KEYS('online_sales.online_sales_fact_rep');

Partition keys on node v_vmart_node0001
  Projection 'online_sales_fact_rep'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 200
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 199
   ...
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 1

 Partition keys on node v_vmart_node0002
  Projection 'online_sales_fact_rep'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 200
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 199
...
(1 row)

另请参阅

4.14.11.5 - DUMP_TABLE_PARTITION_KEYS

转储指定表的所有投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_TABLE_PARTITION_KEYS ( '[[database.]schema.]table‑name' )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
表的名称

特权

非超级用户：对表的 TRUNCATE 权限

示例

下列示例将创建一个名为 states 的简单表并按状态对数据进行分区：

=> CREATE TABLE states (year INTEGER NOT NULL,
       state VARCHAR NOT NULL)
       PARTITION BY state;
=> CREATE PROJECTION states_p (state, year) AS
       SELECT * FROM states
       ORDER BY state, year UNSEGMENTED ALL NODES;

现在转储表 states 上锚定的所有投影的分区键值：

=> SELECT DUMP_TABLE_PARTITION_KEYS( 'states' );
      DUMP_TABLE_PARTITION_KEYS                                                               --------------------------------------------------------------------------------------------
 Partition keys on node v_vmart_node0001
  Projection 'states_p'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: VT
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: PA
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: NY
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: MA

 Partition keys on node v_vmart_node0002
...
(1 row)

另请参阅

4.14.11.6 - MOVE_PARTITIONS_TO_TABLE

将分区从一个表移至另一个表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVE_PARTITIONS_TO_TABLE (
    '[[database.]schema.]source‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target-table'
     [, force‑split]
)

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

source‑table
需要移动的分区所在的源表。
min‑range‑value max‑range‑value
要移动的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要移动某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
分区移动的目标表。 如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 对源表的 SELECT 和 TRUNCATE 权限，对目标表的 INSERT 权限

如果目标表不存在，则必须在目标架构上具有 CREATE 权限以启用表创建。

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

请参阅存档分区。

另请参阅

4.14.11.7 - PARTITION_PROJECTION

拆分指定投影的 ROS 容器。 PARTITION_PROJECTION 如果在 AHM 时期之前应用了删除，则也会在对 ROS 容器分区时清除数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PARTITION_PROJECTION ( '[[database.]schema.]projection')

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要分区的投影。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

在此示例中，PARTITION_PROJECTION 会强制拆分 states_p 投影中的 ROS 容器：

=> SELECT PARTITION_PROJECTION ('states_p');
  PARTITION_PROJECTION
------------------------
 Projection partitioned
(1 row)

另请参阅

4.14.11.8 - PARTITION_TABLE

调用 Tuple Mover，以根据需要重新组织 ROS 存储容器以符合当前分区策略。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PARTITION_TABLE ( '[schema.]table‑name')

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
要分区的表。

特权

  • 表所有者

  • 对架构的 USAGE 权限

限制

  • 不能在实时聚合投影或 Top-K 投影的锚表中运行 PARTITION_TABLE。

  • 要重新组织存储以符合新策略，请在更改分区 GROUP BY 表达式后运行 PARTITION_TABLE。

另请参阅

4.14.11.9 - PURGE_PARTITION

清除已删除行的表分区。类似 PURGE 和 PURGE_PROJECTION，该函数会从物理存储中移除已删除的数据，这样可以重复使用磁盘空间。 PURGE_PARTITION 仅移除 AHM 时期及更早时期的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_PARTITION ( '[[database.]schema.]table', partition‑key )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要清除的已分区的表。
partition‑key
要清除的分区的键。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例列出了表中每个分区已删除行的数量，然后调用 PURGE_PARTITION() 从数据清除已删除的行。

=> SELECT partition_key,table_schema,projection_name,sum(deleted_row_count)
   AS deleted_row_count FROM partitions
   GROUP BY partition_key,table_schema,projection_name
   ORDER BY partition_key;

 partition_key | table_schema | projection_name | deleted_row_count
---------------+--------------+-----------------+-------------------
 0             | public       | t_super         |                 2
 1             | public       | t_super         |                 2
 2             | public       | t_super         |                 2
 3             | public       | t_super         |                 2
 4             | public       | t_super         |                 2
 5             | public       | t_super         |                 2
 6             | public       | t_super         |                 2
 7             | public       | t_super         |                 2
 8             | public       | t_super         |                 2
 9             | public       | t_super         |                 1
(10 rows)
=> SELECT PURGE_PARTITION('t',5); -- Purge partition with key 5.
                            purge_partition
------------------------------------------------------------------------
 Task: merge partitions
(Table: public.t) (Projection: public.t_super)
(1 row)

=> SELECT partition_key,table_schema,projection_name,sum(deleted_row_count)
   AS deleted_row_count FROM partitions
   GROUP BY partition_key,table_schema,projection_name
   ORDER BY partition_key;


 partition_key | table_schema | projection_name | deleted_row_count
---------------+--------------+-----------------+-------------------
 0             | public       | t_super         |                 2
 1             | public       | t_super         |                 2
 2             | public       | t_super         |                 2
 3             | public       | t_super         |                 2
 4             | public       | t_super         |                 2
 5             | public       | t_super         |                 0
 6             | public       | t_super         |                 2
 7             | public       | t_super         |                 2
 8             | public       | t_super         |                 2
 9             | public       | t_super         |                 1
(10 rows)

另请参阅

4.14.11.10 - SWAP_PARTITIONS_BETWEEN_TABLES

在两个表之间切换分区。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SWAP_PARTITIONS_BETWEEN_TABLES (
    '[[database.]schema.]staging‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target‑table'
     [, force‑split]
)

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

临时表
用于切换分区的临时表。
min‑range‑value max‑range‑value
要交换的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要交换某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
待切换分区的表。目标表不能与临时表相同。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 目标表和源表：TRUNCATE、INSERT、SELECT

要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有目标表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。

限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

请参阅交换分区。

4.14.12 - 权限和访问函数

此部分包含用于管理用户和角色权限以及访问策略的函数。

4.14.12.1 - ENABLED_ROLE

检查是否启用了 Vertica 用户角色，并返回 true 或 false。当为数据库角色创建访问策略时，通常会使用此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLED_ROLE ( 'role' )

参数

角色
要评估的角色。

特权

无

示例

请参阅：

另请参阅

CREATE ACCESS POLICY

4.14.12.2 - GET_PRIVILEGES_DESCRIPTION

返回当前用户对对象具有的有效权限，包括显式权限、隐式权限、继承的权限以及基于用户的权限。

因为此元函数仅返回有效权限，因此 GET_PRIVILEGES_DESCRIPTION 将只返回完全满足先决条件的权限。有关常见操作的先决条件列表，请参阅常用数据库操作所需的权限。

例如，用户必须具有以下权限才能查询表：

  • 架构： USAGE

  • 表： SELECT

如果用户 Brooke 对表 s1.t1 具有 SELECT 权限，但缺少对架构 s1 的 USAGE 权限，则 Brooke 将无法查询该表，且 GET_PRIVILEGES_DESCRIPTION 不会返回该表的 SELECT 权限。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PRIVILEGES_DESCRIPTION( 'type', '[[database.]schema.]name' );

参数

类型
指定对象类型，为以下之一：

  • database

  • table

  • schema

  • view

  • sequence

  • model

  • library

  • resource pool

[database.]schema
指定数据库和架构，默认情况下分别为当前数据库和 public。
name
目标对象的名称

特权

无

示例

在以下示例中，用户 Glenn 设置了 REPORTER 角色，并希望检查他对架构 s1 和表 s1.articles 的有效权限。

  • 表 s1.articles 从其架构 (s1) 继承权限。

  • REPORTER 角色具有以下权限：

    • 对架构的 SELECT 权限 s1

    • 对表的 INSERT WITH GRANT OPTION 权限 s1.articles

  • 用户 Glenn 具有以下权限：

    • 对架构 s1 的 UPDATE 和 USAGE 权限。

    • 对表 s1.articles 的 DELETE 权限。

GET_PRIVILEGES_DESCRIPTION 返回 Glenn 对架构 s1 的以下有效权限：

=> SELECT GET_PRIVILEGES_DESCRIPTION('schema', 's1');
   GET_PRIVILEGES_DESCRIPTION
--------------------------------
 SELECT, UPDATE, USAGE
(1 row)

GET_PRIVILEGES_DESCRIPTION 返回 Glenn 对表 s1.articles 的以下有效权限：


=> SELECT GET_PRIVILEGES_DESCRIPTION('table', 's1.articles');
   GET_PRIVILEGES_DESCRIPTION
--------------------------------
 INSERT*, SELECT, UPDATE, DELETE
(1 row)

另请参阅

4.14.12.3 - HAS_ROLE

检查是否已将 Vertica 用户角色授予指定的用户或角色，并返回 true 或 false。

您还可以查询系统表 ROLES、GRANTS 和 USERS，以获取有关用户及其角色分配的信息。有关详细信息，请参阅查看用户角色。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

HAS_ROLE( [ 'grantee' ,] 'verify‑role' );

参数

grantee
仅对超级用户有效，指定要查找的用户或角色的名称。如果忽略此实参，则函数将使用当前用户名 ( CURRENT_USER)。如果指定了角色，Vertica 会检查是否向此角色授予在 verify‑role 中指定的角色。
verify‑role
要为 grantee 验证的角色名称。

特权

无

示例

在以下示例中，dbadmin 用户检查是否为用户 MikeL 分配了 admnistrator 角色：

=> \c
You are now connected as user "dbadmin".
=> SELECT HAS_ROLE('MikeL', 'administrator');
 HAS_ROLE
----------
 t
(1 row)

用户 MikeL 检查其是否具有 regional_manager 角色：

=> \c - MikeL
You are now connected as user "MikeL".
=> SELECT HAS_ROLE('regional_manager');
 HAS_ROLE
----------
 f
(1 row)

dbadmin 将 regional_manager 角色授予 administrator 角色。再次检查时，MikeL 会验证他现在具有 regional_manager 角色：

dbadmin=> \c
You are now connected as user "dbadmin".
dbadmin=> GRANT regional_manager to administrator;
GRANT ROLE
dbadmin=> \c - MikeL
You are now connected as user "MikeL".
dbadmin=> SELECT HAS_ROLE('regional_manager');
 HAS_ROLE
----------
 t
(1 row)

另请参阅

4.14.12.4 - RELEASE_SYSTEM_TABLES_ACCESS

启用非超级用户对所有系统表的访问权限。调用此函数后，Vertica 将忽略表 SYSTEM_TABLES 中的 IS_ACCESSIBLE_DURING_LOCKDOWN 设置。要继续对非超级用户强制执行对系统表的访问限制，请调用 RESTRICT_SYSTEM_TABLES_ACCESS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_SYSTEM_TABLES_ACCESS()

特权

超级用户

4.14.12.5 - RESTRICT_SYSTEM_TABLES_ACCESS

检查系统表 SYSTEM_TABLES，以确定非超级用户可以访问哪些系统表。非超级用户对每个系统表的访问权限由布尔列 IS_ACCESSIBLE_DURING_LOCKDOWN 指定。当调用此函数时，Vertica 会检查每个系统表上的 IS_ACCESSIBLE_DURING_LOCKDOWN 设置，并相应地强制控制所有非超级用户的访问权限。

默认情况下，Vertica 强制应用 IS_ACCESSIBLE_DURING_LOCKDOWN 设置。要启用非超级用户对所有系统表的访问权限，必须显式调用 RELEASE_SYSTEM_TABLES_ACCESS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESTRICT_SYSTEM_TABLES_ACCESS()

特权

超级用户

4.14.13 - 投影函数

此部分包含 Vertica 专用的投影管理函数。

另请参阅

4.14.13.1 - CLEAR_PROJECTION_REFRESHES

从系统表 PROJECTION_REFRESHES 中清除信息投影刷新历史记录。

系统表 PROJECTION_REFRESHES 记录刷新操作成功和失败的相关信息。PROJECTION_REFRESHES 将保留投影刷新数据，直到出现以下事件之一为止：

  • 给定的投影中开始出现另一个刷新操作。

  • CLEAR_PROJECTION_REFRESHES PROJECTION_REFRESHES 被调用并清除所有投影的数据。

  • 已超出表的存储配额。

CLEAR_PROJECTION_REFRESHES 会检查 PROJECTION_REFRESHES 布尔列 IS_EXECUTING，以确定刷新操作是否仍在运行或已完成。该函数仅移除已完成的刷新操作的信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_PROJECTION_REFRESHES()

超级用户

示例

=> SELECT CLEAR_PROJECTION_REFRESHES();
 CLEAR_PROJECTION_REFRESHES
----------------------------
 CLEAR
(1 row)

另请参阅

4.14.13.2 - EVALUATE_DELETE_PERFORMANCE

针对潜在的 DELETE 和 UPDATE 性能问题对投影进行评估。如果 Vertica 发现任何问题，则会发出警告消息。在评估多个投影时，EVALUATE_DELETE_PERFORMANCE 将返回最多十个有问题的投影，以及列出其发现的所有问题的表的名称。

有关解决删除和更新性能问题的信息，请参阅 优化 DELETE 和 UPDATE。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EVALUATE_DELETE_PERFORMANCE ( ['[[database.]schema.]scope'] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

scope
指定要评估的投影，为以下之一：

  • [table.]projection
    评估 projection。例如：

    SELECT EVALUATE_DELETE_PERFORMANCE('store.store_orders_fact.store_orders_fact_b1');

  • 表
    指定评估 table 的所有投影。例如：

    SELECT EVALUATE_DELETE_PERFORMANCE('store.store_orders_fact');

如果未提供实参，EVALUATE_DELETE_PERFORMANCE 将评估您可以访问的所有投影。根据数据库的大小，这可能会产生很大的开销。

特权

非超级用户：对锚表的 SELECT 权限

示例

EVALUATE_DELETE_PERFORMANCE 会针对潜在的 DELETE 和 UPDATE 性能问题对表 example 的所有投影进行评估。

=> create table example (A int, B int,C int);
CREATE TABLE
=> create projection one_sort (A,B,C) as (select A,B,C from example) order by A;
CREATE PROJECTION
=> create projection two_sort (A,B,C) as (select A,B,C from example) order by A,B;
CREATE PROJECTION
=> select evaluate_delete_performance('example');
            evaluate_delete_performance
---------------------------------------------------
 No projection delete performance concerns found.
(1 row)

上一示例表明，one_sort 和 two_sort 这两个投影不存在会引发 DELETE 性能降低的固有结构问题。但如果排序后的列不能唯一标识一行或小量行，则投影中包含的数据可能产生潜在删除问题。

在下面的示例中，Perl 用于通过嵌套的循环系列来为表填充数据：

  • 内部循环填充列 C.

  • 中间循环填充列 B。

  • 外部循环填充列 A。

结果为：列 A 仅包含三个非重复值（0、1 和 2），而列 B 在 20 和 0 之间缓慢变化，列 C 则在每行中均有变化：

=> \\! perl -e 'for ($i=0; $i<3; $i++) { for ($j=0; $j<21; $j++) { for ($k=0; $k<19; $k++) { printf "%d,%d,%d\n", $i,$j,$k;}}}' | /opt/vertica/bin/vsql -c "copy example from stdin delimiter ',' direct;"
Password:
=> select * from example;
 A | B  | C
---+----+----
 0 | 20 | 18
 0 | 20 | 17
 0 | 20 | 16
 0 | 20 | 15
 0 | 20 | 14
 0 | 20 | 13
 0 | 20 | 12
 0 | 20 | 11
 0 | 20 | 10
 0 | 20 |  9
 0 | 20 |  8
 0 | 20 |  7
 0 | 20 |  6
 0 | 20 |  5
 0 | 20 |  4
 0 | 20 |  3
 0 | 20 |  2
 0 | 20 |  1
 0 | 20 |  0
 0 | 19 | 18
 ...
 2 |  1 |  0
 2 |  0 | 18
 2 |  0 | 17
 2 |  0 | 16
 2 |  0 | 15
 2 |  0 | 14
 2 |  0 | 13
 2 |  0 | 12
 2 |  0 | 11
 2 |  0 | 10
 2 |  0 |  9
 2 |  0 |  8
 2 |  0 |  7
 2 |  0 |  6
 2 |  0 |  5
 2 |  0 |  4
 2 |  0 |  3
 2 |  0 |  2
 2 |  0 |  1
 2 |  0 |  0
=> SELECT COUNT (*) FROM example;
 COUNT
-------
  1197
(1 row)
=> SELECT COUNT (DISTINCT A) FROM example;
 COUNT
-------
     3
(1 row)

再次对投影运行 EVALUATE_DELETE_PERFORMANCE，以确定投影内的数据是否会引发任何潜在的 DELETE 性能问题。投影 one_sort 具有潜在的删除性能问题，因为它仅按照具有较少非重复值的列 A 进行排序。排序列中的各值与投影中的多个行对应，而这对 DELETE 性能有负面影响。相反，投影 two_sort 按照列 A 和列 B 进行排序，两个排序列中的每个值组合均可以仅标识少数行，便于删除操作快速执行：


=> select evaluate_delete_performance('example');
            evaluate_delete_performance
---------------------------------------------------
 The following projections exhibit delete performance concerns:
        "public"."one_sort_b1"
        "public"."one_sort_b0"
See v_catalog.projection_delete_concerns for more details.

=> \x
Expanded display is on.
dbadmin=> select * from projection_delete_concerns;
-[ RECORD 1 ]------+------------------------------------------------------------------------------------------------------------------------------------------------------------
projection_id      | 45035996273878562
projection_schema  | public
projection_name    | one_sort_b1
creation_time      | 2019-06-17 13:59:03.777085-04
last_modified_time | 2019-06-17 14:00:27.702223-04
comment            | The squared number of rows matching each sort key is about 159201 on average.
-[ RECORD 2 ]------+------------------------------------------------------------------------------------------------------------------------------------------------------------
projection_id      | 45035996273878548
projection_schema  | public
projection_name    | one_sort_b0
creation_time      | 2019-06-17 13:59:03.777279-04
last_modified_time | 2019-06-17 13:59:03.777279-04
comment            | The squared number of rows matching each sort key is about 159201 on average.

如果忘记向 EVALUATE_DELETE_PERFORMANCE 提供实参，它将评估您可以访问的所有投影：

=> select evaluate_delete_performance();
                          evaluate_delete_performance
---------------------------------------------------------------------------
 The following projections exhibit delete performance concerns:
        "public"."one_sort_b0"
        "public"."one_sort_b1"
See v_catalog.projection_delete_concerns for more details.
(1 row)

4.14.13.3 - GET_PROJECTION_SORT_ORDER

返回投影的 ORDER BY 子句中列的顺序。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTION_SORT_ORDER( '[[database.]schema.]projection' );

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
目标投影。

特权

非超级用户：对锚表的 SELECT 权限

示例

=> SELECT get_projection_sort_order ('store_orders_super');
                                 get_projection_sort_order
--------------------------------------------------------------------------------------------
 public.store_orders_super [Sort Cols: "order_no", "order_date", "shipper", "ship_date"]

(1 row)

4.14.13.4 - GET_PROJECTION_STATUS

返回与 projection 的状态相关的信息：

  • 数据库的当前 K-safety 状态

  • 数据库中节点的数量

  • 投影是否已分段

  • 伙伴实例投影的数量和名称

  • 投影是否安全

  • 投影是否为最新

  • 是否已经为投影计算了统计信息

使用 [GET_PROJECTION_STATUS](#) 来监控投影数据刷新的进度。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTION_STATUS ( '[[database.]schema.]projection' );

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要显示其状态的投影。

示例

=> SELECT GET_PROJECTION_STATUS('public.customer_dimension_site01');
                                     GET_PROJECTION_STATUS
-----------------------------------------------------------------------------------------------
 Current system K is 1.
# of Nodes: 4.
public.customer_dimension_site01 [Segmented: No] [Seg Cols: ] [K: 3] [public.customer_dimension_site04, public.customer_dimension_site03,
public.customer_dimension_site02]
[Safe: Yes] [UptoDate: Yes][Stats: Yes]

4.14.13.5 - GET_PROJECTIONS

返回指定锚表的投影的上下文和投影信息。

上下文信息

  • 数据库 K-safety

  • 数据库节点数

  • 此表的投影的数量

投影数据
对于每个投影，指定：

  • 所有伙伴实例投影

  • 是否分段

  • 是否 安全

  • 是否为最新。

还可以使用 GET_PROJECTIONS 来监控投影数据的刷新进度。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTIONS ( '[[database.]schema-name.]table' )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要列出的投影的锚表。

特权

无

示例

以下示例将获取有关 VMart 表 store.store_dimension 的投影的信息：

=> SELECT GET_PROJECTIONS('store.store_dimension');
-[ RECORD 1 ]---+
GET_PROJECTIONS | Current system K is 1.
# of Nodes: 3.
Table store.store_dimension has 2 projections.

Projection Name: [Segmented] [Seg Cols] [# of Buddies] [Buddy Projections] [Safe] [UptoDate] [Stats]
----------------------------------------------------------------------------------------------------
store.store_dimension_b1 [Segmented: Yes] [Seg Cols: "store.store_dimension.store_key"] [K: 1] [store.store_dimension_b0] [Safe: Yes] [UptoDate: Yes] [Stats: RowCounts]
store.store_dimension_b0 [Segmented: Yes] [Seg Cols: "store.store_dimension.store_key"] [K: 1] [store.store_dimension_b1] [Safe: Yes] [UptoDate: Yes] [Stats: RowCounts]

4.14.13.6 - PURGE_PROJECTION

从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。

有关清除操作的详细信息，请参阅 PURGE。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_PROJECTION ( '[[database.]schema.]projection' )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要清除的投影。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例将清除 Ancient History Mark 时期之前的投影 tbl_p 中的所有历史数据。

=> CREATE TABLE tbl (x int, y int);
CREATE TABLE
=> INSERT INTO tbl VALUES(1,2);
 OUTPUT
--------
      1
(1 row)

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

dbadmin=> COMMIT;
COMMIT
=> CREATE PROJECTION tbl_p AS SELECT x FROM tbl UNSEGMENTED ALL NODES;
WARNING 4468: Projection <public.tbl_p> is not available for query processing.
Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION
=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
 Starting refresh background process.
=> DELETE FROM tbl WHERE x=1;
 OUTPUT
--------
      1
(1 row)

=> COMMIT;
COMMIT
=> SELECT MAKE_AHM_NOW();
         MAKE_AHM_NOW
-------------------------------
 AHM set (New AHM Epoch: 9066)
(1 row)

=> SELECT PURGE_PROJECTION ('tbl_p');
 PURGE_PROJECTION
-------------------
 Projection purged
(1 row)

另请参阅

4.14.13.7 - REFRESH

在前台同步刷新一个或多个表投影，并更新 PROJECTION_REFRESHES 系统表。如果在不使用实参的情况下运行 REFRESH，则它会刷新所有包含过时数据的投影。

有关投影刷新的详细信息，请参阅刷新投影。

如果刷新会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REFRESH ( [ '[[database.]schema.]table[,...]' ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要刷新的投影的锚表。如果指定多个表，REFRESH 会尝试并行刷新。此类调用将包含在 Database Designer 部署（和部署脚本）中。

返回

Projection Name
作为刷新目标的投影。
Anchor Table
投影的关联锚表。
Status
投影的刷新状态：

  • queued：排队等待刷新。

  • refreshing：正在刷新。

  • refreshed：已成功完成刷新。

  • failed：未成功完成刷新。

Refresh Method
用于刷新投影的方法。
Error Count
投影刷新失败的次数。
Duration (sec)
投影刷新运行的时间（以秒为单位）。

特权

刷新方法

Vertica 可以刷新其伙伴实例之一中的投影（如有）。在这种情况下，目标投影将获取源伙伴实例的历史数据。否则，将使用刷新操作时的最新时期数据从头开始刷新投影。在这种情况下，投影不能参与刷新操作之前的任何时期的历史查询。

要确定用来刷新给定投影的方法，请查询 PROJECTION_REFRESHES 系统表中的 REFRESH_METHOD 列。

示例

以下示例将刷新两个表中的投影：

=> SELECT REFRESH('t1, t2');
                                             REFRESH
----------------------------------------------------------------------------------------
Refresh completed with the following outcomes:

Projection Name: [Anchor Table] [Status] [Refresh Method] [Error Count] [Duration (sec)]
----------------------------------------------------------------------------------------

"public"."t1_p": [t1] [refreshed] [scratch] [0] [0]"public"."t2_p": [t2] [refreshed] [scratch] [0] [0]

在以下示例中，仅刷新了一个表中的投影：

=> SELECT REFRESH('allow, public.deny, t');
                                               REFRESH
----------------------------------------------------------------------------------------

Refresh completed with the following outcomes:

Projection Name: [Anchor Table] [Status] [Refresh Method] [Error Count] [Duration (sec)]
----------------------------------------------------------------------------------------
"n/a"."n/a": [n/a] [failed: insufficient permissions on table "allow"] [] [1] [0]
"n/a"."n/a": [n/a] [failed: insufficient permissions on table "public.deny"] [] [1] [0]
"public"."t_p1": [t] [refreshed] [scratch] [0] [0]

另请参阅

4.14.13.8 - REFRESH_COLUMNS

刷新使用约束 SET USING 或 DEFAULT USING 定义的表列。与 REFRESH_COLUMNS 调用关联的所有刷新操作属于同一个事务。因此，必须刷新 REFRESH_COLUMNS 指定的所有表和列；否则，整个操作将回退。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REFRESH_COLUMNS ( 'table‑list', '[column‑list]'
   [, '[refresh‑mode ]' [, min‑partition‑key, max‑partition‑key] ]
)

参数

table‑list
要刷新的表的逗号分隔列表：

[[database.]schema.]table[,...]

column‑list
要刷新的列的逗号分隔列表，指定如下：
  • [[[database.]schema.]table.]column[,...]
  • [[database.]schema.]table.*

其中星号 (*) 指定刷新 表 中的所有 SET USING/DEFAULT USING 列。例如：

SELECT REFRESH_COLUMNS ('t1, t2', 't1.*, t2.b', 'REBUILD');

如果 column‑list 设置为空字符串 ('')，REFRESH_COLUMNS 会刷新指定表中的所有 SET USING/DEFAULT USING 列。

需要满足以下要求：

  • 所有指定列必须具有 SET USING 或 DEFAULT USING 约束。

  • 如果 REFRESH_COLUMNS 指定多个表，则所有列名必须通过其表名进行限定。如果目标表跨越多个架构，则所有列名必须通过其架构和表名完全限定。例如：

    SELECT REFRESH_COLUMNS ('t1, t2', 't1.a, t2.b', 'REBUILD');

如果指定一个数据库，它必须是当前数据库。

refresh‑mode
指定如何刷新 SET USING 列：

  • UPDATE ：将原始行标记为已删除并用新行替换它们。为了保存这些更新，您必须发出 COMMIT 语句。

  • REBUILD: 替换指定列中的所有数据。重建操作是自动提交的。

如果设置为空字符串或被忽略，则在 UPDATE 模式下执行 REFRESH_COLUMNS。如果指定多个表，则必须显式指定 REBUILD 模式。

在这两种情况下，如果任何 SET USING 列定义为 强制执行约束的表中的主键或唯一键，则 REFRESH_COLUMNS 将返回错误。

有关使用 REBUILD 选项的限制，请参阅 REBUILD 模式限制。

min‑partition‑key
max‑partition‑key
限定 REBUILD 模式，将重建操作限定在一个或多个分区。要指定分区范围，max-partition-key 必须大于 min-partition-key。要更新某个分区，两个实参必须相等。

需要满足以下要求：

  • 函数只能指定一个表进行刷新。

  • 表必须在指定的键上进行分区。

您可以使用这些实参通过最近加载的数据（即最新分区中的数据）刷新列。定期使用此选项可以显著降低因重建大型表中的整个列而产生的开销。

有关详细信息，请参阅下文中的基于分区的 REBUILD。

特权

  • 查询表和平展表的架构：USAGE

  • 查询表：SELECT

  • 平展表：SELECT、UPDATE

UPDATE 与 REBUILD 模式

通常，当对 SET USING 列数据的更改仅限于相对较少的行数时，选择 UPDATE 模式较为妥当。如果大量 SET USING 列数据过时且必须更新，请使用 REBUILD 模式。无论在任何新 SET USING 列上使用 REBUILD 调用 REFRESH_COLUMNS 都是一种很好的做法 — 例如，在使用 ALTER TABLE...ADD COLUMN 添加 SET USING 列之后对其进行填充。

REBUILD 模式限制

如果在 SET USING 列上调用 REFRESH_COLUMNS 并将刷新模式指定为 REBUILD，则 Vertica 会在以下任何一项中指定该列时返回错误：

基于分区的 REBUILD 操作

如果对平展表进行分区，则可通过指定一个或多个分区键来降低在 REBUILD 模式下调用 REFRESH_COLUMNS 的开销。这样做会将重建操作限制到指定的分区。例如，通过 SET USING 列 cust_name 定义表 public.orderFact。此表在列 order_date 上进行分区，其中分区子句调用 Vertica 函数 CALENDAR_HIERARCHY_DAY。因此，您可以对此表的特定时间分隔分区调用 REFRESH_COLUMNS — 在本例中，是指对过去两个月的订单调用：

=> SELECT REFRESH_COLUMNS ('public.orderFact',
                        'cust_name',
                        'REBUILD',
                        TO_CHAR(ADD_MONTHS(current_date, -2),'YYYY-MM')||'-01',
                        TO_CHAR(LAST_DAY(ADD_MONTHS(current_date, -1))));
      REFRESH_COLUMNS
---------------------------
 refresh_columns completed
(1 row)

重写 SET USING 查询

当您在平展表的 SET USING（或 DEFAULT USING）列中调用 REFRESH_COLUMNS 时，它将通过联接目标表和源表来执行 SET USING 查询。默认情况下，源表始终为联接的内表。大多数情况下，源表的基数小于目标表，因此 REFRESH_COLUMNS 有效地执行联接。

有时，特别是当您在分区表上调用 REFRESH_COLUMNS 时，源表有可能比目标表更大。在这种情况下，联接操作的性能可能欠佳。

您可以通过启用配置参数 RewriteQueryForLargeDim 来解决此问题。启用 (1) 后，Vertica 将反转目标表和源表之间的内部和外部联接，以此重写查询。

示例

请参阅 修整表示例 和 DEFAULT 与 SET USING。

4.14.13.9 - START_REFRESH

使用各自 锚表的最新数据刷新 当前架构中的投影。START_REFRESH 在后台异步运行，并更新PROJECTION_REFRESHES 系统表。正在运行刷新时，则此函数无效。

要仅刷新特定表的投影，请使用 REFRESH。当通过 Database Designer 部署设计 时，将自动刷新其投影。

如果刷新会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REFRESH()

特权

无

要求

所有节点必须开启。

刷新方法

Vertica 可以刷新其伙伴实例之一中的投影（如有）。在这种情况下，目标投影将获取源伙伴实例的历史数据。否则，将使用刷新操作时的最新时期数据从头开始刷新投影。在这种情况下，投影不能参与刷新操作之前的任何时期的历史查询。

要确定用来刷新给定投影的方法，请查询 PROJECTION_REFRESHES 系统表中的 REFRESH_METHOD 列。

示例

=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
 Starting refresh background process.
(1 row)

另请参阅

4.14.14 - 会话函数

此部分包含 Vertica 专用的会话管理函数。

另请参阅 SQL 系统表 V_MONITOR.SESSIONS。

4.14.14.1 - CANCEL_REFRESH

取消 START_REFRESH 和 REFRESH 启动的刷新相关内部操作。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_REFRESH()

特权

无

注意

  • 刷新任务在内部会话的后台线程中运行，因此不能使用 INTERRUPT_STATEMENT 取消这些语句。相反，使用 CANCEL_REFRESH 取消通过刷新相关内部会话运行的语句。

  • 在启动 START_REFRESH() 的同一节点上运行 CANCEL_REFRESH()。

  • CANCEL_REFRESH() 取消在节点上运行的刷新操作，等待完成取消并返回 SUCCESS。

  • 任何时候，一个节点上都只能运行一组刷新操作。

示例

取消后台执行的刷新操作。

=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
Starting refresh background process.
(1 row)

=> SELECT CANCEL_REFRESH();
              CANCEL_REFRESH
----------------------------------------
Stopping background refresh process.
(1 row)

另请参阅

4.14.14.2 - CLOSE_ALL_SESSIONS

关闭所有外部会话（除发布此函数的外部会话以外）。关闭 Vertica 数据库之前调用此函数。

Vertica 异步关闭会话，因此可以在返回此函数之前打开其他会话。在这种情况下，请重新发出此函数。要查看所有打开会话的状态，请查询系统表 SESSIONS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_ALL_SESSIONS()

特权

非超级用户：设置为“无 (None)”以关闭自己的会话

示例

在单独的节点上打开两个用户会话：

=> SELECT * FROM sessions;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0002
user_name                  | dbadmin
client_hostname            | 127.0.0.1:57174
client_pid                 | 30117
login_timestamp            | 2011-01-03 15:33:00.842021-05
session_id                 | stress05-27944:0xc1a
client_label               |
transaction_start          | 2011-01-03 15:34:46.538102
transaction_id             | -1
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n';)
statement_start            | 2011-01-03 15:34:46.538862
statement_id               |
last_statement_duration_us | 26250
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n';
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 3 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               |
last_statement_duration_us | 1591403
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

关闭所有会话：

=> \x
Expanded display is off.
=> SELECT CLOSE_ALL_SESSIONS();
                           CLOSE_ALL_SESSIONS
-------------------------------------------------------------------------
 Close all sessions command sent. Check v_monitor.sessions for progress.
(1 row)

发出 CLOSE_ALL_SESSIONS 之后的会话内容：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (SELECT * FROM sessions;)
statement_start            | 2011-01-03 16:19:56.720071
statement_id               | 25
last_statement_duration_us | 15605
current_statement          | SELECT * FROM SESSIONS;
ssl_state                  | None
authentication_method      | Trust

另请参阅

4.14.14.3 - CLOSE_SESSION

中断指定的外部会话，回退当前事务（如果有），并关闭套接字。您只能关闭自己的会话。

关闭会话可能需要花费一些时间。要查看所有打开会话的状态，请查询系统表 SESSIONS。

有关会话管理选项的详细信息，请参阅 管理会话。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_SESSION ( 'sessionid')

参数

sessionid
指定要关闭的会话的字符串。此标识符在群集的任何时间点都唯一，但是可以在会话关闭时重复使用。

特权

无

示例

用户会话已打开。记录 2 显示运行 COPY DIRECT 语句的用户会话。

=> SELECT * FROM sessions;
-[ RECORD 1 ]--------------+-----------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (SELECT * FROM sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+-----------------------------------------------
node_name                  | v_vmartdb_node0002
user_name                  | dbadmin
client_hostname            | 127.0.0.1:57174
client_pid                 | 30117
login_timestamp            | 2011-01-03 15:33:00.842021-05
session_id                 | stress05-27944:0xc1a
client_label               |
transaction_start          | 2011-01-03 15:34:46.538102
transaction_id             | -1
transaction_description    | user dbadmin (COPY ClickStream_Fact FROM
                             '/data/clickstream/1g/ClickStream_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:34:46.538862
statement_id               |
last_statement_duration_us | 26250
current_statement          | COPY ClickStream_Fact FROM '/data/clickstream
                             /1g/ClickStream_Fact.tbl' DELIMITER '|' NULL
                             '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

关闭用户会话 stress05-27944:0xc1a

=> \x
Expanded display is off.
=> SELECT CLOSE_SESSION('stress05-27944:0xc1a');
                           CLOSE_SESSION
--------------------------------------------------------------------
 Session close command sent. Check v_monitor.sessions for progress.
(1 row)

再次查询会话表以了解当前状态，您可以看到第二个会话已被关闭：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+--------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from SESSIONS;)
statement_start            | 2011-01-03 16:12:07.841298
statement_id               | 20
last_statement_duration_us | 2099
current_statement          | SELECT * FROM SESSIONS;
ssl_state                  | None
authentication_method      | Trust

另请参阅

4.14.14.4 - CLOSE_USER_SESSIONS

停止用户会话，回退当前正在运行的任何事务，并关闭连接。要确定要关闭的会话的状态，请查询 SESSIONS 表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_USER_SESSIONS ( 'user‑name' )

参数

user‑name
指定要关闭其会话的用户。如果指定自己的用户名，Vertica 将关闭所有会话，但发出此函数的会话除外。

特权

DBADMIN

示例

此示例将关闭用户 u1 的所有活动会话：

=> SELECT close_user_sessions('u1');

另请参阅

4.14.14.5 - GET_NUM_ACCEPTED_ROWS

返回在当前会话的上一个已完成加载中加载到数据库的行数。GET_NUM_ACCEPTED_ROWS 是一个 元函数。请勿将其用作 INSERT 查询中的值。

对于当前正在处理的加载，无法获得已接受的行数。在 LOAD_STREAMS 系统表中检查其状态。

此元函数支持来自 STDIN 的负载、来自 Vertica 客户端的 COPY LOCAL 或发起程序上的单个文件。对于多节点加载，无法使用 GET_NUM_ACCEPTED_ROWS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_NUM_ACCEPTED_ROWS();

特权

无

示例

此示例显示了 vmart_load_data.sql 元命令接受的行数。

=> \i vmart_load_data.sql;

=> SELECT GET_NUM_ACCEPTED_ROWS ();
GET_NUM_ACCEPTED_ROWS
-----------------------
300000
(1 row)

另请参阅

4.14.14.6 - GET_NUM_REJECTED_ROWS

返回在当前会话的上一个已完成加载期间拒绝的行数。GET_NUM_REJECTED_ROWS 是一个 元函数。请勿将其用作 INSERT 查询中的值。

对于当前正在运行的加载，已拒绝的行的信息不可用。对于当前正在处理的加载，无法获得拒绝的行数。在 LOAD_STREAMS 系统表中检查其状态。

此元函数支持来自 STDIN 的负载、来自 Vertica 客户端的 COPY LOCAL 或发起程序上的单个文件。对于多节点加载，无法使用 GET_NUM_REJECTED_ROWS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_NUM_REJECTED_ROWS();

特权

无

示例

此示例显示了 vmart_load_data.sql 元命令拒绝的行数。

=>  \i vmart_load_data.sql

=> SELECT GET_NUM_REJECTED_ROWS ();
GET_NUM_REJECTED_ROWS
-----------------------
0
(1 row)

另请参阅

4.14.14.7 - INTERRUPT_STATEMENT

中断用户会话中的指定语句，回滚当前事务，把成功/失败消息写入日志文件。

执行语句过程中可以中断会话。中断只可针对用户会话运行的语句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INTERRUPT_STATEMENT( 'session‑id', statement‑id)

参数

session‑id
标识要中断的会话。在任何时间点，群集标识符都是唯一的。
statement‑id
标识要中断的语句。如果 statement‑id 有效，则可中断语句，INTERRUPT_STATEMENT 将返回成功消息。否则，系统将返回错误消息：

超级用户

消息

你可能会遇到的消息列表见下文：

示例

两个用户对话是打开状态。RECORD 1 表示用户会话正在运行 SELECT FROM SESSION，RECORD 2 表示用户会话正在运行 COPY DIRECT：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               | 5
last_statement_duration_us | 1591403
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

中断会话 stress06-25663:0xbec 中运行的 COPY DIRECT 语句：

=> \x
Expanded display is off.
=> SELECT INTERRUPT_STATEMENT('stress06-25663:0x1537', 5);
                       interrupt_statement
------------------------------------------------------------------
 Statement interrupt sent. Check v_monitor.sessions for progress.
(1 row)

确认语句已被成功中断，不再处于激活状态。可检查 SESSIONS 系统表中的 current_statement 列。语句被中断后，该列为空：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               | 5
last_statement_duration_us | 1591403
current_statement          |
ssl_state                  | None
authentication_method      | Trust

另请参阅

4.14.14.8 - RELEASE_ALL_JVM_MEMORY

强制所有会话释放其 Java 虚拟机 (JVM) 所用的内存。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_ALL_JVM_MEMORY();

特权

必须为 超级用户。

示例

以下示例演示了查看所有打开的会话中的 JVM 内存使用情况，然后调用 RELEASE_ALL_JVM_MEMORY() 释放内存的过程：

=> select user_name,external_memory_kb FROM V_MONITOR.SESSIONS;
 user_name | external_memory_kb
-----------+---------------
 dbadmin   |         79705
(1 row)

=> SELECT RELEASE_ALL_JVM_MEMORY();
                           RELEASE_ALL_JVM_MEMORY
-----------------------------------------------------------------------------
 Close all JVM sessions command sent. Check v_monitor.sessions for progress.
(1 row)

=> SELECT user_name,external_memory_kb FROM V_MONITOR.SESSIONS;
 user_name | external_memory_kb
-----------+---------------
 dbadmin   |             0
(1 row)

另请参阅

4.14.14.9 - RELEASE_JVM_MEMORY

终止 Java 虚拟机 (JVM)，使 JVM 所用的内存变为可用状态。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_JVM_MEMORY();

特权

无。

示例

用户会话已打开。RECORD 2 将显示运行 COPY DIRECT 语句的用户会话。

=> SELECT RELEASE_JVM_MEMORY();

           release_jvm_memory

-----------------------------------------
Java process killed and memory released

(1 row)

另请参阅

4.14.14.10 - RESERVE_SESSION_RESOURCE

保留 General 资源池中的内存资源，以仅供 Vertica 备份和还原进程使用。其他任何 Vertica 进程都不能访问保留的资源。如果可用的资源量不足，Vertica 会将保留请求排入队列。

此元函数是会话级别的保留。当会话结束时，Vertica 会自动释放该会话中保留的任何资源。由于该元函数在会话级别运行，因此多个会话之间的资源名称无需唯一确定。

可通过查询 SESSIONS 表来查看保留的资源。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESERVE_SESSION_RESOURCE ( 'name', memory)

参数

name
要保留的资源的名称。
memory
要分配给资源的内存量（以 KB 为单位）。

特权

无

示例

将 1024 KB 的内存保留用于备份和还原进程：

=> SELECT reserve_session_resource('VBR_RESERVE',1024);
   -[ RECORD 1 ]------------+----------------
   reserve_session_resource | Grant succeed

4.14.14.11 - RESET_SESSION

将默认的连接字符串配置设置应用于当前会话。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESET_SESSION()

示例

以下示例显示了如何使用 RESET_SESSION。

将当前客户端连接字符串重置为默认的连接字符串设置：

=> SELECT RESET_SESSION();
    RESET_SESSION
----------------------
 Reset session: done.
(1 row)

4.14.15 - 存储函数

此部分包含 Vertica 专用的存储管理函数。

4.14.15.1 - ALTER_LOCATION_LABEL

将标签添加到存储位置，或者更改或移除现有标签。如果任何存储策略未指定位置标签，则可进行更改。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ALTER_LOCATION_LABEL ( 'path' , '[node]' , '[location‑label]' )

参数

路径
存储位置路径。
节点
应用标签更改的节点。如果提供空字符串，Vertica 会将更改应用于所有群集节点。
location‑label
要分配给指定存储位置的标签。如果提供空字符串，Vertica 会移除该存储位置的标签。

超级用户

限制

只有当这两个条件都为真时，您才能移除位置标签：

  • 未在数据库对象的存储策略中指定标签。

  • 标记的位置不是其关联对象的最后一个可用存储。

示例

以下 ALTER_LOCATION_LABEL 语句将标签 SSD 应用于存储位置 /home/dbadmin/SSD/tables 的所有群集节点：

=> SELECT ALTER_LOCATION_LABEL('/home/dbadmin/SSD/tables','', 'SSD');
          ALTER_LOCATION_LABEL
---------------------------------------
 /home/dbadmin/SSD/tables label changed.
(1 row)

另请参阅

4.14.15.2 - ALTER_LOCATION_USE

更改存储位置保存的数据类型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ALTER_LOCATION_USE ( 'path' , '[node]' , 'usage' )

参数

路径
挂载存储位置的位置。
节点
要更改存储位置的 Vertica 节点。要在单个事务中更改所有群集节点的位置，请使用空字符串 ('')。如果 usage 为 SHARED TEMP 或 SHARED USER，则必须在所有节点上进行更改。
usage
以下几项之一：

  • DATA：该存储位置仅存储数据文件。

  • TEMP：该位置仅存储加载或查询期间创建的临时文件。

  • DATA,TEMP：该位置可同时存储两种类型的文件。

超级用户

您不能更改 USER 使用类型的存储位置（如果存储位置是以这种方式创建的），也不能将存储位置更改为 USER 类型（如果存储位置不是以这种方式创建的）。可以更改 USER 存储位置以指定 DATA（不支持存储 TEMP 文件）。但是，这样做不会影响 USER 存储位置的主要目标可由具有已分配权限的非 dbadmin 用户访问。

您不能将存储位置从 SHARED TEMP 或 SHARED USER 更改为 SHARED DATA，反之亦然。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

以下示例将跨所有群集节点将存储位置更改为仅存储数据：

=> SELECT ALTER_LOCATION_USE ('/thirdSL/' , '' , 'DATA');

另请参阅

4.14.15.3 - CLEAR_CACHES

清除 Vertica 内部缓存文件。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_CACHES ( )

超级用户

注意

如果要为查询运行基准测试，除清除内部 Vertica 缓存文件之外，还要清除 Linux 文件系统缓存。内核使用未分配的内存作为缓存以保持磁盘块纯净。如果运行的是 Linux 2.6.16 或更高版本且具有 root 访问权限，则可清除内核文件系统缓存，如下所示：

  1. 确保缓存中的所有数据均已写入磁盘：

    # sync

  2. 写入 drop_caches 文件会导致内核从内存中删除干净缓存、条目和 iNode，使该内存进入空闲状态，如下所示：

    • 要清除页面缓存，请执行以下操作：

      # echo 1 > /proc/sys/vm/drop_caches

    • 要清除条目和 iNode，请执行以下操作：

      # echo 2 > /proc/sys/vm/drop_caches

    • 要清除页面缓存、条目和 iNode，请执行以下操作：

      # echo 3 > /proc/sys/vm/drop_caches

示例

以下示例清除 Vertica 内部缓存文件：

=> SELECT CLEAR_CACHES();
 CLEAR_CACHES
--------------
 Cleared
(1 row)

4.14.15.4 - CLEAR_OBJECT_STORAGE_POLICY

从指定的数据库、架构或表中移除用户定义的存储策略。先前策略标记位置的存储容器将移动到默认位置。默认情况下，此移动发生在所有挂起的合并任务返回之后。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] [, 'enforce‑storage‑move' ] )

参数

object‑name
要清除的对象，为以下之一：

  • database：清除存储策略的 database。

  • [database.]schema: 清除存储策略的 schema。

  • [[database.]schema.]table: 清除存储策略的 table。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。

在所有情况下，database 必须为当前数据库的名称。

key‑min
key‑max
仅当 object‑name 为表时有效，指定存储在标记位置的表分区键值的范围。
enforce‑storage‑move
指定 Tuple Mover 将指定对象的所有现有存储容器移动到其默认存储位置的时间：

  • false （默认值）：仅在所有待定合并任务返回后移动存储容器。

  • true：立即将所有存储容器移动到新位置。

超级用户

示例

以下语句可清除表 store.store_orders_fact 的存储策略。true 实参指定立即实施移动策略：

=> SELECT CLEAR_OBJECT_STORAGE_POLICY ('store.store_orders_fact', 'true');
                         CLEAR_OBJECT_STORAGE_POLICY
-----------------------------------------------------------------------------
 Object storage policy cleared.
Task: moving storages
(Table: store.store_orders_fact) (Projection: store.store_orders_fact_b0)
(Table: store.store_orders_fact) (Projection: store.store_orders_fact_b1)

(1 row)

另请参阅

4.14.15.5 - DO_TM_TASK

运行 Tuple Mover (TM) 操作并提交当前事务。您可以将此操作限定于特定表或投影。开始使用此函数时，TM 会使用 GENERAL 资源池而不是 TM 资源池。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DO_TM_TASK('task'[, '[[database.]schema.]{ table | projection}]' )

参数

task
指定以下 Tuple Mover 操作之一：

  • mergeout：合并 ROS 容器并清除删除的记录。有关详细信息，请参阅合并。

  • reshardmergeout：重新调整存储容器，使其符合通过 RESHARD_DATABASE 调用创建的分片定义。指定表或投影以及分区值范围，限制 reshardmergeout 操作的范围。

  • analyze_row_count：收集一组最少的统计信息并聚合指定投影的行计数，然后将其保存在数据库编录中。收集指定投影中的行数。如果指定一个表名，DO_TM_TASK 会返回该表所有投影的行计数。有关详细信息，请参阅分析行计数。

  • update_storage_catalog （仅推荐用于 Eon 模式）：使用捆绑表数据的元数据更新编录。有关详细信息，请参阅将捆绑包元数据写入编录。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table | projection
将 task 应用到指定表或投影。如果指定了投影，但未查找到该投影，则 DO_TM_TASK 会查找具有该名称的表，如果能够找到，则会将任务应用至该表及与该表相关联的所有投影。

如果未指定表或投影，则会将该任务应用于所有数据库表及其投影。

特权

  • 架构：USAGE

  • 表：INSERT、UPDATE 或 DELETE 之一

示例

以下示例对表中的所有投影执行合并：

=> SELECT DO_TM_TASK('mergeout', 't1');

您可以对表的一系列分区执行重新分片合并任务：

=> SELECT DO_TM_TASK('reshardmergeout', 'store_orders', '2001', '2005');

4.14.15.6 - DROP_LOCATION

永久移除已停用的存储位置。此操作无法撤消。必须先使用 RETIRE_LOCATION 停用存储位置，然后再将其删除；不能删除正在使用的存储位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_LOCATION ( 'path', 'node' )

参数

路径
要删除的存储位置所挂载的位置。
节点
要在其上删除位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。

超级用户

带有临时文件和数据文件的存储位置

如果使用某存储位置来存储数据，之后将其更改为仅存储临时文件，则该位置仍会包含数据文件。Vertica 不允许删除含数据文件的存储位置。您可以使用 MOVE_RETIRED_LOCATION_DATA 函数手动合并存储位置中的数据文件，或者您也可以删除分区。删除数据文件操作无效。

示例

下列示例展示如何删除 v_vmart_node0003 上之前停用的存储位置：

=> SELECT DROP_LOCATION('/data', 'v_vmart_node0003');

另请参阅

4.14.15.7 - ENFORCE_OBJECT_STORAGE_POLICY

仅限企业模式

立即应用指定对象的存储策略。默认情况下，Tuple Mover 在所有挂起的合并操作完成后强制执行对象存储策略。调用此函数相当于在使用 RETIRE_LOCATION 时设置 enforce 实参。此函数通常用作删除存储位置前的最后一步。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENFORCE_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] )

参数

object‑name
要应用其存储策略的数据库对象，为以下之一：

  • database：应用 database 存储策略。

  • [database.]schema: 应用 schema 存储策略。

  • [[database.]schema.]table: 应用 table存储策略。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。

在所有情况下，database 必须为当前数据库的名称。

key‑min, key‑max
仅当 object‑name 为表时有效，指定要执行移动的表分区键值的范围。

特权

以下几项之一：

  • 超级用户

  • 对象所有者及对其存储位置的访问权限。

示例

将存储策略更新应用于 test 表：

=> SELECT ENFORCE_OBJECT_STORAGE_POLICY ('test');

另请参阅

4.14.15.8 - MEASURE_LOCATION_PERFORMANCE

测量存储位置的磁盘性能。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MEASURE_LOCATION_PERFORMANCE ( 'path', 'node' )

参数

路径
指定测量的存储位置。
节点
测量位置可用的 Vertica 节点。要获取群集上所有节点名称的列表，请查询系统表 DISK_STORAGE。

超级用户

注意

  • 如果您试图基于预测或测量访问模式，创建将投影、列和分区存储在不同磁盘的磁盘分层结构，您需要对每一个存放数据的存储位置的性能进行测量。您无需测量临时数据存储位置的性能，因为临时文件基于可用空间进行存储。

  • 测量存储位置性能的方法仅适用于已配置的群集。如果您想在配置群集以前测量磁盘，请参阅 测量存储性能。

  • 存储位置性能等同于从磁盘读取写入 1MB 数据所耗费的时长。这个时间等同于：

    IO‑time = (time‑to‑read‑write‑1MB + time‑to‑seek) = (1/throughput + 1/latency)

    吞吐量为顺序读写的平均吞吐量（以每秒兆字节表示）。

    延迟适用于随机读取（仅在查找中，单位为每秒查找次数）。

示例

下面的例子测量 v_vmartdb_node0004 上的一个存储位置的性能：

=> SELECT MEASURE_LOCATION_PERFORMANCE('/secondVerticaStorageLocation/' , 'v_vmartdb_node0004');
WARNING:  measure_location_performance can take a long time. Please check logs for progress
           measure_location_performance
--------------------------------------------------
 Throughput : 122 MB/sec. Latency : 140 seeks/sec

另请参阅

4.14.15.9 - MOVE_RETIRED_LOCATION_DATA

从数据库中指定的停用存储位置或从全部停用存储位置移出全部数据。 MOVE_RETIRED_LOCATION_DATA 根据存储数据对象的存储策略，将数据移动至非停用存储位置。此函数仅在完成所有受影响的存储位置数据的迁移后才返回。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVE_RETIRED_LOCATION_DATA( ['location‑path'] [, 'node'] )

参数

location‑path
系统表 STORAGE_LOCATIONS 的 LOCATION_PATH 列所指定的存储位置的路径。此存储位置必须标记为已停用。

如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有停用的存储位置移出数据。

节点
要在其上移动停用存储位置的数据的节点。如果 node 上未定义 location-path，则此函数返回错误。

如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有节点的 location-path 移出数据。

超级用户

示例

  1. 查询系统表 STORAGE_LOCATIONS，显示停用的存储位置：

    => SELECT node_name, location_path, location_label, is_retired FROM STORAGE_LOCATIONS
   WHERE is_retired = 't';
    node_name     |    location_path     | location_label | is_retired
------------------+----------------------+----------------+------------
 v_vmart_node0001 | /home/dbadmin/SSDLoc | ssd            | t
 v_vmart_node0002 | /home/dbadmin/SSDLoc | ssd            | t
 v_vmart_node0003 | /home/dbadmin/SSDLoc | ssd            | t
(3 rows)

  2. 查询系统表 STORAGE_LOCATIONS 获取消息表的位置，消息表目前存储在停用存储位置 ssd：

    => SELECT node_name, total_row_count, location_label FROM STORAGE_CONTAINERS
   WHERE projection_name ILIKE 'messages%';
    node_name     | total_row_count | location_label
------------------+-----------------+----------------
 v_vmart_node0001 |          333514 | ssd
 v_vmart_node0001 |          333255 | ssd
 v_vmart_node0002 |          333255 | ssd
 v_vmart_node0002 |          333231 | ssd
 v_vmart_node0003 |          333231 | ssd
 v_vmart_node0003 |          333514 | ssd
(6 rows)

  3. 调用 MOVE_RETIRED_LOCATION_DATA，将数据移出 ssd 存储位置。

    => SELECT MOVE_RETIRED_LOCATION_DATA('/home/dbadmin/SSDLoc');
          MOVE_RETIRED_LOCATION_DATA
-----------------------------------------------
 Move data off retired storage locations done

(1 row)

  4. 重复前述查询，验证消息表的存储位置：

    
=> SELECT node_name, total_row_count, storage_type, location_label FROM storage_containers
   WHERE projection_name ILIKE 'messages%';
    node_name     | total_row_count | location_label
------------------+-----------------+----------------
 v_vmart_node0001 |          333255 | base
 v_vmart_node0001 |          333514 | base
 v_vmart_node0003 |          333514 | base
 v_vmart_node0003 |          333231 | base
 v_vmart_node0002 |          333231 | base
 v_vmart_node0002 |          333255 | base
(6 rows)

另请参阅

4.14.15.10 - RESTORE_LOCATION

恢复之前使用 RETIRE_LOCATION 停用的存储位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESTORE_LOCATION ( 'path', 'node' )

参数

路径
挂载停用的存储位置的位置。
节点
要在其上还原位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。

如果删除任何位置，该操作将会失败。

超级用户

还原之前停用的位置的影响

在还原存储位置之后，Vertica 会对所有群集存储位置重新排名。它将使用新恢复的位置来处理根据其排名确定的查询。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

在 node4 上还原停用的存储位置：

=> SELECT RESTORE_LOCATION ('/thirdSL/' , 'v_vmartdb_node0004');

另请参阅

4.14.15.11 - RETIRE_LOCATION

停用指定的存储位置。要获取所有现有存储位置的列表，请查询 STORAGE_LOCATIONS 系统表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RETIRE_LOCATION ( 'path', 'node' [, enforce ] )

参数

路径
要停用的存储位置所挂载的位置。
节点
要在其上停用位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。
enforce
如果为 true，位置标签将设为空字符串，并且将数据移到其他位置。然后可以删除该位置，而不会出现错误或警告。使用此实参加快删除位置。

超级用户

停用存储位置的影响

RETIRE_LOCATION 检查确认该位置不是唯一的数据和临时文件存储。每个节点上必须至少存在一个用于存储数据和临时文件的位置。但可以将这两种文件存储在同一位置或单独的位置。

如果某个位置是最后一个可用于存储其关联对象的位置，则只有将 enforce 设置为 true 才能将其停用。

在停用存储位置时：

  • 停用的位置不会存储任何新数据，除非首先使用 RESTORE_LOCATION 对其进行还原。

  • 默认情况下，如果当前停用的存储位置包含存储的数据，该数据将不会移动。因此不能删除该存储位置。相反，Vertica 将通过一次或多次合并来移除存储的数据。要在停用位置后立即将其删除，请将 enforce 设置为 true。

  • 如果当前停用的存储位置仅用于临时文件，或者使用了 enforce，则可以删除该位置。请参阅 删除存储位置 和 DROP_LOCATION。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

以下示例显示了停用存储位置的两种方法：

您可以停用存储位置，未来将自动移出其数据：

=> SELECT RETIRE_LOCATION ('/data' , 'v_vmartdb_node0004');

您可以指定存储位置中要立即移动的数据，这样无需等待即可删除该位置：

=> SELECT RETIRE_LOCATION ('/data' , 'v_vmartdb_node0004', true);

另请参阅

4.14.15.12 - SET_LOCATION_PERFORMANCE

设置存储位置的磁盘性能。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_LOCATION_PERFORMANCE ( 'path', 'node' , 'throughput', 'average‑latency')

参数

路径
指定要设置的存储位置的装载位置。
节点
指定存在要设置的位置的 Vertica 节点。
throughput
指定位置的吞吐量，设置为值 ≥1。
average‑latency
指定位置的平均延迟，设置为值 ≥1。

超级用户

示例

以下示例将 node2 上的存储位置性能设置为每秒吞吐 122 MB 和每秒延迟 140 次寻道。

=> SELECT SET_LOCATION_PERFORMANCE('/secondVerticaStorageLocation/','node2','122','140');

另请参阅

4.14.15.13 - SET_OBJECT_STORAGE_POLICY

通过为数据库对象分配一个标记存储位置来创建或更改其存储策略。Tuple Mover 使用此位置存储此对象的新数据和现有数据。如果对象已具有活动存储策略，调用 SET_OBJECT_STORAGE_POLICY 会将此对象的默认存储设置为新的标记位置。对象的现有数据将移动到新位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_OBJECT_STORAGE_POLICY (
  '[[database.]schema.]object‑name', 'location‑label'
   [,'key‑min', 'key‑max'] [, 'enforce‑storage‑move' ] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

object‑name
识别分配到标记存储位置的数据库对象。object‑name 可以解析为数据库、架构或表。
location‑label
object-name 的存储位置的标签。
key‑min
key‑max
仅当 object‑name 为表时有效，指定存储在标记位置的表分区键值的范围。
enforce‑storage‑move
指定 Tuple Mover 将 object‑name 的所有现有存储容器移动到标记存储位置的时间：

  • false （默认值）：仅在所有待定合并任务返回后移动存储容器。

  • true：立即将所有存储容器移动到新位置。

特权

以下几项之一：

  • 超级用户

  • 对象所有者及对其存储位置的访问权限。

示例

请参阅 清除存储策略

另请参阅

4.14.16 - 表函数

此部分包含用于管理表和约束的函数。

另请参阅 V_CATALOG.TABLE_CONSTRAINTS 系统表。

4.14.16.1 - ANALYZE_CONSTRAINTS

在指定范围内分析和报告约束违规

您可以在执行 INSERT、UPDATE、MERGE 或 COPY 语句时启用自动强制执行主键约束、唯一键约束和检查约束。另外，您可以在发出这些语句后使用 ANALYZE_CONSTRAINTS 验证约束。参考约束强制执行了解更多信息。

ANALYZE_CONSTRAINTS 以 SELECT * FROM t1 持有表 t1 的锁定的相同方式执行锁定。有关其他信息，请参阅 LOCKS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_CONSTRAINTS ('[[[database.]schema.]table ]' [, 'column[,...]'] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
标识要分析的表。如果忽略指定架构，Vertica 将使用当前架构搜索路径。如果设置为空字符串，Vertica 将分析当前架构中的所有表。
列
table 中要分析的列。可以指定多个逗号分隔列。Vertica 将分析范围缩小到指定的列。如果忽略指定列，Vertica 将分析 table 中的所有列。

特权

  • 架构：USAGE

  • 表：SELECT

在加载进程中检测约束违规

Vertica 在运行查询（而不是加载数据）时检查约束违规。要在加载进程中检测违反约束，使用 COPY 语句的 NO COMMIT 选项。通过加载数据但不提交数据，可以使用 ANALYZE_CONSTRAINTS 函数对数据执行加载后检查。如果此函数发现违反约束，由于您尚未提交数据，因此可以回退加载。

如果 ANALYZE_CONSTRAINTS 发现冲突，比如当您在主键中插入一个重复值时，则可以使用以下函数更正错误。效果仅持续到会话结束为止：

返回值

ANALYZE_CONSTRAINTS 返回一个结构集中的结果（参阅下表），其中列出造成违规的架构名称、表名称、列名称、约束名称、约束类型和列值。

如果结果集为空，则不存在违反约束；例如：

> SELECT ANALYZE_CONSTRAINTS ('public.product_dimension', 'product_key');
Schema Name | Table Name | Column Names | Constraint Name | Constraint Type | Column Values
-------------+------------+--------------+-----------------+-----------------+---------------
(0 rows)

下面的结果集显示主键冲突，以及导致冲突的值 ('10')：

=> SELECT ANALYZE_CONSTRAINTS ('');
Schema Name | Table Name | Column Names | Constraint Name | Constraint Type | Column Values
-------------+------------+--------------+-----------------+-----------------+---------------
store         t1           c1             pk_t1             PRIMARY           ('10')
(1 row)

结果集列在下表中详细描述：

示例

请参阅检测约束违规。

4.14.16.2 - ANALYZE_CORRELATIONS

分析紧密相关的列对的指定表。ANALYZE_CORRELATIONS 存储相关性最强的 20 对。ANALYZE_CORRELATIONS 还分析统计信息。

ANALYZE_CORRELATIONS 只能分析成对的单列相关。

例如，州名与国家/地区名称列紧密相关，因为通过市名通常（但并非始终）可以确认州名。康舍霍肯市与宾夕法尼亚州唯一相关，相比较而言，佐治亚州、印地安那州、肯塔基州、纽约州、弗吉尼亚州和马萨诸塞州则都有波士顿市。在本例中，市名与州名紧密相关。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

ANALYZE_CORRELATIONS ('[[[database.]schema.]table ]' [, 'recalculate'] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table-name
标识要分析的表。如果忽略指定架构，Vertica 将使用当前架构搜索路径。如果设置为空字符串，Vertica 将分析当前架构中的所有表。
recalculate
布尔值，指定是否分析之前已分析的相关列。

默认值： false

特权

以下几项之一：

示例

在下例中，ANALYZE_CORRELATIONS 分析 public 架构中所有表的列相关，即使当前不存在相关性：

=> SELECT ANALYZE_CORRELATIONS ('public.*', 'true');
 ANALYZE_CORRELATIONS
----------------------
                    0
(1 row)

4.14.16.3 - COPY_TABLE

将一个表复制到另一个表。此轻量级内存函数从源表复制 DDL 及所有用户创建的投影。同时，还会复制源表的投影统计信息。因此，源表和目标表最初具有相同的定义并共享同一个存储。

完成复制操作后，源表与复制表相互独立，因此可以对一个表执行 DML 操作而不会影响另一个表。这些操作可增加两个表所需的存储总量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COPY_TABLE (
    '[[database.]schema.]source-table',
    '[[database.]schema.]target-table'
)

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

source‑table
要复制的源表。Vertica 将此表中的所有数据复制到目标表。
目标表
源表的目标表。如果目标表已存在，Vertica 会将源附加到现有表。

如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。

特权

非超级用户：

  • 源表：SELECT

  • 目标架构/表（新建）： CREATE

  • 目标表（现有）：INSERT

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区表达式

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。

  • 文本索引的数量和定义。

  • 如果目标表已存在，则源表和目标表必须具有相同的访问策略。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 如果源表包含序列，Vertica 会先将序列转换为整数，然后再将其复制到目标表。如果目标表包含自动增量、标识或命名序列列，Vertica 将取消复制并显示错误消息。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

如果调用 COPY_TABLE 且目标表不存在，该函数将自动创建此表。在下例中，COPY_TABLE 创建目标表 public.newtable。Vertica 还会复制与源表 public.product_dimension 关联的所有约束，外键约束除外：

=> SELECT COPY_TABLE ( 'public.product_dimension', 'public.newtable');
-[ RECORD 1 ]--------------------------------------------------
copy_table | Created table public.newtable.
Copied table public.product_dimension to public.newtable

另请参阅

从其他表创建表

4.14.16.4 - DISABLE_DUPLICATE_KEY_ERROR

禁止 Vertica 在运行时找到重复主键值或唯一键值的情况下传送错误消息（与未自动启用的键约束一起使用）。视作架构不定义有任何约束，执行查询。影响限定在会话范围内。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISABLE_DUPLICATE_KEY_ERROR();

超级用户

示例

当您调用 DISABLE_DUPLICATE_KEY_ERROR 时，Vertica 会发出警告，通知您将忽略重复值，且结果可能会不正确。 DISABLE_DUPLICATE_KEY_ERROR 仅用于未自动启用的键约束。

=> select DISABLE_DUPLICATE_KEY_ERROR();
WARNING 3152:  Duplicate values in columns marked as UNIQUE will now be ignored for the remainder of your session or until reenable_duplicate_key_error() is called
WARNING 3539:  Incorrect results are possible. Please contact Vertica Support if unsure
 disable_duplicate_key_error
------------------------------
 Duplicate key error disabled
(1 row)

另请参阅

ANALYZE_CONSTRAINTS

4.14.16.5 - INFER_EXTERNAL_TABLE_DDL

检查 Parquet、ORC 或 Avro 格式的文件并返回可用于读取文件的 CREATE EXTERNAL TABLE AS COPY 语句。此语句可能不完整。它还可以包含更多列或名称长度超出 Vertica 支持范围的列；此函数不强制执行 Vertica 系统限制。使用它创建表之前，请始终检查输出并解决各类问题。

此函数支持 Parquet、ORC 和 Avro 格式的分区列，从输入路径推断。由于通过目录结构完成分区，所以可能不具备充足的信息来推断分区列的类型。在这种情况下，此函数显示这些列的数据类型为 UNKNOWN 并发出警告。

函数可处理大多数数据类型，包括复杂类型。如果 Vertica 不支持输入类型，则函数将发出警告。

默认情况下，函数对复杂类型使用强类型。您可以将 vertica_type_for_complex_type 参数设置为 LONG VARBINARY，将列视为灵活复杂类型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INFER_EXTERNAL_TABLE_DDL( path USING PARAMETERS param=value[,...] )

参数

路径
文件或目录的路径。任何对 COPY 有效并使用此函数支持的文件格式的路径都有效。

参数

format
输入格式（字符串），"Parquet"、"ORC" 或 "Avro" 之一。此参数为必填。
table_name
要创建的外部表的名称。此参数为必填。

不要将架构名称作为表名的一部分；使用 table_schema 参数。

table_schema
在其中创建外部表的架构。如果忽略，则函数的输出中不包含架构。
vertica_type_for_complex_type
用于表示所有复杂类型列的类型，如果不想完全展开的话。唯一支持的值为 LONG VARBINARY。有关详细信息，请参阅可变复杂类型。

特权

非超级用户：对于用户可访问的存储位置的读取权限。

示例

在下例中，输入文件包含具有两个整数列的表的数据。可以完全推断表定义，也可以按原样使用返回的 SQL 语句。

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/orders/*.orc'
        USING PARAMETERS format = 'orc', table_name = 'orders');

                INFER_EXTERNAL_TABLE_DDL
--------------------------------------------------------------------------------------------------
create external table "orders" (
  "id" int,
  "quantity" int
) as copy from '/data/orders/*.orc' orc;
(1 row)

要在架构中创建表，请使用 table_schema 参数。不要将其添加到表名中；函数将其视为带有句点的名称，而不是架构。

以下示例显示了复杂类型的输出。您可以按原样使用定义，也可以修改 VARCHAR 大小：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/people/*.parquet'
        USING PARAMETERS format = 'parquet', table_name = 'employees');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                    INFER_EXTERNAL_TABLE_DDL
-------------------------------------------------------------------------
 create external table "employees"(
  "employeeID" int,
  "personal" Row(
    "name" varchar,
    "address" Row(
      "street" varchar,
      "city" varchar,
      "zipcode" int
    ),
    "taxID" int
  ),
  "department" varchar
 ) as copy from '/data/people/*.parquet' parquet;
(1 row)

在下例中，输入文件的 "prods" 列中包含映射。您可以将映射读取为行数组：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/orders.parquet'
    USING PARAMETERS format='parquet', table_name='orders');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                INFER_EXTERNAL_TABLE_DDL
------------------------------------------------------------------------
 create external table "orders"(
  "orderkey" int,
  "custkey" int,
  "prods" Array[Row(
    "key" varchar,
    "value" numeric(12,2)
  )],
  "orderdate" date
 ) as copy from '/data/orders.parquet' parquet;
(1 row)

在下例中，按区域对数据进行分区。函数无法推断数据类型，报告 UNKNOWN：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/sales/*/*
        USING PARAMETERS format = 'parquet', table_name = 'sales');
WARNING 9262: This generated statement is incomplete because of one or more unknown column types.
Fix these data types before creating the table
                INFER_EXTERNAL_TABLE_DDL
------------------------------------------------------------------------
 create external table "sales"(
  "tx_id" int,
  "date" date,
  "region" UNKNOWN
) as copy from '/data/sales/*/*' PARTITION COLUMNS region parquet;
(1 row)

对于 VARCHAR 和 VARBINARY 列，此函数不指定长度。这些类型的 Vertica 默认长度为 80 字节。如果数据值较长，则使用这个未经修改的表定义可能会导致数据截断。始终查看 VARCHAR 和 VARBINARY 列，以确定是否需要指定长度。如果输入文件包含以下类型的列，则此函数将发出警告：

WARNING 9311: This generated statement contains one or more varchar/varbinary columns which default to length 80

4.14.16.6 - INFER_TABLE_DDL

检查 Parquet、ORC、JSON 或 Avro 格式的文件，并根据其内容返回 CREATE TABLE 或 CREATE EXTERNAL TABLE 语句。

如果输入数据包含不明确或未知的数据类型，则返回的语句可能不完整。它还可以包含更多列或名称长度超出 Vertica 支持范围的列；此函数不强制执行 Vertica 系统限制。使用它创建表之前，请始终检查输出并解决各类问题。

此函数支持从输入路径推断出的分区列。由于通过目录结构完成分区，所以可能不具备充足的信息来推断分区列的类型。在这种情况下，此函数显示这些列的数据类型为 UNKNOWN 并发出警告。

函数可处理大多数数据类型，包括复杂类型。如果 Vertica 不支持输入类型，则函数将发出警告。

对于 VARCHAR 和 VARBINARY 列，此函数不指定长度。这些类型的 Vertica 默认长度为 80 字节。如果数据值较长，则使用返回且未经修改的表定义可能会导致数据截断。始终查看 VARCHAR 和 VARBINARY 列，以确定是否需要指定长度。如果输入文件包含以下类型的列，则此函数将发出警告：

WARNING 9311: This generated statement contains one or more varchar/varbinary columns which default to length 80

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INFER_TABLE_DDL( path USING PARAMETERS param=value[,...] )

参数

路径
文件或 glob 的路径。任何对 COPY 有效并使用此函数支持的文件格式的路径都有效。对于除 JSON 以外的所有格式，如果 glob 指定多个文件，则此函数将读取一个任意选择的文件。对于 JSON，函数可能会读取多个文件。请参阅 JSON。

参数

format
输入格式（字符串），"Parquet"、"ORC"、"Avro" 或 "JSON" 之一。此参数为必填。
table_name
要创建的表的名称。此参数为必填。

不要将架构名称作为表名的一部分；使用 table_schema 参数。

table_schema
在其中创建表的架构。如果忽略，则函数的输出中不包含架构。
table_type
要创建的表的类型，“原生”或“外部”。

默认值： “native”

with_copy_statement
对于原生表，是否在 CREATE TABLE 语句之外包含 COPY 语句。

默认值：false

one_line_result
是否将 DDL 作为单行返回，而不是整齐打印。单行格式可能更便于复制到 SQL 脚本中。

默认值： false（整齐打印）

max_files
（仅限 JSON。）如果 path 为 glob，则为 path 中要检查的最大文件数。使用此参数可增加函数考虑的数据量，例如，如果怀疑文件之间存在差异。文件从 glob 中任意选择而来。有关详细信息，请参阅 JSON。

默认值： 1

max_candidates
（仅限 JSON。）要显示的备选表定义的数量。函数仅为每个文件生成一个备选项，因此如果增加 max_candidates，还会增加 max_files。有关详细信息，请参阅 JSON。

默认值： 1

特权

非超级用户：对于用户可访问的存储位置的读取权限。

JSON

与其他受支持的格式不同，JSON 不会在数据文件中嵌入架构。此函数通过检查原始数据来推断 JSON 表 DDL。由于原始数据可能不明确或不一致，因此函数对此格式采用不同的方法。

对于每个输入文件，函数循环访问记录以开发备选表定义。任何记录中显示的顶级字段都将作为列包含在其中，即使并非所有记录都使用顶级字段也是如此。如果同一字段以不同类型显示到文件中，则函数选择与观察到的所有实例一致的类型。

假设一个文件包含餐厅数据：

{
    "name" : "Pizza House",
    "cuisine" : "Italian",
    "location_city" : [],
    "chain" : true,
    "hours" : [],
    "menu" : [{"item" : "cheese pizza", "price" : 7.99},
              {"item" : "spinach pizza", "price" : 8.99},
              {"item" : "garlic bread", "price" : 4.99}]
}
{
    "name" : "Sushi World",
    "cuisine" : "Asian",
    "location_city" : ["Pittsburgh"],
    "chain" : false,
    "menu" : [{"item" : "maki platter", "price" : "21.95"},
              {"item" : "tuna roll", "price" : "4.95"}]
}

第一条记录包含两个空数组，因此没有足够的信息来确定元素类型。第二条记录包含其中一个数组的字符串值，因此函数可为其推断出一种 VARCHAR 类型。其他数组元素类型仍然未知。

在第一条记录中，菜单价格为数字，但在第二条记录中，菜单价格为字符串。FLOAT 和字符串都可以强制转换为 NUMERIC，因此函数返回 NUMERIC：

=> SELECT INFER_TABLE_DDL ('/data/restaurants.json'
    USING PARAMETERS table_name='restaurants', format='json');
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/1 of total files(s):
  create table "restaurants"(
    "chain" bool,
    "cuisine" varchar,
    "hours" Array[UNKNWON],
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" numeric
    )],
    "name" varchar
  );

(1 row)

所有标量类型都可以强制转换为 VARCHAR，因此如果无法更明确地解决冲突（如在 NUMERIC 示例中），函数仍然可以返回类型。然而，并不总能通过这种方式对复杂类型进行解析。在下例中，文件中的记录包含相互冲突的 hours 字段定义：

{
    "name" : "Sushi World",
    "cuisine" : "Asian",
    "location_city" : ["Pittsburgh"],
    "chain" : false,
    "hours" : {"open" : "11:00", "close" : "22:00" }
}
{
    "name" : "Greasy Spoon",
    "cuisine" : "American",
    "location_city" : [],
    "chain" : "false",
    "hours" : {"open" : ["11:00","12:00"], "close" : ["21:00","22:00"] },
}

在第一条记录中，值为 ROW，包含两个 TIME 字段。在第二条记录中，值为 ROW，包含两个 ARRAY[TIME] 字段（代表工作日和周末时间）。这些类型相互不兼容，因此函数使用 LONG VARBINARY 推荐 灵活复杂类型：

=> SELECT INFER_TABLE_DDL ('/data/restaurants.json'
    USING PARAMETERS table_name='restaurants', format='json');
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/1 of total files(s):
  create table "restaurants"(
    "chain" bool,
    "cuisine" varchar,
    "hours" long varbinary,
    "location_city" Array[varchar],
    "name" varchar
  );

(1 row)

如果使用 glob 调用函数，默认读取一个文件。将 max_files 设置为更大的数字，以检查更多的数据。函数为每个文件计算一个备选表定义，返回涵盖最多文件的定义。

增加文件数量本身并不会增加函数返回的备选项数量。文件越多，函数可以考虑的备选项越多，但默认情况下，返回代表最多文件的单个备选项。要查看多个可能的表定义，还要设置 max_candidates。将 max_candidates 设置为大于 max_files 没有任何益处。

在下例中，glob 包含两个文件，菜单列结构截然不同。在第一个文件中，菜单字段包含两个字段：

{
    "name" : "Bob's pizzeria",
    "cuisine" : "Italian",
    "location_city" : ["Cambridge", "Pittsburgh"],
    "menu" : [{"item" : "cheese pizza", "price" : 8.25},
              {"item" : "spinach pizza", "price" : 10.50}]
}

在第二个文件中，一天当中不同时段的菜品有所不同：

{
    "name" : "Greasy Spoon",
    "cuisine" : "American",
    "location_city" : [],
    "menu" : [{"time" : "breakfast",
           "items" :
           [{"item" : "scrambled eggs", "price" : "3.99"}]
          },
          {"time" : "lunch",
           "items" :
           [{"item" : "grilled cheese", "price" : "3.95"},
        {"item" : "tuna melt", "price" : "5.95"},
        {"item" : "french fries", "price" : "1.99"}]}]
}

要查看两个备选项，请同时提出 max_files 和 max_candidates：

=> SELECT INFER_TABLE_DDL ('/data/*.json'
    USING PARAMETERS table_name='restaurants', format='json',
max_files=3, max_candidates=3);
WARNING 0:  This generated statement contains one or more float types which might lose precision
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" float
    )],
    "name" varchar
  );
Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "items" Array[Row(
        "item" varchar,
        "price" numeric
      )],
      "time" varchar
    )],
    "name" varchar
  );

(1 row)

示例

在下例中，输入路径包含具有两个整数列的表的数据。可以完全推断外部表定义，也可以按原样使用返回的 SQL 语句。函数从输入路径读取一个文件：

=> SELECT INFER_TABLE_DDL('/data/orders/*.orc'
    USING PARAMETERS format = 'orc', table_name = 'orders', table_type = 'external');

                INFER_TABLE_DDL
------------------------------------------------------------------------
create external table "orders" (
  "id" int,
  "quantity" int
) as copy from '/data/orders/*.orc' orc;
(1 row)

要在架构中创建表，请使用 table_schema 参数。不要将其添加到表名中；函数将其视为带有句点的名称，而不是架构。

以下示例显示了复杂类型的输出。您可以按原样使用定义，也可以修改 VARCHAR 大小：

=> SELECT INFER_TABLE_DDL('/data/people/*.parquet'
    USING PARAMETERS format = 'parquet', table_name = 'employees');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 create table "employees"(
  "employeeID" int,
  "personal" Row(
    "name" varchar,
    "address" Row(
      "street" varchar,
      "city" varchar,
      "zipcode" int
    ),
    "taxID" int
  ),
  "department" varchar
 );
(1 row)

在下例中，输入文件的 "prods" 列中包含映射。您可以将映射读取为行数组：

=> SELECT INFER_TABLE_DDL('/data/orders.parquet'
    USING PARAMETERS format='parquet', table_name='orders');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                INFER_TABLE_DDL
------------------------------------------------------------------------
 create table "orders"(
  "orderkey" int,
  "custkey" int,
  "prods" Array[Row(
    "key" varchar,
    "value" numeric(12,2)
  )],
  "orderdate" date
 );
(1 row)

以下示例返回原生表定义和 COPY 语句，将表定义添加到一行，简化剪切和粘贴到脚本的过程：

=> SELECT INFER_TABLE_DDL('/data/orders/*.orc'
    USING PARAMETERS format = 'orc', table_name = 'orders',
                         table_type = 'native', with_copy_statement = true, one_line_result=true);

                INFER_TABLE_DDL
-----------------------------------------------------------------------
create table "orders" ("id" int, "quantity" int);
copy "orders" from '/data/orders/*.orc' orc;
(1 row)

在下例中，按区域对数据进行分区。函数无法推断数据类型，报告 UNKNOWN：

=> SELECT INFER_TABLE_DDL('/data/sales/*/*
    USING PARAMETERS format = 'orc', table_name = 'sales', table_type = 'external');
WARNING 9262:  This generated statement is incomplete because of one or more unknown column types. Fix these data types before creating the table
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 create external table "sales"(
  "orderkey" int,
  "custkey" int,
  "prodkey" Array[varchar],
  "orderprices" Array[numeric(12,2)],
  "orderdate" date,
  "region" UNKNOWN
 ) as copy from '/data/sales/*/*' PARTITION COLUMNS region orc;
(1 row)

在下例中，函数读取多个 JSON 文件，这些 JSON 文件呈现 menu 列的方式有所不同：

=> SELECT INFER_TABLE_DDL ('/data/*.json'
    USING PARAMETERS table_name='restaurants', format='json',
max_files=3, max_candidates=3);
WARNING 0:  This generated statement contains one or more float types which might lose precision
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" float
    )],
    "name" varchar
  );
Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "items" Array[Row(
        "item" varchar,
        "price" numeric
      )],
      "time" varchar
    )],
    "name" varchar
  );

(1 row)

4.14.16.7 - LAST_INSERT_ID

返回 AUTO_INCREMENT/IDENTITY 列的最后一个值。如果多个会话并行加载同一个包含 AUTO_INCREMENT/IDENTITY 列的表，则函数返回为该列生成的最后一个值。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LAST_INSERT_ID()

特权

  • 表所有者

  • 对表架构的 USAGE 权限

示例

请参阅AUTO_INCREMENT 和 IDENTITY 序列。

4.14.16.8 - PURGE_TABLE

从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。

清除指定表的所有投影。不能使用此函数清除临时表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_TABLE ( '[[database.]schema.]table' )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要清除的表。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例清理了 Vmart 架构中的商店销售事实表的所有投影：

=> SELECT PURGE_TABLE('store.store_sales_fact');

另请参阅

4.14.16.9 - REBALANCE_TABLE

同步重新平衡指定表中的数据。

再平衡操作执行以下任务：

  • 基于下列内容分配数据：

  • 在所有节点之间重新分配数据库投影的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_TABLE('[[database.]schema.]table‑name')

参数

架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
要重新平衡的表。

超级用户

执行重新平衡的时间

执行以下任务后，重新平衡很有用，甚至十分必要：

  • 在准备从群集移除一个或多个节点时，将其标记为临时节点。

  • 向群集添加一个或多个节点，以便 Vertica 可以使用数据填充空节点。

  • 更改弹性群集的比例因子，该比例因子可确定用于跨数据库存储投影的存储容器的数目。

  • 设置控制节点大小或重新调整大型群集布局上的控制节点

  • 向容错组添加节点或从中移除节点。

示例

以下命令显示如何重新平衡指定表上的数据。

=> SELECT REBALANCE_TABLE('online_sales.online_sales_fact');
REBALANCE_TABLE
-------------------
 REBALANCED
(1 row)

另请参阅

4.14.16.10 - REENABLE_DUPLICATE_KEY_ERROR

通过逆转 DISABLE_DUPLICATE_KEY_ERROR 的影响来恢复错误报告的默认行为。影响限定在会话范围内。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REENABLE_DUPLICATE_KEY_ERROR();

超级用户

示例

=> SELECT REENABLE_DUPLICATE_KEY_ERROR();
 REENABLE_DUPLICATE_KEY_ERROR
------------------------------
 Duplicate key error enabled
(1 row)

另请参阅

ANALYZE_CONSTRAINTS

4.15 - 匹配和搜索函数

此部分包含文本搜索和正则表达式函数，以及 MATCH 子句中使用的函数。

4.15.1 - MATCH 子句函数

与 MATCH 子句 一起使用，此部分的函数返回关于查找或返回的模式的附加数据。例如，可以使用这些函数返回表示与输入行匹配的事件或模式名的值、匹配的序列名或匹配模式实例的全分区唯一标识符。

如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。典型的在线点击流漏斗是：

公司主页 -> 产品主页 -> 搜索 -> 结果 -> 在线购买

您可以使用以上点击流漏斗，在用户的 Web 点击序列中搜索匹配并标识该用户：

  • 登录了公司主页。

  • 导航至产品页面。

  • 运行查询。

  • 单击搜索结果中的链接。

  • 购买。

有关使用此点击流模型的示例，请参阅 事件系列模式匹配。

4.15.1.1 - EVENT_NAME

返回一个 VARCHAR 值，表示与行匹配事件的名称。

语法

EVENT_NAME()

注意

模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 EVENT_NAME()，Vertica 将返回以下错误消息：

=> SELECT event_name();
ERROR:  query with pattern matching function event_name must include a MATCH clause

示例

以下语句分析了用户在 "website2.com" 的浏览历史并标识了用户从另一网站（进入）登录 website2.com 以及在做出购买之前（购买）浏览任意数量的其他页面（站内）的模式。该查询还将输出 EVENT_NAME() 的结果值，即与行匹配的事件的名称。

SELECT uid,
       sid,
       ts,
       refurl,
       pageurl,
       action,
       event_name()
FROM clickstream_log
MATCH
  (PARTITION BY uid, sid ORDER BY ts
   DEFINE
     Entry    AS RefURL  NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
     Onsite   AS PageURL ILIKE     '%website2.com%' AND Action='V',
     Purchase AS PageURL ILIKE     '%website2.com%' AND Action = 'P'
   PATTERN
     P AS (Entry Onsite* Purchase)
   ROWS MATCH FIRST EVENT);
 uid | sid |    ts    |        refurl        |       pageurl        | action | event_name
-----+-----+----------+----------------------+----------------------+--------+------------
   1 | 100 | 12:00:00 | website1.com         | website2.com/home    | V      | Entry
   1 | 100 | 12:01:00 | website2.com/home    | website2.com/floby   | V      | Onsite
   1 | 100 | 12:02:00 | website2.com/floby   | website2.com/shamwow | V      | Onsite
   1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy     | P      | Purchase
   2 | 100 | 12:10:00 | website1.com         | website2.com/home    | V      | Entry
   2 | 100 | 12:11:00 | website2.com/home    | website2.com/forks   | V      | Onsite
   2 | 100 | 12:13:00 | website2.com/forks   | website2.com/buy     | P      | Purchase
(7 rows)

另请参阅

4.15.1.2 - MATCH_ID

将成功模式匹配作为 INTEGER 值返回。返回值是分区中匹配所在的序号位置。

语法

MATCH_ID()

注意

模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 MATCH_ID()，Vertica 将返回以下错误消息：

=> SELECT match_id();
ERROR:  query with pattern matching function match_id must include a MATCH clause

示例

下面的语句在 website2.com 网站上分析用户的浏览历史，并确定用户从另一个网站（ website2.com 子句中的Entry ）到达 MATCH ，以及订购（购买）之前浏览的其他页面（Onsite）数的模式。查询同时也输出表示匹配序号的 MATCH_ID() 的值。

SELECT uid,
       sid,
       ts,
       refurl,
       pageurl,
       action,
       match_id()
FROM clickstream_log
MATCH
  (PARTITION BY uid, sid ORDER BY ts
   DEFINE
     Entry    AS RefURL  NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
     Onsite   AS PageURL ILIKE     '%website2.com%' AND Action='V',
     Purchase AS PageURL ILIKE     '%website2.com%' AND Action = 'P'
   PATTERN
     P AS (Entry Onsite* Purchase)
   ROWS MATCH FIRST EVENT);

uid | sid |    ts    |        refurl        |       pageurl        | action | match_id
----+-----+----------+----------------------+----------------------+--------+------------
1   | 100 | 12:00:00 | website1.com         | website2.com/home    | V      |          1
1   | 100 | 12:01:00 | website2.com/home    | website2.com/floby   | V      |          2
1   | 100 | 12:02:00 | website2.com/floby   | website2.com/shamwow | V      |          3
1   | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy     | P      |          4
2   | 100 | 12:10:00 | website1.com         | website2.com/home    | V      |          1
2   | 100 | 12:11:00 | website2.com/home    | website2.com/forks   | V      |          2
2   | 100 | 12:13:00 | website2.com/forks   | website2.com/buy     | P      |          3
(7 rows)

另请参阅

4.15.1.3 - PATTERN_ID

返回匹配模式实例的全分区唯一标识符整数值。

语法

PATTERN_ID()

注意

模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 PATTERN_ID()，Vertica 将返回以下错误消息：

=> SELECT pattern_id();
ERROR:  query with pattern matching function pattern_id must include a MATCH clause

示例

以下语句分析了用户在 website2.com 的浏览历史并标识了用户从另一网站（进入）登录 website2.com 以及在做出购买之前（购买）浏览任意数量的其他页面（站内）的模式。查询也输出了 PATTERN_ID() 的值，表示匹配模式实例的全分区标识符。

SELECT uid,
       sid,
       ts,
       refurl,
       pageurl,
       action,
       pattern_id()
FROM clickstream_log
MATCH
  (PARTITION BY uid, sid ORDER BY ts
   DEFINE
     Entry    AS RefURL  NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
     Onsite   AS PageURL ILIKE     '%website2.com%' AND Action='V',
     Purchase AS PageURL ILIKE     '%website2.com%' AND Action = 'P'
   PATTERN
     P AS (Entry Onsite* Purchase)
   ROWS MATCH FIRST EVENT);


uid | sid |    ts    |        refurl        |       pageurl        | action | pattern_id
----+-----+----------+----------------------+----------------------+--------+------------
1   | 100 | 12:00:00 | website1.com         | website2.com/home    | V      |          1
1   | 100 | 12:01:00 | website2.com/home    | website2.com/floby   | V      |          1
1   | 100 | 12:02:00 | website2.com/floby   | website2.com/shamwow | V      |          1
1   | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy     | P      |          1
2   | 100 | 12:10:00 | website1.com         | website2.com/home    | V      |          1
2   | 100 | 12:11:00 | website2.com/home    | website2.com/forks   | V      |          1
2   | 100 | 12:13:00 | website2.com/forks   | website2.com/buy     | P      |          1
(7 rows)

另请参阅

4.15.2 - 正则表达式函数

利用正则表达式可以对字符串执行模式匹配。利用正则表达式语法，可以精确地定义用于匹配字符串的模式，从而为您提供比 LIKE 谓词中所用的通配符匹配更多的控制。利用 Vertica 正则表达式函数可以执行多种任务，例如确定字符串值是否与某个模式匹配，提取字符串中与某个模式匹配的部分，或对字符串中某个模式出现的次数进行计数。

Vertica 使用兼容 Perl 的正则表达式 (PCRE) 库来为正则表达式求值。顾名思义，PCRE 的正则表达式语法可兼容 Perl 5 编程语言所用的语法。您可以阅读 PCRE 文档中关于其库的内容。但如果您不熟悉正则表达式的使用，Perl 正则表达式文档提供了很好的入门材料。

4.15.2.1 - MATCH_COLUMNS

指定为 SELECT 列表中的元素，返回查询表中与指定模式匹配的所有列。例如：

=> SELECT MATCH_COLUMNS ('%order%') FROM store.store_orders_fact LIMIT 3;
 order_number | date_ordered | quantity_ordered | total_order_cost | reorder_level
--------------+--------------+------------------+------------------+---------------
       191119 | 2003-03-09   |               15 |             4021 |            23
        89985 | 2003-05-04   |               19 |             2692 |            23
       246962 | 2007-06-01   |               77 |             4419 |            42
(3 rows)

语法

MATCH_COLUMNS ('pattern')

参数

模式
匹配查询表中所有列名的模式，其中 pattern 通常包含以下一个或两个通配符：

  • _ （下划线）：匹配任意单个字符。

  • % （百分号）：匹配 0 或多个字符的字符串。

模式还可以包含反斜杠 (\\) 字符，转义嵌入列名中的保留字符：_（下划线）、%（百分号）和反斜杠 (\\) 本身。

特权

无

DDL 的用法

您可以使用 MATCH_COLUMNS 定义数据库对象 — 例如，在 CREATE PROJECTION 中指定来标识投影列，或者在 CREATE TABLE...AS 中标识新表中的列。在所有情况下，Vertica 都会在存储对象 DDL 之前扩展 MATCH_COLUMNS 输出。对原始源表的后续更改不会影响派生的对象定义。

限制

通常，将 MATCH_COLUMNS 指定为 SELECT 列表中的一个元素。例如，CREATE PROJECTION 可调用 MATCH_COLUMNS 来指定要包含在投影中的列。但是，尝试在投影的分段子句中指定列会返回错误：

=> CREATE PROJECTION p_store_orders AS SELECT
    MATCH_COLUMNS('%product%'),
    MATCH_COLUMNS('%store%'),
    order_number FROM store.store_orders_fact SEGMENTED BY MATCH_COLUMNS('products%') ALL NODES;
ERROR 0:  MATCH_COLUMNS() function can only be specified as an element in a SELECT list

=> CREATE PROJECTION p_store_orders AS SELECT
    MATCH_COLUMNS('%product%'),
    MATCH_COLUMNS('%store%'),
    order_number FROM store.store_orders_fact;
WARNING 4468:  Projection <store.p_store_orders_b0> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
          The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
WARNING 4468:  Projection <store.p_store_orders_b1> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
          The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION

如果从支持固定数量实参的函数调用 MATCH_COLUMNS，则 Vertica 将返回错误。例如，UPPER 函数仅支持一个实参；因此，按照以下方式从 UPPER 调用 MATCH_COLUMNS 将返回错误：

=> SELECT MATCH_COLUMNS('emp%') FROM employee_dimension LIMIT 1;
-[ RECORD 1 ]-----------+---------------------------------
employee_key            | 1
employee_gender         | Male
employee_first_name     | Craig
employee_middle_initial | F
employee_last_name      | Robinson
employee_age            | 22
employee_street_address | 5 Bakers St
employee_city           | Thousand Oaks
employee_state          | CA
employee_region         | West

=> SELECT UPPER (MATCH_COLUMNS('emp%')) FROM employee_dimension;
ERROR 10465:  MATCH_COLUMNS() function can only be specified as an element in a SELECT list

相反，HASH 函数接受无限数量的实参，因此可以成功将 MATCH_COLUMNS 作为实参调用：

=> select HASH(MATCH_COLUMNS('emp%')) FROM employee_dimension LIMIT 10;
        HASH
---------------------
 2047284364908178817
 1421997332260827278
 7981613309330877388
  792898558199431621
 5275639269069980417
 7892790768178152349
  184601038712735208
 3020263228621856381
 7056305566297085916
 3328422577712931057
(10 rows)

其他约束

MATCH_COLUMNS 的以下用法无效并返回错误：

  • 在 RECURSIVE WITH 子句的非递归（基础）术语查询中包含 MATCH_COLUMNS

  • 连接 MATCH_COLUMNS 调用的结果：

    => SELECT MATCH_COLUMNS ('%store%')||MATCH_COLUMNS('%store%') FROM store.store_orders_fact;
ERROR 0:  MATCH_COLUMNS() function can only be specified as an element in a SELECT list

  • 在 MATCH_COLUMNS 上设置别名

示例

以下 CREATE PROJECTION 语句使用 MATCH_COLUMNS 指定新投影中的表列：

=> CREATE PROJECTION p_store_orders AS SELECT
    MATCH_COLUMNS('%product%'),
    MATCH_COLUMNS('%store%'),
    order_number FROM store.store_orders_fact;
WARNING 4468:  Projection <store.p_store_orders_b0> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
          The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
WARNING 4468:  Projection <store.p_store_orders_b1> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
          The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION

=> SELECT export_objects('', 'store.p_store_orders_b0');
...

CREATE PROJECTION store.p_store_orders_b0 /*+basename(p_store_orders)*/
(
 product_key,
 product_version,
 store_key,
 order_number
)
AS
 SELECT store_orders_fact.product_key,
        store_orders_fact.product_version,
        store_orders_fact.store_key,
        store_orders_fact.order_number
 FROM store.store_orders_fact
 ORDER BY store_orders_fact.product_key,
          store_orders_fact.product_version,
          store_orders_fact.store_key,
          store_orders_fact.order_number
SEGMENTED BY hash(store_orders_fact.product_key, store_orders_fact.product_version, store_orders_fact.store_key, store_orders_fact.order_number) ALL NODES OFFSET 0;

SELECT MARK_DESIGN_KSAFE(1);

(1 row)

如 EXPORT_OBJECTS 输出所示，Vertica 将两个 MATCH_COLUMNS 调用的结果集存储到新投影的 DDL 中。锚表 DDL 中的后续更改不会影响此投影。

4.15.2.2 - REGEXP_COUNT

返回正则表达式与字符串匹配的次数。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_COUNT ( string-expession, pattern [, position [, regexp‑modifier ]... ] )

参数

string-expression

VARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。

模式

与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。

position
函数应该从自字符串开头算起的多少个字符开始搜索匹配项。默认情况下，函数从第一个（最左侧）字符开始搜索匹配项。如果将此参数设置为大于 1 的值，将从您指定的第 n 个字符开始搜索匹配项。

默认值： 1

regexp‑modifier

[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：

  • b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。

  • c （默认值）： 强制匹配区分大小写。

  • i： 强制匹配不区分大小写。

  • m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。

  • n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。

  • x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。

示例

计算指定字符串 (a man, a plan, a canal: Panama) 中子字符串 an 的出现次数：

=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', 'an');
 REGEXP_COUNT
--------------
            4
(1 row)

自第五个字符开始，查找子字符串 an 的出现次数。

=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', 'an',5);
 REGEXP_COUNT
--------------
            3
(1 row)

查找包含小写字符且后跟 an 的子字符串的出现次数：

=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', '[a-z]an');
 REGEXP_COUNT
--------------
            3
(1 row

REGEXP_COUNT 指定 i 修饰符，因此忽略大小写：


=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', '[a-z]an', 1, 'i');

 REGEXP_COUNT
--------------
            4

4.15.2.3 - REGEXP_ILIKE

如果字符串包含正则表达式的匹配项，则返回 True。REGEXP_ILIKE 与 LIKE 谓词 相似，不同的是它使用不区分大小写的正则表达式，而不是简单的通配符匹配。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_ILIKE ( string-expression, pattern )

参数

示例

此示例将创建一个包含多个字符串的表来演示正则表达式。

  1. 使用单个 LONG VARCHAR 列 longvc 创建表 (body)，并插入具有不同字符的数据：

    => CREATE table longvc(body long varchar (1048576));
CREATE TABLE

    
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');
=> insert into longvc values ('Out of the frying pan, he landed immediately in the fire');

    
=> SELECT * FROM longvc;
                      body
------------------------------------------------
 На берегу пустынных волн
 Voin syödä lasia, se ei vahingoita minua
 私はガラスを食べられます。それは私を傷つけません。
 Je peux manger du verre, ça ne me fait pas mal.
 zésbaésbaa
 Out of the frying pan, he landed immediately in the fire
(6 rows)

  2. 包含字符 ç 的模式匹配表行：

    => SELECT * FROM longvc where regexp_ilike(body, 'ç');
                      body
-------------------------------------------------
 Je peux manger du verre, ça ne me fait pas mal.
(1 row)

  3. 选择所有包含字符 A/a 的行：

    => SELECT * FROM longvc where regexp_ilike(body, 'A');
                      body
-------------------------------------------------
 Je peux manger du verre, ça ne me fait pas mal.
 Voin syödä lasia, se ei vahingoita minua
 zésbaésbaa
(3 rows)

  4. 选择所有包含字符 O/o 的行：

    => SELECT * FROM longvc where regexp_ilike(body, 'O');
                           body
----------------------------------------------------------
 Voin syödä lasia, se ei vahingoita minua
 Out of the frying pan, he landed immediately in the fire
(2 rows)

4.15.2.4 - REGEXP_INSTR

返回字符串中正则表达式所匹配的开始或结束位置。如果正则表达式在字符串中没有找到匹配项，REGEXP_INSTR 将返回 0。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_INSTR ( string-expression, pattern 
   [, position [, occurrence [, return‑position [, regexp‑modifier ]... [, captured‑subexp ]]]] )

参数

string-expression

VARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。

模式

与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。

position
函数应该从自字符串开头算起的多少个字符开始搜索匹配项。默认情况下，函数从第一个（最左侧）字符开始搜索匹配项。如果将此参数设置为大于 1 的值，将从您指定的第 n 个字符开始搜索匹配项。

默认值： 1

occurrence
控制要返回字符串中第几次出现的模式匹配项。默认情况下，函数返回第一个匹配子字符串的位置。使用此参数可以查找后续匹配子字符串的位置。例如，如果将此参数设置为 3，将返回与模式匹配的第三个子字符串的位置。

默认值： 1

return‑position
设置字符串内要返回的位置。如果使用默认位置 (0)，函数将返回与模式匹配的子字符串的第一个字符的字符串位置。如果将 return‑position 设为 1，函数将返回匹配的子字符串结束后的第一个字符的位置。

默认值： 0

regexp‑modifier

[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：

  • b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。

  • c （默认值）： 强制匹配区分大小写。

  • i： 强制匹配不区分大小写。

  • m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。

  • n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。

  • x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。

captured‑subexp
要返回其位置的括住的子表达式。默认情况下，函数将返回 string 中与正则表达式匹配的第一个字符的位置。如果将此值设置为从 1 到 9，函数将返回由正则表达式中相应的一组圆括号括住的子表达式。例如，如果将此值设置为 3，将返回由正则表达式中第三组圆括号括住的子字符串。

默认值： 0

示例

在指定字符串 (easy come, easy go) 中查找以字母 e 开头并以字母 y 结尾的字母序列的第一个实例。

=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y');
 REGEXP_INSTR
--------------
            1
(1 row)

自第二个字符 (2) 开始，查找以字母 e 开头并以字母 y 结尾的第一个字母序列：

=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y',2);
 REGEXP_INSTR
--------------
           12
(1 row)

自第一个字符 (1) 开始，查找以字母 e 开头并以字母 y 结尾的第二个字母序列：

=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y',1,2);
 REGEXP_INSTR
--------------
           12
(1 row)

查找第一个空格之后的第一个字符的位置：

=> SELECT REGEXP_INSTR('easy come, easy go','\s',1,1,1);
 REGEXP_INSTR
--------------
            6
(1 row)

通过将每个单词捕获为一个子表达式并返回第三个子表达式的开始位置，查找字符串中第三个单词的开始位置。

=> SELECT REGEXP_INSTR('one two three','(\w+)\s+(\w+)\s+(\w+)', 1,1,0,'',3);
REGEXP_INSTR
--------------
            9
(1 row)

4.15.2.5 - REGEXP_LIKE

如果字符串与正则表达式匹配，则返回 True。REGEXP_LIKE 与 LIKE 谓词 相似，不同的是它使用正则表达式而不是简单的通配符匹配。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_LIKE ( string-expression, pattern [, regexp‑modifier ]... )

参数

string-expression

VARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。

模式

与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。

regexp‑modifier

[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：

  • b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。

  • c （默认值）： 强制匹配区分大小写。

  • i： 强制匹配不区分大小写。

  • m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。

  • n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。

  • x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。

示例

创建一个包含多个字符串的表：

=> CREATE TABLE t (v VARCHAR);
CREATE TABLE
=> CREATE PROJECTION t1 AS SELECT * FROM t;
CREATE PROJECTION
=> COPY t FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> aaa
>> Aaa
>> abc
>> abc1
>> 123
>> \.
=> SELECT * FROM t;
   v
-------
 aaa
 Aaa
 abc
 abc1
 123
(5 rows)

选择表 t 中所有包含字母 a 的记录：

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a');
  v
------
 Aaa
 aaa
 abc
 abc1
(4 rows)

选择表 t 中所有以字母 a 开头的行：

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'^a');
  v
------
 aaa
 abc
 abc1
(3 rows)

选择所有包含子字符串 aa 的行：

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aa');
  v
-----
 Aaa
 aaa
(2 rows)

选择所有包含一个数字的行。

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'\d');
  v
------
 123
 abc1
(2 rows)

选择所有包含子字符串 aaa 的行：

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aaa');
  v
-----
 aaa
(1 row)

选择所有包含子字符串 aaa 且使用不区分大小写的匹配的行。

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aaa', 'i');
  v
-----
 Aaa
 aaa
(2 rows)

选择包含子字符串 a b c 的行：

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a b c');
 v
---
(0 rows)

选择包含子字符串 a b c 且忽略正则表达式内的空格的行。

=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a b c','x');
  v
------
 abc
 abc1
(2 rows)

向表 t 中添加多行行：

=> COPY t FROM stdin RECORD TERMINATOR '!';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Record 1 line 1
>> Record 1 line 2
>> Record 1 line 3!
>> Record 2 line 1
>> Record 2 line 2
>> Record 2 line 3!
>> \.

选择表 t 中以子字符串 Record 开头并以子字符串 line 2 结尾的行。

=> SELECT v from t WHERE REGEXP_LIKE(v,'^Record.*line 2$');
 v
---
(0 rows)

选择以子字符串 Record 开头并以子字符串 line 2 结尾，并且将多个行作为单独字符串处理的行。

=> SELECT v from t WHERE REGEXP_LIKE(v,'^Record.*line 2$','m');
                        v
--------------------------------------------------

Record 2 line 1
Record 2 line 2
Record 2 line 3
Record 1 line 1
Record 1 line 2
Record 1 line 3
(2 rows)

4.15.2.6 - REGEXP_NOT_ILIKE

如果字符串与不区分大小写的正则表达式不匹配，则返回 True。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_NOT_ILIKE ( string-expression, pattern )

参数

示例

  1. 创建一个包含单个 long varchar 列 (longvc) 的表 (body)。然后，插入包含一些不同字符的数据，并查询表内容：

    => CREATE table longvc(body long varchar (1048576));
CREATE TABLE

    
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');

    
=> SELECT * FROM longvc;
                      body
------------------------------------------------
 На берегу пустынных волн
 Voin syödä lasia, se ei vahingoita minua
 私はガラスを食べられます。それは私を傷つけません。
 Je peux manger du verre, ça ne me fait pas mal.
 zésbaésbaa
(5 rows)

  2. 查找所有不包含字符 ç 的行：

    
=> SELECT * FROM longvc where regexp_not_ilike(body, 'ç');
                        body
----------------------------------------------------
 Voin syödä lasia, se ei vahingoita minua
 zésbaésbaa
 На берегу пустынных волн
 私はガラスを食べられます。それは私を傷つけません。
(4 rows)

  3. 查找所有不包含子字符串 a 的行：

    => SELECT * FROM longvc where regexp_not_ilike(body, 'a');
                        body
----------------------------------------------------
 На берегу пустынных волн
 私はガラスを食べられます。それは私を傷つけません。
(2 rows)

4.15.2.7 - REGEXP_NOT_LIKE

如果字符串不包含正则表达式的匹配项，则返回 True。REGEXP_NOT_LIKE 是区分大小写的正则表达式。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_NOT_LIKE ( string-expression, pattern )

参数

示例

  1. 创建一个包含 LONG VARCHAR 列 body 的表 (longvc)。然后，插入包含一些不同字符的数据，并查询表内容：

    => CREATE table longvc(body long varchar (1048576));
CREATE TABLE

    
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');

    
=> SELECT * FROM longvc;
                      body
------------------------------------------------
 На берегу пустынных волн
 Voin syödä lasia, se ei vahingoita minua
 私はガラスを食べられます。それは私を傷つけません。
 Je peux manger du verre, ça ne me fait pas mal.
 zésbaésbaa
(5 rows)

  2. 使用 REGEXP_NOT_LIKE 可以返回不包含字符 ç 的行：

    => SELECT * FROM longvc where regexp_not_like(body, 'ç');
                        body
----------------------------------------------------
 Voin syödä lasia, se ei vahingoita minua
 zésbaésbaa
 На берегу пустынных волн
 私はガラスを食べられます。それは私を傷つけません。
(4 rows)

  3. 返回不包含字符 *ö 和 *ä 的所有行：

    => SELECT * FROM longvc where regexp_not_like(body, '.*ö.*ä');
                        body
----------------------------------------------------
 Je peux manger du verre, ça ne me fait pas mal.
 zésbaésbaa
 На берегу пустынных волн
 私はガラスを食べられます。それは私を傷つけません。
(4 rows)

  4. 对不包含子字符 z 和 *ésbaa 的所有行进行模式匹配：

    => SELECT * FROM longvc where regexp_not_like(body, 'z.*ésbaa');
                        body
----------------------------------------------------
 Je peux manger du verre, ça ne me fait pas mal.
 Voin syödä lasia, se ei vahingoita minua
 zésbaésbaa
 На берегу пустынных волн
 私はガラスを食べられます。それは私を傷つけません。
(5 rows)

4.15.2.8 - REGEXP_REPLACE

将所有与正则表达式匹配的子字符串实例替换为另一个子字符串。REGEXP_REPLACE 与 REPLACE 函数相似，不同的是，它使用正则表达式来选择要替换的子字符串。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_REPLACE ( string-expression, target 
   [, replacement [, position [, occurrence[...] [, regexp‑modifier]]]] )

参数

string-expression

VARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。

模式

与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。

replacement
用于替换匹配的子字符串的字符串。如果不提供 replacement，函数将会删除匹配的子字符串。替换字符串可能包含正则表达式所捕获的子字符串的 baccalaureate。第一个捕获的子字符串将会使用 \1 插入到替换字符串，第二个则会使用 \2 插入到替换字符串，依此类推。
position
函数应该从自字符串开头算起的多少个字符开始搜索匹配项。默认情况下，函数从第一个（最左侧）字符开始搜索匹配项。如果将此参数设置为大于 1 的值，将从您指定的第 n 个字符开始搜索匹配项。

默认值： 1

occurrence
控制要返回字符串中第几次出现的模式匹配项。默认情况下，函数返回第一个匹配子字符串的位置。使用此参数可以查找后续匹配子字符串的位置。例如，如果将此参数设置为 3，将返回与模式匹配的第三个子字符串的位置。

默认值： 1

regexp‑modifier

[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：

  • b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。

  • c （默认值）： 强制匹配区分大小写。

  • i： 强制匹配不区分大小写。

  • m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。

  • n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。

  • x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。

Oracle 如何处理子表达式

与 Oracle 不同，Vertica 可以处理捕获到的无限数量的子表达式，而 Oracle 则限制为 9 个。

在 Vertica 中，可以在替换模式中使用 \10 来访问正则表达式中第 10 对圆括号所捕获的子字符串。在 Oracle 中，\10 将作为第一对圆括号所捕获的子字符串进行处理，后面紧跟 0。要在 Vertica 强制使用此 Oracle 行为，请使用 \g 反向引用，并将捕获的子表达式编号括在花括号内。例如，\g{1}0 表示第一对圆括号所捕获的子字符串，后面紧跟 0。

也可以对捕获的子表达式进行命名，以增强正则表达式的明确性。有关详细信息，请参阅 PCRE 文档。

示例

在字符串 healthy, wealthy, and wise 中查找以 thy 结尾的“字符元”组（字母、数字和下划线），并将其替换为空字符串。

=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy');
 REGEXP_REPLACE
----------------
 , , and wise
(1 row)

查找以 thy 结尾的字符元组，并替换为字符串 something。

=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something');
         REGEXP_REPLACE
--------------------------------
 something, something, and wise
(1 row)

查找以 thy 结尾的字符元组，并从字符串中的第三个字符开始替换为字符串 something。

=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something', 3);
          REGEXP_REPLACE
----------------------------------
 hesomething, something, and wise
(1 row)

将以 thy 结尾的第二个字符元组替换为字符串 something。

=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something', 1, 2);
        REGEXP_REPLACE
------------------------------
 healthy, something, and wise
(1 row)

查找以 thy 结尾的字符元组（捕获 thy 前面的字母），并替换为捕获到的字母加上字母 ish。

=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','(\w+)thy', '\1ish');
       REGEXP_REPLACE
----------------------------
 healish, wealish, and wise
(1 row)

创建表以演示替换查询中的字符串。

=> CREATE TABLE customers (name varchar(50), phone varchar(11));
CREATE TABLE
=> CREATE PROJECTION customers1 AS SELECT * FROM customers;
CREATE PROJECTION
=> COPY customers FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Able, Adam|17815551234
>> Baker,Bob|18005551111
>> Chu,Cindy|16175559876
>> Dodd,Dinara|15083452121
>> \.

查询客户，使用 REGEXP_REPLACE 设置电话号码格式。

=> SELECT name, REGEXP_REPLACE(phone, '(\d)(\d{3})(\d{3})(\d{4})',
'\1-(\2) \3-\4') as phone FROM customers;
    name     |      phone
-------------+------------------
 Able, Adam  | 1-(781) 555-1234
 Baker,Bob   | 1-(800) 555-1111
 Chu,Cindy   | 1-(617) 555-9876
 Dodd,Dinara | 1-(508) 345-2121
(4 rows)

4.15.2.9 - REGEXP_SUBSTR

返回字符串内与正则表达式匹配的子字符串。如果没有找到匹配项，REGEXP_SUBSTR 将返回 NULL。这与空字符串不同，如果正则表达式匹配零长度的字符串，则会返回空字符串。

此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。

语法

REGEXP_SUBSTR ( string-expression, pattern 
   [, position [,  occurrence [, regexp‑modifier [, captured‑subexp ]]... ]] )

参数

string-expression

VARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。

模式

与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。

position
函数应该从自字符串开头算起的多少个字符开始搜索匹配项。默认情况下，函数从第一个（最左侧）字符开始搜索匹配项。如果将此参数设置为大于 1 的值，将从您指定的第 n 个字符开始搜索匹配项。

默认值： 1

occurrence
控制要返回字符串中第几次出现的模式匹配项。默认情况下，函数返回第一个匹配子字符串的位置。使用此参数可以查找后续匹配子字符串的位置。例如，如果将此参数设置为 3，将返回与模式匹配的第三个子字符串的位置。

默认值： 1

regexp‑modifier

[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：

  • b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。

  • c （默认值）： 强制匹配区分大小写。

  • i： 强制匹配不区分大小写。

  • m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。

  • n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。

  • x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。

captured‑subexp
要返回其位置的括住的子表达式。默认情况下，函数将返回 string 中与正则表达式匹配的第一个字符的位置。如果将此值设置为从 1 到 9，函数将返回由正则表达式中相应的一组圆括号括住的子表达式。例如，如果将此值设置为 3，将返回由正则表达式中第三组圆括号括住的子字符串。

默认值： 0

示例

选择以 thy 结尾的第一个字母子字符串。

=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy');
 REGEXP_SUBSTR
---------------
 healthy
(1 row)

选择从字符串中的第二个字符开头并以 thy 结尾的第一个字母子字符串。

=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy',2);
 REGEXP_SUBSTR
---------------
 ealthy
(1 row)

选择以 thy 结尾的第二个字母子字符串。

=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy',1,2);
 REGEXP_SUBSTR
---------------
 wealthy
(1 row)

返回捕获的第三个子表达式的内容，该子表达式将捕获字符串中的第三个词。

=> SELECT REGEXP_SUBSTR('one two three', '(\w+)\s+(\w+)\s+(\w+)', 1, 1, '', 3);
 REGEXP_SUBSTR
---------------
 three
(1 row)

4.15.3 - 文本搜索函数

此部分包含 Vertica 专用的文本搜索函数。

4.15.3.1 - DELETE_TOKENIZER_CONFIG_FILE

删除分词器配置文件。

语法

SELECT v_txtindex.DELETE_TOKENIZER_CONFIG_FILE (USING PARAMETERS proc_oid='proc_oid', confirm={true | false });

参数

confirm = [true | false]
Boolean 标志。表示应删除该配置文件，即使分词器仍在使用。

True — 当使用的参数值为 True 时，强制删除分词器。

False — 当使用的参数值为 False 时，删除分词器。

默认值： False

proc_oid
在创建分词器时为其分配的唯一标识符。用户必须查询系统表 vs_procedures 以为给定分词器名称获取 proc_oid。有关详细信息，请参阅配置分词器。

示例

以下示例说明如何使用 DELETE_TOKENIZER_CONFIG_FILE 删除分词器配置文件：

=> SELECT v_txtindex.DELETE_TOKENIZER_CONFIG_FILE (USING PARAMETERS proc_oid='45035996274126984');
 DELETE_TOKENIZER_CONFIG_FILE
------------------------------
 t
(1 row)

4.15.3.2 - GET_TOKENIZER_PARAMETER

返回给定分词器的配置参数。

语法

SELECT v_txtindex.GET_TOKENIZER_PARAMETER(parameter_name USING PARAMETERS proc_oid='proc_oid');

参数

parameter_name
要返回的参数的名称。

以下几项之一：

  • stopWordsCaseInsensitive

  • minorSeparators

  • majorSeparators

  • minLength

  • maxLength

  • ngramsSize

  • used

proc_oid
在创建分词器时为其分配的唯一标识符。用户必须查询系统表 vs_procedures 以为给定分词器名称获取 proc_oid。有关详细信息，请参阅配置分词器。

示例

以下示例显示了如何使用 GET_TOKENIZER_PARAMETER。

返回分词器中使用的停止词：

=> SELECT v_txtindex.GET_TOKENIZER_PARAMETER('stopwordscaseinsensitive' USING PARAMETERS proc_oid='45035996274126984');
 getTokenizerParameter
-----------------------
 devil,TODAY,the,fox
(1 row)

返回分词器中使用的主要分隔符：

=> SELECT v_txtindex.GET_TOKENIZER_PARAMETER('majorseparators' USING PARAMETERS proc_oid='45035996274126984');
 getTokenizerParameter
-----------------------
 {}()&[]
(1 row)

4.15.3.3 - READ_CONFIG_FILE

读取并返回给定分词器的所有参数的键值对。

您必须将 OVER() 子句与此函数一起使用。

语法

SELECT v_txtindex.READ_CONFIG_FILE(USING PARAMETERS proc_oid='proc_oid') OVER ()

参数

proc_oid
在创建分词器时为其分配的唯一标识符。用户必须查询系统表 vs_procedures 以为给定分词器名称获取 proc_oid。有关详细信息，请参阅配置分词器。

示例

以下示例显示了如何使用 READ_CONFIG_FILE 来返回与分词器关联的参数：

=> SELECT v_txtindex.READ_CONFIG_FILE(USING PARAMETERS proc_oid='45035996274126984') OVER();
                config_key | config_value
 --------------------------+---------------------
  majorseparators          | {}()&[]
  stopwordscaseinsensitive | devil,TODAY,the,fox
(2 rows)

4.15.3.4 - SET_TOKENIZER_PARAMETER

配置分词器参数。

语法

SELECT v_txtindex.SET_TOKENIZER_PARAMETER (parameter_name, parameter_value USING PARAMETERS proc_oid='proc_oid')

参数

parameter_name
要配置的参数的名称。

使用下列内容之一：

  • stopwordsCaseInsensitive：非索引字列表。属于此列表的所有标记都会被忽略。Vertica 支持最多包含前 256 个 Unicode 字符的分隔符和非索引字。

    如果您要定义包含逗号或反斜杠的非索引字，则需要对其转义。
    例如： "Dear Jack\," "Dear Jack\\"

    默认值： '' （空列表）

  • majorSeparators：主要分隔符列表。用引号引起来且之间没有空格。

    默认值： E' []<>(){}|!;,''"*&?+\r\n\t'

  • minorSeparators：二级分隔符列表。用引号引起来且之间没有空格。

    默认值： E'/:=@.-$#%\\_'

  • minLength — 标记拥有的最小长度，Integer 类型。必须大于 0。

    默认值： '2'

  • maxLength：标记拥有的最大长度。Integer 类型。不得大于 1024 字节。有关增加标记大小的信息，请参阅 文本搜索参数。

    默认值： '128'

  • ngramsSize：大于 0 的整数值。仅与 ngram 分词器结合使用。

    默认值： '3'

  • used：指示无法更改分词器配置。Boolean 类型。将 used 设置为 True 后，对 setTokenizerParameter 的任何调用将失败。

    在使用已配置的分词器之前，您必须将参数 used 设置为 True。这样做可防止配置在用于创建文本索引后被修改。

    默认值： False

parameter_value
配置参数的值。

如果您要禁用 minorSeperators 或 stopWordsCaseInsensitive，则将其值设置为 ''。

proc_oid
在创建分词器时为其分配的唯一标识符。用户必须查询系统表 vs_procedures 以为给定分词器名称获取 proc_oid。有关详细信息，请参阅配置分词器。

示例

以下示例显示了如何使用 SET_TOKENIZER_PARAMETER 配置非索引字和分隔符。

配置分词器的非索引字：

=> SELECT v_txtindex.SET_TOKENIZER_PARAMETER('stopwordsCaseInsensitive', 'devil,TODAY,the,fox' USING PARAMETERS proc_oid='45035996274126984');
 SET_TOKENIZER_PARAMETER
-------------------------
 t
(1 row)

配置分词器的主要分隔符：

=> SELECT v_txtindex.SET_TOKENIZER_PARAMETER('majorSeparators',E'{}()&[]' USING PARAMETERS proc_oid='45035996274126984');
 SET_TOKENIZER_PARAMETER
-------------------------
 t
(1 row)

4.16 - 算数函数

其中一些函数通过具有不同自变量类型的多种形式提供。除非另有注明，否则函数的给定形式返回与它的自变量相同的数据类型。在边界情况下，函数与 DOUBLE PRECISION 数据配合使用的准确性和行为可能会有所不同，具体取决于主机系统。

4.16.1 - ABS

返回实参的绝对值。返回值与实参的数据类型相同。

行为类型

不可变

语法

ABS ( expression )

参数

expression
为 INTEGER 或 DOUBLE PRECISION 类型的值

示例

SELECT ABS(-28.7);
 abs
------
 28.7
(1 row)

4.16.2 - ACOS

返回一个 DOUBLE PRECISION 值，该值表示实参的反三角余弦。

行为类型

不可变

语法

ACOS ( expression )

参数

expression
为 DOUBLE PRECISION 类型的值

示例

SELECT ACOS (1);
 acos
------
    0
(1 row)

4.16.3 - ASIN

返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正弦。

行为类型

不可变

语法

ASIN ( expression )

参数

expression
为 DOUBLE PRECISION 类型的值

示例

SELECT ASIN(1);
      asin
-----------------
 1.5707963267949
(1 row)

4.16.4 - ATAN

返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正切。

行为类型

不可变

语法

ATAN ( expression )

参数

表达式
DOUBLE PRECISION 值

示例

SELECT ATAN(1);
       atan
-------------------
 0.785398163397448
(1 row)

4.16.5 - ATAN2

返回一个 DOUBLE PRECISION 值，该值表示实参的算术被除数的三角反正切。

行为类型

不可变

语法

ATAN2 ( quotient, divisor )

参数

quotient
为表示商的 DOUBLE PRECISION 类型的表达式
divisor
为表示除数的 DOUBLE PRECISION 类型的表达式

示例

SELECT ATAN2(2,1);
      ATAN2
------------------
 1.10714871779409
(1 row)

4.16.6 - CBRT

返回实参的立方根。返回值的类型为 DOUBLE PRECISION。

行为类型

不可变

语法

CBRT ( expression )

参数

expression
DOUBLE PRECISION 类型的值

示例

SELECT CBRT(27.0);

 cbrt
------
    3
(1 row)

4.16.7 - CEILING

将返回值向上舍入到下一个整数。例如，给定实参 5.01 和 5.99，CEILING 返回 6。CEILING 与 FLOOR 相对，它向下舍入返回值。

行为类型

不可变

语法

CEIL[ING] ( expression )

参数

表达式
解析为 INTEGER 或 DOUBLE PRECISION 值。

示例

=> SELECT CEIL(-42.8);
 CEIL
------
  -42
(1 row)

SELECT CEIL(48.01);
 CEIL
------
   49
(1 row)

4.16.8 - COS

返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角余弦。

行为类型

不可变

语法

COS ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

SELECT COS(-1);
       COS
------------------
 0.54030230586814
(1 row)

4.16.9 - COSH

返回一个 DOUBLE PRECISION 值，该值表示所传递参数的双曲余弦。

行为类型

不可变

语法

COSH ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

=> SELECT COSH(-1);
       COSH
------------------
 1.54308063481524

4.16.10 - COT

返回一个 DOUBLE PRECISION 值，该值表示实参的三角余切。

行为类型

不可变

语法

COT ( expression )

参数

expression
为 DOUBLE PRECISION 类型的值

示例

SELECT COT(1);
        cot
-------------------
 0.642092615934331
(1 row)

4.16.11 - DEGREES

将表达式从弧度转换为小数度，或从度、分钟和秒转换为小数度。返回值的类型为 DOUBLE PRECISION。

行为类型

不可变

语法

DEGREES ( { radians | degrees, minutes, seconds } )

参数

弧度

角度测量单位。2π 弧度等于全角度。

度

角度测量单位，等于全角度的 1/360。

分钟

角度测量单位，表示 1/60 度。

秒

角度测量单位，表示 1/60 分钟。

示例

SELECT DEGREES(0.5);
     DEGREES
------------------
 28.6478897565412
(1 row)


SELECT DEGREES(1,2,3);
     DEGREES
------------------
 1.03416666666667
(1 row)

4.16.12 - DISTANCE

返回两点之间的距离（以千米为单位）。指定起点和终点的纬度和经度。使用椭球体模型时，还可以指定曲率半径以实现更高的精度。

行为类型

不可变

语法

DISTANCE ( lat0, lon0, lat1, lon1 [, radius‑of‑curvature ] )

参数

lat0
起点纬度。
lon0
起点经度。
lat1
终点纬度
lon1
终点经度。
radius‑of‑curvature
指定起点与终点的中点处的地球曲率半径。当使用椭球状地球模型时，此参数允许更高的精度。如果忽略此参数，则 DISTANCE 使用 WGS-84 r1 平均半径，约为 6371.009 km。

示例

此示例查找纬度 45 度、经度 1 度的距离（以千米为单位），假设地球为球形。

SELECT DISTANCE(45,0,45,1);
      DISTANCE
----------------------
 78.6262959272162
(1 row)

4.16.13 - DISTANCEV

使用 Vincenty 公式返回两点之间的距离（以千米为单位）。由于 Vincenty 公式包含 WGS-84 椭球体模型的参数，因此无需指定曲率半径。指定起点和终点的纬度和经度。此函数的精度高于 DISTANCE 函数，但速度较慢。

行为类型

不可变

语法

DISTANCEV (lat0, lon0, lat1, lon1);

参数

lat0
指定起点的纬度。
lon0
指定起点的经度。
lat1
指定终点的纬度。
lon1
指定终点的经度。

示例

此示例查找纬度 45 度、经度 1 度的距离（以千米为单位），假设地球为椭球形。

SELECT DISTANCEV(45,0, 45,1);
    distanceV
------------------
 78.8463347095916
(1 row)

4.16.14 - EXP

返回指数函数，即某个数字的 e 次幂。返回值与实参的数据类型相同。

行为类型

不可变

语法

EXP ( exponent )

参数

exponent
为 INTEGER 或 DOUBLE PRECISION 类型表达式

示例

SELECT EXP(1.0);
       exp
------------------
 2.71828182845905
(1 row)

4.16.15 - FLOOR

将返回值向下舍入为前一个整数。例如，给定实参 5.01 和 5.99，FLOOR 返回 5。FLOOR 与 CEILING 相对，它向上舍入返回值。

行为类型

不可变

语法

FLOOR ( expression )

参数

表达式
解析为 INTEGER 或 DOUBLE PRECISION 值。

示例

=> SELECT FLOOR((TIMESTAMP '2005-01-17 10:00' - TIMESTAMP '2005-01-01') / INTERVAL '7');
 FLOOR
-------
     2
(1 row)


=> SELECT FLOOR(-42.8);
 FLOOR
-------
   -43
(1 row)


=> SELECT FLOOR(42.8);
 FLOOR
-------
    42
(1 row)

虽然以下示例看似 INTEGER，但左侧的数字为 INTEGER (2^49)，而右侧的数字为 FLOAT：

=> SELECT 1<<49, FLOOR(1 << 49);
    ?column?     |      floor
-----------------+-----------------
 562949953421312 | 562949953421312
(1 row)

将前一示例与以下示例进行比较：

=> SELECT 1<<50, FLOOR(1 << 50);
     ?column?     |        floor
------------------+----------------------
 1125899906842624 | 1.12589990684262e+15
(1 row)

4.16.16 - HASH

通过函数实参计算哈希值，从而产生位于范围 0 <= x < 263 内的值。

HASH 函数通常用于对一组群集节点中的投射进行分段。此函数基于行在列中的值选择每个行的特定节点。HASH 函数在群集中均匀分布数据，有利于优化查询执行。

行为类型

不可变

语法

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

参数

* | expression[,...]
以下几项之一：

  • * （星号）

    指定对查询表中的所有列运行哈希。

  • 表达式

    任何数据类型的表达式。expression 中包含的函数必须具有确定性。如果在投影的哈希分段子句中指定，各表达式通常解析为 列引用。

示例

=> SELECT HASH(product_price, product_cost) FROM product_dimension
     WHERE product_price = '11';
        hash
---------------------
 4157497907121511878
 1799398249227328285
 3250220637492749639
(3 rows)

另请参阅

哈希分段子句

4.16.17 - LN

返回实参的自然对数。返回数据类型与实参相同。

行为类型

不可变

语法

LN ( expression )

参数

expression
为 INTEGER 或 DOUBLE PRECISION 类型表达式

示例

SELECT LN(2);
        ln
-------------------
 0.693147180559945
(1 row)

4.16.18 - LOG

返回实参的指定底的对数。返回值的数据类型与传递参数的数据类型相同。

行为类型

不可变

语法

LOG ( [ base, ] expression )

参数

base
指定基数（默认值为基数 10）
expression
INTEGER 或 DOUBLE PRECISION 类型表达式

示例

=> SELECT LOG(2.0, 64);
 LOG
-----
   6
(1 row)

SELECT LOG(100);
 LOG
-----
   2
(1 row)

4.16.19 - LOG10

返回 10 个基本实参对数，也被称为常用对数。返回值的数据类型与通过参数的数据类型相同。

行为类型

不可变

语法

LOG10 ( expression )

参数

expression
INTEGER 或 DOUBLE PRECISION 类型表达式

示例

=> SELECT LOG10(30);
       LOG10
------------------
 1.47712125471966
(1 row)

4.16.20 - MOD

返回除法运算的余数。

行为类型

不可变

语法

MOD( expression1, expression2 )

参数

expression1
指定被除数的数字数据类型。
expression2
指定除数的数字数据类型。

计算规则

计算 MOD(expression1, expression2) 是采用下列规则：

  • 如果 expression1 或 expression2 是 NULL 值，则结果是 NULL 值。

  • 如果 expression2 是零，则出现例外情况：数据异常 — 除数为 0。

  • 否则，结果是唯一的确切数字值 R，标度为 0 (zero)，则下列各项为 true：

    • R 与 expression2 具有相同的符号。

    • R 的绝对值小于 expression1 的绝对值。

    • 对于标度为 0 (零) 的一些精确数字值 K，expression2 = expression1 * K + R。

示例

SELECT MOD(9,4);
 mod
-----
   1
(1 row)


SELECT MOD(10,3);
 mod
-----
   1
(1 row)


SELECT MOD(-10,3);
 mod
-----
  -1
(1 row)


SELECT MOD(-10,-3);
 mod
-----
  -1
(1 row)


SELECT MOD(10,-3);
 mod
-----
   1
(1 row)

=> SELECT MOD(6.2,0);
ERROR 3117:  Division by zero

4.16.21 - PI

返回常数 pi (P)，即欧式几何中任何圆的周长与其直径的比值。返回类型为 DOUBLE PRECISION。

行为类型

不可变

语法

PI()

示例

SELECT PI();
        pi
------------------
 3.14159265358979
(1 row)

4.16.22 - POWER

返回 DOUBLE PRECISION 值，表示一个数字的另一个数字的幂。

行为类型

不可变

语法

POW[ER] ( expression1, expression2 )

参数

expression1
表示基数的 DOUBLE PRECISION 值。
expression2
表示指数的 DOUBLE PRECISION 值。

示例

SELECT POWER(9.0, 3.0);
 power
-------
   729
(1 row)

4.16.23 - RADIANS

返回一个 DOUBLE PRECISION 值，该值表示以弧度表示的角度。您可以在 DEGREES 中表达输入角度，并且可以选择包括分钟数和秒数。

行为类型

不可变

语法

RADIANS (degrees [, minutes, seconds])

参数

degrees
角度测量单位，表示全角度的 1/360。
minutes
角度测量单位，表示 1/60 度。
seconds
角度测量单位，表示 1/60 分钟。

示例

SELECT RADIANS(45);
      RADIANS
-------------------
 0.785398163397448
(1 row)


SELECT RADIANS (1,2,3);
      RADIANS
-------------------
 0.018049613347708
(1 row)

4.16.24 - RANDOM

返回均匀分布的随机 DOUBLE PRECISION 值 x，其中 0 <= x < 1。

典型的伪随机发生器接受一个种子，该种子被设置为生成可重现的伪随机序列。但是，Vertica 会在节点群集中分布 SQL 处理，其中每个节点都产生其自己的独立随机序列。

基于 RANDOM 的结果是不可重现的，因为该工作可能在各个节点之间以不同方式划分。因此，Vertica 会在每次执行请求时为每个节点自动生成真正的随机种子，并且不会提供一种机制来强制生成特定种子。

行为类型

易变

语法

RANDOM()

示例

在下例中，RANDOM 返回 ≥ 0 且 < 1.0 的浮点数：

SELECT RANDOM();
      random
-------------------
 0.211625560652465
(1 row)

4.16.25 - RANDOMINT

接受并返回 INTEGER 值。 RANDOMINT(n) 返回从 0 到 n – 1 的 n 个整数之一。

典型的伪随机发生器接受一个种子，该种子被设置为生成可重现的伪随机序列。但是，Vertica 会在节点群集中分布 SQL 处理，其中每个节点都产生其自己的独立随机序列。

基于 RANDOM 的结果是不可重现的，因为该工作可能在各个节点之间以不同方式划分。因此，Vertica 会在每次执行请求时为每个节点自动生成真正的随机种子，并且不会提供一种机制来强制生成特定种子。

行为类型

易变

语法

RANDOMINT ( n )

参数

接受的值为介于 1 到 9,223,372,036,854,775,807 之间的任何正整数 (n)。

有关整数数据类型的常规信息，请参阅 INTEGER 部分。

限制

如果提供负值或超出最大值，Vertica 将返回错误。

示例

在下例中，结果为 INTEGER，即 >= 0 且 < n，从集合 {0,1,2,3,4} 中随机选择。

=> SELECT RANDOMINT(5);
RANDOMINT
----------
        3
(1 row)

4.16.26 - RANDOMINT_CRYPTO

接受并返回从 0 到指定函数实参 -1 之间的一组值中的一个 INTEGER 值。对于此加密随机数生成器，Vertica 使用 RAND_bytes 提供随机值。

行为类型

易变

语法

RANDOMINT_CRYPTO ( integer‑expression )

参数

integer‑expression
解析为介于 1 到 263（包含 1）之间的正整数。

示例

在下例中，RANDOMINT_CRYPTO 返回 >= 0 且小于指定实参 5 的 INTEGER，从集合 {0,1,2,3,4} 中随机选择。

=> SELECT RANDOMINT_crypto(5);
RANDOMINT_crypto
----------------
               3
(1 row)

4.16.27 - ROUND

将值四舍五入到指定的小数位数，保留原始精度和小数位数。大于或等于 0.5 的小数部分将四舍五入。小于 0.5 的分数向下舍入（截断）。

行为类型

不可变

语法

ROUND ( expression [ , places ] )

参数

expression
为 NUMERIC 或 DOUBLE PRECISION (FLOAT) 类型的表达式。
places
INTEGER 值。当 places 为正整数时，Vertica 使用指定位数对小数点右侧的值进行四舍五入。当 places 为负整数时，Vertica 使用指定位数对小数点左侧的值进行四舍五入。

注意

将 ROUND 与 NUMERIC 数据类型配合使用，则返回 NUMERIC 并保留原始精度和标度。

=> SELECT ROUND(3.5);
 ROUND
-------
   4.0
(1 row)

示例

=> SELECT ROUND(2.0, 1.0) FROM dual;
 ROUND
-------
   2.0
(1 row)

=> SELECT ROUND(12.345, 2.0);
 ROUND
--------
 12.350
(1 row)

=> SELECT ROUND(3.444444444444444);
       ROUND
-------------------
 3.000000000000000
(1 row)

=> SELECT ROUND(3.14159, 3);
  ROUND
---------
 3.14200
(1 row)

=> SELECT ROUND(1234567, -3);
  ROUND
---------
 1235000
(1 row)

=> SELECT ROUND(3.4999, -1);
 ROUND
--------
 0.0000
(1 row)

以下示例创建了一个包含两列的表，添加了一行值，显示小数点左侧和右侧的舍入示例。

=> CREATE TABLE sampleround (roundcol1 NUMERIC, roundcol2 NUMERIC);
CREATE TABLE

=> INSERT INTO sampleround VALUES (1234567, .1234567);
 OUTPUT
--------
      1
(1 row)

=> SELECT ROUND(roundcol1,-3) AS pn3, ROUND(roundcol1,-4) AS pn4, ROUND(roundcol1,-5) AS pn5 FROM sampleround;

           pn3           |           pn4           |           pn5
-------------------------+-------------------------+-------------------------
 1235000.000000000000000 | 1230000.000000000000000 | 1200000.000000000000000
(1 row)

=> SELECT ROUND(roundcol2,3) AS p3, ROUND(roundcol2,4) AS p4, ROUND(roundcol2,5) AS p5 FROM sampleround;

        p3         |        p4         |        p5
-------------------+-------------------+-------------------
 0.123000000000000 | 0.123500000000000 | 0.123460000000000
(1 row)

4.16.28 - SIGN

返回 DOUBLE PRECISION 值 -1、0 或 1，该值表示实参的算术符号。

行为类型

不可变

语法

SIGN ( expression )

参数

expression
为 DOUBLE PRECISION 类型表达式

示例

SELECT SIGN(-8.4);
 sign
------
   -1
(1 row)

4.16.29 - SIN

返回 DOUBLE PRECISION 值，表示已传递参数的三角正弦。

行为类型

不可变

语法

SIN ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

SELECT SIN(30 * 2 * 3.14159 / 360);
        SIN
-------------------
 0.499999616987256
(1 row)

4.16.30 - SINH

返回 DOUBLE PRECISION 值，表示已传递参数的双曲正弦。

行为类型

不可变

语法

SINH ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

=> SELECT SINH(30 * 2 * 3.14159 / 360);
        SINH
-------------------
 0.547852969600632

4.16.31 - SQRT

返回一个 DOUBLE PRECISION 值，该值表示实参的算术平方根。

行为类型

不可变

语法

SQRT ( expression )

参数

expression
为 DOUBLE PRECISION 类型表达式

示例

SELECT SQRT(2);
      sqrt
-----------------
 1.4142135623731
(1 row)

4.16.32 - TAN

返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角正切。

行为类型

不可变

语法

TAN ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

=> SELECT TAN(30);
        TAN
-------------------
 -6.40533119664628
(1 row)

4.16.33 - TANH

返回 DOUBLE PRECISION 值表示传递参数的双曲正切。

行为类型

不可变

语法

TANH ( expression )

参数

expression
DOUBLE PRECISION 类型的表达式

示例

=> SELECT TANH(-1);
        TANH
-------------------
  -0.761594155955765

4.16.34 - TRUNC

返回完全截断的 expression 值（接近零）。提供 places 实参可将表达式截断为您指定的小数位数。

行为类型

不可变

语法

TRUNC ( expression [ , places ] )

参数

expression
为 NUMERIC 或 DOUBLE PRECISION (FLOAT) 类型的表达式。
places
INTEGER 值。当 places 为正整数时，Vertica 可对小数点右侧的值进行截断。当 places 为负整数时，Vertica 可对小数点左侧的值进行截断。

注意

将 TRUNC 与 NUMERIC 数据类型配合使用，则返回 NUMERIC 并保留原始精度和标度。

=> SELECT TRUNC(3.5);
 TRUNC
-------
   3.0
(1 row)

示例

=> SELECT TRUNC(42.8);
 TRUNC
-------
  42.0
(1 row)

=> SELECT TRUNC(42.4382, 2);
  TRUNC
---------
 42.4300
(1 row)

以下示例创建了一个包含两列的表，添加了一行值，显示小数点左侧和右侧的截断示例。

=> CREATE TABLE sampletrunc (truncol1 NUMERIC, truncol2 NUMERIC);
CREATE TABLE

=> INSERT INTO sampletrunc VALUES (1234567, .1234567);
 OUTPUT
--------
      1
(1 row)

=> SELECT TRUNC(truncol1,-3) AS p3, TRUNC(truncol1,-4) AS p4, TRUNC(truncol1,-5) AS p5 FROM sampletrunc;

           p3            |           p4            |           p5
-------------------------+-------------------------+-------------------------
 1234000.000000000000000 | 1230000.000000000000000 | 1200000.000000000000000
(1 row)

=> SELECT TRUNC(truncol2,3) AS p3, TRUNC(truncol2,4) AS p4, TRUNC(truncol2,5) AS p5 FROM sampletrunc;

        p3         |        p4         |        p5
-------------------+-------------------+-------------------
 0.123000000000000 | 0.123400000000000 | 0.123450000000000
(1 row)

4.16.35 - WIDTH_BUCKET

构建等宽直方图，其中直方图的范围被分为相同大小的区间（存储桶）。此外，低存储桶以下的值返回 0，高存储桶以上的值返回 bucket_count +1。返回整数值。

行为类型

不可变

语法

WIDTH_BUCKET ( expression, hist_min, hist_max, bucket_count )

参数

expression
为其创建直方图的表达式。此表达式必须评估为 numeric 或 datetime 值，或可隐式转换为 numeric 或 datetime 值。如果 expression 求值结果为 NULL，则 expression 返回 NULL。
hist_min
一个表达式，解析为存储桶 1 的下限。必须也评估为 numeric 或 datetime 值，不能评估为 null。
hist_max
一个表达式，解析为存储桶 bucket_count 上限。必须也评估为 numeric 或 datetime 值，不能评估为 null。
bucket_count
一个表达式，解析为常数，代表存储桶的数量。此表达式始终评估为正数 INTEGER。

注意

  • WIDTH_BUCKET 将数据集分成多个等宽的存储桶。例如，Age = 0–20, 20–40, 40–60, 60–80。这称为等宽直方图。

  • 使用 WIDTH_BUCKET 时，请注意最小和最大边界值。每个存储桶包含等于或大于该存储桶基准数的值，所以年龄范围 0–20、20–40 等等实际上是 0–19.99 和 20–39.999。

  • WIDTH_BUCKET 接受以下数据类型：（FLOAT 和/或 INTEGER）、（TIMESTAMP 和/或 DATE 和/或 TIMESTAMPTZ）或 （INTERVAL和/或 TIME）。

示例

下述示例返回五个可能值，有三个存储桶：0 [100以下)、1 [100–300)、2 [300–500)、3 [500–700) 和 4 [700 及以上)：

SELECT product_description, product_cost, WIDTH_BUCKET(product_cost, 100, 700, 3);

下述示例针对康涅狄格州的女医生顾客，在 annual_income 列上创建包含九个存储桶的直方图。结果将存储桶编号返回到“Income”列，共分为 11 个存储桶，其中包括下溢桶和溢出桶。请注意，如果顾客的年收入高于最大值，则分配到溢出桶 10：

SELECT customer_name, annual_income, WIDTH_BUCKET (annual_income, 100000, 1000000, 9) AS "Income"
FROM public.customer_dimension WHERE customer_state='CT'
AND title='Dr.' AND customer_gender='Female' AND household_id < '1000'
ORDER BY "Income";

在下述结果集中，之所以有存储桶 0，是因为存储桶从 1 到 bucket_count 进行编号。任何低于 hist_min 给定值的，都进入存储桶 0；任何高于 hist_max 给定值的，都进入存储桶 bucket_count+1。在这个示例中，存储桶 9 是空的，没有溢出。值 12,283 小于 100,000，因此进入下溢桶。

   customer_name    | annual_income | Income
--------------------+---------------+--------
 Joanna A. Nguyen   |         12283 |      0
 Amy I. Nguyen      |        109806 |      1
 Juanita L. Taylor  |        219002 |      2
 Carla E. Brown     |        240872 |      2
 Kim U. Overstreet  |        284011 |      2
 Tiffany N. Reyes   |        323213 |      3
 Rebecca V. Martin  |        324493 |      3
 Betty . Roy        |        476055 |      4
 Midori B. Young    |        462587 |      4
 Martha T. Brown    |        687810 |      6
 Julie D. Miller    |        616509 |      6
 Julie Y. Nielson   |        894910 |      8
 Sarah B. Weaver    |        896260 |      8
 Jessica C. Nielson |        861066 |      8
(14 rows)

另请参阅

4.17 - NULL 处理函数

NULL 处理函数可接受任何类型的自变量，返回类型基于其自变量类型。

4.17.1 - COALESCE

返回列表中第一个非空表达式的值。如果所有表达式的求值均为 NULL，则 COALESCE 返回 NULL。

COALESCE 符合 ANSI SQL-92 标准。

行为类型

不可变

语法

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

参数

* | expression[,...]
以下几项之一：

  • * （星号）

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

  • 表达式

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

示例

COALESCE 返回从表 lead_vocalists 查询的每一行中的第一个非空值。请注意，在第一行中，COALESCE 返回空字符串。

=> SELECT quote_nullable(fname)fname, quote_nullable(lname)lname,
     quote_nullable(coalesce (fname, lname)) "1st non-null value" FROM lead_vocalists ORDER BY fname;
  fname  |   lname   | 1st non-null value
---------+-----------+--------------------
 ''      | 'Sting'   | ''
 'Diana' | 'Ross'    | 'Diana'
 'Grace' | 'Slick'   | 'Grace'
 'Mick'  | 'Jagger'  | 'Mick'
 'Steve' | 'Winwood' | 'Steve'
 NULL    | 'Cher'    | 'Cher'
(6 rows)

另请参阅

4.17.2 - IFNULL

返回列表中第一个非空表达式的值。

IFNULL 为 NVL 的别名。

行为类型

不可变

语法

IFNULL ( expression1 , expression2 );

参数

  • 如果 expression1 为 NULL，则 IFNULL 返回 expression2。

  • 如果 expression1 不为 NULL，则 IFNULL 返回 expression1。

注意

  • COALESCE 为更标准、更通用的函数。

  • IFNULL 等同于 ISNULL。

  • IFNULL 等同于 COALESCE，但 IFNULL 仅通过两个实参调用。

  • ISNULL(a,b) 与 x IS NULL 不同。

  • 实参可以包含 Vertica 支持的所有数据类型。

  • 实施等同于 CASE 表达式。例如：

    CASE WHEN expression1 IS NULL THEN expression2
ELSE expression1 END;

  • 以下语句返回值 140：

    SELECT IFNULL(NULL, 140) FROM employee_dimension;

  • 以下语句返回值 60：

    SELECT IFNULL(60, 90) FROM employee_dimension;

示例

=> SELECT IFNULL (SCORE, 0.0) FROM TESTING;
 IFNULL
--------
  100.0
   87.0
     .0
     .0
     .0
(5 rows)

另请参阅

4.17.3 - ISNULL

返回列表中第一个非空表达式的值。

ISNULL 为 NVL 的别名。

行为类型

不可变

语法

ISNULL ( expression1 , expression2 );

参数

  • 如果 expression1 为 NULL，则 ISNULL 返回 expression2。

  • 如果 expression1 不为 NULL，则 ISNULL 返回 expression1。

注意

  • COALESCE 为更标准、更通用的函数。

  • ISNULL 等同于 COALESCE，但 ISNULL 仅通过两个实参调用。

  • ISNULL(a,b) 与 x IS NULL 不同。

  • 实参可以包含 Vertica 支持的所有数据类型。

  • 实施等同于 CASE 表达式。例如：

    CASE WHEN expression1 IS NULL THEN expression2
ELSE expression1 END;

  • 以下语句返回值 140：

    SELECT ISNULL(NULL, 140) FROM employee_dimension;

  • 以下语句返回值 60：

    SELECT ISNULL(60, 90) FROM employee_dimension;

示例

SELECT product_description, product_price,
ISNULL(product_cost, 0.0) AS cost
FROM product_dimension;
      product_description       | product_price | cost
--------------------------------+---------------+------
 Brand #59957 wheat bread       |           405 |  207
 Brand #59052 blueberry muffins |           211 |  140
 Brand #59004 english muffins   |           399 |  240
 Brand #53222 wheat bread       |           323 |   94
 Brand #52951 croissants        |           367 |  121
 Brand #50658 croissants        |           100 |   94
 Brand #49398 white bread       |           318 |   25
 Brand #46099 wheat bread       |           242 |    3
 Brand #45283 wheat bread       |           111 |  105
 Brand #43503 jelly donuts      |           259 |   19
(10 rows)

另请参阅

4.17.4 - NULLIF

比较两个表达式。如果两个表达式不相等，则该函数返回第一个表达式 (expression1)。如果两个表达式相等，则该函数返回 null。

行为类型

不可变

语法

NULLIF( expression1, expression2 )

参数

expression1
是任何数据类型的值。
expression2
必须与 expr1 具有相同的数据类型，或者其类型必须可以隐式转换为与 expression1 相匹配。结果与 expression1 具有相同的类型。

示例

下面的一系列语句说明了 NULLIF 函数的一个简单用法。

创建包含单列的表 t and insert some values：

CREATE TABLE t (x TIMESTAMPTZ);
INSERT INTO t VALUES('2009-09-04 09:14:00-04');
INSERT INTO t VALUES('2010-09-04 09:14:00-04');

发出 select 语句：

SELECT x, NULLIF(x, '2009-09-04 09:14:00 EDT') FROM t;
           x            |         nullif
------------------------+------------------------
 2009-09-04 09:14:00-04 |
 2010-09-04 09:14:00-04 | 2010-09-04 09:14:00-04
SELECT NULLIF(1, 2);
 NULLIF
--------
      1
(1 row)
SELECT NULLIF(1, 1);
 NULLIF
--------
(1 row)
SELECT NULLIF(20.45, 50.80);
 NULLIF
--------
  20.45
(1 row)

4.17.5 - NULLIFZERO

如果列中的值为 0，则计算结果为 NULL。

语法

NULLIFZERO(expression)

参数

expression
（INTEGER、DOUBLE PRECISION、INTERVAL 或 NUMERIC）是 0 值求值的字符串。

示例

下表 TESTING 显示了 5 名学生的测试得分。请注意，缺少 S. Robinson 和 K. Johnson 的测试得分（NULL 值显示在“分数 (Score)”列中。）

=> SELECT * FROM TESTING;
    Name     | Score
-------------+-------
 J. Doe      |   100
 R. Smith    |    87
 L. White    |     0
 S. Robinson |
 K. Johnson  |
(5 rows)

下面的 SELECT 语句指定 Vertica 应将“分数 (Score)”列中的任何 0 值返回为 Null。在结果中，您可以看到 Vertica 将 L. White 的 0 分返回为 Null。

=> SELECT Name, NULLIFZERO(Score) FROM TESTING;
    Name     | NULLIFZERO
-------------+------------
 J. Doe      |        100
 R. Smith    |         87
 L. White    |
 S. Robinson |
 K. Johnson  |
(5 rows)

4.17.6 - NVL

返回列表中第一个非空表达式的值。

行为类型

不可变

语法

NVL ( expression1 , expression2 );

参数

  • 如果 expression1 为 NULL，则 NVL 返回 expression2。

  • 如果 expression1 不为 NULL，则 NVL 返回 expression1。

注意

  • COALESCE 为更标准、更通用的函数。

  • NVL 等同于 COALESCE，但 NVL 仅通过两个实参调用。

  • 实参可以包含 Vertica 支持的所有数据类型。

  • 实施等同于 CASE 表达式：

    CASE WHEN expression1 IS NULL THEN expression2
    ELSE expression1 END;

示例

expression1 不为 NULL，因此 NVL 返回 expression1：

SELECT NVL('fast', 'database');
nvl
------
 fast
(1 row)

expression1 为 NULL，因此 NVL 返回 expression2：

SELECT NVL(null, 'database');
nvl
----------
 database
(1 row)

expression2 为 NULL，因此 NVL 返回 expression1：

SELECT NVL('fast', null);
nvl
------
 fast
(1 row)

在以下示例中，expression1 (title) 包含 NULL，因此 NVL 返回 expression2 并将 "Withheld" 替换为未知值：

SELECT customer_name, NVL(title, 'Withheld') as title
FROM customer_dimension
ORDER BY title;
     customer_name      | title
------------------------+-------
 Alexander I. Lang      | Dr.
 Steve S. Harris        | Dr.
 Daniel R. King         | Dr.
 Luigi I. Sanchez       | Dr.
 Duncan U. Carcetti     | Dr.
 Meghan K. Li           | Dr.
 Laura B. Perkins       | Dr.
 Samantha V. Robinson   | Dr.
 Joseph P. Wilson       | Mr.
 Kevin R. Miller        | Mr.
 Lauren D. Nguyen       | Mrs.
 Emily E. Goldberg      | Mrs.
 Darlene K. Harris      | Ms.
 Meghan J. Farmer       | Ms.
 Bettercare             | Withheld
 Ameristar              | Withheld
 Initech                | Withheld
(17 rows)

另请参阅

4.17.7 - NVL2

接受三个实参。如果第一个实参不为 NULL，则返回第二个实参，否则返回第三个实参。如果第二个实参与第三个实参的数据类型不一致，则隐式转换为通用类型，类似于 COALESCE。

行为类型

不可变

语法

NVL2 ( expression1 , expression2 , expression3 );

参数

  • 如果 expression1 不为 NULL，则 NVL2 返回 expression2。

  • 如果 expression1 为 NULL，则 NVL2 返回 expression3。

注意

实参 2 和 3 可为 Vertica 支持的任何数据类型。

实施等同于 CASE 表达式：

CASE WHENexpression1IS NOT NULL THENexpression2ELSEexpression3 END;

示例

在此示例中，expression1 不为 NULL，因此 NVL2 返回 expression2：

SELECT NVL2('very', 'fast', 'database');
nvl2
------
 fast
(1 row)

在此示例中，expression1 为 NULL，因此 NVL2 返回 expression3：

SELECT NVL2(null, 'fast', 'database');
nvl2
----------
 database
(1 row)

在以下示例中，expression1 (title) 包含 NULL，因此 NVL2 返回 expression3 ("Withheld")，同时将非空值替换为表达式 "Known"：

SELECT customer_name, NVL2(title, 'Known', 'Withheld')
as title
FROM customer_dimension
ORDER BY title;
     customer_name      | title
------------------------+-------
 Alexander I. Lang      | Known
 Steve S. Harris        | Known
 Daniel R. King         | Known
 Luigi I. Sanchez       | Known
 Duncan U. Carcetti     | Known
 Meghan K. Li           | Known
 Laura B. Perkins       | Known
 Samantha V. Robinson   | Known
 Joseph P. Wilson       | Known
 Kevin R. Miller        | Known
 Lauren D. Nguyen       | Known
 Emily E. Goldberg      | Known
 Darlene K. Harris      | Known
 Meghan J. Farmer       | Known
 Bettercare             | Withheld
 Ameristar              | Withheld
 Initech                | Withheld
(17 rows)

另请参阅

4.17.8 - ZEROIFNULL

如果列为 NULL，则计算为 0。

语法

ZEROIFNULL(expression)

参数

表达式
用于 NULL 值求值的字符串，以下数据类型之一：

  • INTEGER

  • DOUBLE PRECISION

  • INTERVAL

  • NUMERIC

示例

以下查询从表 test_results 返回 5 名学生的得分，其中 L. White 的 Score 设置为 0，S. Robinson 和 K. Johnson 设置为 NULL：

=> SELECT Name, Score FROM test_results;
    Name     | Score
-------------+-------
 J. Doe      |   100
 R. Smith    |    87
 L. White    |     0
 S. Robinson |
 K. Johnson  |
(5 rows)

下一项查询对列 Score 调用 ZEROIFNULL，因此 Vertica 为 S. Robinson 和 K. Johnson 返回 0：

=> SELECT Name, ZEROIFNULL (Score) FROM test_results;
    Name     | ZEROIFNULL
-------------+------------
 J. Doe      |        100
 R. Smith    |         87
 L. White    |          0
 S. Robinson |          0
 K. Johnson  |          0
(5 rows)

您还可以在 PARTITION BY expressions 中使用 ZEROIFNULL，必须始终解析为非空值。例如：

CREATE TABLE t1 (a int, b int) PARTITION BY (ZEROIFNULL(a));
CREATE TABLE

Vertica 在对表t1 进行分区时调用此函数，通常是在加载操作期间执行。加载期间，函数会检查 PARTITION BY 表达式（在本例中为列 a）的数据是否存在 NULL 值。如果在给定行中遇到 NULL 值，则将分区键设置为 0，而不是返回错误。

4.18 - 性能分析函数

此部分中的函数支持配置和分析数据库和查询性能。

4.18.1 - 配置函数

此部分包含特定于 Vertica 的配置函数。

4.18.1.1 - CLEAR_PROFILING

从指定分析类型的内存数据中清除。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_PROFILING( 'profiling-type' [, 'scope'] )

参数

profiling-type
要清除的分析数据的类型：

  • session：清除对基本会话参数的配置，并锁定超时数据。

  • query：清除对已运行的查询的常规信息的配置，例如使用的查询字符串和查询持续时间。

  • ee：清除对关于每个查询的执行运行的信息的配置。

scope
指定清除对指定数据进行配置的范围，为以下之一：

  • local：清除当前会话的分析数据。

  • global：清除所有数据库会话的配置数据。

示例

以下语句清除了对查询所做分析的数据：

=> SELECT CLEAR_PROFILING('query');

另请参阅

4.18.1.2 - DISABLE_PROFILING

禁止当前会话收集指定类型的分析数据。有关详细信息，请参阅 启用分析。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISABLE_PROFILING( 'profiling-type' )

参数

profiling-type
将禁用的分析数据类型：

  • session：禁用针对基本会话参数和锁定超时数据的分析。

  • query：禁用针对运行的查询相关常规信息（如，使用的查询字符串和查询持续时间）的分析。

  • ee：禁用针对各查询的执行运行相关信息的分析。

示例

以下语句可禁用对查询执行运行的分析：

=> SELECT DISABLE_PROFILING('ee');
   DISABLE_PROFILING
-----------------------
 EE Profiling Disabled
(1 row)

另请参阅

4.18.1.3 - ENABLE_PROFILING

允许当前会话收集指定类型的分析数据。有关详细信息，请参阅 启用分析。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLE_PROFILING( 'profiling-type' )

参数

profiling-type
要启用的分析数据的类型：

  • session：启用针对基本会话参数和锁定超时数据的配置。

  • query：启用针对运行的查询的常规信息（如查询字符串和查询持续时间）的配置。

  • ee：启用针对各查询的执行运行信息的配置。

示例

下列语句将启用对查询执行运行的分析：

=> SELECT ENABLE_PROFILING('ee');
   ENABLE_PROFILING
----------------------
 EE Profiling Enabled
(1 row)

另请参阅

4.18.1.4 - SHOW_PROFILING_CONFIG

显示是否启用分析。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

SHOW_PROFILING_CONFIG ()

示例

以下语句显示为所有分析类型（会话、执行引擎和查询）启用了全局分析：

=> SELECT SHOW_PROFILING_CONFIG();
SHOW_PROFILING_CONFIG
------------------------------------------
 Session Profiling: Session off, Global on
 EE Profiling:      Session off, Global on
 Query Profiling:   Session off, Global on
(1 row)

另请参阅

4.18.2 - 统计信息管理函数

此部分包含用于收集和管理表数据统计信息的 Vertica 函数。

4.18.2.1 - ANALYZE_EXTERNAL_ROW_COUNT

计算外部表中的确切行数。 ANALYZE_EXTERNAL_ROW_COUNT 在后台运行。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_EXTERNAL_ROW_COUNT ('[[[database.]schema.]table‑name ]')

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
指定要计算精确行计数的外部表的名称。如果提供空字符串，Vertica 会计算所有外部表的精确行数。

特权

外部表上的任何 INSERT/UPDATE/DELETE 权限

示例

计算所有外部表的精确行计数：

=> SELECT ANALYZE_EXTERNAL_ROW_COUNT('');

计算表 loader_rejects 的精确行计数：

=> SELECT ANALYZE_EXTERNAL_ROW_COUNT('loader_rejects');

另请参阅

4.18.2.2 - ANALYZE_STATISTICS

从存储与指定表相关联的投影的所有节点上收集并聚合数据示例和存储信息。函数跳过复杂数据类型列。默认情况下，Vertica 会根据资源限制分析单个查询执行计划中的多个列。此类多列分析有助于实现以下目标：

  • 减少计划执行延迟。

  • 加快对相对较小且包含多列的表进行分析。

Vertica 将统计信息写入数据库编录。查询优化器将使用这些收集的数据来创建查询计划。没有这些数据，查询优化器会假设数据值均匀分布，所有投影的存储使用量相等。

您可以使用 CTRL+C 或调用 INTERRUPT_STATEMENT 取消统计信息收集。

ANALYZE_STATISTICS 为函数 ANALYZE_HISTOGRAM 的别名，不再进行记录。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_STATISTICS ('[[[database.]schema.]table]' [, 'column‑list' [, percent ]]  )

返回

0 - 成功

如果发生错误，请参阅 vertica.log 以了解详细信息。

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
在其上收集数据的表。如果设置为空字符串，Vertica 将收集所有数据库表及其投影的统计信息。
column‑list
table 中以逗号分隔的列的列表，通常为谓词列。Vertica 将数据收集范围缩小到指定的列。不支持复杂类型列。

如果通过添加列并以默认值或其他值填充其内容等方式对表进行更改，则在此列上调用 ANALYZE_STATISTICS 以获取最新统计信息。

percent
一个介于 0 和 100 之间的浮点值，指定从磁盘读取数据的百分比（不是要分析的数据量）。如果省略此实参，Vertica 会将百分比设置为 10。

如果分析超过 10% 的磁盘空间，处理时间会成比例地增加，但是得到的采样精确度较高。

特权

非超级用户：

  • 架构：USAGE

  • 表：INSERT、DELETE 或 UPDATE 之一

限制

  • Vertica 在本地和全局临时表上支持 ANALYZE_STATISTICS。在这两种情况下，只能获取使用选项 ON COMMIT PRESERVE ROWS 创建的表的统计信息。否则，Vertica 会在提交当前事务时删除表内容，因此没有可用于分析的表数据。Vertica 不从以下投影中收集任何统计数据： * 实时聚合和 Top-K 投影 * 定义为表达式中包含 SQL 函数的投影
  • Vertica 不收集任何关于 ARRAY、SET 或 ROW 类型的列的统计信息。

示例

请参阅收集表统计信息。

另请参阅

ANALYZE_STATISTICS_PARTITION

4.18.2.3 - ANALYZE_STATISTICS_PARTITION

收集并聚合指定表中一系列分区的数据示例和存储信息。Vertica 将收集的统计信息写入数据库编录。

您可以使用 CTRL+C 或元函数 INTERRUPT_STATEMENT 取消统计信息收集。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_STATISTICS_PARTITION ('[[database.]schema.]table', 'min‑range‑value','max‑range‑value' [, 'column‑list' [, percent ]] )

返回

0：成功

如果发生错误，请参阅 vertica.log 以了解详细信息。

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
在其上收集数据的表。
min‑range‑value
max‑range‑value
要分析的分区键的最小值和最大值，其中 min‑range‑value 必须≤ max‑range‑值。要分析一个分区，min‑range‑value 与 max‑range‑value 必须相等。
column‑list
table 中以逗号分隔的列的列表，通常为谓词列。Vertica 将数据收集范围缩小到指定的列。
percent
介于 0 和 100 之间的浮点值，指定从磁盘读取数据的百分比（不是要分析的数据量）。如果省略此实参，Vertica 会将百分比设置为 10。

如果分析超过 10% 的磁盘空间，处理时间会成比例地增加，但是得到的采样精确度较高。

特权

非超级用户：

  • 架构：USAGE

  • 表：INSERT、DELETE 或 UPDATE 之一

要求和限制

ANALYZE_STATISTICS_PARTITION 具有以下要求和限制：

  • 该表必须进行分区，并且不能包含未分区的数据。

  • 表分区表达式必须指定单个列。支持以下表达式：

    • 仅指定列的表达式，即对所有列值进行分区。例如：

      PARTITION BY ship_date GROUP BY CALENDAR_HIERARCHY_DAY(ship_date, 2, 2)

    • 如果列是 DATE 或 TIMESTAMP/TIMESTAMPTZ，则分区表达式可以指定支持的日期/时间函数，该函数会返回该列或其任何部分，例如月份或年份。例如，以下分区表达式指定对列 order_date 的年份部分进行分区：

      PARTITION BY YEAR(order_date)

    • 该表达式对列执行加法或减法。例如：

      PARTITION BY YEAR(order_date) -1

  • 表分区表达式不能将指定列强制转换为另一种数据类型。

  • Vertica 不从以下投影中收集任何统计数据：

    • 实时聚合投影和 Top-K 投影

    • 定义这些投影可以在表达式中包含 SQL 函数

示例

请参阅收集分区统计信息。

4.18.2.4 - DROP_EXTERNAL_ROW_COUNT

移除使用 ANALYZE_EXTERNAL_ROW_COUNT 编译的外部表行计数统计信息。 DROP_EXTERNAL_ROW_COUNT 在后台运行。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_EXTERNAL_ROW_COUNT ('[[[database.]schema.]table‑name ]');

参数

架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
要移除精确行计数的外部表。如果指定空字符串，Vertica 会删除所有外部表的精确行计数统计信息。

特权

  • 对表的 INSERT/UPDATE/DELETE 权限

  • 包含表的架构上的 USAGE 权限

示例

删除外部表 loader_rejects 的行计数统计信息：

=> SELECT DROP_EXTERNAL_ROW_COUNT('loader_rejects');

另请参阅

收集数据库统计信息

4.18.2.5 - DROP_STATISTICS

移除先前由 ANALYZE_STATISTICS 生成的数据库预测的统计数据。删除此数据后，Vertica 优化器会使用默认统计信息创建查询计划。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_STATISTICS ('[[[database.]schema.]table]' [, 'category' [, '[column‑list]'] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要删除统计信息的表。如果设置为空字符串，Vertica 将删除所有数据库表及其投影的统计信息。
类别
要删除的统计信息类别，为以下之一：

  • ALL （默认值）：删除所有统计信息，包括直方图和行计数。

  • HISTOGRAMS：仅删除直方图。保留行计数统计信息。

column‑list
table 中以逗号分隔的列的列表，通常为谓词列。Vertica 将删除的统计信息范围缩小到指定的列。如果省略此参数或提供空字符串，Vertica 会删除所有列的统计信息。

特权

非超级用户：

  • 架构：USAGE

  • 表：INSERT、DELETE 或 UPDATE 之一

示例

删除表 store.store_sales_fact 的所有基础统计信息：

=> SELECT DROP_STATISTICS('store.store_sales_fact');
 DROP_STATISTICS
-----------------
               0
(1 row)

删除所有表投影的统计信息：

=> SELECT DROP_STATISTICS ('');
 DROP_STATISTICS
-----------------
               0
(1 row)

另请参阅

DROP_STATISTICS_PARTITION

4.18.2.6 - DROP_STATISTICS_PARTITION

移除先前由 ANALYZE_STATISTICS_PARTITION 生成的数据库预测的统计数据。删除此数据后，Vertica 优化器会使用表级统计信息（如果可用）或默认统计信息创建查询计划。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_STATISTICS_PARTITION ('[[database.]schema.]table', '[min‑range‑value]', '[max‑range‑value]' [, category [, '[column‑list]'] )

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要删除统计信息的表。
min‑range‑value max‑range‑value
要删除统计信息的分区键的最小值和最大值，其中 min-range-value 必须 ≤ max‑range‑value。如果您为这两个参数提供空字符串，Vertica 会删除此表或指定列的所有分区级统计信息。
类别
要删除的统计信息类别，为以下之一：

  • BASE （默认值）：删除直方图和行计数（最小/最大列值、直方图）。

  • HISTOGRAMS：仅删除直方图。保留行计数统计信息。

  • ALL：删除所有统计信息。

column‑list
table 中以逗号分隔的列的列表，通常为谓词列。Vertica 将删除的统计信息范围缩小到指定的列。如果省略此参数或提供空字符串，Vertica 会删除所有列的统计信息。

特权

非超级用户：

  • 架构：USAGE

  • 表：INSERT、DELETE 或 UPDATE 之一

另请参阅

DROP_STATISTICS

4.18.2.7 - EXPORT_STATISTICS

从先前通过 ANALYZE_STATISTICS 收集的数据生成 XML 格式的统计信息。导出统计信息之前，请调用 ANALYZE_STATISTICS 以收集最新数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

EXPORT_STATISTICS ('[ filename ]' [,'table‑spec' [,'column[,...]']])

参数

filename
指定在何处写入生成的 XML。如果 filename 已存在，EXPORT_STATISTICS 会覆盖它。如果您提供的是空字符串，则 EXPORT_STATISTICS 会将 XML 写入标准输出。
table‑spec
指定要在其上导出投影统计信息的表： 
  
[[database.]schema.]table

默认架构为 public。如果指定一个数据库，它必须是当前数据库。

如果省略 table‑spec 或将其设置为空字符串，Vertica 会导出数据库的所有统计信息。

列
table‑spec 中的列名称，通常为谓词列。可以指定多个逗号分隔列。Vertica 将导出的统计信息范围缩小到指定的列。

超级用户

限制

EXPORT_STATISTICS 不导出 LONG 数据类型列的统计信息。

示例

以下语句将 VMart 示例数据库的统计信息导出到文件：

=> SELECT EXPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/vmart_stats.xml');
        EXPORT_STATISTICS
-----------------------------------
Statistics exported successfully
(1 row)

下一个语句从名为 food 的表中导出单列（“价格 (price)”）的统计信息：

=> SELECT EXPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/price.xml', 'food.price');
        EXPORT_STATISTICS
-----------------------------------
Statistics exported successfully
(1 row)

另请参阅

4.18.2.8 - EXPORT_STATISTICS_PARTITION

从先前通过 ANALYZE_STATISTICS_PARTITION 收集的数据生成 XML 格式的分区级统计信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

EXPORT_STATISTICS_PARTITION ('[ filename ]', 'table‑spec', 'min‑range‑value','max‑range‑value' [, 'column[,...]' )

参数

filename
指定在何处写入生成的 XML。如果 filename 已经存在，EXPORT_STATISTICS_PARTITION 会覆盖它。如果您提供的是空字符串，则函数会写入标准输出。
table‑spec
指定要在其上导出分区统计信息的表： 
  
[[database.]schema.]table

默认架构为 public。如果指定一个数据库，它必须是当前数据库。

min‑range‑value, max‑range‑value
要导出统计信息的分区键的最小值和最大值，其中 min-range-value 必须 ≤ max‑range‑value。
列
table 中的列名称，通常为谓词列。可以指定多个逗号分隔列。Vertica 将导出的统计信息范围缩小到指定的列。

超级用户

限制

EXPORT_STATISTICS_PARTITION 不导出 LONG 数据类型列的统计信息。

另请参阅

EXPORT_STATISTICS

4.18.2.9 - IMPORT_STATISTICS

从 EXPORT_STATISTICS 生成的 XML 文件导入统计信息。导入的统计信息将覆盖 XML 文件中引用的投影的现有统计信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

IMPORT_STATISTICS ( 'filename' )

参数

filename
EXPORT_STATISTICS 生成的 XML 输入文件的路径和名称。

超级用户

限制

  • IMPORT_STATISTICS 仅导入有效的统计信息。如果源 XML 文件包含特定列的无效统计信息，则不导入这些统计信息，并且 Vertica 将发出警告。如果统计信息文件具有无效的结构，导入操作会失败。若要检查统计信息文件是否有效，请运行 VALIDATE_STATISTICS。

  • IMPORT_STATISTICS 返回 LONG 数据类型列的警告，因为 EXPORT_STATISTICS 生成的源 XML 文件中不包含该类型列的统计信息。

示例

从先前由 EXPORT_STATISTICS 创建的 XML 文件导入 VMart 数据库的统计信息：

=> SELECT IMPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/vmart_stats.xml');
                     IMPORT_STATISTICS
----------------------------------------------------------------------------
Importing statistics for projection date_dimension_super column date_key failure (stats did not contain row counts)

Importing statistics for projection date_dimension_super column date failure (stats did not contain row counts)

Importing statistics for projection date_dimension_super column full_date_description failure (stats did not contain row counts)

...

(1 row)

另请参阅

4.18.2.10 - VALIDATE_STATISTICS

验证由 EXPORT_STATISTICS 生成的 XML 文件中的统计信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

VALIDATE_STATISTICS ( 'XML‑file' )

参数

XML‑file
包含待验证统计信息的 XML 文件的路径和名称。

超级用户

报告有效统计信息

以下示例显示了统计信息有效时的结果：

=> SELECT EXPORT_STATISTICS('cust_dim_stats.xml','customer_dimension');
    EXPORT_STATISTICS
-----------------------------------
 Statistics exported successfully
(1 row)


=> SELECT VALIDATE_STATISTICS('cust_dim_stats.xml');
 VALIDATE_STATISTICS
---------------------
(1 row)

识别无效统计信息

如果 VALIDATE_STATISTICS 无法读取文档的 XML，则会引发以下错误：

=> SELECT VALIDATE_STATISTICS('/home/dbadmin/stats.xml');
                       VALIDATE_STATISTICS
----------------------------------------------------------------------------
Error validating statistics file: At line 1:1. Invalid document structure
(1 row)

如果某些表统计信息无效，VALIDATE_STATISTICS 会返回标识相关信息的报告。在以下示例中，函数报告属性 distinct、buckets、rows、count、并且 distinctCount 不能是负数。

=> SELECT VALIDATE_STATISTICS('/stats.xml');
WARNING 0:  Invalid value '-1' for attribute 'distinct' under column 'public.t.x'.
   Please use a positive value.
WARNING 0:  Invalid value '-1' for attribute 'buckets' under column 'public.t.x'.
   Please use a positive value.
WARNING 0:  Invalid value '-1' for attribute 'rows' under column 'public.t.x'.
   Please use a positive value.
WARNING 0:  Invalid value '-1' for attribute 'count' under bound '1', column 'public.t.x'.
   Please use a positive value.
WARNING 0:  Invalid value '-1' for attribute 'distinctCount' under bound '1', column 'public.t.x'.
   Please use a positive value.
 VALIDATE_STATISTICS
---------------------
 (1 row)

在这种情况下，再次对表运行 ANALYZE_STATISTICS 以创建有效统计信息。

另请参阅

4.18.3 - 工作负载管理函数

此部分包含 Vertica 专用的工作负载管理函数。

4.18.3.1 - ANALYZE_WORKLOAD

运行工作负载分析器，这是一款用于分析系统表中包含的系统信息的实用程序。

工作负载分析器可智能监控 SQL 查询的性能和工作负载历史记录、资源和配置，以确定查询性能低下的根本原因。 ANALYZE_WORKLOAD 从系统表 TUNING_RECOMMENDATIONS 返回您指定的范围和时间内的所有事件的优化建议。

优化建议基于统计信息、系统、 数据收集器事件和数据库-表-投影组合设计。工作负载分析器建议有助于快速轻松地优化查询性能。

有关常见的触发条件和建议，请参阅 工作负载分析器建议。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_WORKLOAD ( '[ scope ]' [, 'since‑time' | save‑data ] );

参数

scope
指定要分析的编录对象，如下所示： 
[[database.]schema.]table

如果设置为空字符串，Vertica 将返回所有数据库对象的建议。

如果指定一个数据库，它必须是当前数据库。

since‑time
指定分析时间范围的开始时间，时间范围一直持续到当前系统状态（包含）。如果省略此参数，"ANALYZE_WORKLOAD" 将返回自上次调用此函数以来的事件的建议。
save‑data
指定是否保存 ANALYZE_WORKLOAD 的返回值：

  • false （默认值）：将丢弃结果。

  • true：保存 ANALYZE_WORKLOAD 返回的结果。对 ANALYZE_WORKLOAD 的后续调用返回从保存结果时最后一次调用开始的结果。该调用之前的对象事件将被忽略。

返回值

从 TUNING_RECOMMENDATIONS 返回聚合优化建议。

超级用户

示例

请参阅获取优化建议。

另请参阅

4.18.3.2 - CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY

更改活动查询的运行时优先级。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY(transaction-id, 'value')

参数

transaction‑id
标识从系统表 SESSIONS 获取的事务。
value
RUNTIMEPRIORITY 值：HIGH、MEDIUM 或 LOW。

特权

  • 超级用户：无

  • 非超级用户只能更改自身查询的运行时优先级，不能提高查询的运行时优先级使其高于资源池级别。

示例

请参阅更改正在运行的查询的运行时优先级。

4.18.3.3 - CHANGE_RUNTIME_PRIORITY

更改主动运行查询的运行时优先级。请注意，虽然此函数仍然有效，但您应使用 CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY 来更改运行时优先级。 CHANGE_RUNTIME_PRIORITY 将在未来版本的 Vertica 中弃用。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CHANGE_RUNTIME_PRIORITY(TRANSACTION_ID,STATEMENT_ID, 'value')

参数

TRANSACTION_ID
会话中事务的标识符。

TRANSACTION_ID 不能为 NULL。

您可以在“会话”表中找到事务 ID。

STATEMENT_ID
由 Vertica 编录分配的唯一数字 ID，可识别当前执行的语句。

您可以在“会话”表中找到语句 ID。

您可以指定 NULL，以更改事务中当前正在运行的查询的运行时优先级。

'value'
RUNTIMEPRIORITY 值。可以为 HIGH、MEDIUM 或 LOW。

特权

不需要特殊权限。但是，非超级用户只能改他们自己查询的运行时优先级。另外，非超级用户不能将查询的运行时优先级提高至高于资源池的优先级。

示例

=> SELECT CHANGE_RUNTIME_PRIORITY(45035996273705748, NULL, 'low');

4.18.3.4 - MOVE_STATEMENT_TO_RESOURCE_POOL

尝试将指定查询移动至指定目标池。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVE_STATEMENT_TO_RESOURCE_POOL (session_id , transaction_id, statement_id, target_resource_pool_name)

参数

session_id
您想要移动的查询正在执行所的会话标识。
transaction_id
会话内事务标识。
statement_id
您想要移动的语句的唯一数字 ID。
target_resource_pool_name
您想将指定查询移至的现存资源池的名称。

输出

函数可能返回下列结果：

超级用户

示例

下面的例子显示如何将指定语句移动至调用 my_target_pool的资源池：

=> SELECT MOVE_STATEMENT_TO_RESOURCE_POOL ('v_vmart_node0001.example.-31427:0x82fbm', 45035996273711993, 1, 'my_target_pool');

另请参阅：

4.18.3.5 - SLEEP

在执行另一个语句或命令之前等待指定的秒数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SLEEP( seconds )

参数

seconds
等待时间（以一秒或多秒（0 或更高）为单位指定），使用正整数表示。单引号是可选的；例如，SLEEP(3) 与 SLEEP('3') 相同。

注意

  • 如果成功执行此函数，返回值 0；否则，因语法错误返回错误消息。

  • 不能取消休眠操作。

  • 在包含共享资源的环境中使用 SLEEP() 时应当慎重，如结合使用独占锁的事务。

示例

以下命令将暂停执行 100 秒：

=> SELECT SLEEP(100);
 sleep
-------
     0
(1 row)

4.19 - 系统信息函数

这些函数提供有关当前系统状态的信息。超级用户对所有系统信息有不受限制的访问权限，但是用户只能查看有关自身当前会话的信息。

4.19.1 - CURRENT_DATABASE

返回当前数据库的名称，等同于 DBNAME。

行为类型

稳定

语法

CURRENT_DATABASE()

示例

=> SELECT CURRENT_DATABASE;
 CURRENT_DATABASE
------------------
 VMart
(1 row)

4.19.2 - CURRENT_LOAD_SOURCE

在 COPY 语句的范围内调用时，返回加载所使用的文件名。存在以下例外：

  • 如果在 COPY 语句的上下文之外调用函数，则返回 NULL。

  • 如果通过未设置源的 UDL 调用函数，则返回字符串 <unknown>。

COPY LOCAL 不支持此函数。

行为类型

稳定

语法

CURRENT_LOAD_SOURCE()

示例

创建表并在加载时使用两个单独文件的名称填充以下其中一列：

=> CREATE TABLE t (c1 integer, c2 varchar(50), c3 varchar(200));
CREATE TABLE

=> COPY t (c1, c2, c3 AS CURRENT_LOAD_SOURCE())
   FROM '/home/load_file_1' ON exampledb_node02,
        '/home/load_file_2' ON exampledb_node03 DELIMITER ',';
Rows Loaded
-------------
5
(1 row)

=> SELECT * FROM t;
c1  |      c2      |          c3
----+--------------+-----------------------
2   |  dogs        | /home/load_file_1
1   |  cats        | /home/load_file_1
4   |  superheroes | /home/load_file_2
3   |  birds       | /home/load_file_1
5   |  whales      | /home/load_file_2
(5 rows)

4.19.3 - CURRENT_SCHEMA

返回当前架构的名称。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

CURRENT_SCHEMA()

特权

无

示例

以下命令返回当前架构的名称。

=> SELECT CURRENT_SCHEMA();
 current_schema
----------------
 public
(1 row)

以下命令将返回不带圆括号的相同结果：

=> SELECT CURRENT_SCHEMA;
 current_schema
----------------
 public
(1 row)

以下命令显示搜索路径中列于当前用户之后的当前架构：

=> SHOW SEARCH_PATH;
    name     |                      setting
-------------+---------------------------------------------------
 search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)

另请参阅

4.19.4 - CURRENT_USER

返回包含启动当前数据库连接的用户的名称的 VARCHAR。

行为类型

稳定

语法

CURRENT_USER()

注意

  • CURRENT_USER 函数不需要括号。

  • 此函数对于权限检查很有用。

  • CURRENT_USER 等同于 SESSION_USER、用户 和 USERNAME。

示例

=> SELECT CURRENT_USER();
 CURRENT_USER
--------------
 dbadmin
(1 row)

以下命令将返回不带圆括号的相同结果：

=> SELECT CURRENT_USER;
 CURRENT_USER
--------------
 dbadmin
(1 row)

4.19.5 - DBNAME（函数）

返回当前数据库的名称，等同于 CURRENT_DATABASE。

行为类型

不可变

语法

DBNAME()

示例

=> SELECT DBNAME();
      dbname
------------------
 VMart
(1 row)

4.19.6 - HAS_TABLE_PRIVILEGE

返回 true 或 false，以验证用户是否具有表的指定权限。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

行为类型

稳定

语法

HAS_TABLE_PRIVILEGE ( [ user, ] '[[database.]schema.]table', 'privilege' )

参数

用户
数据库用户的名称或 OID。如果省略，Vertica 会检查当前用户的权限。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要检查的表的名称或 OID。
privilege
表权限，为以下之一：

特权

非超级用户，为以下之一：

  • 表所有者

  • 对表架构具有 USAGE 权限，对表具有一项或多项权限

示例

=> SELECT HAS_TABLE_PRIVILEGE('store.store_dimension', 'SELECT');
 HAS_TABLE_PRIVILEGE
---------------------
 t
(1 row)

=> SELECT HAS_TABLE_PRIVILEGE('release', 'store.store_dimension', 'INSERT');
 HAS_TABLE_PRIVILEGE
---------------------
 t
(1 row)

=> SELECT HAS_TABLE_PRIVILEGE(45035996273711159, 45035996273711160, 'select');
 HAS_TABLE_PRIVILEGE
---------------------
t
(1 row)

4.19.7 - LIST_ENABLED_CIPHERS

返回启用的密码套件列表，这些套件是用于保护 TLS/SSL 连接的算法集。

默认情况下，Vertica 使用 OpenSSL 的默认密码套件。有关详细信息，请参阅 OpenSSL 手册页。

语法

LIST_ENABLED_CIPHERS()

示例

=> SELECT LIST_ENABLED_CIPHERS();
SSL_RSA_WITH_RC4_128_MD5
SSL_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_AES_128_CBC_SHA

另请参阅

4.19.8 - SESSION_USER

返回 VARCHAR，其中包含发起当前数据库会话的用户的名称。

行为类型

稳定

语法

SESSION_USER()

注意

示例

=> SELECT SESSION_USER();
 session_user
--------------
 dbadmin
(1 row)

以下命令将返回不带圆括号的相同结果：

=> SELECT SESSION_USER;
 session_user
--------------
 dbadmin
(1 row)

4.19.9 - 用户

返回包含启动当前数据库连接的用户的名称的 VARCHAR。

行为类型

稳定

语法

USER()

注意

示例

=> SELECT USER();
 current_user
--------------
 dbadmin
(1 row)

以下命令将返回不带圆括号的相同结果：

=> SELECT USER;
 current_user
--------------
 dbadmin
(1 row)

4.19.10 - USERNAME

返回包含启动当前数据库连接的用户的名称的 VARCHAR。

行为类型

稳定

语法

USERNAME()

注意

示例

=> SELECT USERNAME();
 username
--------------
 dbadmin
(1 row)

4.19.11 - VERSION

返回包含 Vertica 节点的版本信息的 VARCHAR。

行为类型

稳定

语法

VERSION()

示例

=> SELECT VERSION();
                    VERSION
-------------------------------------------
Vertica Analytic Database v10.0.0-0
(1 row)

5 - 语句

SQL 查询的主结构是其语句。无论语句是独立存在还是多语句查询的一部分，每个语句都必须以分号结尾。以下示例包含四个通用 SQL 语句—CREATE TABLE、INSERT、SELECT 和 COMMIT：

=> CREATE TABLE comments (id INT, comment VARCHAR);
CREATE TABLE
=> INSERT INTO comments VALUES (1, 'Hello World');
OUTPUT
--------
1
(1 row)

=> SELECT * FROM comments;
 id |   comment
----+-------------
  1 | Hello World
(1 row)

=> COMMIT;
COMMIT
=>

5.1 - ALTER 语句

ALTER 语句可用于更改现有数据库对象。

5.1.1 - ALTER ACCESS POLICY

对现有访问策略执行以下操作之一：

  • 通过更改其表达式和启用/禁用策略来修改访问策略。

  • 将访问策略从一个表复制到另一个表。

语法

修改策略：

ALTER ACCESS POLICY ON [[database.]schema.]table
   { FOR COLUMN column [ expression ] | FOR ROWS [ WHERE expression ] } { GRANT TRUSTED } { ENABLE | DISABLE }

复制政策：

ALTER ACCESS POLICY ON [[database.]schema.]table
   { FOR COLUMN column | FOR ROWS } COPY TO TABLE table;

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
包含要启用、禁用或复制的访问策略的表的名称。
FOR COLUMN column [expression]
替换之前为此列设置的访问策略表达式。从 FOR COLUMN 子句中省略 expression，以便仅启用或禁用此策略，或将其复制到其他表中。
FOR ROWS [WHERE expression]
替换之前为此表设置的行访问策略表达式。从 FOR ROWS 子句中省略 WHERE expression，以便仅启用或禁用此策略，或将其复制到另一个表。
GRANT TRUSTED

指定 GRANT 语句在确定用户是否可以对目标表执行 DML 操作时优先于访问策略。如果省略，则只有在访问策略允许用户查看原始未更改状态的存储数据时，用户才能修改表数据。有关详细信息，请参阅访问策略和 DML 操作。

ENABLE | DISABLE
指示在表级别启用还是禁用访问策略。
COPY TO TABLE tablename
将现有访问策略复制到指定的表。复制的访问策略包括启用/禁用和 GRANT TRUSTED 状态。

需要满足以下要求：

  • 复制列访问策略：

    • 目标表必须包含相同名称和兼容数据类型的列。

    • 目标列不得包含访问策略。

  • 复制行访问策略：目标表不得包含访问策略。

特权

修改访问策略

非超级用户：表的所有权

复制访问策略

非超级用户：源表和目标表的所有权

示例

请参阅 管理访问策略

另请参阅

CREATE ACCESS POLICY

5.1.2 - ALTER AUTHENTICATION

修改指定身份验证方法的设置。

语法

ALTER AUTHENTICATION auth_record {
   | { ENABLE | DISABLE }
   | { LOCAL | HOST [ { TLS | NO TLS } ] host_ip_address }
   | RENAME TO new_auth_record_name
   | METHOD value
   | SET param=value[,...]
   | PRIORITY value
   | [ [ NO ] FALLTHROUGH ]
}

参数

特权

超级用户

示例

启用和禁用身份验证方法

本示例使用 ALTER AUTHENTICATION 禁用了 v_ldap 身份验证方法，然后再次启用了它：

=> ALTER AUTHENTICATION v_ldap DISABLE;
=> ALTER AUTHENTICATION v_ldap ENABLE;

重命名身份验证方法

以下示例将 v_kerberos 身份验证方法重命名为 K5。所有被授予 v_kerberos 身份验证方法的用户现在都改为授予了 K5 方法。

=> ALTER AUTHENTICATION v_kerberos RENAME TO K5;

修改身份验证参数

本示例将 ident1 身份验证的系统用户设置为 user1：

=> CREATE AUTHENTICATION ident1 METHOD 'ident' LOCAL;
=> ALTER AUTHENTICATION ident1 SET system_users='user1';

在使用 ALTER AUTHENTICATION 设置或修改 LDAP 或 Ident 参数时，Vertica 会对这些参数进行验证。

本示例将更改 IP 地址并为名为 Ldap1. 的 LDAP 身份验证方法指定参数。为 LDAP 服务器指定捆绑参数。Vertica 将连接到对数据库客户端进行身份验证的 LDAP 服务器。如果身份验证成功，Vertica 将在指定 LDAP 服务器上对被关联到（被授予）Ldap1 身份验证方法的任何用户进行身份验证：

=> CREATE AUTHENTICATION Ldap1 METHOD 'ldap' HOST '172.16.65.196';


=> ALTER AUTHENTICATION Ldap1 SET host='ldap://172.16.65.177',
   binddn_prefix='cn=', binddn_suffix=',dc=qa_domain,dc=com';

下一个示例将为名为 Ldap2 的 LDAP 身份验证方法指定参数。指定 LDAP 搜索和捆绑参数。有时 Vertica 没有足够的信息为尝试进行身份验证的用户创建可分辨名称 (Distinguished Name, DN)。在这种情况下，必须指定使用 LDAP 搜索和捆绑：

=> CREATE AUTHENTICATION Ldap2 METHOD 'ldap' HOST '172.16.65.196';

=> ALTER AUTHENTICATION Ldap2 SET basedn='dc=qa_domain,dc=com',
   binddn='cn=Manager,dc=qa_domain,
   dc=com',search_attribute='cn',bind_password='secret';

更改身份验证方法

本示例将 localpwd 身份验证从 hash 更改为trust:

=> CREATE AUTHENTICATION localpwd METHOD 'hash' LOCAL;

=> ALTER AUTHENTICATION localpwd METHOD 'trust';

设置多领域

此示例为身份验证方法 krb_local 设置了其他领域：


=> ALTER AUTHENTICATION krb_local set realm = 'COMPANY.COM';

另请参阅

5.1.3 - ALTER CA BUNDLE

添加证书、从证书颁发机构 (CA) 捆绑包中移除证书或更改证书颁发机构 (CA) 捆绑包的所有者。

语法

ALTER CA BUNDLE name
        [ADD CERTIFICATES ca_cert[, ca_cert[, ...]]
        [REMOVE CERTIFICATES ca_cert[, ca_cert[, ...]]
        [OWNER TO user]

参数

name
CA 捆绑包的名称。
ca_cert
要添加或从捆绑包中移除的 CA 证书的名称。
user
数据库用户的名称。

特权

CA 捆绑包的所有权。

示例

请参阅管理 CA 捆绑包。

另请参阅

5.1.4 - ALTER DATABASE

使用 ALTER DATABASE 可执行以下任务：

  • 从数据库中删除所有容错组及其子容错组。

  • 还原故障节点，恢复活动备用节点至备用状态。

  • 指定要用于导入/导出的公用网络的子网名称。

  • 设置和清除数据库 配置参数。

要查看参数的当前值，请查询系统表 CONFIGURATION_PARAMETERS 或使用 SHOW DATABASE。

语法

ALTER DATABASE db-spec {
      DROP ALL FAULT GROUP
      | EXPORT ON { subnet‑name | DEFAULT }
      | RESET STANDBY
      | SET [PARAMETER] parameter=value [,...]
      | CLEAR [PARAMETER] parameter[,...]
}

参数

db-spec
指定要更改的数据库，为以下之一：

  • 数据库名称

  • DEFAULT：当前数据库

DROP ALL FAULT GROUP
删除所有容错组（在指定数据库上定义）。
EXPORT ON
指定用于导入和导出数据的网络，为以下之一：

  • subnet‑name：公用网络的子网。

  • DEFAULT：指定使用专用网络。

有关详细信息，请参阅识别用于导入/导出的数据库或节点和更改节点导出地址。

RESET STANDBY
仅限 Enterprise 模式，还原所有不活动节点并恢复替换节点至待机状态。如果任何被替换节点无法恢复活动，Vertica 会将备用节点留在适当位置。
SET [PARAMETER]
设置指定参数。
CLEAR [PARAMETER]
将指定参数重置为其默认值。

特权

超级用户

5.1.5 - ALTER FAULT GROUP

修改现有容错组。例如，使用 ALTER FAULT GROUP 语句执行以下操作：

  • 向现有容错组添加节点或从中删除节点

  • 向父容错组添加子容错组或从中删除子容错组

  • 重命名容错组

语法

ALTER FAULT GROUP fault-group-name {
    | ADD NODE node-name
    | DROP NODE node-name
    | ADD FAULT GROUP child-fault-group-name
    | DROP FAULT GROUP child-fault-group-name
    | RENAME TO new-fault-group-name }

参数

fault-group-name
要修改的现有容错组名称。
node-name
要向现有（父）容错组添加或从中删除的节点的名称。
child-fault-group-name
要向现有父容错组添加或从中移除的子容错组的名称。
new-fault-group-name
要重命名的容错组的新名称。

特权

超级用户

示例

此示例显示了如何将 parent0 容错组重命名为 parent100：

=> ALTER FAULT GROUP parent0 RENAME TO parent100;
ALTER FAULT GROUP

通过查询 FAULT_GROUPS 系统表来验证更改：

=> SELECT member_name FROM fault_groups;
   member_name
----------------------
v_exampledb_node0003
parent100
mygroup
(3 rows)

另请参阅

5.1.6 - ALTER FUNCTION 语句

Vertica 为每种类型的用户定义的扩展 提供了 ALTER 语句。每个 ALTER 语句都会修改 Vertica 编录中用户定义的函数的元数据：

Vertica 还提供ALTER FUNCTION (SQL)，可修改用户定义的 SQL 函数的元数据。

5.1.6.1 - ALTER AGGREGATE FUNCTION

更改用户定义的聚合函数。

语法

ALTER AGGREGATE FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET SCHEMA new‑schema
}

参数

[db-name.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function‑name
要更改的 SQL 函数的名称。
arg‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET SCHEMA new‑schema
将函数移动到其他架构。

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE AGGREGATE FUNCTION

5.1.6.2 - ALTER ANALYTIC FUNCTION

更改用户定义的分析函数。

语法

ALTER ANALYTIC FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET FENCED boolean‑expr
    | SET SCHEMA new‑schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE ANALYTIC FUNCTION

5.1.6.3 - ALTER FILTER

更改用户定义的筛选器。

语法

ALTER FILTER [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET FENCED boolean‑expr
    | SET SCHEMA new‑schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE FILTER

5.1.6.4 - ALTER FUNCTION (SQL)

更改用户定义的 SQL 函数。

语法

ALTER FUNCTION [[db-name.]schema.]function‑name( [arg‑list] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET SCHEMA new‑schema
}

参数

[db-name.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function‑name
要更改的 SQL 函数的名称。
arg‑list
函数实参名称的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET SCHEMA new‑schema
将函数移动到其他架构。

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

示例

将函数 SQL_one 重命名为 SQL_two：

=> ALTER FUNCTION SQL_one (int, int) RENAME TO SQL_two;

将函数 SQL_two 移动到架构 macros：

=> ALTER FUNCTION SQL_two (int, int) SET SCHEMA macros;

重新分配 SQL_two 的所有权：

=> ALTER FUNCTION SQL_two (int, int) OWNER TO user1;

另请参阅

5.1.6.5 - ALTER FUNCTION（标量）

更改用户定义的标量函数。

语法

ALTER FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET FENCED boolean‑expr
    | SET SCHEMA new‑schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

示例

将函数 UDF_one 重命名为 UDF_two：

=> ALTER FUNCTION UDF_one (int, int) RENAME TO UDF_two;

将函数 UDF_two 移动到架构 macros：

=> ALTER FUNCTION UDF_two (int, int) SET SCHEMA macros;

禁用函数 UDF_two 的隔离模式：

=> ALTER FUNCTION UDF_two (int, int) SET FENCED false;

另请参阅

CREATE FUNCTION（标量）

5.1.6.6 - ALTER PARSER

更改用户定义的解析器。

语法

ALTER PARSER [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET FENCED boolean‑expr
    | SET SCHEMA new‑schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE PARSER

5.1.6.7 - ALTER SOURCE

更改用户定义的加载源函数。

语法

ALTER SOURCE [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
    OWNER TO new‑owner
    | RENAME TO new‑name
    | SET FENCED boolean‑expr
    | SET SCHEMA new‑schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE SOURCE

5.1.6.8 - ALTER TRANSFORM FUNCTION

更改用户定义的转换函数。

语法

ALTER TRANSFORM FUNCTION [[db-name.]schema.]function-name( [ parameter-list ] ) {
    OWNER TO new-owner
    | RENAME TO new-name
    | SET FENCED { true | false }
    | SET SCHEMA new-schema
}
[db-name.]schema
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name
要更改的函数的名称。
parameter‑list
为此函数定义的参数的逗号分隔列表。如果无列表，请指定一个空列表。
OWNER TO new‑owner
将函数所有权转移给其他用户。
RENAME TO new‑name
重命名此函数。
SET FENCED { true | false }
指定是否为此函数启用隔离模式。
SET SCHEMA new‑schema
将函数移动到其他架构。

权限

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 函数所有者

  • 对函数的 ALTER 权限

对于某些操作，非超级用户还必须具备以下架构权限：

另请参阅

CREATE TRANSFORM FUNCTION

5.1.7 - ALTER HCATALOG SCHEMA

更改使用 CREATE HCATALOG SCHEMA 创建的架构上的参数值。HCatalog 连接器使用 HCatalog 架构访问存储在 Hive 数据仓库中的数据。有关详细信息，请参阅使用 HCatalog 连接器。

某些参数在创建后无法更改。如果需要更改其中一个值，请删除并重新创建架构。您可以使用 ALTER HCATALOG SCHEMA 更改以下参数：

  • HOSTNAME

  • PORT

  • HIVESERVER2_HOSTNAME

  • WEBSERVICE_HOSTNAME

  • WEBSERVICE_PORT

  • WEBHDFS_ADDRESS

  • HCATALOG_CONNECTION_TIMEOUT

  • HCATALOG_SLOW_TRANSFER_LIMIT

  • HCATALOG_SLOW_TRANSFER_TIME

  • SSL_CONFIG

  • CUSTOM_PARTITIONS

语法

ALTER HCATALOG SCHEMA schema-name SET [param=value]+;

参数

schema‑name
Vertica 编录中要更改的架构名称。Hive 数据库中的表通过此架构提供。
param
要更改的参数的名称。
value
参数的新值。必须指定值；此语句不会从类似 CREATE HCATALOG SCHEMA 的配置文件中读取默认值。

特权

以下几项之一：

  • 超级用户

  • 架构所有者

示例

以下示例显示了如何更改 "hcat" 架构的 Hive 元存储主机名和端口。在此示例中，Hive 使用高可用性元存储。

=> ALTER HCATALOG SCHEMA hcat SET HOSTNAME='thrift://ms1.example.com:9083,thrift://ms2.example.com:9083';

以下示例显示了尝试设置不可更改的参数时收到的错误。

=> ALTER HCATALOG SCHEMA hcat SET HCATALOG_USER='admin';
   ERROR 4856: Syntax error at or near "HCATALOG_USER" at character 39

5.1.8 - ALTER LIBRARY

替换当前与 Vertica 编录中的 UDx 库关联的库文件。Vertica 自动将更新文件的副本分发到所有群集节点。编录中定义的引用更新库的 UDx 将自动开始使用更新库文件。如果名称和签名匹配，则视为 UDx 相同。

当前库和替换库必须使用同一种语言编写。

语法

ALTER LIBRARY [[database.]schema.]name [DEPENDS 'depends-path'] AS 'path';

参数

架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

name
使用 CREATE LIBRARY 创建的现有库的名称。
DEPENDS 'depends-path'

此库所依赖的文件或库，启动程序节点的文件系统或其他受支持的文件系统或对象存储中的一个或多个文件或目录。对于目录，路径条目以斜杠 (/) 结束，后跟通配符 (*)（可选）。要指定多个文件，请使用冒号 (:) 分隔条目。

如果任何路径条目包含冒号（例如 URI），请在整个 DEPENDS 路径两端加上括号，且单个路径元素使用双引号，如下例所示：

DEPENDS '["s3://mybucket/gson-2.3.1.jar"]'

要指定具有多个目录级别的库，请参阅多级库依赖项。

DEPENDS 对使用 R 编写的库没有影响。R 软件包必须本地安装在每个节点上，包括外部依赖项。

AS path
替换库文件在启动程序节点文件系统上的绝对路径。

特权

超级用户，或者架构上的 UDXDEVELOPER 和 CREATE。非超级用户必须明确启用 UDXDEVELOPER 角色。有关示例，请参阅 CREATE LIBRARY。

如果 DEPENDS 子句指定具有多个目录级别的库，Vertica 将按照库路径包含该库的所有子目录。例如，以下 CREATE LIBRARY 语句使 UDx 库 mylib 能够导入它在 site‑packages 的子目录中找到的所有 Python 包和模块：

=> CREATE LIBRARY mylib AS '/path/to/python_udx' DEPENDS '/path/to/python/site-packages' LANGUAGE 'Python';

示例

此示例显示了如何使用新文件更新名为 myFunctions 的已定义库。

=> ALTER LIBRARY myFunctions AS '/home/dbadmin/my_new_functions.so';

另请参阅

开发用户定义的扩展 (UDx)

5.1.9 - ALTER LOAD BALANCE GROUP

更改负载均衡组的配置。

语法

ALTER LOAD BALANCE GROUP group-name {
    RENAME TO new-name |
    SET FILTER TO 'ip-cidr-addr' |
    SET POLICY TO 'policy' |
    ADD {ADDRESS | FAULT GROUP | SUBCLUSTER} add-list |
    DROP  {ADDRESS | FAULT GROUP | SUBCLUSTER} drop-list 
}

参数

group-name
要更改的现有负载均衡组的名称。
RENAME TO new-name
将组重命名为 new-name。
SET FILTER TO 'ip-cidr-addr'
用于替换现有 IP 地址筛选器的 IPv4 或 IPv6 CIDR，该筛选器选择将容错组或子群集的哪些成员包括在负载均衡组中。此设置仅在负载均衡组包含容错组或子群集时有效。
SET POLICY TO 'policy'
更改负载均衡组为传入连接选择目标节点所使用的策略。可为以下之一：

  • ROUNDROBIN

  • RANDOM

  • NONE

有关详细信息，请参阅CREATE LOAD BALANCE GROUP。

ADD {ADDRESS | FAULT GROUP | SUBCLUSTER }
将指定类型的对象添加到负载均衡组。负载均衡组只能包含一种类型的对象。例如，如果使用地址列表创建负载均衡组，则只能添加附加地址，而不能添加容错组或子群集。
add-list
要添加到容错组的对象（地址、容错组或子群集）的逗号分隔列表。
DROP {ADDRESS | FAULT GROUP | SUBCLUSTER}
从负载均衡组（地址、容错组或子群集）中移除指定类型的对象。对象类型必须与负载均衡组中已有的对象的类型相匹配。
drop-list
要从负载均衡组中移除的对象的列表。

特权

超级用户

示例

从名为 group_2 的负载均衡组中移除地址。

=> SELECT * FROM LOAD_BALANCE_GROUPS;
  name   |   policy   | filter |         type          | object_name
---------+------------+--------+-----------------------+-------------
 group_1 | ROUNDROBIN |        | Network Address Group | node01
 group_1 | ROUNDROBIN |        | Network Address Group | node02
 group_2 | ROUNDROBIN |        | Network Address Group | node03
(3 rows)

=> ALTER LOAD BALANCE GROUP group_2 DROP ADDRESS node03;
ALTER LOAD BALANCE GROUP

=> SELECT * FROM LOAD_BALANCE_GROUPS;
  name   |   policy   | filter |         type          | object_name
---------+------------+--------+-----------------------+-------------
 group_1 | ROUNDROBIN |        | Network Address Group | node01
 group_1 | ROUNDROBIN |        | Network Address Group | node02
 group_2 | ROUNDROBIN |        | Empty Group           |
(3 rows)

以下示例向名为 group_2 的组中添加了三个网络地址：

=> ALTER LOAD BALANCE GROUP group_2 ADD ADDRESS node01,node02,node03;
ALTER LOAD BALANCE GROUP
=> SELECT * FROM load_balance_groups WHERE name = 'group_2';
-[ RECORD 1 ]----------------------
name        | group_2
policy      | ROUNDROBIN
filter      |
type        | Network Address Group
object_name | node01
-[ RECORD 2 ]----------------------
name        | group_2
policy      | ROUNDROBIN
filter      |
type        | Network Address Group
object_name | node02
-[ RECORD 3 ]----------------------
name        | group_2
policy      | ROUNDROBIN
filter      |
type        | Network Address Group
object_name | node03

另请参阅

5.1.10 - ALTER MODEL

允许用户重命名现有模型、更改所有权或将其移动到其他架构。

语法

ALTER MODEL [[database.]schema.]model
   { OWNER TO owner
     | RENAME TO new‑name
     | SET SCHEMA schema
 }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

model
标识要更改的模型。
OWNER TO owner
将此模型的所有权重新分配给 owner。如果为非超级用户，则必须是当前所有者。
RENAME TO
重命名模式，其中 new‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
SET SCHEMA schema
将模型从一个架构移动到另一个架构。

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 模型所有者

  • 对模型的 ALTER 权限

对于某些操作，非超级用户必须具备以下架构权限：

示例

请参阅更改模型。

5.1.11 - ALTER NETWORK ADDRESS

更改现有网络地址的配置。

语法

ALTER NETWORK ADDRESS name {
    RENAME TO new-name
    | SET TO 'ip-addr' [PORT port-number]
    | { ENABLE | DISABLE }
    }

参数

name
要更改的现有网络地址的名称。
RENAME TO new-name
将网络地址重命名为 new-name。此名称更改不会影响网络地址在负载均衡组中的成员身份。
SET TO 'ip-addr'
更改为网络地址分配的 IP 地址。
PORT port-number
设置网络地址的端口号。更改端口号时必须提供网络地址。
ENABLE | DISABLE
启用或禁用网络地址。

示例

将网络地址从 test_addr 重命名为 alt_node1，然后将其 IP 地址更改为 192.168.1.200，端口号为 4000：

=> ALTER NETWORK ADDRESS test_addr RENAME TO alt_node1;
ALTER NETWORK ADDRESS
=> ALTER NETWORK ADDRESS alt_node1 SET TO '192.168.1.200' PORT 4000;
ALTER NETWORK ADDRESS

另请参阅

5.1.12 - ALTER NETWORK INTERFACE

重命名网络接口。

语法

ALTER NETWORK INTERFACE network-interface-name RENAME TO new-network-interface-name

参数

network-interface-name
现有网络接口的名称。
new-network-interface-name
网络接口的新名称。

特权

超级用户

示例

重命名网络接口：

=> ALTER NETWORK INTERFACE myNetwork RENAME TO myNewNetwork;

5.1.13 - ALTER NODE

设置和清除指定节点上的节点级别配置参数。ALTER NODE 还执行以下管理任务：

  • 更改节点类型。

  • 指定用于导入和导出的各个节点上公用网络的网络接口。

  • 替换故障节点。

有关移除节点的信息，请参阅

语法

ALTER NODE node‑name {
    EXPORT ON { network‑interface | DEFAULT }
    | [IS] node‑type
    | REPLACE [ WITH standby‑node ]
    | RESET
    | SET [PARAMETER] parameter=value[,...]
    | CLEAR [PARAMETER] parameter[,...]
}

参数

node‑name
要更改的节点的名称。
[IS] node‑type
更改节点类型，其中 node‑type 为以下之一：

  • PERMANENT：（默认值）：存储数据的节点。

  • EPHEMERAL：从一种类型转换到另一种类型的节点——通常是从 PERMANENT 到 STANDBY 或 EXECUTE。

  • STANDBY：保留以在任何节点发生故障时替换该节点的节点。备用节点不存储段或数据，直到它被调用以替换故障节点。当用作替换节点时，Vertica 将其类型更改为 PERMANENT。有关详细信息，请参阅活动备用节点。

  • EXECUTE：该节点仅为计算目的而保留。执行节点不包含段或数据。

EXPORT ON
指定用于导入和导出数据的网络，为以下之一：

  • network‑interface：公用网络的网络接口名称。

  • DEFAULT：使用公用网络的默认网络接口，通过 ALTER DATABASE 指定。

REPLACE [WITH standby‑node]
仅限 Enterprise 模式，将指定节点替换为可用的活动的备用节点。如果省略 WITH 子句，Vertica 会尝试从与故障节点相同的容错组中查找替换节点。

如果指定的节点未发生故障，Vertica 将忽略此语句。

RESET
仅限 Enterprise 模式，恢复指定的故障节点并使其替换节点返回到备用状态。如果故障节点无法恢复活动，Vertica 将忽略此语句并将备用节点留在原处。
SET [PARAMETER]
在节点级别将一个或多个配置参数设置为指定值。
CLEAR [PARAMETER]
清除一个或多个指定配置参数。

特权

超级用户

示例

指定使用 v_vmart_node0001 上公用网络的默认网络接口进行导入/导出操作：

=> ALTER NODE v_vmart_node0001 EXPORT ON DEFAULT;

将故障节点 v_vmart_node0001 替换为活动的备用节点，然后还原故障节点：

=> ALTER NODE v_vmart_node0001 REPLACE WITH standby1;
...
=> ALTER NODE v_vmart_node0001 RESET;

设置和清除配置参数 MaxClientSessions：

=> ALTER NODE v_vmart_node0001 SET MaxClientSessions = 0;
...
=> ALTER NODE v_vmart_node0001 CLEAR MaxClientSessions;

将节点类型设置为 EPHEMERAL：

=> ALTER NODE v_vmart_node0001 IS EPHEMERAL;

5.1.14 - ALTER NOTIFIER

更新现有通知程序。

语法

ALTER NOTIFIER notifier‑name
    [ ENABLE | DISABLE ]
    [ MAXPAYLOAD 'max‑payload‑size' ]
    [ MAXMEMORYSIZE 'max‑memory‑size' ]
    [ TLSMODE 'tls‑mode' ]
    [ CA BUNDLE bundle‑name [ CERTIFICATE certificate‑name ] ]
    [ IDENTIFIED BY 'uuid' ]
    [ [NO] CHECK COMMITTED ]
    [ PARAMETERS 'adapter‑params' ]

参数

notifier‑name
指定要更新的通知程序。
[NO] CHECK COMMITTED
指定在发送队列中的下一条消息之前等待传递确认。并非所有消息传递系统都支持传递确认。
ENABLE | DISABLE
指定启用还是禁用通知程序。
MAXPAYLOAD
消息的最大大小，最大为 2 TB，以 KB、MB、GB 或 TB 为单位指定，如下所示： 
MAXPAYLOAD integer{K|M|G|T}

默认设置特定于适配器，例如 Kafka 为 1 M。

对此参数的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。

MAXMEMORYSIZE
内部通知程序的最大大小，最大为 2 TB，以 KB、MB、GB 或 TB 为单位指定，如下所示： 
MAXMEMORYSIZE integer{K|M|G|T}

如果队列超过此大小，通知程序将删除多余的消息。

TLSMODE 'tls‑mode'

指定通知程序和端点之间的连接类型，可以是以下类型之一：

  • disable （默认值）：明文连接。

  • verify-ca：加密连接，且服务器的证书已经验证为由受信任的 CA 签名。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

CA BUNDLE bundle‑name

指定 CA 捆绑包。如果 TLSMODE 需要，捆绑包中的证书可用于验证 Kafka 服务器的证书。

如果为当前使用 disable 的通知程序指定了 CA 捆绑包，而不会验证 Kafka 服务器的证书，则在连接到 Kafka 服务器时，将不使用该捆绑包。除非将 TLSMODE 更改为验证服务器证书行为，否则此行为会持续存在。

对 CA 捆绑包内容的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。但是，对通知程序所用的 CA 捆绑包的更改会立即生效。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

CERTIFICATE certificate‑name

指定一个供端点验证的客户端证书。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

IDENTIFIED BY 'uuid'
指定通知程序的唯一标识符。如果设置，则此通知程序发布的所有消息都具有此属性。
PARAMETERS 'adapter‑params'
指定以字符串形式传递给适配器的一个或多个可选适配器参数。适配器参数仅适用于与通知程序关联的适配器。

对此参数的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。

对于 Kafka 通知程序，请参阅 Kafka 和 Vertica 配置设置。

特权

超级用户

SASL_SSL Kafka 配置的加密通知程序

按照此步骤，为使用 SASL_SSL 的 Kafka 端点创建或更改通知程序。请注意，每当您更改给定通知程序的 TLSMODE、证书或 CA 捆绑包时，都必须重复此步骤。

  1. 在设置 TLSMODE、证书和 CA 捆绑包时，使用 CREATE 或 ALTER 以禁用通知程序。

    => ALTER NOTIFIER encrypted_notifier
    DISABLE
    TLSMODE 'verify-ca'
    CA BUNDLE ca_bundle2;

  2. 更改通知程序并为 SASL_SSL 设置适合的 rdkafka 适配器参数。

    => ALTER NOTIFIER encrypted_notifier PARAMETERS
  'sasl.username=user;sasl.password=password;sasl.mechanism=PLAIN;security.protocol=SASL_SSL';

  3. 启用通知程序。

    => ALTER NOTIFIER encrypted_notifier ENABLE;

示例

更新现有通知程序的设置：

=> ALTER NOTIFIER my_dc_notifier
    ENABLE
    MAXMEMORYSIZE '2G'
    IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
    CHECK COMMITTED;

更改 TLSMODE 并将 CA 捆绑包和证书添加到现有通知程序。此通知程序连接到 Kafka 服务器的证书，并验证其是否由受信任的 CA 签名。

=> ALTER NOTIFIER my_notifier
    TLSMODE 'verify-ca'
    CA BUNDLE ca_bundle
    CERTIFICATE client_cert;

另请参阅

5.1.15 - ALTER PROCEDURE（存储）

更改存储过程，同时保留任何现有授权。

语法

ALTER PROCEDURE procedure ( [ [ parameter_mode ] [ parameter ] parameter_type [, ...] ] )
    [ SECURITY { INVOKER | DEFINER }
      | RENAME TO new_procedure_name
      | OWNER TO new_owner
      | SET SCHEMA new_schema
      | SOURCE TO new_source
    ]

参数

过程
要更改的过程。
parameter_mode
存储过程的 IN 参数。
parameter
参数的名称。
parameter_type
参数的类型。
SECURITY { INVOKER | DEFINER }
指定是否以调用者或过程定义者（所有者）的权限执行过程。

有关详细信息，请参阅执行存储过程。

RENAME TO new_procedure_name
过程的新名称。
OWNER TO new_owner
过程的新所有者（定义者）。
SET SCHEMA new_schema
过程的新架构。
SOURCE TO new_source
新的过程源代码。有关详细信息，请参阅范围和结构。

特权

OWNER TO

超级用户

RENAME 和 SCHEMA TO

非超级用户：

  • 对过程架构的 CREATE 权限

  • 过程的所有权

其他操作

非超级用户：过程的所有权

示例

请参阅更改存储过程。

5.1.16 - ALTER PROJECTION

更改指定投影的 DDL。

语法

ALTER PROJECTION [[database.]schema.]projection
   { RENAME TO new‑name | ON PARTITION RANGE BETWEEN min-val AND max-val }

参数

架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
要更改的投影，其中 projection 可以为以下之一：

  • 投影基本名称：重命名共享此基本名称的所有投影。

  • 投影名称：重命名指定投影及其基本名称。如果投影是分段的，则其伙伴实例不受此更改的影响。

有关投影名称约定，请参阅投影命名。

new‑name
新的投影名称。
ON PARTITION RANGE

指定将此投影的数据限制在分区键范围内，指定如下：

ON PARTITION RANGE BETWEEN min-range-value AND max-range-value

以下要求适用于 min‑range‑value 和 ≤ max‑range‑value：

  • Min‑range‑value 必须 ≤ max‑range‑value

  • 它们必须解析为与表分区表达式兼容的数据类型。

  • 它们可以是：

    • 字符串字面量。例如， 2021-07-31

    • 具有稳定或不可变函数的表达式，例如：

      date_trunc('month', now()::timestamp - interval'1 month')

max-range-value 可以设置为 NULL，以指定分区范围没有上限。

如果新的键范围超出之前的范围，Vertica 将发出警告，指出投影已过期，必须刷新才能使用。

有关其他要求和使用详细信息，请参阅分区范围投影。

特权

非超级用户权限、对架构的 CREATE 和 USAGE 权限以及以下锚表权限之一：

示例

=> SELECT export_tables('','public.store_orders');

                export_tables
---------------------------------------------

CREATE TABLE public.store_orders
(
    order_no int,
    order_date timestamp NOT NULL,
    shipper varchar(20),
    ship_date date NOT NULL
);
(1 row)

=> CREATE PROJECTION store_orders_p AS SELECT * from store_orders;
CREATE PROJECTION

=> ALTER PROJECTION store_orders_p RENAME to store_orders_new;
ALTER PROJECTION

另请参阅

CREATE PROJECTION

5.1.17 - ALTER PROFILE

更改配置文件。未在配置文件中设置的所有参数都从默认配置文件继承其设置。可以使用 ALTER PROFILE 更改默认配置文件。

语法

ALTER PROFILE name LIMIT [
    PASSWORD_LIFE_TIME setting
    PASSWORD_MIN_LIFE_TIME setting
    PASSWORD_GRACE_TIME setting
    FAILED_LOGIN_ATTEMPTS setting
    PASSWORD_LOCK_TIME setting
    PASSWORD_REUSE_MAX setting
    PASSWORD_REUSE_TIME setting
    PASSWORD_MAX_LENGTH setting
    PASSWORD_MIN_LENGTH setting
    PASSWORD_MIN_LETTERS setting
    PASSWORD_MIN_UPPERCASE_LETTERS setting
    PASSWORD_MIN_LOWERCASE_LETTERS setting
    PASSWORD_MIN_DIGITS setting
    PASSWORD_MIN_SYMBOLS setting
    PASSWORD_MIN_CHAR_CHANGE setting ]

参数

特权

超级用户

配置文件设置和客户端身份验证

以下配置文件设置会影响客户端身份验证方法，例如 LDAP 或 GSS：

  • FAILED_LOGIN_ATTEMPTS

  • PASSWORD_LOCK_TIME

所有其他配置文件设置仅供 Vertica 用于管理其密码。

示例

ALTER PROFILE sample_profile LIMIT FAILED_LOGIN_ATTEMPTS 3;

另请参阅

5.1.18 - ALTER PROFILE RENAME

重命名现有配置文件。

语法

ALTER PROFILE name RENAME TO new‑name;

参数

name
配置文件的当前名称。
new‑name
配置文件的新名称。

特权

超级用户

示例

此示例显示了如何重命名现有配置文件。

ALTER PROFILE sample_profile RENAME TO new_sample_profile;

另请参阅

5.1.19 - ALTER RESOURCE POOL

通过设置一个或多个参数来修改现有资源池。

语法

ALTER RESOURCE POOL pool‑name [ FOR subcluster-spec ] [ parameter‑name setting ]...

参数

pool‑name
资源池的名称。内置池名称不能用于用户定义的池。
FOR subcluster‑spec
仅限 Eon 模式，指定将此资源池与某个子群集关联，其中 subcluster-spec 为以下之一：
  • SUBCLUSTER subcluster-name：更改现有子群集的资源池。您不能连接到此子群集，否则 Vertica 会返回错误。
  • CURRENT SUBCLUSTER：更改您连接到的子群集的资源池。
parameter‑name
要设置的参数，如下所示。
设置

要在 parameter‑name 上设置的值。要将此参数重置为其默认值，请指定 DEFAULT。

CASCADE TO

指定一个辅助资源池，用于执行其 [RUNTIMECAP](#RUNTIMECAP) 设置超出分配资源池的查询：

CASCADE TO secondary‑pool
CPUAFFINITYMODE

指定资源池是单独使用还是共用 [CPUAFFINITYSET](#CPUAFFINITYSET) 中指定的 CPU。

CPUAFFINITYMODE { SHARED | EXCLUSIVE | ANY }

  • SHARED：在此池中运行的查询与其他 Vertica 资源池共享其 CPUAFFINITYSET CPU。

  • EXCLUSIVE：仅将 CPUAFFINITYSET CPU 专用于此资源池，不用于其他 Vertica 资源池。如果将 CPUAFFINITYSET 设置为百分比，那么仅为此资源池分配可用于 Vertica 的 CPU 资源百分比。

  • ANY （默认值）：此资源池中的查询可以在任何 CPU 上运行，如果 CPUAFFINITYSET 指定 CPU 资源，则此查询无效。

CPUAFFINITYSET

指定此资源池可用的 CPU。所有群集节点必须具有相同的 CPU 数量。分配给该集合的 CPU 资源对常规资源池不可用。

CPUAFFINITYSET {
  'cpu‑index[,...]'
| 'cpu‑indexi-cpu‑indexn'
| 'integer%'
| NONE
}

  • cpu‑index[,...]：将以一个或多个逗号分隔的 CPU 专用于此池。

  • cpu‑indexi-cpu‑indexn：将一系列连续的 CPU 索引专用于此池

  • integer%：此池可用的所有可用 CPU 的百分比。Vertica 将此百分比向下舍入以包括整个 CPU 单元。

  • NONE （默认值）：没有关联集分配给该资源池。与该池关联的查询可在任何 CPU 上执行。

EXECUTIONPARALLELISM

限制用于处理此资源池中发出的任何单一查询的线程数量。

EXECUTIONPARALLELISM { limit | AUTO }

  • limit：介于 1 与内核数之间的整数值。将此参数设置为减小的值时，可以增大池中发出的简短查询的吞吐量，特别是在并发执行多个查询的情况下。

  • AUTO or0（默认值）：Vertica 根据系统中的内核数、可用内存和数据量计算设置。除非内存有限，或者数据量非常小，否则 Vertica 会将此参数设置为节点中的核心数。

MAXCONCURRENCY

设置群集中资源池可用的最大并发执行槽数：

MAXCONCURRENCY { integer | NONE }

NONE （默认）指定不限数量的并发执行槽。

MAXMEMORYSIZE

通过从 GENERAL 池中借用内存，资源池可以增加的每个节点的最大大小：

MAXMEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
| NONE
}

  • integer%：占总内存的百分比

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量

  • NONE （默认值）：无限制，池可以从 GENERAL 池中借用任意数量的可用内存。

MAXQUERYMEMORYSIZE

此池可以在运行时分配以处理查询的最大内存量。如果查询需要的内存超过此设置，Vertica 将停止执行并返回错误。

设置此参数如下：

MAXQUERYMEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
| NONE
}

  • integer%：百分比 此池的 MAXMEMORYSIZE。

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量，最大为 MAXMEMORYSIZE。

  • NONE （默认值）：无限制；池可以从 GENERAL 池中借用任意数量的可用内存，其限制由以下设置： MAXMEMORYSIZE。

MEMORYSIZE

每个节点分配给此池的 Vertica 资源管理器可用的总内存量：

MEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
}

  • integer%：占总内存的百分比

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量

默认值： 0%。没有分配任何内存，资源池从 GENERAL 池中借用内存。

PLANNEDCONCURRENCY

指定资源池中并发执行的查询首选数量。此设置适用于整个群集：

PLANNEDCONCURRENCY { num‑queries | AUTO }

  • num‑queries：整数值 ≥ 1，指定并发执行查询的首选数量。在可能的情况下，查询资源预算被限制为允许此级别的并发执行。

  • AUTO （默认值）：值将在查询运行时自动计算。Vertica 将此参数设置为这两个计算中的较低值，但绝不会小于 4：

    • 逻辑核心数

    • 内存除以 2GB

对于不同节点上逻辑核数不同的群集，AUTO 可以在每个节点上应用不同的方法。分布式查询的运行方式类似于最低的有效计划并发性能。单节点查询以发起方的计划并发性能运行。

PRIORITY

指定此池中的查询在争用 GENERAL 池中资源时的优先级：

PRIORITY { integer | HOLD }

  • integer：一个负整数或正整数值。数字越大，表示优先级越高：

    • 用户定义的池： ‑100 到 100

    • 内置池 SYSQUERY、 RECOVERY 和 TM： ‑110 到 110

  • HOLD：将优先级设置为 -999。此池中的查询将排队，直到达到 [QUEUETIMEOUT](#QUEUETIMEOUT) 为止。

默认值： 0

QUEUETIMEOUT

指定请求在被拒绝之前可以等待池资源多长时间：

QUEUETIMEOUT { integer | NONE }

  • integer：最长等待时间（以秒为单位）

  • NONE：没有最长等待时间，请求可以无限排队。

默认值： 300 秒

RUNTIMECAP

通过设置池中的查询可以执行的最大时间，可以防止查询失控。如果查询超出此设置，它会尝试级联到辅助池。

RUNTIMECAP { 'interval' | NONE }

  • interval：1 分钟或 100 秒的间隔；不应超过 1 年。

  • NONE （默认值）：在此池中运行的查询没有时间限制。

    要以天为单位指定一个值，请提供整数值。要提供小于一天的值，请以 hours:minutes:seconds 格式提供间隔。例如，值为 1:30:00 时，则等于 90 分钟。

    如果用户或会话也具有 RUNTIMECAP，则会应用较短的限制。

RUNTIMEPRIORITY

确定资源管理器应如何将运行时资源（CPU、I/O 带宽）的优先级分配给已在此资源池中运行的查询：

RUNTIMEPRIORITY { HIGH | MEDIUM | LOW }

默认值： MEDIUM

RUNTIMEPRIORITYTHRESHOLD

以秒为单位指定一个时间限制，在资源管理器为其分配资源池 RUNTIMEPRIORITY 之前，必须完成一个查询。所有查询从 HIGH 优先级开始运行。如果查询的持续时间超过了此阈值，它将分配到资源池的 RUNTIMEPRIORITY。

RUNTIMEPRIORITYTHRESHOLD seconds

默认值： 2

SINGLEINITIATOR

默认情况下，已设置为 false 以实现向后兼容性。切勿更改此设置。

特权

超级用户

示例

以下示例显示如何通过将优先级设置为 5 来更改资源池 ceo_pool。

=> ALTER RESOURCE POOL ceo_pool PRIORITY 5;

以下示例显示如何为 ceo_pool 指定一个辅助资源池。

=> CREATE RESOURCE POOL second_pool;
=> ALTER RESOURCE POOL ceo_pool CASCADE TO second_pool;

以下 Eon 模式示例将 dashboard 辅助子群集的内置 TM 资源池的 MAXMEMORYSIZE 和 MEMORYSIZE 减小到 0%。将这些设置更改为 0 会阻止子群集运行 Tuple Mover 合并操作。

=> ALTER RESOURCE POOL TM FOR SUBCLUSTER dashboard MEMORYSIZE '0%'
   MAXMEMORYSIZE '0%';

有关详细信息，请参阅调整 Tuple Mover 池设置。

另请参阅

5.1.20 - ALTER ROLE

重命名现有角色。

语法

ALTER ROLE name RENAME TO new‑name

参数

name
要重命名的角色。
new‑name
角色的新名称。

特权

超级用户

示例

=> ALTER ROLE applicationadministrator RENAME TO appadmin;
ALTER ROLE

另请参阅

5.1.21 - ALTER ROUTING RULE

更改现有负载均衡策略路由规则。

语法

ALTER ROUTING RULE rule_name {
    RENAME TO new_name |
    SET ROUTE TO 'cidr_range'|
    SET GROUP TO group_name
    }

参数

rule_name
要更改的现有路由规则的名称。
RENAME TO new_name
将路由规则的名称更改为 new_name。
SET ROUTE TO 'cidr_range'
CIDR 格式的 IPv4 或 IPv6 地址范围。更改此规则适用的客户端连接的地址范围。
SET GROUP TO group_name
更改用于处理与此规则匹配的连接的负载均衡组。

示例

此示例将更改名为 etl_rule 的路由规则，以便其使用名为 etl_rule 的负载均衡组来处理 IP 地址范围 10.20.100.0 到 10.20.100.255 内的传入连接。

=> ALTER ROUTING RULE etl_rule SET GROUP TO etl_group;
ALTER ROUTING RULE
=> ALTER ROUTING RULE etl_rule SET ROUTE TO '10.20.100.0/24';
ALTER ROUTING RULE
=> \x
Expanded display is on.
=> SELECT * FROM routing_rules WHERE NAME = 'etl_rule';
-[ RECORD 1 ]----+---------------
name             | etl_rule
source_address   | 10.20.100.0/24
destination_name | etl_group

另请参阅

5.1.22 - ALTER SCHEMA

通过以下方式之一更改一个或多个架构：

  • 通过在架构中创建的表启用或禁用架构权限的继承。

  • 将架构所有权重新分配给另一个用户。

  • 更改架构磁盘配额。

  • 重命名一个或多个架构。

语法

ALTER SCHEMA [database.]schema
    DEFAULT {INCLUDE | EXCLUDE} SCHEMA PRIVILEGES
    | OWNER TO user-name [CASCADE]
    | DISK_QUOTA { value | SET NULL }

您可以在单个操作中重命名多个架构：

ALTER SCHEMA [database.]schema[,...] RENAME TO new-schema-name[,...]

参数

数据库
包含架构的数据库的名称。如果指定，则必须是当前数据库。
架构
要修改的架构的名称。
DEFAULT {INCLUDE | EXCLUDE} SCHEMA PRIVILEGES

指定是否启用或禁用指定架构中新表的默认权限继承：

  • EXCLUDE SCHEMA PRIVILEGES （默认值）：禁用架构的权限继承。

  • INCLUDE SCHEMA PRIVILEGES：指定为指定架构中的表授予的权限与为架构授予的权限相同。此选项对架构中的现有表没有影响。

另请参阅 启用架构继承。

OWNER TO
将架构所有权重新分配给指定用户： 
OWNER TO user-name [CASCADE]

默认情况下，重新分配的架构中对象的所有权保持不变。要将架构对象的所有权重新分配给新架构所有者，请使用 CASCADE 对 OWNER TO 子句进行限定。有关详细信息，请参阅下面的级联架构所有权。

DISK_QUOTA
以下几项之一：

  • 一个字符串，整数后跟支持的单位：K、M、G 或 T。如果新值小于当前使用量，操作将成功，但在使用量降至新配额以下之前，将无法使用更多磁盘空间。

  • SET NULL，用于移除配额。

有关详细信息，请参阅磁盘配额。

RENAME TO
重命名一个或多个架构： 
RENAME TO new-schema-name[,...]

需要满足以下要求：

  • 新架构名称符合标识符中描述的约定。此外，该名称在数据库中所有序列、表、投影、视图、模型和架构的名称中必须是唯一的。

  • 如果指定多个要重命名的架构，则源列表和目标列表必须具有相同数量的名称。

特权

以下几项之一：

  • 超级用户

  • 架构所有者

级联架构所有权

默认情况下，ALTER SCHEMA...OWNER TO 不会影响目标架构中对象的所有权或授予给这些对象的权限。如果使用 CASCADE 对 OWNER TO 子句进行限定，Vertica 将对目标架构中的对象执行以下操作：

  • 将先前架构所有者所拥有的对象所有权转移给新的所有者。

  • 撤销上一个架构所有者授予的所有对象权限。

如果由非超级用户发出，ALTER SCHEMA...OWNER TO CASCADE 会忽略属于其他用户的所有对象，并就其无法更改的对象返回通知。例如：

  1. 架构 ms 归用户 mayday 所有，其包含两个表： ms.t1 归 mayday 所有，ms.t2 归用户joe 所有：

    => \dt
                           List of tables
     Schema     |         Name          | Kind  |  Owner  | Comment
----------------+-----------------------+-------+---------+---------
 ms             | t1                    | table | mayday  |
 ms             | t2                    | table | joe     |

  2. 用户 mayday 使用 CASCADE 将架构 ms 的所有权转移给用户 dbadmin。返回时，ALTER SCHEMA 报告它无法转移归用户 joe 所有的表 ms.t2 及其投影的所有权：

    
=> \c - mayday
You are now connected as user "mayday".
=> ALTER SCHEMA ms OWNER TO dbadmin CASCADE;
NOTICE 3583:  Insufficient privileges on ms.t2
NOTICE 3583:  Insufficient privileges on ms.t2_b0
NOTICE 3583:  Insufficient privileges on ms.t2_b1
ALTER SCHEMA
=> \c
You are now connected as user "dbadmin".
=> \dt
                           List of tables
     Schema     |         Name          | Kind  |  Owner  | Comment
----------------+-----------------------+-------+---------+---------
 ms             | t1                    | table | dbadmin |
 ms             | t2                    | table | joe     |

  3. 用户 dbadmin 再次使用 CASCADE 将架构 ms 的所有权转移给用户 pat。这次，因为 dbadmin 是超级用户，所以 ALTER SCHEMA 可以将所有 ms 表的所有权转移给用户 pat

    => ALTER SCHEMA ms OWNER TO pat CASCADE;
ALTER SCHEMA
=> \dt
                           List of tables
     Schema     |         Name          | Kind  |  Owner  | Comment
----------------+-----------------------+-------+---------+---------
 ms             | t1                    | table | pat     |
 ms             | t2                    | table | pat     |

交换架构

重命名架构可用于交换架构而无需实际移动数据。为便于交换，请输入一个不存在的、临时占位符架构。例如，以下 ALTER SCHEMA 语句使用临时架构 temps 来帮助架构 S1 与架构 S2 进行交换。在此示例中，S1 被重命名为 temps。然后 S2 被重命名为 S1。最后，temps 被重命名为 S2。

=> ALTER SCHEMA S1, S2, temps RENAME TO temps, S1, S2;

示例

以下示例将架构 S1 和 S2 分别重命名为 S3 和 S4：

=> ALTER SCHEMA S1, S2 RENAME TO S3, S4;

此示例将新表 t2 的默认行为设置为自动继承架构的权限：

=> ALTER SCHEMA s1 DEFAULT INCLUDE SCHEMA PRIVILEGES;

=> CREATE TABLE s1.t2 (i, int);

此示例将新表的默认行为设置为不自动继承架构的权限：

=> ALTER SCHEMA s1 DEFAULT EXCLUDE SCHEMA PRIVILEGES;

另请参阅

5.1.23 - ALTER SEQUENCE

通过以下两种方式更改命名序列：

  • 设置控制序列行为的参数，例如，序列起始值以及其最小值和最大值的范围。这些更改仅在您启动新的数据库会话时生效。

  • 设置序列名称、架构或所有权。这些更改会立即生效。

语法

更改序列行为：

ALTER SEQUENCE [[database.]schema.]sequence
    [ INCREMENT [ BY ] integer ]
    [ MINVALUE integer | NO MINVALUE ]
    [ MAXVALUE integer | NO MAXVALUE ]
    [ RESTART [ WITH ] integer ]
    [ CACHE integer | NO CACHE ]
    [ CYCLE | NO CYCLE ]

更改序列名称、架构或所有权：

ALTER SEQUENCE [schema.]sequence-name {
    RENAME TO seq-name
    | SET SCHEMA schema-name]
    | OWNER TO owner-name
}

参数

架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

如果未指定架构，系统将在默认架构中创建表。

序列
要更改的序列的名称。
INCREMENT [BY] integer

一个正整数或负整数，指定每次调用 NEXTVAL 时序列的增减数量，默认设置为 1。

MINVALUE integer
NO MINVALUE （默认值）
修改序列可以生成的最小值。如果更改了此值且当前值超出了范围，增量大于零时当前值将更改为最小值，增量小于零时当前值将更改为最大值。
MAXVALUE integer
NO MAXVALUE （默认值）
修改序列的最大值。如果更改了此值且当前值超出了范围，增量大于零时当前值将更改为最小值，增量小于零时当前值将更改为最大值。
RESTART [WITH] integer
将序列的当前值更改为 integer。下一次调用 NEXTVAL 将返回 integer。
CACHEinteger
NO CACHE （默认值）
指定预先分配和存储在内存中的序列号数量，以提高访问速度。Vertica 为每个会话设置缓存，并将其分布到所有节点。默认情况下，序列缓存设置为 250,000。

有关详细信息，请参阅分发命名序列。

CYCLE
NO CYCLE （默认值）
指定序列是否可以在达到其最小值或最大值时回绕：

  • CYCLE：序列按如下方式进行回绕：

    • 当递增序列达到其上限时，会被重置为其最小值。

    • 当递减序列达到其下限时，会被重置为其最大值。

  • NO CYCLE （默认值）：在序列达到其最大值或最小值后，调用 NEXTVAL 会返回错误。

RENAME TO seq‑name
重命名当前架构中的序列，其中 seq‑name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
SET SCHEMA schema‑name
将序列移至架构 schema-name。
OWNER TO owner‑name
将当前序列所有者重新分配给指定所有者。

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 序列所有者

  • 对序列的 ALTER 权限

对于某些操作，非超级用户必须具备以下架构权限：

示例

请参阅更改序列。

另请参阅

CREATE SEQUENCE

5.1.24 - ALTER SUBCLUSTER

更改子群集的配置。您可以使用此语句重命名子群集或将其设为 默认子群集。

语法

ALTER SUBCLUSTER subcluster‑name {
    RENAME TO new-name |
    SET DEFAULT
}

参数

subcluster‑name
要更改的子群集的名称。
RENAME TO new‑name
将子群集的名称更改为 new-name。
SET DEFAULT
将子群集设为默认子群集。将新节点添加到数据库时，如果未指定要包含这些节点的子群集，Vertica 会将这些节点添加到默认子群集中。每次只能设置一个默认子群集。先前作为默认子群集的子群集将变为非默认子群集。

特权

超级用户

示例

此示例将 analytics_cluster 设为默认子群集：

=> SELECT DISTINCT subcluster_name FROM SUBCLUSTERS WHERE is_default = true;
  subcluster_name
--------------------
 default_subcluster
(1 row)

=> ALTER SUBCLUSTER analytics_cluster SET DEFAULT;
ALTER SUBCLUSTER
=> SELECT DISTINCT subcluster_name FROM SUBCLUSTERS WHERE is_default = true;
  subcluster_name
-------------------
 analytics_cluster
(1 row)

此示例将 default_subcluster 重命名为 load_subcluster：

=> ALTER SUBCLUSTER default_subcluster RENAME TO load_subcluster;
ALTER SUBCLUSTER

=> SELECT DISTINCT subcluster_name FROM subclusters;
  subcluster_name
-------------------
 load_subcluster
 analytics_cluster
(2 rows)

另请参阅

5.1.25 - ALTER SESSION

ALTER SESSION 为当前会话设置和清除会话级别的配置参数值。要识别会话级别参数，请查询系统表 CONFIGURATION_PARAMETERS。

语法

ALTER SESSION {
    SET [PARAMETER] parameter‑name=value[,...]
    | CLEAR { [PARAMETER] parameter‑name[,...] | PARAMETER ALL }
    | SET UDPARAMETER [ FOR libname ] key=value[,...]
    | CLEAR UDPARAMETER { [ FOR libname ] key[,...] | ALL }
}

参数

SET [PARAMETER]
将一个或多个配置参数设置为指定值。
CLEAR [PARAMETER]
清除在当前会话中设置的更改的指定配置参数。
CLEAR PARAMETER ALL
清除在当前会话中设置的更改的所有会话级别配置参数。
SET UDPARAMETER
设置一个或多个用户定义的会话参数 (key=value)，以与 UDx 结合使用。键值大小限制如下：

  • 从客户端设置：128 个字符

  • 从 UDx 端设置：无限制

可以通过包含子句 FOR libname 将 SET 操作的范围限制为单个库。例如：

=> ALTER SESSION SET UDPARAMETER FOR securelib username='alice';

如果指定一个库，则只有该库可以访问参数的值。使用此限制来保护包含敏感数据（例如凭据）的参数。

CLEAR UDPARAMETER
清除通过以下选项之一指定的用户定义参数：

  • [FOR libname] key[,...]：清除 key 指定的参数，（可选）这些参数的范围被限制为库 libname。

  • ALL：清除当前会话中的所有用户定义参数。

特权

无

示例

设置和清除参数

  • 强制所有支持隔离模式的 UDx 在隔离模式下运行，即使其定义指定了 NOT FENCED 也是如此：

    => ALTER SESSION SET ForceUDxFencedMode = 1;
ALTER SESSION

  • 在会话级别清除 ForceUDxFencedMode。其值将被重置为其默认值 0：

    => ALTER SESSION CLEAR ForceUDxFencedMode;
ALTER SESSION
=> SELECT parameter_name, current_value, default_value FROM configuration_parameters WHERE  parameter_name = 'ForceUDxFencedMode';
   parameter_name   | current_value | default_value
--------------------+---------------+---------------
 ForceUDxFencedMode | 0             | 0
(1 row)

  • 清除在此会话中设置的更改的所有会话级别配置参数：

    => ALTER SESSION CLEAR PARAMETER ALL;
ALTER SESSION

设置和清除用户定义的参数

  • 将库 MyLibrary 中的用户定义参数 RowCount 的值设置为 25。

    => ALTER SESSION SET UDPARAMETER FOR MyLibrary RowCount = 25;
ALTER SESSION

  • 清除会话级别的 RowCount：

    => ALTER SESSION CLEAR UDPARAMETER FOR MyLibrary RowCount;
ALTER SESSION

5.1.26 - ALTER SUBNET

重命名现有子网。

语法

ALTER SUBNET subnet‑name RENAME TO new‑subnet‑name

参数

subnet‑name
现有子网的名称。
new‑subnet‑name
子网的新名称。

特权

超级用户

示例

=> ALTER SUBNET mysubnet RENAME TO myNewSubnet;

5.1.27 - ALTER TABLE

修改现有表的元数据。所有更改都将自动提交。

语法

ALTER TABLE [[database.]schema.]table {
    ADD COLUMN [ IF NOT EXISTS ] column datatype
       [ column‑constraint ]
       [ ENCODING encoding‑type ]
       [ PROJECTIONS (projections-list) | ALL PROJECTIONS ]
    | ADD table‑constraint
    | ALTER COLUMN column {
        ENCODING encoding-type PROJECTIONS (projection-list)
        | { SET | DROP } expression }
    | ALTER CONSTRAINT constraint‑name { ENABLED | DISABLED }
    | DISK_QUOTA { value | SET NULL }
    | DROP CONSTRAINT constraint‑name [ CASCADE | RESTRICT ]
    | DROP [ COLUMN ] [ IF EXISTS ] column [ CASCADE | RESTRICT ]
    | FORCE OUTER integer
    | { INCLUDE | EXCLUDE | MATERIALIZE } [ SCHEMA ] PRIVILEGES
    | OWNER TO owner
    | partition‑clause [ REORGANIZE ]
    | REMOVE PARTITIONING
    | RENAME [ COLUMN ] name TO new‑name
    | RENAME TO new-table-name[,...]
    | REORGANIZE
    | SET {
        ActivePartitionCount { count | DEFAULT }
        | IMMUTABLE ROWS
        | MERGEOUT { 1 | 0 }
        | SCHEMA schema 
}

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要更改的表。
ADD COLUMN
向表中添加一列，默认情况下会将该列添加到所有超投影中： 
ADD COLUMN [IF NOT EXISTS]
    column datatype 
    [ NULL | NOT NULL ]
    [ ENCODING encoding‑type]
    [ PROJECTIONS (projections-list) | ALL PROJECTIONS]

对复杂类型列的限制也适用于通过 ADD COLUMN 添加的列。

如果指定的名称下面已经存在列，则可选的 IF NOT EXISTS 子句会生成一条信息性消息。如果您忽略此选项且列存在，Vertica 会生成 ROLLBACK 错误消息。

您可以使用以下选项之一限定新的列定义：

  • column‑constraint 指定一个列约束，如下所示：

    
  {NULL | NOT NULL}
  | [ DEFAULT default‑expr ] [ SET USING using‑expr ] } | DEFAULT USING exp}

  • ENCODING 指定列的编码类型。默认设置为 AUTO。

  • PROJECTIONS 将新列添加到此表的一个或多个现有投影中，指定为投影基本名称的逗号分隔列表。Vertica 将该列添加到每个投影的所有伙伴实例。投影列表不能包含具有预聚合数据的投影，例如实时聚合投影；否则，Vertica 将回退 ALTER TABLE 语句。

  • ALL PROJECTIONS 将该列添加到此表的所有投影（不包括具有预聚合数据的投影）中。

ADD table‑constraint
将约束添加到一个没有任何关联投影的表。
ALTER COLUMN
您可以通过以下两种方式之一更改现有列：

  • 在一列上为该表的一个或多个投影设置编码：

    ENCODING encoding-type PROJECTIONS (projections-list)

    其中 projections-list 是以逗号分隔的投影列表，这些投影将使用新编码进行更新。可以通过以下两种方式指定每个投影：

    • 投影基本名称：更新所有共享此基本名称的投影。

    • 投影名称：更新指定的投影。如果投影被分段，则所做的更改将传播到所有伙伴实例。

    如果其中一个投影不包含目标列，Vertica 将返回一个回退错误。

    有关详细信息，请参阅投影列编码。

  • 设置或删除一列标量数据（包括原始数组）的设置：

    SET { DEFAULT expression
          | USING expression
    | DEFAULT USING expression
    | NOT NULL
    | DATA TYPE datatype
}

    DROP { DEFAULT
     | SET USING
     | DEFAULT USING
     | NOT NULL
}

    如果列所属的复杂类型既不是标量类型也不是标量类型数组，则无法更改其数据类型。存在一个例外：在外部表中，您可以将基元列类型更改为复杂类型。

    设置 DEFAULT 或 SET USING 表达式对现有列值没有影响。要使用列的 DEFAULT 或 SET USING 表达式刷新列，请按如下方式对其进行更新：

    • SET USING 列：对该表调用 REFRESH_COLUMNS。

    • DEFAULT 列：按如下方式更新该列：

      UPDATE table-name SET column-name=DEFAULT;

使用 DEFAULT 或 SET USING 更改列会增加磁盘使用率，如果违反表或架构磁盘配额，这可能会导致操作失败。

ALTER CONSTRAINT
指定是否强制执行主键、唯一键和检查约束： 
ALTER CONSTRAINT constraint‑name {ENABLED | DISABLED}
DISK_QUOTA
以下几项之一：

  • 一个字符串，整数后跟支持的单位：K、M、G 或 T。如果新值小于当前使用量，操作将成功，但在使用量降至新配额以下之前，将无法使用更多磁盘空间。

  • SET NULL，用于移除配额。

有关详细信息，请参阅磁盘配额。

DROP CONSTRAINT
从表中删除指定的表约束： 
DROP CONSTRAINT constraint-name [CASCADE | RESTRICT]

您可以使用以下选项之一限定 DROP CONSTRAINT：

  • CASCADE：删除其他表中的约束和所有依赖项。

  • RESTRICT：如果存在依赖对象，则不删除约束。与默认行为相同。

删除表约束对引用该表的视图没有影响。

DROP [COLUMN]
删除表中的指定列以及该列的 ROS 容器： 
DROP [COLUMN] [IF EXISTS] column [CASCADE | RESTRICT]

您可以使用以下选项之一限定 DROP COLUMN：

  • 如果列不存在，IF EXISTS 会生成一条信息性消息。如果您忽略此选项且列不存在，Vertica 会生成 ROLLBACK 错误消息。

  • 如果列具有依赖项，则需要 CASCADE。

  • RESTRICT 仅删除给定表中的列。

列所在的表不能是不可变表。

请参阅删除表列。

FORCE OUTER integer
指定是否将表作为内部或外部输入联接到另一个表。有关详细信息，请参阅控制联接输入。
{INCLUDE | EXCLUDE | MATERIALIZE} [SCHEMA] PRIVILEGES
指定在默认情况下继承此表的架构权限：

  • EXCLUDE PRIVILEGES（默认）禁止从架构继承权限。

  • INCLUDE PRIVILEGES 将针对表架构授予的相同权限授予视图。

  • MATERIALIZE PRIVILEGES 将授权复制到表并在表上创建一个 GRANT 对象。这将禁用表上的权限继承标志，让您可以：

    • 在表级别授予更具体的权限。

    • 使用架构级权限作为模板。

    • 将表移动到不同的架构。

    • 更改架构权限而不影响表。

另请参阅 设置表和视图的权限继承。

OWNER TO owner
更改表所有者。
partition‑clause [REORGANIZE]
对外部表无效，通过 PARTITION BY 子句对表数据存储进行逻辑划分： 
PARTITION BY partition‑expression
  [ GROUP BY group‑expression ]
  [ SET ACTIVEPARTITIONCOUNT integer ]

有关详细信息，请参阅分区子句。

如果您使用 REORGANIZE 限定分区子句，并且在以前没有为表指定分区，则 Vertica Tuple Mover 会立即实现分区子句。如果在以前为表指定了分区，则 Tuple Mover 会评估 ROS 存储容器，并根据需要重新组织这些容器，使其符合新的分区子句。

REMOVE PARTITIONING
指定要从表定义中移除分区。 Tuple Mover 随后从 ROS 容器中移除现有分区。
RENAME [COLUMN]
重命名表中的指定列。列所在的表不能是不可变表。
RENAME TO
重命名一个或多个表： 
RENAME TO new‑table‑name[,...]

需要满足以下要求：

  • 重命名的表必须与原始表在同一架构中。

  • 新的表名 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

  • 如果指定多个要重命名的表，则源列表和目标列表必须具有相同数量的名称。

REORGANIZE
仅对分区表有效，调用 Tuple Mover，以根据需要重新组织 ROS 存储容器，使其符合表的当前分区子句。ALTER TABLE...REORGANIZE 和 Vertica 元函数PARTITION_TABLE的运行方式相同。

REORGANIZE 也可以限定一个新的分区子句。

SET
更改表设置，为以下几项之一：

  • ActivePartitionCount {count | DEFAULT }，仅对分区表有效，指定该表有多少个分区处于活动状态，为以下几项之一：

    • count：无符号整数，取代配置参数 ActivePartitionCount。

    • DEFAULT：移除表级活动分区计数。该表从配置参数 ActivePartitionCount 中获取其活动分区计数。

    有关用法的详细信息，请参阅活动和非活动分区。

  • IMMUTABLE ROWS 通过阻止 DML 操作（如 UPDATE 和 DELETE）来防止更改表行值。表的不可变性一旦设置便无法恢复。

    您不能将修整表设置为不可变。有关不可变表的所有限制的详细信息，请参阅不可变表。

  • MERGEOUT { 1 | 0 } 指定是允许还是禁止合并用来合并此表的投影数据的 ROS 容器。默认情况下，会针对所有表启用合并 (1)。

  • SCHEMA schema-name 将表从其当前架构移动到 schema-name。Vertica 自动将锚定到源表的所有投影移动到目标架构。它还将所有 IDENTITY 和 AUTO_INCREMENT 列移动到目标架构。有关详细信息，请参阅 将表移动到另一个架构

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 表所有者

  • ALTER 权限

非超级用户还必须具有 SELECT 权限才能启用或禁用 约束强制执行或移除分区。

对于某些操作，非超级用户必须具备以下架构权限：

  • 要重命名表：CREATE、USAGE

  • 要将表移动到另一个架构：对源架构具有 USAGE 权限，对目标架构具有 CREATE 权限

复杂类型的限制

原生表中使用的复杂类型除了其参考页面上列出的个别类型的限制外，还有一些限制：

  • 原生表必须至少有一个基本类型或原生数组（基本类型的一维数组）的列。如果一个 Flex 表有真实的列，它也必须至少有一个满足这个限制的列。

  • 复杂类型列不能在 ORDER BY 或 PARTITION BY 子句中使用，也不能用作 FILLER 列。

  • 复杂类型列不能有 约束。

  • 返回复杂类型的表达式不能用作投影列，并且投影不能按复杂类型的列进行分段或排序。

  • 具有复杂类型列的表不能使用 DEFAULT 和 SET USING。

独占 ALTER TABLE 子句

以下 ALTER TABLE 子句不能与其他 ALTER TABLE 子句结合使用：

  • ADD COLUMN

  • DROP COLUMN

  • RENAME COLUMN

  • SET SCHEMA

  • RENAME [TO]

节点关闭限制

仅限企业模式

当一个或多个数据库群集节点关闭时，不支持以下 ALTER TABLE 操作：

  • ALTER COLUMN ...ADD table‑constraint

  • ALTER COLUMN ...SET DATA TYPE

  • ALTER COLUMN ...{ SET DEFAULT | DROP DEFAULT }

  • ALTER COLUMN ...{ SET USING | DROP SET USING }

  • ALTER CONSTRAINT

  • DROP COLUMN

  • DROP CONSTRAINT

预聚合投影的限制

您不能修改实时聚合或 Top-K 投影中包含的锚定表列的元数据。您也不能删除这些列。要进行这些更改，您必须首先删除与之关联的所有实时聚合和 Top-K 投影。

外部表的限制

并不是所有 ALTER TABLE 选项都适用于外部表。例如，您不能向外部表添加列，但可以重命名该表：

=> ALTER TABLE mytable RENAME TO mytable2;
ALTER TABLE

锁定的表

如果操作无法在目标表上获取 O lock，Vertica 将尝试关闭该表上运行的任何内部 tuple mover 会话。如果成功，则可以继续操作。在用户会话中运行的显式 Tuple Mover 操作不会关闭。如果显式 Tuple Mover 操作在表上运行，则该操作仅在 Tuple Mover 操作完成后继续。

另请参阅

5.1.27.1 - Table-constraint

为表元数据添加约束。您可以使用 CREATE TABLE 指定表约束，或使用 ALTER TABLE 将约束添加到现有表。有关详细信息，请参阅设置约束。

语法

[ CONSTRAINT constraint-name ]
{
... PRIMARY KEY (column[,... ]) [ ENABLED | DISABLED ]
... | FOREIGN KEY (column[,... ] ) REFERENCES table [ (column[,...]) ]
... | UNIQUE (column[,...]) [ ENABLED | DISABLED ]
... | CHECK (expression) [ ENABLED | DISABLED ]
}

参数

CONSTRAINT constraint‑name
为约束分配名称。Vertica 建议对所有约束进行命名。
PRIMARY KEY
定义一个或多个 NOT NULL 列作为主键，如下所示： 
PRIMARY KEY (column[,...]) [ ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名主键约束，Vertica 会分配名称 C_PRIMARY。

FOREIGN KEY
添加引用完整性约束，以将一个或多个列定义为外键，如下所示： 
FOREIGN KEY (column[,... ]) REFERENCES table [(column[,... ])]

如果省略了 column，Vertica 将引用 table 中的主键。

如果您没有命名外键约束，Vertica 会分配名称 C_FOREIGN。

UNIQUE
指定一个列或一组列中的数据对于所有表行都是唯一的，如下所示： 
UNIQUE (column[,...]) [ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名唯一约束，Vertica 会分配名称 C_UNIQUE。

CHECK
指定检查条件，即一个返回布尔值的表达式，如下所示： 
CHECK (expression) [ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名检查约束，Vertica 会分配名称 C_CHECK。

权限

非超级用户：表所有者，或以下权限：

  • 对架构的 USAGE 权限

  • 对表的 ALTER 权限

  • 对表的 SELECT 权限，用于在表上启用或禁用约束实施

强制执行约束

表可以使用关键字 ENABLED 或 DISABLED 指定 Vertica 是否自动强制执行主键、唯一键或检查约束。如果省略了 ENABLED 或 DISABLED，Vertica 会通过检查相应的配置参数来确定是否自动启用约束：

  • EnableNewPrimaryKeysByDefault

  • EnableNewUniqueKeysByDefault

  • EnableNewCheckConstraintsByDefault

有关详细信息，请参阅约束强制执行。

示例

以下示例将使用主键约束创建一个表 (t01)。

CREATE TABLE t01 (id int CONSTRAINT sampleconstraint PRIMARY KEY);
CREATE TABLE

此示例没有使用约束创建相同表，然后添加约束 ALTER TABLE ADD CONSTRAINT

CREATE TABLE t01 (id int);
CREATE TABLE

ALTER TABLE t01 ADD CONSTRAINT sampleconstraint PRIMARY KEY(id);
WARNING 2623:  Column "id" definition changed to NOT NULL
ALTER TABLE

以下示例创建一个包含两列的表 (addapk)，向表中添加第三列，然后在第三列上添加主键约束。

=> CREATE TABLE addapk (col1 INT, col2 INT);
CREATE TABLE

=> ALTER TABLE addapk ADD COLUMN col3 INT;
ALTER TABLE

=> ALTER TABLE addapk ADD CONSTRAINT col3constraint PRIMARY KEY (col3) ENABLED;
WARNING 2623:  Column "col3" definition changed to NOT NULL
ALTER TABLE

使用示例表 addapk，检查是否启用了主键约束（is_enabled 为 t）。

=> SELECT constraint_name, column_name, constraint_type, is_enabled FROM PRIMARY_KEYS WHERE table_name IN ('addapk');

 constraint_name | column_name | constraint_type | is_enabled
-----------------+-------------+-----------------+------------
 col3constraint  | col3        | p               | t
(1 row)

此示例使用 ALTER TABLE ALTER CONSTRAINT 禁用约束。

=> ALTER TABLE addapk ALTER CONSTRAINT col3constraint DISABLED;

检查主键现在是否已禁用（is_enabled 为 f）。

=> SELECT constraint_name, column_name, constraint_type, is_enabled FROM PRIMARY_KEYS WHERE table_name IN ('addapk');

 constraint_name | column_name | constraint_type | is_enabled
-----------------+-------------+-----------------+------------
 col3constraint  | col3        | p               | f
(1 row)

有关约束的一般讨论，请参阅约束。有关创建和命名约束的其他示例，请参阅对约束进行命名。

5.1.27.2 - 投影列编码

创建表及其投影后，可以调用 ALTER TABLE...ALTER COLUMN 来设置或更改一个或多个投影中现有列的编码类型。例如：

ALTER TABLE store.store_dimension ALTER COLUMN store_region
  ENCODING rle PROJECTIONS (store.store_dimension_p1_b0, store.store_dimension_p2);

在此示例中，ALTER TABLE 语句指定对两个投影的 store_region 列设置 RLE 编码： store_dimension_p1_b0 和 store_dimension_p2。PROJECTIONS 列表分别通过投影名称和基本名称引用这两个投影。可以通过任意一种方式引用投影；在这两种情况下，更改都会传播到投影的所有伙伴实例并相应地存储在其 DDL 中：

=> select export_objects('','store.store_dimension');

                          export_objects
------------------------------------------------------------------
CREATE TABLE store.store_dimension
(
    store_key int NOT NULL,
    store_name varchar(64),
    store_number int,
    store_address varchar(256),
    store_city varchar(64),
    store_state char(2),
    store_region varchar(64)
);

CREATE PROJECTION store.store_dimension_p1
(
 store_key,
 store_name,
 store_number,
 store_address,
 store_city,
 store_state,
 store_region ENCODING RLE
)
AS
 SELECT store_dimension.store_key,
        store_dimension.store_name,
        store_dimension.store_number,
        store_dimension.store_address,
        store_dimension.store_city,
        store_dimension.store_state,
        store_dimension.store_region
 FROM store.store_dimension
 ORDER BY store_dimension.store_key
SEGMENTED BY hash(store_dimension.store_key) ALL NODES KSAFE 1;

CREATE PROJECTION store.store_dimension_p2
(
 store_key,
 store_name,
 store_number,
 store_address,
 store_city,
 store_state,
 store_region ENCODING RLE
)
AS
 SELECT ...

5.1.28 - ALTER TLS CONFIGURATION

更改指定的 TLS CONFIGURATION 对象。有关现有 TLS CONFIGURATION 对象的信息，请查询 TLS_CONFIGURATIONS。

语法

ALTER TLS CONFIGURATION tls_config_name {
    [ CERTIFICATE { NULL | cert_name }
    [ ADD CA CERTIFICATES ca_cert_name [,...] ]
    [ REMOVE CA CERTIFICATES ca_cert_name [,...] ]
    [ CIPHER SUITES { '' | 'openssl_cipher [,...]' } ]
    [ TLSMODE 'tlsmode' ]
    [ OWNER TO user_name ]
}

参数

tls_config_name
要更改的 TLS CONFIGURATION 对象。
NULL
从 TLS 配置中移除非 CA 证书。
cert_name
使用 CREATE CERTIFICATE 创建的证书。

您必须拥有证书的使用权限（来自 证书 的所有权或 对其密钥的使用，如果有的话）将其添加到 TLS 配置。

ca_cert_name
使用 CREATE CERTIFICATE 创建的 CA 证书。

您必须拥有证书的使用权限（来自 证书 的所有权或 对其密钥的使用，如果有的话）将其添加到 TLS 配置。

openssl_cipher
要使用的密码套件的逗号分隔列表，而不是默认的密码套件集。为该参数提供空字符串会清除备用密码套件列表，并指示指定的 TLS CONFIGURATION 使用默认密码套件集。

要查看启用的密码套件，请使用 LIST_ENABLED_CIPHERS。

tlsmode
Vertica 如何建立 TLS 连接并处理证书（以下几项之一，按安全性升序排列）：

  • DISABLE：禁用 TLS。此参数的所有其他选项都启用 TLS。

  • ENABLE：启用 TLS。Vertica 不检查客户端证书。

  • TRY_VERIFY：如果出现以下任一情况，则建立 TLS 连接：

    • 另一台主机出示有效证书

    • 另一台主机不提供证书

    如果其他主机提供无效证书，则连接将使用纯文本。

  • VERIFY_CA：如果 Vertica 验证其他主机的证书来自受信任的 CA，则连接成功。如果其他主机不提供证书，则连接使用纯文本。

  • VERIFY_FULL：如果 Vertica 验证其他主机的证书来自受信任的 CA，并且证书的 cn（通用名称）或 subjectAltName 属性与其他主机的主机名或 IP 地址匹配，则连接成功。

    请注意，对于客户端证书，cn 将用于用户名，因此 subjectAltName 必须与其他主机的主机名或 IP 地址匹配。

VERIFY_FULL 不受客户端-服务器 TLS 和 HTTPS（分别为参数 ServerTLSConfig 和 HttpsTLSConfig）支持，其行为类似于 VERIFY_CA。

特权

非超级用户： 对 TLS CONFIGURATION 的 ALTER 权限。

示例

要配置客户端-服务器 TLS，请参阅配置客户端-服务器 TLS。

要为 LDAP Link 服务及其试运行函数配置 TLS，请参阅 LDAP Link 的 TLS。

要为 LDAP 身份验证记录配置 TLS，请参阅 LDAP 身份验证的 TLS。

要从 LDAPLink TLS 配置中移除所有证书和 CA 证书：

=>  SELECT * FROM tls_configurations WHERE name='LDAPLink';
   name   |  owner  | certificate | ca_certificate | cipher_suites |  mode
----------+---------+-------------+----------------+---------------+---------
 LDAPLink | dbadmin | server_cert | ca             |               | DISABLE
 LDAPLink | dbadmin | server_cert | ica            |               | DISABLE
(2 rows)

=> ALTER TLS CONFIGURATION LDAPLink CERTIFICATE NULL REMOVE CA CERTIFICATES ca, ica;
ALTER TLS CONFIGURATION

=> SELECT * FROM tls_configurations WHERE name='LDAPLink';
   name   |  owner  | certificate | ca_certificate | cipher_suites |  mode
----------+---------+-------------+----------------+---------------+---------
 LDAPLink | dbadmin |             |                |               | DISABLE
(3 rows)

要为客户端-服务器 TLS 使用一组备用密码套件：

 => ALTER TLS CONFIGURATION server CIPHER SUITES
    'DHE-PSK-AES256-CBC-SHA384,
     DHE-PSK-AES128-GCM-SHA256,
     PSK-AES128-CBC-SHA256';
ALTER TLS CONFIGURATION

 => SELECT name, cipher_suites FROM tls_configurations WHERE name='server';
   name   |                               cipher_suites
 server   | DHE-PSK-AES256-CBC-SHA384,DHE-PSK-AES128-GCM-SHA256,PSK-AES128-CBC-SHA256
(1 row)

5.1.29 - ALTER USER

更改用户帐户参数和用户级别配置参数。

语法

ALTER USER user‑name {
   account‑parameter value[,...]
   | SET [PARAMETER] cfg‑parameter=value[,...]
   | CLEAR [PARAMETER] cfg‑parameter[,...]
}

参数

user‑name
用户名。包含特殊字符的名称必须加上双引号。要强制区分大小写，请使用双引号。

有关名称要求的详细信息，请参阅创建数据库名称和密码。

account‑parameter value
指定用户帐户设置（见下文）。
SET [PARAMETER]
设置指定的配置参数。新设置仅适用于当前会话，以及该用户启动的所有后续会话。并发用户会话不受新设置的影响，除非它们调用元函数 RESET_SESSION。
CLEAR [PARAMETER]
将指定的配置参数重置为其默认值。

用户帐户参数

以逗号分隔列表的形式指定一个或多个用户帐户参数及其设置：

account‑parameter value[,...]

参数

设置
ACCOUNT

锁定或解锁用户对数据库的访问，可以用以下操作之一：

  • UNLOCK （默认值）

  • LOCK 可使新用户无法登录，在为不需要直接访问权限的用户创建帐户时十分有用。
DEFAULT ROLE

指定哪些角色是此用户的默认角色，设置为以下之一：

  • NONE （默认值）：删除所有默认角色。

  • ALL：将所有用户角色设置为默认值。

当用户登录时，会自动激活默认角色。此参数指定的角色将取代之前分配的任何角色。
GRACEPERIOD

指定用户查询可以被任何会话套接字拦截多长时间，可以是以下值之一：

  • NONE （默认值）：移除先前对会话查询设置的任何宽限期。

  • 'interval'：将当前会话查询的最长宽限期指定为间隔，最长 20 天。

有关详细信息，请参阅处理会话套接字阻止。
IDENTIFIED BY

更改用户密码：

IDENTIFIED BY '[new-password]'

['hashed-password' SALT 'hash-salt'] [REPLACE 'current-password']

  • new-password：Vertica 随后将进行哈希处理以用于内部存储的 ASCII 密码。如果为空字符串，则该用户无需密码即可访问数据库。

  • hashed-password: 经过预哈希处理的密码及其关联的十六进制字符串 hash-salt。以这种方式设置密码会绕过所有密码复杂性要求。

  • REPLACE：对于必须提供当前密码的非超级用户来说，为必需选项。非超级用户只能更改自己的密码。

有关详细信息，请参阅“密码指导原则”和“创建数据库名称和密码”。
IDLESESSIONTIMEOUT

系统在断开空闲会话之前所等待的时间长度，可以为以下值之一：

  • NONE （默认值）：未对此用户设置限制。如果省略此参数，则不会对此用户设置限制。

  • 'interval'：一个时间间隔值，最长为一年。

有关详细信息，请参阅管理客户端连接。
MAXCONNECTIONS

设置用户可以与服务器建立的最大连接数，可以为以下值之一：

  • NONE （默认值）：没有设置限制。如果省略此参数，则用户可以在数据库群集中拥有无限数量的连接。

  • integer ON DATABASE：设置为 integer，跨数据库群集的最大连接数。

  • integer ON NODE：设置为 integer，到每个节点的最大连接数。

有关详细信息，请参阅管理客户端连接。
MEMORYCAP

设置可以为用户请求分配的内存量，可以为下之值一：

  • NONE （默认值）：没有限制

  • 一个字符串值，用于指定内存限制，为以下几项之一：

    • ' int%' 将最大值表示为资源管理器可用总内存的百分比到，其中 int 是 0 到 100 之间的整数值。例如：

      MEMORYCAP '40%'

    • 'int{K|M|G|T}' 表示内存分配（以千字节、兆字节、千兆字节或太字节为单位）。例如：

      MEMORYCAP '10G'
PASSWORD EXPIRE

强制用户密码立即到期。用户必须在下次登录时更改密码。

PROFILE

分配一个配置文件来控制此用户的密码要求，可以为以下值之一：

  • DEFAULT （默认值）：将默认数据库配置文件分配给该用户。

  • profile-name：该配置文件由 CREATE PROFILE 定义。

 
RENAME TO

为用户分配新的用户名。分配给用户的所有权限保持不变。
RESOURCE POOL 将默认资源池文件分配给该用户。还必须对用户授予此池的权限，除非该池的权限设置为 PUBLIC。
RUNTIMECAP

设置此用户的查询可以执行多长时间，可以为以下值之一：

  • NONE （默认值）：未对此用户设置限制。如果省略此参数，则不会对此用户设置限制。

  • 'interval'：一个时间间隔值，最长为一年。

查询的运行时限制可以在三个级别设置：用户的运行时限制、用户的资源池和会话设置。有关详细信息，请参阅为查询设置运行时限制。
SEARCH_PATH

指定用户默认搜索路径，此路径会指示 Vertica 在哪个架构中搜索引用的未限定表和 UDF，可以是以下值之一：

  • DEFAULT （默认值）：按如下方式设置搜索路径：

    "$user", public, v_catalog, v_monitor, v_internal

  • 以逗号分隔的架构列表。

有关详细信息，请参阅设置搜索路径。
SECURITY_ALGORITHM 'algorithm'

设置哈希身份验证的用户级别安全算法，其中 algorithm 为以下之一：

  • NONE （默认值）：使用系统级别参数， SecurityAlgorithm

  • SHA512

  • MD5

当您更改 SECURITY_ALGORITHM 值时，用户密码将会过期，因此必须重置密码。
TEMPSPACECAP

设置用户请求可用的临时文件存储量，可以为下之值一：

  • NONE （默认值）：没有限制

  • 指定存储限制的字符串值，可以为下之值一：

    • int% 将最大值表示为资源管理器可用的临时总存储的百分比，其中 int 为 0 至 100 之间的整数值。例如：

      TEMPSPACECAP '40%'

    • int{K|M|G|T} 以 KB、MB、GB 或 TB 表示存储分配。例如：

      TEMPSPACECAP '10G'

特权

非超级用户可以在自己的用户帐户上更改以下选项：

  • IDENTIFIED BY

  • RESOURCE POOL

  • SEARCH_PATH

  • SECURITY_ALGORITHM

将另一个用户的默认资源池更改为 PUBLIC 架构之外的资源池时，用户必须至少通过以下途径之一获得资源池的 USAGE 权限：

设置用户级别配置参数

SET | CLEAR PARAMETER 只能指定用户级别配置参数，否则 Vertica 将返回错误。只有超级用户可以设置和清除用户级别参数，除非它们在会话级也受支持。

要获取用户级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS。例如：

=> SELECT parameter_name, allowed_levels FROM configuration_parameters
      WHERE allowed_levels ilike '%USER%' AND parameter_name ilike '%depot%' ORDER BY parameter_name;
       parameter_name        |     allowed_levels
-----------------------------+-------------------------
 BackgroundDepotWarming      | SESSION, USER, DATABASE
 DepotOperationsForQuery     | SESSION, USER, DATABASE
 EnableDepotWarmingFromPeers | SESSION, USER, DATABASE
 UseDepotForReads            | SESSION, USER, DATABASE
 UseDepotForWrites           | SESSION, USER, DATABASE
(5 rows)

以下示例为两个用户 Yvonne 和 Ahmed 设置用户级别配置参数 UseDepotForWrites：

=> SHOW USER Yvonne PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Yvonne | DepotOperationsForQuery | Fetches
(1 row)

=> ALTER USER Yvonne SET PARAMETER UseDepotForWrites = 0;
ALTER USER
=> SHOW USER Yvonne PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Yvonne | DepotOperationsForQuery | Fetches
 Yvonne | UseDepotForWrites       | 0
(2 rows)

=> ALTER USER Ahmed SET PARAMETER DepotOperationsForQuery = 'Fetches';
ALTER USER
=> SHOW USER ALL PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Ahmed  | DepotOperationsForQuery | Fetches
 Yvonne | DepotOperationsForQuery | Fetches
 Yvonne | UseDepotForWrites       | 0
(3 rows)

示例

设置用户密码

=> CREATE USER user1;
=> ALTER USER user1 IDENTIFIED BY 'newpassword';

设置用户的安全算法和密码

此示例将用户的安全算法和密码分别设置为 SHA-512 和 newpassword。执行 ALTER USER 语句时，Vertica 会使用 SHA-512 算法对密码进行哈希处理，并保存哈希：

=> CREATE USER user1;
        => ALTER USER user1 SECURITY_ALGORITHM 'SHA512' IDENTIFIED BY 'newpassword'

为用户分配默认角色

此示例使用户的已分配角色成为用户的默认角色。用户登录时会自动设置（启用）默认角色：

=> CREATE USER user1;
CREATE USER
=> GRANT role1, role2, role3 to user1;
=> ALTER USER user1 DEFAULT ROLE ALL;

您可以将 ALL 与 EXCEPT 配对以排除某些角色：

=> CREATE USER user2;
CREATE USER
=> GRANT role1, role2, role3 to user2;
=> ALTER USER user2 DEFAULT ROLE ALL EXCEPT role1;

另请参阅

5.1.30 - ALTER VIEW

修改现有 视图的元数据。更改将自动提交。

语法

一般用途：

ALTER VIEW [[database.]schema.]view {
    | OWNER TO owner
    | SET SCHEMA schema
    | { INCLUDE | EXCLUDE | MATERIALIZE } [ SCHEMA ] PRIVILEGES
}

重命名视图：

ALTER VIEW [[database.]schema.]view[,...] RENAME TO new-view-name[,...]

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
要更改的视图。
SET SCHEMA schema
将视图从一个架构移动到另一个架构。
OWNER TO owner
更改视图所有者。
{ INCLUDE | EXCLUDE | MATERIALIZE } [SCHEMA] PRIVILEGES
指定此视图的架构权限的默认继承：

  • EXCLUDE [SCHEMA] PRIVILEGES （默认）禁止从架构继承权限。

  • INCLUDE [SCHEMA] PRIVILEGES 将授予视图架构的相同权限授予视图。

  • MATERIALIZE：将授权复制到视图并在视图上创建一个 GRANT 对象。这将禁用视图上继承的权限标志，让您可以：

    • 在视图级别授予更具体的权限

    • 使用架构级权限作为模板

    • 将视图移动到不同的架构

    • 更改架构权限而不影响视图

另请参阅 设置表和视图的权限继承。

RENAME TO
重命名一个或多个视图： 
RENAME TO new‑view‑name[,...]

需要满足以下要求：

  • 新的视图名称 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

  • 如果指定多个要重命名的视图，源列表和目标列表必须具有相同数量的名称。

  • 重命名一个视图需要对包含该视图的架构具有 USAGE 和 CREATE 权限。

特权

非超级用户：对架构的 USAGE 权限，为以下之一：

  • 视图所有者

  • 对视图的 ALTER 权限

对于某些操作，非超级用户必须具备以下架构权限：

示例

将视图 view1 重命名为 view2：

=> CREATE VIEW view1 AS SELECT * FROM t;
CREATE VIEW
=> ALTER VIEW view1 RENAME TO view2;
ALTER VIEW

5.2 - ACTIVATE DIRECTED QUERY

激活定向查询并使其可用于所有会话中的查询优化器。

语法

ACTIVATE DIRECTED QUERY [ query-name ]

参数

query-name
标识要激活的定向查询。如果省略，Vertica 将激活最后创建的定向查询。若要获取定向查询的标识符，请使用 GET DIRECTED QUERY 或查询系统表 DIRECTED_QUERIES。

特权

超级用户

激活生命周期

激活定向查询后，它将始终处于活动状态，直到被 DEACTIVATE DIRECTED QUERY 以显式方式停用或被 DROP DIRECTED QUERY 从存储空间中移除。如果在数据库关闭时定向查询处于活动状态，当您重新启动数据库时，Vertica 会自动将其重新激活。

示例

请参阅激活和停用定向查询。

5.3 - BEGIN

启动事务块。

语法

BEGIN [ WORK | TRANSACTION ] [ isolation‑level ] [ READ [ONLY] | WRITE ]

参数

WORK | TRANSACTION
仅为了提高可读性的可选关键字。
isolation‑level
指定事务的隔离级别，用于确定当同时运行其他事务时此事务可以访问的数据，为以下之一：

  • READ COMMITTED（默认值）:

  • SERIALIZABLE

  • REPEATABLE READ（自动转换为 SERIALIZABLE）

  • READ UNCOMMITTED（自动转换为 READ COMMITTED）

有关详细信息，请参阅事务。

READ [ONLY] | WRITE
指定事务模式，为以下之一：

  • READ WRITE（默认）：事务为读取/写入。

  • READ ONLY：事务为只读。

如果将事务会话模式设置为只读，将不允许使用以下 SQL 语句，但是不会阻止所有磁盘写入操作：

  • INSERT、UPDATE、DELETE 和 COPY（如果目标表不是临时表）

  • 所有 CREATE、ALTER 和 DROP 命令

  • GRANT、REVOKE 和 EXPLAIN（如果要运行的 SQL 为上面引用的语句之一）。

特权

无

示例

创建一个隔离级别设置为 READ COMMITTED 且事务模式设置为 READ WRITE 的事务：

=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
BEGIN
=> CREATE TABLE sample_table (a INT);
CREATE TABLE
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)

=> END;
COMMIT

另请参阅

5.4 - CALL

调用使用 CREATE PROCEDURE（存储） 创建的存储过程。

语法

CALL [[database.]schema.]procedure( [ argument-list] );

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
存储过程的名称，其中 procedure 符合标识符中描述的约定。
argument-list
要传递给存储过程的实参的逗号分隔列表，其类型与实参的 IN 参数的类型对应。

特权

非超级用户：对过程的 EXECUTE 权限

示例

请参阅 执行存储过程 和 存储过程：用例和示例。

另请参阅

5.5 - COMMENT ON 语句

COMMENT ON 此语句用于对数据库对象（如架构、表和库）创建注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

5.5.1 - 有关约束的注释

添加、修订或移除有关约束的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON CONSTRAINT constraint ON [[database.]schema.]table IS ... {'comment' | NULL };

参数

约束
与注释相关联的约束的名称。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要与注释相关联的表约束的名称。
注释
指定要添加的注释文本。如果此约束已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 promotion_dimension 表上的 constraint_x 约束添加了一条注释：

=> COMMENT ON CONSTRAINT constraint_x ON promotion_dimension IS 'Primary key';

以下示例从 promotion_dimension 表上的 constraint_x 约束中移除了一条注释：

=> COMMENT ON CONSTRAINT constraint_x ON promotion_dimension IS NULL;

5.5.2 - 有关函数的注释

添加、修订或移除有关函数的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要与注释相关联的函数的名称。
function‑args
函数实参。
comment
指定要添加的注释文本。如果此函数已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 macros.zerowhennull (x INT) 函数添加了一条注释：

=> COMMENT ON FUNCTION macros.zerowhennull(x INT) IS 'Returns a 0 if not NULL';

以下示例从 macros.zerowhennull (x INT) 函数中移除了一条注释：

=> COMMENT ON FUNCTION macros.zerowhennull(x INT) IS NULL;

5.5.3 - COMMENT ON AGGREGATE FUNCTION

添加、修订或移除聚合函数的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON AGGREGATE FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要与注释相关联的聚合函数的名称。
function‑args
函数实参。
comment
指定要添加的注释文本。如果此函数已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 APPROXIMATE_MEDIAN(x FLOAT) 函数添加了一条注释：

=> COMMENT ON AGGREGATE FUNCTION APPROXIMATE_MEDIAN(x FLOAT) IS 'alias of APPROXIMATE_PERCENTILE with 0.5 as its parameter';

以下示例从 APPROXIMATE_MEDIAN(x FLOAT) 函数中移除了一条注释：

=> COMMENT ON AGGREGATE FUNCTION APPROXIMATE_MEDIAN(x FLOAT) IS NULL;

5.5.4 - COMMENT ON ANALYTIC FUNCTION

添加、修订或移除分析函数的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON ANALYTIC FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要与注释相关联的分析函数的名称。
function‑args
函数实参。
comment
指定要添加的注释文本。如果此函数已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向用户定义的 an_rank() 函数添加了一条注释：

=> COMMENT ON ANALYTIC FUNCTION an_rank() IS 'built from the AnalyticFunctions library';

以下示例从用户定义的 an_rank() 函数中移除了一条注释：

=> COMMENT ON ANALYTIC FUNCTION an_rank() IS NULL;

5.5.5 - 有关库的注释

添加、修订或移除有关库的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON LIBRARY [[database.]schema.]library IS {'comment' | NULL}

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

库
与注释相关联的库的名称。
注释
指定要添加的注释文本。如果此库已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向库添加了一条注释 MyFunctions:

=> COMMENT ON LIBRARY MyFunctions IS 'In development';

以下示例从库中移除了一条注释 MyFunctions:

=> COMMENT ON LIBRARY MyFunctions IS NULL;

另请参阅

5.5.6 - 有关节点的注释

添加、修订或移除有关节点的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

如果删除某个对象，将删除与该对象关联的所有注释。

语法

COMMENT ON NODE node‑name IS  { 'comment' | NULL }

参数

node‑name
与注释相关联的节点的名称。
注释
指定要添加的注释文本。如果此节点已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例为 initiator node 添加了一条注释：

=> COMMENT ON NODE initiator IS 'Initiator node';

以下示例从 initiator node 中移除了一条注释：

=> COMMENT ON NODE initiator IS NULL;

另请参阅

COMMENTS

5.5.7 - COMMENT ON PROJECTION

添加、修订或移除有关投影的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

如果删除某个对象，将删除与该对象关联的所有注释。

语法

COMMENT ON PROJECTION [[database.]schema.]projection IS { 'comment' | NULL }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
与注释相关联的投影的名称。
注释
指定要添加的注释的文本。如果此投影已存在注释，则您在此处输入的注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 customer_dimension_vmart_node01 投影添加了一条注释：

=> COMMENT ON PROJECTION customer_dimension_vmart_node01 IS 'Test data';

以下示例从 customer_dimension_vmart_node01 投影中移除了一条注释：

=> COMMENT ON PROJECTION customer_dimension_vmart_node01 IS NULL;

另请参阅

COMMENTS

5.5.8 - COMMENT ON PROJECTION COLUMN

添加、修订或移除投影列注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON COLUMN [[database.]schema.]projection.column IS {'comment' | NULL}

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection.column
要与注释相关联的投影和列的名称。
注释
指定要添加的注释文本。如果此列已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 customer_dimension 投影中的 customer_name 列添加了一条注释：

=> COMMENT ON COLUMN customer_dimension_vmart_node01.customer_name IS 'Last name only';

以下示例从 customer_dimension 投影中的 customer_name 列中移除了一条注释：

=> COMMENT ON COLUMN customer_dimension_vmart_node01.customer_name IS NULL;

5.5.9 - 有关架构的注释

添加、修订或移除有关架构的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON SCHEMA schema-name IS {'comment' | NULL}

参数

schema‑name
与注释相关联的架构。
注释
要添加的注释的文本。如果此架构已存在注释，则您在此处输入的注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 public 架构添加了一条注释：

=> COMMENT ON SCHEMA public  IS 'All users can access this schema';

以下示例从 public 架构中移除了一条注释。

=> COMMENT ON SCHEMA public IS NULL;

5.5.10 - 有关序列的注释

添加、修订或移除有关序列的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON SEQUENCE [[database.]schema.]sequence IS { 'comment' | NULL }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

序列
与注释相关联的序列的名称。
注释
指定要添加的注释的文本。如果此序列已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向名为 prom_seq 的序列添加了一条注释。

=> COMMENT ON SEQUENCE prom_seq IS 'Promotion codes';

以下示例从 prom_seq 序列中移除了一条注释。

=> COMMENT ON SEQUENCE prom_seq IS NULL;

5.5.11 - 有关表的注释

添加、修订或移除有关表的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON TABLE [[database.]schema.]table IS { 'comment' | NULL }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要与注释相关联的表的名称。
注释
指定要添加的注释的文本。注释的文本两边需要加上单引号。如果此表已存在注释，则您在此处输入的注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除之前添加的注释。

特权

非超级用户：对象所有者

示例

以下示例向 promotion_dimension 表添加了一条注释：

=> COMMENT ON TABLE promotion_dimension IS '2011 Promotions';

以下示例从 Promotion_dimension 表中移除了一条注释：

=> COMMENT ON TABLE promotion_dimension IS NULL;

5.5.12 - COMMENT ON TABLE COLUMN

添加、修订或移除表列注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON COLUMN [[database.]schema.]table.column IS {'comment' | NULL}

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table.column
要与注释相关联的表和列的名称。
注释
指定要添加的注释文本。如果此列已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 store 架构的 store_sales_fact 表中的 transaction_time 列添加了一条注释：

=> COMMENT ON COLUMN store.store_sales_fact.transaction_time IS 'GMT';

以下示例从 store 架构的 store_sales_fact 表中的 transaction_time 列中移除了一条注释：

=> COMMENT ON COLUMN store.store_sales_fact.transaction_time IS NULL;

5.5.13 - 有关转换函数的注释

添加、修订或移除有关用户定义的转换函数的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON TRANSFORM FUNCTION [[database.]schema.]tfunction
...( [ tfunction-arg-name tfunction-arg-type ][,...] ) IS {'comment' | NULL}

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

tfunction
要与注释相关联的转换函数的名称。
tfunction‑arg‑name tfunction‑arg‑type
一个或多个转换函数实参的名称和数据类型。如果您提供了参数名称和类型，则每种类型必须与用于创建原始转换函数的库中指定的类型相匹配。
注释
指定要添加的注释文本。如果此转换函数已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 macros.zerowhennull (x INT) UTF 函数添加了一条注释：

=> COMMENT ON TRANSFORM FUNCTION macros.zerowhennull(x INT) IS 'Returns a 0 if not NULL';

以下示例使用 acros.zerowhennull (x INT)选项从 NULL 函数中移除了一条注释。

=> COMMENT ON TRANSFORM FUNCTION macros.zerowhennull(x INT) IS NULL;

5.5.14 - 有关视图的注释

添加、修订或移除有关视图的注释。每个对象可以有一条注释。注释存储在系统表 COMMENTS 中。

语法

COMMENT ON VIEW [[database.]schema.]view IS { 'comment' | NULL }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
要与注释相关联的视图的名称。
注释
指定要添加的注释的文本。如果此视图已存在注释，则此注释将覆盖之前的注释。

注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。

NULL
移除现有注释。

特权

非超级用户：对象所有者

示例

以下示例向 curr_month_ship 视图中添加了一条注释：

=> COMMENT ON VIEW curr_month_ship IS 'Shipping data for the current month';

以下示例从 curr_month_ship 视图中移除了一条注释：

=> COMMENT ON VIEW curr_month_ship IS NULL;

5.6 - COMMIT

结束当前事务，使事务期间发生的所有变更永久化且对其他用户可见。

COMMIT 等同于 END

语法

COMMIT [ WORK | TRANSACTION ]

参数

WORK TRANSACTION
仅为了提高可读性的可选关键字。

特权

无

示例

本示例显示如何提交插入。

=> CREATE TABLE sample_table (a INT);
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
=> COMMIT;

另请参阅

5.7 - CONNECT TO VERTICA

连接到另一个 Vertica 数据库，以便分别使用 COPY FROM VERTICA 和 导出到 VERTICA 在 Vertica 数据库之间导入和导出数据。

与另一个数据库建立连接后，该连接在当前会话中保持打开状态，直到使用 DISCONNECT 将其显式关闭。一次只能与另一个数据库建立一个连接。但是，您可以在同一会话中建立与不同数据库的连续连接。

默认情况下，通过 Vertica 专用网络调用 CONNECT TO VERTICA。有关通过公用网络创建连接的信息，请参阅使用公共和专用 IP 网络。

语法

CONNECT TO VERTICA db‑spec USER username PASSWORD 'password' ON 'host', port
    [ TLSMODE PREFER ]
    [ TLSCONFIG tls_config_name ]

参数

db‑spec
目标数据库，数据库名称或 DEFAULT。
username
连接到其他数据库时使用的用户名。
password
包含用于连接到目标数据库的密码的字符串。

如果目标数据库没有密码，而您提供了密码，连接将成功；但是，Vertica 不会返回您提供的密码不正确的指示。

host
包含其他数据库中某个节点的主机名的字符串。
port
其他数据库的端口号，以整数形式表示。
TLSMODE PREFER
将此连接的配置参数 ImportExportTLSMode 的值覆盖为 PREFER。如果 ImportExportTLSMode 设置为 *_FORCE，则无法进行覆盖。

如果 TLSMODE PREFER 和 ImportExportTLSMode 均未设置，CONNECT TO VERTICA 将使用 ENABLE。

TLSCONFIG tls_config_name
要用于 TLS 的 TLS CONFIGURATION。

从不使用指定的 TLS CONFIGURATION 的 TLSMODE。相反，CONNECT TO VERTICA 使用 TLSMODE PREFER 和 ImportExportTLSMode 参数。

特权

无

安全要求

如 安全性和身份验证 中所述，对 Vertica 数据库执行导入/导出时，您只能连接到使用受信任（仅限用户名）或基于密码的身份验证的数据库。不支持 SSL 身份验证。

如果配置了证书，Vertica 会在传输期间使用 TLS 加密数据并尝试加密计划元数据。您可以设置配置参数 ImportExportTLSMode，以要求对计划元数据进行加密。

示例

=> CONNECT TO VERTICA ExampleDB USER dbadmin PASSWORD 'Password123' ON 'VerticaHost01',5433;
CONNECT

5.8 - COPY

COPY 可将数据批量加载到 Vertica 数据库中。默认情况下，COPY 会自动提交自身及所有当前事务（加载临时表时除外）。如果 COPY 被中止或中断，Vertica 将予以回退。

COPY 以 UTF-8 编码格式读取数据。

有关在群集主机或客户端系统上加载一个或多个文件或管道的信息，请参阅 COPY LOCAL。

语法

COPY [ /*+ LABEL (label‑string)*/ ] [[database.]schema-name.]target-table
   [ ( { column-as-expression | column }
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FILLER datatype]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
       [,...] ) ]
   [ COLUMN OPTION (column
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
     [,...] ) ]
FROM {
   [ LOCAL ] STDIN [ compression ]
   | { 'path-to-data'
       [ ON { nodename | (nodeset) | ANY NODE | EACH NODE } ] [ compression ] }[,...]
     [ PARTITION COLUMNS column[,...] ]
   | LOCAL 'path-to-data' [ compression ] [,...]
   | VERTICA source-database.[source-schema.]source-table[( source-column[,...] ) ]
  }
  [ NATIVE
    | FIXEDWIDTH COLSIZES {( integer )[,...]}
    | NATIVE VARCHAR
    | ORC
    | PARQUET
  ]
  | [ WITH ] UDL-clause[...]
}
   [ ABORT ON ERROR ]
   [ DELIMITER [ AS ] 'char' ]
   [ ENCLOSED [ BY ] 'char'
   [ ENFORCELENGTH ]
   [ ERROR TOLERANCE ]
   [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
   [ EXCEPTIONS 'path' [ ON nodename] [,...]
   [ NULL [ AS ] 'string' ]
   [ RECORD TERMINATOR 'string' ]
   [ REJECTED DATA {'path' [ ON nodename] [,...] | AS TABLE reject-table} ]
   [ REJECTMAX integer ]
   [ SKIP integer ]
   [ SKIP BYTES integer ]
   [ STREAM NAME  'streamName']
   [ TRAILING NULLCOLS ]
   [ TRIM 'byte' ]
   [ [ WITH ] PARSER parser ([ arg=value[,...] ]) ] ]
   [ NO COMMIT ]

参数

请参阅参数。

限制

请参阅限制。

特权

超级用户具有完整的 COPY 权限。以下要求适用于非超级用户：

  • 对表的 INSERT 权限

  • 对架构的 USAGE 权限

  • 用户可访问的存储位置

  • 授予的对读取或写入文件的存储位置的相应 READ 或 WRITE 权限

COPY 可以指定一个路径来存储被拒绝的数据和异常。如果路径解析为存储位置，则以下权限适用于非超级用户：

5.8.1 - 参数

COPY 参数及其描述分为以下部分：

目标选项

以下选项适用于目标表及其列：

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

在 CREATE EXTERNAL TABLE 或 CREATE FLEX EXTERNAL TABLE 语句中使用时，COPY 将忽略 schema-name。

target-table
用于加载新数据的目标列式表或 Flex 表。Vertica 将数据从架构表加载到包含列的全部投影中。
column-as-expression
用于计算目标列值的表达式，不可以是复杂类型。例如： 
=> COPY t(year AS TO_CHAR(k, 'YYYY')) FROM 'myfile.dat'

当加载到目标数据库时，使用该选项来转换数据。

有关详细信息，请参阅在加载期间转换数据。

列
限制加载至表中一个或多个指定列。如果未指定列，COPY 将默认加载所有列。

将向从列列表中忽略的表列分配其 DEFAULT 或 SET USING 值（如有）；否则，COPY 将插入 NULL。

如果将 column 参数留空以加载表中的所有列，则可以使用可选参数 COLUMN OPTION 来为特定列指定解析选项。

数据文件必须包含与 COPY 命令列列表中数量相同的列。

COLUMN OPTION
为表列列表中声明的一个或多个列指定加载元数据。例如，可以指定一个具有自己的 DELIMITER、ENCLOSED BY 或 NULL AS 等表达式的列。不必在 COLUMN OPTION 列表中显式指定每个列名称，但是指定的每一列必须对应表列列表中的列。

列选项

根据选项的指定方式，以下 COPY 选项可以对特定列或所有列进行限定。某些解析器特定选项也可以应用于特定列或所有列。有关这两种模式的详细信息，请参阅全局选项和特定于列的选项。

ENFORCELENGTH
如果指定，COPY 将拒绝 CHAR、VARCHAR、BINARY 和 VARBINARY 类型的数据行，或集合中这些类型的元素（如果集合大于声明的大小）。

默认情况下，COPY 会截断这些数据类型的违反约束的行以及集合中这些类型的元素，但不会拒绝这些行。有关更多详细信息，请参阅处理混乱数据。

如果集合不适合其所有元素，COPY 会拒绝行，但不会截断。不会减少元素的数量。如果每个元素各自都在限制范围内，但元素数量导致集合超过列的最大大小，则可能会发生这种情况。

FILLER datatype
读取但不复制输入列的数据。使用填充内容列来忽略在表中没有列的输入列。还可以使用填充内容列来转换数据（请参阅示例和在加载期间转换数据）。填充内容列不可以是复杂类型。
FORMAT 'format'
输入格式，为以下之一：

  • 八进制

  • 十六进制

  • 比特流

请参阅二进制（原生）数据了解更多关于这些格式的信息。

加载日期/时间列时，使用 FORMAT 会显著提升加载性能。COPY 与 TO_DATE 函数支持相同的格式。请参阅用于日期/时间格式化的模板模式。

如果指定了无效格式的字符串，COPY 操作将返回错误。

NULL [AS]
该字符串表示空值。默认为一个空字符串 ('')。可以将 null 值指定为 E'\000' 至 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 选项使用相同的字符。有关详细信息，请参阅分隔数据。

输入选项

以下选项可用于指定源数据：

LOCAL
在客户端系统上加载数据文件，而不是在群集主机上。LOCAL 可以限定 STDIN 和 path-to-data 参数。有关详细信息，请参阅COPY LOCAL。

限制： 对 CREATE EXTERNAL TABLE AS COPY

STDIN 无效
从客户端读取标准输入而非文件。STDIN 只接受一个输入源。要加载多个输入源，请使用 path-to-data。

用户必须具有表的 INSERT 权限以及架构的 USAGE 权限。

限制： 对 CREATE EXTERNAL TABLE AS COPY 无效

path-to-data
指定包含数据的文件的绝对路径，可来自多个输入源。

  • 如果文件存储在 HDFS 中，则 path-to-data webhdfs 是架构中的 URI，通常为 [[s]web]hdfs://[nameservice]/path。请参阅HDFS 文件系统。

  • 如果文件存储在 S3 存储桶中，则 path-to-data 是格式为 s3://bucket/path 的 URI。请参阅S3 对象存储。

  • 如果文件存储在 Google Cloud Storage 中，则 path-to-data 是格式为 gs://bucket/path 的 URI。请参阅Google Cloud Storage (GCS) 对象存储。

  • 如果文件存储在 Azure Blob 存储中，则 path-to-data 是格式为 azb://account/container/path 的 URI。请参阅Azure Blob 存储对象存储。

  • 如果文件位于本地 Linux 文件系统或 NFS 装载上，则 path-to-data 为本地绝对文件路径。

path-to-data 可以选择包含通配符以和多个文件匹配。文件必须可供本地客户端或 COPY 语句运行的主机访问。COPY 会跳过文件列表中的空文件。若文件列表包含目录，则会导致查询失败。请参阅指定加载数据的位置。在 Linux Manual Page for Glob (7) 中指定了通配符支持的模式，对于 ADO.net 平台，则通过 NET Directory.getFiles 方法指定。

可使用变量来构建 使用加载脚本 中描述的路径名。

如果 path-to-data 解析为本地文件系统上的存储位置，且调用 COPY 的用户为非超级用户，则将应用以下要求：

此外，如果用户具有权限但不是超级用户，并且从该存储位置调用 COPY，Vertica 会确保符号链接不会导致未经授权的访问。

PARTITION COLUMNS column[,...]
其值在目录结构中而不是在数据中指定的列。此选项在路径包含形式为 colname=value 的目录名称时有效，例如： 
/data/created=2016-01-01/*.dat
/data/created=2016-01-02/*.dat
/data/created=2016-01-03/*.dat

值通过目录名称的 value 部分进行解析。如果不能强制转换为列数据类型，该值将被拒绝。如果该值缺失，COPY 会将其加载为 null。

以下示例将这些日期与数据文件中的其他列一起加载到表列中：

=> CREATE EXTERNAL TABLE records
    (id int, name varchar(50), created date)
   AS COPY FROM 'webhdfs:///path/*/*'
   PARTITION COLUMNS created;

有关详细信息，请参阅分区文件路径。

ON nodename
指定要复制的数据所驻留的节点以及应解析加载文件的节点。如果忽略 nodename，输入文件的位置默认为启动程序节点。使用 nodename 从 COPY 启动程序节点以外的节点复制和解析加载文件。
ON (nodeset)
指定一组要在其上执行加载的节点。相同数据必须可供在所有指定节点上加载。nodeset 是括号中节点名称的逗号分隔列表。例如： 
=> COPY t FROM 'file1.txt' ON (v_vmart_node0001, v_vmart_node0002);

Vertica 将加载分摊到所有指定节点。如果同时指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 会改为选择单个节点来执行加载。

如果数据在所有节点上都可用，则通常会使用 ON ANY NODE，这是从 HDFS 和云对象存储加载所使用的默认值。但是，可以使用 ON nodeset 在并发加载之间手动平衡加载。

ON ANY NODE
指定要加载的源文件在所有节点上都可用，这样 COPY 可以打开文件并从群集的任一节点解析。对于 Eon 模式数据库，COPY 将使用与启动程序相同的子群集中的节点。

如果文件足够大，可以进行分摊，Vertica 会尝试在多个节点之间分摊加载。如果指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 将选择单个节点。

可使用通配符或 glob（如 *.dat）并结合 ON ANY NODE 子句加载多个输入文件。如果使用 glob，COPY 会将文件列表分配至所有群集节点并分散工作负载。

ON ANY NODE 对于 STDIN 和 LOCAL 无效。STDIN 只能使用客户端主机，LOCAL 表示客户端节点。

ON ANY NODE 是从 Linux 以外的所有路径（HDFS 和云对象存储）加载时使用的默认值。

ON EACH NODE
从每个节点的指定路径加载数据。当每个节点上的数据文件不同，且您想要加载所有这些文件时，请使用此选项。如果路径在所有节点上都无效，则 COPY 会加载有效路径并生成警告。如果路径是共享位置，则 COPY 仅在 ON ANY NODE 上加载一次。
compression
输入压缩类型，为以下之一：

  • UNCOMPRESSED（默认）

  • BZIP

  • GZIP

  • LZO

  • ZSTD

输入文件可以是任何格式。如果使用通配符，所有的限定输入文件必须是相同的格式。要加载不同的文件格式，则指定具体的格式类型。

以下要求和限制适用：

  • 使用串联的 BZIP 或 GZIP 文件时，确认所有的源文件在串联之前使用记录终止符终止。

  • 串联的 BZIP 和 GZIP 文件不支持 NATIVE（二进制）和 NATIVE VARCHAR 格式。

  • LZO 文件假定使用 lzop 进行压缩。Vertica 支持以下 lzop 实参：

    • --no-checksum / -F

    • --crc32

    • --adler32

    • --no-name / -n

    • --name / -N

    • --no-mode

    • --no-time

    • --fast

    • --best

    • 编号的压缩级别

  • BZIP、GZIP、ZSTD 和 LZO 压缩不能与 ORC 格式结合使用。

VERTICA
请参阅COPY FROM VERTICA。
[WITH] UDL-clause[...]
指定一个或多个用户定义的加载函数、一个源和（可选）一个或多个筛选器和一个解析器，如下所示： 
SOURCE source( [arg=value[,...] ]
[ FILTER filter( [arg=value[,...] ] ) ]...
[ PARSER parser( [arg=value[,...] ] ) ]

要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

处理选项

以下选项用于控制 COPY 如何处理不同的突发事件：

ABORT ON ERROR
指定如果有任何行被拒绝，则停止 COPY。语句将被回滚，并且不加载数据。
COLSIZES (integer[,...])
加载固定宽度数据时指定列宽。COPY 要求在使用 FIXEDWIDTH 解析器时指定 COLSIZES。COLSIZES 与整数列表必须与表列列表中所列出的列对应。有关详细信息，请参阅固定宽度格式数据。
ERROR TOLERANCE
指定加载数据时，COPY 在执行过程中独立处理每个源。如果单个源无效，则语句不会回滚。将跳过无效的源，并继续加载。

使用此参数可禁用分摊加载。

限制： 对 ORC 或 Parquet 数据无效

EXCEPTIONS
指定文件名或要写入异常的文件的绝对路径，如下所示： 
EXCEPTIONS 'path' [ ON nodename[,...]]

异常描述了每个被拒绝的行被拒绝的原因。每个异常描述了通过 REJECTED DATA 选项指定的文件中的相应记录。

文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。

要收集某个位置的所有异常，请使用 REJECTED DATA AS TABLE 子句，异常会自动列在表的 rejected_reason 列中。

ON nodename 子句将 nodename 上的现有异常文件移至同一节点上所示的 path。有关详细信息，请参阅保存加载异常 (EXCEPTIONS)。

如果将此参数与 COPY...ON ANY NODE 一起使用，则仍必须为异常文件指定单独的节点，如以下示例中所示：

EXCEPTIONS '/home/ex01.txt' on v_db_node0001,'/home/ex02.txt'
on v_db_node0002,'/home/ex03.txt' on v_db_node0003

如果 path 解析为存储位置，则以下权限适用于非超级用户：

REJECTED DATA
指定在何处写入加载失败的每一行。如果指定此参数，则将始终写入由于解析错误而失败的记录。仅当设置了配置参数 CopyFaultTolerantExpressions 时，才会写入由于转换过程中的错误而失败的记录。

此参数的语法为：

REJECTED DATA
{ 'path' [ ON nodename ] [,...] | AS TABLE reject-table }

Vertica 可以将被拒绝的数据写入指定路径或表：

  • 'path' [ON nodename]：将被拒绝的行数据复制到执行加载的节点上的指定路径。如果通过 ON nodename 进行限定，Vertica 会将 nodename 上现有的被拒绝的数据文件移至同一节点上的 path。

    path 的值可以是目录，也可以是文件前缀。如果存在多个加载源，会始终将 path 视为目录。如果不存在多个加载源，但 path 以 '/' 结尾，或者如果该名称的目录已经存在，则也会将其视为目录。否则，会将 path 视为文件前缀。

    文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。

    当将此参数与 LOCAL 结合使用时，输出将写入客户端。

  • AS TABLE reject-table：将被拒绝的行保存到 reject-table。

有关这两个选项的详细信息，请参阅处理杂乱的数据。

REJECTMAX integer
加载失败前可以拒绝的逻辑记录的最大数量。有关详细信息，请参阅处理杂乱的数据。

REJECTMAX 禁用分摊加载。

SKIP integer
要在加载文件中跳过的记录的数量。例如，可以使用 SKIP 选项来省略表头信息。

限制： 对 ORC 或 Parquet 数据无效

STREAM NAME
提供 COPY 加载流标识符。使用流名称有助于快速识别特定加载。您在加载语句中提供的 STREAM NAME 值将出现在系统表 LOAD_STREAMS 和 LOAD_SOURCES 的 STREAM_NAME 列中。

无效的流名称包含长度最多为 128 字节的字母数字字符或特殊字符组合。

例如：

=> COPY mytable FROM myfile 
   DELIMITER '|' STREAM NAME 'My stream name';
WITH parser
指定批量加载列式表时要使用的解析器，为以下之一：

默认情况下，COPY 在 UTF-8 格式下使用 DELIMITER 解析器，分隔文本输入数据。如果未直接指定 DELIMITER 解析器，则缺少特定解析器将表示使用默认设置。

要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

加载到 Flex 表时，必须使用兼容的解析器。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。

COPY LOCAL 不支持 NATIVE、NATIVE VARCHAR、ORC 和 PARQUET 解析器。

有关复杂数据类型支持的解析器，请参阅特定解析器的文档。

有关解析器的详细信息，请参阅数据加载中的数据格式。

NO COMMIT
防止 COPY 语句在完成复制数据时自动提交事务。此选项必须是最后一个 COPY 语句参数。

有关详细信息，请参阅使用事务暂存加载。

限制： 对 ORC 或 Parquet 数据无效，将被 CREATE EXTERNAL TABLE AS COPY 忽略

解析器特定选项

以下选项仅在使用特定解析器时适用。

DELIMITED 解析器

DELIMITER

表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。

默认值： 竖线 ('|')。

ENCLOSED [BY]

设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。

ESCAPE [AS]

设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。

COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：

  • ESCAPE [AS]

  • DELIMITER

  • ENCLOSED [BY]

  • RECORD TERMINATOR

  • All COLLECTION 选项

默认值： 反斜线 ('\')。

NO ESCAPE

消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。

RECORD TERMINATOR
指定表明数据文件记录结束的字面量字符字符串。有关使用此参数的更多信息，请参见 分隔数据。
TRAILING NULLCOLS
指定如果 Vertica 遇到的记录不具有足够数据来匹配表列列表中的列，COPY 将使用 NULL 值插入缺失的列。有关其他信息和示例，请参阅固定宽度格式数据。
COLLECTIONDELIMITER

对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 逗号 (',')。

COLLECTIONOPEN， COLLECTIONCLOSE

对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认值： 方括号（'[' 和 ']'）。

COLLECTIONNULLELEMENT

该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 'null'

COLLECTIONENCLOSE

对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。

没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认： 双引号（'"'）

FIXEDWIDTH 解析器

SKIP BYTES integer
要在记录中跳过的总字节数。
TRIM
截取从列中指定的字符数。此选项仅在加载固定宽度数据时可用。您可以在表级别设置列的 TRIM，或将其作为 COLUMN OPTION 参数的一部分。

5.8.2 - 限制

COPY 具有以下限制：

无效数据

COPY 认为以下数据无效：

  • 缺失列（输入行的列数少于接收表的列数）。

  • 多余列（输入行的列数多于接收表的列数）。

  • INTEGER 或 DATE/TIME 数据类型的空列。对于这些类型中的任何一种，如果某列是空的，则 COPY 将不会使用 CREATE TABLE 命令定义的默认值。但是，如果您在 COPY 语句中未提供列选项，则将使用默认值。

  • 某个数据类型的表示不正确。例如，尝试将非数字值加载到 INTEGER 列的操作是无效的。

约束违规

如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。

空行处理

若 COPY 在加载数据时遇到空行，则既不会插入也不会拒绝该行，但 COPY 将递增行记录编号。评估被拒绝的记录时，请考虑此行为。如果您要返回被拒绝记录的列表，而 COPY 在加载数据时遇到空行，则被拒绝记录的位置将不会递增 1，如以下示例中所示。

该示例首先将值加载到将第一列定义为 INT 的表中。请注意第 3、4 和 8 行中的错误：

=> \! cat -n /home/dbadmin/test.txt
     1 1|A|2
     2 2|B|4
     3 A|D|7
     4 A|E|7
     5
     6
     7 6|A|3
     8 B|A|3

空行（5 和 6）会将错误报告转移到第 8 行：

=> SELECT row_number, rejected_data, rejected_reason FROM test_bad;
 row_number | rejected_data | rejected_reason
------------+---------------+----------------------------------------------
          3 | A|D|7 | Invalid integer format 'A' for column 1 (c1)
          4 | A|E|7 | Invalid integer format 'A' for column 1 (c1)
          6 | B|A|3 | Invalid integer format 'B' for column 1 (c1)
(3 rows)

压缩文件错误

加载压缩文件时，如果文件似乎已损坏，则 COPY 可能会中止并报告错误。例如，读取头块失败时，可能发生此行为。

磁盘配额

表和架构可以设置磁盘配额。如果加载违反任一配额，操作将失败。有关详细信息，请参阅磁盘配额。

5.8.3 - 解析器

Vertica 支持多种解析器以加载不同类型的数据。如下所述，某些解析器仅用于 Flex 表。

5.8.3.1 - DELIMITED

使用 DELIMITED 解析器（默认）通过 COPY 加载分隔的文本数据。您可以指定分隔符、转义字符、如何处理空值以及其他参数。

DELIMITED 解析器支持读取标量类型的一维集合（数组或集）。

DELIMITED 解析器同时支持分摊加载和协作解析。

COPY 选项

以下选项特定于此解析器。有关其他适用选项，请参阅参数。

DELIMITER

表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。

默认值： 竖线 ('|')。

ENCLOSED [BY]

设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。

ESCAPE [AS]

设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。

COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：

  • ESCAPE [AS]

  • DELIMITER

  • ENCLOSED [BY]

  • RECORD TERMINATOR

  • All COLLECTION 选项

默认值： 反斜线 ('\')。

NO ESCAPE

消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。

RECORD TERMINATOR
指定表明数据文件记录结束的字面量字符字符串。有关使用此参数的更多信息，请参见 分隔数据。
TRAILING NULLCOLS
指定如果 Vertica 遇到的记录不具有足够数据来匹配表列列表中的列，COPY 将使用 NULL 值插入缺失的列。有关其他信息和示例，请参阅固定宽度格式数据。
COLLECTIONDELIMITER

对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 逗号 (',')。

COLLECTIONOPEN， COLLECTIONCLOSE

对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认值： 方括号（'[' 和 ']'）。

COLLECTIONNULLELEMENT

该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。

默认值： 'null'

COLLECTIONENCLOSE

对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。

没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。

默认： 双引号（'"'）

示例

以下示例显示了默认行为，其中分隔符为 '|'

=> CREATE TABLE employees (id INT, name VARCHAR(50), department VARCHAR(50));
CREATE TABLE

=> COPY employees FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|Physics
>> 17|Howard Wolowitz|Astronomy
>> \.

=> SELECT * FROM employees;
 id |      name       |  department
----+-----------------+--------------
 17 | Howard Wolowitz | Astrophysics
 42 | Sheldon Cooper  | Physics
(2 rows)

以下示例显示如何使用默认选项加载数组值。

=> CREATE TABLE researchers (id INT, name VARCHAR, grants ARRAY[VARCHAR], values ARRAY[INT]);
CREATE TABLE

=> COPY researchers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|[US-7376,DARPA-1567]|[65000,135000]
>> 17|Howard Wolowitz|[NASA-1683,NASA-7867,SPX-76]|[16700,85000,45000]
>> \.

=> SELECT * FROM researchers;
 id |      name       |               grants               |       values
----+-----------------+------------------------------------+---------------------
 17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
 42 | Sheldon Cooper  | ["US-7376","DARPA-1567"]           | [65000,135000]
(2 rows)

在以下示例中，集合括在大括号中并由句点分隔，且数组包含空值。

=> COPY researchers FROM STDIN COLLECTIONOPEN '{' COLLECTIONCLOSE '}' COLLECTIONDELIMITER '.';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 19|Leonard|{"us-1672".null."darpa-1963"}|{16200.null.16700}
>> \.

=> SELECT * FROM researchers;
 id |      name       |               grants               |       values
----+-----------------+------------------------------------+---------------------
 17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
 42 | Sheldon Cooper  | ["US-7376","DARPA-1567"]           | [65000,135000]
 19 | Leonard         | ["us-1672",null,"darpa-1963"]      | [16200,null,16700]
(3 rows)

5.8.3.2 - FAVROPARSER

解析来自 Avro 文件的数据。需要满足以下要求：

  • Avro 文件必须以 Avro 二进制序列化编码格式进行编码，如 Apache Avro 标准中所述。解析器还支持 Snappy 和 deflate 压缩。

  • FAVROPARSER 不支持包含单独架构文件的 Avro 文件。Avro 文件必须包含架构。

您可以使用强类型加载 Avro 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型进行加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。

加载到 Flex 表中时，Vertica 会将所有数据加载到 __raw__ (VMap) 列中，包括数据中的复杂类型。

此解析器不支持分摊加载或协作解析。

语法

FAVROPARSER ( [parameter=value[,...]] )

参数

flatten_maps
布尔值，是否平展所有 Avro 映射。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

flatten_arrays
布尔值，是否平展所有 Avro 数组。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：false

flatten_records
布尔值，是否平展所有 Avro 记录。键名必须通过嵌套层连接起来。该值为递归值，且会影响加载中的所有数据。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

reject_on_materialized_type_error

布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。

如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。

默认值：false

基元数据类型

FAVROPARSER 支持以下基元数据类型，包括复杂类型中的元素类型和字段值。

Avro 逻辑类型

FAVROPARSER 支持以下 Avro 逻辑类型。目标列必须使用支持逻辑类型的 Vertica 数据类型。当尝试使用无效的逻辑类型加载数据时，将忽略此逻辑类型并使用基础 Avro 类型。

Avro 复杂数据类型

Avro 格式支持某些复杂数据类型。加载到强类型列时，您可以使用 ROW 和 ARRAY 类型来表示这些类型。例如，Avro Record 和 Enums 为结构 (ROW)；请参阅 Avro 规范。

您可以使用 ARRAY[ROW] 来匹配 Avro 映射。必须将 ROW 字段命名为 key 和 value。这些是 Avro 格式用于数据中的字段的名称，解析器通过字段名称将数据与表列进行匹配。

当加载到 Flex 表或使用灵活的复杂类型时，此解析器会按如下方式处理 Avro 复杂类型：

Record

各字段的名称被用作虚拟列名称。如果 flatten_records 为 true，且存在几个嵌套级别，Vertica 将连接 record 名称以创建键名。

Map

每个 map 键的值被用作虚拟列名称。如果 flatten_maps 为 true，且存在几个嵌套级别，Vertica 将连接所有键名以创建键名。

Enum

Vertica 将 Avro Enum 视为 record，将 Enum 的名称作为键，将其值作为值。

Array

Vertica 将 Avro Array 视为键/值对。默认情况下，每个元素的索引作为键。在以下示例中，product_detail 是一个包含字段 product_category 的 Record，即一个 Array：

=> CREATE FLEX TABLE products;
CREATE TABLE

=> COPY products FROM :datafile WITH PARSER FAVROPARSER();
 Rows Loaded
-------------
           2
(1 row)

=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
                    maptostring
--------------------------------------------------------------------------------
 {
    "__name__": "Order",
    "customer_id": "111222",
    "order_details": {
        "0.__name__": "OrderDetail",
        "0.product_detail.__name__": "Product",
        "0.product_detail.price": "46.21",
        "0.product_detail.product_category": {
            "0": "electronics",
            "1": "printers",
            "2": "computers"
        },
        "0.product_detail.product_description": "hp printer X11ew description :\
P",
        "0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0004",
        "0.product_detail.product_id": "999012",
        "0.product_detail.product_map.one": "1.1",
        "0.product_detail.product_map.two": "1.1",
        "0.product_detail.product_name": "hp printer X11ew",
        "0.product_detail.product_status": "ONLY_FEW_LEFT",
        "0.quantity": "3",
        "0.total": "354.34"
    },
    "order_id": "2389646",
    "total": "132.43"
}
...

如果 flatten_arrays 为 true，且存在几个嵌套级别，Vertica 将连接索引以创建键名。

=> COPY products FROM :datafile WITH PARSER FAVROPARSER(flatten_arrays=true);
 Rows Loaded
-------------
           2
(1 row)

=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
                    maptostring
--------------------------------------------------------------------------------

 {
    "__name__": "Order",
    "customer_id": "111222",
    "order_details.0.__name__": "OrderDetail",
    "order_details.0.product_detail.__name__": "Product",
    "order_details.0.product_detail.price": "46.21",
    "order_details.0.product_detail.product_category.0": "electronics",
    "order_details.0.product_detail.product_category.1": "printers",
    "order_details.0.product_detail.product_category.2": "computers",
    "order_details.0.product_detail.product_description": "hp printer X11ew des\
cription :P",
    "order_details.0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0\
004",
    "order_details.0.product_detail.product_id": "999012",
    "order_details.0.product_detail.product_map.one": "1.1",
    "order_details.0.product_detail.product_map.two": "1.1",
    "order_details.0.product_detail.product_name": "hp printer X11ew",
    "order_details.0.product_detail.product_status": "ONLY_FEW_LEFT",
    "order_details.0.quantity": "3",
    "order_details.0.total": "354.34",
    "order_id": "2389646",
    "total": "132.43"
}
...

Union

Vertica 将 Avro Union 视为 Array。

示例

此示例演示了如何使用 favroparser 创建 Flex 表并将 Avro 数据加载到其中。加载数据后，您可以查询虚拟列：

=> CREATE FLEX TABLE avro_basic();
CREATE TABLE

=> COPY avro_basic FROM '/home/dbadmin/data/weather.avro' PARSER FAVROPARSER();
Rows Loaded
-------------
5
(1 row)

=> SELECT station, temp, time FROM avro_basic;
station | temp |     time
---------+------+---------------
mohali  | 0    | -619524000000
lucknow | 22   | -619506000000
norwich | -11  | -619484400000
ams     | 111  | -655531200000
baddi   | 78   | -655509600000
(5 rows)

有关详细信息，请参阅Avro 数据。

5.8.3.3 - FJSONPARSER

解析并加载 JSON 文件。此文件可能包含重复的 JSON 数据对象（包括嵌套映射）或 JSON 元素的外部列表。

加载到 Flex 表或混合表中时，解析器将 JSON 数据存储在单值 VMap 中。加载到混合表或列式表中时，解析器将数据直接加载到列名称与 JSON 源数据键相匹配的任何表列。

您可以使用强类型加载 JSON 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。

仅当指定了 record_terminator 时，FJSONPARSER 才支持 协作解析。它不支持分摊加载。

语法

FJSONPARSER ( [parameter=value[,...]] )

参数

flatten_maps
布尔值，是否将 JSON 数据中的子映射平展，以句点 (.) 分隔映射层级。此值会影响加载中的所有数据，包括嵌套映射。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：true

flatten_arrays
布尔值，是否将列表转换为带有整数键的子映射。列表被平展后，键名会像映射一样连接起来。默认不对列表进行平展。此值影响加载中的所有数据，包括嵌套列表。

此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。

默认值：false

reject_on_duplicate
布尔值，是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值：false

reject_on_empty_key
布尔值，是否拒绝包含的字段键不含值的任何行。

默认值：false

omit_empty_keys
布尔值，是否忽略数据中不含值的任何字段键。同一记录中的其他字段将加载。

默认值：false

record_terminator
设置后，将跳过所有无效的 JSON 记录，并继续解析下一个记录。必须统一终止记录。例如，如果您的输入文件包含通过换行符终止的 JSON 记录，请将此参数设置为 E'\n')。如果存在任何无效的 JSON 记录，则在下一个 record_terminator 之后继续解析。

即使数据不包含无效的记录，也可以指定显式记录终止符，这样可以提高协作解析和分摊加载的运行效率，从而提升加载性能。

如果忽略此参数，解析将在第一条无效 JSON 记录处结束。

reject_on_materialized_type_error

布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。

如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。

默认值：false

start_point
字符串，即 JSON 加载数据中用作解析起点的键的名称。解析器忽略 start_point 值之前的所有数据。将为文件中的每个对象加载该值。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。
start_point_occurrence
整数，您通过 start_point 指定的值的第 n 次出现。如果数据具有多个起始值，而且您知道要在其第几次出现时开始解析，请与 start_point 结合使用。

默认值： 1

suppress_nonalphanumeric_key_chars
布尔值，是否禁止显示 JSON 键值中的非字母数字字符。当此参数为 true 时，解析器将用下划线 (_) 替换这些字符。

默认值：false

key_separator
解析器在连接键名时要使用的字符。

默认： 句点 (.)

示例

以下示例使用默认参数从 STDIN 加载 JSON 数据：

=> CREATE TABLE people(age INT, name VARCHAR);
CREATE TABLE

=> COPY people FROM STDIN PARSER FJSONPARSER();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"age": 5, "name": "Tim"}
>>  {"age": 3}
>>  {"name": "Fred"}
>>  {"name": "Bob", "age": 10}
>> \.
=> SELECT * FROM people;
 age | name
-----+------
     | Fred
  10 | Bob
   5 | Tim
   3 |
(4 rows)

以下示例使用 reject_on_duplicate 参数拒绝重复值：

=> CREATE FLEX TABLE json_dupes();
CREATE TABLE

=> COPY json_dupes FROM stdin PARSER fjsonparser(reject_on_duplicate=true)
exceptions '/home/dbadmin/load_errors/json_e.out'
rejected data '/home/dbadmin/load_errors/json_r.out';

Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.

>> {"a":"1","a":"2","b":"3"}
>> \.

=>  \!cat /home/dbadmin/load_errors/json_e.out
COPY: Input record 1 has been rejected (Rejected by user-defined parser).
Please see /home/dbadmin/load_errors/json_r.out, record 1 for the rejected record.
COPY: Loaded 0 rows, rejected 1 rows.

以下示例将加载数组数据：

$ cat addrs.json
 {"number": 301, "street": "Grant", "attributes": [1, 2, 3, 4]}

=> CREATE EXTERNAL TABLE customers(number INT, street VARCHAR, attributes ARRAY[INT])
    AS COPY FROM 'addrs.json' PARSER fjsonparser();

=> SELECT number, street, attributes FROM customers;
 num | street| attributes
-----+-----------+---------------
301  | Grant | [1,2,3,4]
(1 row)

以下示例将加载一个灵活的复杂类型，同时拒绝嵌套记录中具有空键的行。请注意，虽然数据包含两家餐厅，但其中一家的键名是空字符串。此餐厅将被拒绝：

$ cat rest1.json
{
    "name" : "Bob's pizzeria",
    "cuisine" : "Italian",
    "location_city" : ["Cambridge", "Pittsburgh"],
    "menu" : [{"item" : "cheese pizza", "" : "$8.25"},
              {"item" : "spinach pizza", "price" : "$10.50"}]
}
{
    "name" : "Bakersfield Tacos",
    "cuisine" : "Mexican",
    "location_city" : ["Pittsburgh"],
    "menu" : [{"item" : "veggie taco", "price" : "$9.95"},
              {"item" : "steak taco", "price" : "$10.95"}]
}

=> CREATE TABLE rest (name VARCHAR, cuisine VARCHAR, location_city LONG VARBINARY, menu LONG VARBINARY);

=> COPY rest FROM '/data/rest1.json'
    PARSER fjsonparser(flatten_maps=false, reject_on_empty_key=true);
Rows Loaded
------------
       1
(1 row)

=> SELECT maptostring(location_city), maptostring(menu) FROM rest;
        maptostring        |                          maptostring
---------------------------+-------------------------------------------------------
 {
    "0": "Pittsburgh"
} | {
    "0": {
        "item": "veggie taco",
        "price": "$9.95"
    },
    "1": {
        "item": "steak taco",
        "price": "$10.95"
    }
}
(1 row)

要改为加载部分数据，请使用 omit_empty_keys 在加载其他所有内容时绕过缺失键：



=> COPY rest FROM '/data/rest1.json'
    PARSER fjsonparser(flatten_maps=false, omit_empty_keys=true);
 Rows Loaded
-------------
           2
(1 row)

=> SELECT maptostring(location_city), maptostring(menu) from rest;
                   maptostring                   |               maptostring
-------------------------------------------------+---------------------------------
 {
    "0": "Pittsburgh"
}                       | {
    "0": {
        "item": "veggie taco",
        "price": "$9.95"
    },
    "1": {
        "item": "steak taco",
        "price": "$10.95"
    }
}
 {
    "0": "Cambridge",
    "1": "Pittsburgh"
} | {
    "0": {
        "item": "cheese pizza"
    },
    "1": {
        "item": "spinach pizza",
        "price": "$10.50"
    }
}
(2 rows)

要改为使用强类型加载此数据，请在表中定义复杂类型：

=> CREATE EXTERNAL TABLE restaurants
  (name VARCHAR, cuisine VARCHAR,
   location_city ARRAY[VARCHAR(80)],
   menu ARRAY[ ROW(item VARCHAR(80), price FLOAT) ]
  )
 AS COPY FROM '/data/rest.json' PARSER fjsonparser();

=> SELECT * FROM restaurants;
       name        | cuisine |       location_city        |                    \
                menu
-------------------+---------+----------------------------+--------------------\
--------------------------------------------------------
 Bob's pizzeria    | Italian | ["Cambridge","Pittsburgh"] | [{"item":"cheese pi\
zza","price":0.0},{"item":"spinach pizza","price":0.0}]
 Bakersfield Tacos | Mexican | ["Pittsburgh"]             | [{"item":"veggie ta\
co","price":0.0},{"item":"steak taco","price":0.0}]
(2 rows)

有关其他示例，请参阅 JSON 数据。

5.8.3.4 - ORC

使用包含 COPY 语句的 ORC 子句以 ORC 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。

加载 ORC 数据时，必须考虑数据中的所有列；不能只选择某些列。

如果表定义包含基元类型的列，且这些列不存在于数据中，则解析器将使用 NULL 填充这些列。如果表定义包含复杂类型的列，则这些列必须存在于数据中。

此解析器不支持分摊加载或协作解析。

语法

ORC ( [ parameter=value[,...] ] )

参数

所有参数均为可选参数。

hive_partition_cols
以逗号分隔的列列表，这些列是数据中的分区列。
allow_no_match
是否接受包含的 glob 没有匹配文件的路径并在查询结果中报告 0 行。如果未设置此参数，当 FROM 子句中的路径与至少一个文件不匹配时，Vertica 将返回错误。

示例

ORC 子句不使用 PARSER 选项：

=> CREATE EXTERNAL TABLE orders (...)
   AS COPY FROM 's3://DataLake/orders.orc' ORC;

可以将映射列读取为行数组，如以下示例中所示：

=> CREATE EXTERNAL TABLE orders
 (orderkey INT,
  custkey INT,
  prods ARRAY[ROW(key VARCHAR(10), value DECIMAL(12,2))],
  orderdate DATE
 ) AS COPY FROM '...' ORC;

5.8.3.5 - PARQUET

使用包含 COPY 语句的 PARQUET 解析器以 Parquet 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。

默认情况下，Parquet 解析器使用强架构匹配，这意味着数据中的列必须与使用数据的表中的列完全匹配。您可以选择使用弱架构匹配。

加载 Parquet 数据时，Vertica 会缓存 Parquet 元数据以提升效率。此缓存使用本地 TEMP 存储，如果 TEMP 为远程存储，则不使用。请参阅 ParquetMetadataCacheSizeMB 配置参数来更改缓存的大小。

此解析器不支持分摊加载或协作解析。

语法

PARQUET ( [ parameter=value[,...] ] )

参数

所有参数均为可选参数。

hive_partition_cols
以逗号分隔的列列表，这些列是数据中的分区列。
allow_no_match
Boolean。是否接受包含的 glob 没有匹配文件的路径并在查询结果中报告 0 行。如果未设置此参数，当 FROM 子句中的路径与至少一个文件不匹配时，Vertica 将返回错误。
allow_long_varbinary_match_complex_type
Boolean。是否启用灵活的列类型（请参阅可变复杂类型）。如果为 true，Parquet 解析器将允许数据中的复杂类型与定义为 LONG VARBINARY 的表列匹配。如果为 false，Parquet 解析器将需要使用复杂类型的强类型。对于参数集，仍然可以使用强类型。如果您希望将使用灵活的列视为错误，请将此参数设置为 false。
do_soft_schema_match_by_name
Boolean。是否启用弱架构匹配 (true)，而不是使用基于表定义和 parquet 文件中的列顺序的严格匹配（false，默认值）。有关详细信息，请参阅弱架构匹配。
reject_on_materialized_type_error
布尔值，仅在 do_soft_schema_match_by_name 为 true 时适用。指定在使用弱架构匹配且无法将值从数据强制转换为目标列类型时要执行的操作。值为 true（默认值）表示拒绝行；值为 false 表示使用 NULL 作为值，或者截断（对于过长的字符串）。有关强制转换类型映射，请参阅类型强制转换表。

弱架构匹配

默认情况下，Parquet 解析器使用强架构匹配。这意味着必须按照与数据中相同的顺序加载 Parquet 数据中的所有列。但是，有时您只想提取某些列，或者您希望能够适应未来 Parquet 架构中的一些更改。

使用 do_soft_schema_match_by_name 参数启用弱架构匹配。此设置具有以下影响：

  • 数据中的列通过名称与表中的列匹配。名称必须完全匹配，但不区分大小写。

  • 在 Parquet 数据中存在但不属于表定义的列将被忽略。

  • 在表定义中存在但不属于 Parquet 数据的列将用 NULL 填充。解析器在 QUERY_EVENTS 中记录 UNMATCHED_TABLE_COLUMNS_PARQUETPARSER 事件。

  • 如果 Parquet 数据中存在多个不区分大小写的相同列名，解析器将使用最后一个。（当使用通过区分大小写的工具写入的数据时，可能会出现这种情况。）

  • 列类型不需要完全匹配，只要可以将 Parquet 文件中的数据类型强制转换为表使用的类型即可。如果无法强制转换某个类型，解析器会在 QUERY_EVENTS 中记录 TYPE_MISMATCH_COLUMNS_PARQUETPARSER 事件。如果 reject_on_materialized_type_error 为 true，解析器将拒绝行。如果为 false，解析器将使用 NULL，或者对于过长的字符串值，将截断该值。

  • 可以定义但不能查询使用复杂类型（基元类型的一维数组除外）的列。

数据类型

Parquet 解析器将 Parquet 数据类型映射到 Vertica 数据类型，如下所示。

以下逻辑类型不受支持：

  • EnumLogicalType
  • IntervalLogicalType
  • JSONLogicalType
  • BSONLogicalType
  • UnknownLogicalType

Parquet 解析器支持以下物理类型的映射：

类型强制转换和弱架构匹配支持以下映射。

Vertica 仅支持 3 级编码的数组，不支持 2 级编码的数组。

示例

PARQUET 子句不使用 PARSER 选项：

=> COPY sales FROM 's3://DataLake/sales.parquet' PARQUET;

在以下示例中，数据目录不包含文件：

=> CREATE EXTERNAL TABLE customers (...)
    AS COPY FROM 'webhdfs:///data/*.parquet' PARQUET;
=> SELECT COUNT(*) FROM customers;
ERROR 7869: No files match when expanding glob: [webhdfs:///data/*.parquet]

要读取零行而不是生成错误，请使用 allow_no_match 参数：

=> CREATE EXTERNAL TABLE customers (...)
    AS COPY FROM 'webhdfs:///data/*.parquet'
       PARQUET(allow_no_match='true');
=> SELECT COUNT(*) FROM customers;
 count
-------
     0
(1 row)

要允许将复杂类型（在此示例中为菜单）作为灵活的列类型进行读取，请使用 allow_long_varbinary_match_complex_type 参数：

=> CREATE EXTERNAL TABLE restaurants
    (name VARCHAR, cuisine VARCHAR, location_city ARRAY[VARCHAR], menu LONG VARBINARY)
    AS COPY FROM '/data/rest*.parquet'
    PARQUET(allow_long_varbinary_match_complex_type='True');

要仅读取餐厅数据中的某些列，请使用弱架构匹配：

=> CREATE EXTERNAL TABLE restaurants(name VARCHAR, cuisine VARCHAR)
    AS COPY FROM '/data/rest*.parquet'
    PARQUET(allow_long_varbinary_match_complex_type='True',
            do_soft_schema_match_by_name='True');

=> SELECT * from restaurant;
       name        | cuisine
-------------------+----------
 Bob's pizzeria    | Italian
 Bakersfield Tacos | Mexican
(2 rows)

5.8.3.6 - FCEFPARSER

解析 ArcSight 通用事件格式 (CEF) 日志文件。该解析器将值直接加载到列名称与源数据键相匹配的任何表列中。该解析器可将加载到 Flex 表中的数据存储在单个 VMap 中。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FAVROPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
单字符分隔符。

默认值： ' '

record_terminator
单字符记录终止符。

**默认 **** 值： **newline

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

reject_on_unescaped_delimiter
布尔值，指定是否拒绝包含非转义分隔符的行。CEF 标准不允许出现此类行。

默认值： false

示例

以下示例演示了为 CEF 数据创建 Flex 表的示例，该表包含两个实际列，eventId 和 priority。

  1. 创建 Flex 表 cefdata：

    => create flex table cefdata();
CREATE TABLE

  2. 使用 Flex 解析器 fcefparser 加载一些基本的 CEF 数据：

    => copy cefdata from stdin parser fcefparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> CEF:0|ArcSight|ArcSight|2.4.1|machine:20|New alert|High|
>> \.

  3. 使用 maptostring() 函数查看 cefdata Flex 表的内容：

    => select maptostring(__raw__) from cefdata;
                  maptostring
-------------------------------------------------------------
 {
   "deviceproduct" : "ArcSight",
   "devicevendor" : "ArcSight",
   "deviceversion" : "2.4.1",
   "name" : "New alert",
   "severity" : "High",
   "signatureid" : "machine:20",
   "version" : "0"
}


(1 row)

  4. 从 cefdata Flex 表中选择一些虚拟列：

    
= select deviceproduct, severity, deviceversion from cefdata;
 deviceproduct | severity | deviceversion
---------------+----------+---------------
 ArcSight      | High     | 2.4.1
(1 row)

    有关详细信息，请参阅 通用事件格式 (CEF) 数据

    另请参阅

5.8.3.7 - FCSVPARSER

解析 CSV 格式（逗号分隔值）的数据。使用此解析器将 CSV 数据加载至列式表、Flex 表和混合表中。所有数据均必须以 Unicode UTF-8 格式进行编码。fcsvparser 解析器支持 CSV 数据的 RFC 4180 标准和其他选项，以适应 CSV 文件格式定义的变化。无效记录被拒绝。有关数据格式的详细信息，请参阅处理非 UTF-8 输入。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FCSVPARSER ( [parameter='value'[,...]] )

参数

type
解析器的默认参数值，为以下字符串之一：

  • rfc4180

  • traditional

您在加载符合 RFC 4180 标准的数据（如 MS Excel 文件）时，无须使用 type 参数。请参阅加载 CSV 数据，以了解 RFC4180 的默认参数以及您可为传统 CSV 文件指定的其他选项。

默认值： RFC4180

delimiter
用于分隔 CSV 数据中的字段的单字符值。

默认值： ,（对于 rfc4180 和 traditional）

escape
用作转义字符的单字符值，用于按字面解释数据中的下一个字符。

默认值：

  • rfc4180： "

  • traditional： \\

enclosed_by
单字符值。使用 enclosed_by 包括一个与分隔符完全相同但应该按字面解释的值。例如，如果数据分隔符为逗号 (,)，则您要在数据 ("my name is jane, and his is jim") 中使用逗号。

默认值： "

record_terminator
用于指定记录末尾的单字符值。

默认值：

  • rfc4180： \n

  • traditional： \r\n

header
布尔值，指定是否使用第一行数据作为标题列。当 header=true（默认）且不存在标题时，fcsvparser 使用默认列标题。默认标题由 ucoln 组成，其中 n 为列偏移数，第一列为 0。您可以使用 header_names 参数指定自定义列标题名称，如下所述。

如果您指定 header=false，则 fcsvparser 会将输入的第一行解析为数据，而不是列标题。

默认值： true

header_names
列标题名称列表，由解析器的分隔符参数定义的字符分隔。使用此参数可以在没有标题行的 CSV 文件中指定标题名称，或覆盖 CSV 源中存在的列名称。要覆盖一个或多个现有列名，请指定要使用的标题名称。此参数覆盖数据中的任何标题行。
trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

omit_empty_keys
布尔值，指定解析器如何处理没有值的标头键。如果是 true，则不加载 header 行中的空值键。

默认值： false

reject_on_duplicate
布尔值，指定是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值：false

reject_on_empty_key
布尔值，指定是否拒绝包含的键不含值的任何行。

默认值：false

reject_on_materialized_type_error
布尔值，指定是否拒绝解析器无法强制转换为兼容数据类型的任何实体化列值。请参阅加载 CSV 数据。

默认值：false

示例

此示例展示了如何使用 fcsvparser 加载 Flex 表，构建视图，然后查询该视图。

  1. 为 CSV 数据创建 Flex 表：

    => CREATE FLEX TABLE rfc();
CREATE TABLE

  2. 使用 fcsvparser 加载来自 STDIN 的数据。指定不存在标题，然后按如下方式输入一些数据：

    => COPY rfc FROM stdin PARSER fcsvparser(header='false');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 10,10,20
>> 10,"10",30
>> 10,"20""5",90
>> \.

  3. 运行 compute_flextable_keys_and_build_view 函数，然后查询 rfc_view。请注意，默认的 enclosed_by 字符允许字段 ("20""5") 内出现转义字符 (")。因此，所得到的值得以正确解析。由于输入数据中不存在标题，函数为各列添加了 ucoln：

    => SELECT compute_flextable_keys_and_build_view('rfc');
                           compute_flextable_keys_and_build_view
--------------------------------------------------------------------------------------------
 Please see public.rfc_keys for updated keys
The view public.rfc_view is ready for querying
(1 row)

=> SELECT * FROM rfc_view;
 ucol0 | ucol1 | ucol2
-------+-------+-------
 10    | 10    | 20
 10    | 10    | 30
 10    | 20"5  | 90
(3 rows)

    有关使用此解析器其他参数的详细信息和示例，请参阅加载 CSV 数据。

另请参阅

5.8.3.8 - FDELIMITEDPAIRPARSER

解析分隔的数据文件。此解析器提供了解析器 fdelimitedparser 功能的一个子集。当您要加载的数据指定成对列名称且每行均有数据时，使用 fdelimitedpairparser。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FDELIMITEDPAIRPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
指定单字符分隔符。

默认值： ' '

record_terminator
指定单字符记录终止符。

默认值： 换行符

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

示例

以下示例演示了为简单分隔数据创建示例 Flex 表，该表包含两个实际列，分别为 eventId 和 priority。

  1. 创建一个表：

    => create flex table CEFData(eventId int default(eventId::int), priority int default(priority::int) );
CREATE TABLE

  2. 使用 fcefparser 将示例分隔的 Micro Focus ArcSight 日志文件加载到 CEFData 表中：

    => copy CEFData from '/home/release/kmm/flextables/sampleArcSight.txt' parser fdelimitedpairparser();
Rows Loaded | 200

  3. 加载示例数据文件后，使用 maptostring() 在 CEFData 的 __raw__ 列中显示虚拟列：

    => select maptostring(__raw__) from CEFData limit 1;                                                                                                                                                                                                                                        maptostring
-----------------------------------------------------------
   "agentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
   "agentzone" : "3083",
   "agt" : "265723237",
   "ahost" : "svsvm0176",
   "aid" : "3tGoHuD0BABCCMDVAeX21vg==",
   "art" : "1099267576901",
   "assetcriticality" : "0",
   "at" : "snort_db",
   "atz" : "America/Los_Angeles",
   "av" : "5.3.0.19524.0",
   "cat" : "attempted-recon",
   "categorybehavior" : "/Communicate/Query",
   "categorydevicegroup" : "/IDS/Network",
   "categoryobject" : "/Host",
   "categoryoutcome" : "/Attempt",
   "categorysignificance" : "/Recon",
   "categorytechnique" : "/Scan",
   "categorytupledescription" : "An IDS observed a scan of a host.",
   "cnt" : "1",
   "cs2" : "3",
   "destinationgeocountrycode" : "US",
   "destinationgeolocationinfo" : "Richardson",
   "destinationgeopostalcode" : "75082",
   "destinationgeoregioncode" : "TX",
   "destinationzone" : "3133",
   "device product" : "Snort",
   "device vendor" : "Snort",
   "device version" : "1.8",
   "deviceseverity" : "2",
   "dhost" : "198.198.121.200",
   "dlat" : "329913940429",
   "dlong" : "-966644973754",
   "dst" : "3334896072",
   "dtz" : "America/Los_Angeles",
   "dvchost" : "unknown:eth1",
   "end" : "1364676323451",
   "eventid" : "1219383333",
   "fdevice product" : "Snort",
   "fdevice vendor" : "Snort",
   "fdevice version" : "1.8",
   "fdtz" : "America/Los_Angeles",
   "fdvchost" : "unknown:eth1",
   "lblstring2label" : "sig_rev",
   "locality" : "0",
   "modelconfidence" : "0",
   "mrt" : "1364675789222",
   "name" : "ICMP PING NMAP",
   "oagentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
   "oagentzone" : "3083",
   "oagt" : "265723237",
   "oahost" : "svsvm0176",
   "oaid" : "3tGoHuD0BABCCMDVAeX21vg==",
   "oat" : "snort_db",
   "oatz" : "America/Los_Angeles",
   "oav" : "5.3.0.19524.0",
   "originator" : "0",
   "priority" : "8",
   "proto" : "ICMP",
   "relevance" : "10",
   "rt" : "1099267573000",
   "severity" : "8",
   "shost" : "198.198.104.10",
   "signature id" : "[1:469]",
   "slat" : "329913940429",
   "slong" : "-966644973754",
   "sourcegeocountrycode" : "US",
   "sourcegeolocationinfo" : "Richardson",
   "sourcegeopostalcode" : "75082",
   "sourcegeoregioncode" : "TX",
   "sourcezone" : "3133",
   "src" : "3334891530",
   "start" : "1364676323451",
   "type" : "0"
}

(1 row)

  4. 选择 eventID 和 priority 实际列以及两个虚拟列 atz 和 destinationgeoregioncode：

    
=>  select eventID, priority, atz, destinationgeoregioncode from CEFData limit 10;
  eventID   | priority |         atz         | destinationgeoregioncode
------------+----------+---------------------+--------------------------
 1218325417 |        5 | America/Los_Angeles |
 1219383333 |        8 | America/Los_Angeles | TX
 1219533691 |        9 | America/Los_Angeles | TX
 1220034458 |        5 | America/Los_Angeles | TX
 1220034578 |        9 | America/Los_Angeles |
 1220067119 |        5 | America/Los_Angeles | TX
 1220106960 |        5 | America/Los_Angeles | TX
 1220142122 |        5 | America/Los_Angeles | TX
 1220312009 |        5 | America/Los_Angeles | TX
 1220321355 |        5 | America/Los_Angeles | CA
(10 rows)

另请参阅

5.8.3.9 - FDELIMITEDPARSER

使用分隔符分隔值，从而解析数据。fdelimitedparser 加载分隔数据，将其存储在单值 VMap 中。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FDLIMITEDPARSER ( [parameter‑name='value'[,...]] )

参数

delimiter
单字符分隔符。

默认值： |

record_terminator
单字符记录终止符。

默认值： \n

trim
布尔值，指定是否从标题名和键值中去掉空格。

默认值： true

header
布尔值，指定存在标题列。如果您使用此参数但不存在标题，解析器使用 col### 为列命名。

默认值： true

omit_empty_keys
布尔值，指定解析器如何处理没有值的标头键。如果 omit_empty_keys=true，则不加载 header 行中的空值键。

默认值： false

reject_on_duplicate
布尔值，指定是忽略重复记录 (false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。

默认值： false

reject_on_empty_key
布尔值，指定是否拒绝包含的键不含值的任何行。

默认值： false

reject_on_materialized_type_error
布尔值，指定针对不能用解析器强制转换为兼容的数据类型的实体化列，是否拒绝该列中的任何行值。请参阅使用 Flex 表解析器。

默认值： false

treat_empty_val_as_null
布尔值，指定空字段变为 NULLs，而不是变为空字符串 ('')。

默认值： true

示例

  1. 为分隔数据创建 Flex 表：

    t=> CREATE FLEX TABLE delim_flex ();
CREATE TABLE

  2. 使用 fdelimitedparser 加载些来自 STDIN 的分隔数据，并指定逗号 (,) 列分隔符：

    => COPY delim_flex FROM STDIN parser fdelimitedparser (delimiter=',');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> deviceproduct, severity, deviceversion
>> ArcSight, High, 2.4.1
>> \.

您现在可以在 delim_flex Flex 表中查询虚拟列：

=> SELECT deviceproduct, severity, deviceversion from delim_flex;
 deviceproduct | severity | deviceversion
---------------+----------+---------------
 ArcSight      | High     | 2.4.1
(1 row)

另请参阅

5.8.3.10 - FREGEXPARSER

解析正则表达式，将各列与指定正则表达式组的内容相匹配。

该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。

语法

FREGEXPARSER ( pattern=[parameter‑name='value'[,...]] )

参数

pattern
指定要匹配的数据正则表达式。

默认值： 空字符串 ("")

use_jit
布尔值，指定在解析正则表达式时是否使用实时编译。

默认值：false

record_terminator
指定用于分隔输入记录的字符。

默认值： \n

logline_column
一个字符串，用于捕获包含与正则表达式相匹配的完整字符串的目标列。

默认值： 空字符串 ("")

示例

这些示例使用以下正则表达式，它们搜索包括 timestamp、date、thread_name 和 thread_id 字符串的信息。

此示例表达式加载任何 thread_id 十六进制值，无论其是否包含 0x 前缀 (<thread_id>(?:0x)?[0-9a-f]+)。

'^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

  1. 创建一个 Flex 表 (vlog)，以包含 Vertica 日志文件的结果。针对此示例，我们复制了一份目录 /home/dbadmin/data/vertica.log 中的日志文件：

    => create flex table vlog1();
CREATE TABLE

  2. 将 fregexparser 用于示例正则表达式，以加载日志文件中的数据。请务必在使用此处显示的此表达式之前移除任何行字符：

    =>  copy vlog1 from '/home/dbadmin/tempdat/KMvertica.log'
PARSER FREGEXPARSER(pattern=
    '^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
 (?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'

    

    
);

 Rows Loaded
-------------
       31049
(1 row)

  3. 成功加载数据后，将 MAPTOSTRING() 函数用于表的 __raw__ 列。查询返回的四行 (limt 4) 为使用 fregexparser 解析的 KMvertica.log 文件的正则表达式结果。输出将显示前面带或不带 0x 的 thread_id 值：

  4. => select maptostring(__raw__) from vlog1 limit 4; maptostring ------------------------------------------------------------------------------------- { "text" : " [Init] <INFO> Log /home/dbadmin/VMart/v_vmart_node0001_catalog/vertica.log opened; #2", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Processing command line: /opt/vertica/bin/vertica -D /home/dbadmin/VMart/v_vmart_node0001_catalog -C VMart -n v_vmart_node0001 -h 10.20.100.247 -p 5433 -P 4803 -Y ipv4", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Starting up Vertica Analytic Database v8.1.1-20170321", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Compiler Version: 4.8.2 20140120 (Red Hat 4.8.2-15)", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } (4 rows)

另请参阅

5.8.4 - 示例

有关其他 COPY 示例，请参阅特定解析器的参考页，包括：DELIMITED、ORC、PARQUET、FJSONPARSER 和 FAVROPARSER。

指定字符串选项

将 COPY 与 FORMAT、DELIMITER、NULL 和 ENCLOSED BY 选项结合使用：

=> COPY public.customer_dimension (customer_since FORMAT 'YYYY')
   FROM STDIN
   DELIMITER ','
   NULL AS 'null'
   ENCLOSED BY '"';

将 COPY 与 DELIMITER 和 NULL 选项结合使用。此示例设置并引用输入文件的 vsql 变量：

=> \set input_file ../myCopyFromLocal/large_table.gzip
=> COPY store.store_dimension
   FROM :input_file
   DELIMITER '|'
   NULL ''
   RECORD TERMINATOR E'\f';

包括多个源文件

创建一个表，然后将多个源文件复制到其中：

=> CREATE TABLE sampletab (a int);
CREATE TABLE

=> COPY sampletab FROM '/home/dbadmin/one.dat', 'home/dbadmin/two.dat';
 Rows Loaded
-------------
           2
(1 row)

使用通配符表示一组文件：

=> COPY myTable FROM 'webhdfs:///mydirectory/ofmanyfiles/*.dat';

通配符可以包含正则表达式：

=> COPY myTable FROM 'webhdfs:///mydirectory/*_[0-9]';

使用单个 COPY 语句指定多个路径：

=> COPY myTable FROM 'webhdfs:///data/sales/01/*.dat', 'webhdfs:///data/sales/02/*.dat',
    'webhdfs:///data/sales/historical.dat';

分布加载

加载所有节点共享的数据。如果可能，Vertica 会将加载操作分布到所有节点：

=> COPY sampletab FROM '/data/file.dat' ON ANY NODE;

从两个文件中加载数据。因为第一个加载文件未指定节点（或 ON ANY NODE），因此启动程序将执行加载操作。将加载第二个文件的操作分布到所有节点：

=> COPY sampletab FROM '/data/file1.dat', '/data/file2.dat' ON ANY NODE;

为每个加载文件指定不同的节点：

=> COPY sampletab FROM '/data/file1.dat' ON (v_vmart_node0001, v_vmart_node0002),
    '/data/file2.dat' ON (v_vmart_node0003, v_vmart_node0004);

从共享存储中加载数据

要从共享存储中加载数据，请使用相应架构中的 URL：

  • HDFS： [[s]web]hdfs://[nameservice]/path

  • S3： s3://bucket/path

  • Google Cloud： gs://bucket/path

  • Azure： azb://account/container/path

使用默认名称节点或名称服务加载存储在 HDFS 中的文件：

=> COPY t FROM 'webhdfs:///opt/data/file1.dat';

通过特定的 HDFS 名称服务 (testNS) 加载数据。如果数据库配置为从多个 HDFS 群集中读取，则可以指定一个名称服务：

=> COPY t FROM 'webhdfs://testNS/opt/data/file2.csv';

从 S3 存储桶中加载数据：

=> COPY t FROM 's3://AWS_DataLake/*' ORC;

分区数据

可以使用目录结构对数据文件进行分区，例如：

path/created=2016-11-01/region=northeast/*
path/created=2016-11-01/region=central/*
path/created=2016-11-01/region=southeast/*
path/created=2016-11-01/...
path/created=2016-11-02/region=northeast/*
path/created=2016-11-02/region=central/*
path/created=2016-11-02/region=southeast/*
path/created=2016-11-02/...
path/created=2016-11-03/...
path/...

使用 PARTITION COLUMNS 选项加载分区列：

=> CREATE EXTERNAL TABLE records (id int, name varchar(50), created date, region varchar(50))
   AS COPY FROM 'webhdfs:///path/*/*/*'
   PARTITION COLUMNS created, region;

使用填充内容列

在以下示例中，该表包含名字、姓氏和全名列，但正在加载的数据包含名字、中间名和姓氏列。COPY 语句读取所有源数据，但只加载名字和姓氏的源列。它通过连接每个源数据列（包括中间名）来构造全名数据。中间名被读取为 FILLER 列，因此可以在串联中使用，但在其他情况下会被忽略。（中间名没有表格列。）

=> CREATE TABLE names(first VARCHAR(20), last VARCHAR(20), full VARCHAR(60));
CREATE TABLE
=> COPY names(first,
              middle FILLER VARCHAR(20),
              last,
              full AS first||' '||middle||' '||last)
      FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Marc|Gregory|Smith
>> Sue|Lucia|Temp
>> Jon|Pete|Hamilton
>> \.
=> SELECT * from names;
 first |   last   |        full
-------+----------+--------------------
 Jon   | Hamilton | Jon Pete Hamilton
 Marc  | Smith    | Marc Gregory Smith
 Sue   | Temp     | Sue Lucia Temp
(3 rows)

将数据加载到 Flex 表中

创建一个 Flex 表并使用 FJSONPARSER 将 JSON 数据复制到其中：

=> CREATE FLEX TABLE darkdata();
CREATE TABLE
=> COPY tweets FROM '/myTest/Flexible/DATA/tweets_12.json' PARSER FJSONPARSER();
 Rows Loaded
-------------
          12
(1 row)

使用命名管道

COPY 支持遵循与给定文件系统上的文件名称相同的命名约定的命名管道。权限为 open、write 和 close。

创建命名管道 pipe1，并设置两个 vsql 变量：

=> \! mkfifo  pipe1
=> \set dir `pwd`/
=> \set file '''':dir'pipe1'''

从命名管道中复制一个未压缩的文件：

=> \! cat pf1.dat > pipe1 &
=> COPY large_tbl FROM :file delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;

加载压缩数据

从命名管道中复制一个 GZIP 文件并解压缩：

=> \! gzip pf1.dat
=> \! cat pf1.dat.gz > pipe1 &
=> COPY large_tbl FROM :file ON site01 GZIP delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;
=> \!gunzip pf1.dat.gz

5.9 - COPY LOCAL

将 COPY 语句与其 LOCAL 选项配合使用，可以在客户端系统而不是群集主机上加载数据文件。COPY LOCAL 支持 STDIN 和 'pathToData' 参数，但是不支持 [ON nodename] 子句。COPY LOCAL 不支持具有 NATIVE 或 NATIVE VARCHAR 格式的多个文件批量。COPY LOCAL 不支持读取 ORC 或 Parquet 文件；改用 ON NODE。COPY LOCAL 不支持 CURRENT_LOAD_SOURCE()。

COPY LOCAL 选项与平台无关。该语句在所有受支持的 Vertica 平台和驱动程序中的工作方式均相同。有关支持的驱动程序的更多详细信息，请参阅客户端驱动程序。

COPY LOCAL 必须是您使用 ODBC 客户端库进行的任何多语句查询中的第一条语句。将其用作第二个或以后的语句会导致错误。在使用其他客户端库（例如 JDBC）时，COPY LOCAL 应该始终是多语句查询中的第一条语句。另外，不要在同一个查询中多次使用它。

COPY LOCAL 即使发生异常，也不会自动创建异常和拒绝文件。

特权

用户必须具有表的 INSERT 权限以及架构的 USAGE 权限。

Copy Local 的工作原理

COPY LOCAL 通过平台中性的方式加载数据。COPY LOCAL 语句将本地客户端系统中的所有文件加载到 Vertica 主机（服务器会在其中处理文件）。您可以复制各种格式的文件：已解压缩、已压缩、固定宽度格式、bzip 或 gzip 格式或者指定为 bash glob。单个格式（例如全部为 bzip 或 gzip）的文件可以是以逗号分隔的输入文件列表。此外，还可以使用任何适用的 COPY 语句选项（只要数据格式支持该选项即可）。例如，可以定义特定的分隔符，或者定义如何处理 NULL 值等等。

有关使用 COPY LOCAL 选项加载数据的详细信息，请参阅 COPY 以查看语法描述，参阅指定加载数据的位置以查看详细示例。

Vertica 主机会根据需要解压缩并处理文件，无论文件格式如何或从中加载文件的客户端平台如何。一旦服务器拥有复制的文件，Vertica 就会通过跨节点分发文件解析任务（例如编码、压缩、解压缩）来保持性能。

在查询计划中查看 Copy Local 操作

在使用 COPY LOCAL 选项时，GraphViz 查询计划包括用于 Load-Client-File 而不是 Load-File 的标签。以下是查询计划示例中的一部分：

-----------------------------------------------
  PLAN:  BASE BULKLOAD PLAN  (GraphViz Format)
-----------------------------------------------
 digraph G {
 graph [rankdir=BT, label = " BASE BULKLOAD PLAN \nAll Nodes Vector:
 \n\n  node[0]=initiator (initiator) Up\n", labelloc=t, labeljust=l ordering=out]
.
.
.
10[label = "Load-Client-File(/tmp/diff) \nOutBlk=[UncTuple]",
color = "green", shape = "ellipse"];

示例

以下示例显示了从本地文件的加载过程。

$ cat > t.dat
12
17
9
^C

=> CREATE TABLE numbers (value INT);
CREATE TABLE

=> COPY numbers FROM LOCAL 't.dat';
 Rows Loaded
-------------
           3
(1 row)

=> SELECT * FROM numbers;
 value
-------
    12
    17
     9
(3 rows)

5.10 - COPY FROM VERTICA

从其他 Vertica 数据库导入数据。COPY FROM VERTICA 类似于 COPY，但仅支持后者的一部分参数。

语法

COPY [[database.]schema-name.]target-table
    [( target‑columns )]
    FROM VERTICA source‑database.[schema.]source‑table
    [( source‑columns )]
    [STREAM NAME 'stream name']
    [NO COMMIT]

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

目标表
所导入数据的目标表。Vertica 将数据从架构表加载到包含列的全部投影中。
target‑columns
target‑table 中列的逗号分隔列表，用于存储所复制的数据。请参阅下面的目标列和源列之间的映射。

您不能将 FILLER 列或复杂类型（原生数组除外）的列用作列定义的一部分。

source‑database
要导入的数据的源数据库。在启动复制操作之前，当前会话中必须已经存在与该数据库的连接；否则 Vertica 将返回错误。有关详细信息，请参阅 CONNECT TO VERTICA。
[schema.]source‑table
作为导入数据来源的表。如果 schema 是除 public 以外的任何其他架构，则必须提供架构名称。
source‑columns
源表中要导入的列的逗号分隔列表。如果省略，则导出所有列。列不能属于复杂类型。请参阅下面的目标列和源列之间的映射。
STREAM NAME
COPY 加载流标识符。使用流名称有助于快速识别特定加载。您在加载语句中指定的 STREAM NAME 值出现在 LOAD_STREAMS 系统表的 stream 列中。
NO COMMIT
防止 COPY 在完成复制数据时自动提交其事务。有关详细信息，请参阅使用事务暂存加载。

特权

  • 源表：选择

  • 源表架构： USAGE

  • 目标表： INSERT

  • 目标表架构： USAGE

目标列和源列之间的映射

将一个数据库中的所有表数据复制到另一个数据库时，如果两个表中的列定义都符合以下条件，COPY FROM VERTICA 可以不用指定列的列表：

  • 列数相同

  • 列名相同

  • 列序列相同

  • 列数据类型匹配或兼容

  • 没有复杂的数据类型（ARRAY、SET 或 ROW），原生数组除外

如果其中任何一个条件不成立，则 COPY FROM VERTICA 语句必须包含列的列表，这些列表将目标列和源列显式映射到彼此，如下所示：

  • 包含相同数量的列。

  • 按相同顺序列出源列和目标列。

  • 将具有相同（或兼容）数据类型的列配对。

执行 COPY 期间出现节点故障

请参阅处理复制/导出期间的节点故障。

示例

以下示例将整个表的内容从 vmart 数据库复制到当前数据库中具有相同定义的表中：

=> CONNECT TO VERTICA vmart USER dbadmin PASSWORD 'myPassword' ON 'VertTest01',5433;
CONNECT
=> COPY customer_dimension FROM  VERTICA vmart.customer_dimension;
 Rows Loaded
-------------
      500000
(1 row)
=> DISCONNECT vmart;
DISCONNECT

有关更多示例，请参阅从另一个 Vertica 数据库复制数据。

另请参阅

导出到 VERTICA

5.11 - CREATE 语句

CREATE 语句允许您创建新的数据库对象，例如表和用户。

5.11.1 - CREATE ACCESS POLICY

创建一个访问策略，筛选用户和角色对表数据的访问。您可以为表的行和列创建访问策略。Vertica 对每个查询应用访问策略筛选器，并仅返回当前用户或角色允许的数据。

您不能对原生数组以外的复杂数据类型的列设置访问策略。如果表包含复杂类型的列，您仍然可以对其他列设置行访问策略和列访问策略。

语法


CREATE ACCESS POLICY ON [[database.]schema.]table
    { FOR COLUMN column | FOR ROWS WHERE } expression [GRANT TRUSTED] { ENABLE | DISABLE }

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
包含目标列或行的表。
FOR COLUMN 列
应用此访问策略的列。该列可以是原生数组，但不支持其他复杂类型。（请参阅复杂类型。）
FOR ROWS WHERE
应用此访问策略的行。
表达式
指定访问行或列数据的条件的 SQL 表达式：

  • 行访问策略限制对表中特定行的访问，由策略的 WHERE 表达式指定。仅从表中提取满足此表达式的行。有关详细信息和示例用法，请参阅创建行访问策略。

  • 列访问策略限制对特定表列的访问。访问策略表达式还可以指定如何将列数据呈现给特定的用户和角色。有关详细信息和示例用法，请参阅创建列访问策略。

GRANT TRUSTED

指定 GRANT 语句在确定用户是否可以对目标表执行 DML 操作时优先于访问策略。如果省略，则只有在访问策略允许用户查看原始未更改状态的存储数据时，用户才能修改表数据。有关详细信息，请参阅访问策略和 DML 操作。

ENABLE | DISABLE
是否启用访问策略。您可以使用 ALTER ACCESS POLICY 启用和禁用现有的访问策略。

特权

非超级用户：表的所有权

限制

访问策略具有以下限制：

  • 一列只能有一个访问策略。

  • 不能为除原生数组以外的复杂类型列设置列访问策略。

  • 不能为　Flex 表中的实体化列设置列访问策略。可以为 __raw__ 列设置访问策略，但此举将限制对整个表的访问。

  • 行访问策略对临时表和具有聚合投影的表无效。

  • 访问策略表达式不能包含：

    • 子查询

    • 聚合函数

    • 分析函数

    • 用户定义的转换函数 (UDTF)

  • 如果查询优化器无法使用计算值替换仅涉及常量的确定性表达式，则会阻止所有 DML 操作，例如 INSERT。

另请参阅

5.11.2 - CREATE AUTHENTICATION

创建并启用与用户或角色关联的身份验证记录。身份验证记录在创建后自动启用。

语法

CREATE AUTHENTICATION auth‑record‑name
            METHOD 'auth‑method'
            access‑method
            [ FALLTHROUGH ]

参数

特权

DBADMIN

示例

请参阅创建身份验证记录。

另请参阅

5.11.3 - 创建 CA 捆绑包

创建证书颁发机构 (CA) 捆绑包。这些包含根 CA 证书。

语法

CREATE CA BUNDLE name [CERTIFICATES ca_cert[, ca_cert[, ...]]

参数

name
CA 捆绑包的名称。
ca_cert
CA 证书的名称。如果未指定证书，则捆绑包将为空。

特权

CA 捆绑包中 CA 证书的所有权。

示例

请参阅管理 CA 捆绑包。

另请参阅

5.11.4 - CREATE CERTIFICATE

创建或导入证书、证书颁发机构 (CA) 或中间 CA。这些证书可以与 ALTER TLS CONFIGURATION 一起使用来设置客户端-服务器 TLS、LDAPLink TLS、LDAPAuth TLS 和节点间 TLS。

CREATE CERTIFICATE 生成 x509v3 证书。

语法

CREATE [TEMP[ORARY]] [CA] CERTIFICATE certificate_name
    {AS cert [KEY key_name]
    | SUBJECT subject
      [ SIGNED BY ca_cert ]
      [ VALID FOR days ]
      [ EXTENSIONS ext = val[,...] ]
      [ KEY private_key ]}

参数

TEMPORARY
使用会话范围创建。密钥存储在内存中，仅对当前会话有效。
CA
将证书指定为 CA 或中间证书。如果省略，则该操作会创建一个普通证书。
certificate_name
证书的名称。
AS cert
导入的证书（字符串）。

此参数应包括整个证书链，不包括 CA 证书。

KEY key_name
密钥的名称。

只需为您打算在 Vertica 中签署其他证书的客户端/服务器证书和 CA 证书设置此参数。如果您导入的 CA 证书仅用于验证其他证书，则无需指定密钥。

SUBJECT subject
向（字符串）颁发证书的实体。
SIGNED BY ca_cert
签署证书的 CA 的名称。

添加 CA 证书时，该参数可选。指定该参数将创建一个不能用于签署其他 CA 证书的中间 CA。

创建证书时，此参数是必需的。

VALID FOR days
证书的有效天数。
EXTENSIONS ext = val
指定证书扩展的字符串。有关扩展的完整列表，请参阅 OpenSSL 文档。
KEY private_key
证书私钥的名称。

导入证书时，此参数是必需的。

特权

超级用户

默认扩展

CREATE CERTIFICATE 生成 x509v3 证书并默认包含多个扩展。这些因您创建的证书类型而异：

CA 证书：

  • 'basicConstraints' = 'critical, CA:true'

  • 'keyUsage' = 'critical, digitalSignature, keyCertSign'

  • 'nsComment' = Vertica generated [CA] certificate'

  • 'subjectKeyIdentifier' = 'hash'

证书：

  • 'basicConstraints' = 'CA:false'

  • 'keyUsage' = 'critical, digitalSignature, keyEncipherment'

示例

请参阅生成 TLS 证书和密钥。

另请参阅

5.11.5 - CREATE DIRECTED QUERY

保存输入查询与通过优化器提示注释的查询之间的关联。

语法

优化器生成

CREATE DIRECTED QUERY OPT[IMIZER] directedqueryID [COMMENT 'comments'] input-query

用户定义（自定义）

CREATE DIRECTED QUERY CUSTOM directedqueryID [COMMENT 'comments'] annotated-query

参数

OPT[IMIZER]
指示查询优化器通过 input-query 生成一个注释查询，然后在新的定向查询中将两者关联起来。
CUSTOM
指定将 annotated-query 与之前由 SAVE QUERY 指定的查询相关联。
directedqueryID
用于定向查询的唯一标识符，字符串 符合标识符中描述的约定。
COMMENT 'comments'
有关定向查询的注释，最多 128 个字符。注释可在以后作为非常有用的参考，例如说明为何创建指定的定向查询。

如果忽略此实参，Vertica 会插入以下注释之一：

  • 优化器生成的定向查询

  • 自定义定向查询

input-query
要与优化器生成的定向查询关联的输入查询。输入查询仅支持一个优化器提示 :v (alias IGNORECONST)。
annotated-query
具有嵌入式优化器提示的查询，与最近通过 SAVE QUERY 保存的输入查询关联。

特权

超级用户

描述

CREATE DIRECTED QUERY 将输入查询与使用优化器提示进行注释的查询相关联。它将此关联存储在一个唯一标识符下。CREATE DIRECTED QUERY 有两种变体：

  • CREATE DIRECTED QUERY OPTIMIZER 指示查询优化器从指定的输入查询生成带注释的 SQL。带注释的查询包含一些提示，优化器可使用这些提示为输入查询重新创建其当前查询计划。

  • CREATE DIRECTED QUERY CUSTOM 指定用户提供的带注释的查询。Vertica 将带注释的查询与最后一个 SAVE QUERY 语句指定的输入查询相关联。

在这两种情形中，Vertica 都会将带注释的查询与输入查询相关联，并将其关联注册在 query_name 下的系统表 DIRECTED_QUERIES 中。

另请参阅

创建定向查询

5.11.6 - CREATE EXTERNAL TABLE AS COPY

CREATE EXTERNAL TABLE AS COPY 为 Vertica 数据库外部的数据创建表定义。该语句是 CREATE TABLE 和 COPY 语句的组合，支持每个语句的部分参数。

取消 CREATE EXTERNAL TABLE AS COPY 语句会导致不可预测的结果。如果您需要进行更改，请让语句完成，删除表，然后重试。

可以使用 ALTER TABLE 更改列的数据类型，而不是删除并重新创建表。

您可以将 CREATE EXTERNAL TABLE AS COPY 用于除 Place 软件包中的类型以外的任何类型。

语法

CREATE EXTERNAL TABLE [ IF NOT EXISTS ] [[database.]schema.]table-name 
    ( column-definition[,...] )
[{INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES]
AS COPY
    [ ( { column-as-expression | column }
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FILLER datatype ]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
    [,...] ) ]
    [ COLUMN OPTION ( column 
       [ DELIMITER [ AS ] 'char' ]
       [ ENCLOSED [ BY ] 'char' ]
       [ ENFORCELENGTH ]
       [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
       [ FORMAT 'format' ]
       [ NULL [ AS ] 'string' ]
       [ TRIM 'byte' ]
    [,...] ) ]


FROM {
   { 'path-to-data'
       [ ON { nodename | (nodeset) | ANY NODE | EACH NODE } ] [ compression ] }[,...]
     [ PARTITION COLUMNS column[,...] ]
   | 
LOCAL 'path-to-data' [ compression ] [,...]
   | 
VERTICA source-database.[source-schema.]source-table[( source-column[,...] ) ]
  }
      [ NATIVE
        | FIXEDWIDTH COLSIZES {( integer )[,...]}
        | NATIVE VARCHAR
        | ORC
        | PARQUET
      ]
   [ ABORT ON ERROR ]
   [ DELIMITER [ AS ] 'char' ]
   [ ENCLOSED BY 'char' [ AND 'char' ] ]
   [ ENFORCELENGTH ]
   [ ERROR TOLERANCE ]
   [ ESCAPE AS 'char' | NO ESCAPE ]
   [ EXCEPTIONS 'path' [ ON nodename ] [,...] ]
   [ [ WITH ] FILTER filter( [ arg=value[,...] ] ) ]
   [ NULL [ AS ] 'string' ]
   [ [ WITH ] PARSER parser([arg=value [,...] ]) ]
   [ RECORD TERMINATOR 'string' ]
   [ REJECTED DATA 'path' [ ON nodename ] [,...] ]
   [ REJECTMAX integer ]
   [ SKIP integer ]
   [ SKIP BYTES integer ]
   [ TRAILING NULLCOLS ]
   [ TRIM 'byte' ]

参数

对于所有支持的参数，请参阅 CREATE TABLE 和 COPY 语句。有关将此语句与 UDL 配合使用的信息，请参阅用户定义的加载 (UDL)。

有关使用 COPY 参数的其他指导，请参阅指定加载数据的位置。

特权

具有以下权限的超级用户或非超级用户：

  • 有关用户可访问的存储位置的 READ 权限，请参阅 GRANT（存储位置）

  • 对用户有权创建的外部表的完整访问权限（包括 SELECT）

分区数据

可以使用其目录结构对数据进行分区，Vertica 可以利用该分区来提高外部表的查询性能。有关详细信息，请参阅分区文件路径。

如果在读取数据时看到意外结果，请验证文件路径中的 glob 是否与分区结构正确对齐。请参阅外部表故障排除。

ORC 和 Parquet 数据

使用 ORC 和 Parquet 格式时，Vertica 支持 COPY 语句和列数据结构中的一些附加选项。请参阅 ORC 和 PARQUET。

示例

以下示例为存储在 HDFS 中的分隔数据定义了一个外部表：

=> CREATE EXTERNAL TABLE sales (itemID INT, date DATE, price FLOAT)
    AS COPY FROM 'hdfs:///data/ext1.csv' DELIMITER ',';

以下示例使用存储在 S3 中的 ORC 格式的数据。数据有两个分区列。有关分区的详细信息，请参阅分区文件路径。

=> CREATE EXTERNAL TABLE records (id int, name varchar(50), created date, region varchar(50))
   AS COPY FROM 's3://datalake/sales/*/*/*'
   PARTITION COLUMNS created, region;

下面的示例演示了，如何才能从本地目录（没有分区和 glob）中的所有 Parquet 文件读取数据：

=> CREATE EXTERNAL TABLE sales (itemID INT, date DATE, price FLOAT)
    AS COPY FROM '/data/sales/*.parquet' PARQUET;

以下示例为包含数组的数据创建一个外部表：

=> CREATE EXTERNAL TABLE cust (cust_custkey int,
        cust_custname varchar(50),
        cust_custstaddress ARRAY[varchar(100)],
        cust_custaddressln2 ARRAY[varchar(100)],
        cust_custcity ARRAY[varchar(50)],
        cust_custstate ARRAY[char(2)],
        cust_custzip ARRAY[int],
        cust_email varchar(50), cust_phone varchar(30))
   AS COPY FROM 'webhdfs://data/*.parquet' PARQUET;

要允许没有超级用户访问权限的用户将外部表与本地文件系统、S3 或 GCS 上的数据配合使用，请为 'user' 使用创建一个位置，并授予对该位置的访问权限。本例显示了为一个名为 Bob 的用户授予对数据位于 /tmp（包含任何深度的子目录）之下的所有外部表的访问权限：

=> CREATE LOCATION '/tmp' ALL NODES USAGE 'user';
=> GRANT ALL ON LOCATION '/tmp' to Bob;

以下示例显示了使用用户定义源的 CREATE EXTERNAL TABLE：

=> CREATE SOURCE curl AS LANGUAGE 'C++' NAME 'CurlSourceFactory' LIBRARY curllib;
=> CREATE EXTERNAL TABLE curl_table1 as COPY SOURCE CurlSourceFactory;

另请参阅

创建外部表

5.11.7 - CREATE FAULT GROUP

仅限企业模式

创建容错组，其可包含以下内容：

  • 一个或多个节点

  • 一个或多个子容错组

  • 一个或多个节点以及一个或多个子容错组

CREATE FAULT GROUP 创建空的容错组。使用 ALTER FAULT GROUP 将节点或其他容错组添加到现有容错组。

语法

CREATE FAULT GROUP name

参数

name
要创建的容错组的名称，在所有容错组中唯一，其中 name 符合标识符中描述的约定。

特权

超级用户

示例

以下命令会创建名为 parent0 的容错组：

=> CREATE FAULT GROUP parent0;
CREATE FAULT GROUP

使用 ALTER FAULT GROUP 将节点或其他容错组添加到 parent0 容错组。

另请参阅

5.11.8 - CREATE FLEXIBLE TABLE

在逻辑架构中创建 flexible (Flex) 表。

创建 Flex 表时，Vertica 会自动创建两个依赖对象：

  • 名为 flex‑table‑name_keys 的键表

  • 名为 flex‑table‑name_view 的视图

Flex 表需要键表和视图。这些对象均不能独立于 Flex 表而存在。

语法

使用列定义创建：

CREATE [[ scope ] TEMP[ORARY]] FLEX[IBLE] TABLE [ IF NOT EXISTS ]
   [[database.]schema.]table-name
   ( [ column‑definition[,...] [, table-constraint ][,...] ] )
   [ ORDER BY column[,...] ]
   [ segmentation‑spec ]
   [ KSAFE [k‑num] ]
   [ partition-clause]
   [ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]
   [ DISK_QUOTA quota ]

从其他表创建：

CREATE FLEX[IBLE] TABLE [[database.]schema.] table-name
   [ ( column-name-list ) ]
   [ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]
   AS  query [ ENCODED BY column-ref-list ]
   [ DISK_QUOTA quota ]

参数

有关常规参数描述，请参阅 CREATE TABLE；对于特定于临时 Flex 表的参数，请参阅 CREATE TEMPORARY TABLE 和创建 Flex 表。

您无法在任何虚拟列（键）上对 Flex 表进行分区。

特权

非超级用户：表架构上的 CREATE 权限

默认列

CREATE 语句可以省略指定任何列定义。CREATE FLEXIBLE TABLE 总是自动创建两列：

__raw__
LONG VARBINARY 类型列，用于存储您加载的非结构化数据。默认情况下，此列具有 NOT NULL 约束。
__identity__
IDENTITY 列，用于在未定义其他列时进行分段和排序。

默认投影

在您创建 Flex 表和键表时，Vertica 会自动为它们创建 超投影。

如果通过一个或多个 ORDER BY、ENCODED BY、SEGMENTED BY 或 KSAFE 子句创建 Flex 表，则可使用该子句的信息创建投射。如果未使用任何子句，Vertica 将使用以下默认值：

示例

以下示例将创建一个名为 darkdata 的 Flex 表，而不指定任何列信息。Vertica 将在创建表的过程中创建默认的超投影和伙伴实例投影：

=> CREATE FLEXIBLE TABLE darkdata();
CREATE TABLE
=> \dj darkdata1*
                         List of projections
 Schema |         Name         |  Owner  |       Node       | Comment
--------+----------------------+---------+------------------+---------
 public | darkdata1_b0         | dbadmin |                  |
 public | darkdata1_b1         | dbadmin |                  |
 public | darkdata1_keys_super | dbadmin | v_vmart_node0001 |
 public | darkdata1_keys_super | dbadmin | v_vmart_node0002 |
 public | darkdata1_keys_super | dbadmin | v_vmart_node0003 |
(5 rows)

=> SELECT export_objects('','darkdata1_b0');
CREATE PROJECTION public.darkdata1_b0 /*+basename(darkdata1),createtype(P)*/
(
 __identity__,
 __raw__
)
AS
 SELECT darkdata1.__identity__,
        darkdata1.__raw__
 FROM public.darkdata1
 ORDER BY darkdata1.__identity__
SEGMENTED BY hash(darkdata1.__identity__) ALL NODES OFFSET 0;

SELECT MARK_DESIGN_KSAFE(1);
(1 row)

=> select export_objects('','darkdata1_keys_super');
CREATE PROJECTION public.darkdata1_keys_super /*+basename(darkdata1_keys),createtype(P)*/
(
 key_name,
 frequency,
 data_type_guess
)
AS
 SELECT darkdata1_keys.key_name,
        darkdata1_keys.frequency,
        darkdata1_keys.data_type_guess
 FROM public.darkdata1_keys
 ORDER BY darkdata1_keys.frequency
UNSEGMENTED ALL NODES;

SELECT MARK_DESIGN_KSAFE(1);
(1 row)

以下示例将以下面一个列定义创建名为 darkdata1 的表：date_col。该语句将 partition by 子句指定为按年为数据分区。Vertica 将在创建表的过程中创建默认的超投影和伙伴实例投影：

=> CREATE FLEX TABLE darkdata1 (date_col date NOT NULL) partition by
  extract('year' from date_col);
CREATE TABLE

另请参阅

5.11.9 - CREATE FLEXIBLE EXTERNAL TABLE AS COPY

CREATE FLEXIBLE EXTERNAL TABLE AS COPY 会创建灵活的外部表。此语句结合语句 CREATE FLEXIBLE TABLE 和 COPY 语句，支持每个语句的部分参数。

此外，还可以使用用户定义的加载函数 (UDL) 创建外部 Flex 表。有关创建和使用 Flex 表的详细信息，请参阅“使用 Flex 表”。

有关创建和使用 Flex 表的详细信息，请参阅“使用 Flex 表”中的创建 Flex 表。

语法

CREATE FLEX[IBLE] EXTERNAL TABLE [ IF NOT EXISTS ] [[database.]schema.]table-name
   ( [ column‑definition[,...] ] )
   [ INCLUDE | EXCLUDE [SCHEMA] PRIVILEGES ]
AS COPY [ ( { column-as-expression | column } [ FILLER datatype ] ]
   FROM {
      'path‑to‑data' [ ON nodename | ON ANY NODE | ON (nodeset) ] input‑format [,...]
      | [ WITH ] UDL-clause[...]
   }
   [ ABORT ON ERROR ]
   [ DELIMITER [ AS ] 'char' ]
   [ ENCLOSED [ BY ] 'char' ]
   [ ENFORCELENGTH ]
   [ ESCAPE [ AS ] 'char' | NO ESCAPE ]
   [ EXCEPTIONS 'path' [ ON nodename ] [,...] ]
   [ NULL [ AS ] 'string' ]
   [ RECORD TERMINATOR 'string' ]
   [ REJECTED DATA 'path' [ ON nodename ][,...] ]
   [ REJECTMAX integer ]
   [ SKIP integer ]
   [ SKIP BYTES integer ]
   [ TRAILING NULLCOLS ]
   [ TRIM 'byte' ]

参数

有关参数描述，请参阅 CREATE TABLE 和参数。

特权

具有以下权限的超级用户或非超级用户：

  • 有关用户可访问的存储位置的 READ 权限，请参阅 GRANT（存储位置）

  • 对用户有权创建的外部表的完整访问权限（包括 SELECT）

示例

要创建外部 Flex 表：

=> CREATE flex external table mountains() AS COPY FROM 'home/release/KData/kmm_ountains.json' PARSER fjsonparser();
CREATE TABLE

与其他 Flex 表一样，创建外部 Flex 表会生成两个常规表：命名表及其关联的 _keys 表。键表不是外部表：

=> \dt mountains
                 List of tables
 Schema |   Name    | Kind  |  Owner  | Comment
--------+-----------+-------+---------+---------
 public | mountains | table | release |
(1 row)

可以使用帮助程序函数 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 计算键并创建外部表视图：

=> SELECT compute_flextable_keys_and_build_view ('appLog');

                     compute_flextable_keys_and_build_view
--------------------------------------------------------------------------------------------------
Please see public.appLog_keys for updated keys
The view public.appLog_view is ready for querying
(1 row)

检查 _keys 表中的键，以获取帮助应用程序的运行结果：

=> SELECT * FROM appLog_keys;
                          key_name                       | frequency |   data_type_guess
----------------------------------------------------------+-----------+------------------
contributors                                             |         8 | varchar(20)
coordinates                                              |         8 | varchar(20)
created_at                                               |         8 | varchar(60)
entities.hashtags                                        |         8 | long varbinary(186)
.
.
.
retweeted_status.user.time_zone                          |         1 | varchar(20)
retweeted_status.user.url                                |         1 | varchar(68)
retweeted_status.user.utc_offset                         |         1 | varchar(20)
retweeted_status.user.verified                           |         1 | varchar(20)
(125 rows)

您可以查询视图：

=> SELECT "user.lang" FROM appLog_view;

 user.lang
-----------
it
en
es
en
en
es
tr
en
(12 rows)

另请参阅

5.11.10 - CREATE FUNCTION 语句

Vertica 为每种类型的用户定义的扩展提供 CREATE 语句。每个 CREATE 语句都会向 Vertica 编录添加一个用户定义的函数：

Vertica 还提供 CREATE FUNCTION (SQL)，它将 SQL 表达式存储为您可以在查询中调用的函数。

5.11.10.1 - CREATE AGGREGATE FUNCTION

向编录添加用户定义的聚合函数 (UDAF)。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE AGGREGATE FUNCTION 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载聚合函数。当您调用 SQL 函数时，Vertica 会将输入表传递给该函数进行处理。

语法

CREATE [ OR REPLACE ] AGGREGATE FUNCTION [ IF NOT EXISTS ]
  [[database.]schema.]function AS
  [ LANGUAGE 'language' ]
  NAME 'factory'
  LIBRARY library
  [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，目前仅 C++（默认）。
NAME 'factory'
生成函数实例的工厂类的名称。
LIBRARY library
包含函数的共享库的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。

默认值： FENCED

特权

非超级用户：

  • 函数架构的 CREATE 权限

  • 函数库的 USAGE 权限

示例

以下示例演示了加载名为 AggregateFunctions 的库，然后定义名为 ag_avg 和 ag_cat 的函数。这些函数映射到库中的 AverageFactory 和 ConcatenateFactory 类：

=> CREATE LIBRARY AggregateFunctions AS '/opt/vertica/sdk/examples/build/AggregateFunctions.so';
CREATE LIBRARY
=> CREATE AGGREGATE FUNCTION ag_avg AS LANGUAGE 'C++' NAME 'AverageFactory'
   library AggregateFunctions;
CREATE AGGREGATE FUNCTION
=> CREATE AGGREGATE FUNCTION ag_cat AS LANGUAGE 'C++' NAME 'ConcatenateFactory'
   library AggregateFunctions;
CREATE AGGREGATE FUNCTION
=> \x
Expanded display is on.
select * from user_functions;
-[ RECORD 1 ]----------+------------------------------------------------------------------
schema_name            | public
function_name          | ag_avg
procedure_type         | User Defined Aggregate
function_return_type   | Numeric
function_argument_type | Numeric
function_definition    | Class 'AverageFactory' in Library 'public.AggregateFunctions'
volatility             |
is_strict              | f
is_fenced              | f
comment                |
-[ RECORD 2 ]----------+------------------------------------------------------------------
schema_name            | public
function_name          | ag_cat
procedure_type         | User Defined Aggregate
function_return_type   | Varchar
function_argument_type | Varchar
function_definition    | Class 'ConcatenateFactory' in Library 'public.AggregateFunctions'
volatility             |
is_strict              | f
is_fenced              | f
comment                |

另请参阅

5.11.10.2 - CREATE ANALYTIC FUNCTION

向编录添加用户定义的分析函数 (UDAnF)。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE ANALYTIC FUNCTION 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载分析函数。当您调用 SQL 函数时，Vertica 会将输入表传递给库中的函数进行处理。

语法

CREATE [ OR REPLACE ] ANALYTIC FUNCTION [ IF NOT EXISTS ]
    [[database.]schema.]function AS
    [ LANGUAGE 'language' ]
    NAME 'factory'
    LIBRARY library
    [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++ （默认值）

  • Java

NAME 'factory'
生成函数实例的工厂类的名称。
LIBRARY library
包含函数的库的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。

默认值： FENCED

特权

非超级用户：

  • 函数架构的 CREATE 权限

  • 函数库的 USAGE 权限

示例

此示例基于 AnalyticFunctions 库中名为 RankFactory 的工厂类创建名为 an_rank 的分析函数：

=> CREATE ANALYTIC FUNCTION an_rank AS LANGUAGE 'C++'
   NAME 'RankFactory' LIBRARY AnalyticFunctions;

另请参阅

分析函数 (UDAnF)

5.11.10.3 - CREATE FILTER

向编录添加用户定义的加载筛选函数。包含筛选函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE FILTER 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载负载筛选函数。当您调用 SQL 函数时，Vertica 会将输入表传递给库中的函数进行处理。

语法

CREATE [ OR REPLACE ] FILTER [ IF NOT EXISTS ]
   [[database.]schema.]function AS
   [ LANGUAGE 'language' ]
   NAME 'factory' LIBRARY library
   [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++ （默认值）

  • Java

  • Python

NAME 'factory'
生成函数实例的工厂类的名称。 此名称与 RegisterFactory 类使用的名称相同。
LIBRARY library
C++ 库共享对象文件、Python 文件或 Java Jar 文件的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。

默认值： FENCED

特权

超级用户

示例

以下示例演示了如何加载名为 iConverterLib 的库，然后定义了名为 Iconverter 的筛选函数，该函数映射到库中的 iConverterFactory 工厂类：

=> CREATE LIBRARY iConverterLib as '/opt/vertica/sdk/examples/build/IconverterLib.so';
CREATE LIBRARY
=> CREATE FILTER Iconverter AS LANGUAGE 'C++' NAME 'IconverterFactory' LIBRARY IconverterLib;
CREATE FILTER FUNCTION
=> \x
Expanded display is on.
=> SELECT * FROM user_functions;
-[ RECORD 1 ]----------+--------------------
schema_name            | public
function_name          | Iconverter
procedure_type         | User Defined Filter
function_return_type   |
function_argument_type |
function_definition    |
volatility             |
is_strict              | f
is_fenced              | f
comment                |

另请参阅

5.11.10.4 - CREATE FUNCTION (SQL)

将 SQL 表达式存储为函数，以在查询中使用。用户定义的 SQL 函数对于执行复杂的查询和组合 Vertica 内置函数很有用。您只需在给定查询中调用该函数。如果搜索路径中存在多个具有相同名称和实参类型的 SQL 函数，Vertica 将调用它找到的第一个匹配项。

SQL 函数在所有情况下都被修整，包括 DDL。

语法

CREATE [ OR REPLACE ] FUNCTION [ IF NOT EXISTS ]
    [[database.]schema.]function( [ arg_list ] )
    RETURN return_type
    AS
    BEGIN
       RETURN expression;
    END;

参数

OR REPLACE
如果存在相同名称和实参的函数，请将其替换。如果您只更改函数实参，Vertica 会忽略此选项并使用相同的名称保留这两个函数。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要创建的 SQL 函数，其中 function 符合标识符中描述的约定。
arg_list
实参名称及其数据类型的逗号分隔列表，按以下格式指定： 
argname argtype[,...]

其中：

  • argname 为传递给 function 的实参的名称。

  • argtype 为 argname 的数据类型。

return_type
此函数返回的数据类型。
RETURN 表达式
SQL 函数主体，其中 expression 可能包含 CREATE FUNCTION 语句中指定的内置函数、运算符和实参名称。

表达式末尾的分号是必需的。

特权

非超级用户：

  • 函数架构的 CREATE 权限

  • 函数库的 USAGE 权限

严格性和可变性

Vertica 根据 SQL 函数的定义推断该函数的 严格性和可变性（ 稳定、 不可变或 易变）。然后，Vertica 确定使用是否正确，例如期待不可变函数却提供了易变函数的情况。

SQL 函数和视图

可以在使用 SQL 函数的查询中创建视图，然后查询这些视图。创建视图时，SQL 函数会将对用户定义的函数的调用替换为视图定义中的函数主体。因此，当用户定义的函数的主体被替换后，视图也应被替换。

示例

请参阅创建用户定义的 SQL 函数。

另请参阅

5.11.10.5 - CREATE FUNCTION（标量）

向编录添加用户定义的标量函数 (UDSF)。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

UDSF 接受单个数据行并返回单个值。只要可以使用原生 Vertica 函数或语句（CREATE TABLE 及其 PARTITION BY 或任何分段子句除外），便可以使用这些函数。

CREATE FUNCTION 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载 UDx。当您调用函数时，Vertica 会将参数传递给库中的函数进行处理。

语法

CREATE [ OR REPLACE ] FUNCTION [ IF NOT EXISTS ]
   [[database.]schema.]function AS
   [ LANGUAGE 'language' ]
   NAME 'factory'
   LIBRARY library
   [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++ （默认值）

  • Python

  • Java

  • R

NAME 'factory'
生成函数实例的工厂类的名称。
LIBRARY library
C++ 共享对象文件、Python 文件、Java Jar 文件或 R 函数文件的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。以 Java 编写的函数和 R 函数始终在隔离模式下运行。

默认值： FENCED

特权

  • 函数架构的 CREATE 权限

  • 函数库的 USAGE 权限

示例

以下示例加载了名为 ScalarFunctions 的库，然后定义了名为 Add2ints 的函数，该函数映射到库中的 Add2intsInfo 工厂类：

=> CREATE LIBRARY ScalarFunctions AS '/opt/vertica/sdk/examples/build/ScalarFunctions.so';
CREATE LIBRARY
=> CREATE FUNCTION Add2Ints AS LANGUAGE 'C++' NAME 'Add2IntsFactory' LIBRARY ScalarFunctions;
CREATE FUNCTION
=> \x
Expanded display is on.
=> SELECT * FROM USER_FUNCTIONS;

-[ RECORD 1 ]----------+----------------------------------------------------
schema_name            | public
function_name          | Add2Ints
procedure_type         | User Defined Function
function_return_type   | Integer
function_argument_type | Integer, Integer
function_definition    | Class 'Add2IntsFactory' in Library 'public.ScalarFunctions'
volatility             | volatile
is_strict              | f
is_fenced              | t
comment                |

=> \x
Expanded display is off.
=> -- Try a simple call to the function
=> SELECT Add2Ints(23,19);
 Add2Ints
----------
       42
(1 row)

以下示例使用了返回 ROW 的标量函数：

=> CREATE FUNCTION div_with_rem AS LANGUAGE 'C++' NAME 'DivFactory' LIBRARY ScalarFunctions;

=> SELECT div_with_rem(18,5);
        div_with_rem
------------------------------
 {"quotient":3,"remainder":3}
(1 row)

另请参阅

开发用户定义的扩展 (UDx)

5.11.10.6 - CREATE PARSER

向编录添加用户定义的加载解析器函数。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE PARSER 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载负载解析器函数。当您调用 SQL 函数时，Vertica 会将输入表传递给库中的函数进行处理。

语法

CREATE [ OR REPLACE ] PARSER [ IF NOT EXISTS ]
   [[database.]schema.]function AS
   [ LANGUAGE 'language' ]
   NAME 'factory'
   LIBRARY library
   [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++（默认）

  • Java

  • Python

NAME 'factory'
生成函数实例的工厂类的名称。 此名称与 RegisterFactory 类使用的名称相同。
LIBRARY library
C++ 库共享对象文件、Python 文件或 Java Jar 文件的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。

默认值： FENCED

特权

超级用户

示例

以下示例演示了如何加载名为 BasicIntegrerParserLib 的库，然后定义了名为 BasicIntegerParser 的解析器函数，该函数映射到库中的 BasicIntegerParserFactory 工厂类：

=> CREATE LIBRARY BasicIntegerParserLib as '/opt/vertica/sdk/examples/build/BasicIntegerParser.so';
CREATE LIBRARY
=> CREATE PARSER BasicIntegerParser AS LANGUAGE 'C++' NAME 'BasicIntegerParserFactory' LIBRARY BasicIntegerParserLib;
CREATE PARSER FUNCTION
=> \x
Expanded display is on.
=> SELECT * FROM user_functions;
-[ RECORD 1 ]----------+--------------------
schema_name            | public
function_name          | BasicIntegerParser
procedure_type         | User Defined Parser
function_return_type   |
function_argument_type |
function_definition    |
volatility             |
is_strict              | f
is_fenced              | f
comment                |

另请参阅

5.11.10.7 - CREATE SOURCE

向编录添加用户定义的负载源函数。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE SOURCE 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载负载源函数。当您调用 SQL 函数时，Vertica 会将输入表传递给库中的函数进行处理。

语法

CREATE [ OR REPLACE ] SOURCE [ IF NOT EXISTS ]
    [[database.]schema.]function AS
    [ LANGUAGE 'language' ]
    NAME 'factory'
    LIBRARY library
    [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++（默认）

  • Java

NAME 'factory'
生成函数实例的工厂类的名称。 此名称与 RegisterFactory 类使用的名称相同。
LIBRARY library
C++ 库共享对象文件或 Java Jar 文件的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。

默认： FENCED

特权

超级用户

示例

以下示例演示了如何加载名为 curllib 的库，然后定义了名为 curl 的源函数，该函数映射到库中的 CurlSourceFactory 工厂类：

=> CREATE LIBRARY curllib as '/opt/vertica/sdk/examples/build/cURLLib.so';
CREATE LIBRARY
=> CREATE SOURCE curl AS LANGUAGE 'C++' NAME 'CurlSourceFactory' LIBRARY curllib;
CREATE SOURCE
=> \x
Expanded display is on.
=> SELECT * FROM user_functions;
-[ RECORD 1 ]----------+--------------------
schema_name            | public
function_name          | curl
procedure_type         | User Defined Source
function_return_type   |
function_argument_type |
function_definition    |
volatility             |
is_strict              | f
is_fenced              | f
comment                |

另请参阅

5.11.10.8 - CREATE TRANSFORM FUNCTION

向编录添加用户定义的转换函数 (UDTF)。包含该函数的库必须先前已使用 CREATE LIBRARY 添加。

CREATE TRANSFORM FUNCTION 根据工厂类提供的数据自动确定函数参数和返回值。Vertica 支持重载转换函数。当您调用 SQL 函数时，Vertica 会将输入表传递给库中的转换函数进行处理。

语法

CREATE [ OR REPLACE ] TRANSFORM FUNCTION [ IF NOT EXISTS ]
    [[database.]schema.]function AS
    [ LANGUAGE 'language' ]
    NAME 'factory'
    LIBRARY library
    [ FENCED | NOT FENCED ]

参数

OR REPLACE

如果存在具有相同名称和实参的函数，则会替换它。例如，您可以使用它在围栏模式和非围栏模式之间进行切换。如果您不使用此指令并且该函数已存在，则 CREATE 语句将返回一个回退错误。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

IF NOT EXISTS

如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。

OR REPLACE 和 IF NOT EXISTS 是互斥的。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function

要创建的函数的名称。该名称用于函数的 SQL 调用。它不需要匹配工厂名称，但是如果这两个名称相同或相似，可以减少困惑。

函数名必须符合标识符的限制。

LANGUAGE 'language'
用于开发此函数的语言，为以下语言之一：

  • C++ （默认值）

  • Java

  • R

  • Python

NAME 'factory'
生成函数实例的工厂类的名称。
LIBRARY library
C++ 共享对象文件、Python 文件、Java Jar 文件或 R 函数文件的名称。此库必须已由 CREATE LIBRARY 加载。
FENCED | NOT FENCED
启用或禁用此函数的隔离模式。以 Java 编写的函数和 R 函数始终在隔离模式下运行。

默认值： FENCED

特权

非超级用户：

  • 函数架构的 CREATE 权限

  • 函数库的 USAGE 权限

限制

包括 UDTF 的查询不能：

示例

以下示例加载了名为 TransformFunctions 的库，然后定义了名为 tokenize 的函数，该函数映射到库中的 TokenFactory 工厂类：

=> CREATE LIBRARY TransformFunctions AS
   '/home/dbadmin/TransformFunctions.so';
CREATE LIBRARY
=> CREATE TRANSFORM FUNCTION tokenize
   AS LANGUAGE 'C++' NAME 'TokenFactory' LIBRARY TransformFunctions;
CREATE TRANSFORM FUNCTION

另请参阅

5.11.11 - CREATE HCATALOG SCHEMA

使用 HCatalog 连接器为存储在 Hive 数据仓库中的数据定义架构。有关详细信息，请参阅使用 HCatalog 连接器。

大多数可选参数均从 Hadoop 配置文件（如果可用）读出。如果按照为 HCatalog 配置 Vertica 中的描述复制了 Hadoop 配置文件，则可以忽略多数参数。默认情况下，此语句使用这些配置文件中指定的值。如果配置文件是完整的，则以下语句有效：

=> CREATE HCATALOG SCHEMA hcat;

如果配置文件中未指定值，并且参数列表中显示了默认值，则使用该默认值。

某些参数仅在您使用 HiveServer2（默认值）时适用。仅当您使用的是旧版 Hadoop 服务 WebHCat 时，其他选项才适用。使用 HiveServer2 时，使用 HIVESERVER2_HOSTNAME 指定服务器主机。使用 WebHCat 时，使用 WEBSERVICE_HOSTNAME 指定服务器主机。

如果需要使用 WebHCat，还必须将 HCatalogConnectorUseHiveServer2 配置参数设置为 0。请参阅Hadoop 参数。

创建架构后，您可以使用 ALTER HCATALOG SCHEMA 更改许多（但不是全部）参数。

语法

CREATE HCATALOG SCHEMA [IF NOT EXISTS] schemaName
    [AUTHORIZATION user-id]
    [WITH [param=value [,...] ] ]

参数

[IF NOT EXISTS]
如果给定默认值，则当 schemaName 中指定的架构已经存在时，该语句将无错退出。
schemaName
要在 Vertica 编录中创建的架构的名称。Hive 数据库中的表将通过此架构提供。
AUTHORIZATION user-id
要拥有正在创建的架构的 Vertica 帐户的名称。如果正在使用 Kerberos 身份验证，则此参数将被忽略；在这种情况下，使用当前的 vsql 用户。

参数

HOSTNAME
存储 Hive 数据仓库的元存储信息的数据库服务器的主机名、IP 地址或 URI。

如果您指定此参数且未同时指定 PORT，则此值必须采用 hive-site.xml 中用于 hive.metastore.uris 的 URI 格式。

如果 Hive 元存储支持高可用性，您可以为此值指定逗号分隔的 URI 列表。

如果未指定此值，则 hive-site.xml 必须可用。

PORT
运行 metastore 数据库的端口号。如果指定此参数，则还必须指定 HOSTNAME 并且它必须是名称或 IP 地址（不是 URI）。
HIVESERVER2_HOSTNAME
HiveServer2 服务的主机名或 IP 地址。如果在 hive-site.xml 中设置以下属性之一，则此参数可选：

  • 将 hive.server2.thrift.bind.host 设置为有效的主机

  • 将 hive.server2.support.dynamic.service.discovery 设置为 true

如果您使用 WebHCat，则忽略此参数。

WEBSERVICE_HOSTNAME
WebHCat 服务的主机名或 IP 地址（如果使用 WebHCat 而不是 HiveServer2）。如果未指定此值，则 webhcat-site.xml 必须可用。
WEBSERVICE_PORT
运行 WebHCat 服务的端口号（如果使用 WebHCat 而不是 HiveServer2）。如果未指定此值，则 webhcat-site.xml 必须可用。
WEBHDFS_ADDRESS
WebHDFS 服务的主机和端口（“主机:端口”）。此参数仅用于读取 ORC 和 Parquet 文件。如果未设置此值，则 hdfs-site.xml 必须可用，以通过 HCatalog 连接器读取这些文件类型。
HCATALOG_SCHEMA
Vertica 架构映射至的 Hive 架构或数据库的名称。默认值为 schemaName。
CUSTOM_PARTITIONS
Hive 架构是否使用自定义分区位置（'YES' 或 'NO'）。如果架构使用自定义分区位置，则 Vertica 会在执行查询时查询 Hive 以获取这些位置。这些额外的 Hive 查询可能很昂贵，因此仅在需要时才使用此参数。默认值为 'NO'（禁用）。有关详细信息，请参阅使用分区数据。
HCATALOG_USER
调用 HiveServer2 或 WebHCat 服务器时使用的 HCatalog 用户的用户名。默认为当前数据库用户。
HCATALOG_CONNECTION_TIMEOUT
HCatalog 连接器等待成功连接到 HiveServer 或 WebHCat 服务器的秒数。值 0 表示无限期等待。
HCATALOG_SLOW_TRANSFER_LIMIT
来自 HiveServer2 或 WebHCat 服务器且为 HCatalog 连接器所接受的最低数据传输率（以每秒字节数为单位）。有关详细信息，请参阅 HCATALOG_SLOW_TRANSFER_TIME。
HCATALOG_SLOW_TRANSFER_TIME
强制采用数据传输率下限之前 HCatalog 连接器等待的秒数。此时间过后，HCatalog 连接器将测试数据传输率是否至少达到了 HCATALOG_SLOW_TRANSFER_LIMIT 中设置的值。如果未达到，HCatalog 连接器会断开连接并终止查询。
SSL_CONFIG
Hadoop ssl-client.xml 配置文件的路径。如果您使用 HiveServer2 并且它使用 SSL 线路加密，则此参数是必需的。如果您使用 WebHCat，则忽略此参数。

HCATALOG_CONNECTOR_TIMEOUT、HCATALOG_SLOW_TRANSFER_LIMIT 和 HCATALOG_SLOW_TRANSFER_TIME 的默认值由数据库配置参数 HCatConnectionTimeout、HCatSlowTransferLimit 和 HCatSlowTransferTime 设置。有关详细信息，请参阅Hadoop 参数。

配置文件

如果您在创建架构时未覆盖这些值，HCatalog 连接器将使用 Hadoop 配置文件中的以下值。

特权

用户必须是超级用户或具有数据库的所有权限才能使用此语句。

用户还需要通过以下方式之一访问 Hive 数据：

  • 如果 Hive 不使用授权服务（Sentry 或 Ranger）来管理访问，则对 hcatalog_schema 具有 USAGE 权限。

  • 如果 Hive 使用授权服务来管理访问，则通过授权服务获得权限。在这种情况下，您必须将 EnableHCatImpersonation 设置为 0，以作为 Vertica 主体访问数据，或者授予用户访问 HDFS 数据的权限。对于 Sentry，您可以使用 ACL 同步来管理 HDFS 访问。

  • 成为 dbadmin 用户，无论有无授权服务均可访问。

示例

以下示例展示了如何使用 CREATE HCATALOG SCHEMA 为存储在 Hive 数据库中的表定义新架构，然后查询包含有关这些表的信息的系统表：

=> CREATE HCATALOG SCHEMA hcat WITH HOSTNAME='hcathost' PORT=9083
   HCATALOG_SCHEMA='default' HIVESERVER2_HOSTNAME='hs.example.com'
   SSL_CONFIG='/etc/hadoop/conf/ssl-client.xml' HCATALOG_USER='admin';
CREATE SCHEMA
=> \x
Expanded display is on.

=> SELECT * FROM v_catalog.hcatalog_schemata;
-[ RECORD 1 ]----------------+-------------------------------------------
schema_id                    | 45035996273748224
schema_name                  | hcat
schema_owner_id              | 45035996273704962
schema_owner                 | admin
create_time                  | 2017-12-05 14:43:03.353404-05
hostname                     | hcathost
port                         | -1
hiveserver2_hostname         | hs.example.com
webservice_hostname          |
webservice_port              | 50111
webhdfs_address              | hs.example.com:50070
hcatalog_schema_name         | default
ssl_config                   | /etc/hadoop/conf/ssl-client.xml
hcatalog_user_name           | admin
hcatalog_connection_timeout  | -1
hcatalog_slow_transfer_limit | -1
hcatalog_slow_transfer_time  | -1
custom_partitions            | f

=> SELECT * FROM v_catalog.hcatalog_table_list;
-[ RECORD 1 ]------+------------------
table_schema_id    | 45035996273748224
table_schema       | hcat
hcatalog_schema    | default
table_name         | nation
hcatalog_user_name | admin
-[ RECORD 2 ]------+------------------
table_schema_id    | 45035996273748224
table_schema       | hcat
hcatalog_schema    | default
table_name         | raw
hcatalog_user_name | admin
-[ RECORD 3 ]------+------------------
table_schema_id    | 45035996273748224
table_schema       | hcat
hcatalog_schema    | default
table_name         | raw_rcfile
hcatalog_user_name | admin
-[ RECORD 4 ]------+------------------
table_schema_id    | 45035996273748224
table_schema       | hcat
hcatalog_schema    | default
table_name         | raw_sequence
hcatalog_user_name | admin

以下示例展示了如何指定多个元存储主机。

=> CREATE HCATALOG SCHEMA hcat
   WITH HOSTNAME='thrift://node1.example.com:9083,thrift://node2.example.com:9083';

以下示例展示了如何包含自定义分区位置：

=> CREATE HCATALOG SCHEMA hcat WITH HCATALOG_SCHEMA='default'
    HIVESERVER2_HOSTNAME='hs.example.com'
    CUSTOM_PARTITIONS='yes';

5.11.12 - CREATE KEY

创建私钥。

语法

CREATE [TEMP[ORARY]] KEY name
       TYPE type
       [PASSWORD password]
       {LENGTH length | AS key}

参数

TEMPORARY
使用会话范围创建。密钥存储在内存中，仅对当前会话有效。
KEY name
密钥的名称。
TYPE type
密钥类型：“AES”或“RSA”。
PASSWORD password
密钥的密码（字符串）。
LENGTH length
密钥的大小（以位为单位）。

示例：2048

AS key
要导入的现有密钥字符串。例如： 
-----BEGIN RSA PRIVATE KEY-----...ABCD1234...-----END RSA PRIVATE KEY-----

特权

超级用户

示例

请参阅生成 TLS 证书和密钥。

另请参阅

5.11.13 - CREATE LIBRARY

将包含用户定义的扩展 (UDx) 的库加载到 Vertica 编录。Vertica 自动将库文件和支持库的副本分发到所有群集节点。

因为库被添加至数据库编录，因此数据库重新启动后也将如此。

在编录中加载库后，即可使用 CREATE FUNCTION 等语句定义该库中包含的扩展。有关详细信息，请参阅开发用户定义的扩展 (UDx)。

语法

CREATE [OR REPLACE] LIBRARY
    [[database.]schema.]name
    AS 'path'
    [ DEPENDS 'depends-path' ]
    [ LANGUAGE 'language' ]

参数

OR REPLACE
如果存在相同名称的库，请将其替换。编录中定义的引用更新库的 UDx 会自动开始使用新的库文件。

如果您不使用此指令并且库已经存在，则 CREATE 语句会返回错误。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

name
要创建的库的名称。这是在库中创建函数时使用的名称（请参阅创建 UDx 函数）。虽然不是必需的，但最好匹配文件名。
AS path
要加载的库的路径，可以是启动程序节点文件系统上的绝对路径，也可以是其他支持的文件系统或对象存储的 URI。
DEPENDS 'depends-path'

此库所依赖的文件或库，启动程序节点的文件系统或其他受支持的文件系统或对象存储中的一个或多个文件或目录。对于目录，路径条目以斜杠 (/) 结束，后跟通配符 (*)（可选）。要指定多个文件，请使用冒号 (:) 分隔条目。

如果任何路径条目包含冒号（例如 URI），请在整个 DEPENDS 路径两端加上括号，且单个路径元素使用双引号，如下例所示：

DEPENDS '["s3://mybucket/gson-2.3.1.jar"]'

要指定具有多个目录级别的库，请参阅多级库依赖项。

DEPENDS 对使用 R 编写的库没有影响。R 软件包必须本地安装在每个节点上，包括外部依赖项。

如果 Java 库依赖于本机库（SO 文件），请使用 DEPENDS 指定路径并调用 UDx 中的 System.loadLibrary() 以从该路径加载本机库。

LANGUAGE 'language'
库中函数的编程语言，下列之一：

  • C++ （默认值）

  • Python

  • Java

  • R

特权

超级用户，或者架构上的 UDXDEVELOPER 和 CREATE。非超级用户必须显式启用 UDXDEVELOPER 角色，如下例所示：

=> SET ROLE UDXDEVELOPER;
SET

-- Not required, but you can confirm the role as follows:
=> SHOW ENABLED ROLES;
     name      |   setting
---------------+--------------
 enabled roles | udxdeveloper
(1 row)

=> CREATE LIBRARY MyLib AS '/home/dbadmin/my_lib.so';
CREATE LIBRARY

-- Create functions...

-- UDXDEVELOPER also grants DROP (replace):
=> CREATE OR REPLACE LIBRARY MyLib AS '/home/dbadmin/my_lib.so';

要求

  • Vertica 会制作自己的库文件副本。后期修改或删除该语句中指定的原始文件不会影响编录中定义的库。要更新库，请使用 ALTER LIBRARY。

  • 加载库并不能保证该功能可以正常工作。CREATE LIBRARY 会对库文件执行一些基本检查，以验证库文件是否兼容 Vertica。如果语句检测到库未正确编译或发现了其他一些基本的不兼容性，则语句失败。但是，CREATE LIBRARY 无法检测到共享库中的许多其他问题。

如果 DEPENDS 子句指定具有多个目录级别的库，Vertica 将按照库路径包含该库的所有子目录。例如，以下 CREATE LIBRARY 语句使 UDx 库 mylib 能够导入它在 site‑packages 的子目录中找到的所有 Python 包和模块：

=> CREATE LIBRARY mylib AS '/path/to/python_udx' DEPENDS '/path/to/python/site-packages' LANGUAGE 'Python';

示例

在 dbadmin 帐户的主目录中加载库：

=> CREATE LIBRARY MyFunctions AS '/home/dbadmin/my_functions.so';

加载位于您启动 vsql 的目录中的库：

=> \set libfile '\''`pwd`'/MyOtherFunctions.so\'';
=> CREATE LIBRARY MyOtherFunctions AS :libfile;

从云端加载库：

=> CREATE LIBRARY SomeFunctions AS 'S3://mybucket/extensions.so';

加载依赖于同一目录中多个 JAR 文件的库：

=> CREATE LIBRARY DeleteVowelsLib AS '/home/dbadmin/JavaLib.jar'
   DEPENDS '/home/dbadmin/mylibs/*' LANGUAGE 'Java';

加载具有多个显式依赖项的库：

=> CREATE LIBRARY mylib AS '/path/to/java_udx'
   DEPENDS '/path/to/jars/this.jar:/path/to/jars/that.jar' LANGUAGE 'Java';

在云中加载具有依赖项的库：

=> CREATE LIBRARY s3lib AS 's3://mybucket/UdlLib.jar'
   DEPENDS '["s3://mybucket/gson-2.3.1.jar"]' LANGUAGE 'Java';

5.11.14 - CREATE LOAD BALANCE GROUP

创建可通过负载均衡路由规则定位的一组网络地址。您可以使用网络地址列表或基于一个或多个容错组或子群集创建组。

语法

CREATE LOAD BALANCE GROUP group_name WITH {
      ADDRESS address[,...]
    | FAULT GROUP  fault_group[,...] FILTER 'IP_range'
    | SUBCLUSTER subcluster[,...] FILTER 'IP_range'
    }
    [ POLICY 'policy_setting' ]

参数

group_name
要创建的组的名称。以后在定义负载均衡规则时使用此名称。
address[,...]
您之前创建的逗号分隔的网络地址列表。
fault_group[,...]
逗号分隔的容错组列表，用作负载均衡组的基础。
subcluster[,...]
逗号分隔的子群集列表，用作负载均衡组的基础。
IP_range
以 CIDR 表示法包含在来自容错组或子群集的负载均衡组中的 IP 地址范围。此范围可以是 IPv4 或 IPv6。只有网络地址的 IP 地址在此范围内的节点才会添加到负载均衡组中。
policy_setting
确定最初联系的节点如何从组中选择目标，为以下之一：

  • ROUNDROBIN（默认值）将在负载均衡组的可用成员之间轮转。最初联系的节点会跟踪它上次选择的节点，并选择群集中的下一个节点。

  • RANDOM 从组中随机选择一个可用节点。

  • NONE 禁用负载均衡。

特权

超级用户

示例

以下语句演示了创建一个包含多个网络地址的负载均衡组：

=> CREATE NETWORK ADDRESS addr01 ON v_vmart_node0001 WITH '10.20.110.21';
CREATE NETWORK ADDRESS
=> CREATE NETWORK ADDRESS addr02 ON v_vmart_node0002 WITH '10.20.110.22';
CREATE NETWORK ADDRESS
=> CREATE NETWORK ADDRESS addr03 on v_vmart_node0003 WITH '10.20.110.23';
CREATE NETWORK ADDRESS
=> CREATE NETWORK ADDRESS addr04 on v_vmart_node0004 WITH '10.20.110.24';
CREATE NETWORK ADDRESS
=> CREATE LOAD BALANCE GROUP group_1 WITH ADDRESS addr01, addr02;
CREATE LOAD BALANCE GROUP
=> CREATE LOAD BALANCE GROUP group_2 WITH ADDRESS addr03, addr04;
CREATE LOAD BALANCE GROUP

=> SELECT * FROM LOAD_BALANCE_GROUPS;
    name    |   policy   |     filter      |         type          | object_name
------------+------------+-----------------+-----------------------+-------------
 group_1    | ROUNDROBIN |                 | Network Address Group | addr01
 group_1    | ROUNDROBIN |                 | Network Address Group | addr02
 group_2    | ROUNDROBIN |                 | Network Address Group | addr03
 group_2    | ROUNDROBIN |                 | Network Address Group | addr04
(4 rows)

此示例演示使用容错组创建负载均衡组：

=> CREATE FAULT GROUP fault_1;
CREATE FAULT GROUP
=> ALTER FAULT GROUP fault_1 ADD NODE  v_vmart_node0001;
ALTER FAULT GROUP
=> ALTER FAULT GROUP fault_1 ADD NODE  v_vmart_node0002;
ALTER FAULT GROUP
=> ALTER FAULT GROUP fault_1 ADD NODE  v_vmart_node0003;
ALTER FAULT GROUP
=> ALTER FAULT GROUP fault_1 ADD NODE  v_vmart_node0004;
ALTER FAULT GROUP
=> SELECT node_name,node_address,node_address_family,export_address
   FROM v_catalog.nodes;
    node_name     | node_address | node_address_family | export_address
------------------+--------------+---------------------+----------------
 v_vmart_node0001 | 10.20.110.21 | ipv4                | 10.20.110.21
 v_vmart_node0002 | 10.20.110.22 | ipv4                | 10.20.110.22
 v_vmart_node0003 | 10.20.110.23 | ipv4                | 10.20.110.23
 v_vmart_node0004 | 10.20.110.24 | ipv4                | 10.20.110.24
(4 rows)

=> CREATE LOAD BALANCE GROUP group_all WITH FAULT GROUP fault_1 FILTER
   '0.0.0.0/0';
CREATE LOAD BALANCE GROUP

=> CREATE LOAD BALANCE GROUP group_some WITH FAULT GROUP fault_1 FILTER
   '10.20.110.21/30';
CREATE LOAD BALANCE GROUP

=> SELECT * FROM LOAD_BALANCE_GROUPS;
      name      |   policy   |     filter      |         type          | object_name
----------------+------------+-----------------+-----------------------+-------------
 group_all      | ROUNDROBIN | 0.0.0.0/0       | Fault Group           | fault_1
 group_some     | ROUNDROBIN | 10.20.110.21/30 | Fault Group           | fault_1
(2 rows)

另请参阅

5.11.15 - CREATE LOCAL TEMPORARY VIEW

创建或替换本地临时视图。视图是只读内容，所以不支持插入、更新、删除或复制操作。本地临时视图是会话范围的视图，因此仅在当前视图中供其创建者可见。会话结束时，Vertica 会删除视图。

语法

CREATE [OR REPLACE] LOCAL TEMP[ORARY] VIEW view [ (column[,...] ) ] AS query

参数

OR REPLACE
指定覆盖现有视图 view-name。如果您省略此选项并且 view-name 已经存在，则 CREATE VIEW 返回错误。
视图
标识要创建的视图，其中 view 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
列[,...]
由最多 9800 个用作视图列名称的名称组成的列表。Vertica 按照各自列表的顺序将视图列名称映射到查询列。默认情况下，视图使用在查询中指定的列名称。
AS query
临时视图执行的 SELECT 语句。SELECT 语句可以引用表、临时表以及其他视图。

特权

请参阅创建视图。

示例

以下 CREATE LOCAL TEMPORARY VIEW 语句将会创建临时视图 myview。此视图会将 store.store_sales_fact 表中所列的各个客户的所有收入相加，并按州对结果进行分组：

=> CREATE LOCAL TEMP VIEW myview AS
   SELECT SUM(annual_income), customer_state FROM public.customer_dimension
     WHERE customer_key IN (SELECT customer_key FROM store.store_sales_fact)
     GROUP BY customer_state
     ORDER BY customer_state ASC;

以下示例使用临时视图 myview，该视图具有 WHERE 子句，以将结果限制为大于 20 亿美元的合并收入：

=> SELECT * FROM myview WHERE SUM > 2000000000;


     SUM     | customer_state
-------------+----------------
  2723441590 | AZ
 29253817091 | CA
  4907216137 | CO
  3769455689 | CT
  3330524215 | FL
  4581840709 | IL
  3310667307 | IN
  2793284639 | MA
  5225333668 | MI
  2128169759 | NV
  2806150503 | PA
  2832710696 | TN
 14215397659 | TX
  2642551509 | UT
(14 rows)

另请参阅

5.11.16 - CREATE LOCATION

创建可供 Vertica 存储数据的存储位置。创建该位置后，可以在其中存储策略，以将该存储位置分配给将在此位置存储数据的数据库对象。

语法

CREATE LOCATION 'path'
    [NODE 'node' | ALL NODES]
    [SHARED]
    [USAGE 'usage']
    [LABEL 'label']
    [LIMIT 'size']

参数

路径
存储此位置数据的位置。位置所基于的文件系统类型决定了 path 格式：

HDFS 存储位置有其他要求。

ALL NODES | NODE 'node'
在其上定义存储位置的一个或多个节点，为以下之一：

  • ALL NODES （默认值）：在每个节点上创建存储位置。如果还指定了 SHARED，则创建一次存储位置以供所有节点使用。

  • NODE 'node'：在单个节点上创建存储位置，其中 node 是 NODES 系统表中节点的名称。您不能将此选项与 SHARED 一起使用。

SHARED
指示 path 设置的位置被共享（为所有节点使用），而非本地于每个节点。您不能使用 SHARED 指定单个节点；您必须使用 ALL NODES。

多数远程文件系统（例如 HDFS 和 S3）都被共享。对于这些文件系统，path 实参表示远程文件系统中所有节点存储数据的单个位置。如果使用远程文件系统，您必须指定 SHARED，即使对于单节点群集也是如此。

USAGE 'usage'
存储位置可以保存的数据类型，其中 usage 为以下之一：

  • DATA,TEMP （默认值）：存储位置可以存储 DML 生成的永久和临时数据，以及临时表的数据。

  • TEMP：path 指定的位置，用于存储 DML 生成的临时数据。如果 path 设置为 S3，则仅当 RemoteStorageForTemp 配置参数设置为 1 且 TEMP 必须使用 ALL NODES SHARED 加以限定。有关详细信息，请参阅临时数据的 S3 存储。

  • DATA：存储位置只能存储永久数据。

  • USER：具有 READ 和 WRITE 权限的用户可以访问此存储位置的数据和外部表。

  • DEPOT：该存储位置用于在 Eon 模式中存储存储库。仅在本地 Linux 文件系统上创建 DEPOT 存储位置。

    Vertica 允许每个节点有单个 DEPOT 存储位置。如果要将存储库移动到不同的位置（例如，在不同的文件系统上），您必须首先删除旧的存储库存储位置，然后创建新位置。

LABEL 'label'
存储位置的标签，在将存储位置分配给数据对象时使用。当以后在为数据对象分配存储位置时会使用此名称。
LIMIT 'size'

仅当存储位置使用类型设置为 DEPOT 时才有效，指定存储库可以从存储位置的文件系统中分配的最大磁盘空间量。

您可以通过两种方式指定 size：

  • integer%：存储位置的磁盘大小所占的百分比。

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的存储位置的磁盘大小。

如果未指定限制，则将其设置为 60%。

特权

超级用户

文件系统访问

Vertica 进程必须对要存储数据的位置具有读写权限。每个文件系统都有自己的要求：

示例

在本地 Linux 文件系统中创建一个存储位置，用于临时数据存储：

=> CREATE LOCATION '/home/dbadmin/testloc' USAGE 'TEMP' LABEL 'tempfiles';

在 HDFS 上创建存储位置。HDFS 群集不使用 Kerberos：

=> CREATE LOCATION 'hdfs://hadoopNS/vertica/colddata' ALL NODES SHARED
   USAGE 'data' LABEL 'coldstorage';

在使用 Kerberos 的 Hadoop 群集上创建相同的存储位置。请注意报告正在使用的主体的输出：

=> CREATE LOCATION 'hdfs://hadoopNS/vertica/colddata' ALL NODES SHARED
   USAGE 'data' LABEL 'coldstorage';
NOTICE 0: Performing HDFS operations using kerberos principal [vertica/hadoop.example.com]
CREATE LOCATION

为用户数据创建一个位置，授予对这些数据的访问权限以及使用这些数据创建外部表：

=> CREATE LOCATION '/tmp' ALL NODES USAGE 'user';
CREATE LOCATION
=> GRANT ALL ON LOCATION '/tmp' to Bob;
GRANT PRIVILEGE
=> CREATE EXTERNAL TABLE ext1 (x integer) AS COPY FROM '/tmp/data/ext1.dat' DELIMITER ',';
CREATE TABLE

在 S3 上创建用户存储位置和角色，以便没有自己的 S3 凭据的用户可以使用服务器凭据从 S3 读取数据：

   --- set database-level credential (once):
=> ALTER DATABASE DEFAULT SET AWSAuth = 'myaccesskeyid123456:mysecretaccesskey123456789012345678901234';

=> CREATE LOCATION 's3://datalake' SHARED USAGE 'USER' LABEL 's3user';

=> CREATE ROLE ExtUsers;
   --- Assign users to this role using GRANT (Role).

=> GRANT READ ON LOCATION 's3://datalake' TO ExtUsers;

另请参阅

5.11.17 - CREATE NETWORK ADDRESS

创建可用作连接负载均衡策略一部分的网络地址。网络地址会在 Vertica 编录中为与节点关联的 IP 地址和端口号创建名称。节点可以有多个网络地址，网络上的每个 IP 地址最多一个。

语法

CREATE NETWORK ADDRESS name ON node WITH 'ip-address' [PORT port-number] [ENABLED | DISABLED]

参数

name
新网络地址的名称。创建连接负载均衡组时使用此名称。
节点
要在其上创建网络地址的节点的名称。这应该是出现在系统表 NODES 的 node_name 列中的节点的名称。
ip-address
节点上要与网络地址关联的 IPv4 或 IPv6 地址。
PORT port-number
设置网络地址的端口号。更改端口号时必须提供网络地址。
ENABLED | DISABLED
启用或禁用网络地址。

特权

超级用户

示例

创建三个网络地址，一个用于三节点群集中的每个节点：

=> SELECT node_name,export_address from v_catalog.nodes;
      node_name      | export_address
---------------------+----------------
 v_vmart_br_node0001 | 10.20.100.62
 v_vmart_br_node0002 | 10.20.100.63
 v_vmart_br_node0003 | 10.20.100.64
(3 rows)

=> CREATE NETWORK ADDRESS node01 ON v_vmart_br_node0001 WITH '10.20.100.62';
CREATE NETWORK ADDRESS
=> CREATE NETWORK ADDRESS node02 ON v_vmart_br_node0002 WITH '10.20.100.63';
CREATE NETWORK ADDRESS
=> CREATE NETWORK ADDRESS node03 ON v_vmart_br_node0003 WITH '10.20.100.64';

另请参阅

5.11.18 - CREATE NETWORK INTERFACE

标识节点所属的网络接口。

当您要配置从单个节点到其他 Vertica 群集的导入/导出操作时，请使用此语句。默认情况下，安装 Vertica 时，它会为所有连接的网络创建接口。只有在安装 Vertica 后网络拓扑发生变化的情况下，您才需要 CREATE NETWORK INTERFACE。

语法

CREATE NETWORK INTERFACE network‑interface‑name ON node‑name [WITH] 'node‑IP‑address' [PORT port-number] [ENABLED | DISABLED]
network‑interface‑name
分配给网络接口的名称，其中 network-interface-name 符合标识符中描述的约定。
node‑name
节点的名称。
node‑IP‑address
节点的 IP 地址，公共或私有 IP 地址。有关详细信息，请参阅使用公共和专用 IP 网络。
PORT port-number
设置网络接口的端口号。更改端口号时必须提供网络接口。
[ENABLED | DISABLED]
启用或禁用网络接口。

特权

超级用户

示例

创建网络接口：

=> CREATE NETWORK INTERFACE mynetwork ON v_vmart_node0001 WITH '123.4.5.6' PORT 456 ENABLED;

5.11.19 - CREATE NOTIFIER

创建基于推送的通知程序，以从 Vertica 发送事件通知和消息。

语法

CREATE NOTIFIER [ IF NOT EXISTS ] notifier‑name ACTION 'notifier‑type'
    [ ENABLE | DISABLE ]
    [ MAXPAYLOAD 'max‑payload‑size' ]
    MAXMEMORYSIZE 'max‑memory‑size'
    [ TLSMODE 'tls‑mode' ]
    [ CA BUNDLE bundle‑name [ CERTIFICATE certificate‑name ] ]
    [ IDENTIFIED BY 'uuid' ]
    [ [NO] CHECK COMMITTED ]
    [ PARAMETERS 'adapter‑params' ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

notifier‑name
此通知程序的唯一标识符。
ACTION 'notifier‑type'
字符串，通知程序的类型，为以下之一：

  • URL，具有以下格式，用于标识一个或多个目标 Kafka 服务器：

    kafka://kafka-server-ip-address:port-number

    要在 Kafka 服务器不可用时启用故障转移，请在逗号分隔的列表中指定其他主机。例如：

    kafka://192.0.2.0:9092,192.0.2.1:9092,192.0.2.2:9092

  • syslog：通知会发送到 syslog。要使用这种类型的通知程序，您必须设置 SyslogEnabled 参数：

    => ALTER DATABASE DEFAULT SET SyslogEnabled = 1

    此通知程序类型监视的事件不会记录到 MONITORING_EVENTS 或 vertica.log。

ENABLE | DISABLE
指定启用还是禁用通知程序。

默认值： ENABLE。

MAXPAYLOAD
消息的最大大小，最多 10^9 字节，以 KB 或 MB 为单位指定，如下所示： 
MAXPAYLOAD integer{K|M}

存在以下限制：

  • MAXPAYLOAD 不能大于 MAXMEMORYSIZE。

  • 如果您将 syslog 配置为将消息发送到远程目标，请确保 MaxMessageSize (in /etc/rsyslog for rsyslog) 大于或等于 MAXPAYLOAD。

默认值：

  • Kafka：1M

  • syslog：1M

MAXMEMORYSIZE
内部通知程序的最大大小，最大为 2 TB，以 KB、MB、GB 或 TB 为单位指定，如下所示： 
MAXMEMORYSIZE integer{K|M|G|T}

MAXMEMORYSIZE 必须大于 MAXPAYLOAD。

如果消息队列的大小超过 MAXMEMORYSIZE，通知程序将删除多余的消息。

TLSMODE 'tls‑mode'

指定通知程序和端点之间的连接类型，可以是以下类型之一：

  • disable （默认值）：明文连接。

  • verify-ca：加密连接，且服务器的证书已经验证为由受信任的 CA 签名。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

CA BUNDLE bundle‑name

指定 CA 捆绑包。如果 TLSMODE 需要，捆绑包中的证书可用于验证 Kafka 服务器的证书。

如果为当前使用 disable 的通知程序指定了 CA 捆绑包，而不会验证 Kafka 服务器的证书，则在连接到 Kafka 服务器时，将不使用该捆绑包。除非将 TLSMODE 更改为验证服务器证书行为，否则此行为会持续存在。

对 CA 捆绑包内容的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。但是，对通知程序所用的 CA 捆绑包的更改会立即生效。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

CERTIFICATE certificate‑name

指定一个供端点验证的客户端证书。

如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。

IDENTIFIED BY uuid
指定通知程序的唯一标识符。如果设置，则此通知程序发布的所有消息都具有此属性。
[NO] CHECK COMMITTED
指定在发送队列中的下一条消息之前等待传递确认。

某些消息传递系统（如 syslog）不支持传递确认。

PARAMETERS 'adapter‑params'
指定以字符串形式传递给适配器的一个或多个可选适配器参数。适配器参数仅适用于与通知程序关联的适配器。

对于 Kafka 通知程序，请参阅 Kafka 和 Vertica 配置设置。

对于 syslog 通知程序，使用 eventSeverity=severity 指定事件的严重性，其中 severity 为以下之一：

  • 0：紧急

  • 1：警报

  • 2：严重

  • 3：错误

  • 4：警告

  • 5：注意

  • 6：信息

  • 7：Debug

默认情况下，大多数 syslog 实现不记录严重级别为 7 的事件。您必须配置 syslog 来记录这些类型的事件。

特权

超级用户

SASL_SSL Kafka 配置的加密通知程序

按照此步骤，为使用 SASL_SSL 的 Kafka 端点创建或更改通知程序。请注意，每当您更改给定通知程序的 TLSMODE、证书或 CA 捆绑包时，都必须重复此步骤。

  1. 在设置 TLSMODE、证书和 CA 捆绑包时，使用 CREATE 或 ALTER 以禁用通知程序。

    => ALTER NOTIFIER encrypted_notifier
    DISABLE
    TLSMODE 'verify-ca'
    CA BUNDLE ca_bundle2;

  2. 更改通知程序并为 SASL_SSL 设置适合的 rdkafka 适配器参数。

    => ALTER NOTIFIER encrypted_notifier PARAMETERS
  'sasl.username=user;sasl.password=password;sasl.mechanism=PLAIN;security.protocol=SASL_SSL';

  3. 启用通知程序。

    => ALTER NOTIFIER encrypted_notifier ENABLE;

示例

Kafka 通知程序

创建 Kafka 通知程序：

=> CREATE NOTIFIER my_dc_notifier
    ACTION 'kafka://172.16.20.10:9092'
    MAXMEMORYSIZE '1G'
    IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
    NO CHECK COMMITTED;

使用特定于适配器的参数创建通知程序：

=> CREATE NOTIFIER my_notifier
    ACTION 'kafka://127.0.0.1:9092'
    MAXMEMORYSIZE '10M'
    PARAMETERS 'queue.buffering.max.ms=1000';

创建使用加密连接并使用提供的 CA 捆绑包验证 Kafka 服务器证书的通知程序：

=> CREATE NOTIFIER encrypted_notifier
    ACTION 'kafka://127.0.0.1:9092'
    MAXMEMORYSIZE '10M'
    TLSMODE 'verify-ca'
    CA BUNDLE ca_bundle;

Syslog 通知程序

以下示例创建了一个通知程序，当 数据收集器 (DC) 组件 LoginFailures 更新时，它会向 syslog 写入一条消息：

  1. 为当前数据库启用 syslog 通知程序：

    => ALTER DATABASE DEFAULT SET SyslogEnabled = 1;

  2. 创建并启用系统日志通知程序 v_syslog_notifier：

    => CREATE NOTIFIER v_syslog_notifier ACTION 'syslog'
    ENABLE
    MAXMEMORYSIZE '10M'
    IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
    PARAMETERS 'eventSeverity = 5';

  3. 配置 syslog 通知程序 v_syslog_notifier 以更新具有 SET_DATA_COLLECTOR_NOTIFY_POLICY 的 LoginFailures DC 组件：

    => SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','v_syslog_notifier', 'Login failed!', true);

    当用户未能以用户 Bob 身份进行身份验证时，此通知程序将以下消息写入 syslog（默认位置：/var/log/messages）：Apr 25 16:04:58 vertica_host_01 vertica： Event Posted: Event Code:21 Event Id:0 Event Severity: Notice [5] PostedTimestamp: 2022-04-25 16:04:58.083063 ExpirationTimestamp: 2022-04-25 16:04:58.083063 EventCodeDescription: Notifier ProblemDescription: (Login failed!) { "_db":"VMart", "_schema":"v_internal", "_table":"dc_login_failures", "_uuid":"f8b0278a-3282-4e1a-9c86-e0f3f042a971", "authentication_method":"Reject", "client_authentication_name":"default: Reject", "client_hostname":"::1", "client_label":"", "client_os_user_name":"dbadmin", "client_pid":523418, "client_version":"", "database_name":"dbadmin", "effective_protocol":"3.8", "node_name":"v_vmart_node0001", "reason":"REJECT", "requested_protocol":"3.8", "ssl_client_fingerprint":"", "ssl_client_subject":"", "time":"2022-04-25 16:04:58.082568-05", "user_name":"Bob" }#012 DatabaseName: VMart Hostname: vertica_host_01

有关 syslog 通知程序的详细信息，请参阅为 syslog 配置报告。

另请参阅

5.11.20 - CREATE PROCEDURE（外部）

仅限企业模式

将外部过程添加到 Vertica。有关详细信息，请参阅外部过程。

语法

CREATE PROCEDURE [ IF NOT EXISTS ]
    [[database.]schema.]procedure( [ argument-list ] )
    AS executable
    LANGUAGE 'EXTERNAL'
    USER OS-user

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

此选项无法与 OR REPLACE 结合使用。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
为外部过程指定名称，其中 procedure-name符合标识符中描述的约定。
argument-list
过程实参的逗号分隔列表，其中每个实参指定如下： 
[ argname ] argtype

  • argname 可选为此实参提供描述性名称。

  • argtype 必须为 Vertica 支持的以下数据类型之一：

    • BIGINT

    • BOOLEAN

    • DECIMAL

    • DOUBLE PRECISION

    • FLOAT

    • FLOAT8

    • INT

    • INT8

    • INTEGER

    • MONEY

    • NUMBER

    • NUMERIC

    • REAL

    • SMALLINT

    • TINYINT

    • VARCHAR

executable
过程目录中可执行程序的名称，字符串。
OS-user
文件的所有者，字符串。所有者：

  • 不能是 root

  • 必须对 executable 具有执行权限

特权

超级用户

系统安全

  • 过程文件必须由数据库管理员（OS 帐户）或同一组中作为管理员的用户拥有。过程文件还必须启用集 UID 属性，并允许该组的读取和执行权限。

  • 您使用 CREATE PROCEDURE（外部） 创建的外部过程始终以 Linux dbadmin 权限运行。如果 dbadmin 或伪超级用户授予非 dbadmin 权限以使用 GRANT（过程） 运行过程，请注意非 dbadmin 用户以完全 Linux dbadmin 权限运行该过程。

示例

以下示例展示了如何为过程文件 helloplanet.sh 创建一个名为 helloplanet 的过程。此文件接受一个 VARCHAR 实参。

创建文件：

#!/bin/bash
echo "hello planet argument: $1" >> /tmp/myprocedure.log

使用以下 SQL 创建过程：

=> CREATE PROCEDURE helloplanet(arg1 varchar) AS 'helloplanet.sh' LANGUAGE 'external' USER 'dbadmin';

另请参阅

5.11.21 - CREATE PROCEDURE（存储）

创建存储过程。

语法

CREATE [ OR REPLACE ] PROCEDURE [ IF NOT EXISTS ]
    [[database.]schema.]procedure( [ parameter-list ] )
    [ LANGUAGE 'language-name' ]
    [ SECURITY { DEFINER | INVOKER } ]
    AS $$ source $$;

参数

OR REPLACE
如果已存在相同名称的过程，请将其替换。对原始过程具有权限的用户和角色在新过程中保留这些权限。

此选项无法与 IF NOT EXISTS 结合使用。

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

此选项无法与 OR REPLACE 结合使用。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
存储过程的名称，其中 procedure-name符合标识符中描述的约定。
parameter-list
正式参数的逗号分隔列表，每个参数指定如下： 
[ parameter-mode ] parameter-name parameter-type

  • parameter-name：参数的名称。

  • parameter-type：任何 SQL 数据类型，以下内容除外：

    • DECIMAL

    • NUMERIC

    • NUMBER

    • MONEY

    • UUID

    • GEOGRAPHY

    • GEOMETRY

    • 复杂类型

language-name
指定过程 source 的语言，为以下之一（两个选项均涉及 PLvSQL；PLpgSQL 包括在内以保持与现有脚本的兼容性）：

  • PLvSQL

  • PLpgSQL

默认值： PLvSQL

SECURITY { DEFINER | INVOKER }
确定在调用过程时要使用的权限并执行它，就好像用户为以下之一：

  • DEFINER：定义过程的用户

  • INVOKER：调用过程的用户

使用 SECURITY DEFINER 的过程以该用户身份有效地执行过程，因此，对数据库的更改似乎是由过程的定义者（而不是其调用者）执行的。

有关详细信息，请参阅执行存储过程。

源
过程源代码。有关详细信息，请参阅范围和结构。

特权

非超级用户：对过程架构的 CREATE 权限

示例

有关更复杂的示例，请参阅 存储过程：用例和示例

此过程打印其实参：

=> CREATE PROCEDURE raiseXY(IN x INT, y VARCHAR) LANGUAGE PLvSQL AS $$
BEGIN
    RAISE NOTICE 'x = %', x;
    RAISE NOTICE 'y = %', y;
    -- some processing statements
END;
$$;

CALL raiseXY(3, 'some string');
NOTICE 2005:  x = 3
NOTICE 2005:  y = some string

有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。

另请参阅

5.11.22 - CREATE PROFILE

创建一个配置文件以控制用户的密码要求。

语法

CREATE PROFILE profile‑name LIMIT [
    PASSWORD_LIFE_TIME setting
    PASSWORD_MIN_LIFE_TIME setting
    PASSWORD_GRACE_TIME setting
    FAILED_LOGIN_ATTEMPTS setting
    PASSWORD_LOCK_TIME setting
    PASSWORD_REUSE_MAX setting
    PASSWORD_REUSE_TIME setting
    PASSWORD_MAX_LENGTH setting
    PASSWORD_MIN_LENGTH setting
    PASSWORD_MIN_LETTERS setting
    PASSWORD_MIN_UPPERCASE_LETTERS setting
    PASSWORD_MIN_LOWERCASE_LETTERS setting
    PASSWORD_MIN_DIGITS setting
    PASSWORD_MIN_SYMBOLS setting
    PASSWORD_MIN_CHAR_CHANGE setting ]

参数

特权

超级用户

配置文件设置和客户端身份验证

以下配置文件设置会影响客户端身份验证方法，例如 LDAP 或 GSS：

  • FAILED_LOGIN_ATTEMPTS

  • PASSWORD_LOCK_TIME

所有其他配置文件设置仅供 Vertica 用于管理其密码。

示例

=> CREATE PROFILE sample_profile LIMIT PASSWORD_MAX_LENGTH 20;

另请参阅

5.11.23 - CREATE PROJECTION

为 Vertica 编录中的 投影创建元数据。Vertica 支持四种类型的投影：

  • 标准投影： 以优化在该表上执行某些查询的格式存储表数据的集合。

  • 实时聚合投影： 存储对表列调用聚合函数（例如 SUM）的查询的分组结果。

  • Top-K 投影：存储所选行的分区中的前 k 行。

  • UDTF 投影： 在由用户定义的转换函数 (UDTF) 转换和/或聚合后存储新加载的数据。

复杂数据类型在投影中使用时有额外的限制：

  • 每个投影必须至少包含一个原始类型或原生数组的列。

  • AS SELECT 子句可以使用复杂类型的列，但任何其他表达式必须是标量类型或原生数组。

  • ORDER BY、PARTITION BY 和 GROUP BY 子句无法使用复杂类型。

  • 如果投影不包含 ORDER BY 或分段子句，Vertica 仅使用选择列表中的原始列对数据进行排序或分段。

  • 投影列不能是从 ARRAY_CAT 等函数返回的复杂类型。

  • TopK 和 UDTF 投影不支持复杂类型。

5.11.23.1 - 标准投影

Stores a collection of table data in a format that optimizes execution of certain queries on that table.

以优化在该表上执行某些查询的格式存储表数据的集合。有关详细信息，请参阅 投影。

语法

CREATE PROJECTION [ IF NOT EXISTS ] [[database.]schema.]projection
[ (
   { projection-column | grouped-clause
   [ ENCODING encoding-type ]
   [ ACCESSRANK integer ] }[,...]
) ]
AS SELECT { * | { MATCH_COLUMNS('pattern') | expression [ [AS] alias ] }[,...] }
   FROM [[database.]schema.]table [ [AS] alias]
   [ ORDER BY column-expr[,...] ]
   [ segmentation-spec ]
   [ KSAFE [ k-num ]
   [ ON PARTITION RANGE BETWEEN min-val AND max-val ] ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

为该投影及其锚表指定架构，两者的 schema 必须相同。如果指定一个数据库，它必须是当前数据库。

projection

标识要创建的投影，其中 projection 符合 标识符中描述的约定。同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

projection-column

投影列的名称。投影列的列表必须在数量、类型和顺序上与 SELECT 列表列和表达式相匹配。

如果省略投影列名称，Vertica 将使用在 SELECT 列表中指定的锚表列名称。

grouped-clause
请参阅 GROUPED 子句。
ENCODING encoding-type

列编码类型，默认设置为 AUTO。

ACCESSRANK integer

覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。

AS SELECT
指定要从指定表中选择的列或列表达式：

  • * （星号）

    列出查询的表中的所有列。

  • MATCH_COLUMNS('pattern')

    返回查询的锚表中与 pattern匹配的所有列。

  • expression [[AS] alias]

    解析为所查询锚表中的列数据。

    您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置（例如，在 ORDER BY 或分段子句中）引用该别名。

ORDER BY
指定 SELECT 列表中要作为投影排序依据的列。ORDER BY 子句 只能设置为 ASC（默认值）。Vertica 始终按升序存储投影数据。

如果您按具有集合数据类型（ARRAY 或 SET）的列排序，则在 ORDER BY 子句中使用该列的查询将再次执行排序。这是因为投影和查询执行排序的方式不同。

如果省略 ORDER BY 子句，Vertica 将使用 SELECT 列表对投影排序。

segmentation-spec
使用以下子句之一指定如何分布投影数据：

  • hash-segmentation-clause: 指定此项将对数据均匀分段并在群集节点之间分布数据：

    SEGMENTED BY expression ALL NODES [ OFFSET offset ]

  • unsegmented-clause: 指定此项将创建未分段的投影：

    UNSEGMENTED ALL NODES

如果对于锚表和投影都未指定分段，则将使用一个包含 SELECT 列表中所有列的哈希分段子句来定义投影，如下所示：

SEGMENTED BY HASH(column-expr[,...]) ALL NODES OFFSET 0;
KSAFE [k-num]

指定投影的 K-safety，其中 k-num 必须等于或大于数据库 K-safety。如果针对未分段的投影设置了此参数，Vertica 将忽略此参数。 如果省略 k-num，Vertica 将使用数据库 K-safety。

有关常规信息，请参阅 企业模式数据库中的 K-safety。

ON PARTITION RANGE

指定将此投影的数据限制在分区键范围内，指定如下：

ON PARTITION RANGE BETWEEN min-range-value AND max-range-value

以下要求适用于 min‑range‑value 和 ≤ max‑range‑value：

  • Min‑range‑value 必须 ≤ max‑range‑value

  • 它们必须解析为与表分区表达式兼容的数据类型。

  • 它们可以是：

    • 字符串字面量。例如， 2021-07-31

    • 具有稳定或不可变函数的表达式，例如：

      date_trunc('month', now()::timestamp - interval'1 month')

max-range-value 可以设置为 NULL，以指定分区范围没有上限。

有关其他要求和使用详细信息，请参阅 分区范围投影。

特权

非超级用户：

  • 锚表所有者

  • 对架构的 CREATE 权限

示例

请参阅：

5.11.23.2 - 实时聚合投影

存储对表列调用聚合函数（例如 SUM）的查询的分组结果。有关详细信息，请参阅实时聚合投影。

语法

CREATE PROJECTION [ IF NOT EXISTS ] [[database.]schema.]projection
[ (
   { projection-column | grouped-clause
   [ ENCODING encoding-type ]
   [ ACCESSRANK integer ] }[,...]
) ]
AS SELECT { table-column | expr-with-table-columns }[,...] FROM [[database.]schema.]table [ [AS] alias]
   GROUP BY column-expr
   [ KSAFE [ k-num ] ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

为该投影及其锚表指定架构，两者的 schema 必须相同。如果指定一个数据库，它必须是当前数据库。

projection

标识要创建的投影，其中 projection 符合 标识符中描述的约定。同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

projection-column

投影列的名称。投影列的列表必须在数量、类型和顺序上与 SELECT 列表列和表达式相匹配。

如果省略投影列名称，Vertica 将使用在 SELECT 列表中指定的锚表列名称。

grouped-clause
请参阅GROUPED 子句。
ENCODING encoding-type

列编码类型，默认设置为 AUTO。

ACCESSRANK integer

覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。

AS SELECT

指定要查询的表数据：

{table-column | expr-with-table-columns } [ [AS] alias] }[,...]

您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。

GROUP BY column‑expr[,...]
SELECT 列表中的一个或多个列表达式。第一个 column-expr 必须是 SELECT 列表中的第一个列表达式，第二个 column-expr 必须是 SELECT 列表中的第二个列表达式，依此类推。

特权

非超级用户：

  • 锚表所有者

  • 对架构的 CREATE 权限

要求和限制

Vertica 不会将实时聚合投影视为 超投影，即使是包含所有表列的投影也是如此。有关其他要求和限制，请参阅创建实时聚合投影。

示例

请参阅实时聚合投影示例。

5.11.23.3 - Top-K 投影

存储所选行的分区中的前 k 行。有关详细信息，请参阅 Top-K 投影。

语法

CREATE PROJECTION [ IF NOT EXISTS ] [[database.]schema.]projection
[ (
   { projection-column | grouped-clause
   [ ENCODING encoding-type ]
   [ ACCESSRANK integer ] }[,...]
) ]
AS SELECT { table-column | expr-with-table-columns }[,...] FROM [[database.]schema.]table [ [AS] alias]
   LIMIT num-rows OVER ( window-partition-clause [window-order-clause] )
   [ KSAFE [ k-num ] ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

为该投影及其锚表指定架构，两者的 schema 必须相同。如果指定一个数据库，它必须是当前数据库。

projection

标识要创建的投影，其中 projection 符合 标识符中描述的约定。同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

projection-column

投影列的名称。投影列的列表必须在数量、类型和顺序上与 SELECT 列表列和表达式相匹配。

如果省略投影列名称，Vertica 将使用在 SELECT 列表中指定的锚表列名称。

grouped-clause
请参阅 GROUPED 子句。
ENCODING encoding-type

列编码类型，默认设置为 AUTO。

ACCESSRANK integer

覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。

AS SELECT

指定要查询的表数据：

{table-column | expr-with-table-columns } [ [AS] alias] }[,...]

您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。

AS SELECT

指定要查询的表数据：

{table-column | expr-with-table-columns } [ [AS] alias] }[,...]

您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。

LIMIT num‑rows
要从指定分区返回的行数。
window-partition-clause
指定按 SELECT 列表中的一个或多个列表达式（用逗号分隔）进行窗口分区。第一个分区表达式必须是 SELECT 列表中的第一项，第二个分区表达式必须是 SELECT 列表中的第二项，依此类推。
window-order-clause
指定前 k 行的返回顺序，默认情况下按升序 (ASC)。所有列表达式都必须来自 SELECT 列表，其中第一个窗口顺序表达式必须是未在窗口分区子句中指定的第一个 SELECT 列表项。

Top-K 投影支持 ORDER BY NULLS FIRST/LAST。

特权

非超级用户：

  • 锚表所有者

  • 对架构的 CREATE 权限

要求和限制

Vertica 不会将 Top-K 投影视为 超投影，即使是包含所有表列的投影也是如此。有关其他要求和限制，请参阅 创建 Top-K 投影。

示例

请参阅 Top-K 投影示例。

5.11.23.4 - UDTF 投影

在由用户定义的转换函数 (UDTF) 转换和/或聚合后存储新加载的数据。有关详细信息和示例，请参阅 预聚合 UDTF 结果。

语法

CREATE PROJECTION [ IF NOT EXISTS ] [[database.]schema.]projection
[ (
   { projection-column | grouped-clause
   [ ENCODING encoding-type ]
   [ ACCESSRANK integer ]  }[,...]
) ]
AS { [batch-query](#UDTFBatchQuery) FROM { [prepass-query](#UDTFPrePassQuery) sq-ref | table [[AS] alias] }
     | [prepass-query](#UDTFPrePassQuery) }


batch-query
SELECT { table-column | expr-with-table-columns }[,...], batch-udtf(batch-args)
   OVER (PARTITION BATCH BY partition-column-expr[,...])
   [ AS (batch-output-columns) ]


prepass-query
SELECT { table-column | expr-with-table-columns }[,...], prepass-udtf(prepass-args)
   OVER (PARTITION PREPASS BY partition-column-expr[,...])
   [ AS (prepass-output-columns) ] FROM table

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

为该投影及其锚表指定架构，两者的 schema 必须相同。如果指定一个数据库，它必须是当前数据库。

projection

标识要创建的投影，其中 projection 符合 标识符中描述的约定。同一架构中的序列、表、投影、视图和模型中也必须是唯一的。

projection-column

投影列的名称。投影列的列表必须在数量、类型和顺序上与 SELECT 列表列和表达式相匹配。

如果省略投影列名称，Vertica 将使用在 SELECT 列表中指定的锚表列名称。

grouped-clause
请参阅 GROUPED 子句。
ENCODING encoding-type

列编码类型，默认设置为 AUTO。

ACCESSRANK integer

覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。

AS SELECT

指定要查询的表数据：

{table-column | expr-with-table-columns } [ [AS] alias] }[,...]

您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。

batch-udtf(batch-args)
每当发生以下事件时要调用的 批量 UDTF：

  • Tuple Mover 合并

  • 在投影上执行查询

  • 在执行数据加载操作时进行单个调用

prepass-udtf(prepass-args)
要在执行每个加载操作（例如 COPY 或 INSERT）时调用的 预传递 UDTF。

如果在子查询中指定，则预传递 UDTF 会将转换的数据返回给批量查询，以做进一步处理。否则，预传递查询结果将添加至投影数据存储。

OVER (PARTITION { BATCH | PREPASS } BY partition-column-expr[,...]
指定 UDTF 类型以及如何对其返回的数据进行分区：

在两种情况下，OVER 子句会指定要借助于 SELECT 列表中的一个或多个列表达式进行分区。第一个 partition-column-expr 是 SELECT 列表中的第一个列表达式，第二个 partition-column- expr 是 SELECT 列表中的第二个列表达式，依此类推。

AS (batch-output-columns) AS (prepass-output-columns)
（可选）命名 UDTF 返回的列。

如果预传递子查询忽略此子句，则外部批量查询 UDTF 实参 (batch-args) 必须引用列名称，像它们在预传递 UDTF 中定义的那样。

table [[AS] alias]
指定投影的锚表，可选择性地由别名限定。
sq-results
返回到外部批量 UDTF 的子查询结果集。

特权

非超级用户：

  • 锚表所有者

  • 对架构的 CREATE 权限

  • 对由投影引用的所有 UDTF 的 EXECUTE 权限

示例

请参阅 预聚合 UDTF 结果。

5.11.23.5 - 编码类型

Vertica 支持各种编码和压缩类型，由以下 ENCODING 参数实参指定：

创建投影时，您可以在投影列上设置编码类型。您还可以使用 ALTER TABLE...ALTER COLUMN 更改给定表的一个或多个投影列的编码。

AUTO（默认）

AUTO 对于已排序、多值的列是理想的方案，如对于主键。除此之外，它还适用于其他编码或压缩方案不适用的一般用途。因此，在未指定编码/压缩类型的情况下，它将作为默认类型。

BINARY/VARBINARY
BOOLEAN
CHAR/VARCHAR
FLOAT
基于 Lempel-Ziv-Oberhumer (LZO) 的压缩
DATE/TIME/TIMESTAMP
INTEGER
INTERVAL
基于连续列值之间的增量的压缩方案。

此类型对 CPU 的要求相对较小。最坏的情况，LZO 数据可能膨胀百分之八 (8%)，整数数据可能膨胀百分之二十 (20%)。

BLOCK_DICT

对于每个存储块，Vertica 会将不同列值编译到词典中，然后存储词典和索引列表，用以表示该数据块。

BLOCK_DICT 对于少值、未排序的列是理想方案，因为在这种情况下，节省空间比编码速度更重要。某些类数据（如股票价格）经过排序后（如按股票代码和时间戳）在局部区域内通常都是少值的，很适合选择 BLOCK_DICT 方案。相反，CHAR/VARCHAR 列则不适合选择 BLOCK_DICT 编码。

包含 0x00 或 0xFF 字符的 CHAR 和 VARCHAR 列不应使用 BLOCK_DICT 编码。同样，BINARY/VARBINARY 列也不支持 BLOCK_DICT 编码。

BLOCK_DICT 编码需要占用的 CPU 要远远超过默认编码方案。最大数据膨胀率为百分之八 (8%)。

BLOCKDICT_COMP

此编码类型与 BLOCK_DICT 类似，只不过其词典索引为熵编码。此编码类型需要更多的 CPU 时间来编码和解码，其最坏情况性能较差。但如果值分布倾斜极为严重，使用 BLOCK_DICT_COMP 编码可节省空间。

BZIP_COMP

BZIP_COMP 编码对块内容使用 bzip2 压缩算法。有关更多信息，请参阅 bzip 网站。此算法的压缩率较自动 LZO 和 gzip 编码高；但它需要更多的 CPU 时间执行压缩。此算法最好用于大型字符串列，例如 VARCHAR、VARBINARY、CHAR 和 BINARY。如果想牺牲加载速度，换取较高的数据压缩率，那么请选择此编码类型。

COMMONDELTA_COMP

此压缩方案会为块中所有增量构建一个词典，然后使用熵编码将索引存储到增量词典中。

对于已排序的 FLOAT 和基于 INTEGER (DATE/TIME/TIMESTAMP/INTERVAL)、序列可预见且仅偶有序列断点的数据列（如按周期性间隔记录的时间戳，或者主键），此方案是理想选择。例如，以下序列的压缩效果很好：300, 600, 900, 1200, 1500, 600, 1200, 1800, 2400。以下序列的压缩效果则很差：1, 3, 6, 10, 15, 21, 28, 36, 45, 55。

如果增量分布非常好，那么列将能够以每行少于一个字节的方式存储。但是，此方案会占用大量的 CPU。如果对增量很随意的数据使用此方案，那么可能引发大幅度的数据膨胀。

DELTARANGE_COMP

此压缩方案主要用于浮点数据；它以相对于上一个值的增量的形式存储各值。

对于已排序或限定在一定范围内的多值 FLOAT 列，此方案是理想选择。请勿对包含 NULL 值的未排序列使用此方案，因为表示 NULL 值所消耗的存储量非常高。此方案的压缩和解压过程的损耗都很高。

要确定 DELTARANGE_COMP 是否适合特定数据集，可以将其与其他方案进行对比。要确保与投影使用相同的排序顺序，且要选择将以连续方式存储在数据库中的示例数据。

DELTAVAL

对于 INTEGER 和 DATE/TIME/TIMESTAMP/INTERVAL 列，将以与数据库中最小值的差的形式记录数据。此编码对于其他数据类型没有任何作用。

DELTAVAL 最适合多值、未排序整数或基于整数的列。此编码类型对 CPU 的要求最低，而且数据永不会膨胀。

GCDDELTA

对于 INTEGER 和 DATE/TIME/TIMESTAMP/INTERVAL 列，以及只有 18 位或少于 18 位的 NUMERIC 列，将以与数据块中最小值的差除以块中所有条目的最大公约数 (GCD) 的形式存储数据。此编码对于其他数据类型没有任何作用。

ENCODING GCDDELTA 最适合值为同一因子倍数情况下的多值、未排序、整数列或基于整数的列。例如，时间戳在内部以微秒为单位存储，因此，仅精确到毫秒的数据均为 1000 倍。GCDDELTA 编码类型的解码过程对 CPU 的要求最低，且数据永不膨胀，但 GCDDELTA 的编码时间要比 DELTAVAL 长。

GZIP_COMP

此编码类型使用 gzip 压缩算法。有关更多信息，请参阅 gzip 网站。此算法的压缩效果要比自动 LZO 压缩好，但比 BZIP_COMP 的压缩率低。它执行压缩占用的 CPU 时间比 LZO 多，比 BZIP_COMP 少。此算法最好用于大型字符串列，例如 VARCHAR、VARBINARY、CHAR 和 BINARY。想要压缩效果比 LZO 好、占用的 CPU 时间比 bzip2 少时，请使用此编码。

RLE

RLE（运行长度编码）将相同值的序列（运行）替换为包含值和出现次数的单个对。因此，它最适合出现在投影的 ORDER BY 子句中的低基数列。

Vertica 执行引擎按逐个运行的方式处理 RLE 编码，Vertica 优化器优先处理 RLE 编码。仅在运行长度较长时（如存储低基数列时）使用此类型。

Zstandard 压缩

Vertica 支持三种 ZSTD 压缩类型：

  • ZSTD_COMP 提供高压缩率。此编码类型的压缩率高于 gzip。想要压缩效果比 gzip 好时，请使用此编码。对于一般用例，请使用此编码或 ZSTD_FAST_COMP 编码类型。

  • ZSTD_FAST_COMP 使用 zstd 库提供的最快压缩级别。它是 zstd 库中最快的编码类型，但比其他两种编码类型占用更多空间。对于一般用例，请使用此编码或 ZSTD_COMP 编码类型。

  • ZSTD_HIGH_COMP 提供 zstd 库中的最佳压缩。它比其他两种编码类型慢。当您需要最佳压缩时，请使用此类型，但 CPU 时间较慢。

5.11.23.6 - GROUPED 子句

仅限企业模式

将两个或多个列分组到单个磁盘文件。这样可以将以下工作负载的 I/O 降到最低：

  • 读取表中大部分的列。

  • 执行单个行查找。

  • 针对大量小型列进行查询。

  • 频繁更新这些列中的数据。

如果您具有始终同时访问的数据并且这些数据不会在谓词中使用，那么可以通过分组这些列来提高查询性能。一旦分组，查询将不再独立于组中的其他列从磁盘独立检索单个列的所有数据。

对列分组时，您可以：

  • 对部分列进行分组：

    (a, GROUPED(b, c), d)

  • 对所有列进行分组：

    (GROUPED(a, b, c, d))

  • 在同一投影中创建多个分组：

    (GROUPED(a, b), GROUPED(c, d))

对相关列进行分组

以下示例展示了如何对高度相关的列 bid 和 ask 进行分组。stock 列单独存储。

=> CREATE TABLE trades (stock CHAR(5), bid INT, ask INT);
=> CREATE PROJECTION tradeproj (stock ENCODING RLE,
   GROUPED(bid ENCODING DELTAVAL, ask))
   AS (SELECT * FROM trades) KSAFE 1;

以下示例展示了如何创建在列定义中使用表达式的投影。投射包含两个整数列 a 和 b，以及第三列 product_value，用于存储 a 和 b 的乘积：

=> CREATE TABLE values (a INT, b INT


=> CREATE PROJECTION product (a, b, product_value) AS
   SELECT a, b, a*b FROM values ORDER BY a KSAFE;

5.11.23.7 - 哈希分段子句

指定如何对投影数据进行分段，以便在所有群集节点上分布数据。您可以为表和投影指定分段。如果表定义指定了分段，则 Vertica 会将其用于该表的自动投影。

强烈建议使用 Vertica 的 HASH 内置函数，该函数可在整个群集中均匀分布数据，且便于实现最佳查询执行。

语法

SEGMENTED BY expression ALL NODES [ OFFSET offset ]

参数

SEGMENTED BY expression
常用的 SQL 表达式。哈希分段是首选分段方法。Vertica 建议使用其内置的 HASH 函数，该函数的实参解析为表列。如果使用 HASH 之外的表达式，Vertica 会发出警告。

分段表达式应指定具有大量唯一数据值和在数据分布中可接受的偏离的列。通常，符合这些条件的主键列适合用于哈希分段。

有关详细信息，请参阅下面的表达式要求。

ALL NODES
创建投影时，会自动在所有节点中均匀分布数据。节点顺序是固定的。
OFFSET offset
基于零的偏移表示在哪个节点上开始分段分布。

此选项对于 CREATE TABLE 和 CREATE TEMPORARY TABLE 无效。

表达式要求

分段表达式在指定表列时必须按照其在源表中定义的那样进行指定。不支持投影列名称。

以下限制适用于分段表达式：

  • 所有叶表达式都必须为常数或 CREATE PROJECTION 的 SELECT 列表中的列的列引用。

  • 表达式在数据库的整个使用过程中都必须返回相同的值。

  • 不允许集合函数。

  • 表达式必须返回 0 <= x < 263 范围内的非负 INTEGER 值，且值通常均匀分布在该范围内。

示例

以下 CREATE PROJECTION 语句将创建投影 public.employee_dimension_super。它指定包含表 public.employee_dimension 中的所有列。哈希分段子句将调用 Vertica HASH 函数，对列 employee_key 中的投影数据进行分段；此外，它还包括 ALL NODES 子句，指定在群集中的所有节点上均匀分布投影数据：

=> CREATE PROJECTION public.employee_dimension_super
    AS SELECT * FROM public.employee_dimension
    ORDER BY employee_key
    SEGMENTED BY hash(employee_key) ALL NODES;

5.11.23.8 - 未分段子句

指定在整个群集的所有节点上分发表或投影数据的相同副本。使用此子句有助于对因太小而无法从分段中受益的表和投影执行分布式查询。

Vertica 使用相同的名称来标识未分段投影的所有实例。有关投影名称约定的详细信息，请参阅投影命名。

语法

UNSEGMENTED ALL NODES

示例

此示例为表 store.store_dimension 创建一个未分段的投影：


=> CREATE PROJECTION store.store_dimension_proj (storekey, name, city, state)
             AS SELECT store_key, store_name, store_city, store_state
             FROM store.store_dimension
             UNSEGMENTED ALL NODES;
CREATE PROJECTION

=>  SELECT anchor_table_name anchor_table, projection_name, node_name
      FROM PROJECTIONS WHERE projection_basename='store_dimension_proj';
  anchor_table   |   projection_name    |    node_name
-----------------+----------------------+------------------
 store_dimension | store_dimension_proj | v_vmart_node0001
 store_dimension | store_dimension_proj | v_vmart_node0002
 store_dimension | store_dimension_proj | v_vmart_node0003
(3 rows)

5.11.24 - CREATE RESOURCE POOL

创建自定义资源池并设置一个或多个资源池参数。

语法

CREATE RESOURCE POOL pool‑name [ FOR subcluster-spec ] [ parameter‑name setting ]...

参数

pool‑name
资源池的名称。内置池名称不能用于用户定义的池。
FOR subcluster‑spec
仅限 Eon 模式，指定将此资源池与某个子群集关联，其中 subcluster-spec 为以下之一：
  • SUBCLUSTER subcluster-name：为现有子群集创建资源池。您不能连接到此子群集，否则 Vertica 会返回错误。
  • CURRENT SUBCLUSTER：为连接到的子群集创建资源池。

如果忽略，则在全局创建资源池。尝试创建与特定于子群集的资源池同名的全局资源池时会返回错误。

parameter‑name
要设置的参数，如下所示。
设置

要在 parameter‑name 上设置的值。要将此参数重置为其默认值，请指定 DEFAULT。

CASCADE TO

指定一个辅助资源池，用于执行其 [RUNTIMECAP](#RUNTIMECAP) 设置超出分配资源池的查询：

CASCADE TO secondary‑pool
CPUAFFINITYMODE

指定资源池是单独使用还是共用 [CPUAFFINITYSET](#CPUAFFINITYSET) 中指定的 CPU。

CPUAFFINITYMODE { SHARED | EXCLUSIVE | ANY }

  • SHARED：在此池中运行的查询与其他 Vertica 资源池共享其 CPUAFFINITYSET CPU。

  • EXCLUSIVE：仅将 CPUAFFINITYSET CPU 专用于此资源池，不用于其他 Vertica 资源池。如果将 CPUAFFINITYSET 设置为百分比，那么仅为此资源池分配可用于 Vertica 的 CPU 资源百分比。

  • ANY （默认值）：此资源池中的查询可以在任何 CPU 上运行，如果 CPUAFFINITYSET 指定 CPU 资源，则此查询无效。

CPUAFFINITYSET

指定此资源池可用的 CPU。所有群集节点必须具有相同的 CPU 数量。分配给该集合的 CPU 资源对常规资源池不可用。

CPUAFFINITYSET {
  'cpu‑index[,...]'
| 'cpu‑indexi-cpu‑indexn'
| 'integer%'
| NONE
}

  • cpu‑index[,...]：将以一个或多个逗号分隔的 CPU 专用于此池。

  • cpu‑indexi-cpu‑indexn：将一系列连续的 CPU 索引专用于此池

  • integer%：此池可用的所有可用 CPU 的百分比。Vertica 将此百分比向下舍入以包括整个 CPU 单元。

  • NONE （默认值）：没有关联集分配给该资源池。与该池关联的查询可在任何 CPU 上执行。

EXECUTIONPARALLELISM

限制用于处理此资源池中发出的任何单一查询的线程数量。

EXECUTIONPARALLELISM { limit | AUTO }

  • limit：介于 1 与内核数之间的整数值。将此参数设置为减小的值时，可以增大池中发出的简短查询的吞吐量，特别是在并发执行多个查询的情况下。

  • AUTO or0（默认值）：Vertica 根据系统中的内核数、可用内存和数据量计算设置。除非内存有限，或者数据量非常小，否则 Vertica 会将此参数设置为节点中的核心数。

MAXCONCURRENCY

设置群集中资源池可用的最大并发执行槽数：

MAXCONCURRENCY { integer | NONE }

NONE （默认）指定不限数量的并发执行槽。

MAXMEMORYSIZE

通过从 GENERAL 池中借用内存，资源池可以增加的每个节点的最大大小：

MAXMEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
| NONE
}

  • integer%：占总内存的百分比

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量

  • NONE （默认值）：无限制，池可以从 GENERAL 池中借用任意数量的可用内存。

MAXQUERYMEMORYSIZE

此池可以在运行时分配以处理查询的最大内存量。如果查询需要的内存超过此设置，Vertica 将停止执行并返回错误。

设置此参数如下：

MAXQUERYMEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
| NONE
}

  • integer%：百分比 此池的 MAXMEMORYSIZE。

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量，最大为 MAXMEMORYSIZE。

  • NONE （默认值）：无限制；池可以从 GENERAL 池中借用任意数量的可用内存，其限制由以下设置： MAXMEMORYSIZE。

MEMORYSIZE

每个节点分配给此池的 Vertica 资源管理器可用的总内存量：

MEMORYSIZE {
  'integer%'
| 'integer{K|M|G|T}'
}

  • integer%：占总内存的百分比

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量

默认值： 0%。没有分配任何内存，资源池从 GENERAL 池中借用内存。

PLANNEDCONCURRENCY

指定资源池中并发执行的查询首选数量。此设置适用于整个群集：

PLANNEDCONCURRENCY { num‑queries | AUTO }

  • num‑queries：整数值 ≥ 1，指定并发执行查询的首选数量。在可能的情况下，查询资源预算被限制为允许此级别的并发执行。

  • AUTO （默认值）：值将在查询运行时自动计算。Vertica 将此参数设置为这两个计算中的较低值，但绝不会小于 4：

    • 逻辑核心数

    • 内存除以 2GB

对于不同节点上逻辑核数不同的群集，AUTO 可以在每个节点上应用不同的方法。分布式查询的运行方式类似于最低的有效计划并发性能。单节点查询以发起方的计划并发性能运行。

PRIORITY

指定此池中的查询在争用 GENERAL 池中资源时的优先级：

PRIORITY { integer | HOLD }

  • integer：一个负整数或正整数值。数字越大，表示优先级越高：

    • 用户定义的池： ‑100 到 100

    • 内置池 SYSQUERY、 RECOVERY 和 TM： ‑110 到 110

  • HOLD：将优先级设置为 -999。此池中的查询将排队，直到达到 [QUEUETIMEOUT](#QUEUETIMEOUT) 为止。

默认值： 0

QUEUETIMEOUT

指定请求在被拒绝之前可以等待池资源多长时间：

QUEUETIMEOUT { integer | NONE }

  • integer：最长等待时间（以秒为单位）

  • NONE：没有最长等待时间，请求可以无限排队。

默认值： 300 秒

RUNTIMECAP

通过设置池中的查询可以执行的最大时间，可以防止查询失控。如果查询超出此设置，它会尝试级联到辅助池。

RUNTIMECAP { 'interval' | NONE }

  • interval：1 分钟或 100 秒的间隔；不应超过 1 年。

  • NONE （默认值）：在此池中运行的查询没有时间限制。

    要以天为单位指定一个值，请提供整数值。要提供小于一天的值，请以 hours:minutes:seconds 格式提供间隔。例如，值为 1:30:00 时，则等于 90 分钟。

    如果用户或会话也具有 RUNTIMECAP，则会应用较短的限制。

RUNTIMEPRIORITY

确定资源管理器应如何将运行时资源（CPU、I/O 带宽）的优先级分配给已在此资源池中运行的查询：

RUNTIMEPRIORITY { HIGH | MEDIUM | LOW }

默认值： MEDIUM

RUNTIMEPRIORITYTHRESHOLD

以秒为单位指定一个时间限制，在资源管理器为其分配资源池 RUNTIMEPRIORITY 之前，必须完成一个查询。所有查询从 HIGH 优先级开始运行。如果查询的持续时间超过了此阈值，它将分配到资源池的 RUNTIMEPRIORITY。

RUNTIMEPRIORITYTHRESHOLD seconds

默认值： 2

SINGLEINITIATOR

默认情况下，已设置为 false 以实现向后兼容性。切勿更改此设置。

特权

超级用户

示例

此示例显示了如何创建具有 1800 MB MEMORYSIZE 的资源池。

=> CREATE RESOURCE POOL ceo_pool MEMORYSIZE '1800M' PRIORITY 10;
CREATE RESOURCE POOL

使用 ALTER USER 语句将假设已存在的 CEO 报告用户与上述资源池相关联。

=> GRANT USAGE ON RESOURCE POOL ceo_pool to ceo_user;
GRANT PRIVILEGE
=> ALTER USER ceo_user RESOURCE POOL ceo_pool;
ALTER USER

发出以下命令确认 ceo_user 与 ceo_pool 相关联：

=> SELECT * FROM users WHERE user_name ='ceo_user';
-[ RECORD 1 ]-----+--------------------------------------------------
user_id           | 45035996273733402
user_name         | ceo_user
is_super_user     | f
profile_name      | default
is_locked         | f
lock_time         |
resource_pool     | ceo_pool
memory_cap_kb     | unlimited
temp_space_cap_kb | unlimited
run_time_cap      | unlimited
all_roles         |
default_roles     |
search_path       | "$user", public, v_catalog, v_monitor, v_internal

此示例显示了如何创建和指定辅助资源池。

=> CREATE RESOURCE POOL rp3 RUNTIMECAP '5 minutes';
=> CREATE RESOURCE POOL rp2 RUNTIMECAP '3 minutes' CASCADE TO rp3;
=> CREATE RESOURCE POOL rp1 RUNTIMECAP '1 minute' CASCADE TO rp2;
=> SET SESSION RESOURCE_POOL = rp1;

此 Eon 模式示例确认当前子群集名称，然后为当前子群集创建资源池：

=> SELECT CURRENT_SUBCLUSTER_NAME();
 CURRENT_SUBCLUSTER_NAME
-------------------------
 analytics_1
(1 row)

=> CREATE RESOURCE POOL dashboard FOR SUBCLUSTER analytics_1;
CREATE RESOURCE POOL

另请参阅

5.11.24.1 - 内置池

Vertica 预先配置了内置池来完成各种系统任务：

有关资源池设置的详细信息，请参阅 ALTER RESOURCE POOL。

GENERAL

一个通用池，用于答复未关联到特定 资源池的请求。为所有其他池分配内存后剩下的任何内存将自动分配给 GENERAL 池。GENERAL 池的 MEMORYSIZE 参数未定义（变量），但是 GENERAL 池的大小必须至少为 1GB，而且不得小于系统内存的 25%。

GENERAL 池的 MAXMEMORYSIZE 参数具有特殊意义，当设置为 % 值时，它表示计算机上 资源管理器可用于查询的总物理内存的百分比。默认情况下，它设置为 95%。MAXMEMORYSIZE 控制资源管理器可用于查询的内存总量，不论将它是设置为百分比还是特定的值（例如，“10GB”）。

用户定义的池可以从 GENERAL 池中借用内存，以满足需要额外内存的请求，直到达到该池的 MAXMEMORYSIZE 参数。如果将池配置为 MEMORYSIZE 等于 MAXMEMORYSIZE，则它不能从 GENERAL 池中借用任何内存。当多个池从 GENERAL 池请求内存时，它们将有权根据各自的优先级设置访问通用池内存。通过这种方式，GENERAL 池可以灵活地解释正常使用各个资源池产生的时间点偏差。

如果编录使用的总内存超过 5%，Vertica 会建议减少 GENERAL 池的 MAXMEMORYSIZE。您可以按以下方式计算编录使用的 GENERAL 池内存的百分比：

=> WITH memory_use_metadata AS (SELECT node_name, memory_size_kb FROM resource_pool_status WHERE pool_name='metadata'),
        memory_use_general  AS (SELECT node_name, memory_size_kb FROM resource_pool_status WHERE pool_name='general')
   SELECT m.node_name, ((m.memory_size_kb/g.memory_size_kb) * 100)::NUMERIC(4,2) pct_catalog_usage
   FROM memory_use_metadata m JOIN memory_use_general g ON m.node_name = g.node_name;
    node_name     | pct_catalog_usage
------------------+-------------------
 v_vmart_node0001 |              0.41
 v_vmart_node0002 |              0.37
 v_vmart_node0003 |              0.36
(3 rows)

BLOBDATA

控制内存中的 blob 的资源使用情况量。内存中的 blob 是许多机器学习 SQL 函数使用的对象。如果计划处理大型机器学习工作负载，则应调整此池。有关优化池的信息，请参阅为机器学习进行调整。

如果使用 BLOBDATA 池的查询超出该池的查询计划预算，则它会溢出到磁盘。有关优化查询预算的详细信息，请参阅查询预算。

DBD

控制 Database Designer 处理的资源使用情况。使用此池由配置参数 DBDUseOnlyDesignerResourcePool 启用，默认情况下该参数设置为 false。

默认情况下，此池的 QUEUETIMEOUT 设置为 0。当资源面临压力时，此设置可使 DBD 立即超时，而不是排队等待运行。Database Designer 随后会请求用户在有更多的资源可用时再运行设计器。

JVM

控制 Java 用户定义的扩展使用的 Java 虚拟机资源。当 Java UDx 启动 JVM 时，它会从 JVM 资源池中获取指定的资源。Vertica 不会提前为 JVM 池保留内存。必要时，池可以扩展到物理内存的 10% 或 2 GB 内存，以较小者为准。如果您正在缓冲大量数据，可能需要增加 JVM 资源池的大小。

您可以通过更改其配置设置调整 JVM 资源池的大小。与其他资源池不同的是，JVM 资源池在会话关闭前不会释放资源。

METADATA

跟踪为编录数据和存储数据结构分配的内存。随着 Vertica 元数据使用更多资源，此池的大小会增加。分配给 METADATA 池的内存将从 GENERAL 池中减去，从而使 Vertica 资源管理器能够更有效地利用可用资源。如果 METADATA 资源池达到 GENERAL 池的 75%，Vertica 将停止更新 METADATA 内存大小并在 vertica.log 中显示警告消息。您可以通过配置参数 EnableMetadataMemoryTracking 启用或禁用 METADATA 池。

如果您创建了一个“虚拟”或“交换”资源池来保护操作系统使用的资源，您可以将该池替换为 METADATA 池。

用户不能更改 METADATA 资源池的参数。

RECOVERY

由恢复数据库的另一个节点时发出的查询使用。MAXCONCURRENCY 参数用于确定要使用多少个并发恢复线程。可以使用 PLANNEDCONCURRENCY 参数（默认情况下，设置为 MAXCONCURRENCY 的两倍）优化分摊内存来恢复查询的方式。

请参阅为恢复进行调整。

REFRESH

由 PROJECTION_REFRESHES 操作发出的查询使用。 刷新当前不使用多个并发线程，因此，对 MAXCONCURRENCY 值的更改无效。

请参阅场景：对刷新进行优化。

SYSQUERY

对所有系统监控和编录表运行查询。SYSQUERY 池保留系统表查询的资源，以便它们不会被可用资源争用拦截。

TM

Tuple Mover (TM) 池。可以为 TM 池设置 MAXCONCURRENCY 参数，以允许并发 TM 操作。

请参阅调整 Tuple Mover 池设置。

5.11.24.2 - 内置资源池配置

要查看内置资源池的当前和默认配置，请分别查询系统表 RESOURCE_POOLS 和 RESOURCE_POOL_DEFAULTS。 以下部分提供了这些信息，并指出了哪些内置池参数可以使用 ALTER RESOURCE POOL 进行修改：

GENERAL

BLOBDATA

参数

设置
MEMORYSIZE 空/不能设置
MAXMEMORYSIZE

供所有资源池使用的最大内存，为以下之一：

MAXMEMORYSIZE {
'integer%'

'integer{K|M|G|T}' }

例如，如果您的节点有 64GB 内存，则将 MAXMEMORYSIZE 设置为 50% 会分配一半的可用内存。因此，所有资源池可用的最大内存量为 32GB。

默认值： 95%
MAXQUERYMEMORYSIZE

此池为处理任何查询分配的最大内存量：

MAXQUERYMEMORYSIZE {
'integer%'

'integer{K|M|G|T}' }
EXECUTIONPARALLELISM 默认值： AUTO
PRIORITY 默认值： 0
RUNTIMEPRIORITY 默认值： 中
RUNTIMEPRIORITYTHRESHOLD 默认值： 2
QUEUETIMEOUT 默认值： 00:05（分钟）
RUNTIMECAP

通过设置池中的查询可以执行的最大时间，可以防止查询失控。如果查询超出此设置，它会尝试级联到辅助池。

RUNTIMECAP { 'interval' | NONE }

  • interval：设置为 1 分钟或 100 秒的时间间隔，不应超过 1 年。

  • NONE （默认值）：在此池中运行的查询没有时间限制。
PLANNEDCONCURRENCY

您希望对资源池运行的并发查询数，此整数 ≥ 4。如果设置为 AUTO（默认），Vertica 会在查询运行时自动设置 PLANNEDCONCURRENCY，选择这两个值中较小的值：

  • 核心数

  • 内存/2GB

默认值： AUTO
MAXCONCURRENCY

默认值： Empty
SINGLEINITIATOR

默认值： False。
CPUAFFINITYSET 默认值： Empty
CPUAFFINITYMODE 默认值： ANY
CASCADETO 默认值： Empty

DBD

JVM

METADATA

RECOVERY

参数

默认设置
MEMORYSIZE 0%
MAXMEMORYSIZE

通过从 GENERAL 池中借用内存，资源池可以增加的每个节点的最大大小：

MAXMEMORYSIZE {
  'integer%'
'integer{K|M|G|T}'

NONE }

  • integer%：占总内存的百分比

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量

  • NONE （默认值）：无限制，池可以从 GENERAL 池中借用任意数量的可用内存。
MAXQUERYMEMORYSIZE 空/不能设置
EXECUTIONPARALLELISM AUTO
PRIORITY

以下几项之一：

  • 企业模式：107

  • Eon 模式：110
RUNTIMEPRIORITY 中
RUNTIMEPRIORITYTHRESHOLD 60
QUEUETIMEOUT 00:05（分钟）
RUNTIMECAP NONE
PLANNEDCONCURRENCY AUTO
MAXCONCURRENCY

默认情况下，设置如下：

(numberCores / 2) + 1

因此，对于具有四个内核的系统，MAXCONCURRENCY 的默认设置为 3。
SINGLEINITIATOR

True。
CPUAFFINITYSET 空/不能设置
CPUAFFINITYMODE ANY/无法设置
CASCADETO 空/不能设置

REFRESH

SYSQUERY

TM

5.11.25 - CREATE ROLE

创建 角色。创建角色后，使用 GRANT 语句指定角色权限。

语法

CREATE ROLE role

参数

角色
新角色的名称，其中 role 符合标识符中描述的约定。

特权

超级用户

示例

此示例显示了如何创建名为 roleA 的空角色。

=> CREATE ROLE roleA;
CREATE ROLE

另请参阅

5.11.26 - CREATE ROUTING RULE

创建负载均衡路由规则，将传入客户端连接从 IP 地址范围定向到一组 Vertica 节点。此组 Vertica 节点由负载均衡组定义。创建路由规则后，如果客户端选择使用负载均衡，则源自规则 IP 地址范围的任何客户端连接都将重定向到负载均衡组中的节点之一。

语法

CREATE ROUTING RULE rule_name ROUTE 'address_range' TO group_name

参数

rule_name
路由规则的名称。
``` address_range ```
CIDR 格式的 IPv4 或 IPv6 地址范围。设置此规则适用的客户端连接的地址范围。
group_name
负载均衡组的名称，用于处理来自地址范围的客户端连接。可以使用 CREATE LOAD BALANCE GROUP 语句创建此组。

特权

超级用户。

示例

以下示例创建了一个路由规则，可将 192.168.1.0 至 192.168.1.255 范围内的所有客户端连接路由到名为 internal_clients 的负载均衡组：

=> CREATE ROUTING RULE internal_clients ROUTE '192.168.1.0/24' TO internal_clients;
CREATE ROUTING RULE

另请参阅

5.11.27 - CREATE SCHEMA

定义架构。

语法

CREATE SCHEMA [ IF NOT EXISTS ] [database.]schema
   [ AUTHORIZATION username]
   [ DEFAULT { INCLUDE | EXCLUDE } [ SCHEMA ] PRIVILEGES ]
   [ DISK_QUOTA quota ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

数据库
要在其中创建架构的数据库的名称。如果指定，则必须是当前数据库。
架构
要创建的架构的名称，具有以下要求：

  • 在数据库的所有其他架构名称中必须是唯一的。

  • 必须符合关键字限制和 标识符 的规则。

  • 不能以 v_ 开头；此前缀是针对 Vertica 系统表保留的。

AUTHORIZATIONusername
仅对超级用户有效，用于将架构的所有权分配给其他用户。默认情况下，还会为创建架构的用户分配所有权。

创建架构后，可以使用 ALTER SCHEMA 将所有权重新分配给其他用户。

DEFAULT {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES

指定是否启用或禁用指定架构中新表的默认权限继承：

  • EXCLUDE SCHEMA PRIVILEGES （默认值）：禁用架构的权限继承。

  • INCLUDE SCHEMA PRIVILEGES：指定为指定架构中的表授予的权限与为架构授予的权限相同。此选项对架构中的现有表没有影响。

如果忽略 INCLUDE PRIVILEGES，则必须显式授予所需表的架构权限。

有关详细信息，请参阅启用架构继承。

DISK_QUOTA配额
字符串，一个整数，后跟支持的单位：K、M、G 或 T。导致架构的使用率超出设置的配额的数据加载、DML 和 ILM 操作失败。有关详细信息，请参阅磁盘配额。

如果未指定，则架构没有配额。

特权

支持的子语句

CREATE SCHEMA 可以包含一个或多个子语句，例如，在新架构中创建表或投影。支持的子语句包括：

CREATE SCHEMA 语句和所有子语句均被视为单个事务。如果任何语句失败，Vertica 将回退整个事务。将为新架构的所有者分配在此事务中创建的所有对象的所有权。

例如，以下 CREATE SCHEMA 语句还将授予对新架构的权限，并创建一个表和该表的视图：

=> \c - Joan
You are now connected as user "Joan".
=> CREATE SCHEMA s1
     GRANT USAGE, CREATE ON SCHEMA s1 TO public
     CREATE TABLE s1.t1 (a varchar)
     CREATE VIEW s1.t1v AS SELECT * FROM s1.t1;
CREATE SCHEMA
=> \dtv s1.*
             List of tables
 Schema | Name | Kind  | Owner | Comment
--------+------+-------+-------+---------
 s1     | t1   | table | Joan  |
 s1     | t1v  | view  | Joan  |
(2 rows)

示例

创建架构 s1：

=> CREATE SCHEMA s1;

如果架构 s2 尚未存在，则创建此架构：

=> CREATE SCHEMA IF NOT EXISTS s2;

如果此架构已存在，Vertica 将返回回退消息：

=> CREATE SCHEMA IF NOT EXISTS s2;
NOTICE 4214:  Object "s2" already exists; nothing was done

在架构 s1 中创建表 t1，然后授予用户 Fred 和 Aniket 对所有现有表的访问权限以及对表 t1 的所有权限：


=> CREATE TABLE s1.t1 (c INT);
CREATE TABLE
=> GRANT USAGE ON SCHEMA s1 TO Fred, Aniket;
GRANT PRIVILEGE
=> GRANT ALL PRIVILEGES ON TABLE s1.t1 TO Fred, Aniket;
GRANT PRIVILEGE

启用新架构 s3 上的继承，以便在其中创建的所有表都会自动继承其权限。在这种情况下，新表 s3.t2 将继承 USAGE、CREATE 和 SELECT 权限，这些权限会自动授予所有数据库用户： => CREATE SCHEMA s3 DEFAULT INCLUDE SCHEMA PRIVILEGES; CREATE SCHEMA => GRANT USAGE, CREATE, SELECT, INSERT ON SCHEMA S3 TO PUBLIC; GRANT PRIVILEGE => CREATE TABLE s3.t2(i int); WARNING 6978: 表“t2”将包括架构“s3”的 CREATE TABLE 权限

另请参阅

5.11.28 - CREATE SEQUENCE

定义新的命名序列号生成器对象。与 AUTO_INCREMENT 和 IDENTITY 序列一样，命名序列允许您设置主键列的默认值。序列保证了唯一性，并避免了约束强制执行问题及开销。

有关序列类型及其用法的详细信息，请参阅序列。

语法

CREATE SEQUENCE [ IF NOT EXISTS ] [[database.]schema.]sequence
   [ INCREMENT [ BY ] integer ]
   [ MINVALUE integer | NO MINVALUE ]
   [ MAXVALUE maxvalue | NO MAXVALUE ]
   [ START [ WITH ] integer ]
   [ CACHE integer | NO CACHE ]
   [ CYCLE | NO CYCLE ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

序列
标识要创建的序列，其中 sequence 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
INCREMENT [BY] integer

一个正整数或负整数，指定每次调用 NEXTVAL 时序列的增减数量，默认设置为 1。

MINVALUE integer | NO MINVALUE
确定序列可生成的最小值。如果忽略此子句或指定 NO MINVALUE（默认值），则将使用默认值：升序序列和降序序列分别为 1 和 ‑263‑1。
MAXVALUE integer | NO MAXVALUE
确定序列的最大值。如果忽略此子句或指定 NO MAXVALUE（默认值），则将使用默认值：升序序列和降序序列分别为 263‑1 和 ‑1。
START [WITH] integer
将序列起始值设置为 integer。下一次调用 NEXTVAL 时将返回 integer。如果忽略此子句，则升序序列的起始值将设置为 MINVALUE，降序序列的起始值将设置为 MAXVALUE。
CACHE integer | NO CACHE
指定是否在每个节点上缓存唯一的序列号，以便提高访问速度。 CACHE 需要一个整数实参，如下所示：

  • >1 指定每个节点在每个会话中缓存的唯一编号的数量。

  • 0 或 1 指定禁用缓存（等同于 NO CACHE）。

如果忽略此子句，序列缓存将设置为 250,000。

有关命名序列缓存的详细信息，请参阅分发命名序列。

CYCLE | NO CYCLE
指定序列是否可以在达到其最小值或最大值时回绕：

  • CYCLE：序列按如下方式进行回绕：

    • 当递增序列达到其上限时，会被重置为其最小值。

    • 当递减序列达到其下限时，会被重置为其最大值。

  • NO CYCLE （默认值）：在序列达到其最大值或最小值后，调用 NEXTVAL 会返回错误。

特权

非超级用户：对架构的 CREATE 权限

示例

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

另请参阅

5.11.29 - CREATE SUBNET

标识 Vertica 数据库的节点所属的子网。使用此语句可配置从数据库到其他 Vertica 群集的导入/导出操作。

语法

CREATE SUBNET subnet-name WITH 'subnet‑prefix'

参数

subnet‑name
您分配给子网的名称，其中 subnet‑name 符合标识符中描述的约定。
subnet‑prefix
对于 IPv4 地址，子网前缀采用点分数字格式，对于 IPv6 地址，采用四个冒号分隔的四位十六进制数字。请参阅系统表 NETWORK_INTERFACES，以获取所有可用 IP 网络的前缀。

然后配置数据库，将子网用于导入/导出。有关详细信息，请参阅识别用于导入/导出的数据库或节点。

特权

超级用户

示例

=> CREATE SUBNET mySubnet WITH '123.4.5.6';
=> CREATE SUBNET mysubnet WITH 'fd9b:1fcc:1dc4:78d3::';

5.11.30 - CREATE TABLE

在逻辑架构中创建一个表。

语法

使用列定义创建：

CREATE TABLE [ IF NOT EXISTS ] [[database.]schema.]table
   ( column-definition[,...] [, table-constraint [,...]] )
   [ ORDER BY column[,...] ]
   [ segmentation-spec ]
   [ KSAFE [safety] ]
   [ partition-clause]
   [ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]
   [ DISK_QUOTA quota ]

从其他表创建：


CREATE TABLE [ IF NOT EXISTS ] [[database.]schema.]table
   { AS-clause | LIKE-clause }
   [ DISK_QUOTA quota ]

AS 子句：

[ ( column-name-list ) ]
[ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]
AS  [ /*+ LABEL */ ] [ AT {{< codevar >}}epoch{{< /codevar >}} ] query [ ENCODED BY column-ref-list ] [ segmentation-spec ]

LIKE 子句：

LIKE [[database.]schema.]existing-table
  [ {INCLUDING | EXCLUDING} PROJECTIONS ]
  [ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]

参数

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要创建的表的名称，在架构的所有序列、表、投影、视图和模型的名称中必须是唯一的。
column-definition
列名称、数据类型和可选约束。一个表最多可以有 9800 列。表中至少有一列必须是标量类型或原生数组。
table-constraint
表级别约束，与列约束相反。
ORDER BY column[,...]

对外部表无效，指定 SELECT 列表中的列，基于该列表对为此表自动创建的超投影进行排序。ORDER BY 子句不能包含限定符 ASC 或 DESC。Vertica 始终按升序存储投影数据。

如果省略 ORDER BY 子句，Vertica 将使用 SELECT 列表顺序作为投影排序顺序。

segmentation-spec

对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：

如果省略此子句，Vertica 将生成自动投影，并使用默认哈希分段。

KSAFE [safety]

对外部表无效，指定为此表创建的 自动投影的 K-safety，其中 k‑num 必须等于或大于系统 K-safety。如果您省略此选项，投影将使用系统 K-safety 水平。

partition-clause
对外部表无效，通过 PARTITION BY 子句对表数据存储进行逻辑划分： 
PARTITION BY partition-expression
  [ GROUP BY group-expression ] [ ACTIVEPARTITIONCOUNT integer ]
column-name-list

只有从查询 ( AS query) 创建表时有效，定义映射到查询输出的列名称。如果忽略此列表，Vertica 将使用查询输出列名称。

该子句和 ENCODED BY 子句互斥。列名称列表对外部表无效。

column-name-list 中的名称必须与查询列的个数相同。

例如：

CREATE TABLE customer_occupations (name, profession)
   AS SELECT customer_name, occupation FROM customer_dimension;
{INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES

默认继承此表的架构权限：

  • INCLUDE PRIVILEGES 指定在其架构上设置的表继承权限。如果启用了架构权限继承，则这是默认行为。

  • EXCLUDE PRIVILEGES 禁用从架构继承权限。

有关详细信息，请参阅继承的权限。

AS query

根据查询结果创建并加载一个表，按如下方式指定：


AS  [ /*+ LABEL */ ] [ AT {{< codevar >}}epoch{{< /codevar >}} ] query

查询不能包含复杂类型的列。

ENCODED BY column-ref-list

该列表中的列来自源表且以逗号分隔，其中每列由以下一个或两个编码选项限定：

  • ACCESSRANK integer：覆盖列的默认访问等级，对于确定列访问的优先级很有用。请参阅确定列访问速度的优先级。

  • ENCODING encoding-type: 指定要在列上使用的编码的类型。默认编码类型为“AUTO”。

此选项和 column-name-list 是互斥的。此选项对于外部表无效。

LIKE existing-table
通过复制现有表创建表。您可以使用以下选项之一限定 LIKE 子句：

  • EXCLUDING PROJECTIONS（默认值）：不要从源表中复制投影。

  • INCLUDING PROJECTIONS：从新表的源表中复制当前投影。

  • {INCLUDE|EXCLUDE} [SCHEMA] PRIVILEGES：请参阅以上描述）。

DISK_QUOTA配额
字符串，一个整数，后跟支持的单位：K、M、G 或 T。导致表的使用率超出设置的配额的数据加载、DML 和 ILM 操作失败。有关详细信息，请参阅磁盘配额。

如果未指定，则表没有配额。

特权

超级用户可以设置磁盘配额。

非超级用户：

  • 对表架构的 CREATE 权限

  • 如果创建包含命名序列的表：

    • 对于序列对象的 SELECT 权限

    • 对于序列架构的 USAGE 权限

  • 如果使用 LIKE 子句创建表，则为源表所有者

复杂类型的限制

原生表中使用的复杂类型除了其参考页面上列出的个别类型的限制外，还有一些限制：

  • 原生表必须至少有一个基本类型或原生数组（基本类型的一维数组）的列。如果一个 Flex 表有真实的列，它也必须至少有一个满足这个限制的列。

  • 复杂类型列不能在 ORDER BY 或 PARTITION BY 子句中使用，也不能用作 FILLER 列。

  • 复杂类型列不能有 约束。

  • 返回复杂类型的表达式不能用作投影列，并且投影不能按复杂类型的列进行分段或排序。

  • 具有复杂类型列的表不能使用 DEFAULT 和 SET USING。

示例

以下示例将在公共架构中创建一个表：

CREATE TABLE public.Premium_Customer
(
    ID IDENTITY ,
    lname varchar(25),
    fname varchar(25),
    store_membership_card int
);

以下示例将使用 LIKE 从该表创建一个新表：

=> CREATE TABLE All_Customers LIKE Premium_Customer;
CREATE TABLE

以下示例将使用 AS 子句从一个表中选择要在新表中使用的列：

=> CREATE TABLE cust_basic_profile AS SELECT
     customer_key, customer_gender, customer_age, marital_status, annual_income, occupation
     FROM customer_dimension WHERE customer_age>18 AND customer_gender !='';
CREATE TABLE
=> SELECT customer_age, annual_income, occupation FROM cust_basic_profile
     WHERE customer_age > 23 ORDER BY customer_age;
 customer_age | annual_income |     occupation
--------------+---------------+--------------------
           24 |        469210 | Hairdresser
           24 |        140833 | Butler
           24 |        558867 | Lumberjack
           24 |        529117 | Mechanic
           24 |        322062 | Acrobat
           24 |        213734 | Writer
           ...

以下示例将使用数组列创建一个表：

=> CREATE TABLE orders(
    orderkey    INT,
    custkey     INT,
    prodkey     ARRAY[VARCHAR(10)],
    orderprices ARRAY[DECIMAL(12,2)],
    orderdate   DATE
);

以下示例使用 ROW 复杂类型：

=> CREATE TABLE inventory
    (store INT, products ROW(name VARCHAR, code VARCHAR));

以下示例使用配额：

=> CREATE SCHEMA internal DISK_QUOTA '10T';
CREATE SCHEMA

=> CREATE TABLE internal.sales (...) DISK_QUOTA '5T';
CREATE TABLE

=> CREATE TABLE internal.leads (...) DISK_QUOTA '12T';
WARNING 0: Table leads has disk quota greater than its schema internal

另请参阅

5.11.30.1 - Column-definition

指定将应用于某一列的名称、数据类型和约束。

语法

column-name data-type
    [ column‑constraint ][...]
    [ ENCODING encoding-type ]
    [ ACCESSRANK integer ]

参数

column-name
要创建或添加的列的名称。
data-type
Vertica 支持的数据类型。
column‑constraint
Vertica 支持的约束类型，例如，NOT NULL 或 UNIQUE。有关常规信息，请参阅 约束。
ENCODING encoding-type

列编码类型，默认设置为 AUTO。

ACCESSRANK {{< codevar >}}integer{{< /codevar >}}

覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。

示例

以下示例在 Employee_Dimension 架构中创建了一个名为 public 的表，及其相关联的超投影。Employee_key 列被指定为主键，并为 Employee_gender 列定义指定了 RLE 编码。

=> CREATE TABLE public.Employee_Dimension (
    Employee_key                   integer PRIMARY KEY NOT NULL,
    Employee_gender                varchar(8) ENCODING RLE,
    Courtesy_title                 varchar(8),
    Employee_first_name            varchar(64),
    Employee_middle_initial        varchar(8),
    Employee_last_name             varchar(64)
);

5.11.30.2 - Column-name-list

用于在通过查询创建表或临时表时重命名列；还可用于指定列的编码类型和 访问等级。

语法

column-name-list
    [ ENCODING encoding‑type ]
    [ ACCESSRANK integer ]
    [ GROUPED ( column‑reference[,...] ) ]

参数

column‑name
为列指定新名称。
ENCODING encoding‑type
指定要在列上使用的编码的类型。默认编码类型为“AUTO”。
ACCESSRANK integer
覆盖列的默认访问等级，对于确定列访问的优先级很有用。请参阅确定列访问速度的优先级。
GROUPED
将两个或多个列分组。有关详细信息，请参阅 GROUPED 子句。

要求

  • 列表中的列不能指定该列的数据类型或任何约束。这些是从已查询表中派生的。

  • 如果查询输出包含表达式简单列以外的表达式（例如，常数或函数），则必须为该表达式指定别名，或者列名称列表中必须包括所有已查询列。

  • CREATE TABLE 可以在列名称列表或查询的 ENCODED BY 子句之一中指定编码类型和访问等级，但不能同时在两者中指定。例如，以下 CREATE TABLE 语句将在列名称列表中的两列上设置编码和访问等级：

    => CREATE TABLE promo1 (state ENCODING RLE ACCESSRANK 1, zip ENCODING RLE,...)
     AS SELECT * FROM customer_dimension ORDER BY customer_state;

    下一个语句在查询的 ENCODED BY 子句中指定相同的编码和访问等级。

    
=> CREATE TABLE promo2
     AS SELECT * FROM customer_dimension ORDER BY customer_state
     ENCODED BY customer_state ENCODING RLE ACCESSRANK 1, customer_zip ENCODING RLE;

5.11.30.3 - Column-constraint

为某一列的元数据添加约束。有关详细信息，请参阅约束。

语法

[ { AUTO_INCREMENT | IDENTITY } [ (args) ] ]
[ CONSTRAINT constraint‑name ] {
   [ CHECK (expression) [ ENABLED | DISABLED ] ]
   [ [ DEFAULT expression ] [ SET USING expression } | DEFAULT USING expression ]
   [ NULL | NOT NULL ]
   [ { PRIMARY KEY [ ENABLED | DISABLED ] REFERENCES table [( column )] } ]
   [ UNIQUE [ ENABLED | DISABLED ] ]
}

参数

AUTO_INCREMENT | IDENTITY
创建一个表列，其值将由数据库自动生成和管理。不能更改或加载此列中的值。只能在一个表列上设置此约束。

AUTO_INCREMENT 和 IDENTITY 是同义词。有关此约束和可选实参的详细信息，请参阅 AUTO_INCREMENT 和 IDENTITY 序列。

这些选项对临时表无效。

CONSTRAINT constraint‑name
为约束分配名称，对以下约束有效：

  • PRIMARY KEY

  • REFERENCES （外键）

  • CHECK

  • UNIQUE

如果忘记为这些约束分配名称，Vertica 会分配其自己的名称。有关详细信息，请参阅对约束进行命名。

Vertica 建议对所有约束进行命名。

CHECK (expression)
添加检查条件 expression，该条件将返回布尔值。
DEFAULT
指定此列的默认值： 
DEFAULT default‑expr

如果操作忽略了此列中的值，Vertica 将评估 DEFAULT 表达式并在加载操作时设置此列。有关有效表达式的详细信息，请参阅定义列值。

SET USING
指定通过指定的表达式设置此列中的值： 
SET USING using‑expr

仅当调用了函数 REFRESH_COLUMNS 时，Vertica 才会评估 SET USING 表达式并刷新列值。有关有效表达式的详细信息，请参阅定义列值。

DEFAULT USING
定义具有 DEFAULT 和 SET USING 约束的列，为两者指定相同的表达式。 DEFAULT USING 列支持的表达式与 SET USING 列相同，并遵从相同的限制。
NULL | NOT NULL
指定列是否可以包含 null 值：

  • NULL：允许列中出现 null 值。如果您在主键列上设置此约束，Vertica 将忽略该约束并将其设置为 NOT NULL。

  • NOT NULL：指定列在插入和更新操作期间必须设置为一个值。如果列既没有默认值，也没有为其提供值，则 INSERT 或 UPDATE 将返回错误。

如果忽略此约束，则除主键列之外的所有列的默认值将为 NULL，Vertica 始终将其设置为 NOT NULL。

外部表： 如果指定 NOT NULL 且列包含 null 值，则查询可能会返回错误或产生异常行为。仅当您确定列不包含 null 值时，再为外部表列指定 NOT NULL。

PRIMARY KEY
将此列标识为表的主键。
REFERENCES
将此列标识为外键： 
REFERENCES table [column]

其中 column 是 table 中的主键。如果省略了 column，Vertica 将引用 table 中的主键。

UNIQUE
要求列数据对于所有表行都是唯一的。

特权

表所有者或用户 WITH GRANT OPTION 是授予者。

  • 对表的 REFERENCES 权限，可创建引用此表的外键约束

  • 包含表的架构上的 USAGE 权限

强制执行约束

可以使用关键字 ENABLED 或 DISABLED 限定以下约束：

  • PRIMARY KEY

  • UNIQUE

  • CHECK

如果省略了 ENABLED 或 DISABLED，Vertica 会通过检查相应的配置参数来确定是否自动启用约束：

  • EnableNewPrimaryKeysByDefault

  • EnableNewUniqueKeysByDefault

  • EnableNewCheckConstraintsByDefault

有关详细信息，请参阅约束强制执行。

5.11.30.4 - 分区子句

通过表定义中的 PARTITION BY 子句指定表数据的分区：

PARTITION BY partition‑expression [ GROUP BY group‑expression ] [ active‑partition‑count‑expr ]
PARTITION BY partition‑expression
对于每个表行，解析为从一个或多个表列派生的分区键。
GROUP BY group‑expression
对于每个表行，解析为从分区键派生的分区组键。Vertica 使用组键将分区合并到单独的分区组中。GROUP BY 必须使用与 PARTITION BY 相同的表达式。例如： 
...PARTITION BY (i+j) GROUP BY (
     CASE WHEN (i+j) < 5 THEN 1
          WHEN (i+j) < 10 THEN 2
          ELSE 3);

有关按组对表数据进行分区的详细信息，请参阅分区分组和分层分区。

active‑partition‑count‑expr
指定此表的活动分区数量，具体如下：

  • 在 CREATE TABLE 的分区子句中：

    ACTIVEPARTITIONCOUNT integer

  • 在 ALTER TABLE 的分区子句中：

    SET ACTIVEPARTITIONCOUNT integer

此设置将取代配置参数 ActivePartitionCount。有关用法的详细信息，请参阅活动和非活动分区。

分区要求和限制

PARTITION BY 表达式可以指定叶表达式、函数和运算符。以下要求和限制适用：

  • 所有的表投影必须包含表达式引用的所有列；否则 Vertica 将无法解析表达式。
  • 表达式可以引用多个列，但是它必须在每一行解析为一个非 null 值。
  • 所有叶表达式都必须为常数或表列。
  • 所有其他表达式必须为函数和运算符。以下限制适用于函数： * 必须为 不可变，即在不同时间和区域设置以及其他会话 - 或特定环境条件下返回相同的值。 * 不可以为聚合函数。 * 不可以为 Vertica 元函数。
  • 表达式不可以包含查询。
  • 表达式不可以包含用户定义的数据类型，如 Geometry。

GROUP BY 表达式不支持 modulo (%) 运算。

示例

以下语句创建 store_orders 表并将数据加载到其中。CREATE TABLE 语句包含一个简单的分区子句，指定按年份对数据进行分区：

=> CREATE TABLE public.store_orders
(
    order_no int,
    order_date timestamp NOT NULL,
    shipper varchar(20),
    ship_date date
)
UNSEGMENTED ALL NODES
PARTITION BY YEAR(order_date);
CREATE TABLE
=> COPY store_orders FROM '/home/dbadmin/export_store_orders_data.txt';
41834

当 COPY 将新表数据加载到 ROS 存储中时，Tuple Mover 会将每年的订单划分为单独的分区，且将这些分区合并到 ROS 容器中，以执行表的分区子句。

在这种情况下，Tuple Mover 为加载的数据创建四个分区键（2017、2016、2015 和 2014），并将数据相应划分到单独的 ROS 容器中：

=> SELECT dump_table_partition_keys('store_orders');
... Partition keys on node v_vmart_node0001
  Projection 'store_orders_super'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2017
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2016
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2015
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2014

 Partition keys on node v_vmart_node0002
  Projection 'store_orders_super'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2017
...

(1 row)

当新数据加载到 store_orders 中时，Tuple Mover 会将其合并到适当的分区中，以此根据需要创建新的分区键。

另请参阅

分区表

5.11.30.5 - Table-constraint

为表元数据添加约束。您可以使用 CREATE TABLE 指定表约束，或使用 ALTER TABLE 将约束添加到现有表。有关详细信息，请参阅设置约束。

语法

[ CONSTRAINT constraint-name ]
{
... PRIMARY KEY (column[,... ]) [ ENABLED | DISABLED ]
... | FOREIGN KEY (column[,... ] ) REFERENCES table [ (column[,...]) ]
... | UNIQUE (column[,...]) [ ENABLED | DISABLED ]
... | CHECK (expression) [ ENABLED | DISABLED ]
}

参数

CONSTRAINT constraint‑name
为约束分配名称。Vertica 建议对所有约束进行命名。
PRIMARY KEY
定义一个或多个 NOT NULL 列作为主键，如下所示： 
PRIMARY KEY (column[,...]) [ ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名主键约束，Vertica 会分配名称 C_PRIMARY。

FOREIGN KEY
添加引用完整性约束，以将一个或多个列定义为外键，如下所示： 
FOREIGN KEY (column[,... ]) REFERENCES table [(column[,... ])]

如果省略了 column，Vertica 将引用 table 中的主键。

如果您没有命名外键约束，Vertica 会分配名称 C_FOREIGN。

UNIQUE
指定一个列或一组列中的数据对于所有表行都是唯一的，如下所示： 
UNIQUE (column[,...]) [ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名唯一约束，Vertica 会分配名称 C_UNIQUE。

CHECK
指定检查条件，即一个返回布尔值的表达式，如下所示： 
CHECK (expression) [ENABLED | DISABLED]

可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。

如果您没有命名检查约束，Vertica 会分配名称 C_CHECK。

权限

非超级用户：表所有者，或以下权限：

  • 对架构的 USAGE 权限

  • 对表的 ALTER 权限

  • 对表的 SELECT 权限，用于在表上启用或禁用约束实施

强制执行约束

表可以使用关键字 ENABLED 或 DISABLED 指定 Vertica 是否自动强制执行主键、唯一键或检查约束。如果省略了 ENABLED 或 DISABLED，Vertica 会通过检查相应的配置参数来确定是否自动启用约束：

  • EnableNewPrimaryKeysByDefault

  • EnableNewUniqueKeysByDefault

  • EnableNewCheckConstraintsByDefault

有关详细信息，请参阅约束强制执行。

示例

以下示例将使用主键约束创建一个表 (t01)。

CREATE TABLE t01 (id int CONSTRAINT sampleconstraint PRIMARY KEY);
CREATE TABLE

此示例没有使用约束创建相同表，然后添加约束 ALTER TABLE ADD CONSTRAINT

CREATE TABLE t01 (id int);
CREATE TABLE

ALTER TABLE t01 ADD CONSTRAINT sampleconstraint PRIMARY KEY(id);
WARNING 2623:  Column "id" definition changed to NOT NULL
ALTER TABLE

以下示例创建一个包含两列的表 (addapk)，向表中添加第三列，然后在第三列上添加主键约束。

=> CREATE TABLE addapk (col1 INT, col2 INT);
CREATE TABLE

=> ALTER TABLE addapk ADD COLUMN col3 INT;
ALTER TABLE

=> ALTER TABLE addapk ADD CONSTRAINT col3constraint PRIMARY KEY (col3) ENABLED;
WARNING 2623:  Column "col3" definition changed to NOT NULL
ALTER TABLE

使用示例表 addapk，检查是否启用了主键约束（is_enabled 为 t）。

=> SELECT constraint_name, column_name, constraint_type, is_enabled FROM PRIMARY_KEYS WHERE table_name IN ('addapk');

 constraint_name | column_name | constraint_type | is_enabled
-----------------+-------------+-----------------+------------
 col3constraint  | col3        | p               | t
(1 row)

此示例使用 ALTER TABLE ALTER CONSTRAINT 禁用约束。

=> ALTER TABLE addapk ALTER CONSTRAINT col3constraint DISABLED;

检查主键现在是否已禁用（is_enabled 为 f）。

=> SELECT constraint_name, column_name, constraint_type, is_enabled FROM PRIMARY_KEYS WHERE table_name IN ('addapk');

 constraint_name | column_name | constraint_type | is_enabled
-----------------+-------------+-----------------+------------
 col3constraint  | col3        | p               | f
(1 row)

有关约束的一般讨论，请参阅约束。有关创建和命名约束的其他示例，请参阅对约束进行命名。

5.11.31 - CREATE TEMPORARY TABLE

创建数据仅存在于当前会话中的表。默认情况下，临时表数据对其他会话不可见。

语法

使用列定义创建：

CREATE [ scope ] TEMP[ORARY] TABLE [ IF NOT EXISTS ] [[database.]schema.]table-name 
   ( column-definition[,...] )
   [ table-constraint ]
   [ ON COMMIT { DELETE | PRESERVE } ROWS ]
   [ NO PROJECTION ]
   [ ORDER BY table-column[,...] ]
   [ segmentation-spec ]
   [ KSAFE [safety-level] ]
   [ {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES ]
   [ DISK_QUOTA quota ]

从其他表创建：


CREATE TEMP[ORARY] TABLE [ IF NOT EXISTS ] [[database.]schema.]table-name
   [ ( column-name-list ) ]
   [ ON COMMIT { DELETE | PRESERVE } ROWS ]
   AS  [ /*+ LABEL */ ] [ AT {{< codevar >}}epoch{{< /codevar >}} ] query [ ENCODED BY column-ref-list ]
   [ DISK_QUOTA quota ]

参数

scope
表定义的可见性：

  • GLOBAL：表定义对所有会话可见，并且持续存在，直到显式删除了该表。

  • LOCAL：表定义仅对在其中创建该表定义的会话可见，并在会话结束后删除。

如果未指定范围，Vertica 将使用通过 DefaultTempTableLocal 配置参数设置的默认值。

不论此设置如何，都可通过 ON COMMIT DELETE 和 ON COMMIT PRESERVE 关键字（见下文）设置临时表数据的保留策略。

有关详细信息，请参阅创建临时表。

IF NOT EXISTS

如果存在同名对象，请不要创建它并继续。如果忽略此选项且对象存在，Vertica 将生成 ROLLBACK 错误消息。在上述两种情况下，如果对象已经存在，则不会创建它。

IF NOT EXISTS 子句适用于以下 SQL 脚本：可在某个对象不存在时创建该对象。

请参阅 ON_ERROR_STOP 了解相关信息。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

如果未指定架构，系统将在默认架构中创建表。

table-name
要创建的表的名称，其中 table-name 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
column-definition
列名称和类型。一个表最多可以有 9800 列。
table-constraint
为表元数据添加约束。
ON COMMIT
数据为事务范围还是会话范围数据： 
ON COMMIT {PRESERVE | DELETE} ROWS

  • DELETE（默认）会将临时表标记为事务范围数据。每次提交之后，Vertica 会移除所有表数据。

  • PRESERVE 会将临时表标记为会话范围数据，这些数据在单个事务结束后仍会保存。但会话结束后，Vertica 会移除所有表数据。

NO PROJECTION
防止 Vertica 为此表创建自动投影。仅当数据显式加载到此表中时才会创建超投影。

NO PROJECTION 对以下子句无效：

{INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES

默认继承此表的架构权限：

  • INCLUDE PRIVILEGES 指定在其架构上设置的表继承权限。如果启用了架构权限继承，则这是默认行为。

  • EXCLUDE PRIVILEGES 禁用从架构继承权限。

有关详细信息，请参阅继承的权限。

ORDER BY table-column[,...]

对外部表无效，指定 SELECT 列表中的列，基于该列表对为此表自动创建的超投影进行排序。ORDER BY 子句不能包含限定符 ASC 或 DESC。Vertica 始终按升序存储投影数据。

如果省略 ORDER BY 子句，Vertica 将使用 SELECT 列表顺序作为投影排序顺序。

segmentation-spec

对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：

如果省略此子句，Vertica 将生成自动投影，并使用默认哈希分段。

KSAFE [safety-level]

对外部表无效，指定为此表创建的 自动投影的 K-safety，其中 k‑num 必须等于或大于系统 K-safety。如果您省略此选项，投影将使用系统 K-safety 水平。

Eon 模式： 无论系统 K-safety 如何，临时表的 K-safety 始终设置为 0。如果 CREATE TEMPORARY TABLE 语句将 k‑num 设置为大于 0，Vertica 会返回警告。

column-name-list

只有从查询 ( AS query) 创建表时有效，定义映射到查询输出的列名称。如果忽略此列表，Vertica 将使用查询输出列名称。

该子句和 ENCODED BY 子句互斥。列名称列表对外部表无效。

column-name-list 中的名称必须与查询列的个数相同。

例如：

CREATE TEMP TABLE customer_occupations (name, profession)
   AS SELECT customer_name, occupation FROM customer_dimension;
AS query

根据查询结果创建并加载一个表，按如下方式指定：


AS  [ /*+ LABEL */ ] [ AT {{< codevar >}}epoch{{< /codevar >}} ] query

查询不能包含复杂类型的列。

ENCODED BYcolumn-ref-list

该列表中的列来自源表且以逗号分隔，其中每列由以下一个或两个编码选项限定：

  • ACCESSRANK integer：覆盖列的默认访问等级，对于确定列访问的优先级很有用。请参阅确定列访问速度的优先级。

  • ENCODING encoding-type: 指定要在列上使用的编码的类型。默认编码类型为“AUTO”。

此选项和 column-name-list 是互斥的。此选项对于外部表无效。

DISK_QUOTA配额
字符串，一个整数，后跟支持的单位：K、M、G 或 T。如果架构设置了配额，则此值必须小于架构配额。导致表的使用率超出设置配额的数据加载和 ILM 操作失败。有关详细信息，请参阅磁盘配额。

如果未指定，则表没有配额。

磁盘配额对全局临时表有效，对本地临时表无效。

特权

必须具有以下权限：

  • 对表架构的 CREATE 权限

  • 如果创建包含命名序列的临时表：

    • 对于序列对象的 SELECT 权限

    • 对于序列架构的 USAGE 权限

限制

  • 对临时表的查询与对持久表的查询面临相同的 SQL 支持限制。

  • 不可以将投影添加到非空的全局临时表 (ON COMMIT PRESERVE ROWS)。请确保投影在加载数据之前已存在。请参阅自动投影。

  • 尽管可以为定义时指定了 ON COMMIT DELETE ROWS 的临时表添加投影，但需要注意的是，您可能会丢失所有数据。

  • 无法对会话范围临时数据执行合并操作。

  • 一般来说，使用系统（虚拟）表时，会话范围临时表数据不可见。

  • 临时表不会恢复。如果某个节点发生故障，使用临时表的查询也会失败。重新启动会话并填充临时表。

  • 本地临时表不能设置磁盘配额。

示例

请参阅创建临时表。

另请参阅

5.11.32 - CREATE TEXT INDEX

创建用于执行文本搜索的文本索引。如果表中的数据已分区，则文本索引中会显示一个额外的列用于显示分区。

语法

CREATE TEXT INDEX [[database.]schema.]txtindex-name
 ON [schema.]source-table (unique-id, text-field [, column-name,...])
 [STEMMER {stemmer-name(stemmer-input-data-type)| NONE}]
 [TOKENIZER tokenizer-name(tokenizer-input-data-type)];

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

如果未指定架构，系统将在默认架构中创建表。

txtindex‑name
文本索引名称。
source‑table
要索引的源表。
unique‑id
源表中包含唯一标识符的列的名称。允许任何数据类型。该列必须是源表中的主键。
text‑field
源表中包含文本字段的列的名称。有效的数据类型为：

  • CHAR

  • VARCHAR

  • LONG VARCHAR

  • VARBINARY

  • LONG VARBINARY

允许 null 值。

column‑name
要作为附加列包含的一列或多列的名称。
stemmer‑name
词干分析器的名称。
stemmer‑input‑data‑type
stemmer-name 函数的输入数据类型。
tokenizer‑name
指定分词器的名称。
tokenizer‑input‑data‑type
此值为 tokenizer-name 函数的输入数据类型。可以接受任意数量的实参。

如果使用了 Vertica 分词器，则可以省略此参数。

特权

索引可自动继承其父表的查询权限。将允许表所有者和 dbadmin 创建和/或修改索引。

要求

  • 要求将具有唯一标识符的一列设置为主键。

  • 源表必须具有关联的投影，并且必须按主键进行排序和分段。

示例

以下示例显示如何使用 CREATE TEXT INDEX 语句在表 t_log 上创建附加有未索引列的文本索引：

=> CREATE TEXT INDEX t_log_index ON t_log (id, text, day_of_week);
CREATE INDEX

=> SELECT * FROM t_log_index;
        token          | doc_id | day_of_week
-----------------------+--------+-------------
'catalog               |      1 | Monday
'dbadmin'              |      2 | Monday
2014-06-04             |      1 | Monday
2014-06-04             |      2 | Monday
2014-06-04             |      3 | Monday
2014-06-04             |      4 | Monday
2014-06-04             |      5 | Monday
2014-06-04             |      6 | Monday
2014-06-04             |      7 | Monday
2014-06-04             |      8 | Monday
45035996273704966      |      3 | Tuesday
45035996273704968      |      4 | Tuesday
<INFO>                 |      1 | Tuesday
<INFO>                 |      6 | Tuesday
<INFO>                 |      7 | Tuesday
<INFO>                 |      8 | Tuesday
<WARNING>              |      2 | Tuesday
<WARNING>              |      3 | Tuesday
<WARNING>              |      4 | Tuesday
<WARNING>              |      5 | Tuesday

...

(97 rows)

以下示例显示了从已分区的源表创建的文本索引 tpart_index：

=> SELECT * FROM tpart_index;
         token          | doc_id | partition
------------------------+--------+-----------
 0                      |      4 |      2014
 0                      |      5 |      2014
 11:00:49.568           |      4 |      2014
 11:00:49.568           |      5 |      2014
 11:00:49.569           |      6 |      2014
 <INFO>                 |      6 |      2014
 <WARNING>              |      4 |      2014
 <WARNING>              |      5 |      2014
 Database               |      6 |      2014
 Execute:               |      6 |      2014
 Object                 |      4 |      2014
 Object                 |      5 |      2014
 [Catalog]              |      4 |      2014
 [Catalog]              |      5 |      2014
 'catalog               |      1 |      2013
 'dbadmin'              |      2 |      2013
 0                      |      3 |      2013
 11:00:49.568           |      1 |      2013
 11:00:49.568           |      2 |      2013
 11:00:49.568           |      3 |      2013
 11:00:49.570           |      7 |      2013
 11:00:49.571           |      8 |      2013
 45035996273704966      |      3 |      2013

...

(89 rows)

另请参阅

5.11.33 - CREATE TLS CONFIGURATION

创建 TLS CONFIGURATION 对象。有关现有 TLS CONFIGURATION 对象的信息，请查询 TLS_CONFIGURATIONS。

要修改现有的 TLS CONFIGURATION 对象，请参阅 ALTER TLS CONFIGURATION。

语法

CREATE TLS CONFIGURATION tls_config_name {
    [ CERTIFICATE { NULL | cert_name } ]
    [ CA CERTIFICATES ca_cert_name [,...] ]
    [ CIPHER SUITES { '' | 'openssl_cipher [,...]' } ]
    [ TLSMODE 'tlsmode' ]
}

参数

tls_config_name
TLS CONFIGURATION 对象的名称。
cert_name
使用 CREATE CERTIFICATE 创建的证书。
ca_cert_name
使用 CREATE CERTIFICATE 创建的 CA 证书。
openssl_cipher
要使用的密码套件的逗号分隔列表，而不是默认的密码套件集。为该参数提供空字符串会清除备用密码套件列表，并指示指定的 TLS CONFIGURATION 使用默认密码套件集。

要查看启用的密码套件，请使用 LIST_ENABLED_CIPHERS。

tlsmode
Vertica 如何建立 TLS 连接以及处理客户端证书（为以下几项之一，按安全性升序排列）：

  • DISABLE：禁用 TLS。此参数的所有其他选项都启用 TLS。

  • ENABLE：启用 TLS。Vertica 不检查客户端证书。

  • TRY_VERIFY：如果出现以下任一情况，则建立 TLS 连接：

    • 另一台主机出示有效证书

    • 另一台主机不提供证书

    如果其他主机提供无效证书，则连接将使用纯文本。

  • VERIFY_CA：如果 Vertica 验证其他主机的证书来自受信任的 CA，则连接成功。如果其他主机不提供证书，则连接使用纯文本。

  • VERIFY_FULL：如果 Vertica 验证其他主机的证书来自受信任的 CA，并且证书的 cn（通用名称）或 subjectAltName 属性与其他主机的主机名或 IP 地址匹配，则连接成功。

    请注意，对于客户端证书，cn 将用于用户名，因此 subjectAltName 必须与其他主机的主机名或 IP 地址匹配。

VERIFY_FULL 不受客户端-服务器 TLS（server TLS CONFIGURATION 上下文）支持，且行为与 VERIFY_CA 相同。

5.11.34 - CREATE USER

将名称添加到授权数据库用户列表。

语法

CREATE USER user‑name [ account‑parameter value[,...] ]

参数

user‑name
新用户的名称，其中 user‑name 符合标识符中描述的约定。
account‑parameter value
一个或多个用户帐户参数设置（见下文）。

用户帐户参数

将一个或多个用户帐户参数指定为逗号分隔的列表：

account‑parameter setting[,...]

特权

超级用户

用户名称最佳实践

Vertica 数据库用户名称在逻辑上独立于服务器运行的操作系统的用户名称。如果特定服务器中所有用户也具有服务器计算机的帐户，则有必要分配与操作系统用户名称匹配的数据库用户名称。但是，接受远程连接的服务器可能拥有许多没有本地操作系统帐户的数据库用户。在这种情况下，无需连接数据库和系统用户名称。

示例

=> CREATE USER Fred IDENTIFIED BY 'Mxyzptlk';
=> GRANT USAGE ON SCHEMA PUBLIC to Fred;

另请参阅

5.11.35 - CREATE VIEW

定义 视图。视图是只读内容，所以不支持插入、更新、删除或复制操作。

语法

CREATE [ OR REPLACE ] VIEW [[database.]schema.]view [ (column[,...]) ]
  [ {INCLUDE|EXCLUDE} [SCHEMA] PRIVILEGES ] AS query

参数

OR REPLACE
指定覆盖现有视图 view-name。如果您省略此选项并且 view-name 已经存在，则 CREATE VIEW 返回错误。

在执行 CREATE OR REPLACE 之前分配给视图的任何权限都保留在更新后的视图上。请参阅GRANT（视图）。

[database]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
标识要创建的视图，其中 view 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
列[,...]
由最多 9800 个用作视图列名称的名称组成的列表。Vertica 按照各自列表的顺序将视图列名称映射到查询列。默认情况下，视图使用在查询中指定的列名称。
query
临时视图执行的 SELECT 语句。SELECT 语句可以引用表、临时表以及其他视图。
{INCLUDE|EXCLUDE}[SCHEMA] PRIVILEGES
指定此视图是否继承架构权限：

  • INCLUDE PRIVILEGES 指定视图继承在其架构上设置的权限。如果启用了架构权限继承，则这是默认行为。

  • EXCLUDE PRIVILEGES 禁用从架构继承权限。

有关详细信息，请参阅继承的权限。

特权

请参阅创建视图。

示例

以下示例显示了如何创建包含来自多个表的数据的视图。

=> CREATE VIEW temp_t0 AS SELECT * from t0_p1 UNION ALL
     SELECT * from t0_p2 UNION ALL
       SELECT * from t0_p3 UNION ALL
         SELECT * from t0_p4 UNION ALL
           SELECT * from t0_p5;

另请参阅

5.12 - DEACTIVATE DIRECTED QUERY

停用一个或多个先前由 ACTIVATE DIRECTED QUERY 激活的定向查询。

语法

DEACTIVATE DIRECTED QUERY { query-name | input-query }

参数

query‑name
识别要停用的定向查询。若要获取定向查询的标识符，请使用 GET DIRECTED QUERY 或查询系统表 DIRECTED_QUERIES。
input‑query
要停用的定向查询的输入查询。使用此实参可停用映射到同一输入查询的多个定向查询。

特权

超级用户

5.13 - DELETE

从表中移除指定的行并返回已删除的行的计数。0 的计数并非错误，而是表示没有任何一行符合条件。未限定的 DELETE 语句（省略 WHERE 子句的语句）会移除所有行但留下完整的表列、投影和约束。

DELETE 支持子查询和联接，这样您可以基于其他表中的值删除某个表中的值。

语法

DELETE [ /*+LABEL (label‑string)*/ ]  FROM [[database.]schema.]table [ where-clause ]

参数

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
包括临时表格在内的任何表格。
where‑clause
要标记删除的行。如果省略此子句，DELETE 操作将根据永久和临时表而有所差异。有关详细信息，请参阅下文。

特权

表所有者或用户 WITH GRANT OPTION 是授予者。

  • 对表的 DELETE 权限

  • 目标表架构的 USAGE 权限

  • 当 DELETE 语句包含用于指定表列的 WHERE 或 SET 子句时，对某个表的 SELECT 权限。

限制

无法对不可变表执行 DELETE 操作。

Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。

持久表和临时表

从持久表中删除数据时，DELETE 会直接从 ROS 中移除数据。

对临时表执行的 DELETE 操作会有所不同，具体取决于表是通过 ON COMMIT DELETE ROWS（默认）还是 ON COMMIT PRESERVE ROWS 创建的：

  • 如果 DELETE 包含用于指定待移除行的 WHERE 子句，则操作是相同的：DELETE 标记待删除的行。在这两种情况下，您都无法回退到更早的保存点。

  • 如果 DELETE 省略 WHERE 子句，且该表通过 ON COMMIT PRESERVE ROWS 创建，Vertica 会标记所有待删除的表行。如果表是通过 ON COMMIT DELETE ROWS 创建的，DELETE 操作和 TRUNCATE TABLE 一样，会从存储空间中移除所有行。

示例

以下语句将从临时表中移除所有行：

=> DELETE FROM temp1;

以下语句将从满足条件的架构限定表中删除所有记录：

=> DELETE FROM retail.customer WHERE state IN ('MA', 'NH');

有关显示如何在 DELETE 语句中嵌套子查询的示例，请参阅 UPDATE 和 DELETE 中的子查询。

另请参阅

5.14 - DISCONNECT

关闭与在同一会话中使用 CONNECT TO VERTICA 打开的另一个 Vertica 数据库的连接。

语法

DISCONNECT db‑spec

参数

db‑spec
指定目标数据库，数据库名称或 DEFAULT。

特权

无

示例

=> DISCONNECT DEFAULT;
DISCONNECT

5.15 - DO

执行匿名（未命名）存储过程，但不保存。

语法

DO [ LANGUAGE 'language-name' ] $$
    source
$$;

参数

language-name
指定过程 source 的语言，为以下之一（两个选项均涉及 PLvSQL；PLpgSQL 包括在内以保持与现有脚本的兼容性）：

  • PLvSQL

  • PLpgSQL

默认值： PLvSQL

源
过程的源代码。

特权

无

示例

有关更复杂的示例，请参阅 存储过程：用例和示例

此过程将打印 DECLARE 块中的变量：

DO LANGUAGE PLvSQL $$
DECLARE
    x int := 3;
    y varchar := 'some string';
BEGIN
    RAISE NOTICE 'x = %', x;
    RAISE NOTICE 'y = %', y;
END;
$$;

NOTICE 2005:  x = 3
NOTICE 2005:  y = some string

有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。

另请参阅

5.16 - DROP 语句

DROP 语句可用于删除数据库对象，例如架构、表和用户。

5.16.1 - DROP ACCESS POLICY

从列或行中删除访问策略。

语法

DROP ACCESS POLICY ON table FOR { COLUMN column | ROWS}

参数

表
包含要移除的列访问策略的表的名称
列
包含要移除的访问策略的列的名称

特权

非超级用户：表的所有权

示例

以下这些示例展示了能够删除访问策略的各种情况。

删除列访问策略：

=> DROP ACCESS POLICY ON customer FOR COLUMN Customer_Number;

删除表的行访问策略：

=> DROP ACCESS POLICY ON customer_info FOR ROWS;

5.16.2 - DROP AGGREGATE FUNCTION

从 Vertica 编录中删除用户定义的聚合函数 (UDAnF)。

语法

DROP AGGREGATE FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arglist ] )

参数

IF EXISTS
指定当要删除的函数不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
指定要删除的 SQL 函数的名称。如果函数名称是架构限定的名称，会将函数从指定的架构中删除（如上所述）。
arglist
传递给函数的实参名称和数据类型的逗号分隔列表，格式如下： 
{ [argname] argtype }[,...]

  • argname 选择性地指定实参名称，通常是列名称。

  • argtype 指定实参的数据类型，其中 argtype 与 Vertica 数据库类型匹配。

特权

非超级用户：所有者

要求

  • 要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。

  • Vertica 不会检查依赖项，因此，如果删除其他对象（例如视图或其他 SQL 函数）所引用的 SQL 函数，Vertica 会在使用这些对象时（而非删除该函数时）返回错误。

示例

以下命令将删除 ag_avg 函数：

=> DROP AGGREGATE FUNCTION ag_avg(numeric);
DROP AGGREGATE FUNCTION

另请参阅

聚合函数 (UDAF)

5.16.3 - DROP ANALYTIC FUNCTION

从 Vertica 编录中删除用户定义的分析函数。

语法

DROP ANALYTIC FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arglist ] )

参数

IF EXISTS
指定当要删除的函数不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
指定要删除的 SQL 函数的名称。如果函数名称是架构限定的名称，会将函数从指定的架构中删除（如上所述）。
arglist
传递给函数的实参名称和数据类型的逗号分隔列表，格式如下： 
{ [argname] argtype }[,...]

  • argname 选择性地指定实参名称，通常是列名称。

  • argtype 指定实参的数据类型，其中 argtype 与 Vertica 数据库类型匹配。

特权

非超级用户：所有者

要求

  • 要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。

  • Vertica 不会检查依赖项，因此，如果删除其他对象（例如视图或其他 SQL 函数）所引用的 SQL 函数，Vertica 会在使用这些对象时（而非删除该函数时）返回错误。

示例

以下命令将删除 analytic_avg 函数：

=> DROP ANALYTIC FUNCTION analytic_avg(numeric);
DROP ANALYTIC FUNCTION

另请参阅

分析函数 (UDAnF)

5.16.4 - DROP AUTHENTICATION

删除身份验证方法。

语法

DROP AUTHENTICATION [ IF EXISTS ] auth‑method‑name [ CASCADE ]

参数

IF EXISTS
指定当要删除的身份验证方法不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
auth‑method‑name
要删除的身份验证方法的名称。
CASCADE
如果要删除的身份验证方法已授予用户，则此项为必填。在这种情况下，忽略此选项会导致删除操作失败。

特权

超级用户

示例

删除身份验证方法 md5_auth：

=> DROP AUTHENTICATION md5_auth;

使用 CASCADE 删除已授予用户的身份验证方法：

=> CREATE AUTHENTICATION localpwd METHOD 'password' LOCAL;
=> GRANT AUTHENTICATION localpwd TO jsmith;
=> DROP AUTHENTICATION localpwd CASCADE;

另请参阅

5.16.5 - DROP CA BUNDLE

删除证书颁发机构 (CA) 捆绑包。

语法

DROP CA BUNDLE [ IF EXISTS ] name [,...] [ CASCADE ]

参数

IF EXISTS
当要删除的 CA 捆绑包不存在时，Vertica 不会报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
name
CA 捆绑包的名称。
CASCADE
在删除 CA 捆绑包之前删除依赖对象。

特权

CA 捆绑包的所有权

示例

请参阅管理 CA 捆绑包。

另请参阅

5.16.6 - DROP CERTIFICATE

从数据库中删除 TLS 证书。

要查看现有证书，请查询 CERTIFICATES。

语法

DROP CERTIFICATE [ IF EXISTS ] certificate-name [,...] [ CASCADE ]

参数

IF EXISTS
当要删除的证书不存在时，Vertica 不会报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
certificate-name
要删除的证书的名称。
CASCADE
在删除证书之前删除依赖对象（例如，TLS 配置）。

特权

非超级用户，为以下之一：

  • 证书的所有权

  • 对私钥的 DROP 权限（当与 DROP KEY...CASCADE 一起使用时）

示例

删除 server_cert，如果存在：

=> DROP CERTIFICATE server_cert;
DROP CERTIFICATE;

删除 CA 证书及其依赖项（通常是它已签名的证书）：

=> DROP CERTIFICATE ca_cert CASCADE;
DROP CERTIFICATE;

另请参阅

5.16.7 - DROP DIRECTED QUERY

从数据库中删除定向查询。如果定向查询处于活动状态，Vertica 会在移除前将其停用。

语法

DROP DIRECTED QUERY directed-query-id

参数

directed‑query‑id
标识将从数据库中删除的定向查询。若要获取定向查询的标识符，请使用 GET DIRECTED QUERY 或查询系统表 DIRECTED_QUERIES。

特权

超级用户

5.16.8 - DROP FAULT GROUP

移除指定容错组及其子容错组，并会将所有节点放置在已删除容错组的父组下。

要删除所有容错组，请使用 ALTER DATABASE..DROP ALL FAULT GROUP。

要将孤立的节点添加回容错组，必须使用 CREATE FAULT GROUP 和 ALTER FAULT GROUP...ADD NODE 手动将其重新分配给新的或现有容错组。

语法

DROP FAULT GROUP [ IF EXISTS ] fault‑group

参数

IF EXISTS
指定当 fault-group 不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
fault‑group
指定要删除的容错组的名称。

特权

超级用户

示例

=> DROP FAULT GROUP group2;
DROP FAULT GROUP

另请参阅

5.16.9 - DROP FILTER

从 Vertica 编录中删除用户定义的加载筛选器函数。

语法

DROP FILTER [[database.]schema.]filter()

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

filter()
指定要删除的筛选器函数。必须在函数名称上附加空的圆括号。

特权

非超级用户：

示例

以下命令将删除 Iconverter 筛选器函数：

=> drop filter Iconverter();
DROP FILTER

另请参阅

5.16.10 - DROP FUNCTION

从 Vertica 编录中删除 SQL 函数或用户定义的函数 (UDF)。

语法

DROP FUNCTION [ IF EXISTS ] [[database.]schema.]function[,...] ( [ arg‑list ] )

参数

IF EXISTS
指定当要删除的函数不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要删除的 SQL 或用户定义函数 (UDF)，其中 UDF 可以是以下类型之一：
arg‑list

创建此函数时为其定义的以逗号分隔的实参列表，按如下方式指定：

[arg‑name] arg‑type[,...]

其中 arg-name（可选）限定 arg-type：

  • arg‑name 通常是列名称。

  • arg‑type 是 Vertica 支持的 SQL 数据类型的名称。

特权

非超级用户，为以下之一：

要求

  • 要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。

  • 删除 SQL 函数时，Vertica 不会检查依赖项，因此，如果其他对象引用 SQL 函数（例如视图或其他 SQL 函数），Vertica 只会在使用这些对象时返回错误。

示例

以下命令将删除 zerowhennull 函数，该函数在 macros 架构中：

=>  DROP FUNCTION macros.zerowhennull(x INT);
DROP FUNCTION

另请参阅

5.16.11 - DROP KEY

从数据库中删除加密密钥及其证书（如果有）。

要查看现有的加密密钥，请查询 CRYPTOGRAPHIC_KEYS。

语法

DROP KEY [ IF EXISTS ] key-name [,...] [ CASCADE ]

参数

IF EXISTS
当要删除的密钥不存在时，Vertica 不会报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
key-name
要删除的加密密钥的名称。
CASCADE
在删除密钥之前删除依赖对象。

特权

非超级用户，为以下之一：

  • 密钥的所有权

  • DROP 权限

示例

删除 k_ca，如果存在：

=> DROP KEY k_ca IF EXISTS;
DROP KEY;

删除 k_client 及其依赖项（与之关联的证书）：

=> DROP KEY k_client CASCADE;
DROP KEY;

另请参阅

5.16.12 - DROP LIBRARY

从数据库中移除 UDx 库。从 Vertica 节点上的托管目录中删除库文件。库中用户定义的函数 (UDF) 不再可用。有关详细信息，请参阅开发用户定义的扩展 (UDx)。

语法

DROP LIBRARY [ IF EXISTS ] [[database.]schema.]library [  CASCADE]

参数

IF EXISTS
仅当库存在时才执行此命令。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

库
要删除的库名称，与在 CREATE LIBRARY 中用于加载库的名称相同。
CASCADE
同时删除使用该库定义的所有函数。DROP LIBRARY 在以下情况下会失败：CASCADE 被省略，且有一个或多个 UDx 在使用目标库。

特权

可为以下之一：

示例

超级用户可以删除任何库：

=> DROP LIBRARY ml.MyLib CASCADE;

具有 UDXDEVELOPER 角色的用户可以删除其创建的库：

=> GRANT UDXDEVELOPER TO alice, bob;
GRANT ROLE

=> \c - alice;
You are now connected as user "alice".

-- Must enable the role before using:
=> SET ROLE UDXDEVELOPER;
SET

-- Create and use ml.mylib...

-- Drop library and dependencies:
DROP LIBRARY ml.mylib CASCADE;
DROP LIBRARY

可以向用户授予删除库的显式权限：

=> \c - alice
You are now connected as user "alice".

=> GRANT DROP ON LIBRARY ml.mylib to bob;
GRANT PRIVILEGE

=> \c - bob
You are now connected as user "bob".

=> SET ROLE UDXDEVELOPER;
SET

=> DROP LIBRARY ml.mylib cascade;
DROP LIBRARY

5.16.13 - DROP LOAD BALANCE GROUP

删除负载均衡组。

语法

DROP LOAD BALANCE GROUP [ IF EXISTS ] group_name [ CASCADE ]

参数

IF EXISTS
指定当要删除的负载均衡组不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
group_name
要删除的组的名称。
[CASCADE]
同时还会删除针对该组的所有负载均衡路由规则。如果未提供此关键字和一个或多个路由规则目标 group_name，此语句将失败并显示错误消息。

特权

超级用户

示例

以下语句演示了当负载均衡组具有依赖路由规则以及使用 CASCADE 关键字时会出现的错误：

=> DROP LOAD BALANCE GROUP group_all;
NOTICE 4927:  The RoutingRule catch_all depends on LoadBalanceGroup group_all
ROLLBACK 3128:  DROP failed due to dependencies
DETAIL:  Cannot drop LoadBalanceGroup group_all because other objects depend on it
HINT:  Use DROP ... CASCADE to drop the dependent objects too

=> DROP LOAD BALANCE GROUP group_all CASCADE;
DROP LOAD BALANCE GROUP

另请参阅

5.16.14 - DROP MODEL

从 Vertica 数据库中移除一个或多个模型。

语法

DROP MODEL [ IF EXISTS ] [[database.]schema.]model[,...]

参数

IF EXISTS
指定当要删除的模型不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]架构

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

模型
要删除的模型。

特权

以下几项之一：

  • 超级用户

  • 非超级用户：模型所有者

示例

请参阅删除模型。

5.16.15 - DROP NETWORK ADDRESS

从编录中删除网络地址。网络地址是节点上用于连接负载均衡策略的 IP 地址和端口的名称。

语法

DROP NETWORK ADDRESS [ IF EXISTS ] address‑name [ CASCADE ]

参数

IF EXISTS
指定当要删除的网络地址不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
address‑name
要删除的网络地址的名称。
CASCADE
从指向该网络地址的任何负载均衡组中移除该网络地址。如果未提供此关键字，且一个或多个负载均衡组包含此地址，则此语句将失败并显示错误消息。

特权

超级用户

示例

以下语句演示了当网络地址具有依赖的负载均衡组以及使用 CASCADE 关键字时会出现的错误：

=> DROP NETWORK ADDRESS node01;
NOTICE 4927:  The LoadBalanceGroup group_1 depends on NetworkInterface node01
NOTICE 4927:  The LoadBalanceGroup group_random depends on NetworkInterface node01
ROLLBACK 3128:  DROP failed due to dependencies
DETAIL:  Cannot drop NetworkInterface node01 because other objects depend on it
HINT:  Use DROP ... CASCADE to drop the dependent objects too
=> DROP NETWORK ADDRESS node01 CASCADE;
DROP NETWORK ADDRESS

5.16.16 - DROP NETWORK INTERFACE

从 Vertica 中移除网络接口。使用 CASCADE 选项还可以从节点定义中移除网络接口。（有关详细信息，请参阅识别用于导入/导出的数据库或节点。）

语法

DROP NETWORK INTERFACE [ IF EXISTS ] network‑interface‑name [ CASCADE ]

参数

参数定义如下：

IF EXISTS
指定当要删除的网络接口不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
network‑interface‑name
要移除的网络接口。
CASCADE
从所有节点定义中移除网络接口。

特权

超级用户

示例

=> DROP NETWORK INTERFACE myNetwork;

5.16.17 - DROP NOTIFIER

删除通过 CREATE NOTIFIER 创建的基于推送的通知程序。

语法

DROP NOTIFIER [ IF EXISTS ] notifier‑name

参数

IF EXISTS
指定当要删除的通知程序不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
notifier‑name
通知程序的唯一标识符。

5.16.18 - DROP PARSER

从 Vertica 编录中删除用户定义的加载解析器函数。

语法

DROP PARSER[[database.]schema.]parser()

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

parser()
要删除的解析器函数的名称。必须在函数名称上附加空的圆括号。

特权

非超级用户：

示例

=> DROP PARSER BasicIntegerParser();
DROP PARSER

另请参阅

5.16.19 - DROP PROCEDURE（外部）

仅限企业模式

从 Vertica 中移除外部过程。只会移除对 Vertica 内部过程的引用。外部文件仍保留在每个数据库节点的 database/procedures 目录中。

语法

DROP PROCEDURE [ IF EXISTS ] [[database.]schema.]procedure( [ parameter‑list ] )

参数

IF EXISTS
指定当要删除的过程不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
指定要删除的过程。
parameter‑list
为此过程定义的形式参数的逗号分隔列表，指定如下： [parameter‑name] parameter‑type[,...]

其中 parameter-name 选择性地限定 parameter-type。

特权

非超级用户：

示例

=> DROP PROCEDURE helloplanet(arg1 varchar);

另请参阅

CREATE PROCEDURE（外部）

5.16.20 - DROP PROCEDURE（存储）

删除存储过程。

语法

DROP PROCEDURE [ IF EXISTS ] [[database.]schema.]procedure( [ parameter-type-list] );

参数

IF EXISTS
指定当要删除的过程不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
存储过程的名称，其中 procedure 符合标识符中描述的约定。
parameter-type-list
IN 参数类型的逗号分隔列表。

特权

非超级用户：

  • 所有者或 DROP 权限

  • 对架构的 USAGE 权限

示例

对于下列过程：

=> CREATE PROCEDURE raiseXY(IN x INT, y VARCHAR) LANGUAGE PLvSQL AS $$
BEGIN
    RAISE NOTICE 'x = %', x;
    RAISE NOTICE 'y = %', y;
    -- some processing statements
END;
$$;

CALL raiseXY(3, 'some string');
NOTICE 2005:  x = 3
NOTICE 2005:  y = some string

您可以使用以下命令进行删除：

=> DROP PROCEDURE raiseXY(INT, VARCHAR);
DROP PROCEDURE

有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。

另请参阅

5.16.21 - DROP PROFILE

从数据库中移除用户定义的配置文件（通过 CREATE PROFILE 创建）。不能删除 DEFAULT 配置文件。

语法

DROP PROFILE [ IF EXISTS ] profile‑name[,...] [ CASCADE ]

参数

IF EXISTS
指定当要删除的配置文件不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
profile‑name
要删除的配置文件。
CASCADE
将分配给已删除的配置文件的所有用户转移给 DEFAULT 配置文件。如果忽略此选项，且目标配置文件分配有用户，Vertica 将返回错误。

特权

超级用户

示例

=> DROP PROFILE sample_profile;

5.16.22 - DROP PROJECTION

屏蔽要从编录中删除的 投影，以便该投影不可供用户查询。

语法

DROP PROJECTION [ IF EXISTS ] { [[database.]schema.]projection[,...] } [ RESTRICT | CASCADE ]

参数

IF EXISTS
指定当要删除的投影不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

projection
指定要删除的投影：

  • 如果投影未分段，则将删除数据库群集中的所有投影副本。

  • 如果投影已分段，则将通过指定投影基本名的方式删除所有伙伴实例投影。您也可以指定具体的伙伴投影名称，但前提是如此删除该伙伴实例投影不会违反系统 K-safety。

有关投影名称约定，请参阅投影命名。

RESTRICT | CASCADE
指定在投影包含对象的情况下是否将其删除：

  • RESTRICT （默认值）：仅在投影不包含任何对象的情况下将其删除。

  • CASCADE：即便投影包含对象，仍将其删除。

特权

非超级用户：锚表的所有者

限制

投影删除操作有以下限制：

  • 投影不能是锚表的 超投影。

  • 以下情况不能删除伙伴实例投影：删除该伙伴实例投影违反系统 K-safety。

  • 必须有另一个投影可用于强制执行相同主键或唯一键约束。

另请参阅

5.16.23 - DROP RESOURCE POOL

删除用户创建的资源池。分配给此池的所有内存都将返回到 GENERAL 池。

语法

DROP RESOURCE POOL pool-name [ FOR subcluster-spec ]

参数

pool-name
指定要删除的资源池。
FOR subcluster‑spec
仅适用于 Eon 模式，从指定的子群集中删除此资源池，其中 subcluster-spec 为以下几项之一：
  • SUBCLUSTER subcluster-name：从已命名子群集中删除 pool‑name。您不能连接到此子群集，否则 Vertica 会返回错误。
  • CURRENT SUBCLUSTER：从连接到的子群集中删除 pool‑name。

如果省略此参数，将从所有子群集中删除资源池。如果为单个子群集创建了资源池，则必须指定此参数以将资源池从该子群集中显式删除；否则，Vertica 将返回错误。

特权

超级用户

如果您尝试删除的资源池是另一个资源池的辅助池，则 Vertica 会返回一个错误。该错误会列出与您尝试删除的辅助池有关的资源池。要删除辅助资源池，首先在主要资源池上将 CASCADE TO 参数设置为 DEFAULT，然后再删除辅助池。

例如，可以删除资源池 rp2，它是 rp1 的辅助池，如下：

=> ALTER RESOURCE POOL rp1 CASCADE TO DEFAULT;
=> DROP RESOURCE POOL rp2;

传输资源请求

按照该池对比于 GENERAL 池的优先级，队列中对该池的请求将全部传输给 GENERAL 池。如果该池的优先级高于 GENERAL 池，则这些请求将放置在队列列首；否则，这些请求将放置在队列列尾。

正在使用该池的用户将收到通知，通知其改为使用 GENERAL 池：

NOTICE:  Switched the following users to the General pool: username

如果用户不具备使用 GENERAL 池的权限，DROP RESOURCE POOL 会返回错误。现有会话将传输给 GENERAL 池，而无论会话的用户是否具备使用 GENERAL 池的权限。如果正在删除的池的限制级别较 GENERAL 池高，这一会话传输过程会导致需要更多用户权限。为避免赋予用户更多特权，请按照以下步骤删除受限池：

  1. 针对所有用户调用池权限。

  2. 关闭对池有权限的所有会话。

  3. 删除资源池。

示例

此示例将删除用户定义的资源池：

=> DROP RESOURCE POOL ceo_pool;

此 Eon 模式示例返回了当前子群集，然后删除了当前子群集的用户定义资源池：

=> SELECT CURRENT_SUBCLUSTER_NAME();
 CURRENT_SUBCLUSTER_NAME
-------------------------
 analytics_1
(1 row)

=> DROP RESOURCE POOL dashboard FOR CURRENT SUBCLUSTER;
DROP RESOURCE POOL

另请参阅

5.16.24 - DROP ROLE

从数据库中删除角色。

语法

DROP ROLE [ IF EXISTS ] role‑name[,...] [ CASCADE ]

参数

IF EXISTS
指定当要删除的角色不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
role‑name
要删除的角色名称
CASCADE
删除角色前先自用户或其他角色调用该角色

特权

超级用户

示例

=> DROP ROLE appadmin;
NOTICE:  User bob depends on Role appadmin
ROLLBACK:  DROP ROLE failed due to dependencies
DETAIL:  Cannot drop Role appadmin because other objects depend on it
HINT:  Use DROP ROLE ... CASCADE to remove granted roles from the dependent users/roles
=> DROP ROLE appadmin CASCADE;
DROP ROLE

另请参阅

5.16.25 - DROP ROUTING RULE

从编录中删除路由规则。

语法

DROP ROUTING RULE [ IF EXISTS ] rule‑name

参数

IF EXISTS
指定当要删除的路由规则不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
rule‑name
要删除的规则的名称。

特权

超级用户

示例

=> DROP ROUTING RULE internal_clients;
DROP ROUTING RULE

5.16.26 - DROP SCHEMA

从数据库中永久删除架构。由于 DROP SCHEMA 是一个不可逆的过程，因此在删除架构前，请务必先确认您确实想要删除该架构。使用 CASCADE 参数可删除包含一个或多个对象的架构。

语法

DROP SCHEMA [ IF EXISTS ] [database.]schema[,...] [ CASCADE | RESTRICT ]

参数

IF EXISTS
指定当要删除的架构不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]架构
要删除的数据库的名称。如果指定一个数据库，它必须是当前数据库。
CASCADE
指定删除架构及其中的所有对象，而不考虑这些对象的所有者。
RESTRICT
仅当架构为空时将其删除（默认）。

特权

非超级用户：架构所有者

限制

  • 不能删除 PUBLIC 架构。

  • 如果有用户正在访问正在删除的架构中的对象，则在该事务完成前，不会删除该架构。

  • 取消 DROP SCHEMA 语句可能导致无法预见的结果。

示例

以下示例将删除架构 S1，但前提是该架构不包含任何对象：

=> DROP SCHEMA S1;

以下示例将删除架构 S1，而无论其包含架构与否：

=> DROP SCHEMA S1 CASCADE;

5.16.27 - DROP SEQUENCE

移除指定的命名序列号生成器。

语法

DROP SEQUENCE [ IF EXISTS ] [[database.]schema.]sequence[,...]

参数

IF EXISTS
指定当要删除的序列不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

序列
要删除的序列的名称。

特权

非超级用户：序列或架构所有者

限制

  • 对于在表的默认表达式中指定的序列，在您下次尝试加载数据时，默认表达式会执行失败。Vertica 不会检查这些实例。

  • DROP SEQUENCE 不支持 CASCADE 关键字。如果序列用在列的默认表达式中，那么在从默认表达式中删除对序列的所有引用之前，不能删除该序列。

示例

以下命令将删除名为 sequential 的序列。

=> DROP SEQUENCE sequential;

另请参阅

5.16.28 - DROP SOURCE

从 Vertica 编录中删除用户定义的加载源函数。

语法

DROP SOURCE [[database.]schema.]source()

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

source()
指定要删除的源函数。必须在函数名称上附加空的圆括号。

特权

非超级用户：

示例

以下命令将删除 curl 源函数：

=> DROP SOURCE curl();
DROP SOURCE

另请参阅

5.16.29 - DROP SUBNET

从 Vertica 中移除子网。

语法

DROP SUBNET [ IF EXISTS ] subnet‑name[,...] [ CASCADE ]

参数

参数定义如下：

IF EXISTS
指定当要删除的子网不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
subnet‑name
要移除的子网。
CASCADE
从所有数据库定义中移除指定的子网。

特权

超级用户

示例

=> DROP SUBNET mySubnet;

另请参阅

识别用于导入/导出的数据库或节点

5.16.30 - DROP TABLE

移除一个或多个表及其 投影。当您运行 DROP TABLE 时，更改会自动提交。

语法

DROP TABLE [ IF EXISTS ] [ [database.]schema.]table[,...] [ CASCADE ]

参数

IF EXISTS
指定当要删除的一个或多个表不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要删除的表。
CASCADE
指定删除目标表的所有投影。 CASCADE 可选，如果目标表只有自动投影。如果忽略此选项且任何表具有非超投影集，Vertica 将返回错误并回退整个删除操作。

此选项对外部表无效。

特权

非超级用户：

要求

  • 请勿取消正在执行的 DROP TABLE。这样会导致数据库不一致。

  • 请检查确定目标表不在使用中，无论是直接使用还是间接使用——例如，在视图中。

  • 如果删除然后恢复被某视图引用的表，新表必须具有相同的名称和列定义。

示例

请参阅 删除表

另请参阅

5.16.31 - DROP TEXT INDEX

删除用于执行文本搜索的文本索引。

语法

DROP TEXT INDEX [ IF EXISTS ] [[database.]schema.]idx‑table

参数

IF EXISTS
指定当要删除的文本索引不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

idx‑table
指定文本索引名称。当使用多个架构时，指定在 DROP TEXT INDEX 语句中包含该索引的架构。

特权

  • dbadmin

  • 表所有者

  • 对于源表的 DROP 权限

示例

=> DROP TEXT INDEX t_text_index;
DROP INDEX

另请参阅

5.16.32 - DROP TLS CONFIGURATION

删除现有的 TLS CONFIGURATION。

如果将 TLS 配置设置为配置参数，则无法删除。有关详细信息，请参阅TLS 配置。

语法

DROP TLS CONFIGURATION tls_config_name

参数

tls_config_name
要删除的 TLS CONFIGURATION 对象的名称。

特权

非超级用户，为以下之一：

5.16.33 - DROP TRANSFORM FUNCTION

从 Vertica 编录中删除用户定义的转换函数 (UDTF)。

语法

DROP TRANSFORM FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arg‑list ] )

参数

IF EXISTS
指定当要删除的函数不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
指定要删除的转换函数。
arg‑list

创建此函数时为其定义的以逗号分隔的实参列表，按如下方式指定：

[arg‑name] arg‑type[,...]

其中 arg-name（可选）限定 arg-type：

  • arg‑name 通常是列名称。

  • arg‑type 是 Vertica 支持的 SQL 数据类型的名称。

特权

以下几项之一：

示例

以下命令将删除 tokenize UDTF，该 UDTF 在 macros 架构中：

=> DROP TRANSFORM FUNCTION macros.tokenize(varchar);
DROP TRANSFORM FUNCTION

以下命令将删除 Pagerank多态函数，该函数在 online 架构中：

=> DROP TRANSFORM FUNCTION online.Pagerank();
DROP TRANSFORM FUNCTION

另请参阅

CREATE TRANSFORM FUNCTION

5.16.34 - DROP USER

从授权数据库用户列表中删除一个名称。

语法

DROP USER [ IF EXISTS ] user‑name[,...] [ CASCADE ]

参数

IF EXISTS
当要删除的用户不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
user‑name
要删除的用户的名称。
CASCADE
删除通过 user‑name 创建的所有用户定义的对象，包括架构、表和引用该表的所有视图，以及该表的投影。

特权

超级用户

示例

当用户定义的对象不存在时，DROP USER 将成功：

=> CREATE USER user2;
CREATE USER
=> DROP USER IF EXISTS user2;
DROP USER

当用户创建的对象仍然存在时，DROP USER 将失败：

=> DROP USER IF EXISTS user1;
NOTICE:  Table T_tbd1 depends on User user1
ROLLBACK:  DROP failed due to dependencies
DETAIL:  Cannot drop User user1 because other objects depend on it
HINT:  Use DROP ... CASCADE to drop the dependent objects too

无论用户定义的对象是否存在，DROP USER CASCADE 均可成功。该语句会强制删除所有用户定义的对象，如架构、表及其关联投影：

=> DROP USER IF EXISTS user1 CASCADE;
DROP USER

另请参阅

5.16.35 - DROP VIEW

删除指定视图。Vertica 不会检查删除的视图的依赖项。删除视图后，引用该视图的其他视图将出现故障。

如果删除视图，并将其替换为具有相同名称和列名称的其他视图或表，则引用该名称的其他视图将使用新视图。如果更改新视图中的列数据类型，则服务器会将旧数据类型强制转换为新类型（如果可行）；否则将返回错误。

语法

DROP VIEW [ IF EXISTS ] [[database.]schema.]view[,...]

参数

IF EXISTS
指定当要删除的视图不存在时不报告错误。 在 SQL 脚本中使用此子句，可避免在尝试创建不存在的对象之前删除它们时出错。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
要删除的视图的名称。

特权

为以下几项之一

  • 视图所有者和 USAGE 权限

  • 架构所有者

示例

=> DROP VIEW myview;

5.17 - END

结束当前事务，使事务期间发生的所有变更永久化且对其他用户可见。

语法

END [ WORK | TRANSACTION ]

参数

WORK | TRANSACTION
不起任何作用的可选关键字，仅为了可读性。

特权

无

示例

=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
BEGIN
=> CREATE TABLE sample_table (a INT);
CREATE TABLE
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)

=> END;
COMMIT

另请参阅

5.18 - EXPLAIN

返回 Vertica 用于执行特定语句的优化器计划的格式化描述。

语法

EXPLAIN [/*+ ALLNODES */] [explain-options] sql-statement

参数

/*+ALLNODES*/
指定创建一个查询计划，该计划假设所有节点均为激活状态，对 LOCAL 选项无效。
explain‑options
一个或多个 EXPLAIN 选项，按所示顺序指定： 
[ LOCAL ] [ VERBOSE ] [ JSON ] [ ANNOTATED ]

  • LOCAL：在多节点数据库中，显示分配给每一节点的本地查询计划，它们共同组成整个（全球）查询计划。如果您忽略此选项，Vertica 将仅显示全局查询计划。本地查询计划仅以 DOT 语源显示，在 Graphviz 中呈现。

    此选项与提示 /*+ALL NODES*/ 不兼容。如果您同时指定两者，EXPLAIN 将返回错误。

  • VERBOSE：增加呈现的查询计划的详细程度。

  • JSON：以 JSON 格式呈现查询计划。此选项仅与 VERBOSE 兼容。

  • ANNOTATED：嵌入用于封装此查询的查询计划的优化器提示。Vertica 使用这些提示来创建定向查询。有关详细信息，请参阅定向查询。此选项与 LOCAL 和 VERBOSE 兼容。

sql‑statement
查询或 DML 语句—例如， SELECT、 INSERT、 UPDATE、 COPY 和 MERGE。

特权

指定语句要求的同一特权。

要求

以下要求适用于 EXPLAIN 的作用，用于产生有用信息：

  • 必须提供您数据中的具有合理代表性的统计信息。有关详细信息，请参阅收集统计信息。

  • EXPLAIN 仅在可以为被查询的表提供投影时产生有用输出。

  • 必须按之前显示的顺序指定限定符选项，否则 EXPLAIN 将返回错误。如果某个选项与前面的任何选项均不兼容，EXPLAIN 将忽略这些选项。

示例

请参阅查看查询计划。

5.19 - EXPORT TO DELIMITED

将表、表中的列或查询结果导出到分隔文件。可以使用 DELIMITED 读回文件。某些导出器参数具有相应的解析器参数，可用于更改分隔符、空指示符和其他格式。

您可以在导出语句中使用的查询有一些限制。请参阅查询限制。

您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。

此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。

在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。

语法

EXPORT [ /*+LABEL (label-string)*/ ] TO DELIMITED ( directory=path[, param=value [,...] ]
   [ OVER (over-clause ) ] AS SELECT query-expression

参数

LABEL
将标签分配到语句，以便您可以在分析和调试时识别它。
over-clause
指定如何使用 PARTITION BY 对表数据进行分区。在分区内，您可以使用 ORDER BY 进行排序。请参阅SQL 分析。该子句可能包含列引用，但不包含表达式。

如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。

如果省略此子句，Vertica 会优化最大并行度。

query-expression
指定要导出的数据。有关重要限制，请参阅查询限制。

参数

directory

输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：

filename

如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。

addHeader
布尔值，指定是否在每个文件的开头添加标题行。

默认值：false

delimiter
列分隔符。要根据 RFC 4180 生成 CSV，请将分隔符设置为 ,（逗号）。

默认值： |（垂直条）

recordTerminator
用于标记记录结尾的字符。

默认值： \n

enclosedBy
用于将字符串和日期/时间数据括起来的字符。如果省略此参数，将不会使用字符将这些数据类型括起来。

默认值： ''（空字符串）

escapeAs
用于转义导出数据中必须转义的值的字符，包括 enclosedBy 值。

默认值： \\（反斜杠）

nullAs
用于表示数据中的 null 值的字符串。如果包含此参数，导出器会将所有 null 值导出为此值。否则，导出器会将 null 值导出为长度为零的字符串。
binaryTypesFormat
导出的二进制数据类型（BINARY、VARBINARY 和 LONG VARBINARY）值的格式，为以下几项之一：

  • Default：可打印的 ASCII 字符（如果可能）和不可打印字节的已转义八进制表示。DELIMITED 解析器将读取此格式。

  • Hex：Base 16（十六进制）表示；值前面为“0x”，且字节不会被转义。

  • Octal：Base 8（八进制）表示，未转义。

  • Bitstring：二进制表示，未转义。

例如，可以将值 a\000b\001c 导出为如下格式：

  • 默认（假设 \\ 的转义字符为）： a\\\000b\\\001c

  • 十六进制： 0x6100620163

  • 八进制： 141000142001143

  • 位字符串： 0110000100000000011000100000000101100011

compression
压缩类型，为以下几项之一：

  • Uncompressed

  • BZip

  • GZip

默认值： 未压缩

fileExtension
输出文件扩展名。如果使用压缩，则会附加一个特定于压缩的扩展，例如 .bz2。

默认值： csv

fileSizeMB

单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。

此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。

默认值： 10GB

fileMode

仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或 user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。

有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。

dirMode

仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。

特权

非超级用户：

  • 源表：SELECT

  • 源表架构：USAGE

  • 目标目录：写入

查询限制

必须为作为表达式的选定列目标提供别名列标签。

如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。

查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：

=> EXPORT TO DELIMITED(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT 1 as account_id, '{}' as json, 0 hash
   UNION ALL
   SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975:  Only a single outer SELECT statement is supported
HINT:  Please use a subquery for multiple outer SELECT statements

而需要重写查询以使用子查询：

=> EXPORT TO DELIMITED(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT
    account_id,
    json
   FROM
   (
     SELECT 1 as account_id, '{}' as json, 0 hash
     UNION ALL
     SELECT 2 as account_id, '{}' as json, 1 hash
   ) a;
 Rows Exported
---------------
             2
(1 row)

要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。

数据类型

此操作将原始 Flex 列导出为二进制数据。

输出

导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。

输出文件名遵循以下模式： [8-character-hash]-[nodename]-[thread-id].fileExtension.

分区目录中的列名采用小写。

由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。

具有以下要求和限制：

  • 避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。

  • 使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。

  • 要输出到本地文件系统，您必须有一个 USER 存储位置。

  • 导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。

有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。

示例

以下示例导出未压缩的逗号分隔值 (CSV)，每个文件中都有一个标题行：

=> EXPORT TO DELIMITED(directory='webhdfs:///user1/data', delimiter=',', addHeader='true')
  AS SELECT * FROM public.sales;

5.20 - EXPORT TO JSON

将表、表中的列或查询结果导出到 JSON 文件。可以使用 FJSONPARSER 将文件读回 Vertica。

您可以在导出语句中使用的查询有一些限制。请参阅查询限制。

您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。

此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。

在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。

语法


EXPORT [ /*+LABEL (label)*/ ] TO JSON ( directory=path[, param=value [,...] ]
   [ OVER (over-clause ) ] AS SELECT query-expression

参数

LABEL
将标签分配到语句，以便您可以在分析和调试时识别它。
over-clause
指定如何使用 PARTITION BY 对表数据进行分区。在分区内，您可以使用 ORDER BY 进行排序。请参阅SQL 分析。该子句可能包含列引用，但不包含表达式。

如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。

如果省略此子句，Vertica 会优化最大并行度。

query-expression
指定要导出的数据。有关重要限制，请参阅查询限制。

参数

directory

输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：

filename

如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。

omitNullFields
布尔值，是否忽略值为 null 的 ROW 字段。

默认值：false

compression
压缩类型，为以下几项之一：

  • Uncompressed

  • BZip

  • GZip

默认值： 未压缩

fileSizeMB

单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。

此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。

默认值： 10GB

fileMode

仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或 user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。

有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。

dirMode

仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。

特权

非超级用户：

  • 源表：SELECT

  • 源表架构：USAGE

  • 目标目录：写入

查询限制

必须为作为表达式的选定列目标提供别名列标签。

如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。

查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：

=> EXPORT TO JSON(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT 1 as account_id, '{}' as json, 0 hash
   UNION ALL
   SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975:  Only a single outer SELECT statement is supported
HINT:  Please use a subquery for multiple outer SELECT statements

而需要重写查询以使用子查询：

=> EXPORT TO JSON(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT
    account_id,
    json
   FROM
   (
     SELECT 1 as account_id, '{}' as json, 0 hash
     UNION ALL
     SELECT 2 as account_id, '{}' as json, 1 hash
   ) a;
 Rows Exported
---------------
             2
(1 row)

要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。

数据类型

EXPORT TO JSON 可以以任意组合导出 ARRAY 和 ROW 类型。

EXPORT TO JSON 不支持二进制输出 (VARBINARY)。

输出

导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。

输出文件名遵循以下模式： [8-character-hash]-[nodename]-[thread-id].json.

分区目录中的列名采用小写。

由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。

具有以下要求和限制：

  • 避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。

  • 使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。

  • 要输出到本地文件系统，您必须有一个 USER 存储位置。

  • 导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。

有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。

示例

在以下示例中，ROW 元素之一包含 null 值，该值将在输出中被忽略。EXPORT TO JSON 将每条 JSON 记录写入一行；为了便于阅读，已在以下输出中插入了换行符：

=> SELECT name, menu FROM restaurants;
       name        |                                     menu

-------------------+------------------------------------------------------------
------------------
 Bob's pizzeria    | [{"item":"cheese pizza","price":null},{"item":"spinach pizza","price":10.5}]
 Bakersfield Tacos | [{"item":"veggie taco","price":9.95},{"item":"steak taco","price":10.95}]
(2 rows)

=> EXPORT TO JSON (directory='/output/json', omitNullFields=true)
   AS SELECT * FROM restaurants;
 Rows Exported
---------------
             2
(1 row)

=> \! cat /output/json/*.json
{"name":"Bob's pizzeria","cuisine":"Italian","location_city":["Cambridge","Pittsburgh"],
 "menu":[{"item":"cheese pizza"},{"item":"spinach pizza","price":10.5}]}
{"name":"Bakersfield Tacos","cuisine":"Mexican","location_city":["Pittsburgh"],
 "menu":[{"item":"veggie taco","price":9.95},{"item":"steak taco","price":10.95}]}

5.21 - EXPORT TO ORC

将表、表中的列或查询结果以 ORC 格式导出到文件。

可以在导出前使用 OVER() 子句对数据进行分区。除了导出列数据之外，还可以对数据进行分区。对数据进行分区可启用分区修剪，从而提高查询性能。请参阅分区文件路径。

您可以在导出语句中使用的查询有一些限制。请参阅查询限制。

您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。

此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。

在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。

语法


EXPORT [ /*+LABEL (label-string)*/ ] TO ORC ( directory=path[, param=value [,...] ] )
   [ OVER (over-clause ) ] AS SELECT query-expression

参数

LABEL
将标签分配到语句，以便您可以在分析和调试时识别它。
over-clause
指定如何使用 PARTITION BY 对表数据进行分区。在分区内，您可以使用 ORDER BY 进行排序。请参阅SQL 分析。该子句可能包含列引用，但不包含表达式。

如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。

如果省略此子句，Vertica 会优化最大并行度。

query-expression
指定要导出的数据。有关重要限制，请参阅查询限制。

参数

directory

输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：

filename

如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。

compression
列压缩类型，为以下几项之一：

  • Zlib

  • Uncompressed

默认值： Zlib

stripeSizeMB
导出的带区的未压缩大小 (MB)，为 1 至 1024 （包含）之间的整数值。

默认值： 250

rowIndexStride
用于指定导出器在输出中构建索引统计信息的频率，为 1 至 1000000（100 万）（包含）之间的整数。值为 0 表示禁用索引。导出器在每个带区中的每个 rowIndexStride 行之后构建统计信息，或者为带区 < rowIndexStride 构建一次统计信息。

默认值： 1000

fileSizeMB

单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。

此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。

默认值： 10GB

fileMode

仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或 user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。

有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。

dirMode

仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。

特权

非超级用户：

  • 源表：SELECT

  • 源表架构：USAGE

  • 目标目录：写入

查询限制

必须为作为表达式的选定列目标提供别名列标签。

如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。

查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：

=> EXPORT TO ORC(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT 1 as account_id, '{}' as json, 0 hash
   UNION ALL
   SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975:  Only a single outer SELECT statement is supported
HINT:  Please use a subquery for multiple outer SELECT statements

而需要重写查询以使用子查询：

=> EXPORT TO ORC(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT
    account_id,
    json
   FROM
   (
     SELECT 1 as account_id, '{}' as json, 0 hash
     UNION ALL
     SELECT 2 as account_id, '{}' as json, 1 hash
   ) a;
 Rows Exported
---------------
             2
(1 row)

要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。

数据类型

EXPORT TO ORC 将 Vertica 数据类型转换为 Hive 数据类型，如下表所示。

小数精度必须为 <= 38。

导出的 Hive 类型可能与 Vertica 类型不同。例如，Vertica INT 导出为 Hive BIGINT。在定义 Hive 外部表以读取导出的数据时，可能必须要调整列定义。

此操作将原始 Flex 列导出为二进制数据。

输出

导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。

输出文件名遵循以下模式： [8-character-hash]-[nodename]-[thread-id].orc.

分区目录中的列名采用小写。

由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。

具有以下要求和限制：

  • 避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。

  • 使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。

  • 要输出到本地文件系统，您必须有一个 USER 存储位置。

  • 导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。

有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。

示例

以下示例演示了数据的分区和导出操作。EXPORT TO ORC 首先对区域上的数据进行分区，然后在每个分区内按存储进行排序。

=> EXPORT TO ORC(directory='gs://DataLake/user2/data')
  OVER(PARTITION BY store.region ORDER BY store.ID)
  AS SELECT sale.price, sale.date, store.ID
  FROM public.sales sale
  JOIN public.vendor store ON sale.distribID = store.ID;

有关更多示例，请参阅 EXPORT TO PARQUET，该语句（某些参数除外）操作与 EXPORT TO ORC 相同。

5.22 - EXPORT TO PARQUET

将表、表中的列或查询结果以 Parquet 格式导出到文件。

可以在导出前使用 OVER() 子句对数据进行分区。除了导出列数据之外，还可以对数据进行分区。对数据进行分区可启用分区修剪，从而提高查询性能。请参阅分区文件路径。

您可以在导出语句中使用的查询有一些限制。请参阅查询限制。

您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。

此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。

在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。

导出数据后，您可以使用 GET_METADATA 函数检查结果。

语法


EXPORT [ /*+LABEL (label-string)*/ ] TO PARQUET ( directory=path[, param=value [,...] ] )
   [ OVER (over-clause ) ] AS SELECT query-expression

参数

LABEL
将标签分配到语句，以便您可以在分析和调试时识别它。
over-clause
指定如何使用 PARTITION BY 对表数据进行分区。在分区内，您可以使用 ORDER BY 进行排序。请参阅SQL 分析。该子句可能包含列引用，但不包含表达式。

如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。

如果省略此子句，Vertica 会优化最大并行度。

query-expression
指定要导出的数据。有关重要限制，请参阅查询限制。

参数

directory

输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：

filename

如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。

compression
列压缩类型，为以下几项之一：

  • Snappy

  • GZIP

  • Brotli

  • ZSTD

  • Uncompressed

默认值： Snappy

rowGroupSizeMB
导出的行组的未压缩大小 (MB)，为 1 至 fileSizeMB（包含）之间的整数值，如果 fileSizeMB 为 0，则为无限制。

导出文件中的行组小于此值，因为 Parquet 文件在写入时被压缩。为了在导出到 HDFS 时获得最佳性能，请将 size 设置为小于 HDFS 块大小。

行组大小会影响导出时的内存消耗。导出线程至少使用两倍的行组大小。默认值 512MB 是在写入更大行组和允许其他 Vertica 操作有足够可用内存之间进行折衷。如果您在数据库负载不重时执行导出，则可以通过增加导出的行组大小来提高导出数据的读取性能。但是，跨 HDFS 上的多个块的行组会因需要更多 I/O 而降低读取性能，因此请不要将行组大小设置为大于 HDFS 块大小。

默认值： 512

fileSizeMB

单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。

此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。

默认值： 10GB

fileMode

仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或 user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。

有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。

dirMode

仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。

将文件写入 HDFS 以外的任何目标位置时，此参数无效。

默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。

int96AsTimestamp
布尔值，指定将时间戳导出为 int96 物理类型 (true) 还是 int64 物理类型 (false)。

默认值：true

特权

非超级用户：

  • 源表：SELECT

  • 源表架构：USAGE

  • 目标目录：写入

查询限制

必须为作为表达式的选定列目标提供别名列标签。

如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。

查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：

=> EXPORT TO PARQUET(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT 1 as account_id, '{}' as json, 0 hash
   UNION ALL
   SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975:  Only a single outer SELECT statement is supported
HINT:  Please use a subquery for multiple outer SELECT statements

而需要重写查询以使用子查询：

=> EXPORT TO PARQUET(directory = '/mnt/shared_nfs/accounts/rm')
   OVER(PARTITION BY hash)
   AS
   SELECT
    account_id,
    json
   FROM
   (
     SELECT 1 as account_id, '{}' as json, 0 hash
     UNION ALL
     SELECT 2 as account_id, '{}' as json, 1 hash
   ) a;
 Rows Exported
---------------
             2
(1 row)

要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。

数据类型

EXPORT TO PARQUET 将 Vertica 数据类型转换为 Hive 数据类型，如下表所示。

小数精度必须为 <= 38。

导出的 Hive 类型可能与 Vertica 类型不同。例如，Vertica INT 导出为 Hive BIGINT。在定义 Hive 外部表以读取导出的数据时，可能必须要调整列定义。

此操作将原始 Flex 列导出为二进制数据。

输出

导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。

输出文件名遵循以下模式： [8-character-hash]-[nodename]-[thread-id].parquet.

分区目录中的列名采用小写。

由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。

具有以下要求和限制：

  • 避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。

  • 使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。

  • 要输出到本地文件系统，您必须有一个 USER 存储位置。

  • 导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。

有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。

示例

以下示例演示了如何使用 GZIP 压缩从公共架构的 T1 表中导出所有列。

=> EXPORT TO PARQUET(directory='webhdfs:///user1/data', compression='gzip')
  AS SELECT * FROM public.T1;

以下示例演示了如何使用多个表导出查询结果。

=> EXPORT TO PARQUET(directory='s3://DataLake/sales_by_region')
   AS SELECT sale.price, sale.date, store.region
   FROM public.sales sale
   JOIN public.vendor store ON sale.distribID = store.ID;

以下示例演示了数据的分区和导出操作。EXPORT TO PARQUET 首先对区域上的数据进行分区，然后在每个分区内按存储进行排序。

=> EXPORT TO PARQUET(directory='gs://DataLake/user2/data')
  OVER(PARTITION BY store.region ORDER BY store.ID)
  AS SELECT sale.price, sale.date, store.ID
  FROM public.sales sale
  JOIN public.vendor store ON sale.distribID = store.ID;

以下示例对作为表达式的选定列目标使用了别名列标签。

=> EXPORT TO PARQUET(directory='webhdfs:///user3/data')
  OVER(ORDER BY col1) AS SELECT col1 + col1 AS A, col2
  FROM public.T3;

以下示例为输出设置了权限。

=> EXPORT TO PARQUET(directory='webhdfs:///user1/data',
     fileMode='432', dirMode='rwxrw-r-x')
  AS SELECT * FROM public.T1;

5.23 - 导出到 VERTICA

将表数据从一个 Vertica 数据库导出到另一个数据库。

语法

EXPORT [ /*+LABEL (label‑string)*/ ] TO VERTICA
   database.[schema.]target‑table [ ( target‑columns ) ]
   { AS SELECT query‑expression | FROM [schema.]source‑table[ ( source‑columns ) ] }

参数

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

数据库
要导出的数据的目标数据库。在启动复制操作之前，当前会话中必须已经存在与该数据库的连接；否则 Vertica 将返回错误。有关详细信息，请参阅 CONNECT TO VERTICA。
[schema.]target‑table
database 中的表用于存储导出的数据。此表不可以包含除原生数组之外的复杂数据类型列。
target‑columns
target‑table 中列的逗号分隔列表，用于存储导出的数据。请参阅源列和目标列之间的映射，如下所示。
query‑expression
要导出的数据。
[schema.]source‑table
包含要导出的数据的表。
source‑columns
源表中要导出的列的逗号分隔列表。此表不可以包含复杂数据类型的列。请参阅下面的源列和目标列之间的映射。

特权

非超级用户：

  • 源表：选择

  • 源表架构： USAGE

  • 目标表： INSERT

  • 目标表架构： USAGE

源列和目标列之间的映射

将一个数据库中的所有表数据导出到另一个数据库时，如果两个表中的列定义都符合以下条件，EXPORT TO VERTICA 可以不用指定列列表：

  • 列数相同

  • 列名相同

  • 列序列相同

  • 列数据类型匹配或兼容

  • 没有复杂的数据类型（ARRAY、SET 或 ROW），原生数组除外

如果其中任何一个条件不成立，则 EXPORT TO VERTICA 语句必须包含将源列和目标列显式映射到彼此的列列表，如下所示：

  • 包含相同数量的列。

  • 按相同顺序列出源列和目标列。

  • 将具有相同（或兼容）数据类型的列配对。

示例

请参阅将数据导出到另一个数据库。

另请参阅

5.24 - GET DIRECTED QUERY

在指定的输入查询上查询系统表 DIRECTED_QUERIES，并返回映射到输入查询的所有定向查询的详细信息。有关输出的详细信息，请参阅获取定向查询。

语法

GET DIRECTED QUERY input-query

参数

input-query
与一个或多个定向查询关联的一个输入查询。

特权

无

示例

请参阅获取定向查询。

5.25 - GRANT 语句

GRANT 语句将数据库对象的权限授予用户和角色。

5.25.1 - GRANT（身份验证）

将身份验证记录与一个或多个用户和角色相关联。

语法

GRANT AUTHENTICATION auth‑method‑name TO grantee[,...]

参数

auth‑method‑name
与一个或多个用户或角色关联的身份验证方法的名称。
grantee
指定与身份验证方法关联的人员，为以下几项之一：

特权

超级用户

示例

  • 将 v_ldap 身份验证与用户 jsmith 关联：

    => GRANT AUTHENTICATION v_ldap TO jsmith;

  • 将 v_gss 身份验证与角色 DBprogrammer 关联：

    
=> CREATE ROLE DBprogrammer;
=> GRANT AUTHENTICATION v_gss TO DBprogrammer;

  • 将客户端身份验证方法 v_localpwd 与角色 PUBLIC 关联，默认情况下会被分配给所有用户：

    => GRANT AUTHENTICATION v_localpwd TO PUBLIC;

另请参阅

5.25.2 - GRANT（数据库）

将数据库权限授予用户和角色。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] }
   ON DATABASE db‑spec
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对数据库有效：

  • CREATE：创建架构。

  • TEMP：创建临时表。默认情况下，会通过所有用户的 DEFAULT 角色授予其此权限。

ALL [PRIVILEGES]
授予同时属于授予者的所有数据库权限。授予者不能授予其自身缺少的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

db‑spec

指定当前数据库，设置为数据库名称或DEFAULT。

grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户：权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

以下示例授予用户 Fred 在当前数据库中创建架构的权利。

=> GRANT CREATE ON DATABASE DEFAULT TO Fred;

另请参阅

5.25.3 - GRANT（密钥）

将加密密钥权限授予用户或角色。

要撤销授予的权限，请参阅 REVOKE（密钥）。

对于自己未拥有的加密对象，超级用户的访问权限有限。有关详细信息，请参阅数据库对象权限。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] } ON KEY
    key_name[,...]
    TO grantee[,...]
    [ WITH GRANT OPTION ]

参数

privilege

权限，可为以下之一：

  • USAGE：允许用户执行以下操作：

    密钥的 USAGE 还为将其用作私钥的证书提供了隐式 USAGE 权限。用户还可以从密钥或证书的所有权中获取此类权限。证书的 USAGE 权限允许用户执行以下操作：

    • 查看证书的内容。

    • 将证书添加（通过使用 CREATE 或 ALTER）到 TLS 配置。

    • 导入由 CA 签名的证书时重复使用 CA 证书。例如，如果用户导入证书链 A > B > C 且具有 B 的 USAGE，则数据库会重用 B（而不是创建 B 的副本）。

    • 指定 CA 证书已签署导入的证书。例如，如果证书 B 已签署证书 C，则 B 的 USAGE 允许用户导入 C 并指定它是 SIGNED BYB。

  • DROP

  • ALTER：允许用户在各自的系统表中查看密钥及其关联的证书，但不能查看其内容。

key_name
目标密钥。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

以下示例将私钥的 USAGE 权限授予用户，该权限允许用户将自签名 CA 证书添加到 server TLS 配置：

=> CREATE KEY new_ca_key TYPE 'RSA' LENGTH 2048;
=> CREATE CA CERTIFICATE new_ca_cert
    SUBJECT '/C=US/ST=Massachusetts/L=Cambridge/O=Micro Focus/OU=Vertica/CN=Vertica example CA'
    VALID FOR 3650
    EXTENSIONS 'authorityKeyIdentifier' = 'keyid:always,issuer', 'nsComment' = 'new CA'
    KEY new_ca_key;

=> CREATE USER u1;
=> GRANT USAGE ON KEY new_ca_key TO u1;
=> GRANT ALTER ON TLS CONFIGURATION data_channel TO u1;

=> \c - u1

=> ALTER TLS CONFIGURATION data_channel ADD CA CERTIFICATES new_ca_cert;

-- clean up:
=> \c
=> ALTER TLS CONFIGURATION data_channel REMOVE CA CERTIFICATES new_ca_cert;
=> DROP KEY new_ca_key CASCADE;
=> DROP USER u1;

5.25.4 - GRANT（库）

将一个或多个库的权限授予用户和角色。

例如，当您使用连接器框架服务时，您可能需要授予一个用户库的使用权限，才可以设置 UD 会话参数。有关详细信息，请参阅实施 CFS。

语法

GRANT privilege
   ON LIBRARY [[database.]schema.]library[,...]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
要授予的权限，为以下几项之一：

  • USAGE：授予对指定库中函数的访问权限。

  • DROP：授予删除被授予者创建的库的权限。

  • ALL [PRIVILEGES] [EXTEND]：授予同时属于授予者的所有库权限。授予者不能授予其自身缺少的权限。

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包含 DROP 权限。未限定的 ALL 不包括此权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

库
目标库。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

将 MyFunctions 库的 USAGE 权限授予 Fred：

=> GRANT USAGE ON LIBRARY MyFunctions TO Fred;

另请参阅

5.25.5 - GRANT（模型）

将模型的使用权限授予用户和角色。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON MODEL [[database.]schema.]model‑name[,...]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对模型有效：
ALL [PRIVILEGES][EXTEND]
授予同时属于授予者的所有模型权限。授予者不能授予其自身缺少的权限。

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

model‑name
授予其权限的模型。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

此示例将 mySvmClassModel 模型的 USAGE 权限授予 user1：

=> GRANT USAGE ON MODEL mySvmClassModel TO user1;

另请参阅

5.25.6 - GRANT（过程）

将存储过程或外部过程的权限授予用户或角色。

语法

GRANT { EXECUTE | ALL [ PRIVILEGES ] }
   ON PROCEDURE [[database.]schema.]procedure( [arg-list] )[,...]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

EXECUTE
使被授予者能够运行指定的过程。
ALL [PRIVILEGES]
授予同时属于授予者的所有过程权限。授予者不能授予其自身缺少的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
目标过程。
arg-list
过程实参的逗号分隔列表，其中每个实参指定如下： 
[ argname ] argtype

如果过程未定义实参，请提供一个空的实参列表。

grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户，为以下之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色

示例

将 tokenize 过程的 EXECUTE 权限授予用户 Bob 和 Jules，以及授予角色 Operator：

=> GRANT EXECUTE ON PROCEDURE tokenize(varchar) TO Bob, Jules, Operator;

另请参阅

5.25.7 - GRANT（资源池）

将资源池的 USAGE 权限授予用户和角色。用户可以通过 ALTER USER 或 SET SESSION RESOURCE POOL 访问其资源池。

语法

GRANT USAGE
   ON RESOURCE POOL resource-pool[,...]
   [FOR SUBCLUSTER subcluster | FOR CURRENT SUBCLUSTER]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

USAGE
使被授予者能够访问指定的资源池。
ALL [PRIVILEGES]
授予同时属于授予者的所有资源池权限。授予者不能授予其自身缺少的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

resource-pool
授予其指定权限的资源池。
subcluster
资源池的子群集。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户，为以下之一：

示例

授予用户 Joe 对资源池 Joe_pool 的 USAGE 权限。

=> CREATE USER Joe;
CREATE USER
=> CREATE RESOURCE POOL Joe_pool;
CREATE RESOURCE POOL
=> GRANT USAGE ON RESOURCE POOL Joe_pool TO Joe;
GRANT PRIVILEGE

授予用户 Joe 对子群集 sub1 的资源池 Joe_pool 的 USAGE 权限。

=> GRANT USAGE on RESOURCE POOL Joe_pool FOR SUBCLUSTER sub1 TO Joe;
GRANT PRIVILEGE

另请参阅

5.25.8 - 授权（角色）

将角色分配给用户或其他角色。

语法

GRANT role[,...] TO grantee[,...] [ WITH ADMIN OPTION ]

参数

角色
要授予的角色
grantee
被授予指定角色的用户或角色，为以下几项之一：
WITH ADMIN OPTION
授予被授予者将指定角色授予其他用户或角色的权限。有关详细信息，请参阅授予权限。

特权

非超级用户：如果使用 WITH GRANT OPTION，则可以将相同的角色授予其他用户或角色。

示例

请参阅授予数据库角色。

另请参阅

REVOKE（角色）

5.25.9 - GRANT（架构）

将架构权限授予用户和角色。默认情况下，只有超级用户和架构所有者才拥有以下架构权限：

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON SCHEMA [database.]schema[,...]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限之一：

  • USAGE：允许访问指定架构中的对象。然后可以授予被授予者对这些架构中的单个对象的访问权限，例如使用 GRANT TABLE 和 GRANT VIEW。

  • CREATE：在指定架构中创建和重命名对象，以及从其他架构中移动对象。

您还可以授予以下架构权限，以供表及其投影以及该架构的视图继承。如果数据库和架构启用了继承，这些权限会在创建时自动授予这些对象：

  • SELECT：查询表和视图。默认情况下，会将 SELECT 权限授予 PUBLIC 角色。

  • INSERT：插入行，或者使用 COPY 将数据加载到表中。

  • UPDATE：更新表行。

  • DELETE：删除表行。

  • REFERENCES：在此表上创建外键约束。必须对引用的和被引用的表上都设置此权限。

  • TRUNCATE：截断表内容。表的非所有者也可以对表执行以下分区操作：

  • ALTER：使用 ALTER TABLE 和 ALTER VIEW 分别修改表和视图的 DDL。

  • DROP：删除表和视图。

ALL [PRIVILEGES][EXTEND]
授予 USAGE AND CREATE 权限。必须显式授予继承的权限。

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema
指定目标架构。如果指定一个数据库，它必须是当前数据库。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户，为以下几项之一：

  • 架构所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

授予用户 Joe 对架构 online_sales 的 USAGE 权限。

=> CREATE USER Joe;
CREATE USER

=> GRANT USAGE ON SCHEMA online_sales TO Joe;
GRANT PRIVILEGE

另请参阅

5.25.10 - GRANT（序列）

将序列权限授予用户和角色。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON {
     SEQUENCE [[database.]schema.]sequence[,...]
     | ALL SEQUENCES IN SCHEMA [database.]schema[,...] }
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对序列有效：
ALL [PRIVILEGES][EXTEND]
授予同时属于授予者的所有序列权限。授予者不能授予其自身缺少的权限

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

SEQUENCE sequence
指定授予其权限的序列。
ALL SEQUENCES IN SCHEMA schema
授予对架构 schema 中所有序列的指定权限。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

此示例说明如何授予用户 Joe 对序列 my_seq 的所有权限。

=> CREATE SEQUENCE my_seq START 100;
CREATE SEQUENCE

=> GRANT ALL PRIVILEGES ON SEQUENCE my_seq TO Joe;
GRANT PRIVILEGE

另请参阅

5.25.11 - GRANT（存储位置）

将用户定义的存储位置的权限授予用户和角色。有关详细信息，请参阅创建存储位置。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] }
   ON LOCATION 'path' [ ON node ]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对存储位置有效：

  • READ：将数据从存储位置中的文件复制到表。

  • WRITE：将数据从数据库导出到存储位置。被授予者获得 WRITE 特权后，还可以将 COPY 语句被拒绝的数据和异常文件保存到存储位置。

ALL [PRIVILEGES]
授予同时属于授予者的所有存储位置权限。授予者不能授予其自身缺少的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

ON LOCATION 'path' [ ON node]
指定存储位置的路径名称挂载点。如果通过 ON NODE 进行限定，Vertica 将授予对位于节点上的存储位置的访问权限。

如果未指定节点，则授予操作适用于指定路径上的所有节点。所有节点必须在指定路径上；否则，整个授权操作将回退。

grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

特权

非超级用户，为以下之一：

示例

创建存储位置：

=> CREATE LOCATION '/home/dbadmin/UserStorage/BobStore' NODE 'v_mcdb_node0007' USAGE 'USER';
CREATE LOCATION

授予用户 Bob 对 /BobStore 位置的所有可用权限：

=> GRANT ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' TO Bob;
GRANT PRIVILEGE

取消授予 Bob 的全部存储位置特权：

=> REVOKE ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' FROM Bob;
REVOKE PRIVILEGE

再次授予 Bob 在 BobStore 位置的特权，指定节点：

=> GRANT ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' ON v_mcdb_node0007 TO Bob;
GRANT PRIVILEGE

取消授予 Bob的全部存储位置特权：

=> REVOKE ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' ON v_mcdb_node0007 FROM Bob;
REVOKE PRIVILEGE

另请参阅

5.25.12 - GRANT（表）

将表权限授予用户和角色。同时必须将表架构的 USAGE 权限授予用户。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON {
     [ TABLE ] [[database.]schema.]table[,...]
     | ALL TABLES IN SCHEMA [database.]schema[,...] }
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对表有效：
ALL [PRIVILEGES][EXTEND]
对系统表无效，授予同时属于授予者的所有表权限。授予者不能授予其自身缺少的权限。

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema
指定架构，默认为 public。如果 schema 是除 public 以外的任何其他架构，则必须提供架构名称。例如： 
myschema.thisDbObject

这里有一个例外：您可以指定系统表但不指定其架构名称。

如果指定一个数据库，它必须是当前数据库。

TABLE table
指定授权的表。
ON ALL TABLES IN SCHEMA schema
授予对架构 schema 中所有表和视图的指定权限。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

授予用户 Joe 对表 customer_dimension 的所有权限：

=> CREATE USER Joe;
CREATE USER

=> GRANT ALL PRIVILEGES ON TABLE customer_dimension TO Joe;
GRANT PRIVILEGE

授予用户 Joe 对所有系统表的 SELECT 权限：

=> GRANT SELECT on all tables in schema V_MONITOR, V_CATALOG TO Joe;
GRANT PRIVILEGE

另请参阅

5.25.13 - GRANT（用户定义的扩展）

将用户定义的扩展 (UDx) 的权限授予用户和角色。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON {
       UDx‑type [[database.]schema.]function( [arg‑list] )[,...]
       | ALL FUNCTIONS IN SCHEMA schema[,...] }
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
以下权限对用户定义的扩展有效：
ALL [PRIVILEGES] [EXTEND]
授予同时属于授予者的所有函数权限。授予者不能授予其自身缺少的权限

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

ON UDx‑type
用户定义的扩展 (UDx) 的类型，为以下几项之一：

  • FUNCTION （标量函数）

  • AGGREGATE FUNCTION

  • ANALYTIC FUNCTION

  • TRANSFORM FUNCTION

  • FILTER

  • PARSER

  • SOURCE

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function
要授予其权限的用户定义函数的名称。
ON ALL FUNCTIONS IN SCHEMAschema
授予对指定架构中所有函数的权限。
arg-list
对所有多态函数都是必需的，是一个逗号分隔的函数实参列表，其中每个实参指定如下： 
[ argname ] argtype

如果过程未定义实参，请提供一个空的实参列表。

grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

将 myzeroifnullSQL 函数的 EXECUTE 权限授予用户 Bob 和 Jules 以及角色 Operator。该函数需要一个整数参数：

=> GRANT EXECUTE ON FUNCTION myzeroifnull (x INT) TO Bob, Jules, Operator;

将 zero-schema 架构中所有函数的 EXECUTE 权限授予用户 Bob：

=> GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA zero-schema TO Bob;

将tokenize转换函数的 EXECUTE 权限授予用户 Bob 和角色 Operator：

=> GRANT EXECUTE ON TRANSFORM FUNCTION tokenize(VARCHAR) TO Bob, Operator;

将 ExampleSource() 源的 EXECUTE 权限授予用户 Alice：

=> CREATE USER Alice;
=> GRANT USAGE ON SCHEMA hdfs TO Alice;
=> GRANT EXECUTE ON SOURCE ExampleSource() TO Alice;

将 ExampleSource() 源的所有权限授予用户 Alice：

=> GRANT ALL ON SOURCE ExampleSource() TO Alice;

将多态函数 Pagerank 的所有权限授予 dbadmin 角色：

=> GRANT ALL ON TRANSFORM FUNCTION Pagerank(z varchar) to dbadmin;

另请参阅

5.25.14 - GRANT（视图）

将视图权限授予用户和角色。

语法

GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
   ON [[database.]schema.]view[,...]
   TO grantee[,...]
   [ WITH GRANT OPTION ]

参数

privilege
视图具有以下有效权限：
ALL [PRIVILEGES][EXTEND]
授予同时属于授予者的所有视图权限。授予者不能授予其自身缺少的权限。

您可以使用两个可选关键字限定 ALL：

  • PRIVILEGES 符合 SQL 标准。

  • EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
目标视图。
grantee

指定向谁授予权限，可以为以下值之一：

WITH GRANT OPTION

授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。

非超级用户需要对架构的 USAGE 权限和以下权限之一：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

授予用户 Joe 对视图 ship 的所有权限。

=> CREATE VIEW ship AS SELECT * FROM public.shipping_dimension;
CREATE VIEW

=> GRANT ALL PRIVILEGES ON ship TO Joe;
GRANT PRIVILEGE

另请参阅

REVOKE（视图）

5.26 - INSERT

将值插入指定表的所有投影。每次只能插入一个完整的元组。如果没有与目标表关联的投影，Vertica 会创建一个超投影以存储插入值。

INSERT 适用于 flex 表以及常规原生表。如果表包含实际列，则会将标量类型的插入数据和标量类型的原生数组添加到实际列和 __raw__ 列。对于复杂类型的数据，不会将值添加到 __raw__ 列。

语法

INSERT [ /*+LABEL (label‑string)*/ ] INTO [[database.]schema.]table-name 
    [ ( column-list ) ]
    { DEFAULT VALUES | VALUES ( values-list )[,...] | SELECT {{< codevar >}}query-expression{{< /codevar >}} }

参数

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
目标表。不能在投影中调用 INSERT。
column‑list
此表中一个或多个目标列的逗号分隔列表，按任意顺序列出。VALUES 子句值将以相同的顺序映射到列。如果忽略此列表，Vertica 将根据表定义中的列顺序将 VALUES 子句值映射到列。

DEFAULT VALUES 对目标列列表无效。

DEFAULT VALUES
使用表定义中指定的默认值填充所有列。如果没有为列指定默认值，Vertica 将插入 NULL 值。

不能使用此选项指定目标列的列表。

VALUES (values‑list)
要在目标列中插入的一个或多个值的逗号分隔列表，其中每个值是以下值之一：

  • expression 将解析为要插入到目标列中的值。表达式不得嵌套其他表达式（包含 Vertica 元函数）或使用混合复杂类型。如果 Vertica 可以强制转换元素或字段类型，则值可能包括原生数组或 ROW 类型。

  • DEFAULT 将插入表定义中指定的默认值。

如果没有为列提供值，Vertica 会隐式添加 DEFAULT 值（如果已定义）。否则，Vertica 将插入 NULL 值。如果将列定义为 NOT NULL，则 INSERT 将返回错误。

您可以使用 INSERT 在目标表中插入多行，方法是指定多个以逗号分隔的 VALUES 列表：

INSERT INTO table-name
   VALUES ( values-list ), ( values-list )[,...]

有关详细信息，请参阅下面的多行 INSERT。

SELECT query‑expression
返回要插入的行的查询。隔离级别仅适用于 SELECT 子句并且按照任意查询的方式工作。对使用复杂类型的限制同样适用于其他查询。

特权

  • 表所有者或具有 GRANT OPTION 权限的用户是授予者

  • 对表的 INSERT 权限

  • 包含表的架构上的 USAGE 权限

Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。

多行 INSERT

通过指定多个以逗号分隔的 VALUES 列表，您可以使用 INSERT 在目标表中插入多行。例如：

=> CREATE TABLE public.t1(a int, b int, c varchar(16));
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2, 'un, deux'), (3,4, 'trois, quatre');
 OUTPUT
--------
      2
(1 row)

=> COMMIT;
COMMIT
=> SELECT * FROM t1;
 a | b |       c
---+---+---------------
 1 | 2 | un, deux
 3 | 4 | trois, quatre
(4 rows)

限制

  • Vertica 不支持将子查询作为 INSERT 语句的目标。

  • 对在 SELECT 语句中使用 复杂类型的限制同样适用于 INSERT。使用无法强制转换为列类型的复杂值会导致错误。

  • 如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。

  • 如果插入会违反表或架构磁盘配额，则操作将失败。有关详细信息，请参阅磁盘配额。

示例

=> INSERT INTO t1 VALUES (101, 102, 103, 104);
=> INSERT INTO customer VALUES (10, 'male', 'DPR', 'MA', 35);
=> INSERT INTO start_time VALUES (12, 'film','05:10:00:01');
=> INSERT INTO retail.t1 (C0, C1) VALUES (1, 1001);
=> INSERT INTO films SELECT * FROM tmp_films WHERE date_prod < '2004-05-07';

Vertica 不支持将子查询或嵌套的表达式作为 INSERT 语句的目标。例如，以下查询会返回一条错误消息：

=> INSERT INTO t1 (col1, col2) VALUES ('abc', (SELECT mycolumn FROM mytable));
ERROR 4821:  Subqueries not allowed in target of insert

您可以重新编写以上查询，如下所示：

=> INSERT INTO t1 (col1, col2) (SELECT 'abc', mycolumn FROM mytable);
 OUTPUT
--------
      0
(1 row)

以下示例显示了如何将 INSERT...VALUES 与 flex 表一起使用：

=> CREATE FLEX TABLE flex1();
 CREATE TABLE
=> INSERT INTO flex1(a,b) VALUES (1, 'x');
 OUTPUT
--------
      1
(1 row)

=> SELECT MapToString(__raw__) FROM flex1;
           MapToString
---------------------------------
{
"a" : "1",
"b" : "x"
}
(1 row)

以下示例显示了如何将 INSERT...SELECT 与 flex 表一起使用：

=> CREATE FLEX TABLE flex2();
 CREATE TABLE
=> INSERT INTO flex2(a, b) SELECT a, b, '2016-08-10 11:10' c, 'Hello' d, 3.1415 e, f from flex1;
 OUTPUT
--------
      1
(1 row)

=> SELECT MapToString(__raw__) FROM flex2;
           MapToString
---------------------------------
{
"a" : "1",
"b" : "x",
"c" : "2016-08-10",
"d" : "Hello",
"e" : 3.1415,
"f" : null
}
(1 row)

以下示例使用复杂类型：

=> CREATE TABLE inventory(storeID INT, product ROW(name VARCHAR, code VARCHAR));
CREATE TABLE

--- LookUpProducts() returns a row(varchar, int), which is cast to row(varchar, varchar):
=> INSERT INTO inventory(product) SELECT LookUpProducts();
 OUTPUT
--------
      5
(1 row)

--- Cannot use with select...values:
=> INSERT INTO inventory(product) VALUES(LookUpProducts());
ERROR 2631:  Column "product" is of type "row(varchar,varchar)" but expression is of type "row(varchar,int)"

--- Literal values are supported:
=> INSERT INTO inventory(product) VALUES(ROW('xbox',165));
 OUTPUT
--------
      1
(1 row)

=> SELECT product FROM inventory;
          product
------------------------------
 {"name":"xbox","code":"125"}
(1 row)

5.27 - MERGE

根据目标表与另一个数据集（例如表或视图）的联接结果，对其执行更新和插入操作。联接只能将一个源行与一个目标行匹配；否则，Vertica 将返回错误。

如果合并会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。

目标表不能包含复杂数据类型列。但源表可以，只要合并操作中不包含这些列。

语法

MERGE [ /*+LABEL (label‑string)*/ ]
    INTO [[database.]schema.]target‑table [ [AS] alias ]
    USING source‑dataset
    ON  join-condition matching‑clause[ matching‑clause ]

返回

更新或插入的目标表行数

参数

LABEL

将标签分配到语句，以便您可以在分析和调试时识别它。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

目标表
对其执行更新和插入操作的表。MERGE 在操作中对目标表进行 X（互斥）锁。表不得包含复杂类型列。
source‑dataset
要联接到 target-table 的数据，为以下几项之一：
  • [[database.]schema.]table [ [AS] alias ]
  • [[database.]schema.]view [ [AS] alias ]
  • (subquery) sq-alias

指定的数据集通常提供用于更新目标表和填充新行的数据。可以指定一个外部表。

ON join‑condition
联接目标表和源数据集的条件。
matching‑clause
以下子句之一：

MERGE 支持每个子句的一个实例，且必须至少包含一个实例。

WHEN MATCHED THEN UPDATE
对于联接（匹配）到 source‑dataset 的每个target‑table 行，指定更新一列或多列： 
WHEN MATCHED [ AND update-filter ] THEN UPDATE
  SET { column = expression }[,...]

update-filter 选择性地筛选匹配行的集合。更新筛选器可以指定任意数量的条件。Vertica 会根据此筛选器评估每个匹配行，并仅更新评估为 true 的行。有关详细信息，请参阅更新和插入筛选器。

需要满足以下要求：

  • MERGE 语句只能包含一个 WHEN MATCHED 子句。

  • target‑column 只能指定目标表中的列名称。不能用表名称来限定。

有关详细信息，请参阅合并表数据。

WHEN NOT MATCHED THEN INSERT
对于每个未联接到（未匹配）到 target‑table 的 source‑dataset 行，指定：

  • 在 target-table 中插入一个新行。

  • 使用 values‑list 中指定的值填充每个新行。

WHEN NOT MATCHED [ AND insert-filter ] THEN INSERT
  [ ( column‑list ) ] VALUES ( values‑list )

column‑list 是目标表中一个或多个目标列的逗号分隔列表，按任意顺序列出。MERGE 以相同的顺序将 column‑list 列映射到 values‑list 值，且每个列值对必须兼容。如果您忽略 column‑list，Vertica 将根据表定义中的列顺序将 values‑list 值映射到列。

insert-filter 选择性地筛选不匹配的行集。插入筛选器可以指定任意数量的条件。Vertica 根据此筛选器评估每个不匹配的源行。对于计算结果为 true 的每一行，Vertica 都会在目标表中插入一个新行。有关详细信息，请参阅更新和插入筛选器。

需要满足以下要求：

  • MERGE 语句只能包含一个 WHEN NOT MATCHED 子句。

  • column‑list 只能指定目标表中的列名称。不能用表名称来限定。

  • 插入筛选条件只能引用源数据。如果任何条件引用目标表，Vertica 将返回错误。

有关详细信息，请参阅合并表数据。

特权

MERGE 需要以下权限：

  • 对源数据的 SELECT 权限以及对目标表的 INSERT、UPDATE 和 DELETE 权限。

  • 自动约束强制执行要求具有对限制的表的 SELECT 权限。

  • 如果语法中的条件从目标表中读取数据，则需要具有对目标表的 SELECT 权限。

例如，以下 GRANT 语句授予 user1 对 t2 表的访问权限。这将允许 user1 运行以下 MERGE 语句：

=> GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE t2 to user1;
GRANT PRIVILEGE

=>\c - user1
You are now connected as user "user1".

=> MERGE INTO t2 USING t1 ON t1.a = t2.a
WHEN MATCHED THEN UPDATE SET b = t1.b
WHEN NOT MATCHED THEN INSERT (a, b) VALUES (t1.a, t1.b);

改善 MERGE 性能

您可以通过多种方式改善 MERGE 性能：

有关详细信息，请参阅MERGE 优化。

如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。

禁止合并的列

合并操作中不能指定以下列，否则将返回错误：

示例

请参阅：

另请参阅

5.28 - PROFILE

分析单个 SQL 语句。

语法

PROFILE { sql-statement }

参数

sql‑statement
查询 (SELECT) 语句或 DML 语句，例如，您可以分析 INSERT、 UPDATE、 COPY 和 MERGE。

输出

将分析摘要写入 stderr，将详细信息保存至系统编录 V_MONITOR.EXECUTION_ENGINE_PROFILES。

特权

需要相同的权限运行已分析的语句

描述

PROFILE 生成关于目标语句执行的详细信息，并将其保存在系统编录 V_MONITOR.EXECUTION_ENGINE_PROFILES 中。查询输出通过分析总结执行：分析标识符 transaction_id 和 statement_id、启动程序的查询内存以及需要的总内存。例如：

=> PROFILE SELECT customer_name, annual_income FROM public.customer_dimension WHERE (customer_gender, annual_income) IN (SELECT customer_gender, MAX(annual_income) FROM public.customer_dimension GROUP BY customer_gender);
NOTICE 4788:  Statement is being profiled
HINT:  Select * from v_monitor.execution_engine_profiles where transaction_id=45035996274683334 and statement_id=7;
NOTICE 3557:  Initiator memory for query: [on pool general: 708421 KB, minimum: 554324 KB]
NOTICE 5077:  Total memory required by query: [708421 KB]
  customer_name   | annual_income
------------------+---------------
 Emily G. Vogel   |        999998
 James M. McNulty |        999979
(2 rows)

使用分析标识符在给定的查询中查询分析信息的表。

另请参阅

分析单个语句

5.29 - RELEASE SAVEPOINT

销毁保存点，而不撤销在建立保存点后所执行的命令的影响。

语法

RELEASE [ SAVEPOINT ] savepoint_name

参数

savepoint_name
指定要销毁的保存点名称。

特权

无

注意

保存点一经销毁便不可用作回退点。

示例

以下示例首先建立名为 my_savepoint 的保存点，然后将其销毁。值 101 和 102 均在提交时插入。

=> INSERT INTO product_key VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (102);
=> RELEASE SAVEPOINT my_savepoint;
=> COMMIT;

另请参阅

5.30 - REVOKE 语句

REVOKE 语句用于撤销用户和角色对数据库对象的权限。

5.30.1 - REVOKE（身份验证）

撤销用户和角色对身份验证方法的权限。

语法

REVOKE AUTHENTICATION auth‑method‑name FROM grantee[,...]

参数

auth‑method‑name
目标身份验证方法的名称。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

特权

超级用户

示例

  • 从用户 jsmith 撤销 v_ldap 身份验证：

    => REVOKE AUTHENTICATION v_ldap FROM jsmith;

  • 从角色 DBprogrammer 撤销 v_gss 身份验证：

    => REVOKE AUTHENTICATION v_gss FROM DBprogrammer;

  • 撤销 localpwd 作为默认客户端身份验证方法：

    => REVOKE AUTHENTICATION localpwd FROM PUBLIC;

另请参阅

5.30.2 - REVOKE（数据库）

撤销用户和角色的数据库权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON DATABASE db‑spec
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
要撤销的数据库权限，为以下几项之一：

  • CREATE：创建架构。

  • TEMP：创建临时表。

ALL [PRIVILEGES]
撤销同时属于撤销者的所有数据库权限。用户无法撤销其自身没有的权限。

支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。

ON DATABASE db‑spec

指定当前数据库，设置为数据库名称或DEFAULT。

grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Fred 在当前数据库中创建架构的权限：

=> REVOKE CREATE ON DATABASE DEFAULT FROM Fred;

撤销用户 Fred 在当前数据库中创建临时表的权限：

=> REVOKE TEMP ON DATABASE DEFAULT FROM Fred;

另请参阅

5.30.3 - REVOKE（密钥）

撤销用户或角色对加密密钥的权限。

要授予密钥权限，请参阅 GRANT（密钥）。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] } ON KEY
    key_name[,...]
    FROM user[,...]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege

权限，可为以下之一：

  • USAGE：允许用户执行以下操作：

    密钥的 USAGE 还为将其用作私钥的证书提供了隐式 USAGE 权限。用户还可以从密钥或证书的所有权中获取此类权限。证书的 USAGE 权限允许用户执行以下操作：

    • 查看证书的内容。

    • 将证书添加（通过使用 CREATE 或 ALTER）到 TLS 配置。

    • 导入由 CA 签名的证书时重复使用 CA 证书。例如，如果用户导入证书链 A > B > C 且具有 B 的 USAGE，则数据库会重用 B（而不是创建 B 的副本）。

    • 指定 CA 证书已签署导入的证书。例如，如果证书 B 已签署证书 C，则 B 的 USAGE 允许用户导入 C 并指定它是 SIGNED BYB。

  • DROP

  • ALTER：允许用户在各自的系统表中查看密钥及其关联的证书，但不能查看其内容。

key_name
目标密钥。
用户

指定向谁授予权限，可以为以下值之一：

特权

非超级用户：

  • 所有者

  • 权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。

示例

以下示例撤销用户对密钥（以及扩展的相关证书）的 DROP 权限：

=> REVOKE USAGE ON KEY new_key FROM u1;
REVOKE PRIVILEGE

5.30.4 - REVOKE（库）

撤销用户和角色的库权限。

语法

REVOKE [ GRANT OPTION FOR ] { USAGE | ALL [ PRIVILEGES ] }
   ON LIBRARY [[database.]schema.]library[,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

USAGE
撤销对指定库的访问权限。
ALL [PRIVILEGES]
撤销同时属于撤销者的所有库权限。用户无法撤销其自身没有的权限。可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

库
目标库。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

示例

这些命令将展示如何新建一个库，然后如何授予和撤销用户 Fred 对该库的 USAGE 权限。

=> CREATE LIBRARY MyFunctions AS 'home/dbadmin/my_functions.so';
=> GRANT USAGE ON LIBRARY MyFunctions TO Fred;
=> REVOKE USAGE ON LIBRARY MyFunctions FROM Fred;

另请参阅

5.30.5 - REVOKE（模型）

撤销用户和角色的模型权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON MODEL [[database.]schema.]model‑name [,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

USAGE
以下权限之一：
ALL [PRIVILEGES]
撤销同时属于撤销者的所有模型权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

model‑name
目标模型的名称。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Fred 对模型 mySvmClassModel 的 USAGE 权限：

=> REVOKE USAGE ON mySvmClassModel FROM Fred;

另请参阅

5.30.6 - REVOKE（过程）

撤销用户和角色的过程权限。

语法

REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL PRIVILEGES }
   ON PROCEDURE [[database.]schema.]procedure( [argument-list] )[,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

EXECUTE
撤销被授予者运行指定过程的能力。
ALL [PRIVILEGES]
撤销同时属于撤销者的所有过程权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

过程
目标过程。
argument-list
过程实参的逗号分隔列表，其中每个实参指定如下： 
[argname] argtype

如果过程未定义实参，请提供一个空的实参列表。

grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

此示例将撤销用户 Bob 对 tokenize 过程的执行权限。

=> REVOKE EXECUTE ON PROCEDURE tokenize(varchar) FROM Bob;

另请参阅

5.30.7 - REVOKE（资源池）

撤销用户和角色的资源池访问权限。

Vertica 在运行时检查资源池权限。撤销用户对资源池的权限可立即对用户的当前会话产生影响。例如，用户查询可能需要使用资源池的 USAGE 权限。如果您撤销该用户的这些权限，则该用户随后执行该查询的尝试将失败并返回错误消息。

语法

REVOKE  [ GRANT OPTION FOR ] { USAGE | ALL PRIVILEGES }
   ON RESOURCE POOL resource-pool[,...]
   [FOR SUBCLUSTER subcluster | FOR CURRENT SUBCLUSTER]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

USAGE
撤销被授予者对指定资源池的访问权限。
ALL PRIVILEGES
撤销同时属于调用者的所有资源池权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

resource-pool
目标资源池。
subcluster
资源池的子群集。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Joe 对资源池 Joe_pool 的 USAGE 权限。

=> REVOKE USAGE ON RESOURCE POOL Joe_pool FROM Joe;
REVOKE PRIVILEGE

撤销用户 Joe 对子群集 sub1 的资源池 Joe_pool 的 USAGE 权限。

=> REVOKE USAGE ON RESOURCE POOL Joe_pool FOR SUBCLUSTER sub1 FROM Joe;
REVOKE PRIVILEGE

另请参阅

5.30.8 - REVOKE（角色）

撤销用户和角色的角色权限。

语法

REVOKE [ ADMIN OPTION FOR ] role[,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

ADMIN OPTION FOR
撤销被授予者将指定角色分配给其他用户或角色的权限。被授予者的当前角色不受影响。如果忽略此子句，Vertica 将撤销角色分配权限和当前角色。
角色
要撤销的角色。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

特权

以下几项之一：

  • 超级用户

  • 可以选择 (WITH ADMIN OPTION) 将这些权限扩展到其他用户的权限被授予者

示例

此示例显示了如何撤销 dbadmin 用户的 pseudosuperuser 角色：

=> REVOKE pseudosuperuser from dbadmin;

此示例显示了如何撤销 dbadmin 用户对 pseudosuperuser 角色的管理访问权限。ADMIN OPTION 命令不会移除 pseudosuperuser 角色。

=> REVOKE ADMIN OPTION FOR pseudosuperuser FROM dbadmin;

注意

如果尚未将尝试撤销的角色授予用户，Vertica 将返回一则通知：

=> REVOKE commentor FROM Sue;
NOTICE 2022:  Role "commentor" was not already granted to user "Sue"
REVOKE ROLE

另请参阅

5.30.9 - REVOKE（架构）

撤销用户和角色的架构权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON SCHEMA [database.]schema[,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
要撤销的架构权限，为以下几项之一：

  • USAGE：访问指定架构中的对象。

  • CREATE：在指定的架构中创建对象。

您还可以撤销表和视图在创建时从该架构继承的权限。当您撤销在架构级别继承的权限时，Vertica 会自动将撤销应用于继承这些权限的所有表和视图。

  • SELECT：查询表和视图。默认情况下，会将 SELECT 权限授予 PUBLIC 角色。

  • INSERT：插入行，或者使用 COPY 将数据加载到表中。

  • UPDATE：更新表行。

  • DELETE：删除表行。

  • REFERENCES：在此表上创建外键约束。必须对引用的和被引用的表上都设置此权限。

  • TRUNCATE：截断表内容。表的非所有者也可以对表执行以下分区操作：

  • ALTER：使用 ALTER TABLE 和 ALTER VIEW 分别修改表和视图的 DDL。

  • DROP：删除表和视图。

ALL [PRIVILEGES]
撤销 USAGE AND CREATE 权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

[database.]schema
要撤销其权限的架构。如果指定一个数据库，它必须是当前数据库。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Joe 对架构 online_sales 的 USAGE 权限。

=> REVOKE USAGE ON SCHEMA online_sales FROM Joe;
REVOKE PRIVILEGE

另请参阅

5.30.10 - REVOKE（序列）

撤销用户和角色的序列权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON {
     SEQUENCE [[database.]schema.]sequence[,...]
     | ALL SEQUENCES IN SCHEMA [database.]schema[,...] }
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
以下权限之一：
ALL [PRIVILEGES]
撤销同时属于撤销者的所有序列权限。用户无法撤销其自身没有的权限。

支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

SEQUENCE sequence
指定要撤销权限的序列。
ALL SEQUENCES IN SCHEMA schema
撤销对架构 schema 中所有序列的指定权限。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Joe 对序列 my_seq 的权限。

=> REVOKE ALL PRIVILEGES ON SEQUENCE my_seq FROM Joe;
REVOKE PRIVILEGE

另请参阅

5.30.11 - REVOKE（存储位置）

撤销用户和角色对用户定义的存储位置的权限。有关详细信息，请参阅创建存储位置。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON LOCATION 'path' [ ON node ]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
以下权限之一：

  • READ：将数据从存储位置中的文件复制到表。

  • WRITE：将数据从数据库导出到存储位置。被授予者获得 WRITE 特权后，还可以将 COPY 语句被拒绝的数据和异常文件保存到存储位置。

ALL [PRIVILEGES]
撤销同时属于调用者的所有存储位置权限。用户无法撤销其自身没有的权限。

支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。

ON LOCATION 'path' [ ON node ]
指定存储位置的路径名称挂载点。如果通过 ON NODE 进行限定，Vertica 将撤销对节点上的存储位置的访问权限。

如果未指定节点，撤销操作将适用于指定路径上的所有节点。所有节点必须位于指定路径上；否则，整个撤销操作将回退。

grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

请参阅GRANT（存储位置）。

另请参阅

授予和撤销权限

5.30.12 - REVOKE（表）

撤销用户和角色的表权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON {
     [ TABLE ] [[database.]schema.]table[,...]
     | ALL TABLES IN SCHEMA [database.]schema[,...] }
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
以下权限之一：
ALL [PRIVILEGES]
撤销同时属于撤销者的所有表权限。用户无法撤销其自身没有的权限。

支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。

[database.]schema
指定架构，默认为 public。如果 schema 是除 public 以外的任何其他架构，则必须提供架构名称。例如： 
myschema.thisDbObject

这里有一个例外：您可以指定系统表但不指定其架构名称。

如果指定一个数据库，它必须是当前数据库。

TABLE table
指定要撤销其权限的表。
ON ALL TABLES IN SCHEMA schema
撤销对架构 schema 中所有表和视图的指定权限。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

非超级用户，为以下之一：

示例

撤销用户 Joe 对表 customer_dimension 的权限。

=> REVOKE ALL PRIVILEGES ON TABLE customer_dimension FROM Joe;
REVOKE PRIVILEGE

另请参阅

5.30.13 - REVOKE（用户定义的扩展）

撤销用户和角色对一个或多个用户定义的扩展的权限。

语法

REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL PRIVILEGES }
   ON {
       UDx‑type [[database.]schema.]function‑name( [argument‑list] )[,...]
       | ALL FUNCTIONS IN SCHEMA schema[,...] }
   FROM grantee[,...]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

EXECUTE
撤销被授予者运行指定函数的能力。
ALL [PRIVILEGES]
撤销同时属于调用者的所有函数权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

ON UDx‑type
指定函数的用户定义的扩展 (UDx) 类型，其中 UDx‑type 为以下几项之一：

  • FUNCTION

  • AGGREGATE FUNCTION

  • ANALYTIC FUNCTION

  • TRANSFORM FUNCTION

  • FILTER

  • PARSER

  • SOURCE

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

function‑name
要撤销其权限的用户定义函数的名称。
ON ALL FUNCTIONS IN SCHEMA schema
撤销对指定架构中所有函数的权限。
argument-list
对所有多态函数都是必需的，是一个逗号分隔的函数实参列表，其中每个实参指定如下： 
[argname] argtype

如果过程未定义实参，请提供一个空的实参列表。

grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

特权

非超级用户，为以下之一：

  • 目标函数的所有者

  • 可以选择 (WITH GRANT OPTION) 将这些权限扩展到其他用户的权限被授予者

示例

撤销用户 Bob 对函数 myzeroifnull 的 EXECUTE 权限：

=> REVOKE EXECUTE ON FUNCTION myzeroifnull (x INT) FROM Bob;

撤销用户 Doug 对函数 Pagerank 的所有权限：

=> REVOKE ALL ON TRANSFORM FUNCTION Pagerank (t float) FROM Doug;

撤销用户 Bob 对 zero-schema 架构中所有函数的 EXECUTE 权限：

=> REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA zero-schema FROM Bob;

撤销用户 Bob 对 tokenize 函数的 EXECUTE 权限：

=> REVOKE EXECUTE ON TRANSFORM FUNCTION tokenize(VARCHAR) FROM Bob;

撤销用户 Alice 对 ExampleSource() 源的所有权限：

=> REVOKE ALL ON SOURCE ExampleSource() FROM Alice;

另请参阅

5.30.14 - REVOKE（视图）

撤销用户和角色的视图权限。

语法

REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
   ON [[database.]schema.]view[,...]
   FROM grantee[,...]
   [ CASCADE ]

参数

GRANT OPTION FOR

撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。

privilege
以下几项之一：

  • SELECT：查询指定视图。

  • ALTER：使用 修改视图的 DDL ALTER VIEW

  • DROP：使用 DROP VIEW 删除此视图。

ALL PRIVILEGES
撤销与同时属于撤销者的视图相关的所有权限。用户无法撤销其自身没有的权限。

可选关键字 PRIVILEGES 符合 SQL 标准。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

视图
要撤销其权限的视图。
grantee

指定其权限被撤销的用户，可以为以下用户之一：

CASCADE

I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。

示例

撤销用户 Joe 对视图 test_view 的 SELECT 权限。

=> REVOKE SELECT ON test_view FROM Joe;
REVOKE PRIVILEGE

另请参阅

5.31 - ROLLBACK

结束当前事务，并丢弃在事务期间发生的所有更改。

语法

ROLLBACK [ WORK | TRANSACTION ]

参数

WORK | TRANSACTION
不起任何作用；它们是可选的关键字，目的是提高可读性。

特权

无

注意

回退某项操作时，也会回退该操作获取的任何锁。

ABORT 是 ROLLBACK 的同义词。

示例

此示例显示了如何从某项 DELETE 事务执行回退。

=> SELECT * FROM sample_table;
a
---
1
(1 row)


=> DELETE FROM sample_table WHERE a = 1;


=> SELECT * FROM sample_table;
a
---
(0 rows)

=> ROLLBACK;

=> SELECT * FROM sample_table;
a
---
1
(1 row)

此示例显示了如何回退自 BEGIN 语句以来所做的更改。

=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ ONLY;
BEGIN

=> ROLLBACK TRANSACTION;
ROLLBACK

另请参阅

5.32 - ROLLBACK TO SAVEPOINT

回退自建立给定的保存点以来已在事务中输入的所有命令。

语法

ROLLBACK TO [SAVEPOINT] savepoint_name

参数

savepoint_name
指定要回退到的保存点名称。

特权

无

注意

  • 保存点将保持有效状态，如果将来需要，可以再次回退到该保存点。

  • 回退某项操作时，也会回退该操作获取的任何锁。

  • ROLLBACK TO SAVEPOINT 隐式销毁在命名保存点之后建立的所有保存点。

示例

以下示例回退了在建立保存点 my_savepoint 之后输入的值 102 和 103。在提交时仅插入了值 101 和 104。

=> INSERT INTO product_key VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (102);
=> INSERT INTO product_key VALUES (103);
=> ROLLBACK TO SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (104);
=> COMMIT;

另请参阅

5.33 - SAVE QUERY

保存输入查询以便与自定义定向查询相关联。

语法

SAVE QUERY input-query

参数

input‑query
要与自定义定向查询相关联的输入查询。输入查询仅支持一个优化器提示 :v。

特权

超级用户

描述

SAVE QUERY 保存指定输入查询以供 CREATE DIRECTED QUERY CUSTOM 的下一个调用使用。CREATE DIRECTED QUERY CUSTOM 将已保存的查询与其带注释的查询实参匹配，以创建定向查询。两种语句必须在同一用户会话中发起。

已保存的查询保持可用，直至发生以下事件之一：

  • CREATE DIRECTED QUERY 的下一个调用，无论是通过 CUSTOM 还是 OPTIMIZER 调用。

  • SAVE QUERY 的另一个调用。

  • 会话结束。

示例

请参阅自定义定向查询。

5.34 - SAVEPOINT

在事务内创建称之为保存点的特殊标记。创建保存点后，它允许回退所有已执行的命令，将事务还原到创建保存点时其所在的状态。

语法

SAVEPOINT savepoint_name

参数

savepoint_name
指定要创建的保存点的名称。

特权

无

注意

  • 保存点是事务的局部保存点，只能在事务块内时才可创建。

  • 可在事务内定义多个保存点。

  • 如果具有相同名称的保存点已存在，则其会被新保存点替换。

示例

以下示例显示了保存点如何确定事务内可回退的值。创建保存点“my_savepoint”后输入的值 102 和 103 已回退。在提交时仅插入了值 101 和 104。

=> INSERT INTO T1 (product_key) VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO T1 (product_key) VALUES (102);
=> INSERT INTO T1 (product_key) VALUES (103);
=> ROLLBACK TO SAVEPOINT my_savepoint;
=> INSERT INTO T1 (product_key) VALUES (104);
=> COMMIT;
=> SELECT product_key FROM T1;
.
.
.
101
104
(2 rows)

另请参阅

5.35 - SELECT

从一个或多个数据源返回结果集：表、视图、联接表和已命名查询。

语法

[ AT epoch ] [ WITH-clause ] SELECT [ ALL | DISTINCT ]
    { * | { MATCH_COLUMNS('pattern') | expression [ [AS] alias ] }[,...] }
    [ into-table-clause ]
    [ from-clause ]
    [ where-clause ]
    [ time-series-clause ]
    [ group-by-clause[,...] ]
    [ having-clause[,...] ]
    [ match-clause ]
    [ union-clause ]
    [ intersect-clause ]
    [ except-clause ]
    [ order-by-clause [ offset-clause ]]
    [ limit-clause ]
    [ FOR UPDATE [ OF table-name[,...] ] ]

参数

AT epoch
返回指定时期的数据，其中 epoch 为以下几项之一：

  • EPOCH LATEST：返回数据直到当前时期（但不包括当前时期）。结果集包括来自最新提交的 DML 事务的数据。

  • EPOCH integer：返回数据直到 integer 指定的时期（包括该指定时期）。

  • TIME 'timestamp'：从 timestamp 指定的时期返回数据。

有关 Vertica 如何使用时期的详细信息，请参阅时期。

有关详细信息，请参阅历史查询。

ALL | DISTINCT

  • ALL （默认值）：保留结果集或组中的重复行。

  • DISTINCT：移除结果集或组中的重复行。

ALL 或 DISTINCT 限定符必须紧跟在 SELECT 关键字后。只能有一个关键字实例出现在选择列表中。
*
列出查询的表中的所有列。
MATCH_COLUMNS('pattern')
返回查询的表中与模式匹配的所有列。
expression [[AS] alias]
一个表达式，通常解析为查询的表中的列数据，例如，在 FROM 子句中指定的 列的名称；此外：

您可以选择性地为每个列表达式分配一个临时别名，并在 SELECT 语句的其他位置（例如，在查询谓词或 ORDER BY 子句中）引用该别名。Vertica 使用别名作为查询输出中的列标题。

FOR UPDATE
指定对查询中指定的所有表获取 X 锁定，最常在 READ COMMITTED 隔离中使用。

FOR UPDATE 需要对查询的表具有更新/删除权限，且无法从只读事务中发出。

特权

非超级用户：

  • 对架构的 USAGE 权限

  • 对表或视图的 SELECT 权限

示例

当多个客户端在以下示例查询中运行事务时，如果未使用 FOR UPDATE，则将发生死锁。两个事务获取 S 锁，当两者尝试升级到 X 锁时，将遇到死锁：

=> SELECT balance FROM accounts WHERE account_id=3476 FOR UPDATE;
    ...
=> UPDATE accounts SET balance = balance+10 WHERE account_id=3476;
=> COMMIT;

另请参阅

5.35.1 - EXCEPT 子句

合并两个或多个 SELECT 查询。EXCEPT 返回在右侧查询中未查找到的左侧查询特定结果。

语法

SELECT
    EXCEPT except‑query[...]
    [ ORDER BY { column-name  | ordinal-number } [ ASC | DESC ] [,...] ]
    [ LIMIT { integer | ALL } ]
    [ OFFSET integer ]

注意

  • 使用 EXCEPT 子句可从 SELECT 语句中筛选出特定结果。EXCEPT 查询对两个或更多 SELECT 查询的结果执行操作。它只返回不同时存在于右侧查询中的左侧查询中的行。

  • 除非用括号另作指示，否则 Vertica 会从左向右评估同一 SELECT 查询中的多个 EXCEPT 子句。

  • 不能将 ALL 关键字与 EXCEPT 查询一起使用。

  • 各 SELECT 语句的结果必须是可合并的。各语句必须返回相同数量的列，且对应列的数据类型必须兼容。例如，不能对 INTEGER 类型的列和 VARCHAR 类型的列使用 EXCEPT 子句。如果语句不满足这些条件，Vertica 将返回错误。

  • 您可以在 FROM、WHERE 和 HAVING 子句中使用 EXCEPT。

  • 您可以通过在语句中加入 ORDER BY 操作的方式对 EXCEPT 操作的结果进行排序。编写 ORDER BY 列表时，请指定最左侧 SELECT 语句中的列名称，或者指定指示排序依据列的位置的整数。

  • 由于最右侧的查询指定 Vertica 对 EXCEPT 操作的结果执行操作，因此 EXCEPT 查询中最右侧的 ORDER BY、LIMIT 或 OFFSET 子句不需要加括号。包含在 SELECT 查询中且之前出现在 EXCEPT 查询中的任何 ORDER BY、LIMIT 或 OFFSET 子句都必须括在圆括号中。

  • Vertica 支持 EXCEPT 非相关子查询谓词。例如：

    => SELECT * FROM T1
   WHERE T1.x IN
      (SELECT MAX(c1) FROM T2
       EXCEPT
          SELECT MAX(cc1) FROM T3
       EXCEPT 
          SELECT MAX(d1) FROM T4);

示例

假设有下面三个表：

Company_A

  Id  | emp_lname |      dept      | sales
------+-----------+----------------+-------
 1234 | Stephen   | auto parts     |  1000
 5678 | Alice     | auto parts     |  2500
 9012 | Katherine | floral         |   500
 3214 | Smithson  | sporting goods |  1500
(4 rows)

Company_B

  Id  | emp_lname |    dept     | sales
------+-----------+-------------+-------
 4321 | Marvin    | home goods  |   250
 8765 | Bob       | electronics | 20000
 9012 | Katherine | home goods  |   500
 3214 | Smithson  | home goods  |  1500
(4 rows)

Company_C

  Id  | emp_lname |      dept      | sales
------+-----------+----------------+-------
 3214 | Smithson  | sporting goods |  1500
 5432 | Madison   | sporting goods |   400
 7865 | Cleveland | outdoor        |  1500
 1234 | Stephen   | floral         |  1000
(4 rows)

以下查询将返回存在于 Company_A 内但不存在于 Company_B 内的员工的 ID 和姓氏：

=> SELECT id, emp_lname FROM Company_A
   EXCEPT
   SELECT id, emp_lname FROM Company_B;
  id  | emp_lname
------+-----------
 1234 | Stephen
 5678 | Alice
(2 rows)

以下查询将按照员工的姓氏对上一查询的结果进行排序：

=> SELECT id, emp_lname FROM Company_A
   EXCEPT
   SELECT id, emp_lname FROM Company_B
   ORDER BY emp_lname ASC;
  id  | emp_lname
------+-----------
 5678 | Alice
 1234 | Stephen
(2 rows)

如果按列位置排序，查询将返回相同结果：

=> SELECT id, emp_lname FROM Company_A
   EXCEPT
   SELECT id, emp_lname FROM Company_B
   ORDER BY 2 ASC;
  id  | emp_lname
------+-----------
 5678 | Alice
 1234 | Stephen
(2 rows)

以下查询将返回存在于 Company_A 内但不存在于 Company_B 或 Company_C 内的员工的 ID 和姓氏：

=> SELECT id, emp_lname FROM Company_A
   EXCEPT
   SELECT id, emp_lname FROM Company_B
   EXCEPT
   SELECT id, emp_lname FROM Company_C;
  id  | emp_lname
------+-----------
 5678 | Alice
(1 row)

以下查询将显示不匹配数据类型的结果：

=> SELECT id, emp_lname FROM Company_A
   EXCEPT
   SELECT emp_lname, id FROM Company_B;
ERROR 3429:  For 'EXCEPT', types int and varchar are inconsistent
DETAIL:  Columns: id and emp_lname

以下示例使用 VMart 示例数据库，将返回通过商店购买商品且购买金额已超过 500 美元的康涅狄格州客户，但不包括现金支付的客户：

=> SELECT customer_key, customer_name FROM public.customer_dimension
      WHERE customer_key IN (SELECT customer_key FROM store.store_sales_fact
         WHERE sales_dollar_amount > 500
         EXCEPT
         SELECT customer_key FROM store.store_sales_fact
         WHERE tender_type = 'Cash')
      AND customer_state = 'CT';
 customer_key |    customer_name
--------------+----------------------
        15084 | Doug V. Lampert
        21730 | Juanita F. Peterson
        24412 | Mary U. Garnett
        25840 | Ben Z. Taylor
        29940 | Brian B. Dobisz
        32225 | Ruth T. McNulty
        33127 | Darlene Y. Rodriguez
        40000 | Steve L. Lewis
        44383 | Amy G. Jones
        46495 | Kevin H. Taylor
(10 rows)

另请参阅

5.35.2 - FROM 子句

要查询的数据源的逗号分隔列表。

语法

FROM dataset[,...] [ TABLESAMPLE(percent) ]

参数

dataset
要查询的一组数据，为以下几项之一：
TABLESAMPLE(percent)
指定返回记录的随机采样，其中 percent 指定近似采样大小。percent 值必须介于 0 和 100 之间（不含这两个值），且可以包含十进制值。无法保证返回的记录数是指定的确切百分比。

数据的所有行被选中的机会均等。Vertica 在应用其他查询筛选器之前执行采样。

示例

统计 customer_dimension 表中的所有记录：

=> SELECT COUNT(*) FROM customer_dimension;
 COUNT
-------
 50000
(1 row)

返回表 customer_dimension 中一小部分行的采样：

=> SELECT customer_name, customer_state FROM customer_dimension TABLESAMPLE(0.5) WHERE customer_state='IL';
    customer_name    | customer_state
---------------------+----------------
 Amy Y. McNulty      | IL
 Daniel C. Nguyen    | IL
 Midori O. Greenwood | IL
 Meghan U. Lampert   | IL
 Tiffany Y. Lang     | IL
 Laura S. King       | IL
 Steve T. Nguyen     | IL
 Craig S. Webber     | IL
 Luigi A. Lewis      | IL
 Mark W. Williams    | IL
(10 rows)

5.35.2.1 - Table-reference

语法

[[database.]schema.]table[ [AS] alias]

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
逻辑架构中的表。
[AS] alias
用于引用 table 的临时名称。

5.35.2.2 - Joined-table

指定如何联接表。

语法

table‑reference [join-type] JOIN table-reference[ TABLESAMPLE(sampling‑pct) ] [ ON join‑predicate ]

参数

table‑reference
表或其他的 joined-table。
join-type
有效值：
TABLESAMPLE
指定采用简单的随机采样返回近似的记录百分比。总潜在返回集中的所有行包含在采样中的机会均等。Vertica 在应用查询中的其他筛选器之前执行此采样操作。无法保证返回的记录数是 sampling‑pct 定义的确切的记录百分比。

TABLESAMPLE 选项仅可用于用户定义的表和数据收集器 (DC) 表。不支持视图和系统表。

sampling‑pct
指定作为采样的一部分返回的记录百分比。该值必须大于 0 且小于 100。
开启 join‑predicate
等值联接基于联接表中的一个或多个列。其对于 NATURAL 和 CROSS 联接无效，对于所有其他联接类型都是必需的。

备选联接语法选项

Vertica 支持两种较旧的联接语法约定：

  • WHERE 子句中的联接谓词指定的表联接

  • USING 子句指定的表联接

有关详细信息，请参阅联接语法。

示例

下列 SELECT 语句使用 TABLESAMPLE 选项限定其 JOIN 子句：

=> SELECT user_id.id, user_name.name FROM user_name TABLESAMPLE(50)
     JOIN user_id TABLESAMPLE(50) ON user_name.id = user_id.id;
  id  |  name
------+--------
  489 | Markus
 2234 | Cato
  763 | Pompey
(3 rows)

5.35.3 - GROUP BY 子句

在 GROUP BY 中将 SELECT 子句与聚合函数一起使用可以收集多个记录中的数据。Vertica 将结果分组成为一个或多个与表达式匹配的行集。

不包含聚合的 GROUP BY 子句的使用方式类似于 SELECT DISTINCT。

ROLLUP 是对 GROUP BY 子句的扩展。 ROLLUP 执行小计聚合。

语法

GROUP BY [/*+GBYTYPE(algorithm)*/] { expression | aggregate‑expression }[,...]

参数

/*+GBYTYPE(algorithm)*/
指定实现 GROUP BY 子句时优先级高于 Vertica 查询优化器可能选择的算法的算法。可以将 algorithm 设置为以下值之一：

  • HASH：GROUPBY HASH 算法

  • PIPE：GROUPBY PIPELINED 算法

有关两种算法的详细信息，请参阅 GROUP BY 实施选项。

表达式
任何表达式，包括 FROM 子句中指定的表中的常数和列引用。例如： 
column,... column, (expression)
aggregate‑expression
列、表达式、CUBE, GROUPING SETS 或 ROLLUP 聚合按顺序排列的列表。

可以将 CUBE 和 ROLLUP 聚合包括在一个 GROUPING SETS 聚合内。 CUBE 和 ROLLUP 聚合可产生大量输出。在这种情况下，使用 GROUPING SETS 仅返回某些结果。

不能将任何聚合包含在 CUBE 或 ROLLUP 表达式中。

可以将多个 GROUPING SETS、CUBE 或 ROLLUP 聚合附加到同一个查询中。例如：

  
GROUP BY a,b,c,d, ROLLUP(a,b)
GROUP BY a,b,c,d, CUBE((a,b),c,d)
GROUP BY a,b,c,d, CUBE(a,b), ROLLUP (c,d)
GROUP BY ROLLUP(a), CUBE(b), GROUPING SETS(c)
GROUP BY a,b,c,d, GROUPING SETS ((a,d),(b,c),CUBE(a,b))
GROUP BY a,b,c,d, GROUPING SETS ((a,d),(b,c),(a,b),(a),(b),())

用法注意事项

  • 表达式不能包括聚合函数。但是，可以将 GROUP BY 子句与 CUBE、GROUPING SETS 和 ROLLUP 一起使用，以返回每个组的汇总值。

  • 创建 GROUP BY 子句时，必须包括 SELECT 列表中显示的所有非聚合列。

  • 如果 GROUP BY 子句包括 WHERE 子句，Vertica 会忽略所有不满足 WHERE 子句的行。

示例

此示例显示了如何将 WHERE 子句与 GROUP BY 一起使用。在这种情况下，示例检索姓氏以 S 开头的所有员工，忽略所有不符合此条件的行。GROUP BY 子句使用 ILIKE 函数仅检索以 S 开头的姓氏。聚合函数 SUM 计算每个组的总休假天数。

=> SELECT employee_last_name, SUM(vacation_days)
   FROM employee_dimension
   WHERE employee_last_name ILIKE 'S%'
   GROUP BY employee_last_name;
 employee_last_name | SUM
--------------------+------
 Sanchez            | 2892
 Smith              | 2672
 Stein              | 2660
(3 rows)

以下示例中的 GROUP BY 子句按供应商地区和供应商地区的最大交易对结果分组：


=> SELECT vendor_region, MAX(deal_size) AS "Biggest Deal"
   FROM vendor_dimension
   GROUP BY vendor_region;
 vendor_region | Biggest Deal
---------------+--------------
 East          |       990889
 MidWest       |       699163
 NorthWest     |        76101
 South         |       854136
 SouthWest     |       609807
 West          |       964005
(6 rows)

以下查询使用 HAVING 子句修改上一个查询，该子句指定仅返回最大交易规模超过 $900,000 的组：

=> SELECT vendor_region, MAX(deal_size) as "Biggest Deal"
   FROM vendor_dimension
   GROUP BY vendor_region
   HAVING MAX(deal_size) > 900000;
 vendor_region | Biggest Deal
---------------+--------------
 East          |       990889
 West          |       964005
(2 rows)

可以将 GROUP BY 子句与标量类型的一维数组一起使用。在以下示例中，grants 为 ARRAY[VARCHAR]，grant_values 为 ARRAY[INT]。

=> CREATE TABLE employees (id INT, department VARCHAR(50), grants ARRAY[VARCHAR], grant_values ARRAY[INT]);

=> COPY employees FROM STDIN;
42|Physics|[US-7376,DARPA-1567]|[65000,135000]
36|Physics|[US-7376,DARPA-1567]|[10000,25000]
33|Physics|[US-7376]|[30000]
36|Astronomy|[US-7376,DARPA-1567]|[5000,4000]
\.

=> SELECT department, grants, SUM(apply_sum(grant_values)) FROM employees GROUP BY grants, department;
 department |          grants          |  SUM
------------+--------------------------+--------
 Physics    | ["US-7376","DARPA-1567"] | 235000
 Astronomy  | ["US-7376","DARPA-1567"] |   9000
 Physics    | ["US-7376"]              |  30000
(3 rows)

不包含聚合的 GROUP BY 子句的使用方式类似于 SELECT DISTINCT。例如，以下两个查询返回相同的结果：

=> SELECT DISTINCT household_id FROM customer_dimension;

=> SELECT household_id FROM customer_dimension GROUP BY household_id;

另请参阅

5.35.3.1 - ROLLUP 聚合

作为 GROUP BY 子句的扩展来自动执行小计聚合。 ROLLUP 在单个 SQL 查询内的不同级别跨多个维度执行聚合。

您可以将 ROLLUP 子句与三个分组函数一起使用：

语法

ROLLUP grouping-expression[,...]

参数

group‑expression
以下两项中的一个或两个：

  • 一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：

    column1, (column2+1), column3+column4

  • 一个多级表达式，是以下几项之一：

    • ROLLUP

    • CUBE

    • GROUPING SETS

限制

GROUP BY ROLLUP 不会对结果排序。要对数据进行排序，ORDER BY 子句必须跟在 GROUP BY 子句之后。

聚合级别

如果 n 为分组列的数量，则 ROLLUP 将生成 n+1 个小计和总计级别。由于 ROLLUP 将删除每一步中最右侧的列，所以请仔细指定列顺序。

假设 ROLLUP(A, B, C) 创建 4 个组：

  • (A, B, C)

  • (A, B)

  • (A)

  • ()

由于 ROLLUP 将删除每一步中最右侧的列，所以没有 (A, C) 和 (B, C) 组。

如果将 2 个或更多的列括在圆括号内，GROUP BY 会将其视为单一实体。例如：

  • ROLLUP(A, B, C) 将创建 4 个组：

    
(A, B, C)
(A, B)
(A)
()

  • ROLLUP((A, B), C) 会将 (A, B) 视为单一实体并创建 3 个组：

    (A, B, C)
(A, B)
()

示例：聚合完整数据集

以下示例显示了如何使用 GROUP BY 子句确定几年内家庭用电和书籍的开支。SUM 聚合函数计算每年在各类别上的总开销。

假设您有一个表，其中包含关于家庭书籍和用电开支的信息：

=> SELECT * FROM expenses ORDER BY Category, Year;
 Year |  Category   | Amount
------+-------------+--------
2005  | Books       |  39.98
2007  | Books       |  29.99
2008  | Books       |  29.99
2005  | Electricity | 109.99
2006  | Electricity | 109.99
2007  | Electricity | 229.98

对于 expenses 表，ROLLUP 计算 2005–2007 年之间各类别的小计：

  • 书籍：$99.96

  • 用电：$449.96

  • 总计：$549.92。

使用 ORDER BY 子句对结果排序：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY ROLLUP(Category, Year) ORDER BY 1,2, GROUPING_ID();
 Category    | Year |  SUM
-------------+------+--------
 Books       | 2005 |  39.98
 Books       | 2007 |  29.99
 Books       | 2008 |  29.99
 Books       |      |  99.96
 Electricity | 2005 | 109.99
 Electricity | 2006 | 109.99
 Electricity | 2007 | 229.98
 Electricity |      | 449.96
             |      | 549.92

示例：将 ROLLUP 与 HAVING 子句一起使用

此示例说明如何将 ROLLUP 与 HAVING 子句一起使用，以限制 GROUP BY 结果。以下查询只生成 ROLLUP 类别，其中 year 根据 GROUPING 函数中的表达式得出小计：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY ROLLUP(Category,Year) HAVING GROUPING(Year)=1
   ORDER BY 1, 2, GROUPING_ID();
 Category    | Year |  SUM
-------------+------+--------
 Books       |      |  99.96
 Electricity |      | 449.96
             |      | 549.92

下一个示例对 (Category, Year) 而非完整结果进行汇总。GROUPING_ID 函数指定聚合 3 个以下的级别：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY ROLLUP(Category,Year) HAVING GROUPING_ID(Category,Year)<3
   ORDER BY 1, 2, GROUPING_ID();
 Category    | Year |  SUM
-------------+------+--------
 Books       | 2005 |  39.98
 Books       | 2007 |  29.99
 Books       | 2008 |  29.99
 Books       |      |  99.96
 Electricity | 2005 | 109.99
 Electricity | 2006 | 109.99
 Electricity | 2007 | 229.98
 Electricity |      | 449.96

另请参阅

5.35.3.2 - CUBE 聚合

作为 GROUP BY 子句的扩展，自动对指定列执行所有可能的聚合。

您可以将 ROLLUP 子句与三个分组函数一起使用：

语法

GROUP BY group-expression[,...]

参数

group-expression
以下两项中的一个或两个：

  • 一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：

    column1, (column2+1), column3+column4

  • 一个多级表达式，是以下几项之一：

    • ROLLUP

    • CUBE

    • GROUPING SETS

限制

  • GROUP BY CUBE 不对数据排序。如果要对数据排序，请使用 ORDER BY 子句。ORDER BY 子句必须跟在 GROUP BY 子句的后面。
  • CUBE 可以用在 GROUPING SETS 表达式中，但不可以用在 ROLLUP 表达式或另一个 CUBE 表达式中。

CUBE 聚合级别

如果 n 是指分组列的数量，则 CUBE 将生成 2n 个聚合级别。例如：

CUBE (A, B, C) 将生成所有可能的分组，即产生以下八个组：

  • (A, B, C)
  • (A, B)
  • (A, C)
  • (B, C)
  • (A)
  • (B)
  • (C)
  • ()

如果增加 CUBE 列数，则 CUBE 分组数会呈指数增加。CUBE 查询可能会占用大量资源，并产生不感兴趣的组合。在这种情况下，请考虑使用 GROUPING SETS 聚合，因为通过它可以选择特定的分组。

示例

使用 CUBE 返回所有分组

假设您有一个表，其中包含关于家庭书籍和用电开支的信息：

=> SELECT * FROM expenses ORDER BY Category, Year;
 Year |  Category   | Amount
------+-------------+--------
2005  | Books       |  39.98
2007  | Books       |  29.99
2008  | Books       |  29.99
2005  | Electricity | 109.99
2006  | Electricity | 109.99
2007  | Electricity | 229.98

使用 CUBE 聚合按类别和年份聚合数据：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY CUBE(Category, Year) ORDER BY 1, 2, GROUPING_ID();
 Category    | Year |  SUM
-------------+------+--------
 Books       | 2005 |  39.98
 Books       | 2007 |  29.99
 Books       | 2008 |  29.99
 Books       |      |  99.96
 Electricity | 2005 | 109.99
 Electricity | 2006 | 109.99
 Electricity | 2007 | 229.98
 Electricity |      | 449.96
             | 2005 | 149.97
             | 2006 | 109.99
             | 2007 | 259.97
             | 2008 |  29.99
             |      | 549.92

结果会包含每个类别和年份的小计以及总计 ($549.92)。

将 CUBE 与 HAVING 子句一起使用

此示例显示了如何限制 GROUP BY 结果以及如何将 CUBE 聚合与 HAVING 子句结合使用。此查询仅返回类别合计和总计：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY CUBE(Category,Year) HAVING GROUPING(Year)=1;
 Category    | Year |  SUM
-------------+------+--------
 Books       |      |  99.96
 Electricity |      | 449.96
             |      | 549.92

下一个查询仅返回每个年度两种类别的聚合。GROUPING ID 函数指定忽略总计 ($549.92)：

=> SELECT Category, Year, SUM (Amount) FROM expenses
   GROUP BY CUBE(Category,Year) HAVING GROUPING_ID(Category,Year)<2
   ORDER BY 1, 2, GROUPING_ID();
 Category   | Year |  SUM
------------+------+--------
 Books      | 2005 |  39.98
 Books      | 2007 |  29.99
 Books      | 2008 |  29.99
 Books      |      |  99.96
 Electrical | 2005 | 109.99
 Electrical | 2006 | 109.99
 Electrical | 2007 | 229.98
 Electrical |      | 449.96

另请参阅

5.35.3.3 - GROUPING SETS 聚合

GROUPING SETS 聚合是对在您指定的分组上自动执行小计聚合的 GROUP BY 子句的扩展。

您可以将 GROUPING SETS 子句与三个分组函数一起使用：

若要对数据排序，请使用 ORDER BY 子句。ORDER BY 子句必须跟在 GROUP BY 子句之后。

语法

GROUP BY group-expression[,...]

参数

group-expression
以下两项中的一个或两个：

  • 一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：

    column1, (column2+1), column3+column4

  • 一个多级表达式，是以下几项之一：

    • ROLLUP

    • CUBE

    • GROUPING SETS

定义分组

GROUPING SETS 允许您准确指定结果中需要哪些组。您还可以按照以下方式联接分组：

以下示例子句的分组结果将会显示。

示例：选择分组

此示例显示了如何仅选择您需要的分组。假设您仅希望聚合列，并且您不需要总计。第一个查询会忽略合计。在第二个查询中，您将 () 添加到 GROUPING SETS 列表以获得合计。使用 ORDER BY 子句按分组对结果进行排序：

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY GROUPING SETS((Category, Year), (Year))
   ORDER BY 1, 2, GROUPING_ID();
  Category  | Year |  SUM
------------+------+--------
 Books      | 2005 |  39.98
 Books      | 2007 |  29.99
 Books      | 2008 |  29.99
 Electrical | 2005 | 109.99
 Electrical | 2006 | 109.99
 Electrical | 2007 | 229.98
            | 2005 | 149.97
            | 2006 | 109.99
            | 2007 | 259.97
            | 2008 |  29.99

=> SELECT Category, Year, SUM(Amount) FROM expenses
   GROUP BY GROUPING SETS((Category, Year), (Year), ())
   ORDER BY 1, 2, GROUPING_ID();
  Category  | Year |  SUM
------------+------+--------
 Books      | 2005 |  39.98
 Books      | 2007 |  29.99
 Books      | 2008 |  29.99
 Electrical | 2005 | 109.99
 Electrical | 2006 | 109.99
 Electrical | 2007 | 229.98
            | 2005 | 149.97
            | 2006 | 109.99
            | 2007 | 259.97
            | 2008 |  29.99
            |      | 549.92

另请参阅

5.35.4 - HAVING 子句

筛选 GROUP BY 子句的结果。根据语义，HAVING 子句必须发生在 GROUP BY 操作之后。该子句已添加到 SQL 标准，因为 WHERE 子句无法指定聚合函数。

语法

HAVING condition[,...]

参数

condition
明确引用分组列，除非引用显示在聚合函数中。

示例

以下示例返回薪资大于 $800,000 的员工：


=> SELECT employee_last_name, MAX(annual_salary) as highest_salary FROM employee_dimension
     GROUP BY employee_last_name HAVING MAX(annual_salary) > 800000 ORDER BY highest_salary DESC;
 employee_last_name | highest_salary
--------------------+----------------
 Sanchez            |         992363
 Vogel              |         983634
 Vu                 |         977716
 Lewis              |         957949
 Taylor             |         953373
 King               |         937765
 Gauthier           |         927335
 Garnett            |         903104
 Bauer              |         901181
 Jones              |         885395
 Rodriguez          |         861647
 Young              |         846657
 Greenwood          |         837543
 Overstreet         |         831317
 Garcia             |         811231
(15 rows)

5.35.5 - INTERSECT 子句

计算两个或更多 SELECT 查询结果的交集。INTERSECT 返回 INTERSECT 操作数左右两侧查询的唯一值。

语法

select‑stmt
    INTERSECT query[...]
    [ order-by-clause  [ offset-clause ]]
    [ limit-clause ]

注意

  • INTERSECT 子句返回 SELECT 查询结果的交集。INTERSECT 查询对两个或更多 SELECT 查询的结果执行操作。INTERSECT 仅返回所有指定查询所得到的行。

  • 不能将 ALL 关键字与 INTERSECT 查询一起使用。

  • 每个 SELECT 查询的结果必须是联集兼容的；必须返回相同数目的列，而且相应的列必须含有兼容的数据类型。例如，不能对 INTERSECT 类型的列和 VARCHAR 类型的列使用 EXCEPT 子句。如果 SELECT 查询不满足这些条件，Vertica 将返回错误。

  • 使用 ORDER BY 子句为 INTERSECT 操作结果进行排序。在 ORDER BY 列表中，指定最左侧 SELECT 语句的列，或指定所按照排序列的所在位置。

  • 您可以在 FROM、WHERE 和 HAVING 子句中使用 INTERSECT。

  • 由于最右侧的查询指定 Vertica 对 INTERSECT 操作的结果执行操作，因此 INTERSECT 查询的 ORDER BY、LIMIT 或者 OFFSET 子句不需要加括号。包含在 SELECT 查询中且之前出现在 INTERSECT 查询中的任何 ORDER BY、LIMIT 或 OFFSET 子句都必须括在圆括号中。

  • 排序列名称来自于第一个 select。

  • Vertica 支持 INTERSECT 非相关子查询谓词。例如：

    => SELECT * FROM T1
   WHERE T1.x IN
      (SELECT MAX(c1) FROM T2
       INTERSECT
          SELECT MAX(cc1) FROM T3
       INTERSECT
          SELECT MAX(d1) FROM T4);

示例

假设有下面三个表：

Company_A

id       emp_lname     dept          sales
------+------------+----------------+-------
1234  | Stephen    | auto parts     | 1000
5678  | Alice      | auto parts     | 2500
9012  | Katherine  | floral         |  500
3214  | Smithson   | sporting goods | 1500

Company_B

id       emp_lname     dept        sales
------+------------+-------------+-------
4321  | Marvin     | home goods  |   250
9012  | Katherine  | home goods  |   500
8765  | Bob        | electronics | 20000
3214  | Smithson   | home goods  |  1500

Company_C

  id  | emp_lname |      dept      | sales
------+-----------+----------------+-------
 3214 | Smithson  | sporting goods |  1500
 5432 | Madison   | sporting goods |   400
 7865 | Cleveland | outdoor        |  1500
 1234 | Stephen   | floral         |  1000

以下查询返回 Company_A 和 Company_B 中都包含的 ID 号以及员工姓氏：

=> SELECT id, emp_lname FROM Company_A
   INTERSECT
   SELECT id, emp_lname FROM Company_B;
 id   | emp_lname
------+-----------
 3214 | Smithson
 9012 | Katherine
(2 rows)

接下来的查询返回相同的两个员工，销售额降序排列：

=> SELECT id, emp_lname, sales FROM Company_A
   INTERSECT
   SELECT id, emp_lname, sales FROM Company_B
   ORDER BY sales DESC;
  id  | emp_lname | sales
------+-----------+-------
 3214 | Smithson  |  1500
 9012 | Katherine |   500
(2 rows)

接下来的查询返回同时为两个公司工作而在 Company_B 公司中的销售额超过 1000 的员工姓名：

=> SELECT id, emp_lname, sales FROM Company_A
   INTERSECT
   (SELECT id, emp_lname, sales FROM company_B WHERE sales > 1000)
   ORDER BY sales DESC;
  id  | emp_lname | sales
------+-----------+-------
 3214 | Smithson  |  1500
(1 row)

接下来的查询返回同时为三个公司工作的员工 ID 号以及员工姓氏。

=> SELECT id, emp_lname FROM Company_A
    INTERSECT
   SELECT id, emp_lname FROM Company_B
   INTERSECT
   SELECT id, emp_lname FROM Company_C;
  id  | emp_lname
------+-----------
 3214 | Smithson
(1 row)

接下来的查询返回的是不匹配的数据类型结果；这两个查询不是联集兼容的：

=> SELECT id, emp_lname FROM Company_A
    INTERSECT
   SELECT emp_lname, id FROM Company_B;
ERROR 3429:  For 'INTERSECT', types int and varchar are inconsistent
DETAIL:  Columns: id and emp_lname

使用 VMart 示例数据库，接下来的查询返回有关通过在线销售渠道购买商品且购买金额超过 400 美元和 500 美金的所有康涅狄格州客户的信息：

=> SELECT customer_key, customer_name from public.customer_dimension
       WHERE customer_key IN (SELECT customer_key
         FROM online_sales.online_sales_fact
         WHERE sales_dollar_amount > 400
         INTERSECT
         SELECT customer_key FROM online_sales.online_sales_fact
         WHERE sales_dollar_amount > 500)
      AND customer_state = 'CT' ORDER BY customer_key;
 customer_key |     customer_name
--------------+------------------------
           39 | Sarah S. Winkler
           44 | Meghan H. Overstreet
           70 | Jack X. Cleveland
          103 | Alexandra I. Vu
          110 | Matt . Farmer
          173 | Mary R. Reyes
          188 | Steve G. Williams
          233 | Theodore V. McNulty
          250 | Marcus E. Williams
          294 | Samantha V. Young
          313 | Meghan P. Pavlov
          375 | Sally N. Vu
          384 | Emily R. Smith
          387 | Emily L. Garcia
...

上一个查询和下一个查询是等效的，并且返回相同的结果：

=> SELECT customer_key,customer_name FROM public.customer_dimension
       WHERE customer_key IN (SELECT customer_key
      FROM online_sales.online_sales_fact
         WHERE sales_dollar_amount > 400
         AND sales_dollar_amount < 500)
   AND customer_state = 'CT' ORDER BY customer_key;

另请参阅

5.35.6 - INTO TABLE 子句

从查询结果集中创建表。

语法

永久表：

INTO [TABLE] [[database.]schema.]table

临时表：

INTO [scope] TEMP[ORARY] [TABLE] [[database.]schema.]table
   [ ON COMMIT { DELETE | PRESERVE } ROWS ]

参数

scope
指定临时表定义的可见性：

  • GLOBAL （默认值）：表定义对所有会话可见，并且持续存在，直到显式删除了该表。

  • LOCAL：表定义仅对在其中创建该表定义的会话可见，并在会话结束后删除。

不论此设置如何，都可通过 ON COMMIT DELETE ROWS 和 ON COMMIT PRESERVE ROWS 关键字（见下文）设置临时表数据保留策略。

有关详细信息，请参阅创建临时表。

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

表
要创建的表的名称。
ON COMMIT { DELETE | PRESERVE } ROWS
指定数据为事务范围还是会话范围数据：

  • DELETE （默认）会将临时表标记为事务范围数据。每次提交之后，Vertica 会移除所有表数据。

  • PRESERVE 会将临时表标记为会话范围数据，这些数据在单个事务结束后仍会保存。但会话结束后，Vertica 会移除所有表数据。

示例

以下 SELECT 语句包含一个 INTO TABLE 子句，该子句使用 customer_dimension 创建表 newTable：

=> SELECT * INTO TABLE newTable FROM customer_dimension;

以下 SELECT 语句将创建临时表 newTempTable。默认情况下，临时表是在全局范围创建的，因此该表定义对其他会话可见并一直存在，直到其被显式删除。不会将 customer_dimension 数据复制到新表中，且 Vertica 会发出相应的警告：

=> SELECT * INTO TEMP TABLE newTempTable FROM customer_dimension;
WARNING 4102:  No rows are inserted into table "public"."newTempTable" because
  ON COMMIT DELETE ROWS is the default for create temporary table
HINT:  Use "ON COMMIT PRESERVE ROWS" to preserve the data in temporary table
CREATE TABLE

以下 SELECT 语句将创建本地临时表 newTempTableLocal。表仅对在其中创建该表的会话可见，并在会话结束后自动删除。INTO TABLE 子句包括 ON COMMIT PRESERVE ROWS，因此 Vertica 会将所有选择数据复制到新表中：

=> SELECT * INTO LOCAL TEMP TABLE newTempTableLocal ON COMMIT PRESERVE ROWS
     FROM customer_dimension;
CREATE TABLE

5.35.7 - LIMIT 子句

指定要从整个结果集或从分区结果集的窗口返回的结果集行数最大值。

语法

应用于整个结果集：

   LIMIT { num-rows | ALL }

应用于分区结果集的窗口：

   LIMIT num‑rows OVER ( PARTITION BY {{< codevar >}}column‑expr‑x{{< /codevar >}}, ORDER BY {{< codevar >}}column‑expr‑y{{< /codevar >}} [ASC | DESC]

参数

num‑rows
要返回的行的最大数量。
ALL
返回所有行，仅当 LIMIT 应用于整个结果集时才有效。
OVER()
指定如何就当前行而言对输入数据进行分区和排序。输入数据是查询在对 FROM、WHERE、GROUP BY 和 HAVING 子句求值之后返回的结果集。

有关详细信息，请参阅下面的将 LIMIT 与窗口分区结合使用。

限制返回的行

LIMIT 指定只返回已查询数据集中的前 k 行。行优先级通过查询的 ORDER BY 子句确定。

例如，以下查询将返回表 customer_dimension 中的前 10 行数据，按列 store_region 和 number_of_employees 的顺序排列：

=> SELECT store_region, store_city||', '||store_state location, store_name, number_of_employees
     FROM store.store_dimension WHERE number_of_employees <= 12 ORDER BY store_region, number_of_employees LIMIT 10;
 store_region |    location    | store_name | number_of_employees
--------------+----------------+------------+---------------------
 East         | Stamford, CT   | Store219   |                  12
 East         | New Haven, CT  | Store66    |                  12
 East         | New York, NY   | Store122   |                  12
 MidWest      | South Bend, IN | Store134   |                  10
 MidWest      | Evansville, IN | Store30    |                  11
 MidWest      | Green Bay, WI  | Store27    |                  12
 South        | Mesquite, TX   | Store124   |                  10
 South        | Cape Coral, FL | Store18    |                  11
 South        | Beaumont, TX   | Store226   |                  11
 South        | Houston, TX    | Store33    |                  11
(10 rows)

将 LIMIT 与窗口分区结合使用

您可以使用 LIMIT 对查询结果应用窗口分区，并限制每个窗口中返回的行数：

SELECT ... FROM dataset LIMIT num‑rows OVER ( PARTITION BY column‑expr‑x, ORDER BY column‑expr‑y [ASC | DESC] )

其中查询 dataset 在每个 column‑expr‑x 分区中返回具有最高或最低 column‑expr‑y 值的 num‑rows 个行。

例如，以下语句对表 store.store_dimension 进行了查询并在结果集上指定了窗口分区。LIMIT 设置为 2，所以每个窗口分区最多只能显示两行。OVER 子句指定按 store_region 对结果集进行分区，其中每个分区窗口显示某个区域中员工人数最少的两个商店：

=> SELECT store_region, store_city||', '||store_state location, store_name, number_of_employees FROM store.store_dimension
     LIMIT 2 OVER (PARTITION BY store_region ORDER BY number_of_employees ASC);
 store_region |      location       | store_name | number_of_employees
--------------+---------------------+------------+---------------------
 West         | Norwalk, CA         | Store43    |                  10
 West         | Lancaster, CA       | Store95    |                  11
 East         | Stamford, CT        | Store219   |                  12
 East         | New York, NY        | Store122   |                  12
 SouthWest    | North Las Vegas, NV | Store170   |                  10
 SouthWest    | Phoenix, AZ         | Store228   |                  11
 NorthWest    | Bellevue, WA        | Store200   |                  19
 NorthWest    | Portland, OR        | Store39    |                  22
 MidWest      | South Bend, IN      | Store134   |                  10
 MidWest      | Evansville, IN      | Store30    |                  11
 South        | Mesquite, TX        | Store124   |                  10
 South        | Beaumont, TX        | Store226   |                  11
(12 rows)

5.35.8 - MATCH 子句

允许您以搜索事件模式筛选大量历史数据的 SQL 扩展， MATCH 子句为解析分区、排序提供子类，并基于您定义的模式匹配结果表的行。

您指定一个由 DEFINE 子句中定义的事件类型组成的模式作为正则表达式，其中每个事件都与输入表中的一行对应。接下来，您可以在输入事件序列内搜索模式。模式匹配返回符合 PATTERN 子句的连续行序列。例如，模式 P (A B* C) 由三个事件类型组成：A、B 和 C，当 Vertica 在输入表中找到匹配时，相关模式实例必须是一个 A 类型事件，且后接零个或多个 B 类型事件和一个 C 类型事件。

如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。有关详细信息，请参阅事件系列模式匹配。

语法

MATCH ( [ PARTITION BY table‑column ] ORDER BY table‑column
    DEFINE event‑name AS boolean‑expr [,...]
    PATTERN pattern‑name AS ( regexp )
    [ rows‑match‑clause ] )

参数

PARTITION BY
定义与 PATTERN 子句中定义的模式相匹配的窗口数据范围。分区子句通过 PATTERN 子句中定义的匹配模式将数据分区。使用 OEDER BY 子句对每个分区中的数据进行排序。如果忽略分区子句，则将整个数据集视为单个分区。
ORDER BY
定义与 PATTERN 子句中定义的模式相匹配的窗口数据范围。对于每个分区，顺序子句指定如何针对模式匹配对输入数据排序。
DEFINE
定义在正则表达式中构成事件类型的 boolean 表达式。例如： 
DEFINE
 Entry    AS RefURL  NOT ILIKE '%website2.com%' AND PageURL ILIKE
                               '%website2.com%',
 Onsite   AS PageURL ILIKE     '%website2.com%' AND Action='V',
  
 Purchase AS PageURL ILIKE     '%website2.com%' AND Action='P'

DEFINE 子句最多可接受 52 个事件。有关示例，请参阅 事件系列模式匹配。

event‑name
每一行需要进行评估的事件名称，如前面示例中的 Entry, Onsite, Purchase。
boolean‑expr
返回 true 或 false 的表达式。boolean_expr 可包含 布尔运算符 和相关 (comparison) 运算符。例如： 
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN pattern‑name
在 PATTERN 子句中定义的模式的名称，例如，P 是如下文定义的模式名称： 
 PATTERN P AS (...)

PATTERN 是由名称和正则表达式组成的搜索模式。

regexp
一个正则表达式，由 DEFINE 子句中定义的事件类型和下面的一个或多个限定符组成。当 Vertica 评估 MATCH 子句时，正则表达式会识别满足表达式条件的行。
rows‑match‑clause
指定如何解决单一行中评估为真的事件多于一个的问题，为以下几项之一：

  • ROWS MATCH ALL EVENTS：如果单一行中的多个事件评估为真，Vertica 将返回以下错误：

    ERROR: pattern events must be mutually exclusive
HINT:  try using ROWS MATCH FIRST EVENT

  • ROWS MATCH FIRST EVENT：如果给定行中的多个事件评估为真，Vertica 将使用该行的 SQL 语句中的第一个事件。

模式语意评估

  • SQL 子句的语意评估顺序是：FROM -> WHERE -> PATTERN MATCH -> SELECT。

  • 数据根据 PARTITION BY 子句的规定分区。如果忽略分区子句，则将整个数据集视为单个分区。

  • 对于每个分区，顺序子句指定如何针对模式匹配对输入数据排序。

  • 对每一行的事件进行评估。一行可以具有 0、1 或 N 个事件评估为真。如果同一行中评估为真的事件超过一个，除非您指定 ROWS MATCH FIRST EVENT，否则 Vertica 将返回一个运行时错误。如果指定了 ROWS MATCH FIRST EVENT，且单一行中评估为真的事件多于一个，Vertica 将选择 SQL 语句中第一个定义的事件用于行。

  • Vertica 通过查找符合 PATTERN 子句中定义模式的连续行序列执行模式匹配。

对于每一个匹配，Vertica 将输出匹配行。并非匹配一部分的行（不满足一个或多个术语）不输出。

  • Vertica 仅报告非重叠匹配。如果发生重叠，Vertica 将选择输入流中发现的第一个匹配。查找到匹配后，Vertica 会在前一次匹配结束后，开始搜索下一个匹配。

  • Vertica 将报告最长可能匹配，而不是匹配的子集。例如，考虑模式：AB（包含输入）：AAAB。因为 A 使用贪婪正则表达式量词 ()，所以 Vertica 会报告所有 A 的输入 (AAAB)，而不是 AAB、AB 或 B。

注释和限制

  • 模式匹配查询中不允许使用 DISTINCT 和 GROUP BY/HAVING 子句。

  • 下面的表达式不可用于 DEFINE 子句：

    • 子查询，如 DEFINE X AS c IN ELECT c FROM table

    • 分析函数，如 DEFINE X AS c <EA1) OVER (ORDER BY 1)

    • 聚合函数，如 DEFINE X AS c <A1)

  • 不可使用相同的模式名称定义不同的事件，例如，X 不允许执行下文：

    DEFINE   X AS c1 <  3
  X AS c1  >= 3

  • 与 MATCH 子句一起使用，Vertica MATCH 子句函数 提供关于模式的额外数据。例如，您可是使用函数返回表示与输入行相匹配的事件名称、匹配的序列号或匹配模式实例的分区范围内唯一标识符。

示例

例如，请参阅事件系列模式匹配。

另请参阅

5.35.8.1 - 事件系列模式匹配

搜索事件模式时，您可以使用 SQL MATCH 子句 语法来筛选大量历史数据。您可以将模式指定为正则表达式，然后可以在输入事件序列内搜索该模式。MATCH 提供了分析数据分区和排序的子句，以及对连续行集执行的模式匹配。

如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。典型的在线点击流漏斗是：

公司主页 -> 产品主页 -> 搜索 -> 结果 -> 在线购买

您可以使用此单击流漏斗，在用户的 Web 点击序列中搜索匹配并标识该用户：

  • 登录公司主页

  • 导航至产品页面

  • 运行查询

  • 单击搜索结果中的链接

  • 购买

单击流漏斗架构

此主题中的示例使用了此点击流漏斗以及以下 clickstream_log 表架构：

=> CREATE TABLE clickstream_log (
  uid INT,             --user ID
  sid INT,             --browsing session ID, produced by previous sessionization computation
  ts TIME,             --timestamp that occurred during the user's page visit
  refURL VARCHAR(20),  --URL of the page referencing PageURL
  pageURL VARCHAR(20), --URL of the page being visited
  action CHAR(1)       --action the user took after visiting the page ('P' = Purchase, 'V' = View)
);

INSERT INTO clickstream_log VALUES (1,100,'12:00','website1.com','website2.com/home', 'V');
INSERT INTO clickstream_log VALUES (1,100,'12:01','website2.com/home','website2.com/floby', 'V');
INSERT INTO clickstream_log VALUES (1,100,'12:02','website2.com/floby','website2.com/shamwow', 'V');
INSERT INTO clickstream_log values (1,100,'12:03','website2.com/shamwow','website2.com/buy', 'P');
INSERT INTO clickstream_log values (2,100,'12:10','website1.com','website2.com/home', 'V');
INSERT INTO clickstream_log values (2,100,'12:11','website2.com/home','website2.com/forks', 'V');
INSERT INTO clickstream_log values (2,100,'12:13','website2.com/forks','website2.com/buy', 'P');
COMMIT;

以下为 clickstream_log 表的输出：

=> SELECT * FROM clickstream_log;
 uid | sid |    ts    |        refURL        |       pageURL        | action
-----+-----+----------+----------------------+----------------------+--------
   1 | 100 | 12:00:00 | website1.com         | website2.com/home    | V
   1 | 100 | 12:01:00 | website2.com/home    | website2.com/floby   | V
   1 | 100 | 12:02:00 | website2.com/floby   | website2.com/shamwow | V
   1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy     | P
   2 | 100 | 12:10:00 | website1.com         | website2.com/home    | V
   2 | 100 | 12:11:00 | website2.com/home    | website2.com/forks   | V
   2 | 100 | 12:13:00 | website2.com/forks   | website2.com/buy     | P
(7 rows)

示例

此示例包括 Vertica MATCH 子句函数，以便分析用户在 website2.com 上的浏览历史记录。它会确定用户执行以下任务的模式：

  • 从其他网站登录 website2.com（进入）

  • 浏览任意数量的其他页面（站内）

  • 做出购买（购买）

在以下语句中，模式 P (Entry Onsite* Purchase) 包括三种事件类型：进入、站内和购买。当 Vertica 在输入表中找到匹配时，相关模式实例必须是一个进入事件类型，且后跟零个或多个站内事件类型以及一个购买事件类型

=> SELECT uid,
       sid,
       ts,
       refurl,
       pageurl,
       action,
       event_name(),
       pattern_id(),
       match_id()
FROM clickstream_log
MATCH
  (PARTITION BY uid, sid ORDER BY ts
   DEFINE
     Entry    AS RefURL  NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
     Onsite   AS PageURL ILIKE     '%website2.com%' AND Action='V',
     Purchase AS PageURL ILIKE     '%website2.com%' AND Action = 'P'
   PATTERN
     P AS (Entry Onsite* Purchase)
   ROWS MATCH FIRST EVENT);

在以下输出中，前四行代表用户 1 的浏览活动的模式，而剩下三行显示了用户 2 的浏览习惯。

 uid | sid |    ts    |        refurl        |       pageurl        | action | event_name | pattern_id | match_id
-----+-----+----------+----------------------+----------------------+--------+------------+------------+----------
   1 | 100 | 12:00:00 | website1.com         | website2.com/home    | V      | Entry      |          1 |        1
   1 | 100 | 12:01:00 | website2.com/home    | website2.com/floby   | V      | Onsite     |          1 |        2
   1 | 100 | 12:02:00 | website2.com/floby   | website2.com/shamwow | V      | Onsite     |          1 |        3
   1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy     | P      | Purchase   |          1 |        4
   2 | 100 | 12:10:00 | website1.com         | website2.com/home    | V      | Entry      |          1 |        1
   2 | 100 | 12:11:00 | website2.com/home    | website2.com/forks   | V      | Onsite     |          1 |        2
   2 | 100 | 12:13:00 | website2.com/forks   | website2.com/buy     | P      | Purchase   |          1 |        3
(7 rows)

另请参阅

5.35.9 - MINUS 子句

MINUS 是 EXCEPT 的别名。

5.35.10 - OFFSET 子句

从结果集的开头忽略指定的行数。

语法

OFFSET rows

参数

start‑row
指定要包含在结果集中的第一行。前面的所有行都将被忽略。

依赖关系

  • 将 ORDER BY 子句与 OFFSET 一起使用。否则，查询将返回结果集的一个不确定子集。

  • 在 SELECT 语句或 UNION 子句中，OFFSET 必须跟在 ORDER BY 子句之后。

  • 当 SELECT 语句或 UNION 子句同时指定 LIMIT 和 OFFSET 时，Vertica 首先处理 OFFSET 语句，然后将 LIMIT 语句应用于其余行。

示例

以下查询从 customer_dimension 表中返回 14 行：

=> SELECT customer_name, customer_gender FROM customer_dimension
   WHERE occupation='Dancer' AND customer_city = 'San Francisco' ORDER BY customer_name;
    customer_name     | customer_gender
----------------------+-----------------
 Amy X. Lang          | Female
 Anna H. Li           | Female
 Brian O. Weaver      | Male
 Craig O. Pavlov      | Male
 Doug Z. Goldberg     | Male
 Harold S. Jones      | Male
 Jack E. Perkins      | Male
 Joseph W. Overstreet | Male
 Kevin . Campbell     | Male
 Raja Y. Wilson       | Male
 Samantha O. Brown    | Female
 Steve H. Gauthier    | Male
 William . Nielson    | Male
 William Z. Roy       | Male
(14 rows)

如果修改上一个查询以指定偏移量 8 (OFFSET 8)，Vertica 将跳过上一个结果集的前八行。查询会返回以下结果：

=> SELECT customer_name, customer_gender FROM customer_dimension
   WHERE occupation='Dancer' AND customer_city = 'San Francisco' ORDER BY customer_name OFFSET 8;
   customer_name   | customer_gender
-------------------+-----------------
 Kevin . Campbell  | Male
 Raja Y. Wilson    | Male
 Samantha O. Brown | Female
 Steve H. Gauthier | Male
 William . Nielson | Male
 William Z. Roy    | Male
(6 rows)

5.35.11 - ORDER BY 子句

对一个或多个列或列表达式的查询结果集进行排序。Vertica 使用当前区域设置和排序规则来对字符串值进行比较和排序。

语法

ORDER BY expression [ ASC | DESC ] [,...]

参数

表达式
以下几项之一：

  • SELECT 列表项的名称或序号。序号是指从左边开始计数的结果列的位置。这些序号用于对名称不唯一的列进行排序。序号对于分析函数的 OVER 子句的 ORDER BY 子句无效。

  • 未出现在 SELECT 列表中的列的任意表达式。

  • CASE 表达式。

ASC | DESC
指定是按升序还是降序对值进行排序。NULL 值是排序顺序中的第一个或最后一个，具体取决于数据类型：

  • INTEGER、INT、DATE/TIME：NULL 具有最小值。

  • FLOAT、BOOLEAN、CHAR、VARCHAR、ARRAY、SET：NULL 具有最大值

示例

下面的例子返回根据交易规模降序排列的客户媒体的全部城市和交易规模。

=> SELECT customer_city, deal_siz FROM customer_dimension WHERE customer_name = 'Metamedia'
   ORDER BY deal_size DESC;
  customer_city   | deal_size
------------------+-----------
 El Monte         |   4479561
 Athens           |   3815416
 Ventura          |   3792937
 Peoria           |   3227765
 Arvada           |   2671849
 Coral Springs    |   2643674
 Fontana          |   2374465
 Rancho Cucamonga |   2214002
 Wichita Falls    |   2117962
 Beaumont         |   1898295
 Arvada           |   1321897
 Waco             |   1026854
 Joliet           |    945404
 Hartford         |    445795
(14 rows)

以下示例使用转换函数。该示例返回了错误，因为 ORDER BY 列不在窗口分区中。

=> CREATE TABLE t(geom geometry(200), geog geography(200));
=> SELECT PolygonPoint(geom) OVER(PARTITION BY geom)
   AS SEL_0 FROM t ORDER BY geog;
ERROR 2521: Cannot specify anything other than user defined transforms and partitioning expressions in the ORDER BY list

以下示例使用同一个表更正了此错误。

=> SELECT PolygonPoint(geom) OVER(PARTITION BY geom)
   AS SEL_0 FROM t ORDER BY geom;

以下示例使用 ORDER BY 子句中的一个数组。

=> CREATE TABLE employees (id INT, department VARCHAR(50), grants ARRAY[VARCHAR], grant_values ARRAY[INT]);

=> COPY employees FROM STDIN;
42|Physics|[US-7376,DARPA-1567]|[65000,135000]
36|Physics|[US-7376,DARPA-1567]|[10000,25000]
33|Physics|[US-7376]|[30000]
36|Astronomy|[US-7376,DARPA-1567]|[5000,4000]
\.

=> SELECT * FROM employees ORDER BY grant_values;
 id | department |          grants          |  grant_values
----+------------+--------------------------+----------------
 36 | Astronomy  | ["US-7376","DARPA-1567"] | [5000,4000]
 36 | Physics    | ["US-7376","DARPA-1567"] | [10000,25000]
 33 | Physics    | ["US-7376"]              | [30000]
 42 | Physics    | ["US-7376","DARPA-1567"] | [65000,135000]
(4 rows)

5.35.12 - TIMESERIES 子句

空白填充和插值 (GFI) 计算，这是时序分析计算的一个重要组件。有关详细信息和示例，请参阅时序分析。

语法

TIMESERIES slice‑time AS 'length‑and‑time‑unit‑expr' OVER (
  [ PARTITION BY (column‑expr[,...] ] ORDER BY time‑expr ) [ ORDER BY table‑column[,...] ]

参数

slice‑time
TIMESERIES 子句产生的时间列，用于存储空白填充生成的时间片开始时间。

注意：此参数为别名，因此，您可以使用任何名称作为别名。

length‑and‑time‑unit‑expr
INTERVAL DAY TO SECOND 字面量，用于指定时间片计算的时间单位长度。例如： TIMESERIES slice_time AS '3 seconds' ...
OVER()
指定功能分区和排序。 OVER() 还指定时序函数在查询结果集上的操作—换而言之，评估 FROM、WHERE、GROUP BY 和 HAVING 子句之后返回的行。
PARTITION BY (column‑expr[,...] )
按指定的列表达式对数据进行分区。分别在每个分区上执行空白填充和插值。
ORDER BY time‑expr
按TIMESTAMP表达式 time-expr 对数据排序，以计算时序数据的时间信息。

注意

如果在 TIMESERIES OVER() 内没有为每个定义的时间片指定 window-partition-clause，则只产生一个输出记录；否则，则按每个时间片的每个分区产生一个输出记录。插值在该处计算。

如提供包含 TIMESERIES 子句的查询块，则以下是语义执行阶段（评估 FROM 和可选 WHERE 子句之后）：

  1. 计算 time-expression。

  2. 根据 time‑exp 和 'length‑and‑time‑unit‑expr' 的结果在每个输入记录上执行与 TIME_SLICE() 函数一样的计算。

    1. 执行空白填充以生成输入记录中缺失的时间片。

    2. 将此计算结果命名为 slice_time，表示空白填充之后生成的“时序”列（别名）。

  3. 按 expression、slice‑time 对数据分区。针对每个分区执行步骤 4。

  4. 按 time‑expr 对数据排序。插值在此处计算。

TIMESERIES 子句和 TIME_SLICE 函数之间存在语义重叠，主要区别如下：

  • TIMESERIES 仅支持间隔限定符DAY TO SECOND；不允许 YEAR TO MONTH。

  • 与 TIME_SLICE 不同，length‑and‑time‑unit‑expr 中表示的时间片长度和时间单位必须为常量，以便很好地界定时间片间隙。

  • TIMESERIES 执行空白填充，而 TIME_SLICE 函数则不执行。

  • TIME_SLICE 可以根据其第四个输入参数 (start‑or‑end) 的值来返回时间片的开始和结束时间。TIMESERIES，另一方面，始终返回每个时间片的开始时间。要输出每个时间片的结束时间，请写入 SELECT 语句，如下所示：

    => SELECT slice_time + <slice_length>;

限制

  • 在 SQL 查询块中发生 TIMESERIES 子句时，仅以下子句可用于相同查询块中：

    • SELECT

    • FROM

    • WHERE

    • ORDER BY

    不允许使用“GROUP BY”和“HAVING”子句。如果在间隙填充和插值 (GFI) 之前或之后需要执行“GROUP BY”操作，请使用子查询，并且将“GROUP BY”放入外部查询。例如： => SELECT symbol, AVG(first_bid) as avg_bid FROM ( SELECT symbol, slice_time, TS_FIRST_VALUE(bid1) AS first_bid FROM Tickstore WHERE symbol IN ('MSFT', 'IBM') TIMESERIES slice_time AS '5 seconds' OVER (PARTITION BY symbol ORDER BY ts) ) AS resultOfGFI GROUP BY symbol;

  • TIMESERIES 子句出现在 SQL 查询块时，SELECT 列表仅可包含以下：

    例如，以下两个查询返回语法错误，因为 bid1 不是 PARTITION BY 或 GROUP BY 列：

    => SELECT bid, symbol, TS_FIRST_VALUE(bid) FROM Tickstore
   TIMESERIES slice_time AS '5 seconds' OVER (PARTITION BY symbol ORDER BY ts);
   ERROR:  column "Tickstore.bid" must appear in the PARTITION BY list of Timeseries clause or be used in a Timeseries Output function
=> SELECT bid, symbol, AVG(bid) FROM Tickstore
   GROUP BY symbol;
   ERROR:  column "Tickstore.bid" must appear in the GROUP BY clause or be used in an aggregate function

示例

例如，请参阅空白填充和插值 (GFI)。

另请参阅

5.35.13 - UNION 子句

合并多个 SELECT 语句的结果。您也可以在 FROM、WHERE 和 HAVING 子句中包含 UNION。

语法

select‑stmt { UNION [ ALL | DISTINCT ] select-stmt }[...]
    [ order-by-clause  [ offset-clause ]]
    [ limit-clause ]

参数

select‑stmt
返回一行或多行的 SELECT 语句，具体取决于您指定的关键字是 DISTINCT 还是 ALL。

以下选项也适用：

DISTINCT | ALL
指定是否返回唯一行：

  • DISTINCT（默认）仅返回唯一行。

  • ALL 可连接所有行，包括重复行。为获得最佳性能，请使用 UNION ALL。

要求

  • UNION 结果集的所有行都必须存在于至少一个其 SELECT 语句的结果集中。

  • 每个 SELECT 语句必须指定相同的列数。

  • 对应的 SELECT 语句列的数据类型必须兼容，否则 Vertica 将返回错误。

UNION 中的 ORDER BY、LIMIT 和 OFFSET 子句

UNION 语句可以指定自己的 ORDER BY、LIMIT 和 OFFSET 子句。例如，对于以下示例中描述的表，以下查询将按 emp_name 对 UNION 结果集进行排序，并将输出限制为前两行：

=> SELECT id, emp_name FROM company_a UNION ALL SELECT id, emp_name FROM company_b ORDER BY emp_name LIMIT 2;
  id  | emp_name
------+----------
 5678 | Alice
 8765 | Bob
(2 rows)

UNION 子句中的每个 SELECT 语句都可以指定自己的 ORDER BY、LIMIT 和 OFFSET 子句。在这种情况下，SELECT 语句必须用括号括起来。Vertica 首先处理 SELECT 语句的 ORDER BY、LIMIT 和 OFFSET 子句，然后再处理 UNION 子句。

例如，以下 UNION 中的每个 SELECT 语句都指定了自己的 ORDER BY 和 LIMIT 子句。Vertica 处理单个查询，然后连接两个结果集：

=> (SELECT id, emp_name FROM company_a ORDER BY emp_name LIMIT 2)
   UNION ALL
   (SELECT id, emp_name FROM company_b ORDER BY emp_name LIMIT 2);
  id  | emp_name
------+-----------
 5678 | Alice
 9012 | Katherine
 8765 | Bob
 9012 | Katherine
(4 rows)

以下要求和限制用于确定 Vertica 处理包含 ORDER BY、LIMIT 和 OFFSET 子句的 UNION 子句的方式：

  • UNION 的 ORDER BY 子句必须使用第一个（最左侧的）SELECT 语句指定列。

  • 始终将 ORDER BY 子句与 LIMIT 和 OFFSET 一起使用。否则，查询将返回结果集的一个不确定子集。

  • ORDER BY 必须位于 LIMIT 和 OFFSET 之前。

  • 当 SELECT 或 UNION 语句同时指定 LIMIT 和 OFFSET 时，Vertica 首先处理 OFFSET 语句，然后将 LIMIT 语句应用于其余行。

非相关子查询中的 UNION

Vertica 支持非相关子查询谓词中的 UNION。例如：

=> SELECT DISTINCT customer_key, customer_name FROM public.customer_dimension WHERE customer_key IN
     (SELECT customer_key FROM store.store_sales_fact WHERE sales_dollar_amount > 500
      UNION ALL
      SELECT customer_key FROM online_sales.online_sales_fact WHERE sales_dollar_amount > 500)
   AND customer_state = 'CT';
 customer_key |     customer_name
--------------+------------------------
         7021 | Luigi T. Dobisz
         1971 | Betty V. Dobisz
        46284 | Ben C. Gauthier
        33885 | Tanya Y. Taylor
         5449 | Sarah O. Robinson
        29059 | Sally Z. Fortin
        11200 | Foodhope
        15582 | John J. McNulty
        24638 | Alexandra F. Jones
 ...

示例

使用这两个表的示例：

company_a

  ID    emp_name       dept       sales
------+------------+-------------+-------
1234  | Stephen    | auto parts  | 1000
5678  | Alice      | auto parts  | 2500
9012  | Katherine  | floral      |  500

company_b

  ID    emp_name       dept       sales
------+------------+-------------+-------
4321  | Marvin     | home goods  |   250
9012  | Katherine  | home goods  |   500
8765  | Bob        | electronics | 20000

从 company_a 和 company_b 中查找所有员工 ID 和姓名

UNION 语句指定选项 DISTINCT，将合并员工的唯一 ID 和姓氏；Katherine 同时为两个公司工作，所以她在结果集中只出现一次。DISTINCT 为默认值，可以忽略：

=> SELECT id, emp_name FROM company_a UNION DISTINCT SELECT id, emp_name FROM company_b ORDER BY id;
  id  | emp_name
------+-----------
 1234 | Stephen
 4321 | Marvin
 5678 | Alice
 8765 | Bob
 9012 | Katherine
(5 rows)

下一个 UNION 语句指定选项 ALL。Katherine 同时为两个公司工作，因此查询返回两条与她相关的记录：

=> SELECT id, emp_name FROM company_a UNION ALL SELECT id, emp_name FROM company_b ORDER BY id;
  id  | emp_name
------+-----------
 1234 | Stephen
 5678 | Alice
 9012 | Katherine
 4321 | Marvin
 9012 | Katherine
 8765 | Bob
(6 rows)

查找每个公司里成绩最好的两名销售人员

每个 SELECT 语句都指定了自己的 ORDER BY 和 LIMIT 子句，因此 UNION 语句将连接每个查询返回的结果集：

=> (SELECT id, emp_name, sales FROM company_a ORDER BY sales DESC LIMIT 2)
   UNION ALL
   (SELECT id, emp_name, sales FROM company_b ORDER BY sales DESC LIMIT 2);
  id  |  emp_name | sales
------+-----------+-------
 8765 | Bob       | 20000
 5678 | Alice     |  2500
 1234 | Stephen   |  1000
 9012 | Katherine |   500
(4 rows)

查找所有员工的销售排序

UNION 语句指定其自己的 ORDER BY 子句，Vertica 将其应用于整个结果：

=> SELECT id, emp_name, sales FROM company_a
   UNION
   SELECT id, emp_name, sales FROM company_b
   ORDER BY sales;
  id  |  emp_name | sales
------+-----------+-------
 4321 | Marvin    |   250
 9012 | Katherine |   500
 1234 | Stephen   |  1000
 5678 | Alice     |  2500
 8765 | Bob       | 20000
(5 rows)

计算各公司各部门的销售总量

每个 SELECT 语句都有自己的 GROUP BY 子句。UNION 将合并每个查询的聚合结果：

=> (SELECT 'Company A' as company, dept, SUM(sales) FROM company_a
    GROUP BY dept)
    UNION
   (SELECT 'Company B' as company, dept, SUM(sales) FROM company_b
    GROUP BY dept)
    ORDER BY 1;
 company   |    dept     |  sum
-----------+-------------+-------
 Company A | auto parts  |  3500
 Company A | floral      |   500
 Company B | electronics | 20000
 Company B | home goods  |   750
(4 rows)

另请参阅

5.35.14 - WHERE 子句

指定要包含在查询结果集中的行。

语法

WHERE boolean-expression [ subquery ]...

参数

boolean‑expression
返回 true 或 false 的表达式。结果集仅包括计算结果为 true 的行。该表达式可以包含布尔运算符和以下元素：

使用圆括号将表达式、谓词和布尔运算符进行分组。例如：

... WHERE NOT (A=1 AND B=2) OR C=3;

示例

以下示例返回所有名字以 Amer 字符串开头的东部地区顾客的名字：

=> SELECT DISTINCT customer_name
   FROM customer_dimension
   WHERE customer_region = 'East'
   AND customer_name ILIKE 'Amer%';
 customer_name
---------------
 Americare
 Americom
 Americore
 Americorp
 Ameridata
 Amerigen
 Amerihope
 Amerimedia
 Amerishop
 Ameristar
 Ameritech
(11 rows)

5.35.15 - WITH 子句

WITH 子句定义了一个或多个已命名公用表表达式 (CTE)，其中每个 CTE 均封装了一个结果集，该结果集可以被同一个 WITH 子句中的另一个 CTE 引用或被主要查询引用。Vertica 可以对每个引用执行 CTE（内联展开），或将结果集实体化作为临时表，以供其所有引用重复使用。在这两种情况下，WITH 子句都可以帮助简化复杂查询并避免语句重复。

语法

WITH [ /*+ENABLE_WITH_CLAUSE_MATERIALIZATION */ ] [ RECURSIVE ] {
   cte‑identifier [ ( column-aliases ) ] AS (
   [ subordinate-WITH-clause ]
   query-expression )
} [,...]

参数

/*+ENABLE_WITH_CLAUSE_MATERIALIZATION*/
启用当前 WITH 子句中所有查询的实体化。否则，实体化由配置参数 WithClauseMaterialization 设置，默认设置为 0（禁用）。如果禁用 WithClauseMaterialization，则 WITH 子句的主查询返回时会自动清除实体化。有关详细信息，请参阅WITH 子句的实体化。
RECURSIVE
指定通过重复执行嵌入的 UNION 或 UNION ALL 语句来迭代 WITH 子句的结果集。请参阅下面的递归查询。
cte‑identifier
标识 WITH 子句中的公用表表达式 (CTE)。此标识符可用于同一 WITH 子句中的 CTE，也可用于父 WITH 子句和子 WITH 子句（如果有）中的 CTE。最外层（主）WITH 子句的 CTE 标识符也可用于主要查询。

同一 WITH 子句的所有 CTE 标识符必须是唯一的。例如，以下 WITH 子句定义了两个 CTE，因此它们需要唯一的标识符： regional_sales 和 top_regions：

  
WITH
-- query sale amounts for each region
   regional_sales AS (SELECT ... ),
   top_regions AS ( SELECT ... )
   )
column-aliases
结果集列别名的逗号分隔列表。别名列表必须映射到 CTE 查询中的所有列表达式。如果忽略，则只有查询中使用的名称才能引用结果集列。

在以下示例中，revenue CTE 指定了两个列别名： vkey 和 total_revenue。这两个别名分别映射到列 vendor_key 和聚合表达式 SUM(total_order_cost)。主要查询将引用这些别名：

  
WITH revenue ( vkey, total_revenue ) AS (
   SELECT vendor_key, SUM(total_order_cost)
   FROM store.store_orders_fact
   GROUP BY vendor_key ORDER BY vendor_key)
  
SELECT v.vendor_name, v.vendor_address, v.vendor_city, r.total_revenue
FROM vendor_dimension v JOIN revenue r ON v.vendor_key = r.vkey
WHERE r.total_revenue = (SELECT MAX(total_revenue) FROM revenue )
ORDER BY vendor_name;
subordinate‑WITH‑clause
嵌套在当前 WITH 子句中的 WITH 子句。此 WITH 子句中的 CTE 只能引用同一子句中的 CTE，或者父 WITH 子句和子 WITH 子句中的 CTE。
query-expression
给定 CTE 的查询。

限制

WITH 子句仅支持 SELECT 和 INSERT 语句。它们不支持 UPDATE 或 DELETE 语句。

递归查询

包含 RECURSIVE 选项的 WITH 子句可以重复执行 UNION 或 UNION ALL 查询，从而迭代其自身的输出。递归查询在处理分层结构（例如，经理下属关系）或树状结构数据（如分类法）等自引用数据时十分有用。

配置参数 WithClauseRecursionLimit（默认设置为 8）将设置递归的最大深度。您可以分别使用 ALTER DATABASE 和 ALTER SESSION 在数据库和会话范围内设置此参数。递归将会继续，直到达到配置的最大深度为止，或者直到最后一次迭代返回没有数据为止。

可以按如下方式指定递归 WITH 子句：

WITH [ /*+ENABLE_WITH_CLAUSE_MATERIALIZATION*/ ] RECURSIVE
   cte‑identifier [ ( column-aliases ) ] AS (
     non-recursive-term
     UNION [ ALL ]
     recursive-term
   )

非递归项和递归项由 UNION 或 UNION ALL 分隔：

  • non-recursive-term 查询将其结果集设置在 cte-identifier，在 recursive-term 中递归。

  • UNION 语句的 recursive-term 以递归方式迭代其自身输出。当递归完成时，所有迭代的结果均会编译并在 cte-identifier 中设置。

限制

存在以下限制：

  • 非递归项的 SELECT 列表不能包含通配符 *（星号）或函数 MATCH_COLUMNS。

  • 递归项只能引用目标 CTE 一次。

  • 递归引用不能出现在外联接中。

  • 递归引用不能出现在子查询中。

  • WITH 子句不支持 UNION 选项 ORDER BY、LIMIT 和 OFFSET。

示例

包含一个 CTE 的单个 WITH 子句

下面的 SQL 定义了一个包含单个 CTE 的 WITH 子句 revenue，该子句将聚合表 store.store_orders_fact 中的数据。主要查询将引用两次 WITH 子句结果集：在其 JOIN 子句和谓词中：

-- define WITH clause
WITH revenue ( vkey, total_revenue ) AS (
      SELECT vendor_key, SUM(total_order_cost)
      FROM store.store_orders_fact
      GROUP BY vendor_key ORDER BY 1)
-- End WITH clause

-- primary query
SELECT v.vendor_name, v.vendor_address, v.vendor_city, r.total_revenue
FROM vendor_dimension v JOIN revenue r ON v.vendor_key = r.vkey
WHERE r.total_revenue = (SELECT MAX(total_revenue) FROM revenue )
ORDER BY vendor_name;
   vendor_name    | vendor_address | vendor_city | total_revenue
------------------+----------------+-------------+---------------
 Frozen Suppliers | 471 Mission St | Peoria      |      49877044
(1 row)

包含多个 CTE 的单个 WITH 子句

在以下示例中，WITH 子句包含两个 CTE：

  • regional_sales 每个地区的销售总量

  • top_regions 使用 regional_sales 的结果集确定销售总量最高的三个地区：

主要查询在 top_regions 结果集中按地区和部门聚合销量：


WITH
-- query sale amounts for each region
   regional_sales (region, total_sales) AS (
        SELECT sd.store_region, SUM(of.total_order_cost) AS total_sales
        FROM store.store_dimension sd JOIN store.store_orders_fact of ON sd.store_key = of.store_key
        GROUP BY store_region ),
-- query previous result set
   top_regions AS (
        SELECT region, total_sales
        FROM regional_sales ORDER BY total_sales DESC LIMIT 3
     )

-- primary query
-- aggregate sales in top_regions result set
SELECT sd.store_region AS region, pd.department_description AS department, SUM(of.total_order_cost) AS product_sales
FROM store.store_orders_fact of
JOIN store.store_dimension sd ON sd.store_key = of.store_key
JOIN public.product_dimension pd ON of.product_key = pd.product_key
WHERE sd.store_region IN (SELECT region FROM top_regions)
GROUP BY ROLLUP (region, department) ORDER BY region, product_sales DESC, GROUPING_ID();

 region  |            department            | product_sales
---------+----------------------------------+---------------
 East    |                                  |    1716917786
 East    | Meat                             |     189837962
 East    | Produce                          |     170607880
 East    | Photography                      |     162271618
 East    | Frozen Goods                     |     141077867
 East    | Gifts                            |     137604397
 East    | Bakery                           |     136497842
 East    | Liquor                           |     130410463
 East    | Canned Goods                     |     128683257
 East    | Cleaning supplies                |     118996326
 East    | Dairy                            |     118866901
 East    | Seafood                          |     109986665
 East    | Medical                          |     100404891
 East    | Pharmacy                         |      71671717
 MidWest |                                  |    1287550770
 MidWest | Meat                             |     141446607
 MidWest | Produce                          |     125156100
 MidWest | Photography                      |     122666753
 MidWest | Frozen Goods                     |     105893534
 MidWest | Gifts                            |     103088595
 MidWest | Bakery                           |     102844467
 MidWest | Canned Goods                     |      97647270
 MidWest | Liquor                           |      97306898
 MidWest | Cleaning supplies                |      90775242
 MidWest | Dairy                            |      89065443
 MidWest | Seafood                          |      82541528
 MidWest | Medical                          |      76674814
 MidWest | Pharmacy                         |      52443519
 West    |                                  |    2159765937
 West    | Meat                             |     235841506
 West    | Produce                          |     215277204
 West    | Photography                      |     205949467
 West    | Frozen Goods                     |     178311593
 West    | Bakery                           |     172824555
 West    | Gifts                            |     172134780
 West    | Liquor                           |     164798022
 West    | Canned Goods                     |     163330813
 West    | Cleaning supplies                |     148776443
 West    | Dairy                            |     145244575
 West    | Seafood                          |     139464407
 West    | Medical                          |     126184049
 West    | Pharmacy                         |      91628523
         |                                  |    5164234493
(43 rows)

包含 WITH 子句的 INSERT 语句

以下 SQL 使用 WITH 子句将 JOIN 查询中的数据插入到表 total_store_sales 中：

CREATE TABLE total_store_sales (store_key int, region VARCHAR(20), store_sales numeric (12,2));

INSERT INTO total_store_sales
WITH store_sales AS (
        SELECT sd.store_key, sd.store_region::VARCHAR(20), SUM (of.total_order_cost)
        FROM store.store_dimension sd JOIN store.store_orders_fact of ON sd.store_key = of.store_key
        GROUP BY sd.store_region, sd.store_key ORDER BY sd.store_region, sd.store_key)
SELECT * FROM store_sales;

=> SELECT * FROM total_store_sales ORDER BY region, store_key;
 store_key |  region   | store_sales
-----------+-----------+-------------
         2 | East      | 47668303.00
         6 | East      | 48136354.00
        12 | East      | 46673113.00
        22 | East      | 48711211.00
        24 | East      | 48603836.00
        31 | East      | 46836469.00
        36 | East      | 48461449.00
        37 | East      | 48018279.00
        41 | East      | 48713084.00
        44 | East      | 47808362.00
        49 | East      | 46990023.00
        50 | East      | 47643329.00
         9 | MidWest   | 46851087.00
        15 | MidWest   | 48787354.00
        27 | MidWest   | 48497620.00
        29 | MidWest   | 47639234.00
        30 | MidWest   | 49013483.00
        38 | MidWest   | 48856012.00
        42 | MidWest   | 47297912.00
        45 | MidWest   | 48544521.00
        46 | MidWest   | 48887255.00
         4 | NorthWest | 47580215.00
        39 | NorthWest | 47136892.00
        47 | NorthWest | 48477574.00
         8 | South     | 48131455.00
        13 | South     | 47605422.00
        17 | South     | 46054367.00
...
(50 rows)

另请参阅

WITH 子句

5.36 - SET 语句

SET 语句用于更改数据库的运行方式，例如更改自动提交设置或会话使用的资源池。

5.36.1 - SET DATESTYLE

指定如何设置当前会话的日期/时间输出格式。使用 SHOW DATESTYLE 验证当前输出设置。

语法

SET DATESTYLE TO { arg | 'arg' }[, arg | 'arg' ]

参数

SET DATESTYLE 只有一个参数，该参数可以设置为一个或两个指定日期排序和样式的实参。每个实参可以单独指定或结合使用；如果结合，则可按任意顺序指定。

下表说明了每种样式及其支持的日期排序实参：

Vertica 将忽略 ISO 和 GERMAN 日期样式的顺序实参。如果日期样式为 SQL 或 POSTGRES，则顺序设置将决定以 MDY 还是 DMY 顺序输出日期。SQL 和 POSTGRES 都不支持 YMD 顺序。如果为 YMD 或 SQL 指定 POSTGRES，Vertica 将忽略该设置，并使用默认的 MDY 顺序。

日期样式和排序还会影响 Vertica 解释输入值的方式。有关详细信息，请参阅日期/时间字面量。

特权

无

输入依赖项

在某些情况下，输入格式会决定输出格式，而不管日期样式和顺序的设置：

  • Vertica 中 DATESTYLE 的 ISO 输出为 ISO 长格式，但也接受某些输入样式。如果输入中最先出现年份，则将对输入和输出使用 YMD，而不考虑 DATESTYLE 值。

  • INTERVAL 输入和输出共用同一格式，以下内容除外：

    • CENTURY 或 WEEK 等单位转换为年和日。

    • AGO 转换为相应符号。

    如果日期样式设置为 ISO，输出将遵照以下格式：

    [ quantity unit [...] ] [ days ] [ hours:minutes:seconds ]

示例

=> CREATE TABLE t(a DATETIME);
CREATE TABLE
=> INSERT INTO t values ('3/16/2016');
 OUTPUT
--------
      1
(1 row)

=> SHOW DATESTYLE;
   name    | setting
-----------+----------
 datestyle | ISO, MDY
(1 row)

=> SELECT * FROM t;
          a
---------------------
 2016-03-16 00:00:00
(1 row)

=> SET DATESTYLE TO German;
SET
=> SHOW DATESTYLE;
   name    |   setting
-----------+-------------
 datestyle | German, DMY
(1 row)

=> SELECT * FROM t;
          a
---------------------
 16.03.2016 00:00:00
(1 row)

=> SET DATESTYLE TO SQL;
SET
=> SHOW DATESTYLE;
   name    | setting
-----------+----------
 datestyle | SQL, DMY
(1 row)

=> SELECT * FROM t;
          a
---------------------
 16/03/2016 00:00:00
(1 row)

=> SET DATESTYLE TO Postgres, MDY;
SET
=> SHOW DATESTYLE;
   name    |    setting
-----------+---------------
 datestyle | Postgres, MDY
(1 row)

=> SELECT * FROM t;
            a
--------------------------
 Wed Mar 16 00:00:00 2016
(1 row)

5.36.2 - SET ESCAPE_STRING_WARNING

当前 会话期间，在字符串字面量中使用反斜杠时发出警告。

语法

SET ESCAPE_STRING_WARNING TO { ON | OFF }

参数

ON
[默认] 在字符串字面量中使用反斜杠时发出警告。

提示： 已升级较早版本的 Vertica 的组织可以将此参数用作调试工具，以查找过去被视为转义字符，但现在被视为字面量的反斜杠。

OFF
忽略字符串字面量内的反斜杠。

特权

无

注意

  • 此语句只能在 vsql 下使用。

  • 请先关闭标准一致性字符串，然后再开启此参数。

示例

以下示例显示了如何关闭会话的转义字符串警告。

=> SET ESCAPE_STRING_WARNING TO OFF;

另请参阅

5.36.3 - SET INTERVALSTYLE

指定是否在当前 会话的间隔输出中包含单位。

语法

SET INTERVALSTYLE TO [ plain | units ]

参数

plain
（默认值）设置默认间隔输出以忽略单位。
units
启用在间隔输出中包含子类单位标识符。当 INTERVALSTYLE 设置为单位时，DATESTYLE 参数将控制输出。如果启用了单位，但其未显示在输出中，请检查 DATESTYLE 参数值，该值必须设置为 ISO 或 POSTGRES 才能显示间隔单位。

特权

无

示例

请参阅设置间隔单位显示。

5.36.4 - SET LOCALE

指定当前 会话的区域设置。

还可以使用 vsql 命令 \locale 设置当前区域设置。

语法

SET LOCALE TO ICU‑locale‑identifier

参数

locale‑identifier
指定要使用的 ICU 区域设置标识符，默认设置为： 
en_US@collation=binary

如果设置为空字符串，Vertica 会将区域设置设为 en_US_POSIX。

需要满足以下要求：

  • Vertica 仅支持 COLLATION 关键字。

  • 指定排序规则必须使用单引号。

特权

无

常用区域设置

有关标识符选项的详细信息，请参阅关于区域设置。有关区域设置标识符的完整列表，请参阅 ICU 项目。

de_DE
德语（德国）
en_GB
英语（英国）
es_ES
西班牙语（西班牙）
fr_FR
法语（法国）
pt_BR
葡萄牙语（巴西）
pt_PT
葡萄牙语（葡萄牙）
ru_RU
俄语（俄罗斯）
ja_JP
日语（日本）
zh_CN
中文（中国，简体中文）
zh_Hant_TW
中文（台湾，繁体中文）

示例

将会话区域设置为 en_GB：

=> SET LOCALE TO en_GB;
INFO 2567:  Canonical locale: 'en_GB'
Standard collation: 'LEN'
English (United Kingdom)
SET

使用区域设置的缩写：

=> SET LOCALE TO LEN;
INFO 2567:  Canonical locale: 'en'
Standard collation: 'LEN'
English
SET

指定排序规则：

=> SET LOCALE TO 'tr_tr@collation=standard';
INFO 2567:  Canonical locale: 'tr_TR@collation=standard'
Standard collation: 'LTR'
Turkish (Turkey, collation=standard)  Türkçe (Türkiye, Sıralama=standard)
SET

另请参阅

5.36.5 - SET ROLE

为用户的当前会话启用角色。用户可以访问授予该角色的特权。启用角色不会影响当前已启用的角色。

语法

SET ROLE roles‑expression

参数

roles‑expression
使用以下表达式之一指定此用户的默认角色：

  • NONE （默认值）：禁用所有角色。

  • roles‑list: 要启用的角色列表，以逗号分隔。您只能设置当前已授予您的角色。

  • ALL [EXCEPT roles‑list]: 启用当前已授予此用户的所有角色，不包括在可选 EXCEPT 子句中指定的任何以逗号分隔的角色。

  • DEFAULT：启用所有默认角色。根据定义，默认角色会自动启用，但如果使用 SET ROLE NONE 禁用了这些角色，要重新启用这些角色，此选项可能很有用。

特权

无

示例

示例如下：

  • SHOW AVAILABLE_ROLES; 会列出用户可使用的角色，但不启用。

  • SET ROLE applogs; 为用户启用 applogs 角色。

  • SHOW ENABLED_ROLES; 将 applogs 角色列为已为用户启用 (SET)。

  • SET ROLE appuser; 为用户启用 appuser 角色。

  • SHOW ENABLED_ROLES 将 applogs 和 appuser 列为用户的已启用角色。

  • SET ROLE NONE 禁用用户的所有已启用角色。

  • SHOW ENABLED_ROLES 显示没有为用户启用任何角色。


=> SHOW AVAILABLE_ROLES;
      name       |          setting
-----------------+----------------------------
 available roles | applogs, appadmin, appuser
(1 row)

=> SET ROLE applogs;
SET
=> SHOW ENABLED_ROLES;
     name      | setting
---------------+---------
 enabled roles | applogs
(1 row)

=> SET ROLE appuser;
SET
=> SHOW ENABLED_ROLES;
     name      |     setting
---------------+------------------
 enabled roles | applogs, appuser
(1 row)

=> SET ROLE NONE;
SET


=> SHOW ENABLED_ROLES;
     name      | setting
---------------+---------
 enabled roles |
(1 row)

设置用户默认角色

虽然通常是由 DBADMIN 用户负责设置用户默认角色，但作为用户，您可以设置自己的角色。例如，如果您运行 SET ROLE NONE，则您的所有已启用角色将被禁用。因而决定了您需要将 role1 作为默认角色进行访问。DBADMIN 使用 ALTER USER 向您分配默认角色：

=> ALTER USER user1 default role role1;

此示例将 role1 设置为 user1 的默认角色，因为 DBADMIN 使用 ALTER USER 分配了此默认角色。

user1 => SET ROLE default;
user1 => SHOW ENABLED_ROLES;
    name      | setting
-----------------------
enabled roles |   role1
(1 row)

将所有角色设为默认值

此示例将所有授予 user1 的角色设为默认角色：

user1 => SET ROLE all;
user1 => show enabled roles;
    name      |   setting
----------------------------------
enabled roles | role1, role2, role3
(1 row)

将所有角色设为默认值（含例外）

此示例将授予用户的所有角色设为默认角色，但 role1 除外。

user1 => set role all except role1;
user1 => SHOW ENABLED_ROLES
     name     | setting
----------------------------
enabled roles | role2, role3
(1 row)

5.36.6 - SET SEARCH_PATH

指定当 SQL 语句指定不使用架构名称限定的表名称时 Vertica 搜索架构的顺序。 SET SEARCH_PATH 覆盖当前会话的搜索路径，该路径最初是在用户配置文件中设置的。此搜索路径一直有效，直到下一个 SET SEARCH_PATH 语句或会话结束为止。有关详细信息，请参阅设置搜索路径。

要查看当前搜索路径，请使用 SHOW SEARCH_PATH。

语法

SET SEARCH_PATH { TO | = } { schema‑list | DEFAULT }

参数

schema‑list
以逗号分隔的架构列表，表示 Vertica 搜索表中架构的顺序，该表的名称不通过架构名称进行限定。

如果搜索路径中包含的架构不存在，或者用户缺少对该架构的访问权限，Vertica 会静默跳过该架构。

DEFAULT
将搜索路径设置为数据库默认设置： 
"$user", public, v_catalog, v_monitor, v_internal

特权

无

示例

显示当前搜索路径：

=> SHOW SEARCH_PATH;
    name     |                      setting
-------------+---------------------------------------------------
 search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)

将搜索路径重置为架构 store 和 public：

=> SET SEARCH_PATH TO store, public;
=> SHOW SEARCH_PATH;
    name     |                     setting
-------------+-------------------------------------------------
 search_path | store, public, v_catalog, v_monitor, v_internal
(1 row)

将搜索路径重置为数据库默认设置：

=> SET SEARCH_PATH TO DEFAULT;
SET
=> SHOW SEARCH_PATH;
    name     |                      setting
-------------+---------------------------------------------------
 search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)

5.36.7 - SET SESSION AUTOCOMMIT

设置语句是否在完成时自动提交其事务。此语句主要由客户端驱动程序用于启用和禁用自动提交，您永远没有必要直接调用该语句。

语法

SET SESSION AUTOCOMMIT TO { ON | OFF }

参数

ON
启用自动提交。语句会在完成时自动提交其事务。这是使用 Vertica 客户端库建立的连接的默认设置。
OFF
禁用自动提交。事务不会自动提交。这是交互会话（通过 vsql 建立的连接）的默认设置。

特权

无

示例

此示例显示了如何将 AUTOCOMMIT 设置为“on”，然后再设置为“off”。

=> SET SESSION AUTOCOMMIT TO on;
SET

=> SET SESSION AUTOCOMMIT TO off;
SET

另请参阅

5.36.8 - SET SESSION CHARACTERISTICS AS TRANSACTION

设置在此语句发出后开始的所有事务的隔离级别和访问模式。

事务将保留其隔离级别直至其完成，即使在事务处理期间会话的隔离级别发生更改也是如此。Vertica 内部进程（例如 Tuple Mover 和 刷新操作）以及 DDL 操作始终以 SERIALIZABLE 隔离级别运行以确保一致性。

语法

SET SESSION CHARACTERISTICS AS TRANSACTION settings
设置
以下两项中的一个或两个：
  • ISOLATION LEVEL [argument](#IsolationArgs)
  • [READ ONLY | READ WRITE](#ReadWrite)

ISOLATION LEVEL 实参

ISOLATION LEVEL 子句用于确定当同时运行其他多个事务时，此事务可以访问的数据。如果事务已运行，则不能在第一个查询 (SELECT) 或 DML 语句（INSERT、DELETE、UPDATE）之后更改隔离级别。

将 ISOLATION LEVEL 设置为以下实参之一：

SERIALIZABLE
设置最严格的 SQL 事务隔离级别。此级别连续而不是并发模拟事务。它持有锁并阻止写入操作，直到事务完成为止。

使用 SERIALIZABLE 的应用程序必须准备好在序列化失败后重试事务。对于正常的查询操作，不建议使用此隔离级别。

将事务隔离级别设置为 SERIALIZABLE 不会应用于临时表。临时表通过其事务范围进行隔离。

REPEATABLE READ
自动转换为 SERIALIZABLE。
READ COMMITTED
默认值，允许并发事务。
READ UNCOMMITTED
自动转换为 READ COMMITTED。

READ WRITE/READ ONLY

您可以将事务访问模式设置为以下几项之一：

READ WRITE
默认值，允许对 SQL 语句进行读取/写入。
READ ONLY
不允许需要写入权限的 SQL 语句：

  • 对任何非临时表的 INSERT、UPDATE、DELETE 和 COPY 操作。

  • CREATE、ALTER 和 DROP

  • GRANT、REVOKE

  • EXPLAIN（如果要解释的 SQL 语句需要写入权限）。

特权

无

查看会话事务特征

SHOW TRANSACTION_ISOLATION 和 SHOW TRANSACTION_READ_ONLY 可显示当前会话的事务设置：

=> SHOW TRANSACTION_ISOLATION;
         name          |   setting
-----------------------+--------------
 transaction_isolation | SERIALIZABLE
(1 row)

=> SHOW TRANSACTION_READ_ONLY;
         name          | setting
-----------------------+---------
 transaction_read_only | true
(1 row)

5.36.9 - SET SESSION GRACEPERIOD

设置会话套接字在等待给定查询的客户端输入或输出时保持拦截状态的时间。如果套接字在超过宽限期设置的一段连续时间内被拦截，服务器将关闭套接字并引发致命错误。然后会话终止。如果未设置宽限期，查询可以无限期地在套接字上保留它的块。

Vertica 独立应用会话的宽限期和 RUNTIMECAP 设置。如果未设置宽限期，则无论查询的 RUNTIMECAP 设置如何，查询都可以在会话套接字上无限期地阻塞。

语法

SET SESSION GRACEPERIOD duration

参数

duration
指定查询可以在任何会话套接字上阻塞的时间，可以为以下几项之一：

  • 'interval'：将当前会话查询的最长宽限期指定为间隔，最长 20 天。

  • =DEFAULT：将此会话中查询的宽限期设置为用户的 GRACEPERIOD 值。新会话最初将设置为此值。

  • NONE：仅对超级用户有效，将移除之前在会话查询中设置的任何宽限期。

特权

  • 无论数据库或节点设置如何，超级用户均可以将会话宽限期增加到任意值。

  • 非超级用户只能将会话宽限期设置为不大于自己的用户设置的值。如果没有为用户显式设置宽限期，则该用户的宽限期将从节点或数据库设置继承。

示例

请参阅《管理员指南》中的处理会话套接字阻止。

5.36.10 - SET SESSION IDLESESSIONTIMEOUT

设置会话在退出之前可以保持空闲的最长时间。

语法

SET SESSION IDLESESSIONTIMEOUT duration

参数

duration
指定会话在退出之前可以保持空闲的时间：

  • NONE （默认值）：会话未设置空闲超时。

  • 'interval'：指定为间隔，即会话可以保持空闲的最长时间。

  • =DEFAULT：将此会话的空闲超时时间设置为用户的 IDLESESSIONTIMEOUT 值。

特权

  • 无论数据库或节点设置如何，超级用户均可以将会话保持空闲的时间增加到任意值。

  • 非超级用户只能将会话空闲时间设置为不大于自己的用户设置的值。如果没有为用户显式设置会话空闲时间，则该用户的会话空闲时间将从节点或数据库设置继承。

示例

请参阅《管理员指南》中的管理客户端连接。

5.36.11 - SET SESSION MEMORYCAP

限制可以为当前 会话中的任何请求分配的内存量。此限制仅适用于当前会话；不限制多个会话使用的内存总量。

语法

SET SESSION MEMORYCAP limit

参数

限制
以下几项之一：

  • 'max‑expression'：一个字符串值，用于指定内存限制，为以下几项之一：

    • int% — 将最大值表示为 资源管理器可用总内存的百比，其中 int 为 0 至 100 之间的整数。例如：

      MEMORYCAP '40%'

    • int{K|M|G|T} — 以 KB、MB、GB 或 TB 表示内存分配。例如：

      MEMORYCAP '10G'

  • =DEFAULT：将此会话中查询的内存上限设置为用户的 MEMORYCAP 值。新会话最初将设置为此值。

  • NONE：移除此会话的内存上限。

特权

  • 超级用户可以将会话内存上限增加到任意值。

  • 非超级用户只能将会话内存上限设置为不大于自己的用户设置的值。

示例

将会话内存上限设置为 2 GB：

=> SET SESSION MEMORYCAP '2G';
SET
=> SHOW MEMORYCAP;
   name    | setting
-----------+---------
 memorycap | 2097152
(1 row)

将内存上限恢复为用户配置文件中指定的默认设置：


=> SET MEMORYCAP=DEFAULT;
SET
=> SHOW MEMORYCAP;
   name    | setting
-----------+---------
 memorycap | 2013336
(1 row)

另请参阅

管理工作负载

5.36.12 - SET SESSION MULTIPLEACTIVERESULTSETS

启用或禁用在单一 JDBC 连接上执行多个活动结果集 (MARS)。使用此选项需要具有活动的 JDBC 连接。

语法

SET SESSION MULTIPLEACTIVERESULTSETS TO { ON | OFF }

参数

ON
启用 MultipleActiveResultSets。允许您在单一连接上执行多个结果集。
OFF
禁用 MultipleActiveResultSets。每个连接只允许一个活动结果集。（默认值。）

特权

无

示例

此示例显示了如何将 MultipleActiveResultSets 设置为“on”，然后再设置为“off”：

=> SET SESSION MULTIPLEACTIVERESULTSETS TO on;
SET

=> SET SESSION MULTIPLEACTIVERESULTSETS TO off;
SET

5.36.13 - SET SESSION RESOURCE_POOL

将用户 会话与指定资源池关联。

语法

SET SESSION RESOURCE_POOL = { pool-name | DEFAULT }

参数

pool‑name
要与当前会话关联的现有资源池的名称。
DEFAULT
将会话的资源池设置为用户的默认资源池。

特权

  • 超级用户可以将其会话分配到任意可用的资源池。

  • 非超级用户必须具有资源池的 USAGE 权限。

示例

此示例将 ceo_pool 设置为会话资源池：

=> SET SESSION RESOURCE_POOL = ceo_pool;
SET

另请参阅

5.36.14 - SET SESSION RUNTIMECAP

设置查询和存储过程可以在给定会话中运行的最长时间。如果查询或存储过程超出其会话的 RUNTIMECAP，Vertica 将终止它并返回错误。不能将 RUNTIMECAP 增加到超出用户配置文件中设置的限制。

语法

SET SESSION RUNTIMECAP duration

参数

duration
指定给定查询可以在当前会话中运行的时间，为以下几项之一：

  • NONE （默认值）：移除所有当前会话查询的运行时限制。

  • 'interval'：将当前会话查询的最长运行时间指定为间隔，最长为一年，例如，1 minute 或 100 seconds。

  • =DEFAULT：将此会话中查询的最长运行时间设置为用户的 RUNTIMECAP 值。

特权

  • 超级用户可以将会话 RUNTIMECAP 增加到任意值。

  • 非超级用户只能将会话 RUNTIMECAP 设置为不大于自己的用户 RUNTIMECAP 的值。

示例

将当前会话的最大查询运行时设置为 10 分钟： 

=> SET SESSION RUNTIMECAP '10 minutes';

将会话 RUNTIMECAP 恢复为您的用户默认设置：

=> SET SESSION RUNTIMECAP =DEFAULT;
SET
=> SHOW RUNTIMECAP;
    name    |  setting
------------+-----------
 runtimecap | UNLIMITED
(1 row)

将 RUNTIMECAP 设置为 1 SECOND 并使用无限循环运行匿名过程：

=> SET SESSION RUNTIMECAP '1 SECOND';
SET

=> DO $$
BEGIN
    LOOP
    END LOOP;
END;
$$;

ERROR 0:  Query exceeded maximum runtime
HINT:  Change the maximum runtime using SET SESSION RUNTIMECAP

另请参阅

5.36.15 - SET SESSION TEMPSPACECAP

设置 会话发出的任何请求可以消耗的最大临时文件存储量。如果查询的执行计划所需的存储空间超出会话 TEMPSPACECAP，将会返回错误。

语法

SET SESSION TEMPSPACECAP limit

参数

限制
分配给当前会话的最大临时文件存储量，为以下几项之一：

  • NONE （默认值）：临时存储不受限制

  • = DEFAULT：会话 TEMPSPACECAP 设置为用户的 TEMPSPACECAP 值。

  • 用于指定存储限制的字符串，为以下几项之一：

    • int% 将最大值表示为资源管理器可用的临时总存储的百分比，其中 int 为 0 至 100 之间的整数值。例如：

      SET SESSION TEMPSPACECAP '40%';

    • int{K|M|G|T} 以 KB、MB、GB 或 TB 表示存储分配。例如：

      SET SESSION TEMPSPACECAP '10G';

特权

非超级用户：

  • 仅限于设置自己的会话

  • 会话 TEMPSPACECAP 不能大于其自己的 TEMPSPACECAP。

示例

将会话 TEMPSPACECAP 设置为 20 GB：

=> SET SESSION TEMPSPACECAP '20G';
SET
=> SHOW TEMPSPACECAP;
     name     | setting
--------------+----------
 tempspacecap | 20971520
(1 row)

将会话 TEMPSPACECAP 设置为不受限制：

=> SET SESSION TEMPSPACECAP NONE;
SET
=> SHOW TEMPSPACECAP;
     name     |  setting
--------------+-----------
 tempspacecap | UNLIMITED
(1 row)

另请参阅

5.36.16 - SET STANDARD_CONFORMING_STRINGS

指定是否将反斜杠视为当前会话的转义字符。默认情况下，Vertica 符合 SQL 标准并支持 Unicode 转义中的 SQL:2008 字符串字面量。

语法

SET STANDARD_CONFORMING_STRINGS TO { ON | OFF }

参数

ON
（默认）将普通字符串字面量 ('...') 视为反斜杠 (\)，当作文本处理。这意味着反斜杠将被视为字符串字面量，而非转义字符。
OFF
将反斜杠视为转义字符。

特权

无

要求

  • 此语句只能在 vsql 下使用。

  • 标准-一致性字符串必须开启才可使用 Unicode 样式的字符串字面量 (U&'\nnnn')。

示例

关闭会话的一致性字符串：

=> SET STANDARD_CONFORMING_STRINGS TO OFF;

验证当前设置：

=> SHOW STANDARD_CONFORMING_STRINGS;
            name             | setting
-----------------------------+---------
 standard_conforming_strings | off
(1 row)

打开会话的一致性字符串：

=> SET STANDARD_CONFORMING_STRINGS TO ON;

另请参阅

5.36.17 - SET TIME ZONE

更改当前 会话的 TIME ZONE 运行时参数。使用 SHOW TIMEZONE 显示会话的当前时区。

如果您使用 POSIX 格式设置时区，您使用的时区缩写将覆盖默认时区缩写。如果将日期样式设置为 POSTGRES，在将时间戳转换为字符串时，也会使用您使用的时区缩写。

语法

SET TIME ZONE [TO] { value | 'value' }

参数

value
以下几项之一：

  • Vertica 支持的时区字面量。要查看默认的有效字面量列表，请参阅以下目录中的文件：

    /opt/vertica/share/timezonesets

  • 带符号整数，表示 UTC 偏移量（以小时为单位）

  • 偏移量为带符号整数的时区字面量。例如：

    => SET TIME ZONE TO 'America/New York -3'; -- equivalent to Pacific time

  • 间隔值

  • 常数 LOCAL 和 DEFAULT，分别将时区设置为环境变量 TZ 中指定的时区，或者如果 TZ 未定义，则设置为操作系统时区。

只有有效的（时区+偏移量）组合才能作为此函数的参数。

特权

无

示例

=> SET TIME ZONE TO DEFAULT;
=> SET TIME ZONE TO 'PST8PDT'; -- Berkeley, California
=> SET TIME ZONE TO 'Europe/Rome'; -- Italy
=> SET TIME ZONE TO '-7'; -- UDT offset equivalent to PDT
=> SET TIME ZONE TO INTERVAL '-08:00 HOURS';

另请参阅

在 Vertica 中使用时区

5.36.17.1 - 用于设置 TIME ZONE 的时区名称

Vertica 将下面列出的时区名称识别为 SQL 时区的有效设置（TIME ZONE 运行时参数）。

这些名称不同于 /opt/vertica/share/timezonesets 中显示的名称，后者以 date/time 输入值的形式获得 Vertica 识别。下面列出的 TIME ZONE 名称意味着本地夏令时规则，其中 date/time 输入名称代表 UTC 的固定偏移量。

在许多情况下，同一时区具有多个名称。这些名称位于同一个组中。列表主要按常用时区名称进行排序。

除了列表中的名称之外，Vertica 还接受以下时区名称之一：

  • STDoffset

  • STDoffsetDST

其中 STD 为时区缩写，offset 为从 UTC 往西的偏移量数值（以小时为单位），而 DST 为可选的夏令时时区缩写，假定代表比给定偏移量提前一小时。

例如，如果 EST5EDT 还不是公认的时区名称，Vertica 将接受它在功能上等同于美国东海岸时间。如果存在夏令时时区名称，Vertical 将假定该名称使用美国时区规则，因此此功能在北美以外地区的使用受到限制。

时区

  • 非洲
  • 美洲
  • 南极洲
  • 亚洲
  • 大西洋
  • 澳大利亚

  • CET

  • EET

  • Etc/GMT

    • GMT

    • GMT+0

    • GMT-0

    • GMT0

    • Greenwich

    • Etc/Greenwich

  • 欧洲

  • 工厂

  • 印度洋

  • MET

  • 太平洋

  • UCT Etc

  • UCT

  • 偏移量

    • Universal Zulu

    • Etc/UTC

    • Etc/Universal

    • Etc/Zulu

  • WET

5.37 - SHOW

显示当前会话的运行时参数。

语法

SHOW { parameter | ALL }

参数

ALL
显示所有运行时设置。
AUTOCOMMIT
返回 on/off，以指示语句在完成时是否自动提交事务。
AVAILABLE ROLES
列出可供用户使用的所有 角色。
DATESTYLE
显示日期值的当前样式。请参阅SET DATESTYLE。
ENABLED ROLES
显示为当前会话启用的角色。请参阅SET ROLE。
ESCAPE_STRING_WARNING
返回 on/off，以指示在字符串中发现反斜杠转义时是否发出警告。请参阅SET ESCAPE_STRING_WARNING。
GRACEPERIOD
显示通过 SET SESSION GRACEPERIOD 设置的会话 GRACEPERIOD。
IDLESESSIONTIMEOUT
显示会话在超时之前可以保持空闲的时间。
INTERVALSTYLE
显示在打印时间间隔时是否输出单位。请参阅SET INTERVALSTYLE。
LOCALE
显示当前区域设置。请参阅SET LOCALE。
MEMORYCAP
显示任何请求使用的最大内存量。请参阅 SET MEMORYCAP。
MULTIPLEACTIVERESULTSETS
返回 on/off，以指示是否允许在一个连接上存在多个活动结果集。请参阅SET SESSION MULTIPLEACTIVERESULTSETS。
RESOURCE POOL
显示会话当前使用的资源池。请参阅 SET RESOURCE POOL。
RUNTIMECAP
显示此会话中查询可运行的最长时间。请参阅 SET RUNTIMECAP。
SEARCH_PATH
显示 Vertica 搜索架构时采用的顺序。请参阅SET SEARCH_PATH。例如： 
=> SHOW SEARCH_PATH;
    name     |                      setting
-------------+---------------------------------------------------
 search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)
STANDARD_CONFORMING_STRINGS
显示是否为会话启用反斜杠转义。请参阅SET STANDARD_CONFORMING_STRINGS。
TEMPSPACECAP
显示在会话中查询可以使用的最大临时文件空间。请参阅 SET TEMPSPACECAP。
TIMEZONE
显示当前会话中设置的时区。请参阅 SET TIMEZONE。
TRANSACTION_ISOLATION
显示当前事务隔离设置，如 SET SESSION CHARACTERISTICS AS TRANSACTION 中所述。例如： 
=> SHOW TRANSACTION_ISOLATION;
         name          |    setting
-----------------------+----------------
 transaction_isolation | READ COMMITTED
(1 row)
TRANSACTION_READ_ONLY
返回 true/false 以指示当前的只读设置，如 SET SESSION CHARACTERISTICS AS TRANSACTION 中所述。例如： 
=> SHOW TRANSACTION_READ_ONLY;
         name          | setting
-----------------------+---------
 transaction_read_only | false
(1 row)

特权

无

示例

显示所有当前运行时参数设置：

=> SHOW ALL;
            name             |                          setting
-----------------------------+-----------------------------------------------------------
 locale                      | en_US@collation=binary (LEN_KBINARY)
 autocommit                  | off
 standard_conforming_strings | on
 escape_string_warning       | on
 multipleactiveresultsets    | off
 datestyle                   | ISO, MDY
 intervalstyle               | plain
 timezone                    | America/New_York
 search_path                 | "$user", public, v_catalog, v_monitor, v_internal, v_func
 transaction_isolation       | READ COMMITTED
 transaction_read_only       | false
 resource_pool               | general
 memorycap                   | UNLIMITED
 tempspacecap                | UNLIMITED
 runtimecap                  | UNLIMITED
 idlesessiontimeout          | UNLIMITED
 graceperiod                 | UNLIMITED
 enabled roles               | dbduser*, dbadmin*, pseudosuperuser*
 available roles             | dbduser*, dbadmin*, pseudosuperuser*
 (19 rows)

5.38 - SHOW CURRENT

显示在所有级别设置的活动配置参数值。Vertica 首先检查在会话级别设置的值。如果未在会话级别为配置参数设置值，Vertica 接下来将检查是否为您登录的节点设置值，然后检查数据库级别。如果未设置值，SHOW CURRENT 将显示配置参数的默认值。如果配置参数需要重新启动才能生效，显示的活动值可能不同于设置的值。

语法

SHOW CURRENT { parameter‑name[,...] | ALL }

参数

parameter‑name
要显示的配置参数的名称。
ALL
显示在所有级别设置的所有配置参数。

特权

非超级用户： SHOW CURRENT ALL 返回掩码参数设置。尝试查看特定参数设置会返回错误。

示例

显示所有级别的配置参数及其设置。

=> SHOW CURRENT ALL;

level    |    name                   |setting
---------+---------------------------+---------
DEFAULT  | ActivePartitionCount      | 1
DEFAULT  | AdvanceAHMInterval        | 180
DEFAULT  | AHMBackupManagement       | 0
DATABASE | AnalyzeRowCountInterval   | 3600
SESSION  | ForceUDxFencedMode        | 1
NODE     | MaxClientSessions         | 0
...

5.39 - SHOW DATABASE

显示为数据库设置的配置参数值。

语法

SHOW DATABASE db‑spec { parameter‑name[,...] | ALL }

参数

db‑spec

指定当前数据库，设置为数据库名称或DEFAULT。

parameter‑name
要显示的一个或多个配置参数的名称。非超级用户只能指定设置未被 SHOW DATABASE...ALL 屏蔽的参数，否则 Vertica 将返回错误。

如果指定的参数未设置，SHOW DATABASE 会为该参数返回一个空行。

要获取数据库级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS。

ALL
显示在数据库级别设置的所有配置参数。对于非超级用户，Vertica 会屏蔽只有超级用户才能访问的安全性参数设置。

特权

  • 超级用户：显示所有数据库参数设置。

  • 非超级用户：屏蔽只有超级用户可以访问的所有安全性参数设置。要确定哪些参数需要超级用户权限，请查询系统表 CONFIGURATION_PARAMETERS。

示例

向非超级用户显示在数据库上设置的所有配置参数：

=> SHOW DATABASE DEFAULT ALL;
              name              | setting
--------------------------------+----------
 AllowNumericOverflow           | 1
 CopyFaultTolerantExpressions   | 1
 GlobalHeirUsername             | ********
 MaxClientSessions              | 50
 NumericSumExtraPrecisionDigits | 0
(6 rows)

显示两个配置参数的设置：

=> SHOW DATABASE DEFAULT AllowNumericOverflow, NumericSumExtraPrecisionDigits;
              name              | setting
--------------------------------+---------
 AllowNumericOverflow           | 1
 NumericSumExtraPrecisionDigits | 0
(2 rows)

5.40 - SHOW NODE

显示为节点设置的配置参数值。如果指定的参数未设置，SHOW NODE 会为该参数返回一个空行。

语法

SHOW NODE node‑name { parameter‑name [,...] | ALL }

参数

node‑name
目标节点的名称。
parameter‑name
一个或多个节点级别配置参数的名称。要获取节点级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS。
ALL
显示在节点级别设置的所有配置参数。

特权

无

示例

查看节点 v_vmart_node0001 的所有配置参数及其设置：

=> SHOW NODE v_vmart_node0001 ALL;

           name            | setting
---------------------------+---------
 DefaultIdleSessionTimeout | 5 hour
 MaxClientSessions         | 20

5.41 - SHOW SESSION

显示为当前会话设置的配置参数值。如果指定的参数未设置，SHOW SESSION 会为该参数返回一个空行。

语法

SHOW SESSION { ALL | UDPARAMETER ALL }

参数

ALL
显示在会话级别设置的所有 Vertica 配置参数。
UDPARAMETER ALL
显示由用户定义的扩展定义的所有参数。这些参数未显示在 CONFIGURATION_PARAMETERS 表中。

特权

无

示例

查看当前会话的所有 Vertica 配置参数及其设置。不包括用户定义的参数：

=> SHOW SESSION ALL;

name                        |                      setting
----------------------------+---------------------------------------------------
locale                      | en_US@collation=binary (LEN_KBINARY)
autocommit                  | off
standard_conforming_strings | on
escape_string_warning       | on
datestyle                   | ISO, MDY
intervalstyle               | plain
timezone                    | America/New_York
search_path                 | "$user", public, v_catalog, v_monitor, v_internal
transaction_isolation       | READ COMMITTED
transaction_read_only       | false
resource_pool               | general
memorycap                   | UNLIMITED
tempspacecap                | UNLIMITED
runtimecap                  | UNLIMITED
enabled roles               | dbduser*, dbadmin*, pseudosuperuser*
available roles             | dbduser*, dbadmin*, pseudosuperuser*
ForceUDxFencedMode          | 1
(17 rows)

5.42 - SHOW USER

显示数据库用户的配置参数设置。要获取用户级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS：

SELECT parameter_name, allowed_levels FROM configuration_parameters
      WHERE allowed_levels ilike '%USER%' AND parameter_name ilike '%depot%';
     parameter_name      |     allowed_levels
-------------------------+-------------------------
 UseDepotForWrites       | SESSION, USER, DATABASE
 DepotOperationsForQuery | SESSION, USER, DATABASE
 UseDepotForReads        | SESSION, USER, DATABASE
(3 rows)

语法

SHOW USER { user‑name | ALL } [PARAMETER] { cfg‑parameter [,...] | ALL }

参数

user‑name | ALL
显示指定用户或所有用户的参数设置。
[PARAMETER] parameter-list
用户级别配置参数的逗号分隔列表。
PARAMETER ALL
显示为指定用户设置的所有配置参数。

特权

非超级用户：只能查看自己的配置参数设置。

示例

以下示例显示了 Yvonne 和 Ahmed 两个用户的配置参数设置：

=> SELECT user_name FROM v_catalog.users WHERE user_name != 'dbadmin';
 user_name
-----------
 Ahmed
 Yvonne
(2 rows)

=> SHOW USER Yvonne PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Yvonne | DepotOperationsForQuery | Fetches
(1 row)

=> ALTER USER Yvonne SET PARAMETER UseDepotForWrites = 0;
ALTER USER
=> SHOW USER Yvonne PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Yvonne | DepotOperationsForQuery | Fetches
 Yvonne | UseDepotForWrites       | 0
(2 rows)

=> ALTER USER Ahmed SET PARAMETER DepotOperationsForQuery = 'Fetches';
ALTER USER
=> SHOW USER ALL PARAMETER ALL;
  user  |        parameter        | setting
--------+-------------------------+---------
 Ahmed  | DepotOperationsForQuery | Fetches
 Yvonne | DepotOperationsForQuery | Fetches
 Yvonne | UseDepotForWrites       | 0
(3 rows)

另请参阅

ALTER USER

5.43 - 启动事务处理

启动事务块。

语法

START TRANSACTION [ isolation_level ]

其中，*isolation_level *是以下几项之一：

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }READ { ONLY | WRITE }

参数

隔离级别（在下表中介绍）确定在其他事务并发运行时某个事务可以访问的数据。首个查询 (SELECT) 或 DML 语句（INSERT、DELETE 或 UPDATE）运行后，隔离级别不能更改。

事务将保留其隔离级别直至其完成，即使在事务处理期间会话的隔离级别发生更改也是如此。Vertica 内部进程（例如

Tuple Mover 和

刷新操作）以及 DDL 操作始终以 SERIALIZABLE 隔离级别运行以确保一致性。

WORK | TRANSACTION
不起任何作用；它们是可选的关键字，目的是提高可读性。
ISOLATION LEVEL { | SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
  • SERIALIZABLE：设置最严格的 SQL 事务隔离级别。此级别连续而不是并发模拟事务。它持有锁并阻止写入操作，直到事务完成为止。对于正常的查询操作，不建议使用。
  • REPEATABLE READ：通过 Vertica 自动转换为 SERIALIZABLE。
  • READ COMMITTED（默认值）：允许并发事务。将 READ COMMITTED 隔离用于正常查询操作，但请注意，两者有细微差别。有关详细信息，请参阅 事务。
  • READ UNCOMMITTED：通过 Vertica 自动转换为 READ COMMITTED。
READ {WRITE | ONLY}
确定事务是读取/写入还是只读。默认值为读/写模式。

如果将事务会话模式设置为只读，将不允许使用以下 SQL 命令，但是不会阻止所有磁盘写入操作：

  • INSERT、UPDATE、DELETE 和 COPY - 如果要写入的表不是临时表
  • 所有 CREATE、ALTER 和 DROP 命令
  • GRANT、REVOKE 和 EXPLAIN - 如果要运行的命令在列出的命令当中。

特权

无

注意

BEGIN 执行与 START TRANSACTION 相同的功能。

示例

此示例显示如何启动事务处理。

= > START TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
START TRANSACTION

=> CREATE TABLE sample_table (a INT);
CREATE TABLE

=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)

另请参阅

5.44 - TRUNCATE TABLE

移除与目标表关联的所有存储，同时保留完整的表定义。在执行语句后，TRUNCATE TABLE 将自动提交当前事务，无法回退。

TRUNCATE TABLE 同时还会执行以下操作：

  • 移除当前时期之前的所有表历史记录。在 TRUNCATE TABLE 返回后，在截断后的表上进行 AT EPOCH 查询将不会返回任何内容。

  • 删除所有表级别和分区级别的统计信息。

语法

TRUNCATE TABLE [[database.]schema.]table‑name

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑name
要截断的锚表或临时表的名称。不能截断外部表。

特权

非超级用户：

  • 表所有者

  • 对于表架构的 USAGE 权限

示例

请参阅截断表。

另请参阅

5.45 - UPDATE

对于满足指定条件的所有行，替换其指定列的值。表中所有其他列和行不变。若成功，UPDATE 将返回被更新的行数。为 0 的计数表示没有任何行与该条件匹配。

语法

UPDATE [[database.]schema.]table-reference [AS] alias 
    SET set‑expression [,...]
    [ FROM from-list ]
    [ where‑clause ]

参数

[database.]schema

数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。

table‑reference
一个表，为以下几项之一：

  • 视情况进行限定的表名，带有可选表别名、列别名和外联接。

  • 外联接表。

您无法更新投影。

别名
用于引用表的临时名称。
SET set‑expression
要使用一个或多个 SET 表达式更新的列。每个 SET 子句表达式指定一个目标列及其新值，如下所示： 
column-name =  { expression | DEFAULT }

其中：

  • column-name 是不含主键或外键 引用完整性约束的任意列，而且不是复杂类型。允许使用原生数组。

  • expression 指定要分配给列的值。该表达式可使用此表列或其他表列的当前值。例如：

    => UPDATE T1 SET C1 = C1+1

  • DEFAULT 将 column-name 设置为其默认值，或者如果没有为该列定义默认值，则将其忽略。

UPDATE 只修改通过 SET 子句指定的列。未指定的列保持不变。

FROM from‑list
表的表达式列表，允许其他表的列出现在 WHERE 条件和 UPDATE 表达式中。这类似于可在 SELECT 命令的 FROM 子句 中予以指定的表列表。

FROM 子句可以引用目标表，如下所示：

FROM DEFAULT [join-type] JOIN table-reference [ ON join-predicate ]

DEFAULT 指定要更新的表。此关键字只能在 FROM 子句中使用一次，且不能在 UPDATE 语句的其他位置使用。

特权

表所有者或用户 WITH GRANT OPTION 是授予者。

  • 对表的 UPDATE 权限

  • 包含表的架构上的 USAGE 权限

  • 执行在 WHERE 或 SET 子句中引用表列值的 UPDATE 语句时，对于表拥有 SELECT 权限

子查询和联接

UPDATE 支持子查询和联接，这有利于根据存储在其他表中的值来更新表中的值。有关详细信息，请参阅UPDATE 和 DELETE 语句中的子查询。

Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。

限制

  • 不能更新不可变表。

  • 不能更新复杂类型的列，原生数组除外。

  • 如果 FROM 子句或 WHERE 谓词中指定的联接生成多个目标表中行的副本，则将任意选择表中该行的新值。

  • 如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。

  • 如果更新会违反表或架构磁盘配额，则操作将失败。有关详细信息，请参阅磁盘配额。

示例

在 fact 表中，对于 cost 列值大于 100 的所有行，修改其 price 列值：

=> UPDATE fact SET price = price - cost * 80 WHERE cost > 100;

在 retail.customer 表中，若 CID 列值大于 100，则将 state 列设置为 NH：

=> UPDATE retail.customer SET state = 'NH' WHERE CID > 100;

要在 UPDATE 查询中使用表别名，请考虑以下两个表：

=> SELECT * FROM result_table;
 cust_id |      address
---------+--------------------
      20 | Lincoln Street
      30 | Beach Avenue
      30 | Booth Hill Road
      40 | Mt. Vernon Street
      50 | Hillside Avenue
(5 rows)
=> SELECT * FROM new_addresses;
 new_cust_id | new_address
-------------+---------------
          20 | Infinite Loop
          30 | Loop Infinite
          60 | New Addresses
(3 rows)

以下查询和子查询使用表别名将 result_table（别名 address）中的 r 列更新为 new_addresses 表（别名 n）中相应列的新地址：

=> UPDATE result_table r
   SET address=n.new_address
   FROM new_addresses n
   WHERE r.cust_id = n.new_cust_id;

result_table 显示了顾客 ID 20 和 30 的 address 字段更新：

=> SELECT * FROM result_table ORDER BY cust_id;
 cust_id |     address
---------+------------------
      20 | Infinite Loop
      30 | Loop Infinite
      30 | Loop Infinite
      40 | Mt. Vernon Street
      50 | Hillside Avenue
(5 rows)

不能使用 UPDATE 更新原生数组的单个元素。只能替换整个数组值。以下示例使用 ARRAY_CAT 将元素添加到数组列：

=> SELECT * FROM singers;
 lname  | fname |                    bands
--------+-------+---------------------------------------------
 Cher   |       | ["Sonny and Cher"]
 Jagger | Mick  | ["Rolling Stones"]
 Slick  | Grace | ["Jefferson Airplane","Jefferson Starship"]
(3 rows)

=> UPDATE singers SET bands=ARRAY_CAT(bands,ARRAY['something new'])
    WHERE lname='Cher';
 OUTPUT
--------
      1
(1 row)

=> SELECT * FROM singers;
 lname  | fname |                    bands
--------+-------+---------------------------------------------
 Jagger | Mick  | ["Rolling Stones"]
 Slick  | Grace | ["Jefferson Airplane","Jefferson Starship"]
 Cher   |       | ["Sonny and Cher","something new"]
(3 rows)

6 - 配置参数

Vertica 支持一系列影响数据库多个方面行为的配置参数。通过在一个或多个级别使用适当的 ALTER 语句，可以设置这些参数。以下按优先级降序对其进行排列：

  1. 用户 (ALTER USER)

  2. 会话 (ALTER SESSION)

  3. 节点 (ALTER NODE)

  4. 数据库 (ALTER DATABASE)

您可以查询系统表 CONFIGURATION_PARAMETERS，获取所有用户可访问参数的当前设置。例如，以下查询获取分区参数的设置：它们的当前值和默认值、可以设置的级别，以及更改后是否需要重新启动数据库才能生效：

=> SELECT parameter_name, current_value, default_value, allowed_levels, change_requires_restart FROM configuration_parameters
     WHERE parameter_name ILIKE '%partition%';
           parameter_name           | current_value | default_value | allowed_levels | change_requires_restart
------------------------------------+---------------+---------------+----------------+-------------------------
 MaxPartitionCount                  | 1024          | 1024          | NODE, DATABASE | f
 PartitionSortBufferSize            | 67108864      | 67108864      | DATABASE       | f
 DisableAutopartition               | 0             | 0             | SESSION, USER  | f
 PatternMatchingMaxPartitionMatches | 3932160       | 3932160       | NODE, DATABASE | f
 PatternMatchingMaxPartition        | 20971520      | 20971520      | NODE, DATABASE | f
 ActivePartitionCount               | 1             | 1             | NODE, DATABASE | f
(6 rows)

6.1 - 常规参数

以下参数配置基本数据库操作。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。

ApplyEventsDuringSALCheck
布尔值，指定 Vertica 是否使用编录事件在节点启动期间筛选掉已删除的损坏分区。删除损坏的分区可以加速节点恢复。

禁用 (0) 时，Vertica 会报告损坏的分区，但不采取任何措施。保留损坏的分区可以将当前投影检查点时期重置为损坏发生之前的时期。

此参数对未分区表没有影响。

默认值： 0

ApportionedFileMinimumPortionSizeKB
指定用于分摊文件负载的最小分区大小（以 KB 为单位）。只有在以下情况下，Vertica 才会跨多个节点分摊文件负载：

  • 负载可以拆分成至少等于此值的分区。

  • EnableApportionedFileLoad 和 EnableApportionLoad 设置为 1（启用）。

另请参阅 EnableApportionLoad 和 EnableApportionedFileLoad。

默认值： 1024

BlockedSocketGracePeriod
设置会话套接字在等待给定查询的客户端输入或输出时保持拦截状态的时间。请参阅处理会话套接字阻止。

默认值： None（套接字阻止可以无限期地继续。）

CatalogCheckpointPercent
指定为数据库编录创建检查点的阈值。

默认情况下，此参数设置为 50 (%)，因此当事务日志达到上一个检查点大小的 50% 时，Vertica 会添加一个检查点。每个检查点都会界定自上一个检查点以来对编录进行的所有更改。

默认值： 50 (%)

ClusterSequenceCacheMode
布尔值，指定启动程序节点是否请求群集中其他节点的缓存，然后将缓存随执行计划一起发送至其他节点，为以下之一。

  • 1（启用）：启动程序节点请求缓存。

  • 0：（禁用）：所有节点都请求其自己的缓存。

请参阅分发命名序列。

默认值： 1（启用）

CompressCatalogOnDisk
指定是否压缩磁盘上编录的大小，为以下之一：

  • 0：不压缩。

  • 1：压缩检查点，但不压缩日志。

  • 2：压缩检查点和日志。

如果编录磁盘分区较小 (<50 GB)，而元数据较大（数百个表、分区或节点），则考虑启用此参数。

默认值： 0

CompressNetworkData
布尔值，指定在启用时（设置为 1）是否压缩通过内部网络发送的所有数据。这种压缩将加快网络流量，但会增加 CPU 负载。如果网络正在限制数据库性能，可通过启用压缩解决此问题。

默认值： 0

CopyFaultTolerantExpressions
布尔值，指示在转换期间是否报告记录拒绝，并在转换失败时继续 (true) 或中止 COPY 操作。

默认值： 0 (false)

CopyFromVerticaWithIdentity
允许 COPY FROM VERTICA 和 导出到 VERTICA 将值加载到标识（或自动增量）列中。目标标识列不会自动递增。要禁用默认行为，请将此参数设置为 0（零）。

默认值： 1

DatabaseHeartbeatInterval
确定每个节点执行运行状况检查和传递检测信号的时间间隔（以秒为单位）。如果节点未在连续五个指定时间间隔内收到消息，该节点将被逐出群集。将时间间隔设置为 0 可禁用此功能。

请参阅自动逐出运行状况不佳的节点。

默认值： 120

DefaultArrayBinarySize
如果在创建时未指定最大大小，则为无界集合的最大二进制大小（以字节为单位）。

默认值： 65000

DefaultTempTableLocal
布尔值，指定 CREATE TEMPORARY TABLE 是创建本地临时表还是全局临时表，为以下之一：

  • 0：创建全局临时表。

  • 1：创建本地临时表。

有关详细信息，请参阅创建临时表。

默认值： 0

DivideZeroByZeroThrowsError
布尔值，指定在请求除数为零的运算时是否返回错误：

  • 0：返回 0。

  • 1：返回错误。

默认值： 1

EnableApportionedChunkingInDefaultLoadParser
布尔值，指定是否为已分隔文件启用内置解析器，以利用分摊负载和协作解析，从而获得更好的性能。

默认值： 1（启用）

EnableApportionedFileLoad
布尔值，指定是否使用 COPY FROM VERTICA 启用跨节点自动分摊文件负载。Vertica 在满足以下条件时尝试分摊负载：

  • 此参数和 EnableApportionLoad 均已启用。

  • 解析器支持分摊。

  • 负载可分为至少为 ApportionedFileMinimumPortionSizeKB 值的分区大小。

设置此参数并不能保证负载将被分摊，但禁用此参数可以保证不会被分摊。

请参阅分配加载。

默认值： 1（启用）

EnableApportionLoad
布尔值，指定是否使用 COPY...WITH SOURCE 启用跨节点自动分摊数据负载。Vertica 在满足以下条件时尝试分摊负载：

  • 此参数已启用。

  • 源和解析器均支持分摊。

设置此参数并不能保证负载将被分摊，但禁用此参数可以保证不会被分摊。

有关详细信息，请参阅分配加载。

默认值： 1（启用）

EnableBetterFlexTypeGuessing
布尔值，指定在使用 COMPUTE_FLEXTABLE_KEYS 或 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 将数据类型分配给 Flex 表 __raw__ 列中的非字符串键时，是否启用更准确的类型猜测。如果禁用此参数 (0)，Vertica 将使用一组有限的 Vertica 数据类型分配。例如，请参阅计算 Flex 表键。

默认值： 1（启用）

EnableCooperativeParse
布尔值，指定是否对节点实施多线程解析功能。此参数可用于分隔的负载和固定宽度的负载。

默认值： 1（启用）

EnableForceOuter
布尔值，指定 Vertica 是否使用表的 force_outer 值来实施联接。有关详细信息，请参阅控制联接输入。

默认值： 0（禁用强制联接输入）

EnableMetadataMemoryTracking
布尔值，指定是否允许 Vertica 跟踪 METADATA 资源池中数据库元数据使用的内存。

默认值： 1（启用）

EnableResourcePoolCPUAffinity
布尔值，指定 Vertica 是否根据处理 CPU 的资源池调整查询。禁用时 (0)，查询将在任意 CPU 上运行，无论资源池的 CPU_AFFINITY_SET 为何。

默认值： 1

EnableStrictTimeCasts
指定是否所有转换失败都会导致错误。

默认值： 0（禁用）

EnableUniquenessOptimization
布尔值，指定是否启用可保证列值唯一性的查询优化。可保证具有唯一值的列包括：

默认值： 1（启用）

EnableWithClauseMaterialization
由 WithClauseMaterialization 取代。
ExternalTablesExceptionsLimit
确定当 SELECT 语句引用外部表时所允许的最大 COPY 异常和拒绝数。设置为 -1 可删除任何异常限制。请参阅查询外部表。

默认值： 100

FailoverToStandbyAfter
指定活动备用节点等待多长时间后替换故障节点。

此参数设置为字面量类时间间隔。

默认值： 无

FencedUDxMemoryLimitMB
设置隔离模式 UDF 可以使用的最大内存量（以兆字节 (MB) 为单位）。如果 UDF 尝试分配的内存超过此限制，则该尝试会触发一个异常。有关详细信息，请参阅隔离和非隔离模式。

默认值： -1（无限制）

FlexTableDataTypeGuessMultiplier
指定为 flex 键表分配数据类型和列宽时 COMPUTE_FLEXTABLE_KEYS 和 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 函数使用的系数。这两个函数都会为每个键分配一种数据类型，并用最长键值乘以此因子来估算列宽。此值不可用于在 flex 表中计算任何实际列的宽度。

默认值： 2.0

FlexTableRawSize
指定新 flex 表中 __raw__ 列的默认列宽，该值介于 1 和 32000000（包含）之间。

默认值： 130000

ForceUDxFencedMode
启用 (1) 时，将强制所有支持隔离模式的 UDx 在隔离模式下运行，即使其定义指定了 NOT FENCED 也如此。

默认值： 0

JavaBinaryForUDx
设置 Vertica 用于运行 Java UDx 的 Java 可执行文件的完整路径。请参阅在 Vertica 主机上安装 Java。
JoinDefaultTupleFormat
指定在联接这些列上的表时如何调整 VARCHAR 列数据的大小，并相应地进行缓冲，为以下之一：

  • fixed：使用联接列元数据将列数据的大小调整为固定长度，并相应地进行缓冲。

  • variable：使用联接列数据的实际长度，因此每个联接的缓冲区大小不同。

默认值： fixed

KeepAliveIdleTime
发送第一个 TCP keepalive 探测器以确保客户端仍然连接之前的时间（以秒为单位）。

默认值： 7200

KeepAliveProbeCount
在客户端连接被认为丢失和关闭之前，客户端必须取消确认的 keepalive 探测器的连续数。

默认值： 9

KeepAliveProbeInterval
keepalive 探测器之间的时间间隔（以秒为单位）。

默认值： 75

LockTimeout
指定表可以锁定多长时间（以秒为单位）。您可以在所有级别设置此参数：会话、节点和数据库。

默认值： 300

LoadSourceStatisticsLimit
指定在 LOAD_SOURCES 系统表中分析的每个加载操作的最大源数。将其设置为 0 可禁用分析。

默认值： 256

MaxBundleableROSSizeKB
指定独立 ROS 文件的最小大小（以 KB 为单位）。Vertica 可将低于此大小的存储容器 ROS 文件捆绑成一个文件。捆绑可以提高任何文件密集型操作的性能，包括备份、还原和合并。

如果将此参数的值设为 0，Vertica 会捆绑 .fdb 和 .pidx 文件，而不会捆绑其他存储容器文件。

默认值： 1024

MaxClientSessions
确定可在数据库的单个节点上运行的最大客户端会话数。默认值额外允许五次管理登录。这些登录可防止在非 dbadmin 用户达到登录限制时 DBA 遭到系统阻拦。

默认值： 50 次用户登录和额外的 5 次管理登录

ParquetMetadataCacheSizeMB
读取 Parquet 数据时用于元数据的缓存大小。缓存使用本地 TEMP 存储。

默认值： 4096

PatternMatchingUseJit
布尔值，指定是否可以即时编译查询中使用的正则表达式模式匹配函数（编译成机器代码）。通常，启用此参数可以提高大型表的模式匹配性能。Perl 兼容正则表达式 (PCRE) 模式匹配库可评估正则表达式。重新启动数据库，使此参数生效。

另请参阅 正则表达式函数。

默认值： 1（启用）

PatternMatchStackAllocator
布尔值，指定是否覆盖模式匹配库的堆栈内存分配器。Perl 兼容正则表达式 (PCRE) 模式匹配库可评估正则表达式。重新启动数据库，使此参数生效。

另请参阅 正则表达式函数。

默认值： 1（启用覆盖）

TerraceRoutingFactor
指定在实施基于机架的容错组的任何企业模式大型群集上启用还是禁用 terrace 路由。
  • 要启用，请进行如下设置：
    其中： * numRackNodes：机架中的节点数 * numRacks：群集中的机架数
  • 要禁用，请设置为一个大到无法为最大群集启用 terrace 路由的值，例如 1000。

有关详细信息，请参阅Terrace 路由。

默认值： 2

TransactionIsolationLevel
更改数据库的隔离级别。修改后，Vertica 将对每个新会话使用新的事务级别。现有会话及其事务会继续使用原始隔离级别。

另请参阅 更改事务隔离级别。

默认值： READ COMMITTED

TransactionMode
指定事务处于读/写模式还是处于只读模式。默认值为读/写模式。现有会话及其事务会继续使用原始隔离级别。

默认值： READ WRITE

UDxFencedBlockTimeout
指定中止在 隔离和非隔离模式 中运行的 UDx 之前等待输出的秒数。如果服务器因此中止 UDx，它会产生类似于以下的错误消息：“ERROR 3399: Failure in UDx RPC call: timed out in receiving a UDx message”。如果经常看到此错误，可以提高此限制值。以隔离模式运行的 UDx 不在服务器进程中运行，因此提高此值不会影响服务器性能。

默认值： 60

UseLocalTzForParquetTimestampConversion
布尔值，指定读取 Parquet 文件时是否进行时区转换。Hive 版本 1.2.1 引入了一个选项，用于在写入 Parquet 文件时本地化时区。以前，它以 UTC 写入它们，而 Vertica 在读取文件时会调整值。

如果 Hive 已经调整了时区，则设置为 0。

默认值： 1（启用转换）

UseServerIdentityOverUserIdentity
布尔值，指定是否忽略用户为非 Linux 文件系统提供的凭据，并始终使用 USER 存储位置来管理对数据的访问。请参阅创建供 USER 访问的存储位置。

默认值： 0（禁用）

WithClauseMaterialization
布尔值，指定是否启用 WITH 子句实体化结果。启用实体化 (1) 时，Vertica 会对每个 WITH 子句进行一次评估并将结果存储在临时表中。

对于具有复杂类型的 WITH 查询，临时关系被禁用。

默认值： 0（禁用）

WithClauseRecursionLimit
指定 WITH RECURSIVE 子句在退出之前迭代其自己的结果集内容的最大次数。有关详细信息，请参阅WITH 子句递归。

默认值： 8

6.2 - Azure 参数

使用以下参数配置从 Azure Blob 存储读取。有关从 Azure 读取数据的详细信息，请参阅 Azure Blob 存储对象存储。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
AzureStorageCredentials
JSON 对象的集合，其中每个对象指定一个端点的连接凭据。此参数优先于 Azure 托管标识。

该集合必须至少包含一个对象，并且可能会包含多个对象。每个对象必须至少指定 accountName 或 blobEndpoint 之一，并且至少指定 accountKey 或 sharedAccessSignature 之一。

  • accountName：如果未指定，则使用 blobEndpoint 标签。
  • blobEndpoint：带有可选端口的主机名 (host:port)。如果未指定，则使用 account.blob.core.windows.net。
  • accountKey：帐户或端点的访问密钥。
  • sharedAccessSignature：用于更精细访问控制的访问令牌（如果 Azure 端点正在使用）。
AzureStorageEndpointConfig
JSON 对象的集合，其中每个对象指定一个端点的配置元素。每个对象必须至少指定 accountName 或 blobEndpoint 之一。
  • accountName：如果未指定，则使用 blobEndpoint 标签。
  • blobEndpoint：带有可选端口的主机名 (host:port)。如果未指定，则使用 account.blob.core.windows.net。
  • protocol：HTTPS（默认）或 HTTP。
  • isMultiAccountEndpoint：如果端点支持多个帐户，则为 true，否则为 false（默认为 false）。要使用多帐户访问权限，则必须在 URI 中包含帐户名称。如果 URI 路径包含帐户，则系统将假定此值为 true，但显式设置为 false 则除外。

6.3 - 约束参数

以下配置参数控制 Vertica 评估和强制实施约束的方式。所有参数均通过 ALTER DATABASE 在数据库级别设置。

其中三个参数 — EnableNewCheckConstraintsByDefault, EnableNewPrimaryKeysByDefault 和 EnableNewUniqueKeysByDefault — 可分别用于强制执行 CHECK、PRIMARY KEY 和 UNIQUE 约束。有关详细信息，请参阅约束强制执行。

EnableNewCheckConstraintsByDefault
布尔参数，设置为 0 或 1：

  • 0：禁用新 CHECK 约束的强制执行，除非表 DDL 显式启用它们。

  • 1（默认）：强制执行新的 CHECK 约束，除非表 DDL 显式禁用它们。

EnableNewPrimaryKeysByDefault
布尔参数，设置为 0 或 1：

  • 0（默认）：禁用新 PRIMARY KEY 约束的强制执行，除非表 DDL 显式启用它们。

  • 1：强制执行新的 PRIMARY KEY 约束，除非表 DDL 显式禁用它们。

EnableNewUniqueKeysByDefault
布尔参数，设置为 0 或 1：

  • 0（默认）：禁用新 UNIQUE 约束的强制执行，除非表 DDL 显式启用它们。

  • 1：强制执行新的 UNIQUE 约束，除非表 DDL 显式禁用它们。

MaxConstraintChecksPerQuery
设置 ANALYZE_CONSTRAINTS 可以通过单个查询处理的最大约束数：

  • -1（默认）：没有设置最大值，ANALYZE_CONSTRAINTS 使用单个查询来评估指定范围内的所有约束。

  • 大于 0 的整数：每个查询的最大约束数量。如果要评估的约束数量超过此值，ANALYZE_CONSTRAINTS 会使用多个查询对其进行处理。

有关详细信息，请参阅分布约束分析。

6.4 - Database Designer 参数

下表介绍用于配置 Vertica Database Designer 的参数。

DBDCorrelationSampleRowCount
Database Designer 发现和记录相关列的最少表行数。

默认值： 4000

DBDLogInternalDesignProcess
启用或禁用 Database Designer 日志记录。

默认值： 0 (False)

DBDUseOnlyDesignerResourcePool
允许 Vertica Database Designer 使用 DBD 池。

当设置为 false 时，设计处理操作通常会限制在该用户的资源池内，但不太密集的任务可能会使用系统资源

默认值： 0 (False)

6.5 - Eon 模式参数

以下参数配置数据库在 Eon 模式下运行时的操作方式。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。

BackgroundDepotWarming
指定后台存储库预热行为：

  • 1：存储库在预热时加载对象，在节点变为活动状态并开始执行查询后继续在后台执行此操作。

  • 0：节点激活被延迟，直到存储库获取并加载所有排队的对象

有关详细信息，请参阅存储库预热。

默认值： 1

CatalogSyncInterval
指定事务日志同步服务将元数据同步到公共存储的频率（以分钟为单位）。如果您更改此设置，Vertica 将重启间隔计数。

默认值： 5

DelayForDeletes
指定从公共存储中删除文件之前要等待的时间（以小时为单位）。Vertica 首先从存储库中删除一个文件。在指定的时间间隔之后，删除也会发生在公共存储中。

默认值： 0.分片订购者不使用该文件时，立即从公共存储中将其删除。

DepotOperationsForQuery
指定当存储库不包含查询的文件数据时的行为，为以下之一：

  • ALL （默认值）：从公共存储中提取文件数据，如有必要，通过将现有文件从存储库中逐出来替换它们。

  • FETCHES：仅当空间可用时才从公共存储中提取文件数据；否则，直接从公共存储中读取查询的数据。

  • NONE：请勿将文件数据提取到存储库，而应直接从公共存储中读取查询的数据。

您还可以使用提示 DEPOT_FETCH 指定查询级别的行为。

ECSMode
字符串参数，用于设置 Vertica 在启用 ECS 的查询期间在订阅节点之间划分分片中的数据时使用的策略，为以下之一：

  • AUTO：优化器自动确定要使用的策略。

  • COMPUTE_OPTIMIZED：强制使用计算优化策略。

  • IO_OPTIMIZED：强制使用 I/O 优化策略。

有关详细信息，请参阅手动选择 ECS 策略。

默认值： AUTO

ElasticKSafety
控制 Vertica 是否因 主节点丢失而调整分片订购的布尔参数：
  • 1：当主节点丢失时，Vertica 会将其他主节点订购到已关闭节点的分片订购。此操作有助于减少因分片覆盖率丢失而导致数据库进入只读模式的可能性。
  • 0：Vertica 不会因主节点丢失而更改分片订购。

默认值： 1

有关详细信息，请参阅维护分片覆盖率。

EnableDepotWarmingFromPeers
布尔参数，指定 Vertica 是否在节点启动且未准备好处理查询时预热节点存储库：

  • 1：在节点开始运行时预热存储库。

  • 0：仅在节点正常运行后预热存储库。

有关详细信息，请参阅存储库预热。

默认值： 0

FileDeletionServiceInterval
指定每次执行 reaper 清理服务任务之间的时间间隔（以秒为单位）。

默认值： 60 秒

MaxDepotSizePercent
一个整数值，指定存储库的最大大小（磁盘大小的百分比），

默认值： 80

PreFetchPinnedObjectsToDepotAtStartup
如果启用（设置为 1），则预热存储库获取固定在其子群集上的对象。有关详细信息，请参阅存储库预热。

默认值： 0

ReaperCleanUpTimeoutAtShutdown
指定 Vertica 在关闭前等待 reaper 从公共存储中删除文件的时间（以秒为单位）。如果设置为负值，Vertica 会关闭而不等待 reaper。

默认值： 300

StorageMergeMaxTempCacheMB
每个查询分配给 StorageMerge 运算符以供缓存 S3 存储容器的数据的临时空间大小。

有关详细信息，请参阅存储容器的本地缓存。

UseCommunalStorageForBatchDepotWarming
布尔参数，指定节点在预热其存储库时在何处检索数据：

  • 1：从公共存储中检索数据。

  • 0：从对等点检索数据。

默认值： 1

UseDepotForReads
布尔参数，指定 Vertica 是通过访问存储库以回答查询，还是仅访问公共存储：

  • 1：Vertica 首先在存储库中搜索查询的数据；如果不存在，Vertica 将在运行此查询和将来的查询时从公共存储中获取数据。

  • 0：Vertica 绕过存储库并始终从公共存储中获取查询的数据。

默认值： 1

UseDepotForWrites
布尔参数，指定 Vertica 是否将加载的数据写入存储库，然后将文件上传到公共存储：

  • 1：将加载的数据写入存储库，将文件上传到公共存储。

  • 0：绕过存储库并始终直接写入公共存储。

默认值： 1

UsePeerToPeerDataTransfer
布尔参数，指定 Vertica 是否将加载的数据推送给其他分片订购者：

  • 1：将加载的数据发送给所有分片订购者。

  • 0：不将数据推送到其他分片订购者。

默认值： 0

6.6 - 时期管理参数

下表介绍用于配置 Vertica 的时期管理参数。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
AdvanceAHMInterval
确定 Vertica 检查历史保留状态的频率（以秒为单位）。

不能将 AdvanceAHMInterval 设置为小于 EpochMapInterval 的值。

默认值： 180（秒）

AHMBackupManagement
阻止 Ancient History Mark (AHM) 提前。启用此参数时，AHM 时期不能晚于最近一次完整备份的时期。如果您提前 AHM 来清除和删除数据，请不要启用此参数。

默认值： 0

EpochMapInterval
确定时期之间的映射粒度以及可用于 历史查询的时间。当发出历史查询 AT TIME T 请求时，Vertica 会将其映射到位于 EpochMapInterval 秒粒度内的某个时期。类似地，它会影响故障恢复期间针对 上一个完好的时期报告的时间。请注意，它不会影响时期本身的内部精度。

默认值： 180（秒）

HistoryRetentionTime
确定已删除数据作为历史参考保存的时间长度（以秒为单位）。在删除后的指定时间过去后，您可以清除数据。如果您喜欢使用 HistoryRetentionEpochs 确定可以清除的已删除数据，请使用 -1 设置。

默认值： 0（当节点关闭时保存的数据。）

HistoryRetentionEpochs
指定要保存的历史 时期数以及已删除的数据量。

除非您有理由限制时期数，否则 Vertica 建议您指定保存已删除数据的时间长度。

如果同时指定两个 History 参数，则 HistoryRetentionTime 的优先级更高。将两个参数设置为 -1 可保留所有历史数据。

请参阅设置清除策略。

默认值： -1（禁用）

6.7 - Google Cloud Storage 参数

使用以下参数配置使用 COPY FROM 从 Google Cloud Storage (GCS) 读取。有关从 S3 读取数据的更多信息，请参阅指定加载数据的位置。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
GCSAuth
用于向 GCS 进行身份验证的 ID 和密钥。您可以使用 ALTER DATABASE...SET PARAMETER 和 ALTER SESSION...SET PARAMETER 分别设置全局参数和当前会话的参数。为了获得更高的安全性，不要将凭据存储在数据库中；而是通过 ALTER SESSION 为当前会话设置凭据。例如： 
=> ALTER SESSION SET GCSAuth='ID:secret';

如果您使用共享凭据，请通过 ALTER DATABASE 在数据库中设置。

GCSEnableHttps
指定连接 GCS 时是否使用 HTTPS 协议，只能在数据库级别用 ALTER DATABASE...SET PARAMETER 设置。

默认值： 1（启用）

GCSEndpoint
连接端点地址。

默认值： storage.googleapis.com

6.8 - Hadoop 参数

下表介绍用于配置与 Apache Hadoop 集成的常规参数。有关详细信息，请参阅Apache Hadoop 集成。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
EnableHDFSBlockInfoCache
布尔值，是否将规划期间在启动程序上收集的块位置元数据分发到所有数据库节点以供执行。分发此元数据会减少名称节点访问，从而减少负载，但在名称节点不争用的部署中，可能会在一定程度上降低数据库性能。这种性能影响是因为必须序列化和分发此数据。如果保护名称节点比查询性能更重要，则启用分发；这通常适用于名称节点争用已造成影响的大型 HDFS 群集。

默认值： 0（禁用）

HadoopConfDir
包含从 Hadoop 复制的 XML 配置文件的目录路径。相同的路径必须在每个 Vertica 节点上都有效。您可以使用 VERIFY_HADOOP_CONF_DIR 元函数来测试该值是否设置正确。要从 HDFS 读取数据，需要设置此参数。

对于所有 Vertica 用户，文件由运行 Vertica 服务器进程的 Linux 用户访问。

设置此参数时，会刷新先前缓存的配置信息。

您可以在会话级别设置此参数。这样做会覆盖数据库值；数据库值不附加到它。例如：

  
=> ALTER SESSION SET HadoopConfDir='/test/conf:/hadoop/hcat/conf';

要附加，请获取当前值并将其包含在附加后的新路径中。在会话级别设置此参数不会更改文件的访问方式。

默认值： 从环境中获取（如果可能）

HadoopFSAuthentication
如何（或是否）将 Kerberos 身份验证与 HDFS 一起使用。默认情况下，如果设置了 KerberosKeytabFile，Vertica 会将该凭据用于 Vertica 和 HDFS。通常这是期望的行为。但是，如果您将 Kerberized Vertica 群集与非 Kerberized HDFS 群集一起使用，请将此参数设置为“none”以指示 Vertica 不应使用 Vertica Kerberos 凭据访问 HDFS。

默认值： 如果设置了 KerberosKeytabFile，则为“keytab”，否则为“none”

HadoopFSBlockSizeBytes
写入 HDFS 的块大小。较大的文件被拆分成这种大小的块。

默认值： 64MB

HadoopFSNNOperationRetryTimeout
元数据操作（例如列表目录）在失败前等待响应的秒数。接受毫秒精度的浮点值。

默认值： 6 秒

HadoopFSReadRetryTimeout
读取操作在失败前等待的秒数。接受毫秒精度的浮点值。如果确信您的文件系统失败速度更快，降低此值可提高性能。

默认值： 180 秒

HadoopFSReplication
HDFS 创建的副本数。这与 Vertica 为提供 K-safety 而进行的复制无关。除非 Vertica 支持人员另有指示，否则请勿更改此设置。

默认值： 3

HadoopFSRetryWaitInterval
在重试读取、写入和元数据操作之前等待的初始秒数。接受毫秒精度的浮点值。重试间隔随着每次重试呈指数增长。

默认值： 3 秒

HadoopFSTokenRefreshFrequency
刷新用于保存 Kerberos 票证的 Hadoop 令牌的频率（以秒为单位）（请参阅令牌过期）。

默认值： 0（令牌过期时刷新）

HadoopFSWriteRetryTimeout
写入操作在失败前等待的秒数。接受毫秒精度的浮点值。如果确信您的文件系统失败速度更快，降低此值可提高性能。

默认值： 180 秒

HadoopImpersonationConfig
会话参数，用于指定 HDFS 访问的委派令牌或 Hadoop 用户。请参阅 HadoopImpersonationConfig 格式了解有关此参数值的信息，请参阅代理用户和委托令牌了解有关更一般的上下文。
HDFSUseWebHDFS
布尔值，hdfs 方案中的 URL 是否使用 WebHDFS 而不是 LibHDFS++ 来访问数据。

默认值： 1（启用）

WebhdfsClientCertConf
用于访问一个或多个 WebHDFS 服务器的 mTLS 配置。该值是一个 JSON 字符串；每个成员具有以下属性：

  • nameservice：WebHDFS 名称服务

  • authority：host:port

  • certName：由..定义的证书名称 CREATE CERTIFICATE

nameservice 和 authority 互斥。

例如：

=> ALTER SESSION SET WebhdfsClientCertConf =
    '[{"authority" : "my.authority.com:50070", "certName" : "myCert"},
      {"nameservice" : "prod", "certName" : "prodCert"}]';

HCatalog 连接器参数

下表介绍用于配置 HCatalog 连接器的参数。有关详细信息，请参阅使用 HCatalog 连接器。

EnableHCatImpersonation
布尔值，HCatalog 连接器在访问 Hive 时是否使用（模拟）当前 Vertica 用户。如果启用了模拟，HCatalog 连接器将使用已登录 Vertica 用户的 Kerberos 凭据来访问 Hive 数据。如果您使用授权服务来管理访问权限而不授予用户对基础文件的访问权限，请禁用模拟。有关详细信息，请参阅配置安全性。

默认值： 1（启用）

HCatalogConnectorUseHiveServer2
布尔值，Vertica 内部是否使用 HiveServer2 而不是 WebHCat 从 Hive 获取元数据。

默认值： 1（启用）

HCatalogConnectorUseLibHDFSPP
布尔值，HCatalog 连接器是否应将 hdfs 方案而不是 webhdfs 与 HCatalog 连接器配合使用。

默认值： 1（启用）

HCatConnectionTimeout
HCatalog 连接器在返回超时错误之前成功连接到 HiveServer2（或 WebHCat）服务器所等待的秒数。

默认值： 0（无限期等待）

HCatSlowTransferLimit
HCatalog 连接器从 HiveServer2（或 WebHCat）服务器检索数据时所允许的最低传输速度（以每秒字节数为单位）。在某些情况下，从服务器到 Vertica 的数据传输率低于此阈值。这种情况下，经过 HCatSlowTransferTime 参数中的指定秒数之后，HCatalog 连接器会取消查询并关闭连接。

默认值： 65536

HCatSlowTransferTime
HCatalog 连接器在测试服务器的数据传输是否过慢之前所等待的秒数。请参阅 HCatSlowTransferLimit 参数。

默认值： 60

6.9 - 国际化参数

下表介绍用于配置 Vertica 的国际化参数。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
DefaultIntervalStyle
设置要使用的默认间隔样式。如果设置为 0（默认值），则输出时间隔采用 PLAIN 样式（SQL 标准）并且没有间隔单位。如果设置为 1，则输出时间隔采用 UNITS。重新启动数据库后，此参数才会生效。

默认值： 0

DefaultSessionLocale
设置数据库的默认会话启动区域设置。重新启动数据库后，此参数才会生效。

默认值： en_US@collation=binary

EscapeStringWarning
当字符串字面量中使用反斜线时发出警告。此参数可帮助找到被视为转义字符的反斜线，以便对其进行修复，使其遵循符合字符串语法的 SQL 标准。

默认值： 1

StandardConformingStrings
确定字符串字面量将反斜线 (\) 视为字符串字面量还是视为转义字符。当设置为 -1 时，将反斜线视为字符串字面量；当设置为 0 时，将反斜线视为转义字符。

默认值： -1

6.10 - Kafka 用户定义的会话参数

在不使用调度程序时，使用 ALTER SESSION SET UDPARAMETER 设置 Vertica 用户定义的会话参数以配置 Kafka SSL。以 kafka 为前缀的参数为 Kafka 配置 SSL 身份验证。有关详细信息，请参阅使用 Kafka 进行 TLS/SSL 加密。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
kafka_SSL_CA
证书颁发机构证书的内容。例如： 
=> ALTER SESSION SET UDPARAMETER kafka_SSL_CA='MIIBOQIBAAJBAIOL';

默认值： 无

kafka_SSL_Certificate
SSL 证书的内容。例如： 
=> ALTER SESSION SET UDPARAMETER kafka_SSL_Certificate='XrM07O4dV/nJ5g';

当 Kafka 服务器的参数 ssl.client.auth 设置为 none 或 requested 时，此参数为可选。

默认值： 无

kafka_SSL_PrivateKey_secret
用于加密会话的私钥。Vertica 不会记录此信息。例如： 
=> ALTER SESSION SET UDPARAMETER kafka_SSL_PrivateKey_secret='A60iThKtezaCk7F';

当 Kafka 服务器的参数 ssl.client.auth 设置为 none 或 requested 时，此参数为可选。

默认值： 无

kafka_SSL_PrivateKeyPassword_secret
用于创建私钥的密码。Vertica 不会记录此信息。

例如：

ALTER SESSION SET UDPARAMETER kafka_SSL_PrivateKeyPassword_secret='secret';

当 Kafka 服务器的参数 ssl.client.auth 设置为 none 或 requested 时，此参数为可选。

默认值： 无

kafka_Enable_SSL
为 Vertica-Kafka 集成启用 SSL 身份验证。例如： 
=> ALTER SESSION SET UDPARAMETER kafka_Enable_SSL=1;

默认值： 0

MaxSessionUDParameterSize
在用户定义的会话参数中设置某个值的最大长度。例如： 
=> ALTER SESSION SET MaxSessionUDParameterSize = 2000

默认值： 1000

相关主题

用户定义的会话参数

6.11 - Kerberos 参数

以下参数用于配置 Kerberos 身份验证的 Vertica 主体并指定 Kerberos keytab 文件的位置。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
KerberosServiceName
提供 Vertica Kerberos 主体的服务名称部分。默认情况下，此参数为 vertica。例如： 
vertica/host@EXAMPLE.COM

默认值： vertica

KerberosHostname
提供 Vertica Kerberos 主体的实例或主机名部分。例如： 
vertica/host@EXAMPLE.COM

如果您忽略可选的 KerberosHostname 参数，则 Vertica 使用 gethostname() 函数的返回值。假设每个群集节点都具有不同的主机名，那么这些节点每个都将具有不同的主体，您必须在节点的 keytab 文件中对主体进行管理。

KerberosRealm
提供 Vertica Kerberos 主体的领域部分。领域为身份验证管理域，通常以大写字母组成。例如： 
vertica/hostEXAMPLE.COM
KerberosKeytabFile
提供包含 Vertica Kerberos 主体凭据的 keytab 文件的位置。默认情况下，该文件位于 /etc 中。例如： 
KerberosKeytabFile=/etc/krb5.keytab
KerberosTicketDuration
确定通过执行 kinit 检索到的票证的生命周期。默认值为 0（零），表示禁用此参数。

如果您忽略设置此参数，则生命周期由默认的 Kerberos 配置确定。

6.12 - 机器学习参数

您可以使用机器学习参数来配置 Vertica 中机器学习功能的各个方面。

MaxModelSizeKB
设置可以导入的模型的最大大小。metadata.json 文件中指定的文件大小的总和决定了模型大小。此参数的单位是 KB。原生 Vertica 模型 (category=VERTICA_MODELS) 不受此限制。如果您可以从 Vertica 导出模型，并且模型在 Vertica 之外没有更改，则可以再次将其导入 Vertica。

MaxModelSizeKB 参数只能由超级用户设置，并且只能在数据库级别设置。它仅对超级用户可见。其默认值为 4GB，有效范围为 1KB 到 64GB（包含）。

示例：

将此参数设置为 3KB：

=> ALTER DATABASE DEFAULT SET MaxModelSizeKB = 3;

将此参数设置为 64GB（允许的最大值）：

=> ALTER DATABASE DEFAULT SET MaxModelSizeKB = 67108864;

将此参数重置为默认值：

=> ALTER DATABASE DEFAULT CLEAR MaxModelSizeKB;

默认值： 4GB

6.13 - 内存管理参数

下表介绍用于管理 Vertica 内存利用率的参数。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
MemoryPollerIntervalSec
指定 Vertica 内存轮询器检查 Vertica 内存利用率是否低于几个配置参数的阈值的频率（以秒为单位，见下文）：

  • MemoryPollerMallocBloatThreshold

  • MemoryPollerReportThreshold

  • MemoryPollerTrimThreshold

默认值： 2

MemoryPollerMallocBloatThreshold
glibc 内存膨胀的阈值。

内存轮询器将调用 glibc 函数 malloc_info()，以获取 malloc 中的空闲内存量。然后它将 MemoryPollerMallocBloatThreshold（默认设置为 0.3）与以下表达式进行比较：

free‑memory‑in‑malloc / RSS

如果此表达式的计算结果大于 MemoryPollerMallocBloatThreshold，内存轮询器将调用 glibc 函数 malloc_trim()。此函数从 malloc 中回收空闲内存，并将其返回给操作系统。调用 malloc_trim() 的详细信息将写入系统表 MEMORY_EVENTS。

要禁用此阈值的轮询，请将参数设置为 0。

默认值： 0.3

MemoryPollerReportThreshold
确定 Vertica 内存轮询器是否写入报告的内存利用率阈值。

内存轮询器将 MemoryPollerReportThreshold 与以下表达式进行比较：

RSS / available‑memory

当此表达式的计算结果大于 MemoryPollerReportThreshold（默认设置为 0.93）时，内存轮询器会将报告写入 Vertica 工作目录中的 MemoryReport.log。此报告包括有关 Vertica 内存池、单个查询和会话消耗的内存量等信息。内存轮询器还将报告作为事件记录在系统表 MEMORY_EVENTS 中，并设置 EVENT_TYPE 为 MEMORY_REPORT。

要禁用此阈值的轮询，请将参数设置为 0。

默认值： 0.93

MemoryPollerTrimThreshold
内存轮询器开始检查是否修剪 glibc 分配的内存的阈值。

内存轮询器将 MemoryPollerTrimThreshold（默认设置为 0.83）与以下表达式进行比较：

RSS / available‑memory

如果此表达式的计算结果大于 MemoryPollerTrimThreshold，则内存轮询器开始检查下一个阈值（在 MemoryPollerMallocBloatThreshold 中设置）是否存在 glibc 内存膨胀。

要禁用此阈值的轮询，请将参数设置为 0。这样做也会禁用 MemoryPollerMallocBloatThreshold 的轮询。

默认值： 0.83

6.14 - 监控参数

下表介绍控制用于监控 Vertica 数据库的控制选项的参数。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
EnableDataCollector
启用和禁用数据收集器，数据收集器是工作负载分析器的内部诊断实用程序。影响所有节点上的所有会话。使用 0 关闭数据收集。

默认值： 1（启用）

SnmpTrapDestinationsList
定义 Vertica 在何处针对 SNMP 发送陷阱。请参阅为 SNMP 配置报告。例如： 
=> ALTER DATABASE DEFAULT SET SnmpTrapDestinationsList = 'localhost 162 public';

默认值： 无

SnmpTrapsEnabled
为 SNMP 启用事件陷阱。请参阅为 SNMP 配置报告。

默认值： 0

SnmpTrapEvents
定义 Vertica 通过 SNMP 捕获哪些事件。请参阅为 SNMP 配置报告。例如： 
ALTER DATABASE DEFAULT SET SnmpTrapEvents = 'Low Disk Space, Recovery Failure';

默认值： Low Disk Space、Read Only File System、Loss of K Safety、Current Fault Tolerance at Critical Level、Too Many ROS Containers、Node State Change、Recovery Failure、Stale Checkpoint 和 CRC Mismatch。

SyslogEnabled
为系统日志启用事件陷阱。请参阅为 syslog 配置报告。

默认值： 0

SyslogEvents
定义生成系统日志条目的事件。请参阅为 syslog 配置报告。例如： 
ALTER DATABASE DEFAULT SET SyslogEvents = 'Low Disk Space, Recovery Failure';

默认值： 无

SyslogFacility
定义 Vertica 使用哪个 SyslogFacility。请参阅为 syslog 配置报告。

默认值： user

6.15 - 数值精度参数

以下配置参数允许您配置数值数据类型的数值精度。有关使用这些参数的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
AllowNumericOverflow
布尔值，设置为以下值之一：

  • 1 (true)：允许静默数字溢出。Vertica 不会隐式扩展数值数据类型的精度。Vertica 忽略 NumericSumExtraPrecisionDigits 的值。

  • 0 (false)：如果结果超出 NumericSumExtraPrecisionDigits 设置的精度，Vertica 会产生溢出错误。

默认值： 1 (true)

NumericSumExtraPrecisionDigits
介于 0 和 20 之间的整数（包含）。如果结果超过指定的精度，Vertica 会产生溢出错误。此参数设置仅在 AllowNumericOverflow 设置为 0 (false) 时适用。

默认值： 6（超出 DDL 指定精度的位数）

6.16 - 分析参数

下表介绍用于配置 Vertica 的分析参数。有关分析查询的更多信息，请参阅对数据库性能执行分析。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
GlobalEEProfiling
针对在所有节点上的所有会话中运行的查询执行启用分析。

默认值： 0

GlobalQueryProfiling
针对所有节点上的所有会话启用查询分析。

默认值： 0

GlobalSessionProfiling
针对所有节点上的所有会话启用会话分析。

默认值： 0

SaveDCEEProfileThresholdUS
设置将分析信息保存到系统表 QUERY_CONSUMPTION 和 执行_引擎_配置文件 的查询持续时间阈值（以微秒为单位）。您可以将此参数设置为最大值 2147483647（231-1，或 ~35.79 分钟）。

默认值： 60000000（60 秒）

6.17 - 投影参数

下列配置参数可帮助您管理投影。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
AnalyzeRowCountInterval
指定 Vertica 多久检查一次投影行数量以及是否超出了 ARCCommitPercentage 设置的阈值。

有关详细信息，请参阅收集数据库统计信息。

默认值： 86400 秒（24 小时）

ARCCommitPercentage
针对给定表设置上次记录的聚合投影行计数和当前行计数之间的差异设置阈值百分比。当差异超过此阈值时，Vertica 会使用当前行数更新编录。

默认值： 3 (%)

ContainersPerProjectionLimit
指定在发生 ROS 后推前 Vertica 为每个投影创建的 ROS 容器数。

默认值： 1024

MaxAutoSegColumns
指定在自动投影的哈希分段子句中使用的列数 (0–1024)。设置为 0 以使用所有列。

默认值： 8

MaxAutoSortColumns
指定在自动投影的排序表达式中使用的列数 (0–1024)。设置为 0 以使用所有列。

默认值： 8

RebalanceQueryStorageContainers
默认情况下，在执行重新平衡之前，Vertica 会执行系统表查询，以计算重新平衡任务中涉及的所有投影的大小。此查询使 Vertica 能够优化重新平衡，以最有效地利用可用磁盘空间。但是，此查询会大大增加执行重新平衡所需的时间。

禁用系统表查询可以减少执行重新平衡所需的时间。如果节点的磁盘空间不足，则禁用查询会增加节点磁盘空间不足的可能性。在这种情况下，重新平衡会失败。

默认值： 1（启用）

RewriteQueryForLargeDim
如果启用 (1)，Vertica 会在 REFRESH_COLUMNS 操作期间通过反转目标表和源表之间的内部和外部联接来重写 SET USING 或 DEFAULT USING 查询。这样做可以在源数据所在的表大于目标表的情况下优化刷新性能。

默认值： 0

SegmentAutoProjection
确定在表定义忽略分段子句的情况下，是否对自动投影进行分段。此参数可在数据库和会话范围设置。

默认值： 1（创建分段自动投影）

6.18 - S3 参数

使用以下参数，配置使用 COPY 从 S3 文件系统和具有 S3 兼容 API 的本地存储进行读取。有关从 S3 读取数据的更多信息，请参阅 S3 对象存储。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
AWSAuth
用于身份验证的 ID 和密钥。为了获得更高的安全性，请不要将凭据存储在数据库中；应当使用 ALTER SESSION...SET PARAMETER 仅为当前会话设置此值。如果您使用共享凭据，您可以通过 ALTER DATABASE...SET PARAMETER 在数据库中设置。例如： 
=> ALTER SESSION SET AWSAuth='ID:secret';

在 AWS 中，这些实参被命名为 AccessKeyID 和 SecretAccessKey。

要将管理工具 create_db 或 revive_db 用于本地 Eon 模式，请使用以下设置创建一个名为 auth_params.conf 的配置文件：

AWSAuth = key:secret
  AWSEndpoint = IP:port
AWSCAFile
要使用的 TLS 服务器证书捆绑包的文件名。设置此参数会覆盖 SystemCABundlePath 参数中指定的 Vertica 默认 CA 捆绑包路径。 如果设置，此参数将覆盖 SystemCABundlePath 参数中指定的 Vertica 默认 CA 包路径。 
=> ALTER DATABASE DEFAULT SET AWSCAFile = '/etc/ssl/ca-bundle.pem';

默认值： system-dependent

AWSCAPath
Vertica 用于查找 TLS 服务器证书的路径。要使用的 TLS 服务器证书捆绑包的文件名。 如果设置，此参数将覆盖 SystemCABundlePath 参数中指定的 Vertica 默认 CA 包路径。 
=> ALTER DATABASE DEFAULT SET AWSCAPath = '/etc/ssl/';

默认值： system-dependent

AWSEnableHttps
布尔值，指定连接 S3 时是否使用 HTTPS 协议，只能在数据库级别用 ALTER DATABASE...SET PARAMETER 设置。如果选择不使用 TLS，则该参数必须设置为 0。

默认值： 1（启用）

AWSEndpoint
解释 S3 URL 时使用的端点，设置如下。

  • AWS：hostname_or_ip:port_number。

  • 具有符合 FIPS 规范的 S3 端点的 AWS：S3_hostname 并启用虚拟寻址：

    AWSEndpoint = s3-fips.dualstack.us-east-1.amazonaws.com
S3EnableVirtualAddressing = 1

  • 本地/Pure：Pure Storage 服务器的 IP 地址。如果使用管理工具 create_db 或 revive_db，请创建配置文件 auth_params.conf 并包含以下设置：

    awsauth = key:secret
      awsendpoint = IP:port

  • 如果未设置 AWSEndpoint，则默认行为是使用虚拟托管的请求 URL。

默认值： s3.amazonaws.com

AWSLogLevel
日志级别，可以是以下值之一：

  • OFF

  • FATAL

  • ERROR

  • WARN

  • INFO

  • DEBUG

  • TRACE

默认值： ERROR

AWSRegion
AWS 区域，包含要从中读取文件的 S3 存储桶。此参数一次只能配置一个区域。如果您需要在多个区域中访问存储桶，则应在每次更改区域时更改参数。

如果您没有设置正确的区域，您可能会在查询失败之前遇到延迟，因为 Vertica 在放弃之前会进行多次重试。

默认值： us-east-1

AWSSessionToken
通过运行 get-session-token 命令生成的临时安全令牌，可生成可用于配置多重身份验证的临时凭据。

使用 ALTER SESSION 在用户会话中设置此参数。您可以在数据库级别设置此参数，但请注意会话令牌是临时的。令牌过期时，任何访问 AWS 的尝试都会失败。

AWSStreamingConnectionPercentage
控制 Vertica 用于流式读取的公共存储的连接数。在云环境中，此设置有助于防止来自公共存储的流式数据传输耗尽所有可用的文件句柄。它将为其他公共存储操作留下一些可用的文件句柄。

由于本地对象存储是低延迟的，因此对于使用本地公共存储的 Eon 模式数据库，无需此选项。在这种情况下，通过将其设置为 0 来禁用该参数。

S3BucketConfig
包含作为具有以下属性的 JSON 对象的 S3 存储桶配置信息。除了存储桶名称之外的每个属性都有一个相应的配置参数（显示在括号中）。如果同时设置了 S3BucketConfig 中的属性和配置参数，则 S3BucketConfig 属性优先。

属性：

  • bucket：存储桶的名称

  • region (AWSRegion)：区域的名称

  • protocol (AWSEnableHttps)：连接协议，http 或 https

  • endpoint (AWSEndpoint)：端点 URL 或 IP 地址

  • enableVirtualAddressing (S3BucketCredentials)：是否重写 S3 URL 以使用虚拟托管路径

  • requesterPays (S3RequesterPays)：请求者（而不是存储桶所有者）是否支付访问存储桶数据的费用

  • serverSideEncryption (S3ServerSideEncryption)：使用 SSE-S3 或 SSE-KMS、AES256、aws:kms 或空字符串之一时的加密算法

  • sseCustomerAlgorithm (S3SseCustomerAlgorithm)：使用 SSE-C 时的加密算法；必须是 AES256

  • sseCustomerKey (S3SseCustomerKey)：使用 SSE-C 加密（32 字符纯文本或 44 字符 base64 编码）时的键

  • sseKmsKeyId (S3SseKmsKeyId)：使用 SSE-KMS 加密时的键 ID

给定存储桶的配置属性可能因其类型而异。例如，以下 S3BucketConfig 用于 AWS 存储桶 AWSBucket 和 Pure Storage 存储桶 PureStorageBucket。 AWSBucket 没有指定端点，因此 Vertica 使用 AWSEndpoint 的值，其默认为 s3.amazonaws.com：

ALTER DATABASE DEFAULT SET S3BucketConfig=
'[
    {
        "bucket": "AWSBucket",
        "region": "us-east-2",
        "protocol": "https",
        "requesterPays": true
    },
    {
        "bucket": "PureStorageBucket",
        "endpoint": "pure.mycorp.net:1234",
        "protocol": "http",
        "enableVirtualAddressing": false
    }
]';
S3BucketCredentials
包含用于访问 S3 存储桶的凭据。S3BucketCredentials 中的每个属性都有一个等效参数（显示在括号中）。设置后，S3BucketCredentials 优先于 AWSAuth 和 AWSSessionToken。

为多个存储桶提供凭据可以同时对它们进行身份验证，从而允许执行跨端点联接、从一个存储桶导出到另一个存储桶等。

属性：

  • bucket：存储桶的名称

  • accessKey：存储桶的访问密钥（AWSAuth 中的 ID）

  • secretAccessKey：存储桶的私密访问密钥（AWSAuth 中的 secret）

  • sessionToken：会话令牌，仅在会话级别设置 S3BucketCredentials 时使用 (AWSSessionToken)

例如，以下 S3BucketCredentials 用于 AWS 存储桶 AWSBucket 和 Pure Storage 存储桶 PureStorageBucket 并设置所有可能的属性：

ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "AWSBucket",
        "accessKey": "<AK0>",
        "secretAccessKey": "<SAK0>",
        "sessionToken": "1234567890"
    },
    {
        "bucket": "PureStorageBucket",
        "accessKey": "<AK1>",
        "secretAccessKey": "<SAK1>"
    }
]';

此参数仅对超级用户可见。用户可以使用 ALTER SESSION 在会话级别设置此参数。

S3EnableVirtualAddressing
布尔值，指定是否重写 S3 URL 以使用虚拟托管路径。例如，如果您使用 AWS，S3 URL 将更改为 bucketname.s3.amazonaws.com 而不是 s3.amazonaws.com/bucketname。此配置设置仅在您为 AWSEndpoint 指定值时生效。

如果您将 AWSEndpoint 设置为符合 FIPS 规范的 S3 端点，则必须在 auth_params.conf 中启用 S3EnableVirtualAddressing：

AWSEndpoint = s3-fips.dualstack.us-east-1.amazonaws.com
S3EnableVirtualAddressing = 1

此参数的值不会影响指定 S3 路径的方式。

默认值： 0（禁用）

S3RequesterPays
布尔值，指定请求者（而不是存储桶所有者）是否支付访问存储桶数据的费用。此值为 true 时，存储桶所有者只负责支付存储数据的费用，而不负责与存储桶相关的所有费用；必须设置后才能访问配置为“请求者付款”存储桶的 S3 存储桶。通过将此属性设置为 true，您将接受访问数据的费用。如果未指定，则默认值为 false。
S3ServerSideEncryption
字符串，读取或写入 S3 时使用的加密算法。该值取决于为 S3 配置的静态加密类型：

  • AES256：用于 SSE-S3 加密

  • aws:kms：用于 SSE-KMS 加密

  • 空字符串 ("")：无加密

SSE-C 加密不使用此参数。请参阅 S3SseCustomerAlgorithm。

有关使用 SSE 参数的详细信息，请参阅 S3 对象存储。

默认值： ""（无加密）

S3SseCustomerAlgorithm
字符串，使用 SSE-C 加密读取或写入 S3 时使用的加密算法。支持的值仅包括 AES256 和 ""。

对于 SSE-S3 和 SSE-KMS，请改用 S3ServerSideEncryption。

默认值： ""（无加密）

S3SseCustomerKey
如果使用 SSE-C 加密，则为 S3 访问的客户端密钥。
S3SseKmsKeyId
如果使用 SSE-KMS 加密，则将密钥标识符（不是密钥）传递给密钥管理服务器。Vertica 必须有权使用通过 KMS 管理的密钥。

6.19 - 安全性参数

可使用以下客户端身份验证配置参数和常规安全性参数配置 TLS。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。

数据库参数

DataSSLParams
此参数已弃用。请改用 data_channel TLS CONFIGURATION。

在数据通道上启用使用 SSL 加密。此参数的值是以逗号分隔的以下内容的列表：

  • SSL 证书（可链接）

  • 对应的 SSL 私钥

  • SSL CA（证书颁发机构）证书。

在设置此参数之前，应该设置 EncryptSpreadComm。

在以下示例中，SSL 证书包含两个证书，其中非根 CA 的证书用于验证群集的证书。这称为 SSL 证书链。

=> ALTER DATABASE DEFAULT SET PARAMETER DataSSLParams =
'----BEGIN CERTIFICATE-----<certificate for Cluster>-----END CERTIFICATE-----
-----BEGIN CERTIFICATE-----<certificate for non-root CA>-----END CERTIFICATE-----,
-----BEGIN RSA PRIVATE KEY-----<private key for Cluster>-----END RSA PRIVATE KEY-----,
-----BEGIN CERTIFICATE-----<certificate for public CA>-----END CERTIFICATE-----';
DefaultIdleSessionTimeout
指示未设置 IDLESESSIONTIMEOUT 的所有用户的默认会话超时值。例如： 
=> ALTER DATABASE DEFAULT SET defaultidlesessiontimeout = '300 secs';
DHParams
字符串，至少 2048 位的 Diffie-Hellman 组，形式为： 
 -----BEGIN DH PARAMETERS-----...-----END DH PARAMETERS-----

您可以生成自己的或使用 RFC 3526 中指定的预先计算的模指数 (MODP) Diffie-Hellman 组。

对此参数的更改在重启数据库后才会生效。

默认值： RFC 3526 2048 位 MODP 组 14：

  
-----BEGIN DH PARAMETERS-----MIIBCAKCAQEA///////////
JD9qiIWjCNMTGYouA3BzRKQJOCIpnzHQCC76mOxObIlFKCHmONAT
d75UZs806QxswKwpt8l8UN0/hNW1tUcJF5IW1dmJefsb0TELppjf
tawv/XLb0Brft7jhr+1qJn6WunyQRfEsf5kkoZlHs5Fs9wgB8uKF
jvwWY2kg2HFXTmmkWP6j9JM9fg2VdI9yjrZYcYvNWIIVSu57VKQd
wlpZtZww1Tkq8mATxdGwIyhghfDKQXkYuNs474553LBgOhgObJ4O
i7Aeij7XFXfBvTFLJ3ivL9pVYFxg5lUl86pVq5RXSJhiY+gUQFXK
OWoqsqmj//////////wIBAg==-----END DH PARAMETERS-----
DoUserSpecificFilteringInSysTables
布尔值，指定非超级用户是否可以查看其他用户的详细信息：

  • 0：用户可以查看其他用户的详细信息。

  • 1：用户只能查看有关自己的详细信息。

默认值： 0

EnableAllRolesOnLogin
布尔值，指定是否在登录时自动启用授予用户的所有角色：

  • 0：不自动启用角色

  • 1：自动启用角色。使用此设置时，用户无需运行 SET ROLE。

默认值： 0（禁用）

EnabledCipherSuites
指定哪些 SSL 密码套件用于安全的客户端-服务器通信。对此参数的更改仅适用于新连接。

默认值： Vertica 使用 Microsoft Schannel 默认密码套件。有关详细信息，请参阅 Schannel 文档。

EncryptSpreadComm
在控制通道上启用 Spread 加密，设置为以下字符串之一：

  • vertica：指定 Vertica 为数据库群集生成 Spread 加密密钥。

  • aws-kms|key‑name，其中 key‑name 是 iAWS 密钥管理服务 (KMS) 中的命名密钥。在数据库重启时，Vertica 从 KMS 获取命名密钥，而不是生成自己的密钥。

如果参数为空，则 Spread 通信未加密。通常，您应该在修改其他安全参数之前启用此参数。

启用此参数需要重启数据库。

GlobalHeirUsername
字符串，指定哪些用户在删除其所有者后继承对象。此设置可确保保留那些不执行保留操作就会丢失的数据。

将此参数设置为以下字符串值之一：

  • 空字符串：已删除的用户的对象将从数据库中移除。

  • username：将已删除的用户的对象重新分配给 username。如果 username 不存在，Vertica 会创建该用户并将 GlobalHeirUsername 设置为它。

  • <auto>：将已删除的 LDAP 用户的对象重新分配给用户 dbadmin。

有关用法的更多信息，请参阅示例。

默认值： <auto>

HttpsTLSConfig
用于 HTTPS 的 TLS CONFIGURATION。

例如：

=> ALTER DATABASE DEFAULT SET HttpsTLSConfig = my_tls_config;

默认值： server

ImportExportTLSMode
使用 CONNECT TO VERTICA 连接到另一个 Vertica 群集进行导入或导出时，指定使用 TLS 的严格程度。可能的值为：

  • PREFER：尝试 TLS，但如果 TLS 失败，则回退到明文。

  • REQUIRE：如果服务器不支持 TLS，则使用 TLS 并失败。

  • VERIFY_CA：需要 TLS（与 REQUIRE 一样），并使用“服务器”TLS CONFIGURATION 的 CA 证书（在本例中为“ca_cert”和“ica_cert”）指定的 CA 来验证其他服务器的证书：

    => SELECT name, certificate, ca_certificates, mode FROM tls_configurations WHERE name = 'server';
  name  |   certificate    |   ca_certificates   |   mode
--------+------------------+---------------------+-----------
 server | server_cert      | ca_cert,ica_cert    | VERIFY_CA
(1 row)

  • VERIFY_FULL：需要 TLS 并验证证书（与 VERIFY_CA 一样），并验证服务器证书的主机名。

  • REQUIRE_FORCE、VERIFY_CA_FORCE 和 VERIFY_FULL_FORCE：分别与 REQUIRE、VERIFY_CA 和 VERIFY_FULL 行为相同，并且不能被 CONNECT TO VERTICA 覆盖。

默认值： PREFER

InternodeTLSConfig
用于节点间加密的 TLS CONFIGURATION。

例如：

=> ALTER DATABASE DEFAULT SET InternodeTLSConfig = my_tls_config;

默认值： data_channel

LDAPAuthTLSConfig
用于 TLS 与 LDAP 身份验证的 TLS CONFIGURATION。

例如：

=> ALTER DATABASE DEFAULT SET LDAPAuthTLSConfig = my_tls_config;

默认值： ldapauth

LDAPLinkTLSConfig
用于 LDAP 链接服务的 TLS 的 TLS CONFIGURATION。

例如：

=> ALTER DATABASE DEFAULT SET LDAPLinkTLSConfig = my_tls_config;

默认值： ldaplink

PasswordLockTimeUnit
在 FAILED_LOGIN_ATTEMPTS 之后账户被锁定的 PASSWORD_LOCK_TIME 时间单位，为以下之一：

  • 'd'：天（默认）

  • 'h'：小时

  • 'm'：分钟

  • 's'：秒

例如，配置默认配置文件，以在 3 次登录尝试失败后锁定用户帐户 30 分钟：

  
=> ALTER DATABASE DEFAULT SET PasswordLockTimeUnit = 'm'
=> ALTER PROFILE DEFAULT LIMIT PASSWORD_LOCK_TIME 30;
RequireFIPS
布尔值，指定是否启用 FIPS 模式：

  • 0（禁用）

  • 1：（启用）

启动时，Vertica 会根据文件 crypto.fips_enabled 的内容自动设置此参数。您不能修改此参数。

有关详细信息，请参阅Vertica 服务器的 FIPS 合规性。

默认值： 0

SecurityAlgorithm
设置哈希身份验证使用的算法，为以下之一：

  • SHA512

  • MD5

例如：

=> ALTER DATABASE DEFAULT SET SecurityAlgorithm = 'SHA512';

默认值： SHA512

ServerTLSConfig
用于客户端-服务器 TLS 的 TLS CONFIGURATION。

例如：

=> ALTER DATABASE DEFAULT SET ServerTLSConfig = my_tls_config;

默认值： server

SystemCABundlePath
受信任 CA 的证书捆绑包的绝对路径。当通过各自的 SDK 和 libcurl 与 AWS 或 Azure 等外部服务建立 TLS 连接时，将使用此 CA 捆绑包。在所有节点上，CA 捆绑包文件必须在相同位置。

如果此参数为空，Vertica 将搜索 CA 捆绑包的“标准”路径，这在不同的分发版中有所不同：

  • 基于 Red Hat： /etc/pki/tls/certs/ca-bundle.crt
  • 基于 Debian： /etc/ssl/certs/ca-certificates.crt
  • SUSE： /var/lib/ca-certificates/ca-bundle.pem

示例：

=> ALTER DATABASE DEFAULT SET SystemCABundlePath = 'path/to/ca_bundle.pem';

默认值： Empty

TLS 参数

要设置 Vertica 数据库的 TLSMode、私钥、服务器证书和 CA 证书，请参阅 TLS 配置。在 11.0.0 之前的版本中，这些参数分别称为 EnableSSL、SSLPrivateKey、SSLCertificate 和 SSLCA。

示例

设置数据库参数 GlobalHeirUsername：

=> \du
      List of users
 User name | Is Superuser
-----------+--------------
 Joe       | f
 SuzyQ     | f
 dbadmin   | t
(3 rows)

=> ALTER DATABASE DEFAULT SET PARAMETER GlobalHeirUsername='SuzyQ';
ALTER DATABASE
=>  \c - Joe
You are now connected as user "Joe".
=> CREATE TABLE t1 (a int);
CREATE TABLE

=> \c
You are now connected as user "dbadmin".
=> \dt t1
             List of tables
 Schema | Name | Kind  | Owner | Comment
--------+------+-------+-------+---------
 public | t1   | table | Joe   |
(1 row)

=> DROP USER Joe;
NOTICE 4927:  The Table t1 depends on User Joe
ROLLBACK 3128:  DROP failed due to dependencies
DETAIL:  Cannot drop User Joe because other objects depend on it
HINT:  Use DROP ... CASCADE to drop the dependent objects too
=> DROP USER Joe CASCADE;
DROP USER
=> \dt t1
             List of tables
 Schema | Name | Kind  | Owner | Comment
--------+------+-------+-------+---------
 public | t1   | table | SuzyQ |
(1 row)

6.20 - 文本搜索参数

您可以对 Vertica 进行配置，以便使用以下值参数进行文本搜索：

TextIndexMaxTokenLength
控制文本索引中某个字符串的最大大小。

例如：

ALTER DATABASE database_name SET PARAMETER TextIndexMaxTokenLength=760;

如果将参数设置为一个大于 65000 个字符的值，分词器将在 65000 个字符的位置截断该字符串。

默认值： 128（字符）

6.21 - Tuple Mover 参数

这些参数控制着 Tuple Mover 的操作方式。

查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。
ActivePartitionCount
设置活动分区的数量。活动分区是最近创建的分区。例如： 
=> ALTER DATABASE DEFAULT SET ActivePartitionCount = 2;

有关 Tuple Mover 在合并操作期间如何对待主动和被动分区的信息，请参阅分区合并。

默认值： 1

CancelTMTimeout
当分区、复制表和重新平衡操作与内部 Tuple Mover 作业存在冲突时，这些操作会尝试取消冲突的 Tuple Mover 作业。此参数指定拦截操作等待 Tuple Mover 取消生效的时间量（以秒为单位）。如果操作无法在此参数指定的限制内取消 Tuple Mover 作业，则操作将显示错误并回退。

默认值： 300

EnableTMOnRecoveringNode
布尔值，指定 Tuple Mover 是否在节点状态为 RECOVERING 的节点上执行合并活动。启用 Tuple Mover 会减少恢复期间生成的 ROS 容器的数量。如果每个投影的 ROS 容器少于 1024 个，则可以使 Vertica 保持最佳恢复性能。

默认值： 1（启用）

MaxMrgOutROSSizeMB
指定作为合并操作的候选的 ROS 容器的最大大小（以 MB 为单位）。Tuple Mover 避免合并大于此设置的 ROS 容器。

默认值： -1（没有最大限制）

MergeOutInterval
指定 Tuple Mover 检查合并请求队列是否有待处理请求的频率（以秒为单位）：

  1. 如果队列包含合并请求，则 Tuple Mover 不执行任何操作并重新进入睡眠状态。

  2. 如果队列为空，Tuple Mover：

    • 处理待处理的存储位置移动请求。

    • 检查新的未排队清除请求并将它们添加到队列中。

    然后它重新进入睡眠状态。

默认值： 600

PurgeMergeoutPercent
指定调用自动合并操作以清除这些记录的 ROS 容器中的已删除记录阈值 (%)。Vertica 仅计算“过期”删除向量的数量，即删除“旧”或早于 Ancient History Mark (AHM) 时期的向量。

此阈值适用于非分区表的所有 ROS 容器。它也适用于所有非活动分区的 ROS 容器。在这两种情况下，过期的删除向量都会从 ROS 容器中永久清除。

默认值： 20 (%)

7 - 文件系统和对象存储

除了 Linux 文件系统之外，Vertica 还支持访问多个文件系统和对象存储。此部分中的参考页面提供有关 URI 语法、配置参数和身份验证的信息。

Vertica 通过以下两种方式之一访问此部分中的文件系统：

  • 如果存在用户提供的凭据，Vertica 将使用其访问存储。请注意，在 HDFS 上，始终存在用户凭据，因为 Vertica 使用 Vertica 用户身份访问 HDFS。

  • 如果用户提供的凭据不存在，或者设置了 UseServerIdentityOverUserIdentity 配置参数，Vertica 会检查配置的 USER 存储位置。通过 USER 存储位置管理访问时，Vertica 使用服务器凭据访问文件系统。有关 USER 存储位置的更多信息，请参阅 CREATE LOCATION。

并非在所有上下文中都支持所有文件系统。请参阅特定功能的文档，了解这些功能支持的文件系统。

7.1 - Azure Blob 存储对象存储

Azure 有数个用于访问数据的界面。Vertica 在 Azure 存储中读取并始终写入块 Blob。Vertica 可以读取使用 ADLS Gen2 创建的外部数据，而 Vertica 导出的数据可以使用 ADLS Gen2 读取。

URI 格式

以下几项之一：

  • azb://account/container/path
  • azb://[account@]host[:port]/container/path

在第一个版本中，类似“azb://myaccount/mycontainer/path”的 URI 将“//”后面的第一个令牌视为帐户名。在第二个版本中，您可以指定帐户，并且必须显式指定主机。

以下规则适用于第二种形式：

  • 如果未指定 account，则使用主机的第一个标签。例如，如果 URI 是“azb://myaccount.blob.core.windows.net/mycontainer/my/object”，则“myaccount”用于 account。
  • 如果未指定 account 且 host 有一个标签并且没有端口，则端点是 host.blob.core.windows.net。否则，端点是 URI 中指定的主机和端口。

协议（HTTP 或 HTTPS）在 AzureStorageEndpointConfig 配置参数中指定。

身份验证

如果您使用的是 Azure 托管身份，则无需在 Vertica 中进一步配置。如果 Azure 存储使用多个托管身份，则必须标记要使用的身份。Vertica 查找键为 VerticaManagedIdentityClientId 的 Azure 标记，其值必须是要使用的托管身份的 client_id 属性。如果更新 Azure 标记，请调用 AZURE_TOKEN_CACHE_CLEAR。

如果不使用托管身份，请使用 AzureStorageCredentials 配置参数向 Azure 提供凭据。如果加载数据，您可以在会话级别设置参数。如果在 Azure 上使用 Eon 模式公共存储，则必须在数据库级别设置此配置参数。

在 Azure 中，您还必须为 Vertica 中使用的身份授予对容器的访问权限。

配置参数

以下数据库配置参数适用于 Azure blob 文件系统。您可以使用适当的 ALTER 语句设置不同级别的参数，例如 ALTER SESSION...SET PARAMETER。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。

AzureStorageCredentials
JSON 对象的集合，其中每个对象指定一个端点的连接凭据。此参数优先于 Azure 托管标识。

该集合必须至少包含一个对象，并且可能会包含多个对象。每个对象必须至少指定 accountName 或 blobEndpoint 之一，并且至少指定 accountKey 或 sharedAccessSignature 之一。

  • accountName：如果未指定，则使用 blobEndpoint 标签。
  • blobEndpoint：带有可选端口的主机名 (host:port)。如果未指定，则使用 account.blob.core.windows.net。
  • accountKey：帐户或端点的访问密钥。
  • sharedAccessSignature：用于更精细访问控制的访问令牌（如果 Azure 端点正在使用）。
AzureStorageEndpointConfig
JSON 对象的集合，其中每个对象指定一个端点的配置元素。每个对象必须至少指定 accountName 或 blobEndpoint 之一。
  • accountName：如果未指定，则使用 blobEndpoint 标签。
  • blobEndpoint：带有可选端口的主机名 (host:port)。如果未指定，则使用 account.blob.core.windows.net。
  • protocol：HTTPS（默认）或 HTTP。
  • isMultiAccountEndpoint：如果端点支持多个帐户，则为 true，否则为 false（默认为 false）。要使用多帐户访问权限，则必须在 URI 中包含帐户名称。如果 URI 路径包含帐户，则系统将假定此值为 true，但显式设置为 false 则除外。

示例

以下示例将这些值用于配置参数。AzureStorageCredentials 包含敏感信息，且此示例中在会话级别设置。

=> ALTER SESSION SET AzureStorageCredentials =
    '[{"accountName": "myaccount", "accountKey": "REAL_KEY"},
      {"accountName": "myaccount", "blobEndpoint": "localhost:8080", "accountKey": "TEST_KEY"}]';

=> ALTER DATABASE default SET AzureStorageEndpointConfig =
    '[{"accountName": "myaccount", "blobEndpoint": "localhost:8080", "protocol": "http"}]';

以下示例使用 Azure 中的数据创建一个外部表。URI 指定帐户名称“myaccount”。

=> CREATE EXTERNAL TABLE users (id INT, name VARCHAR(20))
    AS COPY FROM 'azb://myaccount/mycontainer/my/object/*';

Vertica 使用 AzureStorageEndpointConfig 和帐户名称为文件生成以下位置：

https://myaccount.blob.core.windows.net/mycontainer/my/object/*

使用 REAL_KEY 凭据访问数据。

如果 COPY 语句中的 URI 改为 azb://myaccount.blob.core.windows.net/mycontainer/my/object，则结果位置为 https://myaccount.blob.core.windows.net/mycontainer/my/object，同样使用 REAL_KEY 凭据。

但是，如果 COPY 语句中的 URI 是 azb://myaccount@localhost:8080/mycontainer/my/object，则主机和端口指定不同的端点：http://localhost:8080/myaccount/mycontainer/my/object。此端点配置为使用不同的凭据 TEST_KEY。

7.2 - Google Cloud Storage (GCS) 对象存储

使用 Google Cloud Storage 平台的文件系统。

URI 格式

gs://bucket/path

身份验证

要访问 Google Cloud Storage (GCS) 中的数据，您必须首先执行以下任务：

  • 如 GCS 文档中所述，创建一个默认项目，获取开发人员密钥并启用 S3 互操作模式。

  • 设置 GCSAuth 配置参数，如下例所示。

    => ALTER SESSION SET GCSAuth='id:secret';

配置参数

以下数据库配置参数适用于 GCS 文件系统。您可以使用适当的 ALTER 语句设置不同级别的参数，例如 ALTER SESSION...SET PARAMETER。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。 有关与 GCS 相关的所有参数的信息，请参阅Google Cloud Storage 参数。

GCSAuth
用于向 GCS 进行身份验证的 ID 和密钥。为了获得更高的安全性，请不要将凭据存储在数据库中；而是应当使用 ALTER SESSION...SET PARAMETER 仅为当前会话设置此值。
GCSEnableHttps
布尔值，连接 GCS 时是否使用 HTTPS 协议，只能在数据库级别用 ALTER DATABASE...SET PARAMETER 设置。

默认值： 1（启用）

GCSEndpoint
连接端点地址。

默认值： storage.googleapis.com

示例

以下示例从 GCS 加载数据：

=> ALTER SESSION SET GCSAuth='my_id:my_secret_key';

=> COPY t FROM 'gs://DataLake/clicks.parquet' PARQUET;

7.3 - HDFS 文件系统

HDFS 是 Hadoop 分布式文件系统。您可以使用 webhdfs 和 swebhdfs 架构通过 WebHDFS 服务访问数据。Vertica 还支持 hdfs 架构，默认情况下使用 WebHDFS。要让 hdfs URI 使用已弃用的 LibHDFS++ 包，请将 HDFSUseWebHDFS 配置参数设置为 0（禁用）。

如果您指定 webhdfs URI，但 Hadoop HTTP 策略 (dfs.http.policy) 设置为 HTTPS_ONLY，Vertica 会自动使用 swebhdfs。

如果您使用 LibHDFS++，则 WebHDFS 服务必须仍然可用，因为 Vertica 回退到 WebHDFS 以执行不受 LibHDFS++ 支持的操作。

URI 格式

webhdfs、swebhdfs 和 hdfs 架构中的 URI 都有两种格式，具体取决于您是指定名称服务，还是指定主机和名称节点的端口：

  • [[s]web]hdfs://[nameservice]/path
  • [[s]web]hdfs://namenode-host:port/path

字符可以进行 URL 编码（%NN，其中 NN 是两位十六进制数），但不是必须的，除非必须对“%”字符进行编码。

要使用 HDFS 配置文件中指定的默认名称服务，请省略 nameservice。此速记仅用于读取外部数据，而不用于创建存储位置。

将 Vertica 与多个 HDFS 群集一起使用时，始终显式指定名称服务或主机。名称服务或主机名必须全局唯一。使用 [web]hdfs:/// 可能会产生意外结果，因为 Vertica 使用它找到的第一个 fs.defaultFS 值。

身份验证

Vertica 可以对 Cloudera 或 Hortonworks HDFS 群集使用 Kerberos 身份验证。请参阅访问已进行 Kerberize 的 HDFS 数据。

对于加载和导出数据，Vertica 可以通过 swebhdfs 架构访问受 mTLS 保护的 HDFS 群集。您必须创建证书和密钥并设置 WebhdfsClientCertConf 配置参数。

如果指定 TEMPORARY 关键字，则可以使用 CREATE KEY 和 CREATE CERTIFICATE 创建临时的会话范围值。临时密钥和证书存储在内存中，而不是磁盘上。

WebhdfsClientCertConf 配置参数保存一个或多个 HDFS 群集的客户端凭据。该值是一个 JSON 字符串，列出名称服务或权限及其对应的键。您可以在会话或数据库级别配置参数。在数据库级别设置参数有以下额外要求：

以下示例显示了 mTLS 的用法。密钥和证书值本身不会显示，只显示开始标记和结束标记：

=> CREATE TEMPORARY KEY client_key TYPE 'RSA'
   AS '-----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----';

-> CREATE TEMPORARY CERTIFICATE client_cert
   AS '-----BEGIN CERTIFICATE-----...-----END CERTIFICATE-----' key client_key;

=> ALTER SESSION SET WebhdfsClientCertConf =
   '[{"authority": "my.hdfs.namenode1:50088", "certName": "client_cert"}]';

=> COPY people FROM 'swebhdfs://my.hdfs.namenode1:50088/path/to/file/1.txt';
Rows Loaded
-------------
1
(1 row)

要配置对多个 HDFS 群集的访问，请定义密钥和证书，然后在 WebhdfsClientCertConf 的值中为每个群集包括一个对象：

=> ALTER SESSION SET WebhdfsClientCertConf =
    '[{"authority" : "my.authority.com:50070", "certName" : "myCert"},
      {"nameservice" : "prod", "certName" : "prodCert"}]';

配置参数

以下数据库配置参数适用于 HDFS 文件系统。您可以使用适当的 ALTER 语句设置不同级别的参数，例如 ALTER SESSION...SET PARAMETER。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。 有关 Hadoop 相关的所有参数的信息，请参阅 Hadoop 参数。

EnableHDFSBlockInfoCache
布尔值，是否将规划启动程序时收集的块位置元数据分发到所有数据库节点以便执行，减少名称节点争用现象。默认为已禁用。
HadoopConfDir
包含从 Hadoop 复制的 XML 配置文件的目录路径。相同的路径必须在每个 Vertica 节点上都有效。文件将由运行 Vertica 服务器进程的 Linux 用户进行访问。
HadoopImpersonationConfig
会话参数，用于指定 HDFS 访问的委派令牌或 Hadoop 用户。请参阅 HadoopImpersonationConfig 格式了解有关此参数值的信息，请参阅代理用户和委托令牌了解有关更一般的上下文。
HDFSUseWebHDFS
Boolean。如果为 true（默认值），则 hdfs 架构中的 URI 将被视为在 webhdfs 架构中。如果为 false，Vertica 会尽可能使用 LibHDFS++，但如果 LibHDFS++ 不支持，某些操作仍可使用 WebHDFS。
WebhdfsClientCertConf
一个 JSON 字符串，用于访问一个或多个 WebHDFS 服务器的 mTLS 配置。每个对象必须指定一个 nameservice 或 authority 字段和一个 certName 字段。请参阅身份验证。

配置文件

HadoopConfDir 中指定的路径必须包含下表中所列文件的目录。Vertica 将在数据库启动时读取这些文件。如果您未设置值，Vertica 会在 /etc/hadoop/conf 中查找文件。

如果未定义属性，Vertica 将使用表中显示的默认值。如果没有指定属性的默认值，则配置文件必须指定一个值。

如果使用高可用性 (HA) 名称节点，则还必须在 hdfs-site.xml 中定义单个名称节点。

要验证 Vertica 能否在 HadoopConfDir 中找到配置文件，请使用 VERIFY_HADOOP_CONF_DIR 函数。

要通过 hdfs 架构测试访问，请使用 HDFS_CLUSTER_CONFIG_CHECK 函数。

有关测试配置的详细信息，请参阅验证 HDFS 配置。

要重新读取配置文件，请使用 CLEAR_HDFS_CACHES 函数。

名称节点和名称服务

您可以使用默认名称节点（不指定名称节点或名称服务）访问 HDFS 数据：

=> COPY users FROM 'webhdfs:///data/users.csv';

Vertica 使用 fs.defaultFS Hadoop 配置参数来查找名称节点。（然后，它使用该名称节点来查找数据。）您可以改为使用以下格式显式指定主机和端口：

webhdfs://nn-host:nn-port/

指定的主机是名称节点，而不是单个数据节点。如果您使用的是高可用性 (HA) 名称节点，则不应使用显式主机，因为高可用性是通过名称服务提供的。

如果 HDFS 群集使用高可用性名称节点或定义名称服务，请使用名称服务而不是主机和端口，格式为 webhdfs://nameservice/。您指定的名称服务必须在 hdfs-site.xml 中定义。

以下示例显示了如何使用名称服务 hadoopNS：

=> CREATE EXTERNAL TABLE users (id INT, name VARCHAR(20))
    AS COPY FROM 'webhdfs://hadoopNS/data/users.csv';

如果您使用 Vertica 从多个 HDFS 群集访问数据，请始终在 URL 中使用显式名称服务或主机。使用 /// 速记可能会产生意外结果，因为 Vertica 使用它找到的 fs.defaultFS 的第一个值。要访问多个 HDFS 群集，您必须使用全局唯一的主机名和服务名。有关详细信息，请参阅配置 HDFS 访问。

7.4 - S3 对象存储

使用 S3 协议的文件系统，包括 AWS、Pure Storage 和 MinIO。

URI 格式

s3://bucket/path

对于 AWS，使用 AWSRegion 配置参数而不是 URI 指定区域。如果区域不正确，可能会在加载失败之前遇到延迟，因为 Vertica 在放弃之前会进行多次重试。默认区域为 us-east-1。

身份验证

对于 AWS：

  • 要访问 S3，您必须创建一个 IAM 角色并向该角色授予访问 S3 资源的权限。

  • 默认情况下，存储桶访问仅限于公共存储桶。使用 AWS 访问密钥从非公共存储桶加载数据。

  • 设置 AWSAuth 配置参数以提供凭据或为 S3 路径创建 USER 存储位置（请参阅 CREATE LOCATION）并授予用户访问权限。

  • 您可以使用 AWS STS 临时会话令牌来加载数据。因为这些令牌是会话令牌，所以不要将其用于访问存储位置。

  • 您可以使用每个存储桶的参数 S3BucketConfig 和 S3BucketCredentials 单独配置 S3 存储桶。有关详细信息，请参阅每个存储桶 S3 配置。

配置参数

以下数据库配置参数适用于 S3 文件系统。您可以使用适当的 ALTER 语句设置不同级别的参数，例如 ALTER SESSION...SET PARAMETER。 查询 CONFIGURATION_PARAMETERS 系统表以确定哪些级别（节点、会话、用户、数据库）对给定参数有效。

您可以使用 S3BucketConfig 和 S3BucketCredentials 参数而不是全局参数来配置单个存储桶。

有关与 S3 相关的所有参数的详细信息，请参阅S3 参数。

AWSAuth
用于身份验证的 ID 和密钥。AWS 调用这些 AccessKeyID 和 SecretAccessKey。为了获得更高的安全性，请不要将凭据存储在数据库中；应当使用 ALTER SESSION...SET PARAMETER 仅为当前会话设置此值。
AWSCAFile
要使用的 TLS 服务器证书捆绑包的文件名。在 SUSE Linux Enterprise Server 上安装 CA 证书时必须设置一个值。
AWSCAPath
Vertica 用于查找 TLS 服务器证书的路径。在 SUSE Linux Enterprise Server 上安装 CA 证书时必须设置一个值。
AWSEnableHttps
布尔值，连接 S3 时是否使用 HTTPS 协议。只能在数据库级别设置。您可以使用 S3BucketConfig 为各个存储桶设置协议。

默认值： 1（启用）

AWSEndpoint
字符串，所有 S3 URL 的端点主机，设置如下：

  • AWS：hostname_or_IP:port。不要包括架构 (http(s))。

  • 具有符合 FIPS 规范的 S3 端点的 AWS：符合 FIPS 规范的 S3 端点的主机名。您还必须启用 S3EnableVirtualAddressing。

  • 本地/Pure：Pure Storage 服务器的 IP 地址。

如果未设置，Vertica 将使用虚拟托管的请求 URL。

默认值： “s3.amazonaws.com”

AWSLogLevel
日志级别，为以下之一：OFF、FATAL、ERROR、WARN、INFO、DEBUG 或 TRACE。

默认值： ERROR

AWSRegion
包含要从中读取文件的 S3 存储桶的 AWS 区域。此参数一次只能配置一个区域。未能设置正确的区域可能会导致在查询失败之前遇到延迟。

默认值： “us-east-1”

AWSSessionToken
通过运行 get-session-token 命令生成的临时安全令牌，用于配置多重身份验证。
AWSStreamingConnectionPercentage
在 Eon 模式下，用于流式读取的公共存储连接数。在云环境中，此设置有助于防止流式数据传输耗尽所有可用的文件句柄。使用本地对象存储时不需要此设置，因为其延迟较低。
S3BucketConfig
指定每个存储桶配置的 JSON 对象。除了存储桶名称之外的每个属性都有一个相应的配置参数。如果同时设置了数据库级别参数及其在 S3BucketConfig 中的等效项，则 S3BucketConfig 中的值优先。

属性：

  • bucket：存储桶名称

  • region (AWSRegion)

  • protocol：架构，http 或 https 之一；覆盖 AWSEnableHttps

  • endpoint (AWSEndpoint)

  • enableVirtualAddressing：布尔值，是否重写 S3 URL 以使用虚拟托管路径 (S3BucketCredentials)

  • requesterPays (S3RequesterPays)

  • serverSideEncryption (S3ServerSideEncryption)

  • sseCustomerAlgorithm (S3SseCustomerAlgorithm)

  • sseCustomerKey (S3SseCustomerKey)

  • sseKmsKeyId (S3SseKmsKeyId)

S3BucketCredentials
指定每个存储桶凭据的 JSON 对象。除了存储桶名称之外的每个属性都有一个相应的配置参数。如果同时设置了数据库级参数及其在 S3BucketCredentials 中的等效项，则 S3BucketCredentials 中的值优先。

属性：

  • bucket：存储桶名称

  • accessKey：存储桶的访问密钥（AWSAuth 中的 ID）

  • secretAccessKey：存储桶的私密访问密钥（AWSAuth 中的 secret）

  • sessionToken：会话令牌，仅在会话级别设置 S3BucketCredentials 时使用 (AWSSessionToken)

此参数仅对超级用户可见。用户可以使用 ALTER SESSION 在会话级别设置此参数。

S3EnableVirtualAddressing
布尔值，是否重写 S3 URL 以使用虚拟托管路径（默认禁用）。此配置设置仅在您为 AWSEndpoint 指定值时生效。

如果您将 AWSEndpoint 设置为符合 FIPS 规范的 S3 端点，则必须启用 S3EnableVirtualAddressing。

此参数的值不会影响指定 S3 路径的方式。

S3RequesterPays
布尔值，请求者（而不是存储桶所有者）是否支付访问存储桶上的数据的费用。
S3ServerSideEncryption
字符串，读取或写入 S3 时使用的加密算法。支持的值为 AES256（对于 SSE-S3）、aws:kms（对于 SSE-KMS）和空字符串（对于不加密）。请参阅服务器端加密。

默认值： ""（无加密）

S3SseCustomerAlgorithm
字符串，使用 SSE-C 加密读取或写入 S3 时使用的加密算法。支持的值仅包括 AES256 和 ""。对于 SSE-S3 和 SSE-KMS，请改用 S3ServerSideEncryption。

默认值： ""（无加密）

S3SseCustomerKey
如果使用 SSE-C 加密，则为 S3 访问的客户端密钥。
S3SseKmsKeyId
如果使用 SSE-KMS 加密，则将密钥标识符（不是密钥）传递给密钥管理服务。Vertica 必须有权使用通过 KMS 管理的密钥。

服务器端加密

默认情况下，Vertica 读取和写入未加密的 S3 数据。如果 S3 存储桶使用服务器端加密 (SSE)，您可以配置 Vertica 来对其进行访问。S3 支持三种类型的服务器端加密：SSE-S3、SSE-KMS 和 SSE-C。

Vertica 还必须对存储桶具有读取或写入权限（取决于操作）。

SSE-S3

对于 SSE-S3，由 S3 服务管理加密密钥。读取不需要额外的配置。要写入 S3，客户端（在本例中为 Vertica）必须只指定加密算法。

如果 S3 存储桶配置了默认加密设置，Vertica 无需进一步更改即可对其读取和写入数据。如果存储桶不使用默认加密设置，请将 S3ServerSideEncryption 配置参数或 S3BucketConfig 中的 serverSideEncryption 字段设置为 AES256。

SSE-KMS

对于 SSE-KMS，加密密钥由密钥管理服务 (KMS) 管理。客户端在写入数据时必须提供 KMS 密钥标识符（不是实际密钥）。对于所有操作，客户端必须有权使用 KMS 密钥。这些权限在 KMS 中进行管理，而不是在 Vertica 中。

要使用 SSE-KMS：

  • 将 S3ServerSideEncryption 配置参数或 S3BucketConfig 中的 serverSideEncryption 字段设置为 aws:kms。

  • 将 S3SseKmsKeyId 配置参数或 S3BucketConfig 中的 sseKmsKeyId 字段设置为密钥 ID。

SSE-C

对于 SSE-C，由客户端管理加密密钥并将其提供给 S3 以进行每个操作。

要使用 SSE-C：

  • 将 S3SseCustomerAlgorithm 配置参数或 S3BucketConfig 中的 sseCustomerAlgorithm 字段设置为 AES256。

  • 将 S3SseCustomerKey 配置参数或 S3BucketConfig 中的 sseCustomerKey 字段设置为访问密钥。该值可以是 32 个字符的纯文本密钥或 44 个字符的 base64 编码密钥。

示例

以下示例设置数据库范围的 AWS 区域和凭据：

=> ALTER DATABASE DEFAULT SET AWSRegion='us-west-1';
=> ALTER DATABASE DEFAULT SET AWSAuth = 'myaccesskeyid123456:mysecretaccesskey123456789012345678901234';

以下示例从 S3 加载数据。如果可以同时加载 glob 中的所有文件，则可以使用 glob。在以下示例中，AWS_DataLake 仅包含 ORC 文件。

=> COPY t FROM 's3://datalake/*' ORC;

您可以指定逗号分隔的 S3 存储桶列表，如下例所示。所有存储桶必须位于同一区域。要从多个区域加载，请使用单独的 COPY 语句并在调用之间更改 AWSRegion 的值。

=> COPY t FROM 's3://AWS_Data_1/sales.parquet', 's3://AWS_Data_2/sales.parquet' PARQUET;

以下示例创建用户存储位置和角色，以便没有自己的 S3 凭据的用户可以使用服务器凭据从 S3 中读取数据。

   --- set database-level credential (once):
=> ALTER DATABASE DEFAULT SET AWSAuth = 'myaccesskeyid123456:mysecretaccesskey123456789012345678901234';

=> CREATE LOCATION 's3://datalake' SHARED USAGE 'USER' LABEL 's3user';

=> CREATE ROLE ExtUsers;
   --- Assign users to this role using GRANT (Role).

=> GRANT READ ON LOCATION 's3://datalake' TO ExtUsers;

给定存储桶的配置属性可能因其类型而异。以下 S3BucketConfig 设置适用于 AWS 存储桶 (AWSBucket) 和 Pure Storage 存储桶 (PureStorageBucket)。 AWSBucket 没有指定端点，因此 Vertica 使用 AWSEndpoint 配置参数，其默认为 s3.amazonaws.com：

=> ALTER DATABASE DEFAULT SET S3BucketConfig=
'[
    {
        "bucket": "AWSBucket",
        "region": "us-east-2",
        "protocol": "https",
        "requesterPays": true,
        "serverSideEncryption": "aes256"
    },
    {
        "bucket": "PureStorageBucket",
        "endpoint": "pure.mycorp.net:1234",
        "protocol": "http",
        "enableVirtualAddressing": false
    }
]';

以下示例为这两个存储桶设置 S3BucketCredentials：

=> ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "AWSBucket",
        "accessKey": "<AK0>",
        "secretAccessKey": "<SAK0>",
        "sessionToken": "1234567890"
    },
    {
        "bucket": "PureStorageBucket",
        "accessKey": "<AK1>",
        "secretAccessKey": "<SAK1>"
    }
]';

以下示例设置 STS 临时会话令牌。Vertica 使用会话令牌通过指定凭据访问 S3，并绕过对 USER 存储位置的检查。

$ aws sts get-session-token
  {
    "Credentials": {
        "AccessKeyId": "ASIAJZQNDVS727EHDHOQ",
        "SecretAccessKey": "F+xnpkHbst6UPorlLGj/ilJhO5J2n3Yo7Mp4vYvd",
        "SessionToken": "FQoDYXdzEKv//////////wEaDMWKxakEkCyuDH0UjyKsAe6/3REgW5VbWtpuYyVvSnEK1jzGPHi/jPOPNT7Kd+ftSnD3qdaQ7j28SUW9YYbD50lcXikz/HPlusPuX9sAJJb7w5oiwdg+ZasIS/+ejFgCzLeNE3kDAzLxKKsunvwuo7EhTTyqmlLkLtIWu9zFykzrR+3Tl76X7EUMOaoL31HOYsVEL5d9I9KInF0gE12ZB1yN16MsQVxpSCavOFHQsj/05zbxOQ4o0erY1gU=",
        "Expiration": "2018-07-18T05:56:33Z"
    }
  }

$ vsql
=> ALTER SESSION SET AWSAuth = 'ASIAJZQNDVS727EHDHOQ:F+xnpkHbst6UPorlLGj/ilJhO5J2n3Yo7Mp4vYvd';
=> ALTER SESSION SET AWSSessionToken = 'FQoDYXdzEKv//////////wEaDMWKxakEkCyuDH0UjyKsAe6/3REgW5VbWtpuYyVvSnEK1jzGPHi/jPOPNT7Kd+ftSnD3qdaQ7j28SUW9YYbD50lcXikz/HPlusPuX9sAJJb7w5oiwdg+ZasIS/+ejFgCzLeNE3kDAzLxKKsunvwuo7EhTTyqmlLkLtIWu9zFykzrR+3Tl76X7EUMOaoL31HOYsVEL5d9I9KInF0gE12ZB1yN16MsQVxpSCavOFHQsj/05zbxOQ4o0erY1gU=';

另请参阅

每个存储桶 S3 配置

7.4.1 - 每个存储桶 S3 配置

您可以使用 S3BucketConfig 和 S3BucketCredentials 配置参数管理各个存储桶的配置和凭据。这些参数均采用 JSON 对象，其各自属性的行为类似于相关的 S3 配置参数。

例如，您可以通过在数据库级别使用 ALTER DATABASE 设置 S3BucketConfig 来为每个 S3 存储桶创建不同的配置。以下 S3BucketConfig 指定了几个常见的存储桶属性：

=> ALTER DATABASE DEFAULT SET S3BucketConfig='
[
    {
        "bucket": "exampleAWS",
        "region": "us-east-2",
        "protocol": "https",
        "requesterPays": true
    },
    {
        "bucket": "examplePureStorage",
        "endpoint": "pure.mycorp.net:1234",
        "protocol": "http",
        "enableVirtualAddressing": false
    }
]';

然后，用户可以通过在会话级别使用 ALTER SESSION 设置 S3BucketCredentials 来访问存储桶。以下 S3BucketCredentials 指定所有属性并同时对 exampleAWS 和 examplePureStorage 进行身份验证：

=> ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "exampleAWS",
        "accessKey": "<AK0>",
        "secretAccessKey": "<SAK0>",
        "sessionToken": "1234567890"
    },
    {
        "bucket": "examplePureStorage",
        "accessKey": "<AK1>",
        "secretAccessKey": "<SAK1>",
    }
]';

推荐用法

推荐用法如下：

  • 在您的 S3 存储系统中为每个主体、每个存储系统定义一组凭据。

  • 通常最方便的做法是在数据库级别设置一次 S3BucketConfig，并通过在会话级别设置 S3BucketCredentials 来对用户进行身份验证。

  • 要访问在数据库级别配置的存储桶之外的存储桶，请在会话级别设置 S3BucketConfig 和 S3BucketCredentials。

如果您无法为 S3 存储定义凭据，您可以使用 ALTER DATABASE 在数据库级别设置 S3BucketCredentials 或 AWSAuth，但这有一些缺点：

  • 将凭据静态存储在另一个位置（在这种情况下，在 Vertica 编录中）总是会带来其他风险。

  • 这增加了 dbadmin 的开销，他们需要创建用户存储位置并向每个用户或角色授予访问权限。

  • 用户共享一组凭据，如果凭据泄露，则会增加潜在影响。

每个存储桶和标准参数的优先级

Vertica 使用以下规则来确定 S3 连接的有效属性集：

  • 如果设置，则 S3BucketCredentials 将优先于其标准参数。S3BucketCredentials 首先在会话级别检查，然后在数据库级别检查。

  • S3 凭据参数的级别/来源决定了 S3 配置参数的来源：

    • 如果凭据来自会话级别，则配置可以来自会话级别或数据库级别（会话级别优先）。

    • 如果您的凭据来自数据库级别，那么配置只能来自数据库级别。

  • 如果设置了 S3BucketConfig，它将优先于其标准参数。如果未指定 S3BucketConfig 属性，则 Vertica 将回退到缺失属性的等效参数。例如，如果 S3BucketConfig 指定除 protocol 之外的所有属性，则 Vertica 将回退到标准参数 AWSEnableHttps。

示例

多个存储桶

此示例使用 S3BucketConfig 配置一个实际的 Amazon S3 存储桶 AWSBucket 和一个 Pure Storage 存储桶 PureStorageBucket。

AWSBucket 没有指定 endpoint 或协议，因此 Vertica 回退到 AWSEndpoint（默认为 s3.amazonaws.com）和 AWSEnableHttps（默认为 1）。

在此示例环境中，对 PureStorageBucket 的访问是通过安全网络进行的，因此 HTTPS 被禁用：

=> ALTER DATABASE DEFAULT SET S3BucketConfig='
[
    {
        "bucket": "AWSBucket",
        "region": "us-east-2"
    },
    {
        "bucket": "PureStorageBucket",
        "endpoint": "pure.mycorp.net:1234",
        "protocol": "http",
        "enableVirtualAddressing": false
    }
]';

然后 Bob 可以在会话级别设置 S3BucketCredentials 以向 AWSBucket 进行身份验证：

=> ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "AWSBucket",
        "accessKey": "<AK0>",
        "secretAccessKey": "<SAK0>",
        "sessionToken": "1234567890"
    }
]';

同样，Alice 可以向 PureStorageBucket 进行身份验证：

=> ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "PureStorageBucket",
        "accessKey": "<AK1>",
        "secretAccessKey": "<SAK1>"
    }
]';

Charlie 提供 AWSBucket 和 PureStorageBucket 的凭据，并同时对其进行身份验证。这允许他执行跨端点联接、从一个存储桶导出到另一个存储桶等。

=> ALTER SESSION SET S3BucketCredentials='
[
    {
        "bucket": "AWSBucket",
        "accessKey": "<AK0>",
        "secretAccessKey": "<SAK0>",
        "sessionToken": "1234567890"
    },
    {
        "bucket": "PureStorageBucket",
        "accessKey": "<AK1>",
        "secretAccessKey": "<SAK1>"
    }
]';

S3 服务器端加密

S3 具有三种类型的服务器端加密：SSE-S3、SSE-KMS 和 SSE-C。以下示例使用 SSE-KMS 配置访问：

=> ALTER DATABASE DEFAULT SET S3BucketConfig='
[
    {
        "bucket": "AWSBucket",
        "region": "us-east-2",
        "serverSideEncryption": "aws:kms",
        "sseKmsKeyId": "1234abcd-12ab-34cd-56ef-1234567890ab"
    }
]';

有关详细信息，请参阅服务器端加密。

具有 AWSEndpoint 和 S3BucketConfig 的非 Amazon S3 存储

如果 AWSEndpoint 设置为 Pure Storage 或 MinIO 之类的非 Amazon S3 存储桶，并且您想要为实际的 Amazon S3 存储桶配置 S3BucketConfig，则适用以下要求：

  • 如果您实际的 Amazon S3 区域不是 us-east-1（默认值），则必须指定 region。

  • 将 endpoint 设置为空字符串 ("")。

在此示例中，AWSEndpoint 设置为 Pure Storage 存储桶。

=> ALTER DATABASE DEFAULT SET AWSEndpoint='pure.mycorp.net:1234';

要为区域“us-east-2”中的实际 Amazon S3 存储桶 realAmazonS3Bucket 配置 S3BucketConfig：

=> ALTER DATABASE DEFAULT SET S3BucketConfig='
[
    {
        "bucket": "realAmazonS3Bucket",
        "region": "us-east-2",
        "endpoint": ""
    },
]';

8 - Vertica 系统表

Vertica 提供的系统表可以用于监控数据库并评估其对象的设置。您可以像查询其他表一样查询这些表，具体取决于权限要求。

另请参阅

8.1 - V_CATALOG 架构

本部分中的系统表位于 v_catalog 架构中。这些表提供数据库中的对象的相关信息（元数据）；比如表、约束、用户、投影等。

8.1.1 - ACCESS_POLICY

提供有关现有访问策略的信息。

特权

默认情况下，只有超级用户可以查看此表。超级用户可以使用以下语句授予非超级用户对此表的访问权限。非超级用户只能看到其所拥有的表中的行：

=> GRANT SELECT ON access_policy TO PUBLIC

示例

以下查询返回了表 public.customer_dimension 中的所有访问策略：

=> \x
=> SELECT policy_type, is_policy_enabled, table_name, column_name, expression FROM access_policy WHERE table_name = 'public.customer_dimension';
-[ RECORD 1 ]-----+----------------------------------------------------------------------------------------
policy_type       | Column Policy
is_policy_enabled | Enabled
table_name        | public.customer_dimension
column_name       | customer_address
expression        | CASE WHEN enabled_role('administrator') THEN customer_address ELSE '**************' END

8.1.2 - ALL_TABLES

提供有关 Vertica 数据库中表的摘要信息。

示例

onenode=> SELECT DISTINCT table_name, table_type FROM all_tables
          WHERE table_name ILIKE 't%';
       table_name       |  table_type
------------------------+--------------
 types                  | SYSTEM TABLE
 trades                 | TABLE
 tuple_mover_operations | SYSTEM TABLE
 tables                 | SYSTEM TABLE
 tuning_recommendations | SYSTEM TABLE
 testid                 | TABLE
 table_constraints      | SYSTEM TABLE
 transactions           | SYSTEM TABLE
(8 rows)
onenode=> SELECT table_name, table_type FROM all_tables
          WHERE table_name ILIKE 'my%';
 table_name | table_type
------------+------------
 mystocks   | VIEW
(1 row)
=> SELECT * FROM all_tables LIMIT 4;
-[ RECORD 1 ]-------------------------------------------
schema_name | v_catalog
table_id    | 10206
table_name  | all_tables
table_type  | SYSTEM TABLE
remarks     | A complete listing of all tables and views
-[ RECORD 2 ]-------------------------------------------
schema_name | v_catalog
table_id    | 10000
table_name  | columns
table_type  | SYSTEM TABLE
remarks     | Table column information
-[ RECORD 3 ]-------------------------------------------
schema_name | v_catalog
table_id    | 10054
table_name  | comments
table_type  | SYSTEM TABLE
remarks     | User comments on catalog objects
-[ RECORD 4 ]-------------------------------------------
schema_name | v_catalog
table_id    | 10134
table_name  | constraint_columns
table_type  | SYSTEM TABLE
remarks     | Table column constraint information

8.1.3 - AUDIT_MANAGING_USERS_PRIVILEGES

提供有关权限、创建、修改和删除用户以及身份验证更改的摘要信息。此表是 LOG_PARAMS、LOG_QUERIES 和 LOG_TABLES 的联接，已根据 Managing_Users_Privileges 类别进行了筛选。

8.1.4 - CA_BUNDLES

存储通过 创建 CA 捆绑包 创建的证书颁发机构 (CA) 捆绑包。

特权

  • 请参阅 CA 捆绑包 OID、名称和所有者：CA 捆绑包的超级用户或所有者。

  • 请参阅 CA 捆绑包内容：捆绑包的所有者

使用 CERTIFICATES 进行联接

CA_BUNDLES 仅存储 OID。由于对 CA 捆绑包的操作需要证书和所有者名称，因此可以使用以下查询将捆绑包映射到证书和所有者名称：

=> SELECT user_name AS owner_name,
       owner     AS owner_oid,
       b.name    AS bundle_name,
       c.name    AS cert_name
FROM   (SELECT name,
               STRING_TO_ARRAY(certificates) :: array[INT] AS certs
        FROM   ca_bundles) b
       LEFT JOIN certificates c
              ON CONTAINS(b.certs, c.oid)
       LEFT JOIN users
              ON user_id = owner
ORDER  BY 1;

 owner_name |     owner_oid     | bundle_name  | cert_name
------------+-------------------+--------------+-----------
 dbadmin    | 45035996273704962 | ca_bundle    | root_ca
 dbadmin    | 45035996273704962 | ca_bundle    | ca_cert
(2 rows)

另请参阅

8.1.5 - CATALOG_SUBSCRIPTION_CHANGES

列出对编录订阅所做的更改。

8.1.6 - CATALOG_SYNC_STATE

显示 Eon 模式数据库节点何时将其编录同步到公共存储。

8.1.7 - CATALOG_TRUNCATION_STATUS

指示编录在公共存储上的最新程度。如果当前编录版本与编录截断版本相同，则是最新的。

编录截断版本 (CTV) 是 Vertica 群集在崩溃、关闭或休眠后进行恢复时使用的版本。一个群集中的所有节点只有一个 CTV。

8.1.8 - CERTIFICATES

存储通过 CREATE CERTIFICATE 创建的证书。

示例

请参阅生成 TLS 证书和密钥。

8.1.9 - CLIENT_AUTH

提供有关客户端身份验证方法的信息。

值越高表示优先级越高。Vertica 使用优先级从高到低的身份验证方法尝试对用户进行身份验证。例如：

  • 优先级 10 比优先级 5 高。

  • 优先级 0 为最低的值。

示例

此示例显示如何获取您创建的每个客户端身份验证方法的相关信息：

=> SELECT * FROM client_auth;
    auth_oid   |  auth_name  | is_auth_enabled | auth_host_type | auth_host_address | auth_method | auth_parameters | auth_priority | method_priority | address_priority
-------------------+-------------+-----------------+----------------+-------------------+-------------+-----------------+---------------+-----------------+------------------
 45035996274059694 | v_gss       | True            | HOST           | 0.0.0.0/0         | GSS         |                 |             0 |               5 |               96
 45035996274059696 | v_trust     | True            | LOCAL          |                   | TRUST       |                 |             0 |               0 |                0
 45035996274059698 | v_ldap      | True            | HOST           | 10.19.133.123/    | LDAP        |                 |             0 |               5 |              128
 45035996274059700 | RejectNoSSL | True            | HOSTNOSSL      | 0.0.0.0/0         | REJECT      |                 |             0 |              10 |               96
 45035996274059702 | v_hash      | True            | LOCAL          |                   | HASH        |                 |             0 |               2 |                0
 45035996274059704 | v_tls       | True            | HOSTSSL        | 1.1.1.1/0         | TLS         |                 |             0 |               5 |               96
(6 rows)

另请参阅

8.1.10 - CLIENT_AUTH_PARAMS

提供分配了参数值的客户端身份验证方法的相关信息。

示例

以下示例将展示如何检索创建的所有身份验证方法的参数名称和值。具有参数的身份验证方法如下：

  • v_ident

  • v_ldap

  • v_ldap1

=> SELECT * FROM CLIENT_AUTH_PARAMS;
     auth_oid      |   auth_name   | auth_parameter_name |    auth_parameter_value
-------------------+---------------+---------------------+------------------------------
 45035996273741304 | v_ident       | system_users        | root
 45035996273741332 | v_gss         |                     |
 45035996273741350 | v_password    |                     |
 45035996273741368 | v_trust       |                     |
 45035996273741388 | v_ldap        | host                | ldap://172.16.65.177
 45035996273741388 | v_ldap        | binddn_prefix       | cn=
 45035996273741388 | v_ldap        | binddn_suffix       | ,dc=qa_domain,dc=com
 45035996273741406 | RejectNoSSL   |                     |
 45035996273741424 | RejectWithSSL |                     |
 45035996273741450 | v_md5         |                     |
 45035996273904044 | l_tls         |                     |
 45035996273906566 | v_hash        |                     |
 45035996273910432 | v_ldap1       | host                | ldap://172.16.65.177
 45035996273910432 | v_ldap1       | basedn              | dc=qa_domain,dc=com
 45035996273910432 | v_ldap1       | binddn              | cn=Manager,dc=qa_domain,dc=com
 45035996273910432 | v_ldap1       | bind_password       | secret
 45035996273910432 | v_ldap1       | search_attribute    | cn
(17 rows)

8.1.11 - CLUSTER_LAYOUT

显示参与群集的节点以及影响这些节点的容错组（在 Enterprise 模式数据库中）或子群集（在 Eon 模式数据库中）的实际排列的相对位置。暂时节点不会显示在群集布局环中，因为它们不保留任何常驻数据。

另请参阅

大型群集

8.1.12 - COLUMNS

提供表列信息。

示例

从 COLUMNS 表中检索表和列信息：

=> SELECT table_schema, table_name, column_name, data_type, is_nullable
   FROM columns WHERE table_schema = 'store'
   AND data_type = 'Date';
 table_schema |    table_name     |      column_name       | data_type | is_nullable
--------------+-------------------+------------------------+-----------+-------------
 store        | store_dimension   | first_open_date        | Date      | f
 store        | store_dimension   | last_remodel_date      | Date      | f
 store        | store_orders_fact | date_ordered           | Date      | f
 store        | store_orders_fact | date_shipped           | Date      | f
 store        | store_orders_fact | expected_delivery_date | Date      | f
 store        | store_orders_fact | date_delivered         | Date      | f
6 rows)

DATETIME_PRECISION 为 NULL，因为表定义未声明精度：

=> CREATE TABLE c (c TIMESTAMP);
CREATE TABLE
=> SELECT table_name, column_name, datetime_precision FROM columns
   WHERE table_name = 'c';
 table_name | column_name | datetime_precision
------------+-------------+--------------------
 c          | c           |
(1 row)

DATETIME_PRECISION 为 4，因为表定义将精度声明为 4：

=> DROP TABLE c;
=> CREATE TABLE c (c TIMESTAMP(4));
CREATE TABLE
=> SELECT table_name, column_name, datetime_precision FROM columns
   WHERE table_name = 'c';
 table_name | column_name | datetime_precision
------------+-------------+--------------------
 c          | c           |                  4

标识列是仅适用于数字列类型的序列。要标识表中的哪一列（如果有）是标识列，请搜索 COLUMNS 表，在表 testid 中查找标识列：

=> CREATE TABLE testid (c1 IDENTITY(1, 1, 1000), c2 INT);
=> \x
Expanded display is on.
=> SELECT * FROM COLUMNS WHERE is_identity='t' AND table_name='testid';
-[ RECORD 1 ]------------+--------------------
table_id                 | 45035996273719486
table_schema             | public
table_name               | testid
is_system_table          | f
column_id                | 45035996273719486-1
column_name              | c1
data_type                | int
data_type_id             | 6
data_type_length         | 8
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 1
is_nullable              | f
column_default           |
is_identity              | t

使用 SEQUENCES 表获得关于 testid 中序列的详细信息：

=> SELECT * FROM sequences WHERE identity_table_name='testid';
-[ RECORD 1 ]-------+--------------------
sequence_schema     | public
sequence_name       | testid_c1_seq
owner_name          | dbadmin
identity_table_name | testid
session_cache_count | 1000
allow_cycle         | f
output_ordered      | f
increment_by        | 1
minimum             | 1
maximum             | 9223372036854775807
current_value       | 0
sequence_schema_id  | 45035996273704976
sequence_id         | 45035996273719488
owner_id            | 45035996273704962
identity_table_id   | 45035996273719486

有关序列和标识列的更多信息，请参阅 序列。

8.1.13 - COMMENTS

返回关于与数据库中的对象相关联的注释的信息。

8.1.14 - COMPLEX_TYPES

包含有关内联复杂类型 (复杂类型) 的信息。

每个外部表中的每个复杂类型在内部都具有唯一的类型，即使这些类型在结构上是相同的（比如两个不同的 ROW(int,int)）。此内联类型在创建使用该类型的表时创建，并在删除表时自动删除。内联复杂类型不能在其他表中共享或重用。

COMPLEX_TYPES 表中的每一行代表一种复杂类型中的一个组件（字段）。一个 ROW 的每个字段生成一行，一个 ARRAY 生成一行，一个 MAP 生成两行。

原生 (ROS) 表中使用的基元类型数组不包含在 COMPLEX_TYPES 表中。其包含在 TYPES 表中。

示例

以下示例显示了定义单个外部表后的类型和字段值。

=> CREATE EXTERNAL TABLE warehouse(
    name VARCHAR, id_map MAP<INT,VARCHAR>,
    data row(record INT, total FLOAT, description VARCHAR(100)),
    prices ARRAY[INT], comment VARCHAR(200), sales_total FLOAT, storeID INT)
  AS COPY FROM ... PARQUET;

=> SELECT type_id,type_kind,type_name,field_id,field_name,field_type_name,field_position
    FROM COMPLEX_TYPES ORDER BY type_id,field_name;

      type_id      | type_kind |       type_name       | field_id | field_name  | field_type_name | field_position
-------------------+-----------+-----------------------+----------+-------------+-----------------+----------------
 45035996274278280 | Map       | _ct_45035996274278280 |        6 | key         | int             |              0
 45035996274278280 | Map       | _ct_45035996274278280 |        9 | value       | varchar(80)     |              1
 45035996274278282 | Row       | _ct_45035996274278282 |        9 | description | varchar(80)     |              2
 45035996274278282 | Row       | _ct_45035996274278282 |        6 | record      | int             |              0
 45035996274278282 | Row       | _ct_45035996274278282 |        7 | total       | float           |              1
 45035996274278284 | Array     | _ct_45035996274278284 |        6 |             | int             |              0
(6 rows)

8.1.15 - CONSTRAINT_COLUMNS

记录有关表列约束的信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.1.16 - CRYPTOGRAPHIC_KEYS

存储通过 CREATE KEY 创建的私钥。

示例

请参阅生成 TLS 证书和密钥。

8.1.17 - DATABASES

提供有关该 Vertica 安装中的数据库的信息。

示例

此示例从主数据库中查询数据库表。

=> SELECT * FROM DATABASES;
-[ RECORD 1 ]----------+-------------------------------------------------------------
database_id            | 45035996273704976
database_name          | VMart
owner_id               | 45035996273704962
owner_name             | dbadmin
start_time             | 2017-10-22 05:16:22.066961-04
compliance_message     | The database is in compliance with respect to raw data size.
export_subnet          | 0
load_balance_policy    | none
backend_address_family | ipv4
branch_name            |

8.1.18 - DIRECTED_QUERIES

返回关于定向查询的信息。

特权

超级用户

截断的查询结果

字段 INPUT_QUERY 和 ANNOTATED_QUERY 的查询结果在 ~32K 个字符之后会被截断。可以使用两种方法获取这两个字段的完整内容：

8.1.19 - DUAL

DUAL 是一个单列的“虚拟”表，只有一条记录，记录的值为 X；例如：

=> SELECT * FROM DUAL;
 dummy
-------
 X
(1 row)

您可以编写以下类型的查询：

=> SELECT 1 FROM dual;
 ?column?
----------
        1
(1 row)
=> SELECT current_timestamp, current_user FROM dual;
           ?column?            | current_user
-------------------------------+--------------
 2010-03-08 12:57:32.065841-05 | release
(1 row)
=> CREATE TABLE t1(col1 VARCHAR(20), col2 VARCHAR(2));
=> INSERT INTO T1(SELECT 'hello' AS col1, 1 AS col2 FROM dual);)
=> SELECT * FROM t1;
 col1  | col2
-------+------
 hello | 1
(1 row

限制

不能为 DUAL 创建 投影。

8.1.20 - ELASTIC_CLUSTER

返回关于群集弹性的信息，如 弹性群集 是否正在运行。

特权

超级用户

另请参阅

8.1.21 - EPOCHS

对于最近关闭的时期，列出关闭的日期和时间以及已关闭时期相应的时期数。EPOCHS 表可能会根据当前提交活动返回不同数量的行。

示例

=> SELECT * FROM EPOCHS;
       epoch_close_time        | epoch_number
-------------------------------+--------------
 2018-11-12 16:05:15.552571-05 |           16
(1 row)

查询历史数据

如果需要有关时期和相应的日期信息的历史数据，请查询 DC_TRANSACTION_ENDS 表。

=> select dc.end_epoch,min(dc.time),max(dc.time) from dc_transaction_ends dc group by end_epoch;
 end_epoch |             min               | max
-----------+-------------------------------+-------------------------------
       214 |  2018-10-12 08:05:47.02075-04 | 2018-10-15 10:22:24.015292-04
       215 | 2018-10-15 10:22:47.015172-04 | 2018-10-15 13:00:44.888984-04
                          ...
       226 | 2018-10-15 15:03:47.015235-04 | 2018-10-15 20:37:34.346667-04
       227 | 2018-10-15 20:37:47.008137-04 | 2018-10-16 07:39:00.29917-04
       228 | 2018-10-16 07:39:47.012411-04 | 2018-10-16 08:16:01.470232-04
       229 | 2018-10-16 08:16:47.018899-04 | 2018-10-16 08:21:13.854348-04
       230 | 2018-10-16 08:21:47.013767-04 | 2018-10-17 12:21:09.224094-04
       231 |  2018-10-17 12:21:09.23193-04 | 2018-10-17 15:11:59.338777-04

另请参阅

8.1.22 - FAULT_GROUPS

查看容错组和它们在群集中的层次结构。

示例

显示群集中的容错组的当前层次结构：

vmartdb=> SELECT member_type, member_name, parent_type, CASE
          WHEN parent_type = 'DATABASE' THEN ''
          ELSE parent_name END FROM fault_groups
          ORDER BY member_name;
 member_type | member_name           | parent_type | parent_name
-------------+-----------------------+-------------+-------------
 NODE        | v_vmart_node0001      | FAULT GROUP | two
 NODE        | v_vmart_node0002      | FAULT GROUP | two
 NODE        | v_vmart_node0003      | FAULT GROUP | three
 FAULT GROUP | one                   | DATABASE    |
 FAULT GROUP | three                 | DATABASE    |
 FAULT GROUP | two                   | FAULT GROUP | one

查看区段布局的分布：

vmartdb=> SELECT segment_layout from elastic_cluster;
                           segment_layout
-------------------------------------------------------------------------
 v_vmart_node0001[33.3%] v_vmart_node0003[33.3%] v_vmart_node0004[33.3%]
(1 row)

另请参阅

8.1.23 - FOREIGN_KEYS

提供外键信息。

示例

mydb=> SELECT
          constraint_name,
          table_name,
          ordinal_position,
          reference_table_name
       FROM foreign_keys ORDER BY 3;
      constraint_name      |    table_name     | ordinal_position | reference_table_name
---------------------------+-------------------+------------------+-----------------------
 fk_store_sales_date       | store_sales_fact  |                1 | date_dimension
 fk_online_sales_saledate  | online_sales_fact |                1 | date_dimension
 fk_store_orders_product   | store_orders_fact |                1 | product_dimension
 fk_inventory_date         | inventory_fact    |                1 | date_dimension
 fk_inventory_product      | inventory_fact    |                2 | product_dimension
 fk_store_sales_product    | store_sales_fact  |                2 | product_dimension
 fk_online_sales_shipdate  | online_sales_fact |                2 | date_dimension
 fk_store_orders_product   | store_orders_fact |                2 | product_dimension
 fk_inventory_product      | inventory_fact    |                3 | product_dimension
 fk_store_sales_product    | store_sales_fact  |                3 | product_dimension
 fk_online_sales_product   | online_sales_fact |                3 | product_dimension
 fk_store_orders_store     | store_orders_fact |                3 | store_dimension
 fk_online_sales_product   | online_sales_fact |                4 | product_dimension
 fk_inventory_warehouse    | inventory_fact    |                4 | warehouse_dimension
 fk_store_orders_vendor    | store_orders_fact |                4 | vendor_dimension
 fk_store_sales_store      | store_sales_fact  |                4 | store_dimension
 fk_store_orders_employee  | store_orders_fact |                5 | employee_dimension
 fk_store_sales_promotion  | store_sales_fact  |                5 | promotion_dimension
 fk_online_sales_customer  | online_sales_fact |                5 | customer_dimension
 fk_store_sales_customer   | store_sales_fact  |                6 | customer_dimension
 fk_online_sales_cc        | online_sales_fact |                6 | call_center_dimension
 fk_store_sales_employee   | store_sales_fact  |                7 | employee_dimension
 fk_online_sales_op        | online_sales_fact |                7 | online_page_dimension
 fk_online_sales_shipping  | online_sales_fact |                8 | shipping_dimension
 fk_online_sales_warehouse | online_sales_fact |                9 | warehouse_dimension
 fk_online_sales_promotion | online_sales_fact |               10 | promotion_dimension
(26 rows)

8.1.24 - GRANTS

返回在数据库对象上显式授予的权限的相关信息。不包括继承的权限的相关信息。

示例

以下查询显示授予用户 Rob 或角色 R1 的权限。权限附有星号 (*) 表示用户可以将此权限授予其他用户：

=> SELECT grantor,privileges_description,object_name,object_type,grantee FROM grants WHERE grantee='Rob' OR grantee='R1';
 grantor |  privileges_description   | object_name | object_type  | grantee
 --------+---------------------------+-------------+--------------+---------
 dbadmin | USAGE                     | general     | RESOURCEPOOL | Rob
 dbadmin | USAGE, CREATE             | s1          | SCHEMA       | Rob
 dbadmin | INSERT*, SELECT*, UPDATE* | t1          | TABLE        | Rob
 dbadmin | SELECT                    | t1          | TABLE        | R1
 dbadmin | USAGE                     | s1          | SCHEMA       | R1
 dbadmin |                           | R1          | ROLE         | Rob
 (6 rows)

另请参阅

8.1.25 - HCATALOG_COLUMNS

介绍可以通过 HCatalog 连接器使用的所有表的列。此表中的每个行都对应可以通过 HCatalog 连接器访问的表中的列。有关详细信息，请参阅使用 HCatalog 连接器。

特权

不需要显式权限；但是，用户只会看到与他们有权访问的架构对应的记录。

注意

如果使用的是 WebHCat 而非 HiveServer2，则查询此表会导致一个 web 服务对每个 HCatalog 架构中的每个表调用 WebHCat 服务器。如果需要在短时间内对此表执行多次查询，请考虑使用 CREATE TABLE AS 语句创建表的副本，以便提高性能。副本不会反映创建 Hive 表的架构之后对它所做的任何更改，但查询速度会快很多。

示例

以下示例展示了如何查找特定表的列信息：

=> SELECT * FROM HCATALOG_COLUMNS WHERE table_name = 'hcatalogtypes'
-> ORDER BY ordinal_position;
-[ RECORD 1 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | intcol
hcatalog_data_type       | int
data_type                | int
data_type_id             | 6
data_type_length         | 8
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 1
-[ RECORD 2 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | floatcol
hcatalog_data_type       | float
data_type                | float
data_type_id             | 7
data_type_length         | 8
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 2
-[ RECORD 3 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | doublecol
hcatalog_data_type       | double
data_type                | float
data_type_id             | 7
data_type_length         | 8
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 3
-[ RECORD 4 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | charcol
hcatalog_data_type       | string
data_type                | varchar(65000)
data_type_id             | 9
data_type_length         | 65000
character_maximum_length | 65000
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 4
-[ RECORD 5 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | varcharcol
hcatalog_data_type       | string
data_type                | varchar(65000)
data_type_id             | 9
data_type_length         | 65000
character_maximum_length | 65000
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 5
-[ RECORD 6 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | boolcol
hcatalog_data_type       | boolean
data_type                | boolean
data_type_id             | 5
data_type_length         | 1
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 6
-[ RECORD 7 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | timestampcol
hcatalog_data_type       | string
data_type                | varchar(65000)
data_type_id             | 9
data_type_length         | 65000
character_maximum_length | 65000
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 7
-[ RECORD 8 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | varbincol
hcatalog_data_type       | binary
data_type                | varbinary(65000)
data_type_id             | 17
data_type_length         | 65000
character_maximum_length | 65000
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 8
-[ RECORD 9 ]------------+-----------------
table_schema             | hcat
hcatalog_schema          | default
table_name               | hcatalogtypes
is_partition_column      | f
column_name              | bincol
hcatalog_data_type       | binary
data_type                | varbinary(65000)
data_type_id             | 17
data_type_length         | 65000
character_maximum_length | 65000
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 9

另请参阅

8.1.26 - HCATALOG_SCHEMATA

列出使用 HCatalog 连接器定义的所有架构。请参阅使用 HCatalog 连接器。

与 HCatalog 连接器相关的其他系统表不同，此表不调用 Hive，因此查询非常轻松。

特权

不需要显式权限；但是，用户只会看到与他们有权访问的架构对应的记录。

另请参阅

8.1.27 - HCATALOG_TABLES

返回可以通过 HCatalog 连接器使用的所有表的详细列表。请参阅使用 HCatalog 连接器。

特权

不需要显式权限；但是，用户只会看到与他们有权访问的架构对应的记录。

另请参阅

8.1.28 - HCATALOG_TABLE_LIST

所有 Hive 架构和数据库中包含的可以通过 HCatalog 连接器使用的所有列表的简明列表。请参阅使用 HCatalog 连接器。

特权

不需要显式权限；但是，用户只会看到与他们有权访问的架构对应的记录。

注意

  • 查询此表会导致针对使用 HCatalog 连接器定义的每个 Hive 架构调用一次 HiveServer2。这意味着查询需要的时间通常比查询其他系统表更久。

  • 查询此表比查询 HCATALOG_TABLES 更快。查询 HCATALOG_TABLE_LIST 仅针对每个 HCatalog 架构调用一次 HiveServer2，而查询 HCATALOG_TABLES 的每个表都会调用一次。

示例

以下示例演示了定义新 HCatalog 架构，然后查询 HCATALOG_TABLE_LIST。请注意，也会显示在其他 HCatalog 架构中定义的表。HCATALOG_TABLE_LIST 列出任何一个 HCatalog 架构中可用的所有表：

=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost'
-> HCATALOG_SCHEMA='default' HCATALOG_DB='default' HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> \x
Expanded display is on.
=> SELECT * FROM v_catalog.hcatalog_table_list;
-[ RECORD 1 ]------+------------------
table_schema_id    | 45035996273748980
table_schema       | hcat
hcatalog_schema    | default
table_name         | weblogs
hcatalog_user_name | hcatuser
-[ RECORD 2 ]------+------------------
table_schema_id    | 45035996273748980
table_schema       | hcat
hcatalog_schema    | default
table_name         | tweets
hcatalog_user_name | hcatuser
-[ RECORD 3 ]------+------------------
table_schema_id    | 45035996273748980
table_schema       | hcat
hcatalog_schema    | default
table_name         | messages
hcatalog_user_name | hcatuser
-[ RECORD 4 ]------+------------------
table_schema_id    | 45035996273864948
table_schema       | hiveschema
hcatalog_schema    | default
table_name         | weblogs
hcatalog_user_name | hcatuser

另请参阅

8.1.29 - INHERITING_OBJECTS

提供哪些表和视图从哪些架构继承权限的相关信息。

有关从架构及其关联的 GRANT 语句继承的特定权限的信息，请参阅 INHERITED_PRIVILEGES 表。

示例

以下查询返回从父架构（即客户）继承其权限的表和视图。

=> SELECT * FROM inheriting_objects WHERE object_schema='customers';
     object_id     |     schema_id     | object_schema |  object_name  | object_type
 ------------------+-------------------+---------------+---------------+-------------
 45035996273980908 | 45035996273980902 | customers     | cust_info     | table
 45035996273980984 | 45035996273980902 | customers     | shipping_info | table
 45035996273980980 | 45035996273980902 | customers     | cust_set      | view
 (3 rows)

另请参阅

8.1.30 - INHERITED_PRIVILEGES

提供有关父架构上的表和视图通过 GRANT 语句继承的权限的摘要信息，不包括继承的授权选项。

有关显式授予权限的信息，请参阅系统表 GRANTS。

示例

以下查询返回表和视图从其父架构（即客户）继承的权限。

=> SELECT object_schema,object_name,object_type,privileges_description,principal,grantor FROM inherited_privileges WHERE object_schema='customers';
 object_schema |  object_name  | object_type |                          privileges_description                           | principal | grantor
 --------------+---------------+-------------+---------------------------------------------------------------------------+-----------+---------
 customers     | cust_info     | Table       | INSERT, SELECT, UPDATE, DELETE, ALTER, REFERENCES, DROP, TRUNCATE         | dbadmin   | dbadmin
 customers     | shipping_info | Table       | INSERT, SELECT, UPDATE, DELETE, ALTER, REFERENCES, DROP, TRUNCATE         | dbadmin   | dbadmin
 customers     | cust_set      | View        | SELECT, ALTER, DROP                                                       | dbadmin   | dbadmin
 customers     | cust_info     | Table       | SELECT                                                                    | Val       | dbadmin
 customers     | shipping_info | Table       | SELECT                                                                    | Val       | dbadmin
 customers     | cust_set      | View        | SELECT                                                                    | Val       | dbadmin
 customers     | cust_info     | Table       | INSERT                                                                    | Pooja     | dbadmin
 customers     | shipping_info | Table       | INSERT                                                                    | Pooja     | dbadmin
 (8 rows)

另请参阅

8.1.31 - KEYWORDS

识别 Vertica 保留关键字和非保留关键字。

示例

以下查询将获取所有以 B 开头的保留关键字：

=> SELECT * FROM keywords WHERE reserved = 'R' AND keyword ilike 'B%';
 keyword | reserved
---------+----------
 BETWEEN | R
 BIGINT  | R
 BINARY  | R
 BIT     | R
 BOOLEAN | R
 BOTH    | R
(6 rows)

另请参阅

关键字

8.1.32 - LARGE_CLUSTER_CONFIGURATION_STATUS

显示编录中的当前聚类节点和控制节点（spread 主机）目标，以便查看它们是否匹配。

另请参阅

大型群集

8.1.33 - LICENSE_AUDITS

列出 Vertica 许可证的自动合规性审核结果。请参阅 Vertica 如何计算数据库大小。

8.1.34 - LICENSES

显示所有许可证的类型信息、许可证有效日期以及许可证强加限制。

8.1.35 - LOAD_BALANCE_GROUPS

列出所有负载均衡组包含的对象。此表中的每一行代表负载均衡组中的一个对象。如果负载均衡组不包含任何对象，则将会在此表中出现一次，其类型列设置为“Empty Group”。

示例

=> SELECT * FROM LOAD_BALANCE_GROUPS;
     name      |   policy   |  filter   |         type          | object_name
---------------+------------+-----------+-----------------------+-------------
 group_1       | ROUNDROBIN |           | Network Address Group | node01
 group_1       | ROUNDROBIN |           | Network Address Group | node02
 group_2       | ROUNDROBIN |           | Empty Group           |
 group_all     | ROUNDROBIN |           | Network Address Group | node01
 group_all     | ROUNDROBIN |           | Network Address Group | node02
 group_all     | ROUNDROBIN |           | Network Address Group | node03
 group_fault_1 | RANDOM     | 0.0.0.0/0 | Fault Group           | fault_1
(7 rows)

另请参阅

8.1.36 - LOG_PARAMS

提供与数据库中运行的身份验证和安全相关的配置参数更改的摘要信息。

示例

以下示例将查询 LOG_PARAMS 系统表并仅显示此用户在“身份验证 (Authentication)”类别下的最新配置参数：

=> SELECT * FROM log_params limit 1;


--------------------------------------------------------------------------------------------------------


issued_time   | 2018-02-12 13:41:20.837452-05
user_name     | dbadmin
user_id       | 45035996273704962
hostname      | ::1:50690
session_id    | v_vmart_node0001-341751:0x13878
audit_type    | Param
audit_tag_name| SecurityAlgorithm
request_type  | UTILITY
request_id    | 8
subject       | MD5
request       | select set_config_parameter('SecurityAlgorithm','MD5',null);
success       | t
category      | Authentication
(1 row)

8.1.37 - LOG_QUERIES

提供与在数据库中运行的身份验证和安全相关的一些查询的摘要信息。

示例

以下示例将查询 LOG_QUERIES 系统表并仅显示该用户在 Managing_Users_Privileges 类别下的最新查询：

=> SELECT * FROM log_queries limit 1;
---------------------------------------------------------------------------


issued_time   | 2018-01-22 10:36:55.634349-05
user_name     | dbadmin
user_id       | 45035996273704962
hostname      |
session_id    | v_vmart_node0001-237210:0x37e1d
audit_type    | Query
audit_tag_name| REVOKE ROLE
request_type  | DDL
request_id    | 2
subject       |
request       | revoke all privileges from Joe;
success       | f
category      | Managing_Users_Privileges
(1 row)

8.1.38 - LOG_TABLES

提供有关系统表查询的摘要信息。

示例

以下示例显示了对配置参数的最新查询：

dbadmin=> SELECT issued_time, audit_type, request_type, subject, request, category FROM log_tables
   WHERE category ilike '%Managing_Config_Parameters%' ORDER BY issued_time DESC LIMIT 4;
-[ RECORD 1 ]+-------------------------------------------------------------------------------------
issued_time  | 2020-05-14 14:14:53.453552-04
audit_type   | Table
request_type | QUERY
subject      | vs_nodes
request      | SELECT * from vs_nodes order by name  limit 1;
category     | Managing_Config_Parameters
-[ RECORD 2 ]+-------------------------------------------------------------------------------------
issued_time  | 2020-05-14 14:14:27.546474-04
audit_type   | Table
request_type | QUERY
subject      | vs_nodes
request      | SELECT * from vs_nodes order by name ;
category     | Managing_Config_Parameters
-[ RECORD 3 ]+-------------------------------------------------------------------------------------
issued_time  | 2020-05-14 08:54:32.86881-04
audit_type   | Table
request_type | QUERY
subject      | vs_parameters_mismatch
request      | select * from configuration_parameters where parameter_name = 'MaxDepotSizePercent';
category     | Managing_Config_Parameters
-[ RECORD 4 ]+-------------------------------------------------------------------------------------
issued_time  | 2020-05-14 08:54:32.86881-04
audit_type   | Table
request_type | QUERY
subject      | vs_nodes
request      | select * from configuration_parameters where parameter_name = 'MaxDepotSizePercent';
category     | Managing_Config_Parameters

8.1.39 - MATERIALIZE_FLEXTABLE_COLUMNS_RESULTS

运行 flex 表函数以后，返回结果， MATERIALIZE_FLEXTABLE_COLUMNS。系统表包含以下信息：

示例

=> SELECT table_name, creation_time, key_name, status, message FROM v_catalog.materialize_flextable_columns_results WHERE table_name = 'twitter_r'; table_name | creation_time | key_name | status | message ------------+-------------------------------+-------------------+--------+-------------------------------------------------------- twitter_r | 2013-11-20 17:00:27.945484-05 | contributors | ADDED | Added successfully twitter_r | 2013-11-20 17:00:27.94551-05 | entities.hashtags | ADDED | Added successfully twitter_r | 2013-11-20 17:00:27.945519-05 | entities.urls | ADDED | Added successfully twitter_r | 2013-11-20 17:00:27.945532-05 | created_at | EXISTS | Column of same name already exists in table definition (4 rows

8.1.40 - MODELS

列出数据库中机器学习模型的详细信息。

示例

=> SELECT * FROM models;
-[ RECORD 1 ]------------------------------
model_id    | 45035996273714020
model_name  | myLinearRegModel
schema_id   | 45035996273704980
schema_name | public
owner_id    | 45035996273704962
owner_name  | dbadmin
category    | VERTICA_MODELS
model_type  | LINEAR_REGRESSION
is_complete | t
create_time | 2018-01-22 11:13:35.018412-05
size        | 1671

8.1.41 - NETWORK_ADDRESSES

列出使用 CREATE NETWORK ADDRESS 语句在数据库中定义的网络地址的相关信息。

示例

=> \x
Expanded display is on.

=> SELECT * FROM v_catalog.network_addresses;
-[ RECORD 1 ]----+-----------------
name             | node01
node             | v_vmart_node0001
address          | 10.20.100.247
port             | 5433
address_family   | ipv4
is_enabled       | t
is_auto_detected | f
-[ RECORD 2 ]----+-----------------
name             | node02
node             | v_vmart_node0002
address          | 10.20.100.248
port             | 5433
address_family   | ipv4
is_enabled       | t
is_auto_detected | f
-[ RECORD 3 ]----+-----------------
name             | node03
node             | v_vmart_node0003
address          | 10.20.100.249
port             | 5433
address_family   | ipv4
is_enabled       | t
is_auto_detected | f

另请参阅

8.1.42 - NODES

数据库节点的列表详情。

示例

=> SELECT NODE_NAME, NODE_STATE, IS_PRIMARY, IS_READONLY, NODE_TYPE,
          SUBCLUSTER_NAME FROM NODES ORDER BY NODE_NAME ASC;
      NODE_NAME       | NODE_STATE | IS_PRIMARY | IS_READONLY | NODE_TYPE |  SUBCLUSTER_NAME
----------------------+------------+------------+-------------+-----------+--------------------
 v_verticadb_node0001 | UP         | t          | f           | PERMANENT | default_subcluster
 v_verticadb_node0002 | UP         | t          | f           | PERMANENT | default_subcluster
 v_verticadb_node0003 | UP         | t          | f           | PERMANENT | default_subcluster
 v_verticadb_node0004 | UP         | f          | f           | PERMANENT | analytics
 v_verticadb_node0005 | UP         | f          | f           | PERMANENT | analytics
 v_verticadb_node0006 | UP         | f          | f           | PERMANENT | analytics
(6 rows)

8.1.43 - NODE_SUBSCRIPTION_CHANGE_PHASES

在 Eon 模式数据库中，存储有关节点分片订阅更改的信息。

示例

=> SELECT NODE_NAME, SUBSCRIPTION_CHANGE_TYPE, SHARD_NAME,
   ACTION  FROM node_subscription_change_phases
   ORDER BY start_time ASC LIMIT 10;

      NODE_NAME       | SUBSCRIPTION_CHANGE_TYPE | SHARD_NAME  |         ACTION
----------------------+--------------------------+-------------+------------------------
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0007 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0010 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0004 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0005 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | replica     | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0005 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0006 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0008 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0011 | COLLECT SHARD METADATA
 v_verticadb_node0001 | CREATE SUBSCRIPTION      | segment0002 | COLLECT SHARD METADATA

8.1.44 - NODE_SUBSCRIPTIONS

仅限 Eon 模式

列出有关数据库节点订阅分片的信息。

示例

以下示例将查询数据库中的 NODE_SUBSCRIPTIONS 表，该数据库包含 12 个分片，有 2 个三节点子群集（一个主子群集，一个辅助子群集）。

=> SELECT node_name, shard_name, subscription_state, is_primary,
          is_participating_primary AS is_p_primary
       FROM NODE_SUBSCRIPTIONS ORDER BY node_name, shard_name;

      node_name       | shard_name  | subscription_state | is_primary | is_p_primary
----------------------+-------------+--------------------+------------+--------------
 v_verticadb_node0001 | replica     | ACTIVE             | t          | t
 v_verticadb_node0001 | segment0001 | ACTIVE             | t          | t
 v_verticadb_node0001 | segment0003 | ACTIVE             | f          | f
 v_verticadb_node0001 | segment0004 | ACTIVE             | t          | t
 v_verticadb_node0001 | segment0006 | ACTIVE             | f          | f
 v_verticadb_node0001 | segment0007 | ACTIVE             | t          | t
 v_verticadb_node0001 | segment0009 | ACTIVE             | f          | f
 v_verticadb_node0001 | segment0010 | ACTIVE             | t          | t
 v_verticadb_node0001 | segment0012 | ACTIVE             | f          | f
 v_verticadb_node0002 | replica     | ACTIVE             | f          | t
 v_verticadb_node0002 | segment0001 | ACTIVE             | f          | f
 v_verticadb_node0002 | segment0002 | ACTIVE             | t          | t
 v_verticadb_node0002 | segment0004 | ACTIVE             | f          | f
 v_verticadb_node0002 | segment0005 | ACTIVE             | t          | t
 v_verticadb_node0002 | segment0007 | ACTIVE             | f          | f
 v_verticadb_node0002 | segment0008 | ACTIVE             | t          | t
 v_verticadb_node0002 | segment0010 | ACTIVE             | f          | f
 v_verticadb_node0002 | segment0011 | ACTIVE             | t          | t
 v_verticadb_node0003 | replica     | ACTIVE             | f          | t
 v_verticadb_node0003 | segment0002 | ACTIVE             | f          | f
 v_verticadb_node0003 | segment0003 | ACTIVE             | t          | t
 v_verticadb_node0003 | segment0005 | ACTIVE             | f          | f
 v_verticadb_node0003 | segment0006 | ACTIVE             | t          | t
 v_verticadb_node0003 | segment0008 | ACTIVE             | f          | f
 v_verticadb_node0003 | segment0009 | ACTIVE             | t          | t
 v_verticadb_node0003 | segment0011 | ACTIVE             | f          | f
 v_verticadb_node0003 | segment0012 | ACTIVE             | t          | t
 v_verticadb_node0004 | replica     | ACTIVE             | f          | t
 v_verticadb_node0004 | segment0001 | ACTIVE             | f          | t
 v_verticadb_node0004 | segment0003 | ACTIVE             | f          | f
 v_verticadb_node0004 | segment0004 | ACTIVE             | f          | t
 v_verticadb_node0004 | segment0006 | ACTIVE             | f          | f
 v_verticadb_node0004 | segment0007 | ACTIVE             | f          | t
 v_verticadb_node0004 | segment0009 | ACTIVE             | f          | f
 v_verticadb_node0004 | segment0010 | ACTIVE             | f          | t
 v_verticadb_node0004 | segment0012 | ACTIVE             | f          | f
 v_verticadb_node0005 | replica     | ACTIVE             | f          | t
 v_verticadb_node0005 | segment0001 | ACTIVE             | f          | f
 v_verticadb_node0005 | segment0002 | ACTIVE             | f          | t
 v_verticadb_node0005 | segment0004 | ACTIVE             | f          | f
 v_verticadb_node0005 | segment0005 | ACTIVE             | f          | t
 v_verticadb_node0005 | segment0007 | ACTIVE             | f          | f
 v_verticadb_node0005 | segment0008 | ACTIVE             | f          | t
 v_verticadb_node0005 | segment0010 | ACTIVE             | f          | f
 v_verticadb_node0005 | segment0011 | ACTIVE             | f          | t
 v_verticadb_node0006 | replica     | ACTIVE             | f          | t
 v_verticadb_node0006 | segment0002 | ACTIVE             | f          | f
 v_verticadb_node0006 | segment0003 | ACTIVE             | f          | t
 v_verticadb_node0006 | segment0005 | ACTIVE             | f          | f
 v_verticadb_node0006 | segment0006 | ACTIVE             | f          | t
 v_verticadb_node0006 | segment0008 | ACTIVE             | f          | f
 v_verticadb_node0006 | segment0009 | ACTIVE             | f          | t
 v_verticadb_node0006 | segment0011 | ACTIVE             | f          | f
 v_verticadb_node0006 | segment0012 | ACTIVE             | f          | t
(54 rows)

8.1.45 - ODBC_COLUMNS

提供表列信息。该格式由 ODBC SQLColumns 元数据的 ODBC 标准定义。ODBC 规范中提供了有关 ODBC SQLColumns 格式的详细信息：http://msdn.microsoft.com/en-us/library/windows/desktop/ms711683%28v=vs.85%29.aspx。

8.1.46 - PASSWORD_AUDITOR

存储有关用户帐户、帐户过期和 密码哈希算法的信息。

8.1.47 - PASSWORDS

包含当前用户密码的相关信息。如果任何 配置文件 设置了 PASSWORD_REUSE_TIME 或 PASSWORD_REUSE_MAX 参数，此表还将包括过去密码的相关信息。有关详细信息，请参阅CREATE PROFILE。

示例

以下查询返回了用户“u1”的 SHA-512 哈希密码和 salt。

=> SELECT user_name, password, salt FROM passwords WHERE user_name='u1';
 user_name |                         password                       |               salt
-----------+--------------------------------------------------------+----------------------------------
 u1        | sha512f3f802f1c56e2530cd9c3164cc7b8002ba444c0834160f10 | f05e9d859fb441f9f612f8a787bfc872
(1 row)

8.1.48 - PRIMARY_KEYS

提供主键的信息。

8.1.49 - PROFILE_PARAMETERS

定义存储在配置文件中的信息。

8.1.50 - PROFILES

提供您使用 CREATE PROFILE 语句设置的密码策略的相关信息。

注意

查询该表的非超级用户仅能看到所分配的配置文件信息。

另请参阅

8.1.51 - PROJECTION_CHECKPOINT_EPOCHS

提供有关检查点时期的详细信息，仅适用于 Enterprise 模式。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

=> SELECT node_name, projection_schema, projection_name, is_up_to_date, checkpoint_epoch FROM projection_checkpoint_epochs
    WHERE projection_name ilike 't1_b%' ORDER BY projection_name, node_name;
    node_name     | projection_schema | projection_name | is_up_to_date | checkpoint_epoch
------------------+-------------------+-----------------+---------------+------------------
 v_vmart_node0001 | public            | t1_b1           | t             |              965
 v_vmart_node0002 | public            | t1_b1           | t             |              965
 v_vmart_node0003 | public            | t1_b1           | t             |              965
 v_vmart_node0001 | public            | t1_b0           | t             |              965
 v_vmart_node0002 | public            | t1_b0           | t             |              965
 v_vmart_node0003 | public            | t1_b0           | t             |              965
(6 rows)

dbadmin=> INSERT INTO t1 VALUES (100, 101, 102);
 OUTPUT
--------
      1
(1 row)

dbadmin=> COMMIT;
COMMIT
dbadmin=> SELECT node_name, projection_schema, projection_name, is_up_to_date, checkpoint_epoch FROM projection_checkpoint_epochs
           WHERE projection_name ILIKE 't1_b%' ORDER BY projection_name, node_name;
    node_name     | projection_schema | projection_name | is_up_to_date | checkpoint_epoch
------------------+-------------------+-----------------+---------------+------------------
 v_vmart_node0001 | public            | t1_b1           | t             |              966
 v_vmart_node0002 | public            | t1_b1           | t             |              966
 v_vmart_node0003 | public            | t1_b1           | t             |              966
 v_vmart_node0001 | public            | t1_b0           | t             |              966
 v_vmart_node0002 | public            | t1_b0           | t             |              966
 v_vmart_node0003 | public            | t1_b0           | t             |              966
(6 rows)

8.1.52 - PROJECTION_COLUMNS

提供投影列的相关信息，例如编码类型、排序顺序、统计信息类型以及列统计信息的上次更新时间。

示例

请参阅 PROJECTION_COLUMNS 中的统计信息数据

另请参阅

8.1.53 - PROJECTION_DELETE_CONCERNS

列出其设计在删除数据时可能导致性能问题的投影。此表是通过调用 EVALUATE_DELETE_PERFORMANCE 函数生成的。有关详细信息，请参阅优化 DELETE 和 UPDATE。

8.1.54 - PROJECTIONS

提供关于投影的信息。

另请参阅

PROJECTION_COLUMNS

8.1.55 - RESOURCE_POOL_DEFAULTS

返回内置和用户定义的资源池的默认参数设置。使用 ALTER RESOURCE POOL 将资源池参数还原为默认设置。

有关内置资源池的有效参数及其默认设置的信息，请参阅 内置资源池配置。

要获取资源池的当前设置，请查询系统表 RESOURCE_POOLS。

特权

无

8.1.56 - RESOURCE_POOLS

显示内置和用户定义的资源池的设置。有关定义资源池的信息，请参阅 CREATE RESOURCE POOL 和 ALTER RESOURCE POOL。

8.1.57 - ROLES

包含用户可以访问的所有角色以及任何已分配给这些角色的角色的名称。

另请参阅

8.1.58 - ROUTING_RULES

列出将传入 IP 地址映射到负载均衡组的路由规则。

示例

=> SELECT * FROM routing_rules;
-[ RECORD 1 ]----+-----------------
name             | internal_clients
source_address   | 192.168.1.0/24
destination_name | group_1
-[ RECORD 2 ]----+-----------------
name             | etl_rule
source_address   | 10.20.100.0/24
destination_name | group_2
-[ RECORD 3 ]----+-----------------
name             | subnet_192
source_address   | 192.0.0.0/8
destination_name | group_all
-[ RECORD 4 ]----+--------------
name             | all_ipv6
source_address   | 0::0/0
destination_name | default_ipv6

另请参阅

8.1.59 - SCHEMATA

提供有关数据库中架构的信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.1.60 - SEQUENCES

显示有关序列的信息。

示例

创建简单的序列：

=> CREATE SEQUENCE my_seq MAXVALUE 5000 START 150;
CREATE SEQUENCE

返回有关刚创建的序列的信息：

=> \x
Expanded display is on.
=> SELECT * FROM sequences;
-[ RECORD 1 ]-------+------------------
sequence_schema     | public
sequence_name       | my_seq
owner_name          | dbadmin
identity_table_name |
session_cache_count | 250000
allow_cycle         | f
output_ordered      | f
increment_by        | 1
minimum             | 1
maximum             | 5000
current_value       | 149
sequence_schema_id  | 45035996273704966
sequence_id         | 45035996273844996
owner_id            | 45035996273704962
identity_table_id   | 0

标识列是仅适用于数字列类型的序列。要识别表中的列（如有）是标识列，请搜索 COLUMNS 表以查找表中的标识列：

=> CREATE TABLE testid (c1 IDENTITY(1, 1, 1000), c2 INT);
=> \x
Expanded display is on.
=> SELECT * FROM COLUMNS WHERE is_identity='t' AND table_name='testid';
-[ RECORD 1 ]------------+------------------
table_id                 | 45035996274150730
table_schema             | public
table_name               | testid
is_system_table          | f
column_name              | c1
data_type                | int
data_type_id             | 6
data_type_length         | 8
character_maximum_length |
numeric_precision        |
numeric_scale            |
datetime_precision       |
interval_precision       |
ordinal_position         | 1
is_nullable              | f
column_default           |
is_identity              | t

使用 SEQUENCES 表获得关于 testid 中序列的详细信息：

=> SELECT * FROM sequences WHERE identity_table_name='testid';
-[ RECORD 1 ]-------+--------------------
sequence_schema     | public
sequence_name       | testid_c1_seq
owner_name          | dbadmin
identity_table_name | testid
session_cache_count | 1000
allow_cycle         | f
output_ordered      | f
increment_by        | 1
minimum             | 1
maximum             | 9223372036854775807
current_value       | 0
sequence_schema_id  | 45035996273704976
sequence_id         | 45035996274150770
owner_id            | 45035996273704962
identity_table_id   | 45035996274150768

使用 vsql 命令 \ds 以返回序列的列表。以下结果显示了先前示例中创建的两个序列。如果存在更多序列，表会将其列出。

新序列的 CurrentValue 比您在 CREATE SEQUENCE 和 IDENTITY 命令中指定的起始编号少 1，因为您还未使用 NEXTVAL 实例化序列来分配其缓存或提供其首批初始值。

=> \ds
 List of Sequences
-[ RECORD 1 ]+--------------------
Schema       | public
Sequence     | my_seq
CurrentValue | 149
IncrementBy  | 1
Minimum      | 1
Maximum      | 5000
AllowCycle   | f
Comment      |
-[ RECORD 2 ]+--------------------
Schema       | public
Sequence     | testid_c1_seq
CurrentValue | 0
IncrementBy  | 1
Minimum      | 1
Maximum      | 9223372036854775807
AllowCycle   | f
Comment      |

8.1.61 - SESSION_SUBSCRIPTIONS

在 Eon 模式数据库中，列出所有节点的分片订阅，以及订阅是否用于解析当前会话的查询。将参与解析此会话查询的节点在其 IS_PARTICIPATING 列中显示为 TRUE。

示例

以下示例列出了参与当前会话或在其中协作的订阅：

=> SELECT node_name, shard_name, is_collaborating, is_participating
        FROM V_CATALOG.SESSION_SUBSCRIPTIONS
        WHERE is_participating = TRUE OR is_collaborating = TRUE
        ORDER BY shard_name, node_name;
      node_name       | shard_name  | is_collaborating | is_participating
----------------------+-------------+------------------+------------------
 v_verticadb_node0004 | replica     | f                | t
 v_verticadb_node0005 | replica     | f                | t
 v_verticadb_node0006 | replica     | t                | f
 v_verticadb_node0007 | replica     | f                | t
 v_verticadb_node0008 | replica     | t                | f
 v_verticadb_node0009 | replica     | t                | f
 v_verticadb_node0007 | segment0001 | f                | t
 v_verticadb_node0008 | segment0001 | t                | f
 v_verticadb_node0005 | segment0002 | f                | t
 v_verticadb_node0009 | segment0002 | t                | f
 v_verticadb_node0004 | segment0003 | f                | t
 v_verticadb_node0006 | segment0003 | t                | f
(12 rows)

8.1.62 - SHARDS

列出数据库中的分片。

示例

=> SELECT * FROM SHARDS;
-[ RECORD 1 ]----+------------------
shard_oid        | 45035996273704980
shard_name       | replica
shard_type       | Replica
lower_hash_bound |
upper_hash_bound |
is_replicated    | t
has_objects      | t
...

8.1.63 - STORAGE_LOCATIONS

提供有关存储位置（包括 ID、标签和状态）的信息。

特权

超级用户

另请参阅

8.1.64 - SUBCLUSTERS

此表列出了数据库中定义的所有子群集。它包含数据库中每个节点的条目，其中列出了每个条目所属的子群集。任何不包含节点的子群集在此表中都有一个条目，其中 NODE_NAME 和 NODE_OID 列为空。此表仅在数据库在 Eon 模式下运行时才会填充。

示例

=> \x
Expanded display is on.
dbadmin=> SELECT * FROM SUBCLUSTERS;
-[ RECORD 1 ]----+---------------------
subcluster_oid   | 45035996273704978
subcluster_name  | default_subcluster
node_oid         | 45035996273704982
node_name        | v_verticadb_node0001
parent_oid       | 45035996273704976
parent_name      | verticadb
is_default       | t
is_primary       | t
control_set_size | -1
-[ RECORD 2 ]----+---------------------
subcluster_oid   | 45035996273704978
subcluster_name  | default_subcluster
node_oid         | 45035996273840970
node_name        | v_verticadb_node0002
parent_oid       | 45035996273704976
parent_name      | verticadb
is_default       | t
is_primary       | t
control_set_size | -1
-[ RECORD 3 ]----+---------------------
subcluster_oid   | 45035996273704978
subcluster_name  | default_subcluster
node_oid         | 45035996273840974
node_name        | v_verticadb_node0003
parent_oid       | 45035996273704976
parent_name      | verticadb
is_default       | t
is_primary       | t
control_set_size | -1

另请参阅

8.1.65 - SUBCLUSTER_RESOURCE_POOL_OVERRIDES

显示内置全局资源池设置的子群集级别覆盖。

8.1.66 - SYSTEM_COLUMNS

提供 SYSTEM_TABLES 的表列信息。

8.1.67 - SYSTEM_TABLES

返回所有系统表名称的列表。

8.1.68 - TABLE_CONSTRAINTS

提供有关表格约束的信息。

另请参阅

ANALYZE_CONSTRAINTS

8.1.69 - TABLES

提供有关数据库中所有表格的信息。

示例

查找表的创建时间：

=> SELECT table_schema, table_name, create_time FROM tables;
 table_schema |      table_name       |          create_time
--------------+-----------------------+-------------------------------
 public       | customer_dimension    | 2011-08-15 11:18:25.784203-04
 public       | product_dimension     | 2011-08-15 11:18:25.815653-04
 public       | promotion_dimension   | 2011-08-15 11:18:25.850592-04
 public       | date_dimension        | 2011-08-15 11:18:25.892347-04
 public       | vendor_dimension      | 2011-08-15 11:18:25.942805-04
 public       | employee_dimension    | 2011-08-15 11:18:25.966985-04
 public       | shipping_dimension    | 2011-08-15 11:18:25.999394-04
 public       | warehouse_dimension   | 2011-08-15 11:18:26.461297-04
 public       | inventory_fact        | 2011-08-15 11:18:26.513525-04
 store        | store_dimension       | 2011-08-15 11:18:26.657409-04
 store        | store_sales_fact      | 2011-08-15 11:18:26.737535-04
 store        | store_orders_fact     | 2011-08-15 11:18:26.825801-04
 online_sales | online_page_dimension | 2011-08-15 11:18:27.007329-04
 online_sales | call_center_dimension | 2011-08-15 11:18:27.476844-04
 online_sales | online_sales_fact     | 2011-08-15 11:18:27.49749-04
(15 rows)

查明某些表是否为临时表和 flex 表：

=> SELECT distinct table_name, table_schema, is_temp_table, is_flextable FROM v_catalog.tables
   WHERE table_name ILIKE 't%';
  table_name  | table_schema | is_temp_table | is_flextable
--------------+--------------+---------------+-----------------
 t2_temp      | public       | t             | t
 tt_keys      | public       | f             | f
 t2_temp_keys | public       | f             | f
 t3           | public       | t             | f
 t1           | public       | f             | f
 t9_keys      | public       | f             | f
 t2_keys      | public       | f             | t
 t6           | public       | t             | f
 t5           | public       | f             | f
 t2           | public       | f             | t
 t8           | public       | f             | f
 t7           | public       | t             | f
 tt           | public       | t             | t
 t2_keys_keys | public       | f             | f
 t9           | public       | t             | t
(15 rows)

8.1.70 - TEXT_INDICES

提供有关 Vertica 中文本索引的摘要信息。

8.1.71 - TYPES

提供所支持的数据类型的信息。此表不包括内联复杂类型；请参阅 COMPLEX_TYPES。但是此表包括数组和基元类型集。

8.1.72 - USER_AUDITS

列出用户调用 AUDIT 函数生成的数据库和对象大小审核的结果。有关详细信息，请参阅监控数据库大小是否符合许可证要求。

8.1.73 - USER_CLIENT_AUTH

提供与数据库用户关联的客户端身份验证方法的相关信息。您可以使用 GRANT（身份验证）将身份验证方法与用户关联。

8.1.74 - USER_CONFIGURATION_PARAMETERS

提供对数据库用户有效的用户级别配置参数的相关信息。

特权

仅限超级用户

示例

=> SELECT * FROM user_configuration_parameters;
 user_name |      parameter_name       | current_value | default_value
-----------+---------------------------+---------------+---------------
 Yvonne    | LoadSourceStatisticsLimit | 512           | 256
(1 row)

=> ALTER USER Ahmed SET DepotOperationsForQuery='FETCHES';
ALTER USER
=> ALTER USER Yvonne SET DepotOperationsForQuery='FETCHES';
ALTER USER
=> SELECT * FROM user_configuration_parameters;
 user_name |      parameter_name       | current_value | default_value
-----------+---------------------------+---------------+---------------
 Ahmed     | DepotOperationsForQuery   | FETCHES       | ALL
 Yvonne    | DepotOperationsForQuery   | FETCHES       | ALL
 Yvonne    | LoadSourceStatisticsLimit | 512           | 256
(3 rows)

8.1.75 - USER_FUNCTION_PARAMETERS

提供 C++ 用户定义函数 (UDx) 的参数的相关信息。您只能查看那些 Properties.visible 属性已设置为 TRUE 的参数。

特权

任何用户都可查询 USER_FUNCTION_PARAMETERS 表。但是，用户只能看到其拥有使用权限的 UDx 函数的相关表信息。

另请参阅

8.1.76 - USER_FUNCTIONS

返回用户定义的 SQL 函数（将常用的 SQL 表达式作为函数存储在 Vertica 编录中）和用户定义函数的相关元数据。

注意

  • 将根据函数定义自动推断出 SQL 函数的可变性和严格性，以便 Vertica 确定使用的正确性，比如在应该提供不可变函数时却提供了易变函数。

  • UDx 的可变性和严格性由 UDx 开发者予以定义。

示例

在公共架构中创建名为 myzeroifnull 的 SQL 函数：

=> CREATE FUNCTION myzeroifnull(x INT) RETURN INT
   AS BEGIN
     RETURN (CASE WHEN (x IS NOT NULL) THEN x ELSE 0 END);
   END;

现在查询 USER_FUNCTIONS 表。查询仅返回 myzeroifnull 宏，因为它是在此架构中创建的唯一宏：

=> SELECT * FROM user_functions;
-[ RECORD 1 ]----------+---------------------------------------------------
schema_name            | public
function_name          | myzeroifnull
procedure_type         | User Defined Function
function_return_type   | Integer
function_argument_type | x Integer
function_definition    | RETURN CASE WHEN (x IS NOT NULL) THEN x ELSE 0 END
volatility             | immutable
is_strict              | f
is_fenced              | f
comment                |

另请参阅

8.1.77 - USER_PROCEDURES

提供有关存储过程和外部过程的信息。用户只能看到他们可以执行的过程。

特权

非超级用户只有在拥有以下权限时才能查看过程的相关信息：

  • 对过程架构的 USAGE 权限。

  • 对过程的所有权或 EXECUTE 权限。

示例

=> SELECT * FROM user_procedures;
   procedure_name   |  owner  | language | security |                               procedure_arguments                                 | schema_name
--------------------+---------+----------+----------+-----------------------------------------------------------------------------------+-------------
 accurate_auc       | dbadmin | PL/vSQL  | INVOKER  | relation varchar, observation_col varchar, probability_col varchar, epsilon float | public
 conditionalTable   | dbadmin | PL/vSQL  | INVOKER  | b boolean                                                                         | public
 update_salary      | dbadmin | PL/vSQL  | INVOKER  | x int, y varchar                                                                  | public
(3 rows)

8.1.78 - USER_TRANSFORMS

列出当前定义的用户定义转换函数 (UDTF)。

特权

不需要显式权限；但是，用户只会看到他们具有读取权限的架构中包含的 UDTF。

另请参阅

8.1.79 - USERS

提供数据库中所有用户的相关信息。

另请参阅

8.1.80 - VIEW_COLUMNS

提供视图属性信息。

另请参阅

VIEWS

8.1.81 - VIEW_TABLES

显示视图相关依赖项（包括引用视图的表、其架构和所有者）的相关详细信息。

8.1.82 - VIEWS

提供系统内所有 视图的相关信息。有关详细信息，请参阅视图。

另请参阅

VIEW_COLUMNS

8.2 - V_MONITOR 架构

本部分中的系统表位于 v_monitor 架构中。这些表提供 Vertica 数据库运行状况的相关信息。

8.2.1 - ACTIVE_EVENTS

返回群集中的所有活动事件。请参阅监控事件。

8.2.2 - ALLOCATOR_USAGE

提供有关 Vertica 节点内存池分配和重复使用的实时信息。

Vertica 中包含两个内存池，全局和 SAL。全局内存池与 Vertica 编录对象相关。SAL 内存池与系统存储层有关。这两个内存池是 Vertica 从中分配和重复使用部分内存的物理结构。

在内存池中，有两种分配类型。全局和 SAL 内存池均包括区块和对象内存分配类型。

  • 区块分配来自分层存储，并分成 2 的若干次幂大小（以字节为单位）的组。

  • 对象分配为对象类型，例如表或投影。每个对象占用指定的大小。

该表提供了有关这些内存池分配的详细信息。

示例：如何分配、保留和释放内存池内存

下表显示了基于假设示例的示例列值。该示例说明了列值随表对象的添加或删除的变化。

  • 添加一个表对象 (t1) 时，Vertica 假定 UNIT_SIZE 为 8 个字节，USED_COUNT 为 1。

  • 当添加第二个表对象 (t2) 时，USED_COUNT 将增加到 2。由于每个对象占用 8 个字节，因此 USED_BYTES 将增加到 16。

  • 当删除两个表对象之一时，Vertica USED_COUNT 将减少到 1，USED_BYTES 将减少到 8。由于 Vertica 保留内存以供将来使用，因此 FREE_BYTES 将增加到 8，FREE_COUNT 将增加到 1。

  • 最后，当新建一个表对象 (t3) 时，Vertica 会释放内存以供重复使用。 FREE_COUNT FREE_BYTES 将返回 0。

示例

以下示例显示了一个区块分配类型的示例记录以及一个对象类型的示例记录。

=> \x
Expanded display is on.


=> select * from allocator_usage;
-[ RECORD 1 ]---+-----------------------------
node_name       | v_vmart_node0004
pool_name       | global
allocation_type | chunk
unit_size       | 8
free_count      | 1069
free_bytes      | 8552
used_count      | 7327
used_bytes      | 58616
total_size      | 67168
capture_time    | 2017-05-24 13:28:07.83855-04
allocation_name | 2^3
.
.
.
-[ RECORD 105 ]-+------------------------------
node_name       | v_vmart_node0004
pool_name       | SAL
allocation_type | object
unit_size       | 128
free_count      | 0
free_bytes      | 0
used_count      | 2
used_bytes      | 256
total_size      | 256
capture_time    | 2017-05-24 14:44:30.153892-04
allocation_name | SAL::WOSAlloc
.
.
.

8.2.3 - COLUMN_STORAGE

返回每个节点上每个投影的每一列使用的磁盘存储量。

8.2.4 - COMMUNAL_CLEANUP_RECORDS

仅限 Eon 模式

此系统表列出了 Vertica 认为在 Eon 模式的公共存储上泄露的文件。泄漏文件是指被检测到需要删除但被正常清理机制遗漏的文件。此信息可帮助您确定通过清理泄漏文件可以回收或已回收的公共存储的空间量。

示例

=> SELECT clean_communal_storage('true');
                                                                     clean_communal_storage
----------------------------------------------------------------------------------------------------------------------------------------------
 CLEAN COMMUNAL STORAGE
Total leaked files: 10
Total size: 217088
Files have been queued for deletion.
Check communal_cleanup_records for more information.
(1 row)

=> SELECT * FROM communal_cleanup_records;
      detection_timestamp      | location_path     |                       file_name                       | size_in_bytes | queued_for_delete
-------------------------------+-------------------+-------------------------------------------------------+---------------+-------------------
 2018-05-01 17:01:34.045955-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000003_0.gt |         28672 | t
 2018-05-01 17:01:34.045966-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000006_0.gt |         28672 | t
 2018-05-01 17:01:34.045952-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000001_0.gt |         36864 | t
 2018-05-01 17:01:34.045974-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000008_0.gt |         36864 | t
 2018-05-01 17:01:34.045981-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000002_0.gt |         12288 | t
 2018-05-01 17:01:34.045986-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000007_0.gt |          8192 | t
 2018-05-01 17:01:34.045991-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000010_0.gt |         16384 | t
 2018-05-01 17:01:34.046001-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000005_0.gt |         24576 | t
 2018-05-01 17:01:34.046026-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000009_0.gt |          4096 | t
 2018-05-01 17:01:34.046033-04 | s3://chumbucket/  | 020000000000000000000000000000000000000000000004_0.gt |         20480 | t
(10 rows)

另请参阅

CLEAN_COMMUNAL_STORAGE

8.2.5 - COMMUNAL_TRUNCATION_STATUS

仅限 Eon 模式

存储出现编录截断事件时群集状态的相关信息。

示例

=> SELECT * FROM COMMUNAL_TRUNCATION_STATUS;
current_catalog_version  | cluster_truncation_version
-------------------------+----------------------------
                    35   |                        35

8.2.6 - CONFIGURATION_CHANGES

记录系统配置参数的更改历史记录。此信息有助于确定：

  • 更改配置参数值的用户

  • 更改配置参数的时间

  • 非标准设置过去是否有效

特权

超级用户

8.2.7 - CONFIGURATION_PARAMETERS

提供系统当前使用的所有配置参数的相关信息。

示例

以下示例显示了一个参数需要重新启动，才能使新设置生效的案例：

=> SELECT * FROM CONFIGURATION_PARAMETERS WHERE parameter_name = 'RequireFIPS';
-[ RECORD 1 ]-----------------+----------------------
node_name                     | ALL
parameter_name                | RequireFIPS
current_value                 | 0
restart_value                 | 0
database_value                | 0
default_value                 | 0
current_level                 | DEFAULT
restart_level                 | DEFAULT
is_mismatch                   | f
groups                        |
allowed_levels                | DATABASE
superuser_visible_only        | f
change_under_support_guidance | f
change_requires_restart       | t
description                   | Execute in FIPS mode

以下示例显示了一个 superuser_only 为 true 的条件下，非超级用户查看参数的案例。

=> \c VMart nonSuperuser

You are now connected to database "VMart" as user "nonSuperuser".

=> SELECT * FROM CONFIGURATION_PARAMETERS WHERE superuser_visible_only = 't';
-[ RECORD 1 ]-----------------+-------------------------------------------------------
node_name                     | ALL
parameter_name                | S3BucketCredentials
current_value                 | ********
restart_value                 | ********
database_value                | ********
default_value                 | ********
current_level                 | DEFAULT
restart_level                 | DEFAULT
is_mismatch                   | f
groups                        |
allowed_levels                | SESSION, DATABASE
superuser_visible_only        | t
change_under_support_guidance | f
change_requires_restart       | f
description                   | JSON list mapping S3 buckets to specific credentials.

另请参阅

配置参数管理

8.2.8 - CPU_USAGE

记录系统的 CPU 使用历史记录。

特权

超级用户

8.2.9 - CRITICAL_HOSTS

列出故障可能会导致数据库不安全并强制关机的关键主机。

特权

无

8.2.10 - CRITICAL_NODES

列出故障可能会导致数据库不安全并强制关机的 关键节点。

8.2.11 - CRITICAL_SUBCLUSTERS

列出丢失可能会导致数据库不安全并强制关闭的主子群集。Vertica 在停止子群集之前会检查此表，以确保其不会触发数据库关闭。如果尝试停止或移除此表中的子群集，Vertica 将返回错误消息。有关详细信息，请参阅启动和停止子群集。

此表仅在数据库处于 Eon 模式，且一个或多个子群集为关键时才具有内容。

示例

=> SELECT * FROM critical_subclusters;
  subcluster_oid   |  subcluster_name
-------------------+--------------------
 45035996273704996 | default_subcluster
(1 row)

另请参阅

8.2.12 - CURRENT_SESSION

返回有关当前活动会话的信息。使用此表找出当前会话的 sessionID 并获得先前执行查询的时间。

分析设置

以下列显示不同分析类别的设置：

  • EXECUTION_ENGINE_PROFILING_CONFIGURATION

  • QUERY_PROFILING_CONFIGURATION

  • SESSION_PROFILING_CONFIGURATION

这些设置为以下几项之一：

有关控制分析设置的信息，请参阅启用分析。

8.2.13 - DATA_COLLECTOR

显示所有 数据收集器组件的设置：组件当前的保留策略属性和其他数据收集统计信息。

默认情况下，数据收集器处于打开状态。要将其关闭，请将配置参数 EnableDataCollector 设置为 0。

示例

获取资源池的当前状态：

=> SELECT * FROM data_collector WHERE component = 'ResourcePoolStatus' ORDER BY node_name;
-[ RECORD 1 ]----------+---------------------------------
node_name              | v_vmart_node0001
component              | ResourcePoolStatus
table_name             | dc_resource_pool_status
description            | Resource Pool status information
access_restricted      | t
memory_buffer_size_kb  | 64
disk_size_kb           | 25600
interval_set           | f
interval_time          | 0
record_too_big_errors  | 0
lost_buffers           | 0
lost_records           | 0
retired_files          | 385
retired_records        | 3492335
current_memory_records | 0
current_disk_records   | 30365
current_memory_bytes   | 0
current_disk_bytes     | 21936993
first_time             | 2020-08-14 11:03:28.007894-04
last_time              | 2020-08-14 11:59:41.005675-04
kb_per_day             | 548726.098227313
-[ RECORD 2 ]----------+---------------------------------
node_name              | v_vmart_node0002
component              | ResourcePoolStatus
table_name             | dc_resource_pool_status
description            | Resource Pool status information
access_restricted      | t
memory_buffer_size_kb  | 64
disk_size_kb           | 25600
interval_set           | f
interval_time          | 0
record_too_big_errors  | 0
lost_buffers           | 0
lost_records           | 0
retired_files          | 385
retired_records        | 3492335
current_memory_records | 0
current_disk_records   | 28346
current_memory_bytes   | 0
current_disk_bytes     | 20478345
first_time             | 2020-08-14 11:07:12.006484-04
last_time              | 2020-08-14 11:59:41.004825-04
kb_per_day             | 548675.811828872
-[ RECORD 3 ]----------+---------------------------------
node_name              | v_vmart_node0003
component              | ResourcePoolStatus
table_name             | dc_resource_pool_status
description            | Resource Pool status information
access_restricted      | t
memory_buffer_size_kb  | 64
disk_size_kb           | 25600
interval_set           | f
interval_time          | 0
record_too_big_errors  | 0
lost_buffers           | 0
lost_records           | 0
retired_files          | 385
retired_records        | 3492335
current_memory_records | 0
current_disk_records   | 28337
current_memory_bytes   | 0
current_disk_bytes     | 20471843
first_time             | 2020-08-14 11:07:13.008246-04
last_time              | 2020-08-14 11:59:41.006729-04
kb_per_day             | 548675.63541403

另请参阅

8.2.14 - DATA_READS

仅限 Eon 模式

列出查询在 Eon 模式下读取的每个存储位置。如果查询从多个位置获取数据，此表将针对每个节点从中读取数据的每个位置提供一行。例如，一个查询可能在三个节点上运行，从存储库和公共存储中获取数据。在这种情况下，该表将针对查询显示六行：针对每个节点的存储库读取显示三行，针对每个节点的公共存储读取显示三行。

示例

=> SELECT * FROM V_MONITOR.DATA_READS WHERE TRANSACTION_ID = 45035996273707457;
-[ RECORD 1 ]--+---------------------------------------------------
start_time     | 2019-02-13 19:43:43.840836+00
node_name      | v_verticadb_node0001
session_id     | v_verticadb_node0001-11828:0x6f3
user_id        | 45035996273704962
user_name      | dbadmin
transaction_id | 45035996273707457
statement_id   | 1
request_id     | 230
location_id    | 45035996273835000
location_path  | /vertica/data/verticadb/v_verticadb_node0001_depot
bytes_read     | 329460142
-[ RECORD 2 ]--+---------------------------------------------------
start_time     | 2019-02-13 19:43:43.8421+00
node_name      | v_verticadb_node0002
session_id     | v_verticadb_node0001-11828:0x6f3
user_id        | 45035996273704962
user_name      | dbadmin
transaction_id | 45035996273707457
statement_id   | 1
request_id     | 0
location_id    | 45035996273835002
location_path  | /vertica/data/verticadb/v_verticadb_node0002_depot
bytes_read     | 329473033
-[ RECORD 3 ]--+---------------------------------------------------
start_time     | 2019-02-13 19:43:43.841845+00
node_name      | v_verticadb_node0003
session_id     | v_verticadb_node0001-11828:0x6f3
user_id        | 45035996273704962
user_name      | dbadmin
transaction_id | 45035996273707457
statement_id   | 1
request_id     | 0
location_id    | 45035996273835004
location_path  | /vertica/data/verticadb/v_verticadb_node0003_depot
bytes_read     | 329677294

8.2.15 - DATABASE_BACKUPS

在运行 vbr 实用程序后列出成功完成的每个备份的历史信息。此信息可用于确定在推进 AHM 之前是否创建新的备份。因为该系统表显示历史信息，其内容不会始终反映备份存储库的当前状态。例如，如果从存储库中删除备份，DATABASE_BACKUPS 系统表将继续显示相关信息。

要列出现有备份，需运行 vbr，详情请参阅查看备份。

特权

超级用户

8.2.16 - DATABASE_CONNECTIONS

列出与其他数据库的连接以导入和导出数据。请参阅数据库导出和导入。

示例

=> CONNECT TO VERTICA vmart USER dbadmin PASSWORD '' ON '10.10.20.150',5433;
CONNECT
=> SELECT * FROM DATABASE_CONNECTIONS;
 database | username |     host     | port | isvalid
----------+----------+--------------+------+---------
 vmart    | dbadmin  | 10.10.20.150 | 5433 | t
(1 row)

8.2.17 - DATABASE_MIGRATION_STATUS

提供有关 Enterprise-to-Eon 数据库迁移尝试的实时和历史数据。

特权

超级用户

示例

以下示例显示了正在进行迁移的数据：

=> SELECT node_name, phase, status, bytes_to_transfer, bytes_transferred, communal_storage_location FROM database_migration_status ORDER BY node_name, start_time;
     node_name    |       phase        |  status   | bytes_to_transfer | bytes_transferred | communal_storage_location
------------------+--------------------+-----------+-------------------+------------------+---------------------------
 v_vmart_node0001 | Catalog Conversion | COMPLETED |                 0 |                0 | s3://verticadbbucket/
 v_vmart_node0001 | Data Transfer      | COMPLETED |              1134 |             1134 | s3://verticadbbucket/
 v_vmart_node0001 | Catalog Transfer   | COMPLETED |              3765 |             3765 | s3://verticadbbucket/
 v_vmart_node0002 | Catalog Conversion | COMPLETED |                 0 |                0 | s3://verticadbbucket/
 v_vmart_node0002 | Data Transfer      | COMPLETED |              1140 |             1140 | s3://verticadbbucket/
 v_vmart_node0002 | Catalog Transfer   | COMPLETED |              3766 |             3766 | s3://verticadbbucket/
 v_vmart_node0003 | Catalog Conversion | COMPLETED |                 0 |                0 | s3://verticadbbucket/
 v_vmart_node0003 | Data Transfer      | RUNNING   |           5272616 |           183955 | s3://verticadbbucket/

8.2.18 - DELETE_VECTORS

保留有关已删除行的信息，以加速删除进程。

示例

从 Vertica 表中删除数据后，该数据将被标记为删除。要查看标记为待删除的数据，请查询 DELETE_VECTORS 系统表。

运行 PURGE 以从 ROS 容器中移除删除向量。

=> SELECT * FROM test1;
 number
--------
      3
     12
     33
     87
     43
     99
(6 rows)

=> DELETE FROM test1 WHERE number > 50;
 OUTPUT
--------
      2
(1 row)

=> SELECT * FROM test1;
 number
--------
     43
      3
     12
     33
(4 rows)
=> SELECT node_name, projection_name, deleted_row_count FROM DELETE_VECTORS;
    node_name     | projection_name | deleted_row_count
------------------+-----------------+-------------------
 v_vmart_node0002 | test1_b1        |                 1
 v_vmart_node0001 | test1_b1        |                 1
 v_vmart_node0001 | test1_b0        |                 1
 v_vmart_node0003 | test1_b0        |                 1
(4 rows)

=> SELECT PURGE();
...
(Table: public.test1) (Projection: public.test1_b0)
(Table: public.test1) (Projection: public.test1_b1)
...
(4 rows)

Ancient History Mark (AHM) 推进后：

=> SELECT * FROM DELETE_VECTORS;
 (No rows)

另请参阅

8.2.19 - DEPLOY_STATUS

记录已部署的 Database Designer 设计及其部署步骤的历史记录。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.20 - DEPLOYMENT_PROJECTION_STATEMENTS

包含用于部署数据库设计的 CREATE PROJECTION 语句的相关信息。每行包含不同 CREATE PROJECTION 语句的相关信息。函数 DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY 将填充此表。

8.2.21 - DEPLOYMENT_PROJECTIONS

包含设计过程中创建和删除的投影信息。每行包含关于不同投影的信息。设计部署后，Database Designer 会填充此表。

8.2.22 - DEPOT_EVICTIONS

仅限 Eon 模式

记录从存储库逐出对象时的数据。

示例

=> SELECT * FROM V_MONITOR.DEPOT_EVICTIONS LIMIT 2;
-[ RECORD 1 ]----+-------------------------------------------------
start_time       | 2019-02-20 15:32:26.765937+00
end_time         | 2019-02-20 15:32:26.766019+00
node_name        | v_verticadb_node0001
session_id       | v_verticadb_node0001-8997:0x3e
user_id          | 45035996273704962
user_name        | dbadmin
transaction_id   | 45035996273705450
statement_id     | 1
request_id       | 406
storage_id       | 0000000000000000000000000000000000a000000001fbf6
storage_oid      | 45035996273842065
file_size_bytes  | 61
number_hits      | 1
last_access_time | 2019-02-20 15:32:26.668094+00
reason           | DROP OBJECT
is_pinned        | f
-[ RECORD 2 ]----+-------------------------------------------------
start_time       | 2019-02-20 15:32:26.812803+00
end_time         | 2019-02-20 15:32:26.812866+00
node_name        | v_verticadb_node0001
session_id       | v_verticadb_node0001-8997:0x3e
user_id          | 45035996273704962
user_name        | dbadmin
transaction_id   | 45035996273705453
statement_id     | 1
request_id       | 409
storage_id       | 0000000000000000000000000000000000a000000001fbf6
storage_oid      | 45035996273842079
file_size_bytes  | 91
number_hits      | 1
last_access_time | 2019-02-20 15:32:26.770807+00
reason           | DROP OBJECT
is_pinned        | f

8.2.23 - DEPOT_FETCH_QUEUE

仅限 Eon 模式

列出查询文件数据的所有待处理存储库请求，以从公共存储中获取。

示例

=> \x
Expanded display is on.
=> SELECT * FROM depot_fetch_queue;
-[ RECORD 1 ]----------+-------------------------------------------------------------
node_name              | v_example_db_node0002
sal_storage_id         | 029b6fac864e1982531dcde47d00edc500d000000001d5e7
transaction_id         | 45035996273705983
source_file_name       | s3://mydata/mydb/14a/029b6fac864e1982531dcde47d00edc500d000
                              000001d5e7_0.gt
destination_file_name  | /vertica/example_db/v_example_db_node0002_depot/747/029b6fac
                              864e1982531dcde47d00edc500d000000001d5eb_0.gt
-[ RECORD 2 ]----------+-------------------------------------------------------------
node_name              | v_example_db_node0003
sal_storage_id         | 026635d69719c45e8d2d86f5a4d62c7b00b000000001d5e7
transaction_id         | 45035996273705983
source_file_name       | s3://mydata/mydb/4a5/029b6fac864e1982531dcde47d00edc500d0000
                              00001d5eb_0.gt
destination_file_name  | /vertica/example_db/v_example_db_node0002_depot/751/026635d6
                              9719c45e8d2d86f5a4d62c7b00b000000001d5e7_0.gt

8.2.24 - DEPOT_FETCHES

仅限 Eon 模式

记录存储库获取请求的相关数据。

示例

=> \x
Expanded display is on.

=> SELECT * FROM DEPOT_FETCHES LIMIT 2;
-[ RECORD 1 ]----+-------------------------------------------------------------
start_time       | 2019-08-30 15:16:15.125962+00
end_time         | 2019-08-30 15:16:15.126791+00
node_name        | v_verticadb_node0001
transaction_id   | 45035996273706225
storage_id       | 0239ef74126e70db410b301610f1e5b500b0000000020d65
storage_oid      | 45035996273842065
file_size_bytes  | 53033
source_file      |
destination_file | /vertica/data/verticadb/v_verticadb_node0001_depot/957/0239e
                     f74126e70db410b301610f1e5b500b0000000020d65_0.gt
source_node      | v_verticadb_node0002
is_successful    | t
reason           |
-[ RECORD 2 ]----+-------------------------------------------------------------
start_time       | 2019-08-30 15:16:15.285208+00
end_time         | 2019-08-30 15:16:15.285949+00
node_name        | v_verticadb_node0001
transaction_id   | 45035996273706234
storage_id       | 0239ef74126e70db410b301610f1e5b500b0000000020dc7
storage_oid      | 45035996273842075
file_size_bytes  | 69640
source_file      |
destination_file | /vertica/data/verticadb/v_verticadb_node0001_depot/055/0239e
                     f74126e70db410b301610f1e5b500b0000000020dc7_0.gt
source_node      | v_verticadb_node0002
is_successful    | t
reason           |

=> select node_name,transaction_id,storage_id,is_successful,reason FROM
   depot_fetches WHERE is_successful = 'f' LIMIT 3;
-[ RECORD 1 ]--+-------------------------------------------------
node_name      | v_verticadb_node0001
transaction_id | 45035996273721070
storage_id     | 0289281ac4c1f6580b95096fab25290800b0000000027d09
is_successful  | f
reason         | Could not create space in the depot
-[ RECORD 2 ]--+-------------------------------------------------
node_name      | v_verticadb_node0001
transaction_id | 45035996273721070
storage_id     | 0289281ac4c1f6580b95096fab25290800b0000000027d15
is_successful  | f
reason         | Could not create space in the depot
-[ RECORD 3 ]--+-------------------------------------------------
node_name      | v_verticadb_node0002
transaction_id | 45035996273721070
storage_id     | 02693f1c68266e38461084a840ee42aa00c0000000027d09
is_successful  | f
reason         | Could not create space in the depot

8.2.25 - DEPOT_FILES

仅限 Eon 模式

列出所有数据库存储库中包含的所有对象。

示例

=> \x
Expanded display is on.

=> SELECT * FROM depot_files LIMIT 2;

-[ RECORD 1 ]------+---------------------------------------------------------------
node_name          | v_verticadb_node0001
sal_storage_id     | 0275d4a7c99795d22948605e5940758900a000000001d1b1
storage_oid        | 45035996273842075
communal_file_path | s3://mybucket/myfolder/mydb/475/0275d4a7c99795d22948605e5940758900a000000001d1
b1/0275d4a7c99795d22948605e5940758900a000000001d1b1_
depot_file_path    | /vertica/data/verticadb/v_verticadb_node0001_depot/177/0275d4a7c99795d229486
05e5940758900a000000001d1b1/0275d4a7c99795d22948605e
shard_name         | replica
storage_type       | DFS
number_of_accesses | 0
file_size_bytes    | 456465645
last_access_time   | 2018-09-05 17:34:30.417274+00
arrival_time       | 2018-09-05 17:34:30.417274+00
source             | DEPOT FILL AT STARTUP
is_pinned          | f
-[ RECORD 2 ]------+---------------------------------------------------------------
node_name          | v_verticadb_node0001
sal_storage_id     | 0275d4a7c99795d22948605e5940758900a000000001d187
storage_oid        | 45035996273842079
communal_file_path | s3://mybucket/myfolder/mydb/664/0275d4a7c99795d22948605e5940758900a000000001d1
87/0275d4a7c99795d22948605e5940758900a000000001d187_
depot_file_path    | /vertica/data/verticadb/v_verticadb_node0001_depot/135/0275d4a7c99795d229486
05e5940758900a000000001d187/0275d4a7c99795d22948605e
shard_name         | replica
storage_type       | DFS
number_of_accesses | 0
file_size_bytes    | 40
last_access_time   | 2018-09-05 17:34:30.417244+00
arrival_time       | 2018-09-05 17:34:30.417244+00
source             | DEPOT FILL AT STARTUP
is_pinned          | f

8.2.26 - DEPOT_PIN_POLICIES

仅限 Eon 模式

列出固定到数据库存储库的所有对象：表、投影和表分区。

另请参阅

8.2.27 - DEPOT_SIZES

仅限 Eon 模式

报告 Vertica 节点上的存储库缓存容量。

示例

=> \x
Expanded display is on.
=> SELECT * FROM Depot_Sizes;

-[ RECORD 1 ]-------+---------------------------------------------------

node_name           | v_verticadb_node0003
location_oid        | 45035996273823200
location_path       | /vertica/data/verticadb/v_verticadb_node0003_depot
location_label      | auto-data-depot
max_size_bytes      | 0
current_usage_bytes | 0

-[ RECORD 2 ]-------+---------------------------------------------------
node_name           | v_verticadb_node0001
location_oid        | 45035996273823196
location_path       | /vertica/data/verticadb/v_verticadb_node0001_depot
location_label      | auto-data-depot
max_size_bytes      | 33686316032
current_usage_bytes | 206801871

-[ RECORD 3 ]-------+---------------------------------------------------
node_name           | v_verticadb_node0002
location_oid        | 45035996273823198
location_path       | /vertica/data/verticadb/v_verticadb_node0002_depot
location_label      | auto-data-depot
max_size_bytes      | 0
current_usage_bytes | 0

8.2.28 - DEPOT_UPLOADS

仅限 Eon 模式

列出有关存储库上传到公共存储的详细信息。

8.2.29 - DESIGN_QUERIES

包含给定设计的设计查询信息。以下函数将填充此表：

示例

在 VMART_DESIGN 中添加查询，然后查询 DESIGN_QUERIES 表：


=> SELECT DESIGNER_ADD_DESIGN_QUERIES('VMART_DESIGN', '/tmp/examples/vmart_queries.sql','true');
 DESIGNER_ADD_DESIGN_QUERIES
-----------------------------
Number of accepted queries                      =9
Number of queries referencing non-design tables =0
Number of unsupported queries                   =0
Number of illegal queries                       =0
=> \x
Expanded display is on.
=> SELECT * FROM V_MONITOR.DESIGN.QUERIES
-[ RECORD 1 ]------------+-------------------
design_id                | 45035996273705090
design_name              | vmart_design
design_query_id          | 1
design_query_id_index    | 0
query_text               | SELECT fat_content
FROM (
SELECT DISTINCT fat_content
  FROM product_dimension
  WHERE department_description
  IN ('Dairy') ) AS food
  ORDER BY fat_content
  LIMIT 5;
weight                   | 1
design_query_search_path | v_dbd_vmart_design_vmart_design_ltt, "$user", public, v_catalog, v_monitor, v_internal
design_query_signature   | 45035996273724651

-[ RECORD 2]-------------+-------------------
design_query_id          | 2
design_query_id_index    | 0
query_text               | SELECT order_number, date_ordered
        FROM store.store_orders_fact orders
        WHERE orders.store_key IN (
        SELECT store_key
        FROM store.store_dimension
        WHERE store_state = 'MA')
        AND orders.vendor_key NOT IN (
        SELECT vendor_key
        FROM public.vendor_dimension
        WHERE vendor_state = 'MA')
        AND date_ordered < '2012-03-01';

weight                   | 1
design_query_search_path | v_dbd_vmart_design_vmart_design_ltt, "$user", public, v_catalog, v_monitor, v_internal
design_query_signature   | 45035996273724508
-[ RECORD 3]-------------+-------------------
...

8.2.30 - DESIGN_STATUS

记录正在运行的 Database Designer 设计进度或由当前用户执行的上一个 Database Designer 设计的历史。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

以下示例显示了完整 Database Designer 运行的 DESIGN_STATUS 表内容：

=> SELECT event_time, design_name, design_phase, phase_complete_percent
   FROM v_monitor.design_status;
event_time          | design_name | design_phase                                   | phase_complete_percent
--------------------+-------------+------------------------------------------------+------------------------
2012-02-14 10:31:20 | design1     | Design started                                 |
2012-02-14 10:31:21 | design1     | Design in progress: Analyze statistics phase   |
2012-02-14 10:31:21 | design1     | Analyzing data statistics                      | 33.33
2012-02-14 10:31:22 | design1     | Analyzing data statistics                      | 66.67
2012-02-14 10:31:24 | design1     | Analyzing data statistics                      | 100
2012-02-14 10:31:25 | design1     | Design in progress: Query optimization phase   |
2012-02-14 10:31:25 | design1     | Optimizing query performance                   | 37.5
2012-02-14 10:31:31 | design1     | Optimizing query performance                   | 62.5
2012-02-14 10:31:36 | design1     | Optimizing query performance                   | 75
2012-02-14 10:31:39 | design1     | Optimizing query performance                   | 87.5
2012-02-14 10:31:41 | design1     | Optimizing query performance                   | 87.5
2012-02-14 10:31:42 | design1     | Design in progress: Storage optimization phase |
2012-02-14 10:31:44 | design1     | Optimizing storage footprint                   | 4.17
2012-02-14 10:31:44 | design1     | Optimizing storage footprint                   | 16.67
2012-02-14 10:32:04 | design1     | Optimizing storage footprint                   | 29.17
2012-02-14 10:32:04 | design1     | Optimizing storage footprint                   | 31.25
2012-02-14 10:32:05 | design1     | Optimizing storage footprint                   | 33.33
2012-02-14 10:32:05 | design1     | Optimizing storage footprint                   | 35.42
2012-02-14 10:32:05 | design1     | Optimizing storage footprint                   | 37.5
2012-02-14 10:32:05 | design1     | Optimizing storage footprint                   | 62.5
2012-02-14 10:32:39 | design1     | Optimizing storage footprint                   | 87.5
2012-02-14 10:32:39 | design1     | Optimizing storage footprint                   | 87.5
2012-02-14 10:32:41 | design1     | Optimizing storage footprint                   | 100
2012-02-14 10:33:12 | design1     | Design completed successfully                  |
(24 rows)

8.2.31 - DESIGN_TABLES

包括您拥有的所有设计的设计表信息。每一行包含不同设计表的信息。运行 DESIGNER_CREATE_DESIGN 时，Vertica 会创建此表。

示例

将 VMart 数据库中的所有表添加到 VMART_DESIGN 设计中。此操作将填充 DESIGN_TABLES 表：


=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN','online_sales.*');
DESIGNER_ADD_DESIGN_TABLES
----------------------------
 3
(1 row)
=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN','public.*');
DESIGNER_ADD_DESIGN_TABLES
----------------------------
 9
(1 row)
=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN','store.*');
DESIGNER_ADD_DESIGN_TABLES
----------------------------
 3
(1 row)
=> SELECT * FROM DESIGN_TABLES;
design_name  | design_table_id | table_schema |     table_id      |      table_name
-------------+-----------------+--------------+-------------------+-----------------------
VMART_DESIGN |               1 | online_sales | 45035996373718754 | online_page_dimension
VMART_DESIGN |               2 | online_sales | 45035996373718758 | call_center_dimension
VMART_DESIGN |               3 | online_sales | 45035996373718762 | online_sales_fact
VMART_DESIGN |               4 | public       | 45035996373718766 | customer_dimension
VMART_DESIGN |               5 | public       | 45035996373718770 | product_dimension
VMART_DESIGN |               6 | public       | 45035996373718774 | promotion_dimension
VMART_DESIGN |               7 | public       | 45035996373718778 | date_dimension
VMART_DESIGN |               8 | public       | 45035996373718782 | vendor_dimension
VMART_DESIGN |               9 | public       | 45035996373718786 | employee_dimension
VMART_DESIGN |              10 | public       | 45035996373718822 | shipping_dimension
VMART_DESIGN |              11 | public       | 45035996373718826 | warehouse_dimension
VMART_DESIGN |              12 | public       | 45035996373718830 | inventory_face
VMART_DESIGN |              13 | store        | 45035996373718794 | store_dimension
VMART_DESIGN |              14 | store        | 45035996373718798 | store_sales_fact
VMART_DESIGN |              15 | store        | 45035996373718812 | store_orders_fact
        (15 rows)

8.2.32 - DESIGNS

包含关于 Database Designer 设计的信息。创建设计并为 Database Designer 指定某些参数后， DESIGNER_CREATE_DESIGN 将在 V_MONITOR 架构中创建该表。

8.2.33 - DISK_QUOTA_USAGES

提供关于具有磁盘配额的架构和表的信息。不包括无配额的架构和表。

示例

=> SELECT * FROM DISK_QUOTA_USAGES;
    object_oid     | object_name | is_schema | total_disk_usage_in_bytes | disk_quota_in_bytes
-------------------+-------------+-----------+---------------------+---------------------
 45035996273705100 | s           | t         |                 307 |               10240
 45035996273705104 | public.t    | f         |                 614 |                1024
 45035996273705108 | s.t         | f         |                 307 |                2048
(3 rows)

8.2.34 - DISK_RESOURCE_REJECTIONS

返回因磁盘空间不足而遭到拒绝的资源请求。输出按 RESOURCE_TYPE 和 REJECTED_REASON 两者进行聚合，以提供更为全面的信息。

另请参阅

8.2.35 - DISK_STORAGE

返回各节点上的数据库占用的磁盘存储空间。各节点可能有一个或多个存储位置，且可能分布在具备不同属性（如可用空间、已占用空间和块大小）的不同磁盘上。此系统表中的信息有助于确定数据文件所在位置。

此系统表的所有返回值均是在主机操作系统的文件系统上下文中，不特定于 Vertica 特定空间。

存储使用注释为 CATALOG 表示该位置用于存储编录。各 CATALOG 位置仅在创建新数据库时指定。使用 CREATE LOCATION 既无法添加 CATALOG 位置注释，又无法移除现有 CATALOG 注释。

存储位置性能

存储位置的性能用两个值测量：

  • 以每秒兆字节数为单位的吞吐量

  • 以每秒查找次数为单位的延迟

这两个值会通过以下公式转换为一个数值（速度）：

read-time = (1/throughput) + (1/latency)

  • 读取时间：读取 1MB 数据的时间

  • 1/吞吐量：读取 1MB 数据的时间

  • 1/延迟：查找数据的时间。

如果磁盘的读取时间较少，则磁盘速度较其他磁盘快。

8.2.36 - DRAINING_STATUS

返回数据库中每个节点的排空状态。该表还提供用户会话总数以及连接到每个节点的最旧用户会话的信息。有关连接到数据库的用户会话的详细信息，请参阅 SESSIONS。

8.2.37 - ERROR_MESSAGES

列出 Vertica 处理查询时遇到的系统错误消息和警告。有些错误发生时并没有任何事务正在进行中，因此，事务标识符和语句标识符列可能返回 NULL。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.38 - EVENT_CONFIGURATIONS

监控事件配置。

8.2.39 - 执行_引擎_配置文件

提供有关运行时查询执行的配置文件信息。ID 的层次结构，从最高级别到实际执行是：

  • PATH_ID

  • BASEPLAN_ID

  • LOCALPLAN_ID

  • OPERATOR_ID

收集每一实际执行引擎 (EE) 运算符实例的计数器（从 COUNTER_NAME 列输出）。

以下列组合形成唯一键：

  • TRANSACTION_ID

  • STATEMENT_ID

  • NODE_NAME

  • OPERATOR_ID

  • COUNTER_NAME

  • COUNTER_TAG

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

计数器名称

COUNTER_NAME 的值可以是以下任意值：

示例

以下两项查询显示 EXECUTION_ENGINE_PROFILES 表的内容：

=> SELECT operator_name, operator_id, counter_name, counter_value     FROM EXECUTION_ENGINE_PROFILES WHERE operator_name = 'Scan'     ORDER BY counter_value DESC;  operator_name | operator_id | counter_name |  counter_value ---------------+-------------+--------------+------------------  Scan          |          20 | end time     | 1559929719983785  Scan          |          20 | start time   | 1559929719983737  Scan          |          18 | end time     | 1559929719983358  Scan          |          18 | start time   | 1559929718069860  Scan          |          16 | end time     | 1559929718069319  Scan          |          16 | start time   | 1559929718069188  Scan          |          14 | end time     | 1559929718068611  Scan          |          18 | end time     | 1559929717579145  Scan          |          18 | start time   | 1559929717579083  Scan          |          16 | end time     | 1559929717578509  Scan          |          18 | end time     | 1559929717379346  Scan          |          18 | start time   | 1559929717379307  Scan          |          16 | end time     | 1559929717378879  Scan          |          16 | start time   | 1559929716894312  Scan          |          14 | end time     | 1559929716893599  Scan          |          14 | start time   | 1559929716893501  Scan          |          12 | end time     | 1559929716892721  Scan          |          16 | start time   | 1559929716666110 ...   => SELECT DISTINCT counter_name FROM execution_engine_profiles;                     counter_name -----------------------------------------------------  reserved rid memory (bytes)  rows filtered by SIPs expression  rows output by sort  chunk rows scanned squared  join inner execution time (us)  current unbalanced memory requested (bytes)  clock time (us)  join outer clock time (us)  exception handling execution time (us)  peak memory capacity (bytes)  bytes received  peak memory requested (bytes)  send time (us)  ROS blocks encoded  current size of temp files (bytes)  peak memory allocations (count)  current unbalanced memory overhead (bytes)  rows segmented ...

以下查询包括 path_id 列，该列将此查询优化器的路径（通过 EXPLAIN 命令的文本输出）与合并错误信息相连接。 

=> SELECT operator_name, path_id, counter_name, counter_value FROM execution_engine_profiles where operator_name = 'Join';  operator_name | path_id |                    counter_name                     |  counter_value ---------------+---------+-----------------------------------------------------+------------------  Join          |      64 | current memory allocations (count)                  |                0  Join          |      64 | peak memory allocations (count)                     |               57  Join          |      64 | current memory requested (bytes)                    |                0  Join          |      64 | peak memory requested (bytes)                       |          1698240  Join          |      64 | current memory overhead (bytes)                     |                0  Join          |      64 | peak memory overhead (bytes)                        |                0  Join          |      64 | current memory padding (bytes)                      |                0  Join          |      64 | peak memory padding (bytes)                         |           249840  Join          |      64 | current memory capacity (bytes)                     |                0  Join          |      64 | peak memory capacity (bytes)                        |           294912  Join          |      64 | current unbalanced memory allocations (count)       |              145  Join          |      64 | peak unbalanced memory allocations (count)          |              146  Join          |      64 | current unbalanced memory requested (bytes)         |           116506  Join          |      64 | peak unbalanced memory requested (bytes)            |          1059111  Join          |      64 | current unbalanced memory overhead (bytes)          |             3120  Join          |      64 | peak unbalanced memory overhead (bytes)             |             3120 ...

另请参阅

8.2.40 - EXTERNAL_TABLE_DETAILS

返回数据库中支持外部表的源文件所使用的磁盘存储量。此系统表中的信息有助于确定 Hadoop 许可证合规性。

当计算外部表的大小时，Vertica 会计算在 COPY FROM 子句指定的位置找到的所有数据。例如，如果您有一个包含 ORC 和已分隔文件的目录，并且您使用“COPY FROM *”而不是“COPY FROM *.orc”来定义外部表，则此表包含已分隔文件的大小。（在查询该外部表时，您可能还会遇到错误。）当查询此系统表时，Vertica 不会验证您的表定义；只是使用路径查找要报告的文件。

限制您的查询，按架构、表或格式筛选，以避免费用昂贵的查询。Vertica 会在查询时计算此表中的值，因此 "SELECT *" 会访问对每个外部表有影响的每个输入文件。

查询中的谓词只能使用 TABLE_SCHEMA、TABLE_NAME 和 SOURCE_FORMAT 列。值区分大小写。

此表包括 TEMP 外部表。

此表仅报告当前用户可以读取的数据。如需包含支持外部表的所有数据，请以有权访问所有 HDFS 数据的用户身份或使用授予此访问权限的会话委托令牌查询此表。有关使用委派令牌的详细信息，请参阅访问已进行 Kerberize 的 HDFS 数据。

8.2.41 - HIVE_CUSTOM_PARTITIONS_ACCESSED

此表提供关于 Vertica 访问过的 Hive 分区数据的所有自定义位置的信息。当 Hive 对分区数据使用非默认位置、使用 HCatalog 连接器访问该数据，架构使用 CREATE HCATALOG SCHEMA 语句设置 CUSTOM_PARTITIONS 参数时适用。

特权

不需要显式权限；但是，用户只会看到与他们有权访问的架构对应的记录。

8.2.42 - HOST_RESOURCES

提供节点的快照。对于使用自动化工具或脚本定期轮询节点很有用。

示例

=> SELECT * FROM HOST_RESOURCES;
-[ RECORD 1 ]------------------+------------------------------------------
host_name                      | 10.20.100.247
open_files_limit               | 65536
threads_limit                  | 3833
core_file_limit_max_size_bytes | 0
processor_count                | 2
processor_core_count           | 2
processor_description          | Intel(R) Xeon(R) CPU E5-2695 v2 @ 2.40GHz
opened_file_count              | 8
opened_socket_count            | 15
opened_nonfile_nonsocket_count | 7
total_memory_bytes             | 4018823168
total_memory_free_bytes        | 126550016
total_buffer_memory_bytes      | 191803392
total_memory_cache_bytes       | 2418753536
total_swap_memory_bytes        | 2147479552
total_swap_memory_free_bytes   | 2145771520
disk_space_free_mb             | 18238
disk_space_used_mb             | 30013
disk_space_total_mb            | 48251
-[ RECORD 2 ]------------------+------------------------------------------
host_name                      | 10.20.100.248
open_files_limit               | 65536
threads_limit                  | 3833
core_file_limit_max_size_bytes | 0
processor_count                | 2
processor_core_count           | 2
processor_description          | Intel(R) Xeon(R) CPU E5-2695 v2 @ 2.40GHz
opened_file_count              | 8
opened_socket_count            | 9
opened_nonfile_nonsocket_count | 7
total_memory_bytes             | 4018823168
total_memory_free_bytes        | 356466688
total_buffer_memory_bytes      | 327278592
total_memory_cache_bytes       | 2744279040
total_swap_memory_bytes        | 2147479552
total_swap_memory_free_bytes   | 2147479552
disk_space_free_mb             | 37102
disk_space_used_mb             | 11149
disk_space_total_mb            | 48251
-[ RECORD 3 ]------------------+------------------------------------------
host_name                      | 10.20.100.249
open_files_limit               | 65536
threads_limit                  | 3833
core_file_limit_max_size_bytes | 0
processor_count                | 2
processor_core_count           | 2
processor_description          | Intel(R) Xeon(R) CPU E5-2695 v2 @ 2.40GHz
opened_file_count              | 8
opened_socket_count            | 9
opened_nonfile_nonsocket_count | 7
total_memory_bytes             | 4018823168
total_memory_free_bytes        | 241610752
total_buffer_memory_bytes      | 309395456
total_memory_cache_bytes       | 2881675264
total_swap_memory_bytes        | 2147479552
total_swap_memory_free_bytes   | 2147479552
disk_space_free_mb             | 37430
disk_space_used_mb             | 10821
disk_space_total_mb            | 48251

8.2.43 - IO_USAGE

提供系统的磁盘 I/O 带宽使用历史记录。

特权

超级用户

8.2.44 - LDAP_LINK_DRYRUN_EVENTS

从 LDAP 试运行元函数收集结果：

有关使用这些元函数的详细说明，请参阅 使用试运行元函数配置 LDAP Link。

8.2.45 - LDAP_LINK_EVENTS

监控 LDAP 链接同步期间发生的事件。

8.2.46 - LOAD_SOURCES

与 LOAD_STREAMS 一样，监控每个节点的活动和历史加载指标。LOAD_SOURCES 表按源和部分对信息进行细分。此表中仅针对分析或运行时间超过一秒的 COPY 操作显示对应的行。LOAD_SOURCES 不记录来自 ORC 文件、Parquet 文件或 COPY LOCAL 的加载信息。

当开始加载源或部分时，会在此表中添加一行。加载操作期间，与加载进度相关的列值会随之更新。

唯一标识加载源的列（各种 ID 和名称列）和 IS_EXECUTING 列始终包含非 NULL 值。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.47 - LOAD_STREAMS

监控加载流的加载指标（包括当前指标和历史指标）。这将帮助统计上一批加载过程中有多少记录被成功加载和被拒绝加载。 Vertica 将维护系统表指标直到其达到指定的大小配额（以 KB 计）。配额是通过内部进程设置的，不能直接设置或查看。

特权

如果您具有 SYSMONITOR 角色或作为 dbadmin 用户，则此表显示所有加载。否则，只显示您的加载。

8.2.48 - LOCK_USAGE

提供关于锁定请求，释放，尝试的聚合信息，例如等待时间/计数和保持时间/计数。Vertica 记录：

  • 锁定过程结束时的锁定尝试。

  • 锁定尝试释放收的锁定释放。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

8.2.49 - LOCKS

监控所有节点给与锁定和请求锁定。没有结果显示的表则代表目前没有锁定。

另请参阅

8.2.50 - LOGIN_FAILURES

系统表记录了每一次失败的登录尝试。该信息帮助判断用户是否无法进入数据库或无法确认可能的入侵。

特权

超级用户

8.2.51 - MEMORY_EVENTS

记录与 Vertica 内存利用率相关的事件。

特权

无

示例

=> SELECT * FROM MEMORY_EVENTS;
-[ RECORD 1 ]-+-----------------------------------------------------------------
event_time    | 2019-05-02 13:17:20.700892-04
node_name     | v_vmart_node0001
event_type    | MALLOC_TRIM
event_reason  | memory_trim()
event_details | pre-trim RSS 378822656 post-trim RSS 372129792 benefit 0.0176675
duration_us   | 7724

8.2.52 - MEMORY_USAGE

记录内存利用率的系统资源历史记录。对于比较 Vertica 使用的内存与整个系统使用的内存很有用。

特权

超级用户

8.2.53 - MERGEOUT_PROFILES

返回自动合并操作的信息和状态。

此表不包括 REQUEST_TYPE 为 NO_WORK 的操作，也不包括 user-invoked mergeout 函数的操作，如 DO_TM_TASK。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

以下语句返回表 public.store_orders 的合并失败操作。

=> SELECT node_name, schema_name, table_name, request_type, event_type FROM mergeout_profiles WHERE event_type='ERROR';
    node_name     | schema_name |  table_name  | request_type | event_type
------------------+-------------+--------------+--------------+------------
 v_vmart_node0002 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0002 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0001 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0001 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0003 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0003 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0003 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0002 | public      | store_orders | MERGEOUT     | ERROR
 v_vmart_node0001 | public      | store_orders | MERGEOUT     | ERROR
 (9 rows)

另请参阅

8.2.54 - MONITORING_EVENTS

如果根本原因未得到解决，则报告可能影响数据库性能和功能的重要事件。

有关详细信息，请参阅监控事件。

特权

超级用户

另请参阅

ACTIVE_EVENTS

8.2.55 - NETWORK_INTERFACES

提供关于所有 Vertica 节点的网络接口的信息。

特权

无

示例

=> \x
Expanded display is on.
=> SELECT * FROM network_interfaces ORDER BY node_name ASC LIMIT 14;
-[ RECORD 1 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | lo
ip_address_family | ipv6
ip_address        | ::1
subnet            | ::1
mask              | ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
broadcast_address |
-[ RECORD 2 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | ens192
ip_address_family | ipv6
ip_address        | fd9b:1fcc:1dc4:78d3::31
subnet            | fd9b:1fcc:1dc4:78d3::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |
-[ RECORD 3 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | lo
ip_address_family | ipv4
ip_address        | 127.0.0.1
subnet            | 127.0.0.0
mask              | 255.0.0.0
broadcast_address | 127.0.0.1
-[ RECORD 4 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | ens192
ip_address_family | ipv4
ip_address        | 192.168.111.31
subnet            | 192.168.111.0
mask              | 255.255.255.0
broadcast_address | 192.168.111.255
-[ RECORD 5 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | ens32
ip_address_family | ipv4
ip_address        | 10.20.110.21
subnet            | 10.20.110.0
mask              | 255.255.255.0
broadcast_address | 10.20.110.255
-[ RECORD 6 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | ens32
ip_address_family | ipv6
ip_address        | fe80::250:56ff:fe8e:61d3
subnet            | fe80::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |
-[ RECORD 7 ]-----+----------------------------------------
node_id           | 45035996273704982
node_name         | v_verticadb_node0001
interface         | ens192
ip_address_family | ipv6
ip_address        | fe80::250:56ff:fe8e:2721
subnet            | fe80::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |
-[ RECORD 8 ]-----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | lo
ip_address_family | ipv6
ip_address        | ::1
subnet            | ::1
mask              | ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
broadcast_address |
-[ RECORD 9 ]-----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | ens192
ip_address_family | ipv6
ip_address        | fd9b:1fcc:1dc4:78d3::32
subnet            | fd9b:1fcc:1dc4:78d3::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |
-[ RECORD 10 ]----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | lo
ip_address_family | ipv4
ip_address        | 127.0.0.1
subnet            | 127.0.0.0
mask              | 255.0.0.0
broadcast_address | 127.0.0.1
-[ RECORD 11 ]----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | ens192
ip_address_family | ipv4
ip_address        | 192.168.111.32
subnet            | 192.168.111.0
mask              | 255.255.255.0
broadcast_address | 192.168.111.255
-[ RECORD 12 ]----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | ens32
ip_address_family | ipv4
ip_address        | 10.20.110.22
subnet            | 10.20.110.0
mask              | 255.255.255.0
broadcast_address | 10.20.110.255
-[ RECORD 13 ]----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | ens32
ip_address_family | ipv6
ip_address        | fe80::250:56ff:fe8e:1787
subnet            | fe80::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |
-[ RECORD 14 ]----+----------------------------------------
node_id           | 45035996273841968
node_name         | v_verticadb_node0002
interface         | ens192
ip_address_family | ipv6
ip_address        | fe80::250:56ff:fe8e:2c9c
subnet            | fe80::
mask              | ffff:ffff:ffff:ffff::
broadcast_address |

8.2.56 - NETWORK_USAGE

提供系统的网络带宽使用历史记录。对于确定 Vertica 是否使用大部分可用网络带宽很有用。

特权

超级用户

8.2.57 - NODE_EVICTIONS

监控系统节点逐出。

8.2.58 - NODE_RESOURCES

提供节点的快照。对于使用自动化工具或脚本定期轮询节点很有用。

8.2.59 - NODE_STATES

监控系统的节点恢复状态更改历史记录。Vertica 仅返回关于当前状态为 UP 的节点的信息。要确定哪些节点未运行，请查询 NODES 表。

以下流程图详细描绘了不同的节点状态：

特权

无

8.2.60 - NOTIFIER_ERRORS

notifiers 遇到的报告错误。

特权

超级用户

8.2.61 - OUTPUT_DEPLOYMENT_STATUS

包含关于设计中所有投影的配置状态信息。每行包含关于不同投影的信息。当您通过运行函数 DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY 部署数据库设计时，Vertica 将填充此表。

8.2.62 - OUTPUT_EVENT_HISTORY

包含关于 Database Designer 设计并优化您的数据库设计的每个阶段的信息。

示例

以下示例显示了优化 VMart 示例数据库时 Database Designer 进行的步骤：

=> SELECT DESIGNER_CREATE_DESIGN('VMART_DESIGN');
=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN','public.*');
=> SELECT DESIGNER_ADD_DESIGN_QUERIES('VMART_DESIGN','/tmp/examples/vmart_queries.sql',);
...
=> \x
Expanded display is on.
=> SELECT * FROM OUTPUT_EVENT_HISTORY;
-[ RECORD 1 ] -----------+----------------------------
time_stamp               | 2013-06-05 11:44:41.588
design_id                | 45035996273705090
design_name              | VMART_DESIGN
stage_type               | Design in progress
iteration_number         |
total_query_count        |
remaining_query_count    |
max_step_number          |
current_step_number      |
current_step_description | Design with deployment started
table id                 |
-[ RECORD 2 ] -----------+----------------------------
time_stamp               | 2013-06-05 11:44:41.611
design_id                | 45035996273705090
design_name              | VMART_DESIGN
stage_type               | Design in progress
iteration_number         |
total_query_count        |
remaining_query_count    |
max_step_number          |
current_step_number      |
current_step_description | Design in progress: Analyze statistics phase
table id                 |
-[ RECORD 3 ] -----------+----------------------------
time_stamp               | 2013-06-05 11:44:42.011
design_id                | 45035996273705090
design_name              | VMART_DESIGN
stage_type               | Analyzing statistics
iteration_number         |
total_query_count        |
remaining_query_count    |
max_step_number          | 15
current_step_number      | 1
current_step_description | public.customer_dimension
table id                 |
...
-[ RECORD 20 ] ----------+----------------------------
time_stamp               | 2013-06-05 11:44:49.324
design_id                | 45035996273705090
design_name              | VMART_DESIGN
stage_type               | Optimizing query performance
iteration_number         | 1
total_query_count        | 9
remaining_query_count    | 9
max_step_number          | 7
current_step_number      | 1
current_step_description | Extracting interesting columns
table id                 |
...
-[ RECORD 62 ] ----------+----------------------------
time_stamp               | 2013-06-05 11:51:23.790
design_id                | 45035996273705090
design_name              | VMART_DESIGN
stage_type               | Deployment in progress
iteration_number         |
total_query_count        |
remaining_query_count    |
max_step_number          |
current_step_number      |
current_step_description | Deployment completed successfully
table id                 |

8.2.63 - PARTITION_COLUMNS

对于分区表的每个投影，显示以下信息：

  • 每个节点的每列使用的磁盘空间。

  • 收集的分区列统计信息

磁盘使用情况

DISK_SPACE_BYTES 列显示分区数据使用的磁盘空间量，包括已删除数据。因此，如果删除行但未清除行，则 DELETED_ROW_COUNT 列会更改以显示每一列已删除的行数；但是，DISK_SPACE_BYTES 保持不变。清除已删除的行后，Vertica 会回收磁盘空间：DISK_SPACE_BYTES 相应更改，DELETED_ROW_COUNT 重置为 0。

对于分组分区，PARTITION_COLUMNS 显示每个分组分区每一列使用的累计磁盘空间。GROUPED_PARTITION_KEY 列（如果不为 NULL）标识给定列分组所属的分区。

统计信息

STATISTICS_TYPE 始终显示关于给定列的最完整的可用统计信息类型，而不考虑时间戳。例如，如果您收集表的所有级别（表、分区和行）的统计信息，则 STATISTICS_TYPE 设置为 FULL（表级别），即使最近收集了分区级别和行级别的统计信息也不例外。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

给定下表定义：

=> CREATE TABLE messages
(
    time_interval timestamp NOT NULL,
    thread_id varchar(32) NOT NULL,
    unique_id varchar(53) NOT NULL,
    msg_id varchar(65),
    ...
    )
PARTITION BY ((messages.time_interval)::date);

对 partition_columns 运行查询可能返回以下（已截断）结果：

=> SELECT * FROM partition_columns order by table_name, column_name;
column_name | column_id | table_name | projection_name | projection_id     | node_name        | partition_key | grouped_partition_key  | row_count | deleted_row_count | disk_space_bytes
---------------------------+----------+----------------+-------------------+------------------+---------------+------------------------+-----------+-------------------+------------------
msg_id | 45035996273743190 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-03    |                        | 6147      | 0                 | 41145
msg_id | 45035996273743190 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-15    |                        | 178       | 0                 | 65
msg_id | 45035996273743190 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-03    |                        | 6782      | 0                 | 45107
msg_id | 45035996273743190 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-04    |                        | 866       | 0                 | 5883
...

thread_id | 45035996273743186 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-03 |                        | 6147      | 0                 | 70565
thread_id | 45035996273743186 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-15 |                        | 178       | 0                 | 2429
thread_id | 45035996273743186 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-03 |                        | 6782      | 0                 | 77730
thread_id | 45035996273743186 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-04 |                        | 866       | 0                 | 10317
...

time_interval | 45035996273743184 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-03 |                    | 6147      | 0                 | 6320
time_interval | 45035996273743184 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-15 |                    | 178       | 0                 | 265
time_interval | 45035996273743184 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-03 |                    | 6782      | 0                 | 6967
time_interval | 45035996273743184 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-04 |                    | 866       | 0                 | 892
...

unique_id | 45035996273743188 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-03 |                        | 6147      | 0                 | 70747
unique_id | 45035996273743188 | messages | messages_super | 45035996273743182 | v_vmart_node0002 | 2010-07-15 |                        | 178       | 0                 | 2460
unique_id | 45035996273743188 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-03 |                        | 6782      | 0                 | 77959
unique_id | 45035996273743188 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-04 |                        | 866       | 0                 | 10332
unique_id | 45035996273743188 | messages | messages_super | 45035996273743182 | v_vmart_node0003 | 2010-07-15 |                        | 184       | 0                 | 2549
...

(11747 rows)

8.2.64 - PARTITION_REORGANIZE_ERRORS

监控所有背景分区任务，如果 Vertica 发生错误，则在此表中创建条目并记录相关信息。不记录成功完成的重新分区任务。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.65 - PARTITION_STATUS

对于每个分区表的每个投影，显示根据当前分区表达式实际进行分区的数据部分。更改表分区时，每个投影的 PARTITION_REORGANIZE_PERCENT 值会先降为零，并在所有数据重新分区后恢复到 100。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.66 - PARTITIONS

显示分区元数据，每个 ROS 容器、每个分区键一行。

注意

  • 多对多关系存在于分区与 ROS 容器。PARTITIONS 以非标准化方式现实信息。

  • 聚合 partition_key 列中的 PARTITIONS 以查询包含特定分区的 ROS 容器数量。

  • 聚合 ros_id 列中的 PARTITIONS 以查询 ROS 容器中存储的分区数量。

示例

请参阅查看分区存储数据。

8.2.67 - PROCESS_SIGNALS

返回 Vertica 进程接收和处理的信号的历史记录。有关信号的详细信息，请参阅 Linux 文档。

特权

超级用户

8.2.68 - PROJECTION_RECOVERIES

保留投影恢复的历史记录。由于 Vertica 在每个恢复计划添加了一个条目，投影/节点对会在输出中出现多次。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

RECOVERY_STATUS

8.2.69 - PROJECTION_REFRESHES

系统表 PROJECTION_REFRESHES 记录刷新操作成功和失败的相关信息。PROJECTION_REFRESHES 将保留投影刷新数据，直到出现以下事件之一为止：

  • 给定的投影中开始出现另一个刷新操作。

  • CLEAR_PROJECTION_REFRESHES PROJECTION_REFRESHES 被调用并清除所有投影的数据。

  • 已超出表的存储配额。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.70 - PROJECTION_STORAGE

监控每个节点上每个投影所用的磁盘存储量。

另请参阅

8.2.71 - PROJECTION_USAGE

记录关于 Vertica 在每个已处理查询中使用的投影的信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.72 - QUERY_CONSUMPTION

概述单个查询的执行情况。STATEMENT_ID 和 TRANSACTION_ID 列可组合成为这些查询的唯一键。例外情况：具有多个计划的查询包含尽可能多的记录。

8.2.73 - QUERY_EVENTS

返回关于查询计划、优化和执行事件的信息。

信息事件类型

警告事件类型

查看以下事件类型和建议操作：

严重事件类型

查看以下事件类型，并根据建议解决问题：

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

8.2.74 - QUERY_METRICS

监控每个节点上运行的会话和查询。

8.2.75 - QUERY_PLAN_PROFILES

提供系统中当前正在运行的查询的详细执行状态。该表的输出显示了实时数据流以及每个查询计划中的每个路径使用的时间和资源。

特权

非超级用户只能查看其有权查看的表记录。

最佳实践

表结果可能非常宽。为了在查询 QUERY_PLAN_PROFILES 时获得最佳结果，请对以下列排序：

  • TRANSACTION_ID

  • STATEMENT_ID

  • PATH_ID

  • PATH_LINE_INDEX

例如：

=> SELECT ... FROM query_plan_profiles
     WHERE ...
    ORDER BY transaction_id, statement_id, path_id, path_line_index;

示例

请参阅 分析查询计划

另请参阅

8.2.76 - QUERY_PROFILES

提供关于已执行的查询的信息。

8.2.77 - QUERY_REQUESTS

返回关于用户发出的查询请求的信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

QUERY_PROFILES

8.2.78 - REBALANCE_OPERATIONS

包含关于历史和当前重新平衡操作的信息。

特权

超级用户

8.2.79 - REBALANCE_PROJECTION_STATUS

维护关于相关投影的重新平衡进度的历史记录。

特权

超级用户

另请参阅

8.2.80 - REBALANCE_TABLE_STATUS

维护关于相关表的重新平衡进度的历史记录。

特权

超级用户

另请参阅

8.2.81 - RECOVERY_STATUS

提供恢复操作的状态，每个节点返回一行。

特权

无

另请参阅

PROJECTION_RECOVERIES

8.2.82 - REMOTE_REPLICATION_STATUS

为备用群集提供复制任务的状态。

特权

无

8.2.83 - REPARENTED_ON_DROP

列出从原始所有者删除但仍保留在 Vertica 中的对象的重定父级事件。例如，用户可能会离开组织，需要从数据库中将其移除。当数据库管理员从数据库删除用户时，会将该用户的对象重新分配给另一个用户。

在某些情况下，根据 GlobalHeirUsername 参数重新分配 Vertica 用户的对象。在这种情况下，会将用户的对象重新分配给此参数所指示的用户。

8.2.84 - RESOURCE_ACQUISITIONS

保留每个运行请求所获取的资源（内存、打开的文件句柄、线程）的相关信息。每个请求均通过其在给定会话中的事务和语句 ID 进行唯一标识。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

队列等待时间

您可以从 ACQUISITION_TIMESTAMP 中减去 QUEUE_ENTRY_TIMESTAMP，计算资源池开始执行给定请求之前的排队时间。例如：

 => SELECT pool_name, queue_entry_timestamp, acquisition_timestamp,
    (acquisition_timestamp-queue_entry_timestamp) AS 'queue wait'
    FROM V_MONITOR.RESOURCE_ACQUISITIONS WHERE node_name ILIKE '%node0001';

另请参阅

8.2.85 - RESOURCE_POOL_MOVE

显示每个节点上的级联事件信息。

另请参阅

8.2.86 - RESOURCE_POOL_STATUS

提供每个节点的内置和用户定义的资源池的当前状态。信息包括：

  • 当前内存利用率

  • 各种请求所请求和获取的资源

  • 执行的查询数

有关资源池的常规信息，请参阅 资源池架构。

示例

以下查询返回显示三个用户定义资源池的 CPU 分配的位掩码。资源池 bigqueries 对 CPU 0 运行查询，ceo_pool 对 CPU 1 运行查询，testrp 对 CPU 0 和 1 运行查询：

 => SELECT pool_name, node_name, cpu_affinity_set, cpu_affinity_mode,
      TO_BITSTRING(CPU_AFFINITY_MASK::VARBINARY) "CPU Affinity Mask"
      FROM resource_pool_status WHERE IS_INTERNAL = 'false' order by pool_name, node_name;
 pool_name  |    node_name     | cpu_affinity_set | cpu_affinity_mode | CPU Affinity Mask
------------+------------------+------------------+-------------------+-------------------
 bigqueries | v_vmart_node0001 | 0                | SHARED            | 00110001
 bigqueries | v_vmart_node0002 | 0                | SHARED            | 00110001
 bigqueries | v_vmart_node0003 | 0                | SHARED            | 00110001
 ceo_pool   | v_vmart_node0001 | 1                | SHARED            | 00110010
 ceo_pool   | v_vmart_node0002 | 1                | SHARED            | 00110010
 ceo_pool   | v_vmart_node0003 | 1                | SHARED            | 00110010
 testrp     | v_vmart_node0001 | 0-1              | SHARED            | 00110011
 testrp     | v_vmart_node0002 | 0-1              | SHARED            | 00110011
 testrp     | v_vmart_node0003 | 0-1              | SHARED            | 00110011
(9 rows)

另请参阅

8.2.87 - RESOURCE_QUEUES

提供关于正在等待的各种资源池请求的信息。

另请参阅

8.2.88 - RESOURCE_REJECTION_DETAILS

为 Vertica 拒绝的每个资源请求记录一个条目。这对于确定是否存在资源空间问题以及哪些用户/资源池遇到问题很有用。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

RESOURCE_REJECTIONS

8.2.89 - RESOURCE_REJECTIONS

监控 资源管理器所拒绝的资源请求。信息仅在节点正常运行时有效，节点重启时这些计数器将重置为 0。

示例

=> SELECT node_name, pool_name, reason, resource_type, rejection_count AS count, last_rejected_value AS value FROM resource_rejections;
    node_name     | pool_name |           reason            | resource_type | count |  value
------------------+-----------+-----------------------------+---------------+-------+---------
 v_vmart_node0001 | sysquery  | Request exceeded high limit | Memory(KB)    |     1 | 8248449
(1 row)

另请参阅

8.2.90 - RESOURCE_USAGE

监控每个节点的系统资源管理。

8.2.91 - SESSION_MARS_STORE

显示多个活动结果集 (MARS) 的存储信息。

8.2.92 - SESSION_PARAMETERS

提供关于为当前会话设置的用户定义参数 (UDPARAMETERS) 的信息。

另请参阅

8.2.93 - SESSION_PROFILES

提供基本会话参数和锁定超时数据。要获取有关会话的信息，请参阅 对数据库性能执行分析。

另请参阅

LOCKS

8.2.94 - SESSIONS

监控外部会话。使用此表执行以下任务：

  • 识别运行耗时查询的用户。

  • 识别因空闲且未提交的事务持有锁的用户。

  • 确定用于特定会话的数据库安全性的详细信息，即安全套接字层 (SSL) 或客户端身份验证。

  • 识别特定于客户端的信息，例如客户端版本。

特权

超级用户可以无限制访问所有会话信息。用户只能访问有关自身的当前会话的信息。

另请参阅

8.2.95 - SPREAD_STATE

列出群集中所有节点的 Spread 守护程序设置。

示例

=> SELECT * FROM V_MONITOR.SPREAD_STATE;
    node_name     | token_timeout
------------------+---------------
 v_vmart_node0003 |          8000
 v_vmart_node0001 |          8000
 v_vmart_node0002 |          8000
(3 rows)

另请参阅

8.2.96 - STORAGE_BUNDLE_INFO_STATISTICS

指示哪些投影的数据库编录中具有包含无效捆绑元数据的存储容器。如果任何 ROS 或 DV 容器包含无效捆绑元数据字段，Vertica 会在对应的列（ros_without_bundle_info_count 或 dv_ros_without_bundle_info_count）增加一个数值。

要使用有效捆绑元数据更新编录，请调用 UPDATE_STORAGE_CATALOG，作为 Vertica 元函数 DO_TM_TASK 的实参。有关详细信息，请参阅将捆绑包元数据写入编录。

8.2.97 - STORAGE_CONTAINERS

监控有关 Vertica 存储容器的信息。

* 为提高查询性能而缓存的列值

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

以下查询标识在运行 RESHARD_DATABASE 后仍未根据新分片分段边界重新对齐的任何存储容器：

=> SELECT COUNT(*) FROM storage_containers WHERE original_segment_lower_bound IS NOT NULL AND original_segment_upper_bound IS NOT NULL;

8.2.98 - STORAGE_POLICIES

监控对一个或更多数据库对象有效的当前存储策略。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

8.2.99 - STORAGE_TIERS

提供所有群集节点上带相同标签的所有存储位置的信息。此表列出用于所有同名标签位置的数据总计。

系统表显示群集上存在哪些标记位置，以及有关这些位置的群集范围内数据。

特权

无

另请参阅

8.2.100 - STORAGE_USAGE

提供有关文件系统存储使用率的信息。这对于确定磁盘空间使用趋势很有用。

特权

超级用户

另请参阅

8.2.101 - STRATA

包含 Tuple Mover 如何结合每个投影中的 ROS 容器、按层次分解及按尺寸和分区归类 ROS 容器的内部细节。相关 STRATA_STRUCTURES 表提供层次值摘要。

合并 描述了 Tuple Mover 如何结合 ROS 容器。

8.2.102 - STRATA_STRUCTURES

此表提供有关 Tuple Mover 内部细节的概述。它概述了 ROS 容器如何按尺寸归类。有关更详细信息，请查看 STRATA 虚拟表。

示例


=> \pset expanded
Expanded display is on.
=> SELECT node_name, schema_name, projection_name, strata_count,
            stratum_capacity, stratum_height, active_strata_count
            FROM strata_structures WHERE stratum_capacity > 60;
-[ RECORD 1 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0001
schema_name         | public
projection_name     | shipping_dimension_DBD_22_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 2 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0001
schema_name         | public
projection_name     | shipping_dimension_DBD_23_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 3 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0002
schema_name         | public
projection_name     | shipping_dimension_DBD_22_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 4 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0002
schema_name         | public
projection_name     | shipping_dimension_DBD_23_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 5 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0003
schema_name         | public
projection_name     | shipping_dimension_DBD_22_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 6 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0003
schema_name         | public
projection_name     | shipping_dimension_DBD_23_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 7 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0004
schema_name         | public
projection_name     | shipping_dimension_DBD_22_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1
-[ RECORD 8 ]-------+--------------------------------------------------------
node_name           | v_vmartdb_node0004
schema_name         | public
projection_name     | shipping_dimension_DBD_23_seg_vmart_design_vmart_design
strata_count        | 4
stratum_capacity    | 62
stratum_height      | 25.6511590887058
active_strata_count | 1

8.2.103 - SYSTEM

监控数据库的总体状态。

8.2.104 - SYSTEM_RESOURCE_USAGE

提供系统资源（例如内存、CPU、网络、磁盘、I/O）的历史记录。

特权

超级用户

8.2.105 - SYSTEM_SERVICES

提供有关工作负载分析器监控的后台系统服务的信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

8.2.106 - SYSTEM_SESSIONS

按系统任务提供有关系统内部会话历史记录信息。

特权

超级用户

8.2.107 - TABLE_RECOVERIES

提供有关按表恢复期间已恢复或正恢复表格的详细信息。

特权

无

示例

=> SELECT * FROM TABLE_RECOVERIES;
-[RECORD 1]----------------------------------
node_name        | node04
table_oid        | 45035996273708000
table_name       | public.t
status           | recovered
phase            | current replay delete
thread_id        | 7f7a817fd700
start_time       | 2017-12-13 08:47:28.825085-05
end_time         | 2017-12-13 08:47:29.216571-05
recover_priority | -9223372036854775807
recover_error    | Event apply failed
is_historical    | t
-[RECORD 2]--------------------------------------
node_name        | v_test_parquet_ha_node0011
table_oid        | 45035996273937680
table_name       | public.t2_impala230_uncompre_multi_file_libhdfs_1
status           | error-retry
phase            | historical
thread_id        | 7f89a574f700
start_time       | 2018-02-24 11:30:59.008831-05
end_time         | 2018-02-24 11:33:09.780798-05
recover_priority | -9223372036854775807
recover_error    | Could not stop all dirty transactions[txnId = 45035996273718426; ]
is_historical    | t

8.2.108 - TABLE_RECOVERY_STATUS

提供按表恢复期间的节点恢复信息。

特权

无

示例

=> SELECT * FROM TABLE_RECOVERY_STATUS;
-[ RECORD 1 ]------------+-----------------
node_name                | v_vmart_node0001
node_recovery_start_time |
recover_epoch            |
recovering_table_name    |
tables_remain            | 0
is_running               | f
-[ RECORD 2 ]------------+-----------------
node_name                | v_vmart_node0002
node_recovery_start_time |
recover_epoch            |
recovering_table_name    |
tables_remain            | 0
is_running               | f
-[ RECORD 3 ]------------+-----------------
node_name                | v_vmart_node0003
node_recovery_start_time | 2017-12-13 08:47:28.282377-05
recover_epoch            | 23
recovering_table_name    | user_table
tables_remain            | 5
is_running               | y

8.2.109 - TABLE_STATISTICS

显示收集的表及其各自分区的统计信息。

8.2.110 - TLS_CONFIGURATIONS

列出服务器、LDAP 等的 TLS CONFIGURATION 对象的设置。

示例

在此示例中，LDAPAuth TLS CONFIGURATION 使用两个 CA 证书：

=> SELECT * FROM tls_configurations WHERE name='LDAPAuth';
    name   |  owner  | certificate | ca_certificate | cipher_suites |  mode
----------+---------+-------------+----------------+---------------+---------
 LDAPAuth | dbadmin | server_cert | ca             |               | DISABLE
 LDAPAuth | dbadmin | server_cert | ica            |               | DISABLE
(2 rows)

为了更清晰地展示 TLS CONFIGURATION 与其 CA 证书之间的关系，您可以使用 LISTAGG 设置查询格式：

=> SELECT name, owner, certificate, LISTAGG(ca_certificate) AS ca_certificates, cipher_suites, mode
FROM tls_configurations
WHERE name='LDAPAuth'
GROUP BY name, owner, certificate, cipher_suites, mode
ORDER BY 1;
   name   |  owner  | certificate | ca_certificates | cipher_suites |  mode
----------+---------+-------------+-----------------+---------------+---------
 LDAPAuth | dbadmin | server_cert | ca,ica          |               | DISABLE
(1 row)

8.2.111 - TRANSACTIONS

记录每个事务的详细信息。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅

事务

8.2.112 - TRUNCATED_SCHEMATA

列出已还原架构的原始名称，这些名称因为长度超出 128字符而被截断。

特权

无

8.2.113 - TUNING_RECOMMENDATIONS

返回上次调用 ANALYZE_WORKLOAD 产生的优化建议结果。此信息对在工作负载分析器结果集上构建筛选器很有用。

特权

超级用户

示例

请参阅 ANALYZE_WORKLOAD。

另请参阅

8.2.114 - TUPLE_MOVER_OPERATIONS

监控每个节点的 Tuple Mover 操作的状态。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

示例

=> SELECT node_name, operation_status, projection_name, plan_type
    FROM TUPLE_MOVER_OPERATIONS;
 node_name         | operation_status | projection_name  | plan_type
-------------------+------------------+------------------+-----------
 v_vmart_node0001  | Running          | p1_b2            | Mergeout
 v_vmart_node0002  | Running          | p1               | Mergeout
 v_vmart_node0001  | Running          | p1_b2            | Replay Delete
 v_vmart_node0001  | Running          | p1_b2            | Mergeout
 v_vmart_node0002  | Running          | p1_b2            | Mergeout
 v_vmart_node0001  | Running          | p1_b2            | Replay Delete
 v_vmart_node0002  | Running          | p1               | Mergeout
 v_vmart_node0003  | Running          | p1_b2            | Replay Delete
 v_vmart_node0001  | Running          | p1               | Mergeout
 v_vmart_node0002  | Running          | p1_b1            | Mergeout

另请参阅

8.2.115 - UDFS_EVENTS

记录涉及 S3、HDFS、GCS 和 Azure 文件系统的事件的信息。

\* TRANSACTION_ID、STATEMENT_ID 和 REQUEST_ID 组合可以唯一标识给定会话中的事件。

特权

超级用户

8.2.116 - UDFS_OPS_PER_HOUR

此表概述了 S3 文件系统每小时的统计信息。

示例

=> \x
Expanded display is on.
=> SELECT * FROM UDFS_OPS_PER_HOUR;
-[ RECORD 1 ]-------------+--------------------
node_name                 | e1
filesystem                | S3
start_time                | 2018-04-06 04:00:00
end_time                  | 2018-04-06 04:00:00
avg_operations_per_second | 0
avg_errors_per_second     | 0
retries                   | 0
metadata_reads            | 0
metadata_writes           | 0
data_reads                | 0
data_writes               | 0
upstream_bytes            | 0
downstream_bytes          | 0
...

另请参阅

UDFS_OPS_PER_MINUTE

8.2.117 - UDFS_OPS_PER_MINUTE

此表概述了 S3 文件系统每分钟的统计信息。

示例

=> \x
Expanded display is on.
=> SELECT * FROM UDFS_OPS_PER_MINUTE;
-[ RECORD 1 ]-------------+--------------------
node_name                 | e1
filesystem                | S3
start_time                | 2018-04-06 04:17:00
end_time                  | 2018-04-06 04:18:00
avg_operations_per_second | 0
avg_errors_per_second     | 0
retries                   | 0
metadata_reads            | 0
metadata_writes           | 0
data_reads                | 0
data_writes               | 0
upstream_bytes            | 0
downstream_bytes          | 0
...

另请参阅

UDFS_OPS_PER_HOUR

8.2.118 - UDFS_STATISTICS

记录关于文件系统操作的聚合信息。此表记录关于 Linux、S3 和 WebHDFS 文件系统的信息，同时记录关于 Libhdfs++ 文件系统的元数据（而非数据）的信息。

一项操作可以由多个独立读取、写入或重试请求组成。SUCCESSFUL_OPERATIONS 和 FAILED_OPERATIONS 计数操作；其他计数器计算独立请求。完成一项操作后，其中一个 OPERATIONS 计数器递增一次，但其他几个计数器可能分别递增几次。

以下查询获取 Libhdfs++ 操作的元数据 RPC 总数：

=> SELECT SUM(metadata_reads) FROM UDFS_STATISTICS WHERE filesystem = 'Libhdfs++';

8.2.119 - UDX_EVENTS

记录关于因执行用户定义的扩展而引发的事件的信息。

UDx 使用 ServerInterface::logEvent() 填充 RAW 列（仅限 C++）。VMap 支持由 Flex Tables 提供，不得禁用。

8.2.120 - UDX_FENCED_PROCESSES

提供 Vertica 在隔离模式下运行用户定义的扩展时所使用的进程的相关信息。

特权

无

8.2.121 - USER_LIBRARIES

列出当前加载的用户库。这些库包含用户定义的扩展 (UDx)，用于提供额外的分析函数。

8.2.122 - USER_LIBRARY_MANIFEST

列出所有已加载用户库中包含的用户定义函数。

特权

无

8.2.123 - USER_SESSIONS

返回系统中的用户会话历史。

特权

非超级用户：不需要任何显式权限。您只会看到您有权查看的表的记录。

另请参阅