CREATE 语句

• 1: CREATE ACCESS POLICY
• 2: CREATE AUTHENTICATION
• 3: 创建 CA 捆绑包
• 4: CREATE CERTIFICATE
• 5: CREATE DIRECTED QUERY
• 6: CREATE EXTERNAL TABLE AS COPY
• 7: CREATE FAULT GROUP
• 8: CREATE FLEXIBLE TABLE
• 9: CREATE FLEXIBLE EXTERNAL TABLE AS COPY
• 10: CREATE FUNCTION 语句
• 10.1: CREATE AGGREGATE FUNCTION
• 10.2: CREATE ANALYTIC FUNCTION
• 10.3: CREATE FILTER
• 10.4: CREATE FUNCTION (SQL)
• 10.5: CREATE FUNCTION（标量）
• 10.6: CREATE PARSER
• 10.7: CREATE SOURCE
• 10.8: CREATE TRANSFORM FUNCTION
• 11: CREATE HCATALOG SCHEMA
• 12: CREATE KEY
• 13: CREATE LIBRARY
• 14: CREATE LOAD BALANCE GROUP
• 15: CREATE LOCAL TEMPORARY VIEW
• 16: CREATE LOCATION
• 17: CREATE NETWORK ADDRESS
• 18: CREATE NETWORK INTERFACE
• 19: CREATE NOTIFIER
• 20: CREATE PROCEDURE（外部）
• 21: CREATE PROCEDURE（存储）
• 22: CREATE PROFILE
• 23: CREATE PROJECTION
• 23.1: 标准投影
• 23.2: 实时聚合投影
• 23.3: Top-K 投影
• 23.4: UDTF 投影
• 23.5: 编码类型
• 23.6: GROUPED 子句
• 23.7: 哈希分段子句
• 23.8: 未分段子句
• 24: CREATE RESOURCE POOL
• 24.1: 内置池
• 24.2: 内置资源池配置
• 25: CREATE ROLE
• 26: CREATE ROUTING RULE
• 27: CREATE SCHEMA
• 28: CREATE SEQUENCE
• 29: CREATE SUBNET
• 30: CREATE TABLE
• 30.1: Column-definition
• 30.2: Column-name-list
• 30.3: Column-constraint
• 30.4: 分区子句
• 30.5: Table-constraint
• 31: CREATE TEMPORARY TABLE
• 32: CREATE TEXT INDEX
• 33: CREATE TLS CONFIGURATION
• 34: CREATE USER
• 35: CREATE VIEW

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 操作。

重要

GRANT TRUSTED 仅影响 DML 操作，并且不允许用户查看访问策略将屏蔽的数据。指定此选项可能允许具有某些授权的用户更新他们无法查看的数据。

ENABLE | DISABLE

是否启用访问策略。您可以使用 ALTER ACCESS POLICY 启用和禁用现有的访问策略。

特权

非超级用户：表的所有权

限制

访问策略具有以下限制：

• 一列只能有一个访问策略。

• 不能为除原生数组以外的复杂类型列设置列访问策略。

• 不能为　Flex 表中的实体化列设置列访问策略。可以为 __raw__ 列设置访问策略，但此举将限制对整个表的访问。

• 行访问策略对临时表和具有聚合投影的表无效。

• 访问策略表达式不能包含：

  • 子查询

  • 聚合函数

  • 分析函数

  • 用户定义的转换函数 (UDTF)

• 如果查询优化器无法使用计算值替换仅涉及常量的确定性表达式，则会阻止所有 DML 操作，例如 INSERT。

另请参阅

• 访问策略

• ALTER ACCESS POLICY

• DROP ACCESS POLICY

2 - CREATE AUTHENTICATION

创建并启用与用户或角色关联的身份验证记录。身份验证记录在创建后自动启用。

语法

CREATE AUTHENTICATION auth‑record‑name
            METHOD 'auth‑method'
            access‑method
            [ FALLTHROUGH ]

参数

特权

DBADMIN

示例

请参阅创建身份验证记录。

另请参阅

• ALTER AUTHENTICATION
• DROP AUTHENTICATION
• GRANT（身份验证）
• REVOKE（身份验证）

3 - 创建 CA 捆绑包

创建证书颁发机构 (CA) 捆绑包。这些包含根 CA 证书。

语法

CREATE CA BUNDLE name [CERTIFICATES ca_cert[, ca_cert[, ...]]

参数

name

CA 捆绑包的名称。

ca_cert

CA 证书的名称。如果未指定证书，则捆绑包将为空。

特权

CA 捆绑包中 CA 证书的所有权。

示例

请参阅管理 CA 捆绑包。

另请参阅

• ALTER CA BUNDLE
• DROP CA BUNDLE

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 证书和密钥。

另请参阅

• CREATE KEY

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 中。

另请参阅

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;

另请参阅

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 容错组。

另请参阅

• FAULT_GROUPS
• CLUSTER_LAYOUT
• 容错组
• 使用容错组的高可用性

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

另请参阅

• 创建 Flex 表
• CREATE FLEXIBLE EXTERNAL TABLE AS COPY

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)

另请参阅

• CREATE EXTERNAL TABLE AS COPY

10 - CREATE FUNCTION 语句

Vertica 为每种类型的用户定义的扩展提供 CREATE 语句。每个 CREATE 语句都会向 Vertica 编录添加一个用户定义的函数：

Vertica 还提供 CREATE FUNCTION (SQL)，它将 SQL 表达式存储为您可以在查询中调用的函数。

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                |

另请参阅

• DROP AGGREGATE FUNCTION
• USER_FUNCTIONS
• 开发用户定义的扩展 (UDx)
• 聚合函数 (UDAF)

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;

另请参阅

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                |

另请参阅

• DROP FILTER
• USER_FUNCTIONS
• 用户定义的加载 (UDL)

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 FUNCTION 仅允许一个 RETURN 表达式。Return 表达式不支持以下内容：

• FROM、WHERE、GROUP BY、ORDER BY 和 LIMIT 子句

• 聚合、分析和元函数

特权

非超级用户：

• 函数架构的 CREATE 权限

• 函数库的 USAGE 权限

严格性和可变性

Vertica 根据 SQL 函数的定义推断该函数的 严格性和可变性（ 稳定、 不可变或 易变）。然后，Vertica 确定使用是否正确，例如期待不可变函数却提供了易变函数的情况。

SQL 函数和视图

可以在使用 SQL 函数的查询中创建视图，然后查询这些视图。创建视图时，SQL 函数会将对用户定义的函数的调用替换为视图定义中的函数主体。因此，当用户定义的函数的主体被替换后，视图也应被替换。

示例

请参阅创建用户定义的 SQL 函数。

另请参阅

• ALTER FUNCTION（标量）
• DROP FUNCTION
• 用户定义的 SQL 函数

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)

另请参阅

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                |

另请参阅

• DROP PARSER
• USER_FUNCTIONS
• 用户定义的加载 (UDL)

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                |

另请参阅

• DROP SOURCE
• USER_FUNCTIONS
• 用户定义的加载 (UDL)

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 的查询不能：

• 包含调用 UDTF 和 PARTITION BY 表达式的 SELECT 语句之外的所有语句

• 调用 解析函数

• 调用另一个 UDTF

• 包括以下条款之一：

  • TIMESERIES

  • 模式匹配

  • 空白填充和插值

示例

以下示例加载了名为 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

另请参阅

• DROP FUNCTION
• 开发用户定义的扩展 (UDx)

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

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 证书和密钥。

另请参阅

• CREATE CERTIFICATE

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 软件包必须本地安装在每个节点上，包括外部依赖项。

重要

CREATE LIBRARY 的性能在 Eon 模式下会降低，这与 DEPENDS 子句指定的依赖关系的数量和深度成正比。

如果 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';

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[,...]

逗号分隔的容错组列表，用作负载均衡组的基础。

注意

在从容错组创建负载均衡组之前，您必须在负载均衡组中所需的节点上创建网络地址。负载均衡组仅适用于您在节点上定义的网络地址，而不是 IP 地址。请参阅CREATE NETWORK ADDRESS。

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)

另请参阅

• ALTER LOAD BALANCE GROUP
• ALTER NETWORK ADDRESS
• ALTER ROUTING RULE
• LOAD_BALANCE_GROUPS
• NETWORK_ADDRESSES

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)

另请参阅

• ALTER VIEW
• CREATE VIEW
• 创建视图

16 - CREATE LOCATION

创建可供 Vertica 存储数据的存储位置。创建该位置后，可以在其中存储策略，以将该存储位置分配给将在此位置存储数据的数据库对象。

语法

CREATE LOCATION 'path'
    [NODE 'node' | ALL NODES]
    [SHARED]
    [USAGE 'usage']
    [LABEL 'label']
    [LIMIT 'size']

参数

路径

存储此位置数据的位置。位置所基于的文件系统类型决定了 path 格式：

• Linux：Vertica 可以写入存储位置数据的目录的绝对路径。

• 共享文件系统：请参阅 HDFS 文件系统、S3 对象存储、Google Cloud Storage (GCS) 对象存储和 Azure Blob 存储对象存储 中的 URL 规范。

HDFS 存储位置有其他要求。

ALL NODES | NODE 'node'

在其上定义存储位置的一个或多个节点，为以下之一：

• ALL NODES （默认值）：在每个节点上创建存储位置。如果还指定了 SHARED，则创建一次存储位置以供所有节点使用。

• NODE 'node'：在单个节点上创建存储位置，其中 node 是 NODES 系统表中节点的名称。您不能将此选项与 SHARED 一起使用。

SHARED

指示 path 设置的位置被共享（为所有节点使用），而非本地于每个节点。您不能使用 SHARED 指定单个节点；您必须使用 ALL NODES。

多数远程文件系统（例如 HDFS 和 S3）都被共享。对于这些文件系统，path 实参表示远程文件系统中所有节点存储数据的单个位置。如果使用远程文件系统，您必须指定 SHARED，即使对于单节点群集也是如此。

注意

如果 path 设置为 S3 公共存储，则始终隐含 SHARED 并且可以省略。

已弃用

SHARED DATA 和 SHARED DATA,TEMP 存储位置已被弃用。

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}：以千字节、兆字节、千兆字节或太字节为单位的存储位置的磁盘大小。

重要

存储库大小不能超过其所在文件系统磁盘空间的 80%。如果指定的值太大，Vertica 会发出警告并自动将该值更改为文件系统大小的 80%。

如果未指定限制，则将其设置为 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;

另请参阅

• 管理存储位置
• 使用 HDFS 存储位置
• ALTER_LOCATION_LABEL
• ALTER_LOCATION_USE
• RETIRE_LOCATION
• SET_OBJECT_STORAGE_POLICY

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 地址。

注意

Vertica 不会验证您在此参数中提供的 IP 地址是否实际与指定节点相关联。确保 IP 地址实际上属于该节点。否则，您的负载均衡策略可能会将客户端连接发送到错误的节点或非 Vertica 主机。Vertica 拒绝对节点无效的 IP 地址。例如，它会检查 IP 地址是否在 127.0.0.0/8 的环回地址范围内。如果发现 IP 地址无效，则 CREATE NETWORK ADDRESS 返回错误。

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

另请参阅

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;

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 配置报告。

另请参阅

• ALTER NOTIFIER
• DROP NOTIFIER
• 使用通知程序监控 Vertica

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

另请参阅

• DROP PROCEDURE（外部）
• 安装外部过程可执行文件

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 的过程以该用户身份有效地执行过程，因此，对数据库的更改似乎是由过程的定义者（而不是其调用者）执行的。

当心

对 SECURITY DEFINER 使用不当会导致混淆代理问题，并在您的系统中引入 SQL 注入等漏洞。

有关详细信息，请参阅执行存储过程。

源

过程源代码。有关详细信息，请参阅范围和结构。

特权

非超级用户：对过程架构的 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 的详细信息，请参阅错误和诊断。

另请参阅

• PL/vSQL
• CALL
• DO
• DROP PROCEDURE（存储）

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;

另请参阅

• ALTER PROFILE
• DROP PROFILE
• 创建数据库名称和密码
• 配置文件

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 投影不支持复杂类型。

23.1 - 标准投影

以优化在该表上执行某些查询的格式存储表数据的集合。有关详细信息，请参阅 投影。

语法

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;

提示

Vertica 建议对大表进行分段。

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 权限

示例

请参阅：

• 分段投影
• 未分段投影
• 分区范围投影

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 不会将实时聚合投影视为 超投影，即使是包含所有表列的投影也是如此。有关其他要求和限制，请参阅创建实时聚合投影。

示例

请参阅实时聚合投影示例。

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 投影示例。

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 合并

• 在投影上执行查询

• 在执行数据加载操作时进行单个调用

重要

如果投影定义包括预传递子查询，则 batch-args 在名称和顺序上必须与预传递 UDTF 输出列完全匹配。

prepass-udtf(prepass-args)

要在执行每个加载操作（例如 COPY 或 INSERT）时调用的 预传递 UDTF。

如果在子查询中指定，则预传递 UDTF 会将转换的数据返回给批量查询，以做进一步处理。否则，预传递查询结果将添加至投影数据存储。

OVER (PARTITION { BATCH | PREPASS } BY partition-column-expr[,...]

指定 UDTF 类型以及如何对其返回的数据进行分区：

• BATCH 将 UDTF 标识为 批量 UDTF。

• PREPASS 将 UDTF 标识为 预传递 UDTF。

在两种情况下，OVER 子句会指定要借助于 SELECT 列表中的一个或多个列表达式进行分区。第一个 partition-column-expr 是 SELECT 列表中的第一个列表达式，第二个 partition-column- expr 是 SELECT 列表中的第二个列表达式，依此类推。

注意

投影在 PARTITION BY 列上隐式地分段和排序。

AS (batch-output-columns) AS (prepass-output-columns)

（可选）命名 UDTF 返回的列。

如果预传递子查询忽略此子句，则外部批量查询 UDTF 实参 (batch-args) 必须引用列名称，像它们在预传递 UDTF 中定义的那样。

table [[AS] alias]

指定投影的锚表，可选择性地由别名限定。

sq-results

返回到外部批量 UDTF 的子查询结果集。

特权

非超级用户：

• 锚表所有者

• 对架构的 CREATE 权限

• 对由投影引用的所有 UDTF 的 EXECUTE 权限

示例

请参阅 预聚合 UDTF 结果。

23.5 - 编码类型

Vertica 支持各种编码和压缩类型，由以下 ENCODING 参数实参指定：

• AUTO（默认）

• BLOCK_DICT

• BLOCKDICT_COMP

• BZIP_COMP

• COMMONDELTA_COMP

• DELTARANGE_COMP

• DELTAVAL

• GCDDELTA

• GZIP_COMP

• RLE

• Zstandard 压缩

创建投影时，您可以在投影列上设置编码类型。您还可以使用 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 时间较慢。

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;

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 无效。

重要

如果使用 OFFSET 选项为表创建投影，请确保为每个投影段创建足够的副本以满足系统 K-safety；否则，Vertica 会将投影视为不安全，且无法使用它来查询表。

通过组合使用 CREATE PROJECTION 语句中的 OFFSET 和 KSAFE 选项来创建投影，您可以确保 K-safety 合规性。执行此语句时，Vertica 会自动创建必要数量的投影副本。

表达式要求

分段表达式在指定表列时必须按照其在源表中定义的那样进行指定。不支持投影列名称。

以下限制适用于分段表达式：

• 所有叶表达式都必须为常数或 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;

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)

24 - CREATE RESOURCE POOL

创建自定义资源池并设置一个或多个资源池参数。

语法

CREATE RESOURCE POOL pool‑name [ FOR subcluster-spec ] [ parameter‑name setting ]...

参数

pool‑name

资源池的名称。内置池名称不能用于用户定义的池。

注意

如果使用大写字母指定资源池名称，Vertica 会将它们转换为小写字母。

FOR subcluster‑spec

仅限 Eon 模式，指定将此资源池与某个子群集关联，其中 subcluster-spec 为以下之一：

• SUBCLUSTER subcluster-name：为现有子群集创建资源池。您不能连接到此子群集，否则 Vertica 会返回错误。
• CURRENT SUBCLUSTER：为连接到的子群集创建资源池。

如果忽略，则在全局创建资源池。尝试创建与特定于子群集的资源池同名的全局资源池时会返回错误。

parameter‑name

要设置的参数，如下所示。

设置

要在 parameter‑name 上设置的值。要将此参数重置为其默认值，请指定 DEFAULT。

注意

此表中指定的默认值仅适用于用户定义的资源池。有关内置池的默认值，请参阅内置资源池配置，或查询系统表 RESOURCE_POOL_DEFAULTS。

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 资源，则此查询无效。

重要

CPUAFFINITYMODE CPUAFFINITYSET 必须在同一语句中一起设置。

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 上执行。

重要

CPUAFFINITYSET CPUAFFINITYMODE 必须在同一语句中一起设置。

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

另请参阅

• ALTER RESOURCE POOL
• CREATE USER
• DROP RESOURCE POOL
• SET SESSION RESOURCE_POOL
• SET SESSION MEMORYCAP
• 管理工作负载

24.1 - 内置池

Vertica 预先配置了内置池来完成各种系统任务：

• GENERAL

• BLOBDATA

• DBD

• JVM

• METADATA

• RECOVERY

• REFRESH

• SYSQUERY

• TM

有关资源池设置的详细信息，请参阅 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 池设置。

24.2 - 内置资源池配置

要查看内置资源池的当前和默认配置，请分别查询系统表 RESOURCE_POOLS 和 RESOURCE_POOL_DEFAULTS。 以下部分提供了这些信息，并指出了哪些内置池参数可以使用 ALTER RESOURCE POOL 进行修改：

• GENERAL

• BLOBDATA

• DBD

• JVM

• METADATA

• RECOVERY

• REFRESH

• SYSQUERY

• TM

GENERAL

BLOBDATA

MAXMEMORYSIZE {
'integer%'

MAXQUERYMEMORYSIZE {
'integer%'

RUNTIMECAP { 'interval' | NONE }

ALTER RESOURCE POOL general PLANNEDCONCURRENCY #cores;

DBD

JVM

METADATA

RECOVERY

MAXMEMORYSIZE {
  'integer%'

(numberCores / 2) + 1

REFRESH

SYSQUERY

TM

25 - CREATE ROLE

创建 角色。创建角色后，使用 GRANT 语句指定角色权限。

语法

CREATE ROLE role

参数

角色

新角色的名称，其中 role 符合标识符中描述的约定。

特权

超级用户

示例

此示例显示了如何创建名为 roleA 的空角色。

=> CREATE ROLE roleA;
CREATE ROLE

另请参阅

• ALTER ROLE
• DROP ROLE

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

另请参阅

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 权限

支持的子语句

CREATE SCHEMA 可以包含一个或多个子语句，例如，在新架构中创建表或投影。支持的子语句包括：

• CREATE TABLE / CREATE TEMPORARY TABLE
• GRANT 语句
• CREATE PROJECTION
• CREATE SEQUENCE
• CREATE TEXT INDEX
• CREATE VIEW

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 权限

另请参阅

• ALTER SCHEMA
• DROP SCHEMA

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。

注意

将此参数设置为 integer 时，可确保列值始终至少增加 integer。但是，列值的增量有时可能会超过 integer，但如果您还设置了 NO CACHE 参数则除外。

MINVALUE integer | NO MINVALUE

确定序列可生成的最小值。如果忽略此子句或指定 NO MINVALUE（默认值），则将使用默认值：升序序列和降序序列分别为 1 和 ‑2⁶³‑1。

MAXVALUE integer | NO MAXVALUE

确定序列的最大值。如果忽略此子句或指定 NO MAXVALUE（默认值），则将使用默认值：升序序列和降序序列分别为 2⁶³‑1 和 ‑1。

START [WITH] integer

将序列起始值设置为 integer。下一次调用 NEXTVAL 时将返回 integer。如果忽略此子句，则升序序列的起始值将设置为 MINVALUE，降序序列的起始值将设置为 MAXVALUE。

CACHE integer | NO CACHE

指定是否在每个节点上缓存唯一的序列号，以便提高访问速度。 CACHE 需要一个整数实参，如下所示：

• >1 指定每个节点在每个会话中缓存的唯一编号的数量。

  当心

  如果将序列缓存设置为较低的数字，则节点可能会更频繁地请求一组新的缓存值。提供新缓存时，Vertica 必须锁定编录。在 Vertica 释放锁之前，其他数据库活动（例如表插入）会被阻止，这将对整体性能产生不利影响。

• 0 或 1 指定禁用缓存（等同于 NO CACHE）。

如果忽略此子句，序列缓存将设置为 250,000。

有关命名序列缓存的详细信息，请参阅分发命名序列。

CYCLE | NO CYCLE

指定序列是否可以在达到其最小值或最大值时回绕：

• CYCLE：序列按如下方式进行回绕：

  • 当递增序列达到其上限时，会被重置为其最小值。

  • 当递减序列达到其下限时，会被重置为其最大值。

• NO CYCLE （默认值）：在序列达到其最大值或最小值后，调用 NEXTVAL 会返回错误。

特权

非超级用户：对架构的 CREATE 权限

示例

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

另请参阅

• ALTER SEQUENCE
• DROP SEQUENCE

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::';

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

对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：

• hash‑segmentation‑clause：指定将数据均匀分段并分布在群集节点上。Vertica 建议对大表进行分段。

• unsegmented‑clause：指定以创建未分段的投影。

如果省略此子句，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

另请参阅

• 创建表
• 复制表
• 从查询创建表
• CREATE TEMPORARY TABLE
• CREATE EXTERNAL TABLE AS COPY
• CREATE FLEXIBLE TABLE

30.1 - Column-definition

指定将应用于某一列的名称、数据类型和约束。

语法

column-name data-type
    [ column‑constraint ][...]
    [ ENCODING encoding-type ]
    [ ACCESSRANK integer ]

参数

column-name

要创建或添加的列的名称。

data-type

Vertica 支持的数据类型。

提示

在 CREATE TABLE 语句中指定最大列宽时，请对任何字符串类型使用以字节（八位字节）为单位的宽度。每个 UTF-8 字符可能需要 4 个字节，但欧洲语言的每个字符一般需要多于一个字节，而东方语言的每个字符一般需要少于三个字节。

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

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;
  

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

有关详细信息，请参阅约束强制执行。

30.4 - 分区子句

通过表定义中的 PARTITION BY 子句指定表数据的分区：

PARTITION BY partition‑expression [ GROUP BY group‑expression ] [ active‑partition‑count‑expr ]

PARTITION BY partition‑expression

对于每个表行，解析为从一个或多个表列派生的分区键。

当心

避免对 LONG VARBINARY 和 LONG VARCHAR 列上的表进行分区。这样做会对性能产生不利影响。

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 值。

  注意

  可以使用函数 ZEROIFNULL 来避免出现 null 相关错误。此函数可以检查 PARTITION BY 表达式中的 null 值并将其评估为 0。例如： CREATE TABLE t1 (a int, b int) PARTITION BY (ZEROIFNULL(a)); CREATE TABLE
• 所有叶表达式都必须为常数或表列。
• 所有其他表达式必须为函数和运算符。以下限制适用于函数： * 必须为 不可变，即在不同时间和区域设置以及其他会话 - 或特定环境条件下返回相同的值。 * 不可以为聚合函数。 * 不可以为 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 会将其合并到适当的分区中，以此根据需要创建新的分区键。

另请参阅

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。

重要

添加外键约束需要以下权限（除了 ALTER TABLE 也需要的权限外）：

• 对引用表的 REFERENCES 权限

• 对引用表架构的 USAGE 权限

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)

有关约束的一般讨论，请参阅约束。有关创建和命名约束的其他示例，请参阅对约束进行命名。

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 对以下子句无效：

• ORDER BY

• KSAFE

• 任何分段子句（hash-segmentation-clause 或 unsegmented‑clause）。

{INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES

默认继承此表的架构权限：

• INCLUDE PRIVILEGES 指定在其架构上设置的表继承权限。如果启用了架构权限继承，则这是默认行为。

• EXCLUDE PRIVILEGES 禁用从架构继承权限。

有关详细信息，请参阅继承的权限。

ORDER BY table-column[,...]

对外部表无效，指定 SELECT 列表中的列，基于该列表对为此表自动创建的超投影进行排序。ORDER BY 子句不能包含限定符 ASC 或 DESC。Vertica 始终按升序存储投影数据。

如果省略 ORDER BY 子句，Vertica 将使用 SELECT 列表顺序作为投影排序顺序。

segmentation-spec

对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：

• hash‑segmentation‑clause：指定将数据均匀分段并分布在群集节点上。Vertica 建议对大表进行分段。

• unsegmented‑clause：指定以创建未分段的投影。

如果省略此子句，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 的临时表添加投影，但需要注意的是，您可能会丢失所有数据。

• 无法对会话范围临时数据执行合并操作。

• 一般来说，使用系统（虚拟）表时，会话范围临时表数据不可见。

• 临时表不会恢复。如果某个节点发生故障，使用临时表的查询也会失败。重新启动会话并填充临时表。

• 本地临时表不能设置磁盘配额。

示例

请参阅创建临时表。

另请参阅

• ALTER TABLE
• CREATE TABLE

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)

另请参阅

• 使用文本搜索
• DROP TEXT INDEX

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 相同。

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;

另请参阅

• ALTER USER
• DROP USER

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;

另请参阅

• ALTER VIEW
• CREATE LOCAL TEMPORARY VIEW
• 创建视图
• DROP VIEW
• GRANT（视图）
• REVOKE（视图）