SQL 查询的主结构是其语句。无论语句是独立存在还是多语句查询的一部分，每个语句都必须以分号结尾。以下示例包含四个通用 SQL 语句—CREATE TABLE、INSERT、SELECT 和 COMMIT：
=> CREATE TABLE comments (id INT, comment VARCHAR);
CREATE TABLE
=> INSERT INTO comments VALUES (1, 'Hello World');
OUTPUT
--------
1
(1 row)
=> SELECT * FROM comments;
id | comment
----+-------------
1 | Hello World
(1 row)
=> COMMIT;
COMMIT
=>
ALTER 语句可用于更改现有数据库对象。
对现有访问策略执行以下操作之一：
通过更改其表达式和启用/禁用策略来修改访问策略。
将访问策略从一个表复制到另一个表。
修改策略：
ALTER ACCESS POLICY ON [[database.]schema.]table
{ FOR COLUMN column [ expression ] | FOR ROWS [ WHERE expression ] } { GRANT TRUSTED } { ENABLE | DISABLE }
复制政策：
ALTER ACCESS POLICY ON [[database.]schema.]table
{ FOR COLUMN column | FOR ROWS } COPY TO TABLE table;
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表FOR COLUMN column [expression]FOR COLUMN 子句中省略 expression，以便仅启用或禁用此策略，或将其复制到其他表中。FOR ROWS [WHERE expression]FOR ROWS 子句中省略
WHERE expression，以便仅启用或禁用此策略，或将其复制到另一个表。GRANT TRUSTED指定 GRANT 语句在确定用户是否可以对目标表执行 DML 操作时优先于访问策略。如果省略，则只有在访问策略允许用户查看原始未更改状态的存储数据时，用户才能修改表数据。有关详细信息，请参阅访问策略和 DML 操作。
ENABLE | DISABLECOPY TO TABLE tablename需要满足以下要求：
复制列访问策略：
目标表必须包含相同名称和兼容数据类型的列。
目标列不得包含访问策略。
复制行访问策略：目标表不得包含访问策略。
非超级用户：表的所有权
非超级用户：源表和目标表的所有权
请参阅 管理访问策略
修改指定身份验证方法的设置。
ALTER AUTHENTICATION auth_record {
| { ENABLE | DISABLE }
| { LOCAL | HOST [ { TLS | NO TLS } ] host_ip_address }
| RENAME TO new_auth_record_name
| METHOD value
| SET param=value[,...]
| PRIORITY value
| [ [ NO ] FALLTHROUGH ]
}
超级用户
启用和禁用身份验证方法
本示例使用 ALTER AUTHENTICATION 禁用了 v_ldap 身份验证方法，然后再次启用了它：
=> ALTER AUTHENTICATION v_ldap DISABLE;
=> ALTER AUTHENTICATION v_ldap ENABLE;
重命名身份验证方法
以下示例将 v_kerberos 身份验证方法重命名为 K5。所有被授予 v_kerberos 身份验证方法的用户现在都改为授予了 K5 方法。
=> ALTER AUTHENTICATION v_kerberos RENAME TO K5;
修改身份验证参数
本示例将 ident1 身份验证的系统用户设置为 user1：
=> CREATE AUTHENTICATION ident1 METHOD 'ident' LOCAL;
=> ALTER AUTHENTICATION ident1 SET system_users='user1';
在使用 ALTER AUTHENTICATION 设置或修改 LDAP 或 Ident 参数时，Vertica 会对这些参数进行验证。
本示例将更改 IP 地址并为名为 Ldap1. 的 LDAP 身份验证方法指定参数。为 LDAP 服务器指定捆绑参数。Vertica 将连接到对数据库客户端进行身份验证的 LDAP 服务器。如果身份验证成功，Vertica 将在指定 LDAP 服务器上对被关联到（被授予）Ldap1 身份验证方法的任何用户进行身份验证：
=> CREATE AUTHENTICATION Ldap1 METHOD 'ldap' HOST '172.16.65.196';
=> ALTER AUTHENTICATION Ldap1 SET host='ldap://172.16.65.177',
binddn_prefix='cn=', binddn_suffix=',dc=qa_domain,dc=com';
下一个示例将为名为 Ldap2 的 LDAP 身份验证方法指定参数。指定 LDAP 搜索和捆绑参数。有时 Vertica 没有足够的信息为尝试进行身份验证的用户创建可分辨名称 (Distinguished Name, DN)。在这种情况下，必须指定使用 LDAP 搜索和捆绑：
=> CREATE AUTHENTICATION Ldap2 METHOD 'ldap' HOST '172.16.65.196';
=> ALTER AUTHENTICATION Ldap2 SET basedn='dc=qa_domain,dc=com',
binddn='cn=Manager,dc=qa_domain,
dc=com',search_attribute='cn',bind_password='secret';
更改身份验证方法
本示例将 localpwd 身份验证从 hash 更改为trust:
=> CREATE AUTHENTICATION localpwd METHOD 'hash' LOCAL;
=> ALTER AUTHENTICATION localpwd METHOD 'trust';
设置多领域
此示例为身份验证方法 krb_local 设置了其他领域：
=> ALTER AUTHENTICATION krb_local set realm = 'COMPANY.COM';
添加证书、从证书颁发机构 (CA) 捆绑包中移除证书或更改证书颁发机构 (CA) 捆绑包的所有者。
ALTER CA BUNDLE name
[ADD CERTIFICATES ca_cert[, ca_cert[, ...]]
[REMOVE CERTIFICATES ca_cert[, ca_cert[, ...]]
[OWNER TO user]
nameca_certuserCA 捆绑包的所有权。
请参阅管理 CA 捆绑包。
使用 ALTER DATABASE 可执行以下任务：
要查看参数的当前值，请查询系统表 CONFIGURATION_PARAMETERS 或使用 SHOW DATABASE。
ALTER DATABASE db-spec {
DROP ALL FAULT GROUP
| EXPORT ON { subnet‑name | DEFAULT }
| RESET STANDBY
| SET [PARAMETER] parameter=value [,...]
| CLEAR [PARAMETER] parameter[,...]
}
数据库名称
DEFAULT：当前数据库
DROP ALL FAULT GROUP EXPORT ON subnet‑name：公用网络的子网。
DEFAULT：指定使用专用网络。
有关详细信息，请参阅识别用于导入/导出的数据库或节点和更改节点导出地址。
RESET STANDBY SET [PARAMETER] CLEAR [PARAMETER] 超级用户
修改现有容错组。例如，使用 ALTER FAULT GROUP 语句执行以下操作：
向现有容错组添加节点或从中删除节点
向父容错组添加子容错组或从中删除子容错组
重命名容错组
ALTER FAULT GROUP fault-group-name {
| ADD NODE node-name
| DROP NODE node-name
| ADD FAULT GROUP child-fault-group-name
| DROP FAULT GROUP child-fault-group-name
| RENAME TO new-fault-group-name }
fault-group-namenode-namechild-fault-group-namenew-fault-group-name超级用户
此示例显示了如何将 parent0 容错组重命名为 parent100：
=> ALTER FAULT GROUP parent0 RENAME TO parent100;
ALTER FAULT GROUP
通过查询 FAULT_GROUPS 系统表来验证更改：
=> SELECT member_name FROM fault_groups;
member_name
----------------------
v_exampledb_node0003
parent100
mygroup
(3 rows)
Vertica 为每种类型的用户定义的扩展 提供了 ALTER 语句。每个 ALTER 语句都会修改 Vertica 编录中用户定义的函数的元数据：
Vertica 还提供ALTER FUNCTION (SQL)，可修改用户定义的 SQL 函数的元数据。
更改用户定义的聚合函数。
ALTER AGGREGATE FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET SCHEMA new‑schema
}
[db-name.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name arg‑list OWNER TO new‑owner RENAME TO new‑name SET SCHEMA new‑schema 非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改用户定义的分析函数。
ALTER ANALYTIC FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET FENCED boolean‑expr
| SET SCHEMA new‑schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改用户定义的筛选器。
ALTER FILTER [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET FENCED boolean‑expr
| SET SCHEMA new‑schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改用户定义的 SQL 函数。
ALTER FUNCTION [[db-name.]schema.]function‑name( [arg‑list] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET SCHEMA new‑schema
}
[db-name.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
function‑name OWNER TO new‑owner RENAME TO new‑name SET SCHEMA new‑schema 非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
将函数 SQL_one 重命名为 SQL_two：
=> ALTER FUNCTION SQL_one (int, int) RENAME TO SQL_two;
将函数 SQL_two 移动到架构 macros：
=> ALTER FUNCTION SQL_two (int, int) SET SCHEMA macros;
重新分配 SQL_two 的所有权：
=> ALTER FUNCTION SQL_two (int, int) OWNER TO user1;
更改用户定义的标量函数。
ALTER FUNCTION [[db-name.]schema.]function‑name( [ parameter‑list] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET FENCED boolean‑expr
| SET SCHEMA new‑schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
将函数 UDF_one 重命名为 UDF_two：
=> ALTER FUNCTION UDF_one (int, int) RENAME TO UDF_two;
将函数 UDF_two 移动到架构 macros：
=> ALTER FUNCTION UDF_two (int, int) SET SCHEMA macros;
禁用函数 UDF_two 的隔离模式：
=> ALTER FUNCTION UDF_two (int, int) SET FENCED false;
更改用户定义的解析器。
ALTER PARSER [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET FENCED boolean‑expr
| SET SCHEMA new‑schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改用户定义的加载源函数。
ALTER SOURCE [[db-name.]schema.]function‑name( [ parameter‑list ] ) {
OWNER TO new‑owner
| RENAME TO new‑name
| SET FENCED boolean‑expr
| SET SCHEMA new‑schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改用户定义的转换函数。
ALTER TRANSFORM FUNCTION [[db-name.]schema.]function-name( [ parameter-list ] ) {
OWNER TO new-owner
| RENAME TO new-name
| SET FENCED { true | false }
| SET SCHEMA new-schema
}
[db-name.]schemapublic。如果指定一个数据库，它必须是当前数据库。function‑nameparameter‑listOWNER TO new‑ownerRENAME TO new‑nameSET FENCED { true | false }SET SCHEMA new‑schema非超级用户：对架构的 USAGE 权限，为以下之一：
函数所有者
对函数的 ALTER 权限
对于某些操作，非超级用户还必须具备以下架构权限：
更改使用 CREATE HCATALOG SCHEMA 创建的架构上的参数值。HCatalog 连接器使用 HCatalog 架构访问存储在 Hive 数据仓库中的数据。有关详细信息，请参阅使用 HCatalog 连接器。
某些参数在创建后无法更改。如果需要更改其中一个值，请删除并重新创建架构。您可以使用 ALTER HCATALOG SCHEMA 更改以下参数：
HOSTNAME
PORT
HIVESERVER2_HOSTNAME
WEBSERVICE_HOSTNAME
WEBSERVICE_PORT
WEBHDFS_ADDRESS
HCATALOG_CONNECTION_TIMEOUT
HCATALOG_SLOW_TRANSFER_LIMIT
HCATALOG_SLOW_TRANSFER_TIME
SSL_CONFIG
CUSTOM_PARTITIONS
ALTER HCATALOG SCHEMA schema-name SET [param=value]+;
CREATE HCATALOG SCHEMA 的配置文件中读取默认值。以下几项之一：
超级用户
架构所有者
以下示例显示了如何更改 "hcat" 架构的 Hive 元存储主机名和端口。在此示例中，Hive 使用高可用性元存储。
=> ALTER HCATALOG SCHEMA hcat SET HOSTNAME='thrift://ms1.example.com:9083,thrift://ms2.example.com:9083';
以下示例显示了尝试设置不可更改的参数时收到的错误。
=> ALTER HCATALOG SCHEMA hcat SET HCATALOG_USER='admin';
ERROR 4856: Syntax error at or near "HCATALOG_USER" at character 39
替换当前与 Vertica 编录中的 UDx 库关联的库文件。Vertica 自动将更新文件的副本分发到所有群集节点。编录中定义的引用更新库的 UDx 将自动开始使用更新库文件。如果名称和签名匹配，则视为 UDx 相同。
当前库和替换库必须使用同一种语言编写。
ALTER LIBRARY [[database.]schema.]name [DEPENDS 'depends-path'] AS 'path';
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
DEPENDS 'depends-path'此库所依赖的文件或库，启动程序节点的文件系统或其他受支持的文件系统或对象存储中的一个或多个文件或目录。对于目录，路径条目以斜杠 (/) 结束，后跟通配符 (*)（可选）。要指定多个文件，请使用冒号 (:) 分隔条目。
如果任何路径条目包含冒号（例如 URI），请在整个 DEPENDS 路径两端加上括号，且单个路径元素使用双引号，如下例所示：
DEPENDS '["s3://mybucket/gson-2.3.1.jar"]'
要指定具有多个目录级别的库，请参阅多级库依赖项。
DEPENDS 对使用 R 编写的库没有影响。R 软件包必须本地安装在每个节点上，包括外部依赖项。
AS path超级用户，或者架构上的 UDXDEVELOPER 和 CREATE。非超级用户必须明确启用 UDXDEVELOPER 角色。有关示例，请参阅 CREATE LIBRARY。
如果 DEPENDS 子句指定具有多个目录级别的库，Vertica 将按照库路径包含该库的所有子目录。例如，以下 CREATE LIBRARY 语句使 UDx 库 mylib 能够导入它在 site‑packages 的子目录中找到的所有 Python 包和模块：
=> CREATE LIBRARY mylib AS '/path/to/python_udx' DEPENDS '/path/to/python/site-packages' LANGUAGE 'Python';
此示例显示了如何使用新文件更新名为 myFunctions 的已定义库。
=> ALTER LIBRARY myFunctions AS '/home/dbadmin/my_new_functions.so';
更改负载均衡组的配置。
ALTER LOAD BALANCE GROUP group-name {
RENAME TO new-name |
SET FILTER TO 'ip-cidr-addr' |
SET POLICY TO 'policy' |
ADD {ADDRESS | FAULT GROUP | SUBCLUSTER} add-list |
DROP {ADDRESS | FAULT GROUP | SUBCLUSTER} drop-list
}
group-name RENAME TO new-nameSET FILTER TO 'ip-cidr-addr'SET POLICY TO 'policy'ROUNDROBIN
RANDOM
NONE
有关详细信息，请参阅CREATE LOAD BALANCE GROUP。
ADD {ADDRESS | FAULT GROUP | SUBCLUSTER }add-list DROP {ADDRESS | FAULT GROUP | SUBCLUSTER} drop-list 从名为 group_2 的负载均衡组中移除地址。
=> SELECT * FROM LOAD_BALANCE_GROUPS;
name | policy | filter | type | object_name
---------+------------+--------+-----------------------+-------------
group_1 | ROUNDROBIN | | Network Address Group | node01
group_1 | ROUNDROBIN | | Network Address Group | node02
group_2 | ROUNDROBIN | | Network Address Group | node03
(3 rows)
=> ALTER LOAD BALANCE GROUP group_2 DROP ADDRESS node03;
ALTER LOAD BALANCE GROUP
=> SELECT * FROM LOAD_BALANCE_GROUPS;
name | policy | filter | type | object_name
---------+------------+--------+-----------------------+-------------
group_1 | ROUNDROBIN | | Network Address Group | node01
group_1 | ROUNDROBIN | | Network Address Group | node02
group_2 | ROUNDROBIN | | Empty Group |
(3 rows)
以下示例向名为 group_2 的组中添加了三个网络地址：
=> ALTER LOAD BALANCE GROUP group_2 ADD ADDRESS node01,node02,node03;
ALTER LOAD BALANCE GROUP
=> SELECT * FROM load_balance_groups WHERE name = 'group_2';
-[ RECORD 1 ]----------------------
name | group_2
policy | ROUNDROBIN
filter |
type | Network Address Group
object_name | node01
-[ RECORD 2 ]----------------------
name | group_2
policy | ROUNDROBIN
filter |
type | Network Address Group
object_name | node02
-[ RECORD 3 ]----------------------
name | group_2
policy | ROUNDROBIN
filter |
type | Network Address Group
object_name | node03
允许用户重命名现有模型、更改所有权或将其移动到其他架构。
ALTER MODEL [[database.]schema.]model
{ OWNER TO owner
| RENAME TO new‑name
| SET SCHEMA schema
}
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
modelOWNER TO ownerRENAME TO SET SCHEMA schema非超级用户：对架构的 USAGE 权限，为以下之一：
模型所有者
对模型的 ALTER 权限
对于某些操作，非超级用户必须具备以下架构权限：
请参阅更改模型。
更改现有网络地址的配置。
ALTER NETWORK ADDRESS name {
RENAME TO new-name
| SET TO 'ip-addr' [PORT port-number]
| { ENABLE | DISABLE }
}
name RENAME TO new-nameSET TO 'ip-addr'PORT port-numberENABLE | DISABLE将网络地址从 test_addr 重命名为 alt_node1，然后将其 IP 地址更改为 192.168.1.200，端口号为 4000：
=> ALTER NETWORK ADDRESS test_addr RENAME TO alt_node1;
ALTER NETWORK ADDRESS
=> ALTER NETWORK ADDRESS alt_node1 SET TO '192.168.1.200' PORT 4000;
ALTER NETWORK ADDRESS
重命名网络接口。
ALTER NETWORK INTERFACE network-interface-name RENAME TO new-network-interface-name
network-interface-name new-network-interface-name 超级用户
重命名网络接口：
=> ALTER NETWORK INTERFACE myNetwork RENAME TO myNewNetwork;
设置和清除指定节点上的节点级别配置参数。ALTER NODE 还执行以下管理任务：
更改节点类型。
指定用于导入和导出的各个节点上公用网络的网络接口。
替换故障节点。
有关移除节点的信息，请参阅
ALTER NODE node‑name {
EXPORT ON { network‑interface | DEFAULT }
| [IS] node‑type
| REPLACE [ WITH standby‑node ]
| RESET
| SET [PARAMETER] parameter=value[,...]
| CLEAR [PARAMETER] parameter[,...]
}
[IS] node‑typePERMANENT：（默认值）：存储数据的节点。
EPHEMERAL：从一种类型转换到另一种类型的节点——通常是从 PERMANENT 到 STANDBY 或 EXECUTE。
STANDBY：保留以在任何节点发生故障时替换该节点的节点。备用节点不存储段或数据，直到它被调用以替换故障节点。当用作替换节点时，Vertica 将其类型更改为 PERMANENT。有关详细信息，请参阅活动备用节点。
EXECUTE：该节点仅为计算目的而保留。执行节点不包含段或数据。
EXPORT ONnetwork‑interface：公用网络的网络接口名称。
DEFAULT：使用公用网络的默认网络接口，通过
ALTER DATABASE 指定。
REPLACE [WITH standby‑node]WITH 子句，Vertica 会尝试从与故障节点相同的容错组中查找替换节点。
如果指定的节点未发生故障，Vertica 将忽略此语句。
RESETSET [PARAMETER]CLEAR [PARAMETER]超级用户
指定使用 v_vmart_node0001 上公用网络的默认网络接口进行导入/导出操作：
=> ALTER NODE v_vmart_node0001 EXPORT ON DEFAULT;
将故障节点 v_vmart_node0001 替换为活动的备用节点，然后还原故障节点：
=> ALTER NODE v_vmart_node0001 REPLACE WITH standby1;
...
=> ALTER NODE v_vmart_node0001 RESET;
设置和清除配置参数 MaxClientSessions：
=> ALTER NODE v_vmart_node0001 SET MaxClientSessions = 0;
...
=> ALTER NODE v_vmart_node0001 CLEAR MaxClientSessions;
将节点类型设置为 EPHEMERAL：
=> ALTER NODE v_vmart_node0001 IS EPHEMERAL;
更新现有通知程序。
ALTER NOTIFIER notifier‑name
[ ENABLE | DISABLE ]
[ MAXPAYLOAD 'max‑payload‑size' ]
[ MAXMEMORYSIZE 'max‑memory‑size' ]
[ TLSMODE 'tls‑mode' ]
[ CA BUNDLE bundle‑name [ CERTIFICATE certificate‑name ] ]
[ IDENTIFIED BY 'uuid' ]
[ [NO] CHECK COMMITTED ]
[ PARAMETERS 'adapter‑params' ]
[NO] CHECK COMMITTEDENABLE | DISABLEMAXPAYLOADMAXPAYLOAD integer{K|M|G|T}
默认设置特定于适配器，例如 Kafka 为 1 M。
对此参数的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。
MAXMEMORYSIZEMAXMEMORYSIZE integer{K|M|G|T}
如果队列超过此大小，通知程序将删除多余的消息。
TLSMODE 'tls‑mode'指定通知程序和端点之间的连接类型，可以是以下类型之一：
disable （默认值）：明文连接。
verify-ca：加密连接，且服务器的证书已经验证为由受信任的 CA 签名。
如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。
CA BUNDLE bundle‑name指定 CA 捆绑包。如果 TLSMODE 需要，捆绑包中的证书可用于验证 Kafka 服务器的证书。
如果为当前使用 disable 的通知程序指定了 CA 捆绑包，而不会验证 Kafka 服务器的证书，则在连接到 Kafka 服务器时，将不使用该捆绑包。除非将 TLSMODE 更改为验证服务器证书行为，否则此行为会持续存在。
对 CA 捆绑包内容的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。但是，对通知程序所用的 CA 捆绑包的更改会立即生效。
如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。
CERTIFICATE certificate‑name指定一个供端点验证的客户端证书。
如果通知程序 ACTION 为 'syslog'，则该参数无效；您必须为 TLS 配置 syslog 才能为这些 Vertica syslog 通知程序启用加密。
IDENTIFIED BY 'uuid'PARAMETERS 'adapter‑params'对此参数的更改，在通知程序后禁用并重新启用或在数据库重新启动后生效。
对于 Kafka 通知程序，请参阅 Kafka 和 Vertica 配置设置。
超级用户
按照此步骤，为使用 SASL_SSL 的 Kafka 端点创建或更改通知程序。请注意，每当您更改给定通知程序的 TLSMODE、证书或 CA 捆绑包时，都必须重复此步骤。
在设置 TLSMODE、证书和 CA 捆绑包时，使用 CREATE 或 ALTER 以禁用通知程序。
=> ALTER NOTIFIER encrypted_notifier
DISABLE
TLSMODE 'verify-ca'
CA BUNDLE ca_bundle2;
更改通知程序并为 SASL_SSL 设置适合的 rdkafka 适配器参数。
=> ALTER NOTIFIER encrypted_notifier PARAMETERS
'sasl.username=user;sasl.password=password;sasl.mechanism=PLAIN;security.protocol=SASL_SSL';
启用通知程序。
=> ALTER NOTIFIER encrypted_notifier ENABLE;
更新现有通知程序的设置：
=> ALTER NOTIFIER my_dc_notifier
ENABLE
MAXMEMORYSIZE '2G'
IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
CHECK COMMITTED;
更改 TLSMODE 并将 CA 捆绑包和证书添加到现有通知程序。此通知程序连接到 Kafka 服务器的证书，并验证其是否由受信任的 CA 签名。
=> ALTER NOTIFIER my_notifier
TLSMODE 'verify-ca'
CA BUNDLE ca_bundle
CERTIFICATE client_cert;
ALTER PROCEDURE procedure ( [ [ parameter_mode ] [ parameter ] parameter_type [, ...] ] )
[ SECURITY { INVOKER | DEFINER }
| RENAME TO new_procedure_name
| OWNER TO new_owner
| SET SCHEMA new_schema
| SOURCE TO new_source
]
SECURITY { INVOKER | DEFINER }有关详细信息，请参阅执行存储过程。
RENAME TO new_procedure_nameOWNER TO new_ownerSET SCHEMA new_schemaSOURCE TO new_sourceOWNER TO超级用户
RENAME 和 SCHEMA TO非超级用户：
对过程架构的 CREATE 权限
过程的所有权
非超级用户：过程的所有权
请参阅更改存储过程。
更改指定投影的 DDL。
ALTER PROJECTION [[database.]schema.]projection
{ RENAME TO new‑name | ON PARTITION RANGE BETWEEN min-val AND max-val }
架构 数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
projection 投影基本名称：重命名共享此基本名称的所有投影。
投影名称：重命名指定投影及其基本名称。如果投影是分段的，则其伙伴实例不受此更改的影响。
有关投影名称约定，请参阅投影命名。
new‑name ON PARTITION RANGE指定将此投影的数据限制在分区键范围内，指定如下：
ON PARTITION RANGE BETWEEN min-range-value AND max-range-value
以下要求适用于 min‑range‑value 和 ≤ max‑range‑value：
Min‑range‑value 必须 ≤ max‑range‑value
它们必须解析为与表分区表达式兼容的数据类型。
它们可以是：
字符串字面量。例如， 2021-07-31
具有稳定或不可变函数的表达式，例如：
date_trunc('month', now()::timestamp - interval'1 month')
max-range-value 可以设置为 NULL，以指定分区范围没有上限。
如果新的键范围超出之前的范围，Vertica 将发出警告，指出投影已过期，必须刷新才能使用。
有关其他要求和使用详细信息，请参阅分区范围投影。
非超级用户权限、对架构的 CREATE 和 USAGE 权限以及以下锚表权限之一：
表所有者
ALTER 权限
SELECT 权限（仅当定义了分区范围投影时）
=> SELECT export_tables('','public.store_orders');
export_tables
---------------------------------------------
CREATE TABLE public.store_orders
(
order_no int,
order_date timestamp NOT NULL,
shipper varchar(20),
ship_date date NOT NULL
);
(1 row)
=> CREATE PROJECTION store_orders_p AS SELECT * from store_orders;
CREATE PROJECTION
=> ALTER PROJECTION store_orders_p RENAME to store_orders_new;
ALTER PROJECTION
CREATE PROJECTION
更改配置文件。未在配置文件中设置的所有参数都从默认配置文件继承其设置。可以使用 ALTER PROFILE 更改默认配置文件。
ALTER PROFILE name LIMIT [
PASSWORD_LIFE_TIME setting
PASSWORD_MIN_LIFE_TIME setting
PASSWORD_GRACE_TIME setting
FAILED_LOGIN_ATTEMPTS setting
PASSWORD_LOCK_TIME setting
PASSWORD_REUSE_MAX setting
PASSWORD_REUSE_TIME setting
PASSWORD_MAX_LENGTH setting
PASSWORD_MIN_LENGTH setting
PASSWORD_MIN_LETTERS setting
PASSWORD_MIN_UPPERCASE_LETTERS setting
PASSWORD_MIN_LOWERCASE_LETTERS setting
PASSWORD_MIN_DIGITS setting
PASSWORD_MIN_SYMBOLS setting
PASSWORD_MIN_CHAR_CHANGE setting ]
default。
超级用户
以下配置文件设置会影响客户端身份验证方法，例如 LDAP 或 GSS：
FAILED_LOGIN_ATTEMPTS
PASSWORD_LOCK_TIME
所有其他配置文件设置仅供 Vertica 用于管理其密码。
ALTER PROFILE sample_profile LIMIT FAILED_LOGIN_ATTEMPTS 3;
重命名现有配置文件。
ALTER PROFILE name RENAME TO new‑name;
超级用户
此示例显示了如何重命名现有配置文件。
ALTER PROFILE sample_profile RENAME TO new_sample_profile;
通过设置一个或多个参数来修改现有资源池。
ALTER RESOURCE POOL pool‑name [ FOR subcluster-spec ] [ parameter‑name setting ]...
FOR subcluster‑specSUBCLUSTER subcluster-name：更改现有子群集的资源池。您不能连接到此子群集，否则 Vertica 会返回错误。CURRENT SUBCLUSTER：更改您连接到的子群集的资源池。
要在 parameter‑name 上设置的值。要将此参数重置为其默认值，请指定 DEFAULT。
CASCADE TO 指定一个辅助资源池，用于执行其
[RUNTIMECAP](#RUNTIMECAP) 设置超出分配资源池的查询：
CASCADE TO secondary‑pool
CPUAFFINITYMODE 指定资源池是单独使用还是共用
[CPUAFFINITYSET](#CPUAFFINITYSET) 中指定的 CPU。
CPUAFFINITYMODE { SHARED | EXCLUSIVE | ANY }
SHARED：在此池中运行的查询与其他 Vertica 资源池共享其 CPUAFFINITYSET CPU。
EXCLUSIVE：仅将 CPUAFFINITYSET CPU 专用于此资源池，不用于其他 Vertica 资源池。如果将 CPUAFFINITYSET 设置为百分比，那么仅为此资源池分配可用于 Vertica 的 CPU 资源百分比。
ANY （默认值）：此资源池中的查询可以在任何 CPU 上运行，如果 CPUAFFINITYSET 指定 CPU 资源，则此查询无效。
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{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的内存量，最大为
MAXMEMORYSIZE。
NONE （默认值）：无限制；池可以从 GENERAL 池中借用任意数量的可用内存，其限制由以下设置：
MAXMEMORYSIZE。
MAXQUERYMEMORYSIZE 的更改会追溯应用于当前正在执行的查询。如果减少此设置值，对于按照先前内存大小计划的查询，如果其尝试分配的内存大于新设置允许的值，则很可能会失败。
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：一个负整数或正整数值。数字越大，表示优先级越高：
HOLD：将优先级设置为 -999。此池中的查询将排队，直到达到
[QUEUETIMEOUT](#QUEUETIMEOUT) 为止。
默认值： 0
QUEUETIMEOUT指定请求在被拒绝之前可以等待池资源多长时间：
QUEUETIMEOUT { integer | NONE }
integer：最长等待时间（以秒为单位）
NONE：没有最长等待时间，请求可以无限排队。
默认值： 300 秒
RUNTIMECAP通过设置池中的查询可以执行的最大时间，可以防止查询失控。如果查询超出此设置，它会尝试级联到辅助池。
RUNTIMECAP { 'interval' | NONE }
interval：1 分钟或 100 秒的间隔；不应超过 1 年。
NONE （默认值）：在此池中运行的查询没有时间限制。
要以天为单位指定一个值，请提供整数值。要提供小于一天的值，请以 hours:minutes:seconds 格式提供间隔。例如，值为 1:30:00 时，则等于 90 分钟。
如果用户或会话也具有 RUNTIMECAP，则会应用较短的限制。
RUNTIMEPRIORITY确定资源管理器应如何将运行时资源（CPU、I/O 带宽）的优先级分配给已在此资源池中运行的查询：
RUNTIMEPRIORITY { HIGH | MEDIUM | LOW }
默认值： MEDIUM
RUNTIMEPRIORITYTHRESHOLD以秒为单位指定一个时间限制，在资源管理器为其分配资源池 RUNTIMEPRIORITY 之前，必须完成一个查询。所有查询从 HIGH 优先级开始运行。如果查询的持续时间超过了此阈值，它将分配到资源池的 RUNTIMEPRIORITY。
RUNTIMEPRIORITYTHRESHOLD seconds
默认值： 2
SINGLEINITIATOR默认情况下，已设置为 false 以实现向后兼容性。切勿更改此设置。
超级用户
以下示例显示如何通过将优先级设置为 5 来更改资源池 ceo_pool。
=> ALTER RESOURCE POOL ceo_pool PRIORITY 5;
以下示例显示如何为 ceo_pool 指定一个辅助资源池。
=> CREATE RESOURCE POOL second_pool;
=> ALTER RESOURCE POOL ceo_pool CASCADE TO second_pool;
以下 Eon 模式示例将 dashboard 辅助子群集的内置 TM 资源池的 MAXMEMORYSIZE 和 MEMORYSIZE 减小到 0%。将这些设置更改为 0 会阻止子群集运行
Tuple Mover
合并操作。
=> ALTER RESOURCE POOL TM FOR SUBCLUSTER dashboard MEMORYSIZE '0%'
MAXMEMORYSIZE '0%';
有关详细信息，请参阅调整 Tuple Mover 池设置。
重命名现有角色。
ALTER ROLE name RENAME TO new‑name
超级用户
=> ALTER ROLE applicationadministrator RENAME TO appadmin;
ALTER ROLE
更改现有负载均衡策略路由规则。
ALTER ROUTING RULE rule_name {
RENAME TO new_name |
SET ROUTE TO 'cidr_range'|
SET GROUP TO group_name
}
rule_name RENAME TO new_nameSET ROUTE TO 'cidr_range'SET GROUP TO group_name此示例将更改名为 etl_rule 的路由规则，以便其使用名为 etl_rule 的负载均衡组来处理 IP 地址范围 10.20.100.0 到 10.20.100.255 内的传入连接。
=> ALTER ROUTING RULE etl_rule SET GROUP TO etl_group;
ALTER ROUTING RULE
=> ALTER ROUTING RULE etl_rule SET ROUTE TO '10.20.100.0/24';
ALTER ROUTING RULE
=> \x
Expanded display is on.
=> SELECT * FROM routing_rules WHERE NAME = 'etl_rule';
-[ RECORD 1 ]----+---------------
name | etl_rule
source_address | 10.20.100.0/24
destination_name | etl_group
通过以下方式之一更改一个或多个架构：
通过在架构中创建的表启用或禁用架构权限的继承。
将架构所有权重新分配给另一个用户。
更改架构磁盘配额。
重命名一个或多个架构。
ALTER SCHEMA [database.]schema
DEFAULT {INCLUDE | EXCLUDE} SCHEMA PRIVILEGES
| OWNER TO user-name [CASCADE]
| DISK_QUOTA { value | SET NULL }
您可以在单个操作中重命名多个架构：
ALTER SCHEMA [database.]schema[,...] RENAME TO new-schema-name[,...]
DEFAULT {INCLUDE | EXCLUDE} SCHEMA PRIVILEGES 指定是否启用或禁用指定架构中新表的默认权限继承：
EXCLUDE SCHEMA PRIVILEGES （默认值）：禁用架构的权限继承。
INCLUDE SCHEMA PRIVILEGES：指定为指定架构中的表授予的权限与为架构授予的权限相同。此选项对架构中的现有表没有影响。
另请参阅 启用架构继承。
OWNER TOOWNER TO user-name [CASCADE]
默认情况下，重新分配的架构中对象的所有权保持不变。要将架构对象的所有权重新分配给新架构所有者，请使用 CASCADE 对 OWNER TO 子句进行限定。有关详细信息，请参阅下面的级联架构所有权。
DISK_QUOTA一个字符串，整数后跟支持的单位：K、M、G 或 T。如果新值小于当前使用量，操作将成功，但在使用量降至新配额以下之前，将无法使用更多磁盘空间。
SET NULL，用于移除配额。
有关详细信息，请参阅磁盘配额。
RENAME TORENAME TO new-schema-name[,...]
需要满足以下要求：
新架构名称符合标识符中描述的约定。此外，该名称在数据库中所有序列、表、投影、视图、模型和架构的名称中必须是唯一的。
如果指定多个要重命名的架构，则源列表和目标列表必须具有相同数量的名称。
以下几项之一：
超级用户
架构所有者
默认情况下，ALTER SCHEMA...OWNER TO 不会影响目标架构中对象的所有权或授予给这些对象的权限。如果使用 CASCADE 对 OWNER TO 子句进行限定，Vertica 将对目标架构中的对象执行以下操作：
将先前架构所有者所拥有的对象所有权转移给新的所有者。
撤销上一个架构所有者授予的所有对象权限。
如果由非超级用户发出，ALTER SCHEMA...OWNER TO CASCADE 会忽略属于其他用户的所有对象，并就其无法更改的对象返回通知。例如：
架构 ms 归用户 mayday 所有，其包含两个表： ms.t1 归 mayday 所有，ms.t2 归用户joe 所有：
=> \dt
List of tables
Schema | Name | Kind | Owner | Comment
----------------+-----------------------+-------+---------+---------
ms | t1 | table | mayday |
ms | t2 | table | joe |
用户 mayday 使用 CASCADE 将架构 ms 的所有权转移给用户 dbadmin。返回时，ALTER SCHEMA 报告它无法转移归用户 joe 所有的表 ms.t2 及其投影的所有权：
=> \c - mayday
You are now connected as user "mayday".
=> ALTER SCHEMA ms OWNER TO dbadmin CASCADE;
NOTICE 3583: Insufficient privileges on ms.t2
NOTICE 3583: Insufficient privileges on ms.t2_b0
NOTICE 3583: Insufficient privileges on ms.t2_b1
ALTER SCHEMA
=> \c
You are now connected as user "dbadmin".
=> \dt
List of tables
Schema | Name | Kind | Owner | Comment
----------------+-----------------------+-------+---------+---------
ms | t1 | table | dbadmin |
ms | t2 | table | joe |
用户 dbadmin 再次使用 CASCADE 将架构 ms 的所有权转移给用户 pat。这次，因为 dbadmin 是超级用户，所以 ALTER SCHEMA 可以将所有 ms 表的所有权转移给用户 pat
=> ALTER SCHEMA ms OWNER TO pat CASCADE;
ALTER SCHEMA
=> \dt
List of tables
Schema | Name | Kind | Owner | Comment
----------------+-----------------------+-------+---------+---------
ms | t1 | table | pat |
ms | t2 | table | pat |
重命名架构可用于交换架构而无需实际移动数据。为便于交换，请输入一个不存在的、临时占位符架构。例如，以下 ALTER SCHEMA 语句使用临时架构 temps 来帮助架构 S1 与架构 S2 进行交换。在此示例中，S1 被重命名为 temps。然后 S2 被重命名为 S1。最后，temps 被重命名为 S2。
=> ALTER SCHEMA S1, S2, temps RENAME TO temps, S1, S2;
以下示例将架构 S1 和 S2 分别重命名为 S3 和 S4：
=> ALTER SCHEMA S1, S2 RENAME TO S3, S4;
此示例将新表 t2 的默认行为设置为自动继承架构的权限：
=> ALTER SCHEMA s1 DEFAULT INCLUDE SCHEMA PRIVILEGES;
=> CREATE TABLE s1.t2 (i, int);
此示例将新表的默认行为设置为不自动继承架构的权限：
=> ALTER SCHEMA s1 DEFAULT EXCLUDE SCHEMA PRIVILEGES;
通过以下两种方式更改命名序列：
设置控制序列行为的参数，例如，序列起始值以及其最小值和最大值的范围。这些更改仅在您启动新的数据库会话时生效。
设置序列名称、架构或所有权。这些更改会立即生效。
更改序列行为：
ALTER SEQUENCE [[database.]schema.]sequence
[ INCREMENT [ BY ] integer ]
[ MINVALUE integer | NO MINVALUE ]
[ MAXVALUE integer | NO MAXVALUE ]
[ RESTART [ WITH ] integer ]
[ CACHE integer | NO CACHE ]
[ CYCLE | NO CYCLE ]
更改序列名称、架构或所有权：
ALTER SEQUENCE [schema.]sequence-name {
RENAME TO seq-name
| SET SCHEMA schema-name]
| OWNER TO owner-name
}
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
如果未指定架构，系统将在默认架构中创建表。
INCREMENT [BY] integer一个正整数或负整数，指定每次调用 NEXTVAL 时序列的增减数量，默认设置为 1。
NO CACHE 参数则除外。
MINVALUE integerNO MINVALUE （默认值）MAXVALUE integerNO MAXVALUE （默认值）NEXTVAL 将返回 integer。
CACHEintegerNO CACHE （默认值）有关详细信息，请参阅分发命名序列。
CYCLENO CYCLE （默认值）CYCLE：序列按如下方式进行回绕：
当递增序列达到其上限时，会被重置为其最小值。
当递减序列达到其下限时，会被重置为其最大值。
NO CYCLE （默认值）：在序列达到其最大值或最小值后，调用 NEXTVAL 会返回错误。
RENAME TO seq‑nameSET SCHEMA schema‑nameOWNER TO owner‑name非超级用户：对架构的 USAGE 权限，为以下之一：
序列所有者
对序列的 ALTER 权限
对于某些操作，非超级用户必须具备以下架构权限：
请参阅更改序列。
CREATE SEQUENCE
更改子群集的配置。您可以使用此语句重命名子群集或将其设为 默认子群集。
ALTER SUBCLUSTER subcluster‑name {
RENAME TO new-name |
SET DEFAULT
}
subcluster‑name RENAME TO new‑nameSET DEFAULT 此示例将 analytics_cluster 设为默认子群集：
=> SELECT DISTINCT subcluster_name FROM SUBCLUSTERS WHERE is_default = true;
subcluster_name
--------------------
default_subcluster
(1 row)
=> ALTER SUBCLUSTER analytics_cluster SET DEFAULT;
ALTER SUBCLUSTER
=> SELECT DISTINCT subcluster_name FROM SUBCLUSTERS WHERE is_default = true;
subcluster_name
-------------------
analytics_cluster
(1 row)
此示例将 default_subcluster 重命名为 load_subcluster：
=> ALTER SUBCLUSTER default_subcluster RENAME TO load_subcluster;
ALTER SUBCLUSTER
=> SELECT DISTINCT subcluster_name FROM subclusters;
subcluster_name
-------------------
load_subcluster
analytics_cluster
(2 rows)
ALTER SESSION 为当前会话设置和清除会话级别的配置参数值。要识别会话级别参数，请查询系统表 CONFIGURATION_PARAMETERS。
ALTER SESSION {
SET [PARAMETER] parameter‑name=value[,...]
| CLEAR { [PARAMETER] parameter‑name[,...] | PARAMETER ALL }
| SET UDPARAMETER [ FOR libname ] key=value[,...]
| CLEAR UDPARAMETER { [ FOR libname ] key[,...] | ALL }
}
SET [PARAMETER]CLEAR [PARAMETER]CLEAR PARAMETER ALLSET UDPARAMETER(key=value)，以与 UDx 结合使用。键值大小限制如下：
从客户端设置：128 个字符
从 UDx 端设置：无限制
可以通过包含子句
FOR libname 将 SET 操作的范围限制为单个库。例如：
=> ALTER SESSION SET UDPARAMETER FOR securelib username='alice';
如果指定一个库，则只有该库可以访问参数的值。使用此限制来保护包含敏感数据（例如凭据）的参数。
CLEAR UDPARAMETER
[FOR libname] key[,...]：清除 key 指定的参数，（可选）这些参数的范围被限制为库 libname。
ALL：清除当前会话中的所有用户定义参数。
无
强制所有支持隔离模式的 UDx 在隔离模式下运行，即使其定义指定了 NOT FENCED 也是如此：
=> ALTER SESSION SET ForceUDxFencedMode = 1;
ALTER SESSION
在会话级别清除 ForceUDxFencedMode。其值将被重置为其默认值 0：
=> ALTER SESSION CLEAR ForceUDxFencedMode;
ALTER SESSION
=> SELECT parameter_name, current_value, default_value FROM configuration_parameters WHERE parameter_name = 'ForceUDxFencedMode';
parameter_name | current_value | default_value
--------------------+---------------+---------------
ForceUDxFencedMode | 0 | 0
(1 row)
清除在此会话中设置的更改的所有会话级别配置参数：
=> ALTER SESSION CLEAR PARAMETER ALL;
ALTER SESSION
将库 MyLibrary 中的用户定义参数 RowCount 的值设置为 25。
=> ALTER SESSION SET UDPARAMETER FOR MyLibrary RowCount = 25;
ALTER SESSION
清除会话级别的 RowCount：
=> ALTER SESSION CLEAR UDPARAMETER FOR MyLibrary RowCount;
ALTER SESSION
重命名现有子网。
ALTER SUBNET subnet‑name RENAME TO new‑subnet‑name
超级用户
=> ALTER SUBNET mysubnet RENAME TO myNewSubnet;
修改现有表的元数据。所有更改都将自动提交。
ALTER TABLE [[database.]schema.]table {
ADD COLUMN [ IF NOT EXISTS ] column datatype
[ column‑constraint ]
[ ENCODING encoding‑type ]
[ PROJECTIONS (projections-list) | ALL PROJECTIONS ]
| ADD table‑constraint
| ALTER COLUMN column {
ENCODING encoding-type PROJECTIONS (projection-list)
| { SET | DROP } expression }
| ALTER CONSTRAINT constraint‑name { ENABLED | DISABLED }
| DISK_QUOTA { value | SET NULL }
| DROP CONSTRAINT constraint‑name [ CASCADE | RESTRICT ]
| DROP [ COLUMN ] [ IF EXISTS ] column [ CASCADE | RESTRICT ]
| FORCE OUTER integer
| { INCLUDE | EXCLUDE | MATERIALIZE } [ SCHEMA ] PRIVILEGES
| OWNER TO owner
| partition‑clause [ REORGANIZE ]
| REMOVE PARTITIONING
| RENAME [ COLUMN ] name TO new‑name
| RENAME TO new-table-name[,...]
| REORGANIZE
| SET {
ActivePartitionCount { count | DEFAULT }
| IMMUTABLE ROWS
| MERGEOUT { 1 | 0 }
| SCHEMA schema
}
多个 ALTER TABLE 子句不能与同一语句中的其他子句一起指定（请参阅下面的 Exclusive ALTER TABLE 子句）。否则，ALTER TABLE 支持多个以逗号分隔的子句。例如，下面的 ALTER TABLE 语句通过以下两种方式更改 my_table 表：将所有权重新分配给 Joe；在 UNIQUE b 列上设置 约束：
=> ALTER TABLE my_table OWNER TO Joe,
ADD CONSTRAINT unique_b UNIQUE (b) ENABLED;
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表ADD COLUMN ADD COLUMN [IF NOT EXISTS]
column datatype
[ NULL | NOT NULL ]
[ ENCODING encoding‑type]
[ PROJECTIONS (projections-list) | ALL PROJECTIONS]
对复杂类型列的限制也适用于通过 ADD COLUMN 添加的列。
如果指定的名称下面已经存在列，则可选的 IF NOT EXISTS 子句会生成一条信息性消息。如果您忽略此选项且列存在，Vertica 会生成 ROLLBACK 错误消息。
您可以使用以下选项之一限定新的列定义：
column‑constraint 指定一个列约束，如下所示：
{NULL | NOT NULL}
| [ DEFAULT default‑expr ] [ SET USING using‑expr ] } | DEFAULT USING exp}
ENCODING 指定列的编码类型。默认设置为 AUTO。
PROJECTIONS 将新列添加到此表的一个或多个现有投影中，指定为投影基本名称的逗号分隔列表。Vertica 将该列添加到每个投影的所有伙伴实例。投影列表不能包含具有预聚合数据的投影，例如实时聚合投影；否则，Vertica 将回退 ALTER TABLE 语句。
ALL PROJECTIONS 将该列添加到此表的所有投影（不包括具有预聚合数据的投影）中。
ADD table‑constraintALTER COLUMN在一列上为该表的一个或多个投影设置编码：
ENCODING encoding-type PROJECTIONS (projections-list)
其中 projections-list 是以逗号分隔的投影列表，这些投影将使用新编码进行更新。可以通过以下两种方式指定每个投影：
投影基本名称：更新所有共享此基本名称的投影。
投影名称：更新指定的投影。如果投影被分段，则所做的更改将传播到所有伙伴实例。
如果其中一个投影不包含目标列，Vertica 将返回一个回退错误。
有关详细信息，请参阅投影列编码。
设置或删除一列标量数据（包括原始数组）的设置：
SET { DEFAULT expression
| USING expression
| DEFAULT USING expression
| NOT NULL
| DATA TYPE datatype
}
DROP { DEFAULT
| SET USING
| DEFAULT USING
| NOT NULL
}
如果列所属的复杂类型既不是标量类型也不是标量类型数组，则无法更改其数据类型。存在一个例外：在外部表中，您可以将基元列类型更改为复杂类型。
设置 DEFAULT 或 SET USING 表达式对现有列值没有影响。要使用列的 DEFAULT 或 SET USING 表达式刷新列，请按如下方式对其进行更新：
SET USING 列：对该表调用 REFRESH_COLUMNS。
DEFAULT 列：按如下方式更新该列：
UPDATE table-name SET column-name=DEFAULT;
使用 DEFAULT 或 SET USING 更改列会增加磁盘使用率，如果违反表或架构磁盘配额，这可能会导致操作失败。
ALTER CONSTRAINTALTER CONSTRAINT constraint‑name {ENABLED | DISABLED}
DISK_QUOTA一个字符串，整数后跟支持的单位：K、M、G 或 T。如果新值小于当前使用量，操作将成功，但在使用量降至新配额以下之前，将无法使用更多磁盘空间。
SET NULL，用于移除配额。
有关详细信息，请参阅磁盘配额。
DROP CONSTRAINT DROP CONSTRAINT constraint-name [CASCADE | RESTRICT]
您可以使用以下选项之一限定 DROP CONSTRAINT：
CASCADE：删除其他表中的约束和所有依赖项。
RESTRICT：如果存在依赖对象，则不删除约束。与默认行为相同。
删除表约束对引用该表的视图没有影响。
DROP [COLUMN] DROP [COLUMN] [IF EXISTS] column [CASCADE | RESTRICT]
您可以使用以下选项之一限定 DROP COLUMN：
如果列不存在，IF EXISTS 会生成一条信息性消息。如果您忽略此选项且列不存在，Vertica 会生成 ROLLBACK 错误消息。
如果列具有依赖项，则需要 CASCADE。
RESTRICT 仅删除给定表中的列。
列所在的表不能是不可变表。
请参阅删除表列。
FORCE OUTER integer{INCLUDE | EXCLUDE | MATERIALIZE} [SCHEMA] PRIVILEGES EXCLUDE PRIVILEGES（默认）禁止从架构继承权限。
INCLUDE PRIVILEGES 将针对表架构授予的相同权限授予视图。
MATERIALIZE PRIVILEGES 将授权复制到表并在表上创建一个 GRANT 对象。这将禁用表上的权限继承标志，让您可以：
在表级别授予更具体的权限。
使用架构级权限作为模板。
将表移动到不同的架构。
更改架构权限而不影响表。
另请参阅 设置表和视图的权限继承。
OWNER TO ownerpartition‑clause [REORGANIZE] PARTITION BY partition‑expression
[ GROUP BY group‑expression ]
[ SET ACTIVEPARTITIONCOUNT integer ]
有关详细信息，请参阅分区子句。
如果您使用 REORGANIZE 限定分区子句，并且在以前没有为表指定分区，则 Vertica Tuple Mover 会立即实现分区子句。如果在以前为表指定了分区，则 Tuple Mover 会评估 ROS 存储容器，并根据需要重新组织这些容器，使其符合新的分区子句。
REMOVE PARTITIONING RENAME [COLUMN]RENAME TO RENAME TO new‑table‑name[,...]
需要满足以下要求：
重命名的表必须与原始表在同一架构中。
新的表名 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
如果指定多个要重命名的表，则源列表和目标列表必须具有相同数量的名称。
REORGANIZE REORGANIZE 也可以限定一个新的分区子句。
SETActivePartitionCount {count | DEFAULT }，仅对分区表有效，指定该表有多少个分区处于活动状态，为以下几项之一：
count：无符号整数，取代配置参数 ActivePartitionCount。
DEFAULT：移除表级活动分区计数。该表从配置参数 ActivePartitionCount 中获取其活动分区计数。
有关用法的详细信息，请参阅活动和非活动分区。
IMMUTABLE ROWS 通过阻止 DML 操作（如 UPDATE 和 DELETE）来防止更改表行值。表的不可变性一旦设置便无法恢复。
MERGEOUT { 1 | 0 } 指定是允许还是禁止合并用来合并此表的投影数据的 ROS 容器。默认情况下，会针对所有表启用合并 (1)。
SCHEMA schema-name 将表从其当前架构移动到 schema-name。Vertica 自动将锚定到源表的所有投影移动到目标架构。它还将所有 IDENTITY 和 AUTO_INCREMENT 列移动到目标架构。有关详细信息，请参阅 将表移动到另一个架构
非超级用户：对架构的 USAGE 权限，为以下之一：
表所有者
ALTER 权限
非超级用户还必须具有 SELECT 权限才能启用或禁用 约束强制执行或移除分区。
对于某些操作，非超级用户必须具备以下架构权限：
要重命名表：CREATE、USAGE
要将表移动到另一个架构：对源架构具有 USAGE 权限，对目标架构具有 CREATE 权限
原生表中使用的复杂类型除了其参考页面上列出的个别类型的限制外，还有一些限制：
原生表必须至少有一个基本类型或原生数组（基本类型的一维数组）的列。如果一个 Flex 表有真实的列，它也必须至少有一个满足这个限制的列。
复杂类型列不能在 ORDER BY 或 PARTITION BY 子句中使用，也不能用作 FILLER 列。
复杂类型列不能有 约束。
返回复杂类型的表达式不能用作投影列，并且投影不能按复杂类型的列进行分段或排序。
具有复杂类型列的表不能使用 DEFAULT 和 SET USING。
以下 ALTER TABLE 子句不能与其他 ALTER TABLE 子句结合使用：
ADD COLUMN
DROP COLUMN
RENAME COLUMN
SET SCHEMA
RENAME [TO]
仅限企业模式
当一个或多个数据库群集节点关闭时，不支持以下 ALTER TABLE 操作：
ALTER COLUMN ...ADD table‑constraint
ALTER COLUMN ...SET DATA TYPE
ALTER COLUMN ...{ SET DEFAULT | DROP DEFAULT }
ALTER COLUMN ...{ SET USING | DROP SET USING }
ALTER CONSTRAINT
DROP COLUMN
DROP CONSTRAINT
您不能修改实时聚合或 Top-K 投影中包含的锚定表列的元数据。您也不能删除这些列。要进行这些更改，您必须首先删除与之关联的所有实时聚合和 Top-K 投影。
并不是所有 ALTER TABLE 选项都适用于外部表。例如，您不能向外部表添加列，但可以重命名该表：
=> ALTER TABLE mytable RENAME TO mytable2;
ALTER TABLE
如果操作无法在目标表上获取 O lock，Vertica 将尝试关闭该表上运行的任何内部 tuple mover 会话。如果成功，则可以继续操作。在用户会话中运行的显式 Tuple Mover 操作不会关闭。如果显式 Tuple Mover 操作在表上运行，则该操作仅在 Tuple Mover 操作完成后继续。
为表元数据添加约束。您可以使用
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‑namePRIMARY KEYNOT NULL 列作为主键，如下所示：
PRIMARY KEY (column[,...]) [ ENABLED | DISABLED]
可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。
如果您没有命名主键约束，Vertica 会分配名称 C_PRIMARY。
FOREIGN KEYFOREIGN KEY (column[,... ]) REFERENCES table [(column[,... ])]
如果省略了 column，Vertica 将引用 table 中的主键。
如果您没有命名外键约束，Vertica 会分配名称 C_FOREIGN。
添加外键约束需要以下权限（除了 ALTER TABLE 也需要的权限外）：
对引用表的 REFERENCES 权限
对引用表架构的 USAGE 权限
UNIQUEUNIQUE (column[,...]) [ENABLED | DISABLED]
可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。
如果您没有命名唯一约束，Vertica 会分配名称 C_UNIQUE。
CHECKCHECK (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)
创建表及其投影后，可以调用 ALTER TABLE...ALTER COLUMN 来设置或更改一个或多个投影中现有列的编码类型。例如：
ALTER TABLE store.store_dimension ALTER COLUMN store_region
ENCODING rle PROJECTIONS (store.store_dimension_p1_b0, store.store_dimension_p2);
在此示例中，ALTER TABLE 语句指定对两个投影的 store_region 列设置 RLE 编码： store_dimension_p1_b0 和 store_dimension_p2。PROJECTIONS 列表分别通过投影名称和基本名称引用这两个投影。可以通过任意一种方式引用投影；在这两种情况下，更改都会传播到投影的所有伙伴实例并相应地存储在其 DDL 中：
=> select export_objects('','store.store_dimension');
export_objects
------------------------------------------------------------------
CREATE TABLE store.store_dimension
(
store_key int NOT NULL,
store_name varchar(64),
store_number int,
store_address varchar(256),
store_city varchar(64),
store_state char(2),
store_region varchar(64)
);
CREATE PROJECTION store.store_dimension_p1
(
store_key,
store_name,
store_number,
store_address,
store_city,
store_state,
store_region ENCODING RLE
)
AS
SELECT store_dimension.store_key,
store_dimension.store_name,
store_dimension.store_number,
store_dimension.store_address,
store_dimension.store_city,
store_dimension.store_state,
store_dimension.store_region
FROM store.store_dimension
ORDER BY store_dimension.store_key
SEGMENTED BY hash(store_dimension.store_key) ALL NODES KSAFE 1;
CREATE PROJECTION store.store_dimension_p2
(
store_key,
store_name,
store_number,
store_address,
store_city,
store_state,
store_region ENCODING RLE
)
AS
SELECT ...
更改指定的 TLS CONFIGURATION 对象。有关现有 TLS CONFIGURATION 对象的信息，请查询 TLS_CONFIGURATIONS。
ALTER TLS CONFIGURATION tls_config_name {
[ CERTIFICATE { NULL | cert_name }
[ ADD CA CERTIFICATES ca_cert_name [,...] ]
[ REMOVE CA CERTIFICATES ca_cert_name [,...] ]
[ CIPHER SUITES { '' | 'openssl_cipher [,...]' } ]
[ TLSMODE 'tlsmode' ]
[ OWNER TO user_name ]
}
tls_config_name NULL cert_name 您必须拥有证书的使用权限（来自 证书 的所有权或 对其密钥的使用，如果有的话）将其添加到 TLS 配置。
ca_cert_name 您必须拥有证书的使用权限（来自 证书 的所有权或 对其密钥的使用，如果有的话）将其添加到 TLS 配置。
openssl_cipher 要查看启用的密码套件，请使用 LIST_ENABLED_CIPHERS。
DISABLE：禁用 TLS。此参数的所有其他选项都启用 TLS。
ENABLE：启用 TLS。Vertica 不检查客户端证书。
TRY_VERIFY：如果出现以下任一情况，则建立 TLS 连接：
另一台主机出示有效证书
另一台主机不提供证书
如果其他主机提供无效证书，则连接将使用纯文本。
VERIFY_CA：如果 Vertica 验证其他主机的证书来自受信任的 CA，则连接成功。如果其他主机不提供证书，则连接使用纯文本。
VERIFY_FULL：如果 Vertica 验证其他主机的证书来自受信任的 CA，并且证书的 cn（通用名称）或 subjectAltName 属性与其他主机的主机名或 IP 地址匹配，则连接成功。
请注意，对于客户端证书，cn 将用于用户名，因此 subjectAltName 必须与其他主机的主机名或 IP 地址匹配。
VERIFY_FULL 不受客户端-服务器 TLS 和 HTTPS（分别为参数 ServerTLSConfig 和 HttpsTLSConfig）支持，其行为类似于 VERIFY_CA。
Vertica 和另一方中，哪个充当客户端，哪个充当服务器，这取决于连接类型。更具体地说，设置为参数的 TLS 配置会将 Vertica 视为客户端，将另一方（在本示例中为 LDAP 服务器）视为服务器：
对于所有其他连接类型，Vertica 是服务器，另一方是客户端：
InternodeTLSConfig（其他 Vertica 节点既是客户端又是服务器）
非超级用户： 对 TLS CONFIGURATION 的 ALTER 权限。
要配置客户端-服务器 TLS，请参阅配置客户端-服务器 TLS。
要为 LDAP Link 服务及其试运行函数配置 TLS，请参阅 LDAP Link 的 TLS。
要为 LDAP 身份验证记录配置 TLS，请参阅 LDAP 身份验证的 TLS。
要从 LDAPLink TLS 配置中移除所有证书和 CA 证书：
=> SELECT * FROM tls_configurations WHERE name='LDAPLink';
name | owner | certificate | ca_certificate | cipher_suites | mode
----------+---------+-------------+----------------+---------------+---------
LDAPLink | dbadmin | server_cert | ca | | DISABLE
LDAPLink | dbadmin | server_cert | ica | | DISABLE
(2 rows)
=> ALTER TLS CONFIGURATION LDAPLink CERTIFICATE NULL REMOVE CA CERTIFICATES ca, ica;
ALTER TLS CONFIGURATION
=> SELECT * FROM tls_configurations WHERE name='LDAPLink';
name | owner | certificate | ca_certificate | cipher_suites | mode
----------+---------+-------------+----------------+---------------+---------
LDAPLink | dbadmin | | | | DISABLE
(3 rows)
要为客户端-服务器 TLS 使用一组备用密码套件：
=> ALTER TLS CONFIGURATION server CIPHER SUITES
'DHE-PSK-AES256-CBC-SHA384,
DHE-PSK-AES128-GCM-SHA256,
PSK-AES128-CBC-SHA256';
ALTER TLS CONFIGURATION
=> SELECT name, cipher_suites FROM tls_configurations WHERE name='server';
name | cipher_suites
server | DHE-PSK-AES256-CBC-SHA384,DHE-PSK-AES128-GCM-SHA256,PSK-AES128-CBC-SHA256
(1 row)
更改用户帐户参数和用户级别配置参数。
ALTER USER user‑name {
account‑parameter value[,...]
| SET [PARAMETER] cfg‑parameter=value[,...]
| CLEAR [PARAMETER] cfg‑parameter[,...]
}
user‑name 有关名称要求的详细信息，请参阅创建数据库名称和密码。
account‑parameter valueSET [PARAMETER]CLEAR [PARAMETER]以逗号分隔列表的形式指定一个或多个用户帐户参数及其设置：
account‑parameter value[,...]
对于使用 LDAPLink 服务添加到 Vertica 数据库的用户，以下用户帐户参数无效：
IDENTIFIED BY
PROFILE
SECURITY ALGORITHM
|
参数 |
设置 |
|||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ACCOUNT |
锁定或解锁用户对数据库的访问，可以用以下操作之一：
提示要自动锁定帐户，可使用 CREATE PROFILE 设置登录尝试失败的最大次数。 |
|||||||||||||||||||||||
DEFAULT ROLE |
指定哪些角色是此用户的默认角色，设置为以下之一：
当用户登录时，会自动激活默认角色。此参数指定的角色将取代之前分配的任何角色。 注意
|
|||||||||||||||||||||||
GRACEPERIOD |
指定用户查询可以被任何会话套接字拦截多长时间，可以是以下值之一：
有关详细信息，请参阅处理会话套接字阻止。 |
|||||||||||||||||||||||
IDENTIFIED BY |
更改用户密码：
|
非超级用户可以在自己的用户帐户上更改以下选项：
IDENTIFIED BY
RESOURCE POOL
SEARCH_PATH
SECURITY_ALGORITHM
将另一个用户的默认资源池更改为 PUBLIC 架构之外的资源池时，用户必须至少通过以下途径之一获得资源池的 USAGE 权限：
SET | CLEAR PARAMETER 只能指定用户级别配置参数，否则 Vertica 将返回错误。只有超级用户可以设置和清除用户级别参数，除非它们在会话级也受支持。
要获取用户级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS。例如：
=> SELECT parameter_name, allowed_levels FROM configuration_parameters
WHERE allowed_levels ilike '%USER%' AND parameter_name ilike '%depot%' ORDER BY parameter_name;
parameter_name | allowed_levels
-----------------------------+-------------------------
BackgroundDepotWarming | SESSION, USER, DATABASE
DepotOperationsForQuery | SESSION, USER, DATABASE
EnableDepotWarmingFromPeers | SESSION, USER, DATABASE
UseDepotForReads | SESSION, USER, DATABASE
UseDepotForWrites | SESSION, USER, DATABASE
(5 rows)
以下示例为两个用户 Yvonne 和 Ahmed 设置用户级别配置参数 UseDepotForWrites：
=> SHOW USER Yvonne PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Yvonne | DepotOperationsForQuery | Fetches
(1 row)
=> ALTER USER Yvonne SET PARAMETER UseDepotForWrites = 0;
ALTER USER
=> SHOW USER Yvonne PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Yvonne | DepotOperationsForQuery | Fetches
Yvonne | UseDepotForWrites | 0
(2 rows)
=> ALTER USER Ahmed SET PARAMETER DepotOperationsForQuery = 'Fetches';
ALTER USER
=> SHOW USER ALL PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Ahmed | DepotOperationsForQuery | Fetches
Yvonne | DepotOperationsForQuery | Fetches
Yvonne | UseDepotForWrites | 0
(3 rows)
=> CREATE USER user1;
=> ALTER USER user1 IDENTIFIED BY 'newpassword';
此示例将用户的安全算法和密码分别设置为 SHA-512 和 newpassword。执行 ALTER USER 语句时，Vertica 会使用 SHA-512 算法对密码进行哈希处理，并保存哈希：
=> CREATE USER user1;
=> ALTER USER user1 SECURITY_ALGORITHM 'SHA512' IDENTIFIED BY 'newpassword'
此示例使用户的已分配角色成为用户的默认角色。用户登录时会自动设置（启用）默认角色：
=> CREATE USER user1;
CREATE USER
=> GRANT role1, role2, role3 to user1;
=> ALTER USER user1 DEFAULT ROLE ALL;
您可以将 ALL 与 EXCEPT 配对以排除某些角色：
=> CREATE USER user2;
CREATE USER
=> GRANT role1, role2, role3 to user2;
=> ALTER USER user2 DEFAULT ROLE ALL EXCEPT role1;
修改现有 视图的元数据。更改将自动提交。
一般用途：
ALTER VIEW [[database.]schema.]view {
| OWNER TO owner
| SET SCHEMA schema
| { INCLUDE | EXCLUDE | MATERIALIZE } [ SCHEMA ] PRIVILEGES
}
重命名视图：
ALTER VIEW [[database.]schema.]view[,...] RENAME TO new-view-name[,...]
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
SET SCHEMA schema OWNER TO owner{ INCLUDE | EXCLUDE | MATERIALIZE } [SCHEMA] PRIVILEGES EXCLUDE [SCHEMA] PRIVILEGES （默认）禁止从架构继承权限。
INCLUDE [SCHEMA] PRIVILEGES 将授予视图架构的相同权限授予视图。
MATERIALIZE：将授权复制到视图并在视图上创建一个 GRANT 对象。这将禁用视图上继承的权限标志，让您可以：
在视图级别授予更具体的权限
使用架构级权限作为模板
将视图移动到不同的架构
更改架构权限而不影响视图
另请参阅 设置表和视图的权限继承。
RENAME TORENAME TO new‑view‑name[,...]
需要满足以下要求：
新的视图名称 符合标识符中描述的约定。 同一架构中的序列、表、投影、视图和模型中也必须是唯一的。
如果指定多个要重命名的视图，源列表和目标列表必须具有相同数量的名称。
重命名一个视图需要对包含该视图的架构具有 USAGE 和 CREATE 权限。
非超级用户：对架构的 USAGE 权限，为以下之一：
视图所有者
对视图的 ALTER 权限
对于某些操作，非超级用户必须具备以下架构权限：
将视图 view1 重命名为 view2：
=> CREATE VIEW view1 AS SELECT * FROM t;
CREATE VIEW
=> ALTER VIEW view1 RENAME TO view2;
ALTER VIEW
激活定向查询并使其可用于所有会话中的查询优化器。
ACTIVATE DIRECTED QUERY [ query-name ]
query-name激活定向查询后，它将始终处于活动状态，直到被 DEACTIVATE DIRECTED QUERY 以显式方式停用或被 DROP DIRECTED QUERY 从存储空间中移除。如果在数据库关闭时定向查询处于活动状态，当您重新启动数据库时，Vertica 会自动将其重新激活。
请参阅激活和停用定向查询。
启动事务块。
BEGIN [ WORK | TRANSACTION ] [ isolation‑level ] [ READ [ONLY] | WRITE ]
WORK | TRANSACTIONREAD COMMITTED（默认值）:
REPEATABLE READ（自动转换为 SERIALIZABLE）
READ UNCOMMITTED（自动转换为 READ COMMITTED）
有关详细信息，请参阅事务。
READ [ONLY] | WRITEREAD WRITE（默认）：事务为读取/写入。
READ ONLY：事务为只读。
如果将事务会话模式设置为只读，将不允许使用以下 SQL 语句，但是不会阻止所有磁盘写入操作：
INSERT、UPDATE、DELETE 和 COPY（如果目标表不是临时表）
所有 CREATE、ALTER 和 DROP 命令
GRANT、REVOKE 和 EXPLAIN（如果要运行的 SQL 为上面引用的语句之一）。
无
创建一个隔离级别设置为 READ COMMITTED 且事务模式设置为 READ WRITE 的事务：
=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
BEGIN
=> CREATE TABLE sample_table (a INT);
CREATE TABLE
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)
=> END;
COMMIT
调用使用 CREATE PROCEDURE（存储） 创建的存储过程。
CALL [[database.]schema.]procedure( [ argument-list] );
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
过程非超级用户：对过程的 EXECUTE 权限
请参阅 执行存储过程 和 存储过程：用例和示例。
COMMENT ON 此语句用于对数据库对象（如架构、表和库）创建注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
添加、修订或移除有关约束的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON CONSTRAINT constraint ON [[database.]schema.]table IS ... {'comment' | NULL };
约束 [database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表 注释 注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL 非超级用户：对象所有者
以下示例向 promotion_dimension 表上的 constraint_x 约束添加了一条注释：
=> COMMENT ON CONSTRAINT constraint_x ON promotion_dimension IS 'Primary key';
以下示例从 promotion_dimension 表上的 constraint_x 约束中移除了一条注释：
=> COMMENT ON CONSTRAINT constraint_x ON promotion_dimension IS NULL;
添加、修订或移除有关函数的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
functionfunction‑argscomment注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 macros.zerowhennull (x INT) 函数添加了一条注释：
=> COMMENT ON FUNCTION macros.zerowhennull(x INT) IS 'Returns a 0 if not NULL';
以下示例从 macros.zerowhennull (x INT) 函数中移除了一条注释：
=> COMMENT ON FUNCTION macros.zerowhennull(x INT) IS NULL;
添加、修订或移除聚合函数的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON AGGREGATE FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
functionfunction‑argscomment注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 APPROXIMATE_MEDIAN(x FLOAT) 函数添加了一条注释：
=> COMMENT ON AGGREGATE FUNCTION APPROXIMATE_MEDIAN(x FLOAT) IS 'alias of APPROXIMATE_PERCENTILE with 0.5 as its parameter';
以下示例从 APPROXIMATE_MEDIAN(x FLOAT) 函数中移除了一条注释：
=> COMMENT ON AGGREGATE FUNCTION APPROXIMATE_MEDIAN(x FLOAT) IS NULL;
添加、修订或移除分析函数的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON ANALYTIC FUNCTION [[database.]schema.]function (function‑args) IS { 'comment' | NULL };
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
functionfunction‑argscomment注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向用户定义的 an_rank() 函数添加了一条注释：
=> COMMENT ON ANALYTIC FUNCTION an_rank() IS 'built from the AnalyticFunctions library';
以下示例从用户定义的 an_rank() 函数中移除了一条注释：
=> COMMENT ON ANALYTIC FUNCTION an_rank() IS NULL;
添加、修订或移除有关库的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON LIBRARY [[database.]schema.]library IS {'comment' | NULL}
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
库注释注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向库添加了一条注释 MyFunctions:
=> COMMENT ON LIBRARY MyFunctions IS 'In development';
以下示例从库中移除了一条注释 MyFunctions:
=> COMMENT ON LIBRARY MyFunctions IS NULL;
添加、修订或移除有关节点的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
如果删除某个对象，将删除与该对象关联的所有注释。
COMMENT ON NODE node‑name IS { 'comment' | NULL }
注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例为 initiator node 添加了一条注释：
=> COMMENT ON NODE initiator IS 'Initiator node';
以下示例从 initiator node 中移除了一条注释：
=> COMMENT ON NODE initiator IS NULL;
添加、修订或移除有关投影的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
如果删除某个对象，将删除与该对象关联的所有注释。
COMMENT ON PROJECTION [[database.]schema.]projection IS { 'comment' | NULL }
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 customer_dimension_vmart_node01 投影添加了一条注释：
=> COMMENT ON PROJECTION customer_dimension_vmart_node01 IS 'Test data';
以下示例从 customer_dimension_vmart_node01 投影中移除了一条注释：
=> COMMENT ON PROJECTION customer_dimension_vmart_node01 IS NULL;
添加、修订或移除投影列注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON COLUMN [[database.]schema.]projection.column IS {'comment' | NULL}
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
projection.column注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 customer_dimension 投影中的 customer_name 列添加了一条注释：
=> COMMENT ON COLUMN customer_dimension_vmart_node01.customer_name IS 'Last name only';
以下示例从 customer_dimension 投影中的 customer_name 列中移除了一条注释：
=> COMMENT ON COLUMN customer_dimension_vmart_node01.customer_name IS NULL;
添加、修订或移除有关架构的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON SCHEMA schema-name IS {'comment' | NULL}
schema‑name注释注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 public 架构添加了一条注释：
=> COMMENT ON SCHEMA public IS 'All users can access this schema';
以下示例从 public 架构中移除了一条注释。
=> COMMENT ON SCHEMA public IS NULL;
添加、修订或移除有关序列的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON SEQUENCE [[database.]schema.]sequence IS { 'comment' | NULL }
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
序列注释注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向名为 prom_seq 的序列添加了一条注释。
=> COMMENT ON SEQUENCE prom_seq IS 'Promotion codes';
以下示例从 prom_seq 序列中移除了一条注释。
=> COMMENT ON SEQUENCE prom_seq IS NULL;
添加、修订或移除有关表的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON TABLE [[database.]schema.]table IS { 'comment' | NULL }
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 promotion_dimension 表添加了一条注释：
=> COMMENT ON TABLE promotion_dimension IS '2011 Promotions';
以下示例从 Promotion_dimension 表中移除了一条注释：
=> COMMENT ON TABLE promotion_dimension IS NULL;
添加、修订或移除表列注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON COLUMN [[database.]schema.]table.column IS {'comment' | NULL}
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table.column注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 store 架构的 store_sales_fact 表中的 transaction_time 列添加了一条注释：
=> COMMENT ON COLUMN store.store_sales_fact.transaction_time IS 'GMT';
以下示例从 store 架构的 store_sales_fact 表中的 transaction_time 列中移除了一条注释：
=> COMMENT ON COLUMN store.store_sales_fact.transaction_time IS NULL;
添加、修订或移除有关用户定义的转换函数的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON TRANSFORM FUNCTION [[database.]schema.]tfunction
...( [ tfunction-arg-name tfunction-arg-type ][,...] ) IS {'comment' | NULL}
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
tfunctiontfunction‑arg‑name tfunction‑arg‑type注释注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 macros.zerowhennull (x INT) UTF 函数添加了一条注释：
=> COMMENT ON TRANSFORM FUNCTION macros.zerowhennull(x INT) IS 'Returns a 0 if not NULL';
以下示例使用 acros.zerowhennull (x INT)选项从 NULL 函数中移除了一条注释。
=> COMMENT ON TRANSFORM FUNCTION macros.zerowhennull(x INT) IS NULL;
添加、修订或移除有关视图的注释。每个对象可以有一条注释。注释存储在系统表
COMMENTS 中。
COMMENT ON VIEW [[database.]schema.]view IS { 'comment' | NULL }
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
视图注释注释的长度最多为 8192 个字符。如果注释超出此限制，Vertica 将截断注释并通过消息提醒用户。
NULL非超级用户：对象所有者
以下示例向 curr_month_ship 视图中添加了一条注释：
=> COMMENT ON VIEW curr_month_ship IS 'Shipping data for the current month';
以下示例从 curr_month_ship 视图中移除了一条注释：
=> COMMENT ON VIEW curr_month_ship IS NULL;
结束当前事务，使事务期间发生的所有变更永久化且对其他用户可见。
COMMIT 等同于
END
COMMIT [ WORK | TRANSACTION ]
WORK TRANSACTION无
本示例显示如何提交插入。
=> CREATE TABLE sample_table (a INT);
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
=> COMMIT;
连接到另一个 Vertica 数据库，以便分别使用
COPY FROM VERTICA 和
导出到 VERTICA 在 Vertica 数据库之间导入和导出数据。
与另一个数据库建立连接后，该连接在当前会话中保持打开状态，直到使用
DISCONNECT 将其显式关闭。一次只能与另一个数据库建立一个连接。但是，您可以在同一会话中建立与不同数据库的连续连接。
默认情况下，通过 Vertica 专用网络调用 CONNECT TO VERTICA。有关通过公用网络创建连接的信息，请参阅使用公共和专用 IP 网络。
存在以下限制：
如果连接的任一端是安装到 localhost 的单节点群集，则复制和导出操作可能会失败。
如果尝试连接到其 server TLS CONFIGURATION 使用 VERIFY_CA 或 VERIFY_FULL 的 TLSMODE 的数据库，CONNECT TO VERTICA 将失败。有关详细信息，请参阅配置客户端-服务器 TLS。
CONNECT TO VERTICA db‑spec USER username PASSWORD 'password' ON 'host', port
[ TLSMODE PREFER ]
[ TLSCONFIG tls_config_name ]
DEFAULT。如果目标数据库没有密码，而您提供了密码，连接将成功；但是，Vertica 不会返回您提供的密码不正确的指示。
ImportExportTLSMode 的值覆盖为 PREFER。如果 ImportExportTLSMode 设置为 *_FORCE，则无法进行覆盖。
如果 TLSMODE PREFER 和 ImportExportTLSMode 均未设置，CONNECT TO VERTICA 将使用 ENABLE。
从不使用指定的 TLS CONFIGURATION 的 TLSMODE。相反，CONNECT TO VERTICA 使用 TLSMODE PREFER 和 ImportExportTLSMode 参数。
无
如 安全性和身份验证 中所述，对 Vertica 数据库执行导入/导出时，您只能连接到使用受信任（仅限用户名）或基于密码的身份验证的数据库。不支持 SSL 身份验证。
如果配置了证书，Vertica 会在传输期间使用 TLS 加密数据并尝试加密计划元数据。您可以设置配置参数
ImportExportTLSMode，以要求对计划元数据进行加密。
=> CONNECT TO VERTICA ExampleDB USER dbadmin PASSWORD 'Password123' ON 'VerticaHost01',5433;
CONNECT
COPY 可将数据批量加载到 Vertica 数据库中。默认情况下，COPY 会自动提交自身及所有当前事务（加载临时表时除外）。如果 COPY 被中止或中断，Vertica 将予以回退。
COPY 以 UTF-8 编码格式读取数据。
有关在群集主机或客户端系统上加载一个或多个文件或管道的信息，请参阅 COPY LOCAL。
COPY [ /*+ LABEL (label‑string)*/ ] [[database.]schema-name.]target-table
[ ( { column-as-expression | column }
[ DELIMITER [ AS ] 'char' ]
[ ENCLOSED [ BY ] 'char' ]
[ ENFORCELENGTH ]
[ ESCAPE [ AS ] 'char' | NO ESCAPE ]
[ FILLER datatype]
[ FORMAT 'format' ]
[ NULL [ AS ] 'string' ]
[ TRIM 'byte' ]
[,...] ) ]
[ COLUMN OPTION (column
[ DELIMITER [ AS ] 'char' ]
[ ENCLOSED [ BY ] 'char' ]
[ ENFORCELENGTH ]
[ ESCAPE [ AS ] 'char' | NO ESCAPE ]
[ FORMAT 'format' ]
[ NULL [ AS ] 'string' ]
[ TRIM 'byte' ]
[,...] ) ]
FROM {
[ LOCAL ] STDIN [ compression ]
| { 'path-to-data'
[ ON { nodename | (nodeset) | ANY NODE | EACH NODE } ] [ compression ] }[,...]
[ PARTITION COLUMNS column[,...] ]
| LOCAL 'path-to-data' [ compression ] [,...]
| VERTICA source-database.[source-schema.]source-table[( source-column[,...] ) ]
}
[ NATIVE
| FIXEDWIDTH COLSIZES {( integer )[,...]}
| NATIVE VARCHAR
| ORC
| PARQUET
]
| [ WITH ] UDL-clause[...]
}
[ ABORT ON ERROR ]
[ DELIMITER [ AS ] 'char' ]
[ ENCLOSED [ BY ] 'char'
[ ENFORCELENGTH ]
[ ERROR TOLERANCE ]
[ ESCAPE [ AS ] 'char' | NO ESCAPE ]
[ EXCEPTIONS 'path' [ ON nodename] [,...]
[ NULL [ AS ] 'string' ]
[ RECORD TERMINATOR 'string' ]
[ REJECTED DATA {'path' [ ON nodename] [,...] | AS TABLE reject-table} ]
[ REJECTMAX integer ]
[ SKIP integer ]
[ SKIP BYTES integer ]
[ STREAM NAME 'streamName']
[ TRAILING NULLCOLS ]
[ TRIM 'byte' ]
[ [ WITH ] PARSER parser ([ arg=value[,...] ]) ] ]
[ NO COMMIT ]
请参阅参数。
请参阅限制。
超级用户具有完整的 COPY 权限。以下要求适用于非超级用户：
对表的 INSERT 权限
对架构的 USAGE 权限
用户可访问的存储位置
授予的对读取或写入文件的存储位置的相应 READ 或 WRITE 权限
COPY 可以指定一个路径来存储被拒绝的数据和异常。如果路径解析为存储位置，则以下权限适用于非超级用户：
存储位置使用 USER 选项进行创建（请参阅 CREATE LOCATION）。
用户必须具有存储位置的 READ 权限，如 中所述 GRANT（存储位置）
COPY 参数及其描述分为以下部分：
以下选项适用于目标表及其列：
LABEL将标签分配到语句，以便您可以在分析和调试时识别它。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
在 CREATE EXTERNAL TABLE 或 CREATE FLEX EXTERNAL TABLE 语句中使用时，COPY 将忽略 schema-name。
target-tablecolumn-as-expression=> COPY t(year AS TO_CHAR(k, 'YYYY')) FROM 'myfile.dat'
当加载到目标数据库时，使用该选项来转换数据。
有关详细信息，请参阅在加载期间转换数据。
列将向从列列表中忽略的表列分配其 DEFAULT 或 SET USING 值（如有）；否则，COPY 将插入 NULL。
如果将 column 参数留空以加载表中的所有列，则可以使用可选参数 COLUMN OPTION 来为特定列指定解析选项。
数据文件必须包含与 COPY 命令列列表中数量相同的列。
COLUMN OPTION根据选项的指定方式，以下 COPY 选项可以对特定列或所有列进行限定。某些解析器特定选项也可以应用于特定列或所有列。有关这两种模式的详细信息，请参阅全局选项和特定于列的选项。
ENFORCELENGTH默认情况下，COPY 会截断这些数据类型的违反约束的行以及集合中这些类型的元素，但不会拒绝这些行。有关更多详细信息，请参阅处理混乱数据。
如果集合不适合其所有元素，COPY 会拒绝行，但不会截断。不会减少元素的数量。如果每个元素各自都在限制范围内，但元素数量导致集合超过列的最大大小，则可能会发生这种情况。
FILLER datatypeFORMAT 'format'八进制
十六进制
比特流
请参阅二进制（原生）数据了解更多关于这些格式的信息。
加载日期/时间列时，使用 FORMAT 会显著提升加载性能。COPY 与 TO_DATE 函数支持相同的格式。请参阅用于日期/时间格式化的模板模式。
如果指定了无效格式的字符串，COPY 操作将返回错误。
NULL [AS]'')。可以将 null 值指定为 E'\000' 至 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 选项使用相同的字符。有关详细信息，请参阅分隔数据。以下选项可用于指定源数据：
LOCALSTDIN 无效用户必须具有表的 INSERT 权限以及架构的 USAGE 权限。
限制： 对 CREATE EXTERNAL TABLE AS COPY 无效
path-to-data如果文件存储在 HDFS 中，则 path-to-data webhdfs 是架构中的 URI，通常为 [[s]web]hdfs://[nameservice]/path。请参阅HDFS 文件系统。
如果文件存储在 S3 存储桶中，则 path-to-data 是格式为 s3://bucket/path 的 URI。请参阅S3 对象存储。
如果文件存储在 Google Cloud Storage 中，则 path-to-data 是格式为 gs://bucket/path 的 URI。请参阅Google Cloud Storage (GCS) 对象存储。
如果文件存储在 Azure Blob 存储中，则 path-to-data 是格式为 azb://account/container/path 的 URI。请参阅Azure Blob 存储对象存储。
如果文件位于本地 Linux 文件系统或 NFS 装载上，则 path-to-data 为本地绝对文件路径。
path-to-data 可以选择包含通配符以和多个文件匹配。文件必须可供本地客户端或 COPY 语句运行的主机访问。COPY 会跳过文件列表中的空文件。若文件列表包含目录，则会导致查询失败。请参阅指定加载数据的位置。在 Linux Manual Page for Glob (7) 中指定了通配符支持的模式，对于 ADO.net 平台，则通过 NET Directory.getFiles 方法指定。
可使用变量来构建 使用加载脚本 中描述的路径名。
如果 path-to-data 解析为本地文件系统上的存储位置，且调用 COPY 的用户为非超级用户，则将应用以下要求：
存储位置使用 CREATE LOCATION...USAGE USER 进行创建。
用户必须已经具有文件存储位置的 READ 权限。
此外，如果用户具有权限但不是超级用户，并且从该存储位置调用 COPY，Vertica 会确保符号链接不会导致未经授权的访问。
PARTITION COLUMNS column[,...]colname=value 的目录名称时有效，例如：
/data/created=2016-01-01/*.dat
/data/created=2016-01-02/*.dat
/data/created=2016-01-03/*.dat
值通过目录名称的 value 部分进行解析。如果不能强制转换为列数据类型，该值将被拒绝。如果该值缺失，COPY 会将其加载为 null。
以下示例将这些日期与数据文件中的其他列一起加载到表列中：
=> CREATE EXTERNAL TABLE records
(id int, name varchar(50), created date)
AS COPY FROM 'webhdfs:///path/*/*'
PARTITION COLUMNS created;
有关详细信息，请参阅分区文件路径。
ON nodenameON (nodeset)=> COPY t FROM 'file1.txt' ON (v_vmart_node0001, v_vmart_node0002);
Vertica 将加载分摊到所有指定节点。如果同时指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 会改为选择单个节点来执行加载。
如果数据在所有节点上都可用，则通常会使用 ON ANY NODE，这是从 HDFS 和云对象存储加载所使用的默认值。但是，可以使用 ON nodeset 在并发加载之间手动平衡加载。
ON ANY NODE如果文件足够大，可以进行分摊，Vertica 会尝试在多个节点之间分摊加载。如果指定了 ERROR TOLERANCE 或 REJECTMAX，Vertica 将选择单个节点。
可使用通配符或 glob（如 *.dat）并结合 ON ANY NODE 子句加载多个输入文件。如果使用 glob，COPY 会将文件列表分配至所有群集节点并分散工作负载。
ON ANY NODE 对于 STDIN 和 LOCAL 无效。STDIN 只能使用客户端主机，LOCAL 表示客户端节点。
ON ANY NODE 是从 Linux 以外的所有路径（HDFS 和云对象存储）加载时使用的默认值。
ON EACH NODEcompressionUNCOMPRESSED（默认）
BZIP
GZIP
LZO
ZSTD
输入文件可以是任何格式。如果使用通配符，所有的限定输入文件必须是相同的格式。要加载不同的文件格式，则指定具体的格式类型。
以下要求和限制适用：
使用串联的 BZIP 或 GZIP 文件时，确认所有的源文件在串联之前使用记录终止符终止。
串联的 BZIP 和 GZIP 文件不支持 NATIVE（二进制）和 NATIVE VARCHAR 格式。
LZO 文件假定使用 lzop 进行压缩。Vertica 支持以下 lzop 实参：
--no-checksum / -F
--crc32
--adler32
--no-name / -n
--name / -N
--no-mode
--no-time
--fast
--best
编号的压缩级别
BZIP、GZIP、ZSTD 和 LZO 压缩不能与 ORC 格式结合使用。
VERTICA[WITH] UDL-clause[...]SOURCE source( [arg=value[,...] ]
[ FILTER filter( [arg=value[,...] ] ) ]...
[ PARSER parser( [arg=value[,...] ] ) ]
要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。
以下选项用于控制 COPY 如何处理不同的突发事件：
ABORT ON ERRORCOLSIZES (integer[,...])ERROR TOLERANCE使用此参数可禁用分摊加载。
限制： 对 ORC 或 Parquet 数据无效
EXCEPTIONSEXCEPTIONS 'path' [ ON nodename[,...]]
异常描述了每个被拒绝的行被拒绝的原因。每个异常描述了通过 REJECTED DATA 选项指定的文件中的相应记录。
文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。
要收集某个位置的所有异常，请使用 REJECTED DATA AS TABLE 子句，异常会自动列在表的 rejected_reason 列中。
ON nodename 子句将 nodename 上的现有异常文件移至同一节点上所示的 path。有关详细信息，请参阅保存加载异常 (EXCEPTIONS)。
如果将此参数与 COPY...ON ANY NODE 一起使用，则仍必须为异常文件指定单独的节点，如以下示例中所示：
EXCEPTIONS '/home/ex01.txt' on v_db_node0001,'/home/ex02.txt'
on v_db_node0002,'/home/ex03.txt' on v_db_node0003
如果 path 解析为存储位置，则以下权限适用于非超级用户：
必须使用 USER 选项创建存储位置（请参阅 CREATE LOCATION）。
用户必须具有文件所在存储位置的 READ 权限，如 GRANT（存储位置）中所述。
REJECTED DATA此参数的语法为：
REJECTED DATA
{ 'path' [ ON nodename ] [,...] | AS TABLE reject-table }
Vertica 可以将被拒绝的数据写入指定路径或表：
'path' [ON nodename]：将被拒绝的行数据复制到执行加载的节点上的指定路径。如果通过 ON nodename 进行限定，Vertica 会将 nodename 上现有的被拒绝的数据文件移至同一节点上的 path。
path 的值可以是目录，也可以是文件前缀。如果存在多个加载源，会始终将 path 视为目录。如果不存在多个加载源，但 path 以 '/' 结尾，或者如果该名称的目录已经存在，则也会将其视为目录。否则，会将 path 视为文件前缀。
文件将被写入执行加载的一个或多个节点上。如果文件已经存在，其将被覆盖。
当将此参数与 LOCAL 结合使用时，输出将写入客户端。
AS TABLE reject-table：将被拒绝的行保存到 reject-table。
有关这两个选项的详细信息，请参阅处理杂乱的数据。
REJECTMAX integerREJECTMAX 禁用分摊加载。
SKIP integer限制： 对 ORC 或 Parquet 数据无效
STREAM NAME无效的流名称包含长度最多为 128 字节的字母数字字符或特殊字符组合。
例如：
=> COPY mytable FROM myfile
DELIMITER '|' STREAM NAME 'My stream name';
WITH parser默认情况下，COPY 在 UTF-8 格式下使用 DELIMITER 解析器，分隔文本输入数据。如果未直接指定 DELIMITER 解析器，则缺少特定解析器将表示使用默认设置。
要为列表使用 Flex 表解析器，请使用 PARSER 参数，后跟 Flex 表解析器实参。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。
加载到 Flex 表时，必须使用兼容的解析器。有关支持的 Flex 表解析器，请参阅将数据批量加载到 Flex 表中。
COPY LOCAL 不支持 NATIVE、NATIVE VARCHAR、ORC 和 PARQUET 解析器。
有关复杂数据类型支持的解析器，请参阅特定解析器的文档。
NO COMMIT有关详细信息，请参阅使用事务暂存加载。
限制： 对 ORC 或 Parquet 数据无效，将被 CREATE EXTERNAL TABLE AS COPY 忽略
以下选项仅在使用特定解析器时适用。
DELIMITER表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。
默认值： 竖线 ('|')。
ENCLOSED [BY]设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。
ESCAPE [AS]设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。
COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：
ESCAPE [AS]
DELIMITER
ENCLOSED [BY]
RECORD TERMINATOR
All COLLECTION 选项
默认值： 反斜线 ('\')。
NO ESCAPE消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。
RECORD TERMINATORTRAILING NULLCOLSCOLLECTIONDELIMITER对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。
默认值： 逗号 (',')。
COLLECTIONOPEN， COLLECTIONCLOSE对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。
默认值： 方括号（'[' 和 ']'）。
COLLECTIONNULLELEMENT该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。
默认值： 'null'
COLLECTIONENCLOSE对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。
没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。
默认： 双引号（'"'）
SKIP BYTES integerTRIMCOPY 具有以下限制：
COPY 认为以下数据无效：
缺失列（输入行的列数少于接收表的列数）。
多余列（输入行的列数多于接收表的列数）。
INTEGER 或 DATE/TIME 数据类型的空列。对于这些类型中的任何一种，如果某列是空的，则 COPY 将不会使用 CREATE TABLE 命令定义的默认值。但是，如果您在 COPY 语句中未提供列选项，则将使用默认值。
某个数据类型的表示不正确。例如，尝试将非数字值加载到 INTEGER 列的操作是无效的。
如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。
若 COPY 在加载数据时遇到空行，则既不会插入也不会拒绝该行，但 COPY 将递增行记录编号。评估被拒绝的记录时，请考虑此行为。如果您要返回被拒绝记录的列表，而 COPY 在加载数据时遇到空行，则被拒绝记录的位置将不会递增 1，如以下示例中所示。
该示例首先将值加载到将第一列定义为 INT 的表中。请注意第 3、4 和 8 行中的错误：
=> \! cat -n /home/dbadmin/test.txt
1 1|A|2
2 2|B|4
3 A|D|7
4 A|E|7
5
6
7 6|A|3
8 B|A|3
空行（5 和 6）会将错误报告转移到第 8 行：
=> SELECT row_number, rejected_data, rejected_reason FROM test_bad;
row_number | rejected_data | rejected_reason
------------+---------------+----------------------------------------------
3 | A|D|7 | Invalid integer format 'A' for column 1 (c1)
4 | A|E|7 | Invalid integer format 'A' for column 1 (c1)
6 | B|A|3 | Invalid integer format 'B' for column 1 (c1)
(3 rows)
加载压缩文件时，如果文件似乎已损坏，则 COPY 可能会中止并报告错误。例如，读取头块失败时，可能发生此行为。
表和架构可以设置磁盘配额。如果加载违反任一配额，操作将失败。有关详细信息，请参阅磁盘配额。
Vertica 支持多种解析器以加载不同类型的数据。如下所述，某些解析器仅用于 Flex 表。
使用 DELIMITED 解析器（默认）通过 COPY 加载分隔的文本数据。您可以指定分隔符、转义字符、如何处理空值以及其他参数。
DELIMITED 解析器支持读取标量类型的一维集合（数组或集）。
DELIMITED 解析器同时支持分摊加载和协作解析。
以下选项特定于此解析器。有关其他适用选项，请参阅参数。
DELIMITER表示一个 ASCII 字符，用于分隔文件中每条记录内的各个列。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。不能对 DELIMITER 和 NULL 参数使用相同的字符。有关详细信息，请参阅分隔数据。
默认值： 竖线 ('|')。
ENCLOSED [BY]设置在要其内封装数据的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。默认情况下，ENCLOSED BY 没有值，即数据不会被任何类型的引号字符包围。
ESCAPE [AS]设置转义字符。设置后，转义字符后面的字符将按字面意思解释，而不是解释为特殊字符。您可以使用 E'\001' 至 E'\177'（包含）范围内的任何 ASCII 值来定义转义字符（包括除 NULL 以外的任何 ASCII 字符：E'\000'）。
COPY 语句不会将它读取的数据解释为字符串字面量。它也不遵循与其他 SQL 语句（包括 COPY 参数）相同的转义规则。读入数据时，COPY 仅解释被以下选项定义为特殊值的字符：
ESCAPE [AS]
DELIMITER
ENCLOSED [BY]
RECORD TERMINATOR
All COLLECTION 选项
默认值： 反斜线 ('\')。
NO ESCAPE消除转义字符处理。如果不需要任何转义字符并且想要防止数据中的字符不被解释为转义序列，则使用该选项。
RECORD TERMINATORTRAILING NULLCOLSCOLLECTIONDELIMITER对于集合类型的列，表示用于分隔每个集合中元素的单个 ASCII 字符。您可以使用 E'\000' 到 E'\177'（包含）范围内的任何 ASCII 值。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。
默认值： 逗号 (',')。
COLLECTIONOPEN， COLLECTIONCLOSE对于集合类型的列，这些选项指示标记集合开头和结尾的字符。在元素列表中的其他地方使用这些字符而不转义它们是错误的。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。
默认值： 方括号（'[' 和 ']'）。
COLLECTIONNULLELEMENT该字符串表示集合中空元素值。可将一个 null 值指定为在范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 值：E'\000'）。没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。有关详细信息，请参阅分隔数据。
默认值： 'null'
COLLECTIONENCLOSE对于集合类型的列，设置在要其内封装单个元素的引号字符，允许分隔字符嵌套在字符串值中。可选择范围包含在 E'\001' 至 E'\177'（包含）的任何 ASCII 值（包括除 NULL 以外的任何 ASCII 字符）：E'\000'）。
没有任何 COLLECTION 选项可能具有与任何其他 COLLECTION 选项相同的值。
默认： 双引号（'"'）
以下示例显示了默认行为，其中分隔符为 '|'
=> CREATE TABLE employees (id INT, name VARCHAR(50), department VARCHAR(50));
CREATE TABLE
=> COPY employees FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|Physics
>> 17|Howard Wolowitz|Astronomy
>> \.
=> SELECT * FROM employees;
id | name | department
----+-----------------+--------------
17 | Howard Wolowitz | Astrophysics
42 | Sheldon Cooper | Physics
(2 rows)
以下示例显示如何使用默认选项加载数组值。
=> CREATE TABLE researchers (id INT, name VARCHAR, grants ARRAY[VARCHAR], values ARRAY[INT]);
CREATE TABLE
=> COPY researchers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42|Sheldon Cooper|[US-7376,DARPA-1567]|[65000,135000]
>> 17|Howard Wolowitz|[NASA-1683,NASA-7867,SPX-76]|[16700,85000,45000]
>> \.
=> SELECT * FROM researchers;
id | name | grants | values
----+-----------------+------------------------------------+---------------------
17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
42 | Sheldon Cooper | ["US-7376","DARPA-1567"] | [65000,135000]
(2 rows)
在以下示例中，集合括在大括号中并由句点分隔，且数组包含空值。
=> COPY researchers FROM STDIN COLLECTIONOPEN '{' COLLECTIONCLOSE '}' COLLECTIONDELIMITER '.';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 19|Leonard|{"us-1672".null."darpa-1963"}|{16200.null.16700}
>> \.
=> SELECT * FROM researchers;
id | name | grants | values
----+-----------------+------------------------------------+---------------------
17 | Howard Wolowitz | ["NASA-1683","NASA-7867","SPX-76"] | [16700,85000,45000]
42 | Sheldon Cooper | ["US-7376","DARPA-1567"] | [65000,135000]
19 | Leonard | ["us-1672",null,"darpa-1963"] | [16200,null,16700]
(3 rows)
解析来自 Avro 文件的数据。需要满足以下要求：
Avro 文件必须以 Avro 二进制序列化编码格式进行编码，如 Apache Avro 标准中所述。解析器还支持 Snappy 和 deflate 压缩。
FAVROPARSER 不支持包含单独架构文件的 Avro 文件。Avro 文件必须包含架构。
您可以使用强类型加载 Avro 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型进行加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。
加载到 Flex 表中时，Vertica 会将所有数据加载到 __raw__ (VMap) 列中，包括数据中的复杂类型。
此解析器不支持分摊加载或协作解析。
FAVROPARSER ( [parameter=value[,...]] )
flatten_maps此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。
默认值：true
flatten_arrays此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。
默认值：false
flatten_records此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。
默认值：true
reject_on_materialized_type_error布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。
如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。
默认值：false
FAVROPARSER 支持以下基元数据类型，包括复杂类型中的元素类型和字段值。
FAVROPARSER 支持以下 Avro 逻辑类型。目标列必须使用支持逻辑类型的 Vertica 数据类型。当尝试使用无效的逻辑类型加载数据时，将忽略此逻辑类型并使用基础 Avro 类型。
Avro 格式支持某些复杂数据类型。加载到强类型列时，您可以使用 ROW 和 ARRAY 类型来表示这些类型。例如，Avro Record 和 Enums 为结构 (ROW)；请参阅 Avro 规范。
您可以使用 ARRAY[ROW] 来匹配 Avro 映射。必须将 ROW 字段命名为 key 和 value。这些是 Avro 格式用于数据中的字段的名称，解析器通过字段名称将数据与表列进行匹配。
当加载到 Flex 表或使用灵活的复杂类型时，此解析器会按如下方式处理 Avro 复杂类型：
各字段的名称被用作虚拟列名称。如果 flatten_records 为 true，且存在几个嵌套级别，Vertica 将连接 record 名称以创建键名。
每个 map 键的值被用作虚拟列名称。如果 flatten_maps 为 true，且存在几个嵌套级别，Vertica 将连接所有键名以创建键名。
Vertica 将 Avro Enum 视为 record，将 Enum 的名称作为键，将其值作为值。
Vertica 将 Avro Array 视为键/值对。默认情况下，每个元素的索引作为键。在以下示例中，product_detail 是一个包含字段 product_category 的 Record，即一个 Array：
=> CREATE FLEX TABLE products;
CREATE TABLE
=> COPY products FROM :datafile WITH PARSER FAVROPARSER();
Rows Loaded
-------------
2
(1 row)
=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
maptostring
--------------------------------------------------------------------------------
{
"__name__": "Order",
"customer_id": "111222",
"order_details": {
"0.__name__": "OrderDetail",
"0.product_detail.__name__": "Product",
"0.product_detail.price": "46.21",
"0.product_detail.product_category": {
"0": "electronics",
"1": "printers",
"2": "computers"
},
"0.product_detail.product_description": "hp printer X11ew description :\
P",
"0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0004",
"0.product_detail.product_id": "999012",
"0.product_detail.product_map.one": "1.1",
"0.product_detail.product_map.two": "1.1",
"0.product_detail.product_name": "hp printer X11ew",
"0.product_detail.product_status": "ONLY_FEW_LEFT",
"0.quantity": "3",
"0.total": "354.34"
},
"order_id": "2389646",
"total": "132.43"
}
...
如果 flatten_arrays 为 true，且存在几个嵌套级别，Vertica 将连接索引以创建键名。
=> COPY products FROM :datafile WITH PARSER FAVROPARSER(flatten_arrays=true);
Rows Loaded
-------------
2
(1 row)
=> SELECT MAPTOSTRING(__raw__) FROM products ORDER BY __identity__;
maptostring
--------------------------------------------------------------------------------
{
"__name__": "Order",
"customer_id": "111222",
"order_details.0.__name__": "OrderDetail",
"order_details.0.product_detail.__name__": "Product",
"order_details.0.product_detail.price": "46.21",
"order_details.0.product_detail.product_category.0": "electronics",
"order_details.0.product_detail.product_category.1": "printers",
"order_details.0.product_detail.product_category.2": "computers",
"order_details.0.product_detail.product_description": "hp printer X11ew des\
cription :P",
"order_details.0.product_detail.product_hash": "\u0000\u0001\u0002\u0003\u0\
004",
"order_details.0.product_detail.product_id": "999012",
"order_details.0.product_detail.product_map.one": "1.1",
"order_details.0.product_detail.product_map.two": "1.1",
"order_details.0.product_detail.product_name": "hp printer X11ew",
"order_details.0.product_detail.product_status": "ONLY_FEW_LEFT",
"order_details.0.quantity": "3",
"order_details.0.total": "354.34",
"order_id": "2389646",
"total": "132.43"
}
...
Vertica 将 Avro Union 视为 Array。
此示例演示了如何使用 favroparser 创建 Flex 表并将 Avro 数据加载到其中。加载数据后，您可以查询虚拟列：
=> CREATE FLEX TABLE avro_basic();
CREATE TABLE
=> COPY avro_basic FROM '/home/dbadmin/data/weather.avro' PARSER FAVROPARSER();
Rows Loaded
-------------
5
(1 row)
=> SELECT station, temp, time FROM avro_basic;
station | temp | time
---------+------+---------------
mohali | 0 | -619524000000
lucknow | 22 | -619506000000
norwich | -11 | -619484400000
ams | 111 | -655531200000
baddi | 78 | -655509600000
(5 rows)
有关详细信息，请参阅Avro 数据。
解析并加载 JSON 文件。此文件可能包含重复的 JSON 数据对象（包括嵌套映射）或 JSON 元素的外部列表。
加载到 Flex 表或混合表中时，解析器将 JSON 数据存储在单值 VMap 中。加载到混合表或列式表中时，解析器将数据直接加载到列名称与 JSON 源数据键相匹配的任何表列。
您可以使用强类型加载 JSON 源（数组、结构或组合）中的复杂类型，或将其作为灵活的复杂类型加载。将灵活的复杂类型加载到 VMap 列中的操作与加载到 Flex 表中一样。要加载复杂类型作为 VMap 列，请将列类型指定为 LONG VARBINARY。要保留复杂类型的索引，请将 flatten_maps 设置为 false。
仅当指定了 record_terminator 时，FJSONPARSER 才支持 协作解析。它不支持分摊加载。
FJSONPARSER ( [parameter=value[,...]] )
flatten_maps.) 分隔映射层级。此值会影响加载中的所有数据，包括嵌套映射。
此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。
默认值：true
flatten_arrays此参数仅适用于 Flex 表或 VMap 列，且会在加载强类型复杂类型时被忽略。
默认值：false
reject_on_duplicate默认值：false
reject_on_empty_key默认值：false
omit_empty_keys默认值：false
record_terminatorE'\n')。如果存在任何无效的 JSON 记录，则在下一个 record_terminator 之后继续解析。
即使数据不包含无效的记录，也可以指定显式记录终止符，这样可以提高协作解析和分摊加载的运行效率，从而提升加载性能。
如果忽略此参数，解析将在第一条无效 JSON 记录处结束。
reject_on_materialized_type_error布尔值，是否拒绝包含无法强制转换为兼容数据类型的实体化列值的数据行。如果值为 false 且无法强制类型，则解析器将该列中的值设置为 null。
如果该列是强类型复杂类型，而不是可变复杂类型，则复杂类型中的类型不匹配将导致整个列被视为不匹配。解析器不会部分加载复杂类型。
默认值：false
start_pointstart_point 值之前的所有数据。将为文件中的每个对象加载该值。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。start_point_occurrencestart_point 指定的值的第 n 次出现。如果数据具有多个起始值，而且您知道要在其第几次出现时开始解析，请与 start_point 结合使用。
默认值： 1
suppress_nonalphanumeric_key_chars_) 替换这些字符。
默认值：false
key_separator默认： 句点 (.)
以下示例使用默认参数从 STDIN 加载 JSON 数据：
=> CREATE TABLE people(age INT, name VARCHAR);
CREATE TABLE
=> COPY people FROM STDIN PARSER FJSONPARSER();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"age": 5, "name": "Tim"}
>> {"age": 3}
>> {"name": "Fred"}
>> {"name": "Bob", "age": 10}
>> \.
=> SELECT * FROM people;
age | name
-----+------
| Fred
10 | Bob
5 | Tim
3 |
(4 rows)
以下示例使用 reject_on_duplicate 参数拒绝重复值：
=> CREATE FLEX TABLE json_dupes();
CREATE TABLE
=> COPY json_dupes FROM stdin PARSER fjsonparser(reject_on_duplicate=true)
exceptions '/home/dbadmin/load_errors/json_e.out'
rejected data '/home/dbadmin/load_errors/json_r.out';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"a":"1","a":"2","b":"3"}
>> \.
=> \!cat /home/dbadmin/load_errors/json_e.out
COPY: Input record 1 has been rejected (Rejected by user-defined parser).
Please see /home/dbadmin/load_errors/json_r.out, record 1 for the rejected record.
COPY: Loaded 0 rows, rejected 1 rows.
以下示例将加载数组数据：
$ cat addrs.json
{"number": 301, "street": "Grant", "attributes": [1, 2, 3, 4]}
=> CREATE EXTERNAL TABLE customers(number INT, street VARCHAR, attributes ARRAY[INT])
AS COPY FROM 'addrs.json' PARSER fjsonparser();
=> SELECT number, street, attributes FROM customers;
num | street| attributes
-----+-----------+---------------
301 | Grant | [1,2,3,4]
(1 row)
以下示例将加载一个灵活的复杂类型，同时拒绝嵌套记录中具有空键的行。请注意，虽然数据包含两家餐厅，但其中一家的键名是空字符串。此餐厅将被拒绝：
$ cat rest1.json
{
"name" : "Bob's pizzeria",
"cuisine" : "Italian",
"location_city" : ["Cambridge", "Pittsburgh"],
"menu" : [{"item" : "cheese pizza", "" : "$8.25"},
{"item" : "spinach pizza", "price" : "$10.50"}]
}
{
"name" : "Bakersfield Tacos",
"cuisine" : "Mexican",
"location_city" : ["Pittsburgh"],
"menu" : [{"item" : "veggie taco", "price" : "$9.95"},
{"item" : "steak taco", "price" : "$10.95"}]
}
=> CREATE TABLE rest (name VARCHAR, cuisine VARCHAR, location_city LONG VARBINARY, menu LONG VARBINARY);
=> COPY rest FROM '/data/rest1.json'
PARSER fjsonparser(flatten_maps=false, reject_on_empty_key=true);
Rows Loaded
------------
1
(1 row)
=> SELECT maptostring(location_city), maptostring(menu) FROM rest;
maptostring | maptostring
---------------------------+-------------------------------------------------------
{
"0": "Pittsburgh"
} | {
"0": {
"item": "veggie taco",
"price": "$9.95"
},
"1": {
"item": "steak taco",
"price": "$10.95"
}
}
(1 row)
要改为加载部分数据，请使用 omit_empty_keys 在加载其他所有内容时绕过缺失键：
=> COPY rest FROM '/data/rest1.json'
PARSER fjsonparser(flatten_maps=false, omit_empty_keys=true);
Rows Loaded
-------------
2
(1 row)
=> SELECT maptostring(location_city), maptostring(menu) from rest;
maptostring | maptostring
-------------------------------------------------+---------------------------------
{
"0": "Pittsburgh"
} | {
"0": {
"item": "veggie taco",
"price": "$9.95"
},
"1": {
"item": "steak taco",
"price": "$10.95"
}
}
{
"0": "Cambridge",
"1": "Pittsburgh"
} | {
"0": {
"item": "cheese pizza"
},
"1": {
"item": "spinach pizza",
"price": "$10.50"
}
}
(2 rows)
要改为使用强类型加载此数据，请在表中定义复杂类型：
=> CREATE EXTERNAL TABLE restaurants
(name VARCHAR, cuisine VARCHAR,
location_city ARRAY[VARCHAR(80)],
menu ARRAY[ ROW(item VARCHAR(80), price FLOAT) ]
)
AS COPY FROM '/data/rest.json' PARSER fjsonparser();
=> SELECT * FROM restaurants;
name | cuisine | location_city | \
menu
-------------------+---------+----------------------------+--------------------\
--------------------------------------------------------
Bob's pizzeria | Italian | ["Cambridge","Pittsburgh"] | [{"item":"cheese pi\
zza","price":0.0},{"item":"spinach pizza","price":0.0}]
Bakersfield Tacos | Mexican | ["Pittsburgh"] | [{"item":"veggie ta\
co","price":0.0},{"item":"steak taco","price":0.0}]
(2 rows)
有关其他示例，请参阅 JSON 数据。
使用包含 COPY 语句的 ORC 子句以 ORC 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。
加载 ORC 数据时，必须考虑数据中的所有列；不能只选择某些列。
如果表定义包含基元类型的列，且这些列不存在于数据中，则解析器将使用 NULL 填充这些列。如果表定义包含复杂类型的列，则这些列必须存在于数据中。
此解析器不支持分摊加载或协作解析。
ORC ( [ parameter=value[,...] ] )
所有参数均为可选参数。
hive_partition_colsallow_no_matchORC 子句不使用 PARSER 选项：
=> CREATE EXTERNAL TABLE orders (...)
AS COPY FROM 's3://DataLake/orders.orc' ORC;
可以将映射列读取为行数组，如以下示例中所示：
=> CREATE EXTERNAL TABLE orders
(orderkey INT,
custkey INT,
prods ARRAY[ROW(key VARCHAR(10), value DECIMAL(12,2))],
orderdate DATE
) AS COPY FROM '...' ORC;
使用包含 COPY 语句的 PARQUET 解析器以 Parquet 格式加载数据。将数据加载到 Vertica 时，可读取所有基元类型、UUID 和复杂类型。
默认情况下，Parquet 解析器使用强架构匹配，这意味着数据中的列必须与使用数据的表中的列完全匹配。您可以选择使用弱架构匹配。
加载 Parquet 数据时，Vertica 会缓存 Parquet 元数据以提升效率。此缓存使用本地 TEMP 存储，如果 TEMP 为远程存储，则不使用。请参阅 ParquetMetadataCacheSizeMB 配置参数来更改缓存的大小。
此解析器不支持分摊加载或协作解析。
PARQUET ( [ parameter=value[,...] ] )
所有参数均为可选参数。
hive_partition_colsallow_no_matchallow_long_varbinary_match_complex_typedo_soft_schema_match_by_namereject_on_materialized_type_errordo_soft_schema_match_by_name 为 true 时适用。指定在使用弱架构匹配且无法将值从数据强制转换为目标列类型时要执行的操作。值为 true（默认值）表示拒绝行；值为 false 表示使用 NULL 作为值，或者截断（对于过长的字符串）。有关强制转换类型映射，请参阅类型强制转换表。默认情况下，Parquet 解析器使用强架构匹配。这意味着必须按照与数据中相同的顺序加载 Parquet 数据中的所有列。但是，有时您只想提取某些列，或者您希望能够适应未来 Parquet 架构中的一些更改。
使用 do_soft_schema_match_by_name 参数启用弱架构匹配。此设置具有以下影响：
数据中的列通过名称与表中的列匹配。名称必须完全匹配，但不区分大小写。
在 Parquet 数据中存在但不属于表定义的列将被忽略。
在表定义中存在但不属于 Parquet 数据的列将用 NULL 填充。解析器在 QUERY_EVENTS 中记录 UNMATCHED_TABLE_COLUMNS_PARQUETPARSER 事件。
如果 Parquet 数据中存在多个不区分大小写的相同列名，解析器将使用最后一个。（当使用通过区分大小写的工具写入的数据时，可能会出现这种情况。）
列类型不需要完全匹配，只要可以将 Parquet 文件中的数据类型强制转换为表使用的类型即可。如果无法强制转换某个类型，解析器会在 QUERY_EVENTS 中记录 TYPE_MISMATCH_COLUMNS_PARQUETPARSER 事件。如果 reject_on_materialized_type_error 为 true，解析器将拒绝行。如果为 false，解析器将使用 NULL，或者对于过长的字符串值，将截断该值。
可以定义但不能查询使用复杂类型（基元类型的一维数组除外）的列。
Parquet 解析器将 Parquet 数据类型映射到 Vertica 数据类型，如下所示。
以下逻辑类型不受支持：
Parquet 解析器支持以下物理类型的映射：
Vertica 仅支持 3 级编码的数组，不支持 2 级编码的数组。
PARQUET 子句不使用 PARSER 选项：
=> COPY sales FROM 's3://DataLake/sales.parquet' PARQUET;
在以下示例中，数据目录不包含文件：
=> CREATE EXTERNAL TABLE customers (...)
AS COPY FROM 'webhdfs:///data/*.parquet' PARQUET;
=> SELECT COUNT(*) FROM customers;
ERROR 7869: No files match when expanding glob: [webhdfs:///data/*.parquet]
要读取零行而不是生成错误，请使用 allow_no_match 参数：
=> CREATE EXTERNAL TABLE customers (...)
AS COPY FROM 'webhdfs:///data/*.parquet'
PARQUET(allow_no_match='true');
=> SELECT COUNT(*) FROM customers;
count
-------
0
(1 row)
要允许将复杂类型（在此示例中为菜单）作为灵活的列类型进行读取，请使用 allow_long_varbinary_match_complex_type 参数：
=> CREATE EXTERNAL TABLE restaurants
(name VARCHAR, cuisine VARCHAR, location_city ARRAY[VARCHAR], menu LONG VARBINARY)
AS COPY FROM '/data/rest*.parquet'
PARQUET(allow_long_varbinary_match_complex_type='True');
要仅读取餐厅数据中的某些列，请使用弱架构匹配：
=> CREATE EXTERNAL TABLE restaurants(name VARCHAR, cuisine VARCHAR)
AS COPY FROM '/data/rest*.parquet'
PARQUET(allow_long_varbinary_match_complex_type='True',
do_soft_schema_match_by_name='True');
=> SELECT * from restaurant;
name | cuisine
-------------------+----------
Bob's pizzeria | Italian
Bakersfield Tacos | Mexican
(2 rows)
解析 ArcSight 通用事件格式 (CEF) 日志文件。该解析器将值直接加载到列名称与源数据键相匹配的任何表列中。该解析器可将加载到 Flex 表中的数据存储在单个 VMap 中。
该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。
FAVROPARSER ( [parameter‑name='value'[,...]] )
delimiter 默认值： ' '
record_terminator **默认 **** 值： **newline
trim 默认值： true
reject_on_unescaped_delimiter 默认值： false
以下示例演示了为 CEF 数据创建 Flex 表的示例，该表包含两个实际列，eventId 和 priority。
创建 Flex 表 cefdata：
=> create flex table cefdata();
CREATE TABLE
使用 Flex 解析器 fcefparser 加载一些基本的 CEF 数据：
=> copy cefdata from stdin parser fcefparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> CEF:0|ArcSight|ArcSight|2.4.1|machine:20|New alert|High|
>> \.
使用 maptostring() 函数查看 cefdata Flex 表的内容：
=> select maptostring(__raw__) from cefdata;
maptostring
-------------------------------------------------------------
{
"deviceproduct" : "ArcSight",
"devicevendor" : "ArcSight",
"deviceversion" : "2.4.1",
"name" : "New alert",
"severity" : "High",
"signatureid" : "machine:20",
"version" : "0"
}
(1 row)
从 cefdata Flex 表中选择一些虚拟列：
= select deviceproduct, severity, deviceversion from cefdata;
deviceproduct | severity | deviceversion
---------------+----------+---------------
ArcSight | High | 2.4.1
(1 row)
有关详细信息，请参阅 通用事件格式 (CEF) 数据
解析 CSV 格式（逗号分隔值）的数据。使用此解析器将 CSV 数据加载至列式表、Flex 表和混合表中。所有数据均必须以 Unicode UTF-8 格式进行编码。fcsvparser 解析器支持 CSV 数据的 RFC 4180 标准和其他选项，以适应 CSV 文件格式定义的变化。无效记录被拒绝。有关数据格式的详细信息，请参阅处理非 UTF-8 输入。
该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。
FCSVPARSER ( [parameter='value'[,...]] )
typerfc4180
traditional
您在加载符合 RFC 4180 标准的数据（如 MS Excel 文件）时，无须使用 type 参数。请参阅加载 CSV 数据，以了解 RFC4180 的默认参数以及您可为传统 CSV 文件指定的其他选项。
默认值： RFC4180
delimiter默认值： ,（对于 rfc4180 和 traditional）
escape默认值：
rfc4180： "
traditional： \\
enclosed_byenclosed_by 包括一个与分隔符完全相同但应该按字面解释的值。例如，如果数据分隔符为逗号 (,)，则您要在数据 ("my name is jane, and his is jim") 中使用逗号。
默认值： "
record_terminator默认值：
rfc4180： \n
traditional： \r\n
headerheader=true（默认）且不存在标题时，fcsvparser 使用默认列标题。默认标题由
ucoln 组成，其中 n 为列偏移数，第一列为 0。您可以使用 header_names 参数指定自定义列标题名称，如下所述。
如果您指定 header=false，则 fcsvparser 会将输入的第一行解析为数据，而不是列标题。
默认值： true
header_namestrim默认值： true
omit_empty_keysheader 行中的空值键。
默认值： false
reject_on_duplicate默认值：false
reject_on_empty_key默认值：false
reject_on_materialized_type_error默认值：false
此示例展示了如何使用 fcsvparser 加载 Flex 表，构建视图，然后查询该视图。
为 CSV 数据创建 Flex 表：
=> CREATE FLEX TABLE rfc();
CREATE TABLE
使用 fcsvparser 加载来自 STDIN 的数据。指定不存在标题，然后按如下方式输入一些数据：
=> COPY rfc FROM stdin PARSER fcsvparser(header='false');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 10,10,20
>> 10,"10",30
>> 10,"20""5",90
>> \.
运行 compute_flextable_keys_and_build_view 函数，然后查询 rfc_view。请注意，默认的 enclosed_by 字符允许字段 ("20""5") 内出现转义字符 (")。因此，所得到的值得以正确解析。由于输入数据中不存在标题，函数为各列添加了
ucoln：
=> SELECT compute_flextable_keys_and_build_view('rfc');
compute_flextable_keys_and_build_view
--------------------------------------------------------------------------------------------
Please see public.rfc_keys for updated keys
The view public.rfc_view is ready for querying
(1 row)
=> SELECT * FROM rfc_view;
ucol0 | ucol1 | ucol2
-------+-------+-------
10 | 10 | 20
10 | 10 | 30
10 | 20"5 | 90
(3 rows)
有关使用此解析器其他参数的详细信息和示例，请参阅加载 CSV 数据。
解析分隔的数据文件。此解析器提供了解析器 fdelimitedparser 功能的一个子集。当您要加载的数据指定成对列名称且每行均有数据时，使用 fdelimitedpairparser。
该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。
FDELIMITEDPAIRPARSER ( [parameter‑name='value'[,...]] )
delimiter 默认值： ' '
record_terminator 默认值： 换行符
trim 默认值： true
以下示例演示了为简单分隔数据创建示例 Flex 表，该表包含两个实际列，分别为 eventId 和 priority。
创建一个表：
=> create flex table CEFData(eventId int default(eventId::int), priority int default(priority::int) );
CREATE TABLE
使用 fcefparser 将示例分隔的 Micro Focus ArcSight 日志文件加载到 CEFData 表中：
=> copy CEFData from '/home/release/kmm/flextables/sampleArcSight.txt' parser fdelimitedpairparser();
Rows Loaded | 200
加载示例数据文件后，使用 maptostring() 在 CEFData 的 __raw__ 列中显示虚拟列：
=> select maptostring(__raw__) from CEFData limit 1; maptostring
-----------------------------------------------------------
"agentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
"agentzone" : "3083",
"agt" : "265723237",
"ahost" : "svsvm0176",
"aid" : "3tGoHuD0BABCCMDVAeX21vg==",
"art" : "1099267576901",
"assetcriticality" : "0",
"at" : "snort_db",
"atz" : "America/Los_Angeles",
"av" : "5.3.0.19524.0",
"cat" : "attempted-recon",
"categorybehavior" : "/Communicate/Query",
"categorydevicegroup" : "/IDS/Network",
"categoryobject" : "/Host",
"categoryoutcome" : "/Attempt",
"categorysignificance" : "/Recon",
"categorytechnique" : "/Scan",
"categorytupledescription" : "An IDS observed a scan of a host.",
"cnt" : "1",
"cs2" : "3",
"destinationgeocountrycode" : "US",
"destinationgeolocationinfo" : "Richardson",
"destinationgeopostalcode" : "75082",
"destinationgeoregioncode" : "TX",
"destinationzone" : "3133",
"device product" : "Snort",
"device vendor" : "Snort",
"device version" : "1.8",
"deviceseverity" : "2",
"dhost" : "198.198.121.200",
"dlat" : "329913940429",
"dlong" : "-966644973754",
"dst" : "3334896072",
"dtz" : "America/Los_Angeles",
"dvchost" : "unknown:eth1",
"end" : "1364676323451",
"eventid" : "1219383333",
"fdevice product" : "Snort",
"fdevice vendor" : "Snort",
"fdevice version" : "1.8",
"fdtz" : "America/Los_Angeles",
"fdvchost" : "unknown:eth1",
"lblstring2label" : "sig_rev",
"locality" : "0",
"modelconfidence" : "0",
"mrt" : "1364675789222",
"name" : "ICMP PING NMAP",
"oagentassetid" : "4-WwHuD0BABCCQDVAeX21vg==",
"oagentzone" : "3083",
"oagt" : "265723237",
"oahost" : "svsvm0176",
"oaid" : "3tGoHuD0BABCCMDVAeX21vg==",
"oat" : "snort_db",
"oatz" : "America/Los_Angeles",
"oav" : "5.3.0.19524.0",
"originator" : "0",
"priority" : "8",
"proto" : "ICMP",
"relevance" : "10",
"rt" : "1099267573000",
"severity" : "8",
"shost" : "198.198.104.10",
"signature id" : "[1:469]",
"slat" : "329913940429",
"slong" : "-966644973754",
"sourcegeocountrycode" : "US",
"sourcegeolocationinfo" : "Richardson",
"sourcegeopostalcode" : "75082",
"sourcegeoregioncode" : "TX",
"sourcezone" : "3133",
"src" : "3334891530",
"start" : "1364676323451",
"type" : "0"
}
(1 row)
选择 eventID 和 priority 实际列以及两个虚拟列 atz 和 destinationgeoregioncode：
=> select eventID, priority, atz, destinationgeoregioncode from CEFData limit 10;
eventID | priority | atz | destinationgeoregioncode
------------+----------+---------------------+--------------------------
1218325417 | 5 | America/Los_Angeles |
1219383333 | 8 | America/Los_Angeles | TX
1219533691 | 9 | America/Los_Angeles | TX
1220034458 | 5 | America/Los_Angeles | TX
1220034578 | 9 | America/Los_Angeles |
1220067119 | 5 | America/Los_Angeles | TX
1220106960 | 5 | America/Los_Angeles | TX
1220142122 | 5 | America/Los_Angeles | TX
1220312009 | 5 | America/Los_Angeles | TX
1220321355 | 5 | America/Los_Angeles | CA
(10 rows)
使用分隔符分隔值，从而解析数据。fdelimitedparser 加载分隔数据，将其存储在单值 VMap 中。
该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。
fdelimitedparser 将空字段视为 NULL，而不是空字符串 ('')。这种行为使转换更容易。将 NULL 转换成整数 (NULL::int) 是有效的，而将空字符串转换成整数 (''::int) 则是无效的。如有需要，请使用 treat_empty_val_as_null 参数更改 fdelimitedparser 的默认行为。
FDLIMITEDPARSER ( [parameter‑name='value'[,...]] )
delimiter 默认值： |
record_terminator 默认值： \n
trim 默认值： true
header col### 为列命名。
默认值： true
omit_empty_keys omit_empty_keys=true，则不加载 header 行中的空值键。
默认值： false
reject_on_duplicate false)，还是拒绝重复记录 (true)。在任何一种情况下，都会继续加载。
默认值： false
reject_on_empty_key 默认值： false
reject_on_materialized_type_error 默认值： false
treat_empty_val_as_null NULLs，而不是变为空字符串 ('')。
默认值： true
为分隔数据创建 Flex 表：
t=> CREATE FLEX TABLE delim_flex ();
CREATE TABLE
使用 fdelimitedparser 加载些来自 STDIN 的分隔数据，并指定逗号 (,) 列分隔符：
=> COPY delim_flex FROM STDIN parser fdelimitedparser (delimiter=',');
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> deviceproduct, severity, deviceversion
>> ArcSight, High, 2.4.1
>> \.
您现在可以在 delim_flex Flex 表中查询虚拟列：
=> SELECT deviceproduct, severity, deviceversion from delim_flex;
deviceproduct | severity | deviceversion
---------------+----------+---------------
ArcSight | High | 2.4.1
(1 row)
解析正则表达式，将各列与指定正则表达式组的内容相匹配。
该解析器仅可用于 Flex 表。所有 Flex 解析器均会将数据作为单个 VMap 存储在 LONG VARBINAR_raw__ 列中。如果某个数据行过大而无法适应该列，该数据行将被拒绝。Vertica 在加载带 NULL 指定列的数据时支持 NULL 值。
FREGEXPARSER ( pattern=[parameter‑name='value'[,...]] )
pattern 默认值： 空字符串 ("")
use_jit 默认值：false
record_terminator 默认值： \n
logline_column 默认值： 空字符串 ("")
这些示例使用以下正则表达式，它们搜索包括 timestamp、date、thread_name 和 thread_id 字符串的信息。
此示例表达式加载任何 thread_id 十六进制值，无论其是否包含 0x 前缀 (<thread_id>(?:0x)?[0-9a-f]+)。
'^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
(?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'
创建一个 Flex 表 (vlog)，以包含 Vertica 日志文件的结果。针对此示例，我们复制了一份目录 /home/dbadmin/data/vertica.log 中的日志文件：
=> create flex table vlog1();
CREATE TABLE
将 fregexparser 用于示例正则表达式，以加载日志文件中的数据。请务必在使用此处显示的此表达式之前移除任何行字符：
=> copy vlog1 from '/home/dbadmin/tempdat/KMvertica.log'
PARSER FREGEXPARSER(pattern='^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
(?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'
);
Rows Loaded
-------------
31049
(1 row)
成功加载数据后，将 MAPTOSTRING() 函数用于表的 __raw__ 列。查询返回的四行 (limt 4) 为使用 fregexparser 解析的 KMvertica.log 文件的正则表达式结果。输出将显示前面带或不带 0x 的 thread_id 值：
=> select maptostring(__raw__) from vlog1 limit 4; maptostring ------------------------------------------------------------------------------------- { "text" : " [Init] <INFO> Log /home/dbadmin/VMart/v_vmart_node0001_catalog/vertica.log opened; #2", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Processing command line: /opt/vertica/bin/vertica -D /home/dbadmin/VMart/v_vmart_node0001_catalog -C VMart -n v_vmart_node0001 -h 10.20.100.247 -p 5433 -P 4803 -Y ipv4", "thread_id" : "0x7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Starting up Vertica Analytic Database v8.1.1-20170321", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } { "text" : " [Init] <INFO> Compiler Version: 4.8.2 20140120 (Red Hat 4.8.2-15)", "thread_id" : "7f2157e287c0", "thread_name" : "Main", "time" : "2017-03-21 23:30:01.704" } (4 rows)
有关其他 COPY 示例，请参阅特定解析器的参考页，包括：DELIMITED、ORC、PARQUET、FJSONPARSER 和 FAVROPARSER。
将 COPY 与 FORMAT、DELIMITER、NULL 和 ENCLOSED BY 选项结合使用：
=> COPY public.customer_dimension (customer_since FORMAT 'YYYY')
FROM STDIN
DELIMITER ','
NULL AS 'null'
ENCLOSED BY '"';
将 COPY 与 DELIMITER 和 NULL 选项结合使用。此示例设置并引用输入文件的 vsql 变量：
=> \set input_file ../myCopyFromLocal/large_table.gzip
=> COPY store.store_dimension
FROM :input_file
DELIMITER '|'
NULL ''
RECORD TERMINATOR E'\f';
创建一个表，然后将多个源文件复制到其中：
=> CREATE TABLE sampletab (a int);
CREATE TABLE
=> COPY sampletab FROM '/home/dbadmin/one.dat', 'home/dbadmin/two.dat';
Rows Loaded
-------------
2
(1 row)
使用通配符表示一组文件：
=> COPY myTable FROM 'webhdfs:///mydirectory/ofmanyfiles/*.dat';
通配符可以包含正则表达式：
=> COPY myTable FROM 'webhdfs:///mydirectory/*_[0-9]';
使用单个 COPY 语句指定多个路径：
=> COPY myTable FROM 'webhdfs:///data/sales/01/*.dat', 'webhdfs:///data/sales/02/*.dat',
'webhdfs:///data/sales/historical.dat';
加载所有节点共享的数据。如果可能，Vertica 会将加载操作分布到所有节点：
=> COPY sampletab FROM '/data/file.dat' ON ANY NODE;
从两个文件中加载数据。因为第一个加载文件未指定节点（或 ON ANY NODE），因此启动程序将执行加载操作。将加载第二个文件的操作分布到所有节点：
=> COPY sampletab FROM '/data/file1.dat', '/data/file2.dat' ON ANY NODE;
为每个加载文件指定不同的节点：
=> COPY sampletab FROM '/data/file1.dat' ON (v_vmart_node0001, v_vmart_node0002),
'/data/file2.dat' ON (v_vmart_node0003, v_vmart_node0004);
要从共享存储中加载数据，请使用相应架构中的 URL：
HDFS： [[s]web]hdfs://[nameservice]/path
S3： s3://bucket/path
Google Cloud： gs://bucket/path
Azure： azb://account/container/path
使用默认名称节点或名称服务加载存储在 HDFS 中的文件：
=> COPY t FROM 'webhdfs:///opt/data/file1.dat';
通过特定的 HDFS 名称服务 (testNS) 加载数据。如果数据库配置为从多个 HDFS 群集中读取，则可以指定一个名称服务：
=> COPY t FROM 'webhdfs://testNS/opt/data/file2.csv';
从 S3 存储桶中加载数据：
=> COPY t FROM 's3://AWS_DataLake/*' ORC;
可以使用目录结构对数据文件进行分区，例如：
path/created=2016-11-01/region=northeast/*
path/created=2016-11-01/region=central/*
path/created=2016-11-01/region=southeast/*
path/created=2016-11-01/...
path/created=2016-11-02/region=northeast/*
path/created=2016-11-02/region=central/*
path/created=2016-11-02/region=southeast/*
path/created=2016-11-02/...
path/created=2016-11-03/...
path/...
使用 PARTITION COLUMNS 选项加载分区列：
=> CREATE EXTERNAL TABLE records (id int, name varchar(50), created date, region varchar(50))
AS COPY FROM 'webhdfs:///path/*/*/*'
PARTITION COLUMNS created, region;
在以下示例中，该表包含名字、姓氏和全名列，但正在加载的数据包含名字、中间名和姓氏列。COPY 语句读取所有源数据，但只加载名字和姓氏的源列。它通过连接每个源数据列（包括中间名）来构造全名数据。中间名被读取为 FILLER 列，因此可以在串联中使用，但在其他情况下会被忽略。（中间名没有表格列。）
=> CREATE TABLE names(first VARCHAR(20), last VARCHAR(20), full VARCHAR(60));
CREATE TABLE
=> COPY names(first,
middle FILLER VARCHAR(20),
last,
full AS first||' '||middle||' '||last)
FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Marc|Gregory|Smith
>> Sue|Lucia|Temp
>> Jon|Pete|Hamilton
>> \.
=> SELECT * from names;
first | last | full
-------+----------+--------------------
Jon | Hamilton | Jon Pete Hamilton
Marc | Smith | Marc Gregory Smith
Sue | Temp | Sue Lucia Temp
(3 rows)
创建一个 Flex 表并使用 FJSONPARSER 将 JSON 数据复制到其中：
=> CREATE FLEX TABLE darkdata();
CREATE TABLE
=> COPY tweets FROM '/myTest/Flexible/DATA/tweets_12.json' PARSER FJSONPARSER();
Rows Loaded
-------------
12
(1 row)
COPY 支持遵循与给定文件系统上的文件名称相同的命名约定的命名管道。权限为 open、write 和 close。
创建命名管道 pipe1，并设置两个 vsql 变量：
=> \! mkfifo pipe1
=> \set dir `pwd`/
=> \set file '''':dir'pipe1'''
从命名管道中复制一个未压缩的文件：
=> \! cat pf1.dat > pipe1 &
=> COPY large_tbl FROM :file delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;
从命名管道中复制一个 GZIP 文件并解压缩：
=> \! gzip pf1.dat
=> \! cat pf1.dat.gz > pipe1 &
=> COPY large_tbl FROM :file ON site01 GZIP delimiter '|';
=> SELECT * FROM large_tbl;
=> COMMIT;
=> \!gunzip pf1.dat.gz
将 COPY 语句与其 LOCAL 选项配合使用，可以在客户端系统而不是群集主机上加载数据文件。COPY LOCAL 支持 STDIN 和 'pathToData' 参数，但是不支持 [ON nodename] 子句。COPY LOCAL 不支持具有 NATIVE 或 NATIVE VARCHAR 格式的多个文件批量。COPY LOCAL 不支持读取 ORC 或 Parquet 文件；改用 ON NODE。COPY LOCAL 不支持 CURRENT_LOAD_SOURCE()。
COPY LOCAL 选项与平台无关。该语句在所有受支持的 Vertica 平台和驱动程序中的工作方式均相同。有关支持的驱动程序的更多详细信息，请参阅客户端驱动程序。
COPY LOCAL 必须是您使用 ODBC 客户端库进行的任何多语句查询中的第一条语句。将其用作第二个或以后的语句会导致错误。在使用其他客户端库（例如 JDBC）时，COPY LOCAL 应该始终是多语句查询中的第一条语句。另外，不要在同一个查询中多次使用它。
COPY LOCAL 即使发生异常，也不会自动创建异常和拒绝文件。
用户必须具有表的 INSERT 权限以及架构的 USAGE 权限。
COPY LOCAL 通过平台中性的方式加载数据。COPY LOCAL 语句将本地客户端系统中的所有文件加载到 Vertica 主机（服务器会在其中处理文件）。您可以复制各种格式的文件：已解压缩、已压缩、固定宽度格式、bzip 或 gzip 格式或者指定为 bash glob。单个格式（例如全部为 bzip 或 gzip）的文件可以是以逗号分隔的输入文件列表。此外，还可以使用任何适用的 COPY 语句选项（只要数据格式支持该选项即可）。例如，可以定义特定的分隔符，或者定义如何处理 NULL 值等等。
glob 命令会返回与输入的模式（在适用于 Glob 的 Linux 手册页面 (7) 中指定）匹配的文件。对于 ADO.net 平台，按照 .NET Directory.getFiles 方法中的描述指定模式和通配符。
有关使用 COPY LOCAL 选项加载数据的详细信息，请参阅 COPY 以查看语法描述，参阅指定加载数据的位置以查看详细示例。
Vertica 主机会根据需要解压缩并处理文件，无论文件格式如何或从中加载文件的客户端平台如何。一旦服务器拥有复制的文件，Vertica 就会通过跨节点分发文件解析任务（例如编码、压缩、解压缩）来保持性能。
在使用 COPY LOCAL 选项时，GraphViz 查询计划包括用于 Load-Client-File 而不是 Load-File 的标签。以下是查询计划示例中的一部分：
-----------------------------------------------
PLAN: BASE BULKLOAD PLAN (GraphViz Format)
-----------------------------------------------
digraph G {
graph [rankdir=BT, label = " BASE BULKLOAD PLAN \nAll Nodes Vector:
\n\n node[0]=initiator (initiator) Up\n", labelloc=t, labeljust=l ordering=out]
.
.
.
10[label = "Load-Client-File(/tmp/diff) \nOutBlk=[UncTuple]",
color = "green", shape = "ellipse"];
以下示例显示了从本地文件的加载过程。
$ cat > t.dat
12
17
9
^C
=> CREATE TABLE numbers (value INT);
CREATE TABLE
=> COPY numbers FROM LOCAL 't.dat';
Rows Loaded
-------------
3
(1 row)
=> SELECT * FROM numbers;
value
-------
12
17
9
(3 rows)
从其他 Vertica 数据库导入数据。COPY FROM VERTICA 类似于 COPY，但仅支持后者的一部分参数。
COPY [[database.]schema-name.]target-table
[( target‑columns )]
FROM VERTICA source‑database.[schema.]source‑table
[( source‑columns )]
[STREAM NAME 'stream name']
[NO COMMIT]
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
目标表target‑columns您不能将 FILLER 列或复杂类型（原生数组除外）的列用作列定义的一部分。
source‑databaseCONNECT TO VERTICA。[schema.]source‑tablepublic 以外的任何其他架构，则必须提供架构名称。source‑columnsSTREAM NAME stream 列中。NO COMMIT COPY 在完成复制数据时自动提交其事务。有关详细信息，请参阅使用事务暂存加载。源表：选择
源表架构： USAGE
目标表： INSERT
目标表架构： USAGE
将一个数据库中的所有表数据复制到另一个数据库时，如果两个表中的列定义都符合以下条件，COPY FROM VERTICA 可以不用指定列的列表：
列数相同
列名相同
列序列相同
列数据类型匹配或兼容
没有复杂的数据类型（ARRAY、SET 或 ROW），原生数组除外
如果其中任何一个条件不成立，则 COPY FROM VERTICA 语句必须包含列的列表，这些列表将目标列和源列显式映射到彼此，如下所示：
包含相同数量的列。
按相同顺序列出源列和目标列。
将具有相同（或兼容）数据类型的列配对。
请参阅处理复制/导出期间的节点故障。
以下示例将整个表的内容从 vmart 数据库复制到当前数据库中具有相同定义的表中：
=> CONNECT TO VERTICA vmart USER dbadmin PASSWORD 'myPassword' ON 'VertTest01',5433;
CONNECT
=> COPY customer_dimension FROM VERTICA vmart.customer_dimension;
Rows Loaded
-------------
500000
(1 row)
=> DISCONNECT vmart;
DISCONNECT
有关更多示例，请参阅从另一个 Vertica 数据库复制数据。
CREATE 语句允许您创建新的数据库对象，例如表和用户。
创建一个访问策略，筛选用户和角色对表数据的访问。您可以为表的行和列创建访问策略。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 WHEREGRANT TRUSTED指定 GRANT 语句在确定用户是否可以对目标表执行 DML 操作时优先于访问策略。如果省略，则只有在访问策略允许用户查看原始未更改状态的存储数据时，用户才能修改表数据。有关详细信息，请参阅访问策略和 DML 操作。
ENABLE | DISABLE非超级用户：表的所有权
访问策略具有以下限制：
一列只能有一个访问策略。
不能为除原生数组以外的复杂类型列设置列访问策略。
不能为 Flex 表中的实体化列设置列访问策略。可以为 __raw__ 列设置访问策略，但此举将限制对整个表的访问。
行访问策略对临时表和具有聚合投影的表无效。
访问策略表达式不能包含：
子查询
聚合函数
分析函数
用户定义的转换函数 (UDTF)
如果查询优化器无法使用计算值替换仅涉及常量的确定性表达式，则会阻止所有 DML 操作，例如 INSERT。
创建并启用与用户或角色关联的身份验证记录。身份验证记录在创建后自动启用。
CREATE AUTHENTICATION auth‑record‑name
METHOD 'auth‑method'
access‑method
[ FALLTHROUGH ]
DBADMIN
请参阅创建身份验证记录。
创建证书颁发机构 (CA) 捆绑包。这些包含根 CA 证书。
CREATE CA BUNDLE name [CERTIFICATES ca_cert[, ca_cert[, ...]]
nameca_certCA 捆绑包中 CA 证书的所有权。
请参阅管理 CA 捆绑包。
创建或导入证书、证书颁发机构 (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 ]}
TEMPORARYCAAS cert此参数应包括整个证书链，不包括 CA 证书。
KEY key_name只需为您打算在 Vertica 中签署其他证书的客户端/服务器证书和 CA 证书设置此参数。如果您导入的 CA 证书仅用于验证其他证书，则无需指定密钥。
SUBJECT subjectSIGNED BY ca_cert添加 CA 证书时，该参数可选。指定该参数将创建一个不能用于签署其他 CA 证书的中间 CA。
创建证书时，此参数是必需的。
VALID FOR daysEXTENSIONS ext = valKEY 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 DIRECTED QUERY OPT[IMIZER] directedqueryID [COMMENT 'comments'] input-query
用户定义（自定义）
CREATE DIRECTED QUERY CUSTOM directedqueryID [COMMENT 'comments'] annotated-query
OPT[IMIZER]CUSTOMCOMMENT 'comments' 如果忽略此实参，Vertica 会插入以下注释之一：
优化器生成的定向查询
自定义定向查询
:v (alias IGNORECONST)。CREATE DIRECTED QUERY 将输入查询与使用优化器提示进行注释的查询相关联。它将此关联存储在一个唯一标识符下。CREATE DIRECTED QUERY 有两种变体：
CREATE DIRECTED QUERY OPTIMIZER 指示查询优化器从指定的输入查询生成带注释的 SQL。带注释的查询包含一些提示，优化器可使用这些提示为输入查询重新创建其当前查询计划。
CREATE DIRECTED QUERY CUSTOM 指定用户提供的带注释的查询。Vertica 将带注释的查询与最后一个 SAVE QUERY 语句指定的输入查询相关联。
在这两种情形中，Vertica 都会将带注释的查询与输入查询相关联，并将其关联注册在 query_name 下的系统表 DIRECTED_QUERIES 中。
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 格式时，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;
仅限企业模式
创建容错组，其可包含以下内容：
一个或多个节点
一个或多个子容错组
一个或多个节点以及一个或多个子容错组
CREATE FAULT GROUP 创建空的容错组。使用 ALTER FAULT GROUP 将节点或其他容错组添加到现有容错组。
CREATE FAULT GROUP name
超级用户
以下命令会创建名为 parent0 的容错组：
=> CREATE FAULT GROUP parent0;
CREATE FAULT GROUP
使用 ALTER FAULT GROUP 将节点或其他容错组添加到 parent0 容错组。
在逻辑架构中创建 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__ NOT NULL 约束。__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
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)
Vertica 为每种类型的用户定义的扩展提供 CREATE 语句。每个 CREATE 语句都会向 Vertica 编录添加一个用户定义的函数：
Vertica 还提供 CREATE FUNCTION (SQL)，它将 SQL 表达式存储为您可以在查询中调用的函数。
向编录添加用户定义的聚合函数 (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 libraryFENCED | 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 |
向编录添加用户定义的分析函数 (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 libraryFENCED | NOT FENCED默认值： FENCED
非超级用户：
函数架构的 CREATE 权限
函数库的 USAGE 权限
此示例基于 AnalyticFunctions 库中名为 RankFactory 的工厂类创建名为 an_rank 的分析函数：
=> CREATE ANALYTIC FUNCTION an_rank AS LANGUAGE 'C++'
NAME 'RankFactory' LIBRARY AnalyticFunctions;
向编录添加用户定义的加载筛选函数。包含筛选函数的库必须先前已使用 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'LIBRARY libraryFENCED | 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 |
将 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 REPLACEOR REPLACE 和 IF NOT EXISTS 是互斥的。
IF NOT EXISTS如果存在具有相同名称和实参的函数，则会返回该函数而不会创建它。
OR REPLACE 和 IF NOT EXISTS 是互斥的。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
functionarg_listargname argtype[,...]
其中：
argname 为传递给 function 的实参的名称。
argtype 为 argname 的数据类型。
return_typeRETURN 表达式表达式末尾的分号是必需的。
CREATE FUNCTION 仅允许一个 RETURN 表达式。Return 表达式不支持以下内容：
FROM、WHERE、GROUP BY、ORDER BY 和 LIMIT 子句
聚合、分析和元函数
非超级用户：
函数架构的 CREATE 权限
函数库的 USAGE 权限
Vertica 根据 SQL 函数的定义推断该函数的 严格性和可变性（ 稳定、 不可变或 易变）。然后，Vertica 确定使用是否正确，例如期待不可变函数却提供了易变函数的情况。
可以在使用 SQL 函数的查询中创建视图，然后查询这些视图。创建视图时，SQL 函数会将对用户定义的函数的调用替换为视图定义中的函数主体。因此，当用户定义的函数的主体被替换后，视图也应被替换。
请参阅创建用户定义的 SQL 函数。
向编录添加用户定义的标量函数 (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 libraryFENCED | NOT FENCED默认值： 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)
向编录添加用户定义的加载解析器函数。包含该函数的库必须先前已使用 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'LIBRARY libraryFENCED | 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 |
向编录添加用户定义的负载源函数。包含该函数的库必须先前已使用 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'LIBRARY libraryFENCED | 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 |
向编录添加用户定义的转换函数 (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 libraryFENCED | NOT FENCED默认值： FENCED
非超级用户：
函数架构的 CREATE 权限
函数库的 USAGE 权限
包括 UDTF 的查询不能：
以下示例加载了名为 TransformFunctions 的库，然后定义了名为 tokenize 的函数，该函数映射到库中的 TokenFactory 工厂类：
=> CREATE LIBRARY TransformFunctions AS
'/home/dbadmin/TransformFunctions.so';
CREATE LIBRARY
=> CREATE TRANSFORM FUNCTION tokenize
AS LANGUAGE 'C++' NAME 'TokenFactory' LIBRARY TransformFunctions;
CREATE TRANSFORM FUNCTION
使用 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]AUTHORIZATION user-idHOSTNAME如果您指定此参数且未同时指定 PORT，则此值必须采用 hive-site.xml 中用于 hive.metastore.uris 的 URI 格式。
如果 Hive 元存储支持高可用性，您可以为此值指定逗号分隔的 URI 列表。
如果未指定此值，则 hive-site.xml 必须可用。
PORTHOSTNAME 并且它必须是名称或 IP 地址（不是 URI）。HIVESERVER2_HOSTNAME将 hive.server2.thrift.bind.host 设置为有效的主机
将 hive.server2.support.dynamic.service.discovery 设置为 true
如果您使用 WebHCat，则忽略此参数。
WEBSERVICE_HOSTNAMEWEBSERVICE_PORTWEBHDFS_ADDRESSHCATALOG_SCHEMACUSTOM_PARTITIONSHCATALOG_USERHCATALOG_CONNECTION_TIMEOUTHCATALOG_SLOW_TRANSFER_LIMITHCATALOG_SLOW_TRANSFER_TIMESSL_CONFIGHCATALOG_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';
创建私钥。
CREATE [TEMP[ORARY]] KEY name
TYPE type
[PASSWORD password]
{LENGTH length | AS key}
TEMPORARYKEY nameTYPE typePASSWORD passwordLENGTH length示例：2048
AS key-----BEGIN RSA PRIVATE KEY-----...ABCD1234...-----END RSA PRIVATE KEY-----
超级用户
请参阅生成 TLS 证书和密钥。
将包含用户定义的扩展 (UDx) 的库加载到 Vertica 编录。Vertica 自动将库文件和支持库的副本分发到所有群集节点。
因为库被添加至数据库编录，因此数据库重新启动后也将如此。
在编录中加载库后，即可使用 CREATE FUNCTION 等语句定义该库中包含的扩展。有关详细信息，请参阅开发用户定义的扩展 (UDx)。
CREATE [OR REPLACE] LIBRARY
[[database.]schema.]name
AS 'path'
[ DEPENDS 'depends-path' ]
[ LANGUAGE 'language' ]
OR REPLACE如果您不使用此指令并且库已经存在，则 CREATE 语句会返回错误。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
AS pathDEPENDS 'depends-path'此库所依赖的文件或库，启动程序节点的文件系统或其他受支持的文件系统或对象存储中的一个或多个文件或目录。对于目录，路径条目以斜杠 (/) 结束，后跟通配符 (*)（可选）。要指定多个文件，请使用冒号 (:) 分隔条目。
如果任何路径条目包含冒号（例如 URI），请在整个 DEPENDS 路径两端加上括号，且单个路径元素使用双引号，如下例所示：
DEPENDS '["s3://mybucket/gson-2.3.1.jar"]'
要指定具有多个目录级别的库，请参阅多级库依赖项。
DEPENDS 对使用 R 编写的库没有影响。R 软件包必须本地安装在每个节点上，包括外部依赖项。
如果 Java 库依赖于本机库（SO 文件），请使用 DEPENDS 指定路径并调用 UDx 中的 System.loadLibrary() 以从该路径加载本机库。
LANGUAGE 'language'C++ （默认值）
Python
Java
R
超级用户，或者架构上的 UDXDEVELOPER 和 CREATE。非超级用户必须显式启用 UDXDEVELOPER 角色，如下例所示：
=> SET ROLE UDXDEVELOPER;
SET
-- Not required, but you can confirm the role as follows:
=> SHOW ENABLED ROLES;
name | setting
---------------+--------------
enabled roles | udxdeveloper
(1 row)
=> CREATE LIBRARY MyLib AS '/home/dbadmin/my_lib.so';
CREATE LIBRARY
-- Create functions...
-- UDXDEVELOPER also grants DROP (replace):
=> CREATE OR REPLACE LIBRARY MyLib AS '/home/dbadmin/my_lib.so';
Vertica 会制作自己的库文件副本。后期修改或删除该语句中指定的原始文件不会影响编录中定义的库。要更新库，请使用 ALTER LIBRARY。
加载库并不能保证该功能可以正常工作。CREATE LIBRARY 会对库文件执行一些基本检查，以验证库文件是否兼容 Vertica。如果语句检测到库未正确编译或发现了其他一些基本的不兼容性，则语句失败。但是，CREATE LIBRARY 无法检测到共享库中的许多其他问题。
如果 DEPENDS 子句指定具有多个目录级别的库，Vertica 将按照库路径包含该库的所有子目录。例如，以下 CREATE LIBRARY 语句使 UDx 库 mylib 能够导入它在 site‑packages 的子目录中找到的所有 Python 包和模块：
=> CREATE LIBRARY mylib AS '/path/to/python_udx' DEPENDS '/path/to/python/site-packages' LANGUAGE 'Python';
在 dbadmin 帐户的主目录中加载库：
=> CREATE LIBRARY MyFunctions AS '/home/dbadmin/my_functions.so';
加载位于您启动 vsql 的目录中的库：
=> \set libfile '\''`pwd`'/MyOtherFunctions.so\'';
=> CREATE LIBRARY MyOtherFunctions AS :libfile;
从云端加载库：
=> CREATE LIBRARY SomeFunctions AS 'S3://mybucket/extensions.so';
加载依赖于同一目录中多个 JAR 文件的库：
=> CREATE LIBRARY DeleteVowelsLib AS '/home/dbadmin/JavaLib.jar'
DEPENDS '/home/dbadmin/mylibs/*' LANGUAGE 'Java';
加载具有多个显式依赖项的库：
=> CREATE LIBRARY mylib AS '/path/to/java_udx'
DEPENDS '/path/to/jars/this.jar:/path/to/jars/that.jar' LANGUAGE 'Java';
在云中加载具有依赖项的库：
=> CREATE LIBRARY s3lib AS 's3://mybucket/UdlLib.jar'
DEPENDS '["s3://mybucket/gson-2.3.1.jar"]' LANGUAGE 'Java';
创建可通过负载均衡路由规则定位的一组网络地址。您可以使用网络地址列表或基于一个或多个容错组或子群集创建组。
CREATE LOAD BALANCE GROUP group_name WITH {
ADDRESS address[,...]
| FAULT GROUP fault_group[,...] FILTER 'IP_range'
| SUBCLUSTER subcluster[,...] FILTER 'IP_range'
}
[ POLICY 'policy_setting' ]
group_name address[,...] fault_group[,...]subcluster[,...]IP_range 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)
创建或替换本地临时视图。视图是只读内容，所以不支持插入、更新、删除或复制操作。本地临时视图是会话范围的视图，因此仅在当前视图中供其创建者可见。会话结束时，Vertica 会删除视图。
CREATE [OR REPLACE] LOCAL TEMP[ORARY] VIEW view [ (column[,...] ) ] AS query
OR REPLACECREATE VIEW 返回错误。[,...]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)
创建可供 Vertica 存储数据的存储位置。创建该位置后，可以在其中存储策略，以将该存储位置分配给将在此位置存储数据的数据库对象。
如果没有技术问题阻止您使用 CREATE LOCATION 添加一个或多个网络文件系统 (NFS) 存储位置，则 Vertica 不支持 NFS 数据或编录存储，MapR 挂载点除外。您将无法对任何其他 NFS 数据运行查询。在 MapR 文件系统上创建位置时，您必须指定 ALL NODES SHARED。
如果您使用 HDFS 存储位置，则在启动 Vertica 时 HDFS 数据必须可用。HDFS 群集必须可以运行，且 ROS 文件必须存在。如果您已移动数据文件，或者它们已损坏，或者 HDFS 群集没有响应，则 Vertica 无法启动。
CREATE LOCATION 'path'
[NODE 'node' | ALL NODES]
[SHARED]
[USAGE 'usage']
[LABEL 'label']
[LIMIT 'size']
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多数远程文件系统（例如 HDFS 和 S3）都被共享。对于这些文件系统，path 实参表示远程文件系统中所有节点存储数据的单个位置。如果使用远程文件系统，您必须指定 SHARED，即使对于单节点群集也是如此。
SHARED 并且可以省略。
USAGE 'usage'DATA,TEMP （默认值）：存储位置可以存储 DML 生成的永久和临时数据，以及临时表的数据。
TEMP：path 指定的位置，用于存储 DML 生成的临时数据。如果 path 设置为 S3，则仅当 RemoteStorageForTemp 配置参数设置为 1 且 TEMP 必须使用 ALL NODES SHARED 加以限定。有关详细信息，请参阅临时数据的 S3 存储。
DATA：存储位置只能存储永久数据。
DEPOT：该存储位置用于在
Eon 模式中存储存储库。仅在本地 Linux 文件系统上创建 DEPOT 存储位置。
Vertica 允许每个节点有单个 DEPOT 存储位置。如果要将存储库移动到不同的位置（例如，在不同的文件系统上），您必须首先删除旧的存储库存储位置，然后创建新位置。
LABEL 'label'LIMIT 'size'仅当存储位置使用类型设置为 DEPOT 时才有效，指定存储库可以从存储位置的文件系统中分配的最大磁盘空间量。
您可以通过两种方式指定 size：
integer%：存储位置的磁盘大小所占的百分比。
integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的存储位置的磁盘大小。
如果未指定限制，则将其设置为 60%。
超级用户
Vertica 进程必须对要存储数据的位置具有读写权限。每个文件系统都有自己的要求：
在本地 Linux 文件系统中创建一个存储位置，用于临时数据存储：
=> CREATE LOCATION '/home/dbadmin/testloc' USAGE 'TEMP' LABEL 'tempfiles';
在 HDFS 上创建存储位置。HDFS 群集不使用 Kerberos：
=> CREATE LOCATION 'hdfs://hadoopNS/vertica/colddata' ALL NODES SHARED
USAGE 'data' LABEL 'coldstorage';
在使用 Kerberos 的 Hadoop 群集上创建相同的存储位置。请注意报告正在使用的主体的输出：
=> CREATE LOCATION 'hdfs://hadoopNS/vertica/colddata' ALL NODES SHARED
USAGE 'data' LABEL 'coldstorage';
NOTICE 0: Performing HDFS operations using kerberos principal [vertica/hadoop.example.com]
CREATE LOCATION
为用户数据创建一个位置，授予对这些数据的访问权限以及使用这些数据创建外部表：
=> CREATE LOCATION '/tmp' ALL NODES USAGE 'user';
CREATE LOCATION
=> GRANT ALL ON LOCATION '/tmp' to Bob;
GRANT PRIVILEGE
=> CREATE EXTERNAL TABLE ext1 (x integer) AS COPY FROM '/tmp/data/ext1.dat' DELIMITER ',';
CREATE TABLE
在 S3 上创建用户存储位置和角色，以便没有自己的 S3 凭据的用户可以使用服务器凭据从 S3 读取数据：
--- set database-level credential (once):
=> ALTER DATABASE DEFAULT SET AWSAuth = 'myaccesskeyid123456:mysecretaccesskey123456789012345678901234';
=> CREATE LOCATION 's3://datalake' SHARED USAGE 'USER' LABEL 's3user';
=> CREATE ROLE ExtUsers;
--- Assign users to this role using GRANT (Role).
=> GRANT READ ON LOCATION 's3://datalake' TO ExtUsers;
创建可用作连接负载均衡策略一部分的网络地址。网络地址会在 Vertica 编录中为与节点关联的 IP 地址和端口号创建名称。节点可以有多个网络地址，网络上的每个 IP 地址最多一个。
CREATE NETWORK ADDRESS name ON node WITH 'ip-address' [PORT port-number] [ENABLED | DISABLED]
name 节点 node_name 列中的节点的名称。ip-address PORT port-numberENABLED | 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';
标识节点所属的网络接口。
当您要配置从单个节点到其他 Vertica 群集的导入/导出操作时，请使用此语句。默认情况下，安装 Vertica 时，它会为所有连接的网络创建接口。只有在安装 Vertica 后网络拓扑发生变化的情况下，您才需要 CREATE NETWORK INTERFACE。
CREATE NETWORK INTERFACE network‑interface‑name ON node‑name [WITH] 'node‑IP‑address' [PORT port-number] [ENABLED | DISABLED]
超级用户
创建网络接口：
=> CREATE NETWORK INTERFACE mynetwork ON v_vmart_node0001 WITH '123.4.5.6' PORT 456 ENABLED;
创建基于推送的通知程序，以从 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 了解相关信息。
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。
MAXPAYLOADMAXPAYLOAD integer{K|M}
存在以下限制：
MAXPAYLOAD 不能大于 MAXMEMORYSIZE。
如果您将 syslog 配置为将消息发送到远程目标，请确保 MaxMessageSize (in /etc/rsyslog for rsyslog) 大于或等于 MAXPAYLOAD。
默认值：
Kafka：1M
syslog：1M
MAXMEMORYSIZEMAXMEMORYSIZE 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 端点创建或更改通知程序。请注意，每当您更改给定通知程序的 TLSMODE、证书或 CA 捆绑包时，都必须重复此步骤。
在设置 TLSMODE、证书和 CA 捆绑包时，使用 CREATE 或 ALTER 以禁用通知程序。
=> ALTER NOTIFIER encrypted_notifier
DISABLE
TLSMODE 'verify-ca'
CA BUNDLE ca_bundle2;
更改通知程序并为 SASL_SSL 设置适合的 rdkafka 适配器参数。
=> ALTER NOTIFIER encrypted_notifier PARAMETERS
'sasl.username=user;sasl.password=password;sasl.mechanism=PLAIN;security.protocol=SASL_SSL';
启用通知程序。
=> ALTER NOTIFIER encrypted_notifier ENABLE;
创建 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;
以下示例创建了一个通知程序，当
数据收集器 (DC) 组件 LoginFailures 更新时，它会向 syslog 写入一条消息：
为当前数据库启用 syslog 通知程序：
=> ALTER DATABASE DEFAULT SET SyslogEnabled = 1;
创建并启用系统日志通知程序 v_syslog_notifier：
=> CREATE NOTIFIER v_syslog_notifier ACTION 'syslog'
ENABLE
MAXMEMORYSIZE '10M'
IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
PARAMETERS 'eventSeverity = 5';
配置 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 配置报告。
仅限企业模式
将外部过程添加到 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。如果指定一个数据库，它必须是当前数据库。
过程[ argname ] argtype
argname 可选为此实参提供描述性名称。
argtype 必须为 Vertica 支持的以下数据类型之一：
BIGINT
BOOLEAN
DECIMAL
DOUBLE PRECISION
FLOAT
FLOAT8
INT
INT8
INTEGER
MONEY
NUMBER
NUMERIC
REAL
SMALLINT
TINYINT
VARCHAR
不能是 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';
创建存储过程。
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。如果指定一个数据库，它必须是当前数据库。
过程[ parameter-mode ] parameter-name parameter-type
parameter-name：参数的名称。
parameter-type：任何 SQL 数据类型，以下内容除外：
DECIMAL
NUMERIC
NUMBER
MONEY
UUID
GEOGRAPHY
GEOMETRY
复杂类型
PLvSQL
PLpgSQL
默认值： PLvSQL
SECURITY { DEFINER | INVOKER }DEFINER：定义过程的用户
INVOKER：调用过程的用户
使用 SECURITY DEFINER 的过程以该用户身份有效地执行过程，因此，对数据库的更改似乎是由过程的定义者（而不是其调用者）执行的。
有关详细信息，请参阅执行存储过程。
非超级用户：对过程架构的 CREATE 权限
有关更复杂的示例，请参阅 存储过程：用例和示例
此过程打印其实参：
=> CREATE PROCEDURE raiseXY(IN x INT, y VARCHAR) LANGUAGE PLvSQL AS $$
BEGIN
RAISE NOTICE 'x = %', x;
RAISE NOTICE 'y = %', y;
-- some processing statements
END;
$$;
CALL raiseXY(3, 'some string');
NOTICE 2005: x = 3
NOTICE 2005: y = some string
有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。
创建一个配置文件以控制用户的密码要求。
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 ]
default，并从默认配置文件继承其设置。
超级用户
以下配置文件设置会影响客户端身份验证方法，例如 LDAP 或 GSS：
FAILED_LOGIN_ATTEMPTS
PASSWORD_LOCK_TIME
所有其他配置文件设置仅供 Vertica 用于管理其密码。
=> CREATE PROFILE sample_profile LIMIT PASSWORD_MAX_LENGTH 20;
为 Vertica 编录中的 投影创建元数据。Vertica 支持四种类型的投影：
标准投影： 以优化在该表上执行某些查询的格式存储表数据的集合。
实时聚合投影： 存储对表列调用聚合函数（例如 SUM）的查询的分组结果。
Top-K 投影：存储所选行的分区中的前 k 行。
UDTF 投影： 在由用户定义的转换函数 (UDTF) 转换和/或聚合后存储新加载的数据。
复杂数据类型在投影中使用时有额外的限制：
每个投影必须至少包含一个原始类型或原生数组的列。
AS SELECT 子句可以使用复杂类型的列，但任何其他表达式必须是标量类型或原生数组。
ORDER BY、PARTITION BY 和 GROUP BY 子句无法使用复杂类型。
如果投影不包含 ORDER BY 或分段子句，Vertica 仅使用选择列表中的原始列对数据进行排序或分段。
投影列不能是从 ARRAY_CAT 等函数返回的复杂类型。
TopK 和 UDTF 投影不支持复杂类型。
以优化在该表上执行某些查询的格式存储表数据的集合。有关详细信息，请参阅 投影。
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-clauseENCODING encoding-type列编码类型，默认设置为 AUTO。
ACCESSRANK integer覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。
AS SELECT* （星号）
列出查询的表中的所有列。
MATCH_COLUMNS('pattern')
返回查询的锚表中与 pattern匹配的所有列。
expression [[AS] alias]
解析为所查询锚表中的列数据。
您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置（例如，在 ORDER BY 或分段子句中）引用该别名。
ORDER BY如果您按具有集合数据类型（ARRAY 或 SET）的列排序，则在 ORDER BY 子句中使用该列的查询将再次执行排序。这是因为投影和查询执行排序的方式不同。
如果省略 ORDER BY 子句，Vertica 将使用 SELECT 列表对投影排序。
segmentation-spechash-segmentation-clause: 指定此项将对数据均匀分段并在群集节点之间分布数据：
SEGMENTED BY expression ALL NODES [ OFFSET offset ]
unsegmented-clause: 指定此项将创建未分段的投影：
UNSEGMENTED ALL NODES
如果对于锚表和投影都未指定分段，则将使用一个包含 SELECT 列表中所有列的哈希分段子句来定义投影，如下所示：
SEGMENTED BY HASH(column-expr[,...]) ALL NODES OFFSET 0;
KSAFE [k-num]指定投影的 K-safety，其中 k-num 必须等于或大于数据库 K-safety。如果针对未分段的投影设置了此参数，Vertica 将忽略此参数。 如果省略 k-num，Vertica 将使用数据库 K-safety。
有关常规信息，请参阅 企业模式数据库中的 K-safety。
ON PARTITION RANGE指定将此投影的数据限制在分区键范围内，指定如下：
ON PARTITION RANGE BETWEEN min-range-value AND max-range-value
以下要求适用于 min‑range‑value 和 ≤ max‑range‑value：
Min‑range‑value 必须 ≤ max‑range‑value
它们必须解析为与表分区表达式兼容的数据类型。
它们可以是：
字符串字面量。例如， 2021-07-31
具有稳定或不可变函数的表达式，例如：
date_trunc('month', now()::timestamp - interval'1 month')
max-range-value 可以设置为 NULL，以指定分区范围没有上限。
有关其他要求和使用详细信息，请参阅 分区范围投影。
非超级用户：
锚表所有者
对架构的 CREATE 权限
请参阅：
存储对表列调用聚合函数（例如 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-clauseENCODING encoding-type列编码类型，默认设置为 AUTO。
ACCESSRANK integer覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。
AS SELECT指定要查询的表数据：
{table-column | expr-with-table-columns } [ [AS] alias] }[,...]
您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。
GROUP BY column‑expr[,...]非超级用户：
锚表所有者
对架构的 CREATE 权限
Vertica 不会将实时聚合投影视为 超投影，即使是包含所有表列的投影也是如此。有关其他要求和限制，请参阅创建实时聚合投影。
请参阅实时聚合投影示例。
存储所选行的分区中的前 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-clauseENCODING 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‑rowswindow-partition-clausewindow-order-clauseTop-K 投影支持 ORDER BY NULLS FIRST/LAST。
非超级用户：
锚表所有者
对架构的 CREATE 权限
Vertica 不会将 Top-K 投影视为 超投影，即使是包含所有表列的投影也是如此。有关其他要求和限制，请参阅 创建 Top-K 投影。
请参阅 Top-K 投影示例。
在由用户定义的转换函数 (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-clauseENCODING encoding-type列编码类型，默认设置为 AUTO。
ACCESSRANK integer覆盖列的默认访问等级。使用此参数可提高或降低 Vertica 访问列的速度。有关详细信息，请参阅覆盖默认的列等级。
AS SELECT指定要查询的表数据：
{table-column | expr-with-table-columns } [ [AS] alias] }[,...]
您可以选择性地为每个列表达式分配一个别名，并在 SELECT 语句的其他位置引用该别名。
batch-udtf(batch-args)Tuple Mover 合并
在投影上执行查询
在执行数据加载操作时进行单个调用
prepass-udtf(prepass-args)如果在子查询中指定，则预传递 UDTF 会将转换的数据返回给批量查询，以做进一步处理。否则，预传递查询结果将添加至投影数据存储。
OVER (PARTITION { BATCH | PREPASS } BY partition-column-expr[,...]在两种情况下，OVER 子句会指定要借助于 SELECT 列表中的一个或多个列表达式进行分区。第一个 partition-column-expr 是 SELECT 列表中的第一个列表达式，第二个 partition-column- expr 是 SELECT 列表中的第二个列表达式，依此类推。
AS (batch-output-columns) AS (prepass-output-columns)如果预传递子查询忽略此子句，则外部批量查询 UDTF 实参 (batch-args) 必须引用列名称，像它们在预传递 UDTF 中定义的那样。
table [[AS] alias]sq-results非超级用户：
锚表所有者
对架构的 CREATE 权限
对由投影引用的所有 UDTF 的 EXECUTE 权限
请参阅 预聚合 UDTF 结果。
Vertica 支持各种编码和压缩类型，由以下 ENCODING 参数实参指定：
Vertica 支持 数字数据类型的以下编码：
精度 ≤ 18：AUTO、BLOCK_DICT、BLOCKDICT_COMP、COMMONDELTA_COMP、DELTAVAL、GCDDELTA 和 RLE
精密 >；18：AUTO、BLOCK_DICT、BLOCKDICT_COMP、 RLE
创建投影时，您可以在投影列上设置编码类型。您还可以使用 ALTER TABLE...ALTER COLUMN 更改给定表的一个或多个投影列的编码。
AUTO 对于已排序、多值的列是理想的方案，如对于主键。除此之外，它还适用于其他编码或压缩方案不适用的一般用途。因此，在未指定编码/压缩类型的情况下，它将作为默认类型。
此类型对 CPU 的要求相对较小。最坏的情况，LZO 数据可能膨胀百分之八 (8%)，整数数据可能膨胀百分之二十 (20%)。
对于每个存储块，Vertica 会将不同列值编译到词典中，然后存储词典和索引列表，用以表示该数据块。
BLOCK_DICT 对于少值、未排序的列是理想方案，因为在这种情况下，节省空间比编码速度更重要。某些类数据（如股票价格）经过排序后（如按股票代码和时间戳）在局部区域内通常都是少值的，很适合选择 BLOCK_DICT 方案。相反，CHAR/VARCHAR 列则不适合选择 BLOCK_DICT 编码。
包含 0x00 或 0xFF 字符的 CHAR 和 VARCHAR 列不应使用 BLOCK_DICT 编码。同样，BINARY/VARBINARY 列也不支持 BLOCK_DICT 编码。
BLOCK_DICT 编码需要占用的 CPU 要远远超过默认编码方案。最大数据膨胀率为百分之八 (8%)。
此编码类型与 BLOCK_DICT 类似，只不过其词典索引为熵编码。此编码类型需要更多的 CPU 时间来编码和解码，其最坏情况性能较差。但如果值分布倾斜极为严重，使用 BLOCK_DICT_COMP 编码可节省空间。
BZIP_COMP 编码对块内容使用 bzip2 压缩算法。有关更多信息，请参阅 bzip 网站。此算法的压缩率较自动 LZO 和 gzip 编码高；但它需要更多的 CPU 时间执行压缩。此算法最好用于大型字符串列，例如 VARCHAR、VARBINARY、CHAR 和 BINARY。如果想牺牲加载速度，换取较高的数据压缩率，那么请选择此编码类型。
此压缩方案会为块中所有增量构建一个词典，然后使用熵编码将索引存储到增量词典中。
对于已排序的 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。如果对增量很随意的数据使用此方案，那么可能引发大幅度的数据膨胀。
此压缩方案主要用于浮点数据；它以相对于上一个值的增量的形式存储各值。
对于已排序或限定在一定范围内的多值 FLOAT 列，此方案是理想选择。请勿对包含 NULL 值的未排序列使用此方案，因为表示 NULL 值所消耗的存储量非常高。此方案的压缩和解压过程的损耗都很高。
要确定 DELTARANGE_COMP 是否适合特定数据集，可以将其与其他方案进行对比。要确保与投影使用相同的排序顺序，且要选择将以连续方式存储在数据库中的示例数据。
对于 INTEGER 和 DATE/TIME/TIMESTAMP/INTERVAL 列，将以与数据库中最小值的差的形式记录数据。此编码对于其他数据类型没有任何作用。
DELTAVAL 最适合多值、未排序整数或基于整数的列。此编码类型对 CPU 的要求最低，而且数据永不会膨胀。
对于 INTEGER 和 DATE/TIME/TIMESTAMP/INTERVAL 列，以及只有 18 位或少于 18 位的 NUMERIC 列，将以与数据块中最小值的差除以块中所有条目的最大公约数 (GCD) 的形式存储数据。此编码对于其他数据类型没有任何作用。
ENCODING GCDDELTA 最适合值为同一因子倍数情况下的多值、未排序、整数列或基于整数的列。例如，时间戳在内部以微秒为单位存储，因此，仅精确到毫秒的数据均为 1000 倍。GCDDELTA 编码类型的解码过程对 CPU 的要求最低，且数据永不膨胀，但 GCDDELTA 的编码时间要比 DELTAVAL 长。
此编码类型使用 gzip 压缩算法。有关更多信息，请参阅 gzip 网站。此算法的压缩效果要比自动 LZO 压缩好，但比 BZIP_COMP 的压缩率低。它执行压缩占用的 CPU 时间比 LZO 多，比 BZIP_COMP 少。此算法最好用于大型字符串列，例如 VARCHAR、VARBINARY、CHAR 和 BINARY。想要压缩效果比 LZO 好、占用的 CPU 时间比 bzip2 少时，请使用此编码。
RLE（运行长度编码）将相同值的序列（运行）替换为包含值和出现次数的单个对。因此，它最适合出现在投影的 ORDER BY 子句中的低基数列。
Vertica 执行引擎按逐个运行的方式处理 RLE 编码，Vertica 优化器优先处理 RLE 编码。仅在运行长度较长时（如存储低基数列时）使用此类型。
Vertica 支持三种 ZSTD 压缩类型：
ZSTD_COMP 提供高压缩率。此编码类型的压缩率高于 gzip。想要压缩效果比 gzip 好时，请使用此编码。对于一般用例，请使用此编码或 ZSTD_FAST_COMP 编码类型。
ZSTD_FAST_COMP 使用 zstd 库提供的最快压缩级别。它是 zstd 库中最快的编码类型，但比其他两种编码类型占用更多空间。对于一般用例，请使用此编码或 ZSTD_COMP 编码类型。
ZSTD_HIGH_COMP 提供 zstd 库中的最佳压缩。它比其他两种编码类型慢。当您需要最佳压缩时，请使用此类型，但 CPU 时间较慢。
仅限企业模式
将两个或多个列分组到单个磁盘文件。这样可以将以下工作负载的 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;
指定如何对投影数据进行分段，以便在所有群集节点上分布数据。您可以为表和投影指定分段。如果表定义指定了分段，则 Vertica 会将其用于该表的自动投影。
强烈建议使用 Vertica 的
HASH 内置函数，该函数可在整个群集中均匀分布数据，且便于实现最佳查询执行。
SEGMENTED BY expression ALL NODES [ OFFSET offset ]
SEGMENTED BY expressionHASH 函数，该函数的实参解析为表列。如果使用 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;
指定在整个群集的所有节点上分发表或投影数据的相同副本。使用此子句有助于对因太小而无法从分段中受益的表和投影执行分布式查询。
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)
创建自定义资源池并设置一个或多个资源池参数。
CREATE RESOURCE POOL pool‑name [ FOR subcluster-spec ] [ parameter‑name setting ]...
FOR subcluster‑specSUBCLUSTER subcluster-name：为现有子群集创建资源池。您不能连接到此子群集，否则 Vertica 会返回错误。CURRENT SUBCLUSTER：为连接到的子群集创建资源池。如果忽略，则在全局创建资源池。尝试创建与特定于子群集的资源池同名的全局资源池时会返回错误。
要在 parameter‑name 上设置的值。要将此参数重置为其默认值，请指定 DEFAULT。
CASCADE TO 指定一个辅助资源池，用于执行其
[RUNTIMECAP](#RUNTIMECAP) 设置超出分配资源池的查询：
CASCADE TO secondary‑pool
CPUAFFINITYMODE 指定资源池是单独使用还是共用
[CPUAFFINITYSET](#CPUAFFINITYSET) 中指定的 CPU。
CPUAFFINITYMODE { SHARED | EXCLUSIVE | ANY }
SHARED：在此池中运行的查询与其他 Vertica 资源池共享其 CPUAFFINITYSET CPU。
EXCLUSIVE：仅将 CPUAFFINITYSET CPU 专用于此资源池，不用于其他 Vertica 资源池。如果将 CPUAFFINITYSET 设置为百分比，那么仅为此资源池分配可用于 Vertica 的 CPU 资源百分比。
ANY （默认值）：此资源池中的查询可以在任何 CPU 上运行，如果 CPUAFFINITYSET 指定 CPU 资源，则此查询无效。
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
}
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：一个负整数或正整数值。数字越大，表示优先级越高：
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
Vertica 预先配置了内置池来完成各种系统任务：
有关资源池设置的详细信息，请参阅 ALTER RESOURCE POOL。
一个通用池，用于答复未关联到特定 资源池的请求。为所有其他池分配内存后剩下的任何内存将自动分配给 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)
控制内存中的 blob 的资源使用情况量。内存中的 blob 是许多机器学习 SQL 函数使用的对象。如果计划处理大型机器学习工作负载，则应调整此池。有关优化池的信息，请参阅为机器学习进行调整。
如果使用 BLOBDATA 池的查询超出该池的查询计划预算，则它会溢出到磁盘。有关优化查询预算的详细信息，请参阅查询预算。
控制 Database Designer 处理的资源使用情况。使用此池由配置参数 DBDUseOnlyDesignerResourcePool 启用，默认情况下该参数设置为 false。
默认情况下，此池的 QUEUETIMEOUT 设置为 0。当资源面临压力时，此设置可使 DBD 立即超时，而不是排队等待运行。Database Designer 随后会请求用户在有更多的资源可用时再运行设计器。
控制 Java 用户定义的扩展使用的 Java 虚拟机资源。当 Java UDx 启动 JVM 时，它会从 JVM 资源池中获取指定的资源。Vertica 不会提前为 JVM 池保留内存。必要时，池可以扩展到物理内存的 10% 或 2 GB 内存，以较小者为准。如果您正在缓冲大量数据，可能需要增加 JVM 资源池的大小。
您可以通过更改其配置设置调整 JVM 资源池的大小。与其他资源池不同的是，JVM 资源池在会话关闭前不会释放资源。
跟踪为编录数据和存储数据结构分配的内存。随着 Vertica 元数据使用更多资源，此池的大小会增加。分配给 METADATA 池的内存将从 GENERAL 池中减去，从而使 Vertica 资源管理器能够更有效地利用可用资源。如果 METADATA 资源池达到 GENERAL 池的 75%，Vertica 将停止更新 METADATA 内存大小并在 vertica.log 中显示警告消息。您可以通过配置参数 EnableMetadataMemoryTracking 启用或禁用 METADATA 池。
如果您创建了一个“虚拟”或“交换”资源池来保护操作系统使用的资源，您可以将该池替换为 METADATA 池。
用户不能更改 METADATA 资源池的参数。
由恢复数据库的另一个节点时发出的查询使用。MAXCONCURRENCY 参数用于确定要使用多少个并发恢复线程。可以使用 PLANNEDCONCURRENCY 参数（默认情况下，设置为 MAXCONCURRENCY 的两倍）优化分摊内存来恢复查询的方式。
请参阅为恢复进行调整。
由
PROJECTION_REFRESHES 操作发出的查询使用。
刷新当前不使用多个并发线程，因此，对 MAXCONCURRENCY 值的更改无效。
请参阅场景：对刷新进行优化。
对所有系统监控和编录表运行查询。SYSQUERY 池保留系统表查询的资源，以便它们不会被可用资源争用拦截。
Tuple Mover (TM) 池。可以为 TM 池设置 MAXCONCURRENCY 参数，以允许并发 TM 操作。
要查看内置资源池的当前和默认配置，请分别查询系统表 RESOURCE_POOLS 和 RESOURCE_POOL_DEFAULTS。 以下部分提供了这些信息，并指出了哪些内置池参数可以使用 ALTER RESOURCE POOL 进行修改：
|
参数 |
设置 |
||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| MEMORYSIZE | 空/不能设置 | ||||||||||||||||||||||||||||
| MAXMEMORYSIZE | 供所有资源池使用的最大内存，为以下之一：
|
|
参数 |
默认设置 |
||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| MEMORYSIZE | 0% | ||||||||||||||||||||||||||||
| MAXMEMORYSIZE | 通过从
|
创建 角色。创建角色后，使用 GRANT 语句指定角色权限。
CREATE ROLE role
超级用户
此示例显示了如何创建名为 roleA 的空角色。
=> CREATE ROLE roleA;
CREATE ROLE
创建负载均衡路由规则，将传入客户端连接从 IP 地址范围定向到一组 Vertica 节点。此组 Vertica 节点由负载均衡组定义。创建路由规则后，如果客户端选择使用负载均衡，则源自规则 IP 地址范围的任何客户端连接都将重定向到负载均衡组中的节点之一。
CREATE ROUTING RULE rule_name ROUTE 'address_range' TO group_name
rule_name ``` address_range ``` group_name 超级用户。
以下示例创建了一个路由规则，可将 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
定义架构。
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 了解相关信息。
AUTHORIZATIONusername创建架构后，可以使用
ALTER SCHEMA 将所有权重新分配给其他用户。
DEFAULT {INCLUDE | EXCLUDE} [SCHEMA] PRIVILEGES指定是否启用或禁用指定架构中新表的默认权限继承：
EXCLUDE SCHEMA PRIVILEGES （默认值）：禁用架构的权限继承。
INCLUDE SCHEMA PRIVILEGES：指定为指定架构中的表授予的权限与为架构授予的权限相同。此选项对架构中的现有表没有影响。
如果忽略 INCLUDE PRIVILEGES，则必须显式授予所需表的架构权限。
有关详细信息，请参阅启用架构继承。
DISK_QUOTA配额如果未指定，则架构没有配额。
超级用户（需要设置磁盘配额）
CREATE SCHEMA 可以包含一个或多个子语句，例如，在新架构中创建表或投影。支持的子语句包括：
CREATE TABLE / CREATE TEMPORARY TABLE
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 权限
定义新的命名序列号生成器对象。与 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。如果指定一个数据库，它必须是当前数据库。
序列INCREMENT [BY] integer一个正整数或负整数，指定每次调用 NEXTVAL 时序列的增减数量，默认设置为 1。
NO CACHE 参数则除外。
MINVALUE integer | NO MINVALUEMAXVALUE integer | NO MAXVALUESTART [WITH] integerMINVALUE，降序序列的起始值将设置为 MAXVALUE。CACHE integer | NO CACHECACHE 需要一个整数实参，如下所示：
>1 指定每个节点在每个会话中缓存的唯一编号的数量。
0 或 1 指定禁用缓存（等同于 NO CACHE）。
如果忽略此子句，序列缓存将设置为 250,000。
有关命名序列缓存的详细信息，请参阅分发命名序列。
CYCLE | NO CYCLECYCLE：序列按如下方式进行回绕：
当递增序列达到其上限时，会被重置为其最小值。
当递减序列达到其下限时，会被重置为其最大值。
NO CYCLE （默认值）：在序列达到其最大值或最小值后，调用 NEXTVAL 会返回错误。
非超级用户：对架构的 CREATE 权限
请参阅创建和使用命名序列。
标识 Vertica 数据库的节点所属的子网。使用此语句可配置从数据库到其他 Vertica 群集的导入/导出操作。
CREATE SUBNET subnet-name WITH 'subnet‑prefix'
NETWORK_INTERFACES，以获取所有可用 IP 网络的前缀。然后配置数据库，将子网用于导入/导出。有关详细信息，请参阅识别用于导入/导出的数据库或节点。
超级用户
=> CREATE SUBNET mySubnet WITH '123.4.5.6';
=> CREATE SUBNET mysubnet WITH 'fd9b:1fcc:1dc4:78d3::';
在逻辑架构中创建一个表。
使用列定义创建：
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。如果指定一个数据库，它必须是当前数据库。
ORDER BY column[,...] 对外部表无效，指定 SELECT 列表中的列，基于该列表对为此表自动创建的超投影进行排序。ORDER BY 子句不能包含限定符 ASC 或 DESC。Vertica 始终按升序存储投影数据。
如果省略
ORDER BY 子句，Vertica 将使用 SELECT 列表顺序作为投影排序顺序。
segmentation-spec对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：
hash‑segmentation‑clause：指定将数据均匀分段并分布在群集节点上。Vertica 建议对大表进行分段。
unsegmented‑clause：指定以创建未分段的投影。
KSAFE [safety] 对外部表无效，指定为此表创建的 自动投影的 K-safety，其中 k‑num 必须等于或大于系统 K-safety。如果您省略此选项，投影将使用系统 K-safety 水平。
PARTITION BY partition-expression
[ GROUP BY group-expression ] [ ACTIVEPARTITIONCOUNT integer ]
只有从查询 (
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-tableEXCLUDING PROJECTIONS（默认值）：不要从源表中复制投影。
INCLUDING PROJECTIONS：从新表的源表中复制当前投影。
{INCLUDE|EXCLUDE} [SCHEMA] PRIVILEGES：请参阅以上描述）。
DISK_QUOTA配额如果未指定，则表没有配额。
超级用户可以设置磁盘配额。
非超级用户：
对表架构的 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
指定将应用于某一列的名称、数据类型和约束。
column-name data-type
[ column‑constraint ][...]
[ ENCODING encoding-type ]
[ ACCESSRANK integer ]
column-namedata-typecolumn‑constraintENCODING 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)
);
用于在通过查询创建表或临时表时重命名列；还可用于指定列的编码类型和 访问等级。
column-name-list
[ ENCODING encoding‑type ]
[ ACCESSRANK integer ]
[ GROUPED ( column‑reference[,...] ) ]
ENCODING encoding‑typeACCESSRANK integerGROUPED列表中的列不能指定该列的数据类型或任何约束。这些是从已查询表中派生的。
如果查询输出包含表达式简单列以外的表达式（例如，常数或函数），则必须为该表达式指定别名，或者列名称列表中必须包括所有已查询列。
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;
为某一列的元数据添加约束。有关详细信息，请参阅约束。
[ { 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‑namePRIMARY KEY
REFERENCES （外键）
CHECK
UNIQUE
如果忘记为这些约束分配名称，Vertica 会分配其自己的名称。有关详细信息，请参阅对约束进行命名。
Vertica 建议对所有约束进行命名。
CHECK (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 值。如果您在主键列上设置此约束，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
有关详细信息，请参阅约束强制执行。
通过表定义中的 PARTITION BY 子句指定表数据的分区：
PARTITION BY partition‑expression [ GROUP BY group‑expression ] [ active‑partition‑count‑expr ]
PARTITION BY partition‑expressionGROUP BY group‑expression...PARTITION BY (i+j) GROUP BY (
CASE WHEN (i+j) < 5 THEN 1
WHEN (i+j) < 10 THEN 2
ELSE 3);
在 CREATE TABLE 的分区子句中：
ACTIVEPARTITIONCOUNT integer
在 ALTER TABLE 的分区子句中：
SET ACTIVEPARTITIONCOUNT integer
此设置将取代配置参数 ActivePartitionCount。有关用法的详细信息，请参阅活动和非活动分区。
PARTITION BY 表达式可以指定叶表达式、函数和运算符。以下要求和限制适用：
CREATE TABLE t1 (a int, b int) PARTITION BY (ZEROIFNULL(a)); CREATE TABLE
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 会将其合并到适当的分区中，以此根据需要创建新的分区键。
为表元数据添加约束。您可以使用
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‑namePRIMARY KEYNOT NULL 列作为主键，如下所示：
PRIMARY KEY (column[,...]) [ ENABLED | DISABLED]
可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。
如果您没有命名主键约束，Vertica 会分配名称 C_PRIMARY。
FOREIGN KEYFOREIGN KEY (column[,... ]) REFERENCES table [(column[,... ])]
如果省略了 column，Vertica 将引用 table 中的主键。
如果您没有命名外键约束，Vertica 会分配名称 C_FOREIGN。
添加外键约束需要以下权限（除了 ALTER TABLE 也需要的权限外）：
对引用表的 REFERENCES 权限
对引用表架构的 USAGE 权限
UNIQUEUNIQUE (column[,...]) [ENABLED | DISABLED]
可以使用关键字 ENABLED 或 DISABLED 来限定此子句。请参阅下面的强制执行约束。
如果您没有命名唯一约束，Vertica 会分配名称 C_UNIQUE。
CHECKCHECK (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)
创建数据仅存在于当前会话中的表。默认情况下，临时表数据对其他会话不可见。
使用列定义创建：
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 ]
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-namecolumn-definitiontable-constraintON COMMIT ON COMMIT {PRESERVE | DELETE} ROWS
DELETE（默认）会将临时表标记为事务范围数据。每次提交之后，Vertica 会移除所有表数据。
PRESERVE 会将临时表标记为会话范围数据，这些数据在单个事务结束后仍会保存。但会话结束后，Vertica 会移除所有表数据。
NO PROJECTIONNO 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 列表顺序作为投影排序顺序。
对外部表无效，指定如何为此表的自动投影分发数据。提供以下子句之一：
hash‑segmentation‑clause：指定将数据均匀分段并分布在群集节点上。Vertica 建议对大表进行分段。
unsegmented‑clause：指定以创建未分段的投影。
KSAFE [safety-level]对外部表无效，指定为此表创建的 自动投影的 K-safety，其中 k‑num 必须等于或大于系统 K-safety。如果您省略此选项，投影将使用系统 K-safety 水平。
Eon 模式： 无论系统 K-safety 如何，临时表的 K-safety 始终设置为 0。如果 CREATE TEMPORARY TABLE 语句将 k‑num 设置为大于 0，Vertica 会返回警告。
只有从查询 (
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配额如果未指定，则表没有配额。
磁盘配额对全局临时表有效，对本地临时表无效。
必须具有以下权限：
对表架构的 CREATE 权限
如果创建包含命名序列的临时表：
对于序列对象的 SELECT 权限
对于序列架构的 USAGE 权限
对临时表的查询与对持久表的查询面临相同的 SQL 支持限制。
不可以将投影添加到非空的全局临时表 (ON COMMIT PRESERVE ROWS)。请确保投影在加载数据之前已存在。请参阅自动投影。
尽管可以为定义时指定了 ON COMMIT DELETE ROWS 的临时表添加投影，但需要注意的是，您可能会丢失所有数据。
无法对会话范围临时数据执行合并操作。
一般来说，使用系统（虚拟）表时，会话范围临时表数据不可见。
临时表不会恢复。如果某个节点发生故障，使用临时表的查询也会失败。重新启动会话并填充临时表。
本地临时表不能设置磁盘配额。
请参阅创建临时表。
创建用于执行文本搜索的文本索引。如果表中的数据已分区，则文本索引中会显示一个额外的列用于显示分区。
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‑namesource‑tableunique‑idtext‑fieldCHAR
VARCHAR
LONG VARCHAR
VARBINARY
LONG VARBINARY
允许 null 值。
column‑namestemmer‑namestemmer‑input‑data‑typetokenizer‑nametokenizer‑input‑data‑type如果使用了 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)
创建 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 cert_name ca_cert_name openssl_cipher 要查看启用的密码套件，请使用 LIST_ENABLED_CIPHERS。
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 相同。
将名称添加到授权数据库用户列表。
CREATE USER user‑name [ account‑parameter value[,...] ]
account‑parameter value将一个或多个用户帐户参数指定为逗号分隔的列表：
account‑parameter setting[,...]
超级用户
Vertica 数据库用户名称在逻辑上独立于服务器运行的操作系统的用户名称。如果特定服务器中所有用户也具有服务器计算机的帐户，则有必要分配与操作系统用户名称匹配的数据库用户名称。但是，接受远程连接的服务器可能拥有许多没有本地操作系统帐户的数据库用户。在这种情况下，无需连接数据库和系统用户名称。
=> CREATE USER Fred IDENTIFIED BY 'Mxyzptlk';
=> GRANT USAGE ON SCHEMA PUBLIC to Fred;
定义 视图。视图是只读内容，所以不支持插入、更新、删除或复制操作。
CREATE [ OR REPLACE ] VIEW [[database.]schema.]view [ (column[,...]) ]
[ {INCLUDE|EXCLUDE} [SCHEMA] PRIVILEGES ] AS query
OR REPLACECREATE VIEW 返回错误。
在执行 CREATE OR REPLACE 之前分配给视图的任何权限都保留在更新后的视图上。请参阅GRANT（视图）。
[database]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
[,...]SELECT 语句。SELECT 语句可以引用表、临时表以及其他视图。{INCLUDE|EXCLUDE}[SCHEMA] PRIVILEGESINCLUDE 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;
停用一个或多个先前由 ACTIVATE DIRECTED QUERY 激活的定向查询。
DEACTIVATE DIRECTED QUERY { query-name | input-query }
query‑nameinput‑query从表中移除指定的行并返回已删除的行的计数。0 的计数并非错误，而是表示没有任何一行符合条件。未限定的 DELETE 语句（省略 WHERE 子句的语句）会移除所有行但留下完整的表列、投影和约束。
DELETE 支持子查询和联接，这样您可以基于其他表中的值删除某个表中的值。
DELETE [ /*+LABEL (label‑string)*/ ] FROM [[database.]schema.]table [ where-clause ]
LABEL将标签分配到语句，以便您可以在分析和调试时识别它。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表所有者或用户 WITH GRANT OPTION 是授予者。
对表的 DELETE 权限
目标表架构的 USAGE 权限
当 DELETE 语句包含用于指定表列的 WHERE 或 SET 子句时，对某个表的 SELECT 权限。
无法对不可变表执行 DELETE 操作。
Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。
从持久表中删除数据时，DELETE 会直接从 ROS 中移除数据。
对临时表执行的 DELETE 操作会有所不同，具体取决于表是通过 ON COMMIT DELETE ROWS（默认）还是 ON COMMIT PRESERVE ROWS 创建的：
如果 DELETE 包含用于指定待移除行的 WHERE 子句，则操作是相同的：DELETE 标记待删除的行。在这两种情况下，您都无法回退到更早的保存点。
如果 DELETE 省略 WHERE 子句，且该表通过 ON COMMIT PRESERVE ROWS 创建，Vertica 会标记所有待删除的表行。如果表是通过 ON COMMIT DELETE ROWS 创建的，DELETE 操作和 TRUNCATE TABLE 一样，会从存储空间中移除所有行。
以下语句将从临时表中移除所有行：
=> DELETE FROM temp1;
以下语句将从满足条件的架构限定表中删除所有记录：
=> DELETE FROM retail.customer WHERE state IN ('MA', 'NH');
有关显示如何在 DELETE 语句中嵌套子查询的示例，请参阅 UPDATE 和 DELETE 中的子查询。
关闭与在同一会话中使用
CONNECT TO VERTICA 打开的另一个 Vertica 数据库的连接。
DISCONNECT db‑spec
db‑spec DEFAULT。无
=> DISCONNECT DEFAULT;
DISCONNECT
执行匿名（未命名）存储过程，但不保存。
DO [ LANGUAGE 'language-name' ] $$
source
$$;
PLvSQL
PLpgSQL
默认值： PLvSQL
无
有关更复杂的示例，请参阅 存储过程：用例和示例
此过程将打印 DECLARE 块中的变量：
DO LANGUAGE PLvSQL $$
DECLARE
x int := 3;
y varchar := 'some string';
BEGIN
RAISE NOTICE 'x = %', x;
RAISE NOTICE 'y = %', y;
END;
$$;
NOTICE 2005: x = 3
NOTICE 2005: y = some string
有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。
DROP 语句可用于删除数据库对象，例如架构、表和用户。
从列或行中删除访问策略。
DROP ACCESS POLICY ON table FOR { COLUMN column | ROWS}
非超级用户：表的所有权
以下这些示例展示了能够删除访问策略的各种情况。
删除列访问策略：
=> DROP ACCESS POLICY ON customer FOR COLUMN Customer_Number;
删除表的行访问策略：
=> DROP ACCESS POLICY ON customer_info FOR ROWS;
从 Vertica 编录中删除用户定义的聚合函数 (UDAnF)。
DROP AGGREGATE FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arglist ] )
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
{ [argname] argtype }[,...]
argname 选择性地指定实参名称，通常是列名称。
argtype 指定实参的数据类型，其中 argtype 与 Vertica 数据库类型匹配。
非超级用户：所有者
要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。
Vertica 不会检查依赖项，因此，如果删除其他对象（例如视图或其他 SQL 函数）所引用的 SQL 函数，Vertica 会在使用这些对象时（而非删除该函数时）返回错误。
以下命令将删除 ag_avg 函数：
=> DROP AGGREGATE FUNCTION ag_avg(numeric);
DROP AGGREGATE FUNCTION
从 Vertica 编录中删除用户定义的分析函数。
DROP ANALYTIC FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arglist ] )
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
{ [argname] argtype }[,...]
argname 选择性地指定实参名称，通常是列名称。
argtype 指定实参的数据类型，其中 argtype 与 Vertica 数据库类型匹配。
非超级用户：所有者
要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。
Vertica 不会检查依赖项，因此，如果删除其他对象（例如视图或其他 SQL 函数）所引用的 SQL 函数，Vertica 会在使用这些对象时（而非删除该函数时）返回错误。
以下命令将删除 analytic_avg 函数：
=> DROP ANALYTIC FUNCTION analytic_avg(numeric);
DROP ANALYTIC FUNCTION
删除身份验证方法。
DROP AUTHENTICATION [ IF EXISTS ] auth‑method‑name [ CASCADE ]
IF EXISTSCASCADE超级用户
删除身份验证方法 md5_auth：
=> DROP AUTHENTICATION md5_auth;
使用 CASCADE 删除已授予用户的身份验证方法：
=> CREATE AUTHENTICATION localpwd METHOD 'password' LOCAL;
=> GRANT AUTHENTICATION localpwd TO jsmith;
=> DROP AUTHENTICATION localpwd CASCADE;
删除证书颁发机构 (CA) 捆绑包。
DROP CA BUNDLE [ IF EXISTS ] name [,...] [ CASCADE ]
IF EXISTSnameCASCADECA 捆绑包的所有权
请参阅管理 CA 捆绑包。
从数据库中删除 TLS 证书。
要查看现有证书，请查询 CERTIFICATES。
DROP CERTIFICATE [ IF EXISTS ] certificate-name [,...] [ CASCADE ]
IF EXISTSCASCADE非超级用户，为以下之一：
删除 server_cert，如果存在：
=> DROP CERTIFICATE server_cert;
DROP CERTIFICATE;
删除 CA 证书及其依赖项（通常是它已签名的证书）：
=> DROP CERTIFICATE ca_cert CASCADE;
DROP CERTIFICATE;
从数据库中删除定向查询。如果定向查询处于活动状态，Vertica 会在移除前将其停用。
DROP DIRECTED QUERY directed-query-id
directed‑query‑id移除指定容错组及其子容错组，并会将所有节点放置在已删除容错组的父组下。
要删除所有容错组，请使用 ALTER DATABASE..DROP ALL FAULT GROUP。
要将孤立的节点添加回容错组，必须使用 CREATE FAULT GROUP 和 ALTER FAULT GROUP...ADD NODE 手动将其重新分配给新的或现有容错组。
DROP FAULT GROUP [ IF EXISTS ] fault‑group
IF EXISTS超级用户
=> DROP FAULT GROUP group2;
DROP FAULT GROUP
从 Vertica 编录中删除用户定义的加载筛选器函数。
DROP FILTER [[database.]schema.]filter()
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
filter()非超级用户：
所有者或 DROP 权限
对架构的 USAGE 权限
以下命令将删除 Iconverter 筛选器函数：
=> drop filter Iconverter();
DROP FILTER
从 Vertica 编录中删除 SQL 函数或用户定义的函数 (UDF)。
DROP FUNCTION [ IF EXISTS ] [[database.]schema.]function[,...] ( [ arg‑list ] )
IF EXISTS [database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
arg‑list创建此函数时为其定义的以逗号分隔的实参列表，按如下方式指定：
[arg‑name] arg‑type[,...]
其中 arg-name（可选）限定 arg-type：
arg‑name 通常是列名称。
arg‑type 是 Vertica 支持的 SQL 数据类型的名称。
非超级用户，为以下之一：
所有者或 DROP 权限
对架构的 USAGE 权限
要删除某个函数，必须指定实参类型，因为多个函数可能共用相同的名称但是具有不同的参数。
删除 SQL 函数时，Vertica 不会检查依赖项，因此，如果其他对象引用 SQL 函数（例如视图或其他 SQL 函数），Vertica 只会在使用这些对象时返回错误。
以下命令将删除 zerowhennull 函数，该函数在 macros 架构中：
=> DROP FUNCTION macros.zerowhennull(x INT);
DROP FUNCTION
从数据库中删除加密密钥及其证书（如果有）。
要查看现有的加密密钥，请查询 CRYPTOGRAPHIC_KEYS。
DROP KEY [ IF EXISTS ] key-name [,...] [ CASCADE ]
IF EXISTSCASCADE非超级用户，为以下之一：
密钥的所有权
DROP 权限
删除 k_ca，如果存在：
=> DROP KEY k_ca IF EXISTS;
DROP KEY;
删除 k_client 及其依赖项（与之关联的证书）：
=> DROP KEY k_client CASCADE;
DROP KEY;
从数据库中移除 UDx 库。从 Vertica 节点上的托管目录中删除库文件。库中用户定义的函数 (UDF) 不再可用。有关详细信息，请参阅开发用户定义的扩展 (UDx)。
DROP LIBRARY [ IF EXISTS ] [[database.]schema.]library [ CASCADE]
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
库CASCADE可为以下之一：
超级用户
UDXDEVELOPER 和库所有者（通过 CREATE LIBRARY 创建库的用户）
UDXDEVELOPER 和对库的 DROP 权限（请参阅 GRANT（库））
超级用户可以删除任何库：
=> DROP LIBRARY ml.MyLib CASCADE;
具有 UDXDEVELOPER 角色的用户可以删除其创建的库：
=> GRANT UDXDEVELOPER TO alice, bob;
GRANT ROLE
=> \c - alice;
You are now connected as user "alice".
-- Must enable the role before using:
=> SET ROLE UDXDEVELOPER;
SET
-- Create and use ml.mylib...
-- Drop library and dependencies:
DROP LIBRARY ml.mylib CASCADE;
DROP LIBRARY
可以向用户授予删除库的显式权限：
=> \c - alice
You are now connected as user "alice".
=> GRANT DROP ON LIBRARY ml.mylib to bob;
GRANT PRIVILEGE
=> \c - bob
You are now connected as user "bob".
=> SET ROLE UDXDEVELOPER;
SET
=> DROP LIBRARY ml.mylib cascade;
DROP LIBRARY
删除负载均衡组。
DROP LOAD BALANCE GROUP [ IF EXISTS ] group_name [ CASCADE ]
IF EXISTSgroup_name[CASCADE]以下语句演示了当负载均衡组具有依赖路由规则以及使用 CASCADE 关键字时会出现的错误：
=> DROP LOAD BALANCE GROUP group_all;
NOTICE 4927: The RoutingRule catch_all depends on LoadBalanceGroup group_all
ROLLBACK 3128: DROP failed due to dependencies
DETAIL: Cannot drop LoadBalanceGroup group_all because other objects depend on it
HINT: Use DROP ... CASCADE to drop the dependent objects too
=> DROP LOAD BALANCE GROUP group_all CASCADE;
DROP LOAD BALANCE GROUP
从 Vertica 数据库中移除一个或多个模型。
DROP MODEL [ IF EXISTS ] [[database.]schema.]model[,...]
IF EXISTS数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
以下几项之一：
超级用户
非超级用户：模型所有者
请参阅删除模型。
从编录中删除网络地址。网络地址是节点上用于连接负载均衡策略的 IP 地址和端口的名称。
DROP NETWORK ADDRESS [ IF EXISTS ] address‑name [ CASCADE ]
IF EXISTS address‑name CASCADE以下语句演示了当网络地址具有依赖的负载均衡组以及使用 CASCADE 关键字时会出现的错误：
=> DROP NETWORK ADDRESS node01;
NOTICE 4927: The LoadBalanceGroup group_1 depends on NetworkInterface node01
NOTICE 4927: The LoadBalanceGroup group_random depends on NetworkInterface node01
ROLLBACK 3128: DROP failed due to dependencies
DETAIL: Cannot drop NetworkInterface node01 because other objects depend on it
HINT: Use DROP ... CASCADE to drop the dependent objects too
=> DROP NETWORK ADDRESS node01 CASCADE;
DROP NETWORK ADDRESS
从 Vertica 中移除网络接口。使用 CASCADE 选项还可以从节点定义中移除网络接口。（有关详细信息，请参阅识别用于导入/导出的数据库或节点。）
DROP NETWORK INTERFACE [ IF EXISTS ] network‑interface‑name [ CASCADE ]
参数定义如下：
IF EXISTSCASCADE超级用户
=> DROP NETWORK INTERFACE myNetwork;
删除通过
CREATE NOTIFIER 创建的基于推送的通知程序。
DROP NOTIFIER [ IF EXISTS ] notifier‑name
IF EXISTS从 Vertica 编录中删除用户定义的加载解析器函数。
DROP PARSER[[database.]schema.]parser()
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
parser()非超级用户：
所有者或 DROP 权限
对架构的 USAGE 权限
=> DROP PARSER BasicIntegerParser();
DROP PARSER
仅限企业模式
从 Vertica 中移除外部过程。只会移除对 Vertica 内部过程的引用。外部文件仍保留在每个数据库节点的
database/procedures 目录中。
DROP PROCEDURE [ IF EXISTS ] [[database.]schema.]procedure( [ parameter‑list ] )
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
[parameter‑name] parameter‑type[,...]
其中 parameter-name 选择性地限定 parameter-type。
非超级用户：
所有者或 DROP 权限
对架构的 USAGE 权限
=> DROP PROCEDURE helloplanet(arg1 varchar);
删除存储过程。
DROP PROCEDURE [ IF EXISTS ] [[database.]schema.]procedure( [ parameter-type-list] );
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
过程非超级用户：
所有者或 DROP 权限
对架构的 USAGE 权限
对于下列过程：
=> CREATE PROCEDURE raiseXY(IN x INT, y VARCHAR) LANGUAGE PLvSQL AS $$
BEGIN
RAISE NOTICE 'x = %', x;
RAISE NOTICE 'y = %', y;
-- some processing statements
END;
$$;
CALL raiseXY(3, 'some string');
NOTICE 2005: x = 3
NOTICE 2005: y = some string
您可以使用以下命令进行删除：
=> DROP PROCEDURE raiseXY(INT, VARCHAR);
DROP PROCEDURE
有关 RAISE NOTICE 的详细信息，请参阅错误和诊断。
从数据库中移除用户定义的配置文件（通过
CREATE PROFILE 创建）。不能删除 DEFAULT 配置文件。
DROP PROFILE [ IF EXISTS ] profile‑name[,...] [ CASCADE ]
IF EXISTSCASCADE超级用户
=> DROP PROFILE sample_profile;
屏蔽要从编录中删除的 投影，以便该投影不可供用户查询。
DROP PROJECTION [ IF EXISTS ] { [[database.]schema.]projection[,...] } [ RESTRICT | CASCADE ]
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
projection如果投影未分段，则将删除数据库群集中的所有投影副本。
如果投影已分段，则将通过指定投影基本名的方式删除所有伙伴实例投影。您也可以指定具体的伙伴投影名称，但前提是如此删除该伙伴实例投影不会违反系统 K-safety。
有关投影名称约定，请参阅投影命名。
RESTRICT | CASCADERESTRICT （默认值）：仅在投影不包含任何对象的情况下将其删除。
CASCADE：即便投影包含对象，仍将其删除。
非超级用户：锚表的所有者
投影删除操作有以下限制：
删除用户创建的资源池。分配给此池的所有内存都将返回到 GENERAL 池。
DROP RESOURCE POOL pool-name [ FOR subcluster-spec ]
FOR subcluster‑specSUBCLUSTER subcluster-name：从已命名子群集中删除 pool‑name。您不能连接到此子群集，否则 Vertica 会返回错误。CURRENT SUBCLUSTER：从连接到的子群集中删除 pool‑name。如果省略此参数，将从所有子群集中删除资源池。如果为单个子群集创建了资源池，则必须指定此参数以将资源池从该子群集中显式删除；否则，Vertica 将返回错误。
超级用户
如果您尝试删除的资源池是另一个资源池的辅助池，则 Vertica 会返回一个错误。该错误会列出与您尝试删除的辅助池有关的资源池。要删除辅助资源池，首先在主要资源池上将 CASCADE TO 参数设置为 DEFAULT，然后再删除辅助池。
例如，可以删除资源池 rp2，它是 rp1 的辅助池，如下：
=> ALTER RESOURCE POOL rp1 CASCADE TO DEFAULT;
=> DROP RESOURCE POOL rp2;
按照该池对比于 GENERAL 池的优先级，队列中对该池的请求将全部传输给 GENERAL 池。如果该池的优先级高于 GENERAL 池，则这些请求将放置在队列列首；否则，这些请求将放置在队列列尾。
正在使用该池的用户将收到通知，通知其改为使用 GENERAL 池：
NOTICE: Switched the following users to the General pool: username
如果用户不具备使用 GENERAL 池的权限，DROP RESOURCE POOL 会返回错误。现有会话将传输给 GENERAL 池，而无论会话的用户是否具备使用 GENERAL 池的权限。如果正在删除的池的限制级别较 GENERAL 池高，这一会话传输过程会导致需要更多用户权限。为避免赋予用户更多特权，请按照以下步骤删除受限池：
针对所有用户调用池权限。
关闭对池有权限的所有会话。
删除资源池。
此示例将删除用户定义的资源池：
=> DROP RESOURCE POOL ceo_pool;
此 Eon 模式示例返回了当前子群集，然后删除了当前子群集的用户定义资源池：
=> SELECT CURRENT_SUBCLUSTER_NAME();
CURRENT_SUBCLUSTER_NAME
-------------------------
analytics_1
(1 row)
=> DROP RESOURCE POOL dashboard FOR CURRENT SUBCLUSTER;
DROP RESOURCE POOL
从数据库中删除角色。
DROP ROLE [ IF EXISTS ] role‑name[,...] [ CASCADE ]
IF EXISTSCASCADE超级用户
=> DROP ROLE appadmin;
NOTICE: User bob depends on Role appadmin
ROLLBACK: DROP ROLE failed due to dependencies
DETAIL: Cannot drop Role appadmin because other objects depend on it
HINT: Use DROP ROLE ... CASCADE to remove granted roles from the dependent users/roles
=> DROP ROLE appadmin CASCADE;
DROP ROLE
从编录中删除路由规则。
DROP ROUTING RULE [ IF EXISTS ] rule‑name
IF EXISTSrule‑name=> DROP ROUTING RULE internal_clients;
DROP ROUTING RULE
从数据库中永久删除架构。由于 DROP SCHEMA 是一个不可逆的过程，因此在删除架构前，请务必先确认您确实想要删除该架构。使用 CASCADE 参数可删除包含一个或多个对象的架构。
DROP SCHEMA [ IF EXISTS ] [database.]schema[,...] [ CASCADE | RESTRICT ]
IF EXISTSCASCADERESTRICT 非超级用户：架构所有者
不能删除 PUBLIC 架构。
如果有用户正在访问正在删除的架构中的对象，则在该事务完成前，不会删除该架构。
取消 DROP SCHEMA 语句可能导致无法预见的结果。
以下示例将删除架构 S1，但前提是该架构不包含任何对象：
=> DROP SCHEMA S1;
以下示例将删除架构 S1，而无论其包含架构与否：
=> DROP SCHEMA S1 CASCADE;
移除指定的命名序列号生成器。
DROP SEQUENCE [ IF EXISTS ] [[database.]schema.]sequence[,...]
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
非超级用户：序列或架构所有者
对于在表的默认表达式中指定的序列，在您下次尝试加载数据时，默认表达式会执行失败。Vertica 不会检查这些实例。
DROP SEQUENCE 不支持 CASCADE 关键字。如果序列用在列的默认表达式中，那么在从默认表达式中删除对序列的所有引用之前，不能删除该序列。
以下命令将删除名为 sequential 的序列。
=> DROP SEQUENCE sequential;
从 Vertica 编录中删除用户定义的加载源函数。
DROP SOURCE [[database.]schema.]source()
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
source()非超级用户：
所有者或 DROP 权限
对架构的 USAGE 权限
以下命令将删除 curl 源函数：
=> DROP SOURCE curl();
DROP SOURCE
从 Vertica 中移除子网。
DROP SUBNET [ IF EXISTS ] subnet‑name[,...] [ CASCADE ]
参数定义如下：
IF EXISTSCASCADE超级用户
=> DROP SUBNET mySubnet;
移除一个或多个表及其
投影。当您运行 DROP TABLE 时，更改会自动提交。
DROP TABLE [ IF EXISTS ] [ [database.]schema.]table[,...] [ CASCADE ]
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表CASCADECASCADE 可选，如果目标表只有自动投影。如果忽略此选项且任何表具有非超投影集，Vertica 将返回错误并回退整个删除操作。
此选项对外部表无效。
非超级用户：
请勿取消正在执行的 DROP TABLE。这样会导致数据库不一致。
请检查确定目标表不在使用中，无论是直接使用还是间接使用——例如，在视图中。
如果删除然后恢复被某视图引用的表，新表必须具有相同的名称和列定义。
请参阅 删除表
删除用于执行文本搜索的文本索引。
DROP TEXT INDEX [ IF EXISTS ] [[database.]schema.]idx‑table
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
idx‑tableDROP TEXT INDEX 语句中包含该索引的架构。dbadmin
表所有者
对于源表的 DROP 权限
=> DROP TEXT INDEX t_text_index;
DROP INDEX
删除现有的 TLS CONFIGURATION。
如果将 TLS 配置设置为配置参数，则无法删除。有关详细信息，请参阅TLS 配置。
DROP TLS CONFIGURATION tls_config_name
tls_config_name 非超级用户，为以下之一：
TLS 配置的所有权
DROP 权限
从 Vertica 编录中删除用户定义的转换函数 (UDTF)。
DROP TRANSFORM FUNCTION [ IF EXISTS ] [[database.]schema.]function( [ arg‑list ] )
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
arg‑list创建此函数时为其定义的以逗号分隔的实参列表，按如下方式指定：
[arg‑name] arg‑type[,...]
其中 arg-name（可选）限定 arg-type：
arg‑name 通常是列名称。
arg‑type 是 Vertica 支持的 SQL 数据类型的名称。
以下几项之一：
架构或函数所有者
以下命令将删除 tokenize UDTF，该 UDTF 在 macros 架构中：
=> DROP TRANSFORM FUNCTION macros.tokenize(varchar);
DROP TRANSFORM FUNCTION
以下命令将删除 Pagerank多态函数，该函数在 online 架构中：
=> DROP TRANSFORM FUNCTION online.Pagerank();
DROP TRANSFORM FUNCTION
从授权数据库用户列表中删除一个名称。
DROP USER [ IF EXISTS ] user‑name[,...] [ CASCADE ]
IF EXISTSCASCADE超级用户
当用户定义的对象不存在时，DROP USER 将成功：
=> CREATE USER user2;
CREATE USER
=> DROP USER IF EXISTS user2;
DROP USER
当用户创建的对象仍然存在时，DROP USER 将失败：
=> DROP USER IF EXISTS user1;
NOTICE: Table T_tbd1 depends on User user1
ROLLBACK: DROP failed due to dependencies
DETAIL: Cannot drop User user1 because other objects depend on it
HINT: Use DROP ... CASCADE to drop the dependent objects too
无论用户定义的对象是否存在，DROP USER CASCADE 均可成功。该语句会强制删除所有用户定义的对象，如架构、表及其关联投影：
=> DROP USER IF EXISTS user1 CASCADE;
DROP USER
删除指定视图。Vertica 不会检查删除的视图的依赖项。删除视图后，引用该视图的其他视图将出现故障。
如果删除视图，并将其替换为具有相同名称和列名称的其他视图或表，则引用该名称的其他视图将使用新视图。如果更改新视图中的列数据类型，则服务器会将旧数据类型强制转换为新类型（如果可行）；否则将返回错误。
DROP VIEW [ IF EXISTS ] [[database.]schema.]view[,...]
IF EXISTS[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
为以下几项之一
视图所有者和 USAGE 权限
架构所有者
=> DROP VIEW myview;
结束当前事务，使事务期间发生的所有变更永久化且对其他用户可见。
END [ WORK | TRANSACTION ]
WORK | TRANSACTION无
=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
BEGIN
=> CREATE TABLE sample_table (a INT);
CREATE TABLE
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)
=> END;
COMMIT
返回 Vertica 用于执行特定语句的优化器计划的格式化描述。
EXPLAIN [/*+ ALLNODES */] [explain-options] sql-statement
/*+ALLNODES*/LOCAL 选项无效。EXPLAIN 选项，按所示顺序指定：
[ LOCAL ] [ VERBOSE ] [ JSON ] [ ANNOTATED ]
LOCAL：在多节点数据库中，显示分配给每一节点的本地查询计划，它们共同组成整个（全球）查询计划。如果您忽略此选项，Vertica 将仅显示全局查询计划。本地查询计划仅以 DOT 语源显示，在 Graphviz 中呈现。
此选项与提示 /*+ALL NODES*/ 不兼容。如果您同时指定两者，EXPLAIN 将返回错误。
VERBOSE：增加呈现的查询计划的详细程度。
JSON：以 JSON 格式呈现查询计划。此选项仅与 VERBOSE 兼容。
ANNOTATED：嵌入用于封装此查询的查询计划的优化器提示。Vertica 使用这些提示来创建定向查询。有关详细信息，请参阅定向查询。此选项与 LOCAL 和 VERBOSE 兼容。
SELECT、
INSERT、
UPDATE、
COPY 和
MERGE。指定语句要求的同一特权。
以下要求适用于 EXPLAIN 的作用，用于产生有用信息：
必须提供您数据中的具有合理代表性的统计信息。有关详细信息，请参阅收集统计信息。
EXPLAIN 仅在可以为被查询的表提供投影时产生有用输出。
必须按之前显示的顺序指定限定符选项，否则 EXPLAIN 将返回错误。如果某个选项与前面的任何选项均不兼容，EXPLAIN 将忽略这些选项。
请参阅查看查询计划。
将表、表中的列或查询结果导出到分隔文件。可以使用 DELIMITED 读回文件。某些导出器参数具有相应的解析器参数，可用于更改分隔符、空指示符和其他格式。
您可以在导出语句中使用的查询有一些限制。请参阅查询限制。
您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。
此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。
在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。
EXPORT [ /*+LABEL (label-string)*/ ] TO DELIMITED ( directory=path[, param=value [,...] ]
[ OVER (over-clause ) ] AS SELECT query-expression
LABEL如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。
如果省略此子句，Vertica 会优化最大并行度。
directory输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：
Linux 文件系统、每个节点上的 NFS 挂载或本地存储
filename如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。
addHeader默认值：false
delimiter,（逗号）。
默认值： |（垂直条）
recordTerminator默认值： \n
enclosedBy默认值： ''（空字符串）
escapeAsenclosedBy 值。
默认值： \\（反斜杠）
nullAsbinaryTypesFormatDefault：可打印的 ASCII 字符（如果可能）和不可打印字节的已转义八进制表示。DELIMITED 解析器将读取此格式。
Hex：Base 16（十六进制）表示；值前面为“0x”，且字节不会被转义。
Octal：Base 8（八进制）表示，未转义。
Bitstring：二进制表示，未转义。
例如，可以将值 a\000b\001c 导出为如下格式：
默认（假设 \\ 的转义字符为）： a\\\000b\\\001c
十六进制： 0x6100620163
八进制： 141000142001143
位字符串： 0110000100000000011000100000000101100011
compressionUncompressed
BZip
GZip
默认值： 未压缩
fileExtension.bz2。
默认值： csv
fileSizeMB单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。
此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。
默认值： 10GB
fileMode仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或
user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。
有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。
dirMode仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。
非超级用户：
源表：SELECT
源表架构：USAGE
目标目录：写入
必须为作为表达式的选定列目标提供别名列标签。
如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。
查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：
=> EXPORT TO DELIMITED(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975: Only a single outer SELECT statement is supported
HINT: Please use a subquery for multiple outer SELECT statements
而需要重写查询以使用子查询：
=> EXPORT TO DELIMITED(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT
account_id,
json
FROM
(
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash
) a;
Rows Exported
---------------
2
(1 row)
要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。
此操作将原始 Flex 列导出为二进制数据。
导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。
输出文件名遵循以下模式：
[8-character-hash]-[nodename]-[thread-id].fileExtension.
分区目录中的列名采用小写。
由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。
具有以下要求和限制：
避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。
使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。
要输出到本地文件系统，您必须有一个 USER 存储位置。
导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。
有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。
以下示例导出未压缩的逗号分隔值 (CSV)，每个文件中都有一个标题行：
=> EXPORT TO DELIMITED(directory='webhdfs:///user1/data', delimiter=',', addHeader='true')
AS SELECT * FROM public.sales;
将表、表中的列或查询结果导出到 JSON 文件。可以使用 FJSONPARSER 将文件读回 Vertica。
您可以在导出语句中使用的查询有一些限制。请参阅查询限制。
您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。
此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。
在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。
EXPORT [ /*+LABEL (label)*/ ] TO JSON ( directory=path[, param=value [,...] ]
[ OVER (over-clause ) ] AS SELECT query-expression
LABEL如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。
如果省略此子句，Vertica 会优化最大并行度。
directory输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：
Linux 文件系统、每个节点上的 NFS 挂载或本地存储
filename如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。
omitNullFields默认值：false
compressionUncompressed
BZip
GZip
默认值： 未压缩
fileSizeMB单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。
此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。
默认值： 10GB
fileMode仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或
user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。
有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。
dirMode仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。
非超级用户：
源表：SELECT
源表架构：USAGE
目标目录：写入
必须为作为表达式的选定列目标提供别名列标签。
如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。
查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：
=> EXPORT TO JSON(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975: Only a single outer SELECT statement is supported
HINT: Please use a subquery for multiple outer SELECT statements
而需要重写查询以使用子查询：
=> EXPORT TO JSON(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT
account_id,
json
FROM
(
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash
) a;
Rows Exported
---------------
2
(1 row)
要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。
EXPORT TO JSON 可以以任意组合导出 ARRAY 和 ROW 类型。
EXPORT TO JSON 不支持二进制输出 (VARBINARY)。
导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。
输出文件名遵循以下模式：
[8-character-hash]-[nodename]-[thread-id].json.
分区目录中的列名采用小写。
由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。
具有以下要求和限制：
避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。
使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。
要输出到本地文件系统，您必须有一个 USER 存储位置。
导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。
有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。
在以下示例中，ROW 元素之一包含 null 值，该值将在输出中被忽略。EXPORT TO JSON 将每条 JSON 记录写入一行；为了便于阅读，已在以下输出中插入了换行符：
=> SELECT name, menu FROM restaurants;
name | menu
-------------------+------------------------------------------------------------
------------------
Bob's pizzeria | [{"item":"cheese pizza","price":null},{"item":"spinach pizza","price":10.5}]
Bakersfield Tacos | [{"item":"veggie taco","price":9.95},{"item":"steak taco","price":10.95}]
(2 rows)
=> EXPORT TO JSON (directory='/output/json', omitNullFields=true)
AS SELECT * FROM restaurants;
Rows Exported
---------------
2
(1 row)
=> \! cat /output/json/*.json
{"name":"Bob's pizzeria","cuisine":"Italian","location_city":["Cambridge","Pittsburgh"],
"menu":[{"item":"cheese pizza"},{"item":"spinach pizza","price":10.5}]}
{"name":"Bakersfield Tacos","cuisine":"Mexican","location_city":["Pittsburgh"],
"menu":[{"item":"veggie taco","price":9.95},{"item":"steak taco","price":10.95}]}
将表、表中的列或查询结果以 ORC 格式导出到文件。
可以在导出前使用 OVER() 子句对数据进行分区。除了导出列数据之外，还可以对数据进行分区。对数据进行分区可启用分区修剪，从而提高查询性能。请参阅分区文件路径。
您可以在导出语句中使用的查询有一些限制。请参阅查询限制。
您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。
此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。
在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。
EXPORT [ /*+LABEL (label-string)*/ ] TO ORC ( directory=path[, param=value [,...] ] )
[ OVER (over-clause ) ] AS SELECT query-expression
LABEL如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。
如果省略此子句，Vertica 会优化最大并行度。
directory输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：
Linux 文件系统、每个节点上的 NFS 挂载或本地存储
filename如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。
compressionZlib
Uncompressed
默认值： Zlib
stripeSizeMB默认值： 250
rowIndexStriderowIndexStride 行之后构建统计信息，或者为带区 < rowIndexStride 构建一次统计信息。
默认值： 1000
fileSizeMB单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。
此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。
默认值： 10GB
fileMode仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或
user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。
有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。
dirMode仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。
非超级用户：
源表：SELECT
源表架构：USAGE
目标目录：写入
必须为作为表达式的选定列目标提供别名列标签。
如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。
查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：
=> EXPORT TO ORC(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975: Only a single outer SELECT statement is supported
HINT: Please use a subquery for multiple outer SELECT statements
而需要重写查询以使用子查询：
=> EXPORT TO ORC(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT
account_id,
json
FROM
(
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash
) a;
Rows Exported
---------------
2
(1 row)
要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。
EXPORT TO ORC 将 Vertica 数据类型转换为 Hive 数据类型，如下表所示。
小数精度必须为 <= 38。
导出的 Hive 类型可能与 Vertica 类型不同。例如，Vertica INT 导出为 Hive BIGINT。在定义 Hive 外部表以读取导出的数据时，可能必须要调整列定义。
此操作将原始 Flex 列导出为二进制数据。
导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。
输出文件名遵循以下模式：
[8-character-hash]-[nodename]-[thread-id].orc.
分区目录中的列名采用小写。
由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。
具有以下要求和限制：
避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。
使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。
要输出到本地文件系统，您必须有一个 USER 存储位置。
导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。
有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。
以下示例演示了数据的分区和导出操作。EXPORT TO ORC 首先对区域上的数据进行分区，然后在每个分区内按存储进行排序。
=> EXPORT TO ORC(directory='gs://DataLake/user2/data')
OVER(PARTITION BY store.region ORDER BY store.ID)
AS SELECT sale.price, sale.date, store.ID
FROM public.sales sale
JOIN public.vendor store ON sale.distribID = store.ID;
有关更多示例，请参阅 EXPORT TO PARQUET，该语句（某些参数除外）操作与 EXPORT TO ORC 相同。
将表、表中的列或查询结果以 Parquet 格式导出到文件。
可以在导出前使用 OVER() 子句对数据进行分区。除了导出列数据之外，还可以对数据进行分区。对数据进行分区可启用分区修剪，从而提高查询性能。请参阅分区文件路径。
您可以在导出语句中使用的查询有一些限制。请参阅查询限制。
您可以以 ROS 格式导出存储在 Vertica 中的数据，也可以导出来自外部表的数据。
此语句返回写入的行数并在系统表中记录有关导出文件的信息。请参阅监控导出。
在导出到 HDFS 或 NFS 挂载点期间，Vertica 会将文件写入与目标位置相同的临时目录，并在导出完成后对该目录进行重命名。不要尝试使用临时目录中的文件。在导出到 S3、GCS 或 Azure 期间，Vertica 将文件直接写入目标路径，因此您必须等待导出完成才能读取文件。有关详细信息，请参阅导出到对象存储。
导出数据后，您可以使用 GET_METADATA 函数检查结果。
EXPORT [ /*+LABEL (label-string)*/ ] TO PARQUET ( directory=path[, param=value [,...] ] )
[ OVER (over-clause ) ] AS SELECT query-expression
LABEL如果您对数据进行分区，Vertica 会创建一个分区目录结构，将列名称转换为小写。有关目录结构的描述，请参阅分区文件路径。如果您使用 fileName 参数，则无法使用分区。
如果省略此子句，Vertica 会优化最大并行度。
directory输出文件的目标目录。目录不能存在，当前用户必须有写入权限。目标可以位于以下任何文件系统上：
Linux 文件系统、每个节点上的 NFS 挂载或本地存储
filename如果已指定，则所有输出都将写入由 directory 指定的位置中同名的单个文件。虽然查询可以由多个节点处理，但仅有一个节点生成输出数据。fileSizeMB 参数被忽略，查询无法在 OVER() 子句中使用分区。
compressionSnappy
GZIP
Brotli
ZSTD
Uncompressed
默认值： Snappy
rowGroupSizeMBfileSizeMB（包含）之间的整数值，如果 fileSizeMB 为 0，则为无限制。
导出文件中的行组小于此值，因为 Parquet 文件在写入时被压缩。为了在导出到 HDFS 时获得最佳性能，请将 size 设置为小于 HDFS 块大小。
行组大小会影响导出时的内存消耗。导出线程至少使用两倍的行组大小。默认值 512MB 是在写入更大行组和允许其他 Vertica 操作有足够可用内存之间进行折衷。如果您在数据库负载不重时执行导出，则可以通过增加导出的行组大小来提高导出数据的读取性能。但是，跨 HDFS 上的多个块的行组会因需要更多 I/O 而降低读取性能，因此请不要将行组大小设置为大于 HDFS 块大小。
默认值： 512
fileSizeMB单个输出文件的最大文件大小。此值是一个提示，而不是硬限制。值为 0 表示没有任何限制。如果还指定了 filename，则忽略 fileSizeMB。
此值影响单个输出文件的大小，而不是总输出大小。对于较小的值，Vertica 将输出分成更多的文件；仍会导出所有数据。
默认值： 10GB
fileMode仅对 HDFS 的写入，适用于所有导出文件的权限。您可以以 Unix 八进制格式指定值（例如 665）或
user-group-other格式 — 例如，rwxr-xr-x。即使采用八进制格式，也必须将该值的格式设置为字符串。
有效的八进制值范围介于 0 和 1777（包含）之间。请参阅 Apache Hadoop 文档中的 HDFS 权限。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 660，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值为何值。
dirMode仅对 HDFS 的写入，适用于所有导出目录的权限。这些值遵循与 fileMode 相同的规则。此外，您必须授予 Vertica HDFS 用户完全权限，至少为 rwx------ 或 700。
将文件写入 HDFS 以外的任何目标位置时，此参数无效。
默认值： 755，无论 hdfs-site.xml 中的 fs.permissions.umask-mode 的值如何。
int96AsTimestamp默认值：true
非超级用户：
源表：SELECT
源表架构：USAGE
目标目录：写入
必须为作为表达式的选定列目标提供别名列标签。
如果对输出进行分区，则不能在 SELECT 语句中指定架构和表名。只能指定列名称。
查询只能包含一个外部 SELECT 语句。例如，您不能使用 UNION：
=> EXPORT TO PARQUET(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash;
ERROR 8975: Only a single outer SELECT statement is supported
HINT: Please use a subquery for multiple outer SELECT statements
而需要重写查询以使用子查询：
=> EXPORT TO PARQUET(directory = '/mnt/shared_nfs/accounts/rm')
OVER(PARTITION BY hash)
AS
SELECT
account_id,
json
FROM
(
SELECT 1 as account_id, '{}' as json, 0 hash
UNION ALL
SELECT 2 as account_id, '{}' as json, 1 hash
) a;
Rows Exported
---------------
2
(1 row)
要使用 UNION、INTERSECT 和 EXCEPT 等复合语句，请将其重写为子查询。
EXPORT TO PARQUET 将 Vertica 数据类型转换为 Hive 数据类型，如下表所示。
小数精度必须为 <= 38。
导出的 Hive 类型可能与 Vertica 类型不同。例如，Vertica INT 导出为 Hive BIGINT。在定义 Hive 外部表以读取导出的数据时，可能必须要调整列定义。
此操作将原始 Flex 列导出为二进制数据。
导出操作始终会创建一个输出目录，即使所有输出都写入单个文件或查询返回零行。
输出文件名遵循以下模式：
[8-character-hash]-[nodename]-[thread-id].parquet.
分区目录中的列名采用小写。
由任何 Vertica 用户导出到本地文件系统的文件归 Vertica 超级用户所有。导出到 HDFS 或对象存储的文件归导出数据的 Vertica 用户所有。
具有以下要求和限制：
避免同时导出到相同的输出目标位置。这样做在任何文件系统上都是错误的，并且会产生不正确的结果。
使用共享文件位置进行输出。如果您使用本地文件系统中的目录，它必须是 NFS 挂载的目录。
要输出到本地文件系统，您必须有一个 USER 存储位置。
导出到本地文件系统时，目录权限模式为 700，文件权限模式为 600。您无法覆盖这些值。
有关特定于对象存储（S3、GCS 或 Azure）的限制，请参阅导出到对象存储。
以下示例演示了如何使用 GZIP 压缩从公共架构的 T1 表中导出所有列。
=> EXPORT TO PARQUET(directory='webhdfs:///user1/data', compression='gzip')
AS SELECT * FROM public.T1;
以下示例演示了如何使用多个表导出查询结果。
=> EXPORT TO PARQUET(directory='s3://DataLake/sales_by_region')
AS SELECT sale.price, sale.date, store.region
FROM public.sales sale
JOIN public.vendor store ON sale.distribID = store.ID;
以下示例演示了数据的分区和导出操作。EXPORT TO PARQUET 首先对区域上的数据进行分区，然后在每个分区内按存储进行排序。
=> EXPORT TO PARQUET(directory='gs://DataLake/user2/data')
OVER(PARTITION BY store.region ORDER BY store.ID)
AS SELECT sale.price, sale.date, store.ID
FROM public.sales sale
JOIN public.vendor store ON sale.distribID = store.ID;
以下示例对作为表达式的选定列目标使用了别名列标签。
=> EXPORT TO PARQUET(directory='webhdfs:///user3/data')
OVER(ORDER BY col1) AS SELECT col1 + col1 AS A, col2
FROM public.T3;
以下示例为输出设置了权限。
=> EXPORT TO PARQUET(directory='webhdfs:///user1/data',
fileMode='432', dirMode='rwxrw-r-x')
AS SELECT * FROM public.T1;
将表数据从一个 Vertica 数据库导出到另一个数据库。
EXPORT [ /*+LABEL (label‑string)*/ ] TO VERTICA
database.[schema.]target‑table [ ( target‑columns ) ]
{ AS SELECT query‑expression | FROM [schema.]source‑table[ ( source‑columns ) ] }
LABEL将标签分配到语句，以便您可以在分析和调试时识别它。
数据库[schema.]target‑tabletarget‑columnsquery‑expression[schema.]source‑tablesource‑columns非超级用户：
源表：选择
源表架构： USAGE
目标表： INSERT
目标表架构： USAGE
将一个数据库中的所有表数据导出到另一个数据库时，如果两个表中的列定义都符合以下条件，EXPORT TO VERTICA 可以不用指定列列表：
列数相同
列名相同
列序列相同
列数据类型匹配或兼容
没有复杂的数据类型（ARRAY、SET 或 ROW），原生数组除外
如果其中任何一个条件不成立，则 EXPORT TO VERTICA 语句必须包含将源列和目标列显式映射到彼此的列列表，如下所示：
包含相同数量的列。
按相同顺序列出源列和目标列。
将具有相同（或兼容）数据类型的列配对。
请参阅将数据导出到另一个数据库。
在指定的输入查询上查询系统表 DIRECTED_QUERIES，并返回映射到输入查询的所有定向查询的详细信息。有关输出的详细信息，请参阅获取定向查询。
GET DIRECTED QUERY input-query
input-query无
请参阅获取定向查询。
GRANT AUTHENTICATION auth‑method‑name TO grantee[,...]
超级用户
将 v_ldap 身份验证与用户 jsmith 关联：
=> GRANT AUTHENTICATION v_ldap TO jsmith;
将 v_gss 身份验证与角色 DBprogrammer 关联：
=> CREATE ROLE DBprogrammer;
=> GRANT AUTHENTICATION v_gss TO DBprogrammer;
将客户端身份验证方法 v_localpwd 与角色 PUBLIC 关联，默认情况下会被分配给所有用户：
=> GRANT AUTHENTICATION v_localpwd TO PUBLIC;
GRANT { privilege[,...] | ALL [ PRIVILEGES ] }
ON DATABASE db‑spec
TO grantee[,...]
[ WITH GRANT OPTION ]
CREATE：创建架构。
TEMP：创建临时表。默认情况下，会通过所有用户的 DEFAULT 角色授予其此权限。
ALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
db‑spec指定当前数据库，设置为数据库名称或DEFAULT。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户：权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
以下示例授予用户 Fred 在当前数据库中创建架构的权利。
=> GRANT CREATE ON DATABASE DEFAULT TO Fred;
将加密密钥权限授予用户或角色。
要撤销授予的权限，请参阅 REVOKE（密钥）。
对于自己未拥有的加密对象，超级用户的访问权限有限。有关详细信息，请参阅数据库对象权限。
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] } ON KEY
key_name[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
权限，可为以下之一：
USAGE：允许用户执行以下操作：
密钥的 USAGE 还为将其用作私钥的证书提供了隐式 USAGE 权限。用户还可以从密钥或证书的所有权中获取此类权限。证书的 USAGE 权限允许用户执行以下操作：
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
以下示例将私钥的 USAGE 权限授予用户，该权限允许用户将自签名 CA 证书添加到 server TLS 配置：
=> CREATE KEY new_ca_key TYPE 'RSA' LENGTH 2048;
=> CREATE CA CERTIFICATE new_ca_cert
SUBJECT '/C=US/ST=Massachusetts/L=Cambridge/O=Micro Focus/OU=Vertica/CN=Vertica example CA'
VALID FOR 3650
EXTENSIONS 'authorityKeyIdentifier' = 'keyid:always,issuer', 'nsComment' = 'new CA'
KEY new_ca_key;
=> CREATE USER u1;
=> GRANT USAGE ON KEY new_ca_key TO u1;
=> GRANT ALTER ON TLS CONFIGURATION data_channel TO u1;
=> \c - u1
=> ALTER TLS CONFIGURATION data_channel ADD CA CERTIFICATES new_ca_cert;
-- clean up:
=> \c
=> ALTER TLS CONFIGURATION data_channel REMOVE CA CERTIFICATES new_ca_cert;
=> DROP KEY new_ca_key CASCADE;
=> DROP USER u1;
例如，当您使用连接器框架服务时，您可能需要授予一个用户库的使用权限，才可以设置 UD 会话参数。有关详细信息，请参阅实施 CFS。
GRANT privilege
ON LIBRARY [[database.]schema.]library[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
USAGE：授予对指定库中函数的访问权限。
DROP：授予删除被授予者创建的库的权限。
ALL [PRIVILEGES] [EXTEND]：授予同时属于授予者的所有库权限。授予者不能授予其自身缺少的权限。
您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包含 DROP 权限。未限定的 ALL 不包括此权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
EXECUTE 权限，并对其各自的架构具有 USAGE 权限。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
将 MyFunctions 库的 USAGE 权限授予 Fred：
=> GRANT USAGE ON LIBRARY MyFunctions TO Fred;
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON MODEL [[database.]schema.]model‑name[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
ALL [PRIVILEGES][EXTEND] 您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
此示例将 mySvmClassModel 模型的 USAGE 权限授予 user1：
=> GRANT USAGE ON MODEL mySvmClassModel TO user1;
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURE [[database.]schema.]procedure( [arg-list] )[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
EXECUTEALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
[ argname ] argtype
如果过程未定义实参，请提供一个空的实参列表。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户，为以下之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色
将 tokenize 过程的 EXECUTE 权限授予用户 Bob 和 Jules，以及授予角色 Operator：
=> GRANT EXECUTE ON PROCEDURE tokenize(varchar) TO Bob, Jules, Operator;
将资源池的 USAGE 权限授予用户和角色。用户可以通过 ALTER USER 或 SET SESSION RESOURCE POOL 访问其资源池。
GRANT USAGE
ON RESOURCE POOL resource-pool[,...]
[FOR SUBCLUSTER subcluster | FOR CURRENT SUBCLUSTER]
TO grantee[,...]
[ WITH GRANT OPTION ]
USAGEALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
resource-pool subcluster grantee 指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
授予用户 Joe 对资源池 Joe_pool 的 USAGE 权限。
=> CREATE USER Joe;
CREATE USER
=> CREATE RESOURCE POOL Joe_pool;
CREATE RESOURCE POOL
=> GRANT USAGE ON RESOURCE POOL Joe_pool TO Joe;
GRANT PRIVILEGE
授予用户 Joe 对子群集 sub1 的资源池 Joe_pool 的 USAGE 权限。
=> GRANT USAGE on RESOURCE POOL Joe_pool FOR SUBCLUSTER sub1 TO Joe;
GRANT PRIVILEGE
GRANT role[,...] TO grantee[,...] [ WITH ADMIN OPTION ]
WITH ADMIN OPTION非超级用户：如果使用 WITH GRANT OPTION，则可以将相同的角色授予其他用户或角色。
请参阅授予数据库角色。
将架构权限授予用户和角色。默认情况下，只有超级用户和架构所有者才拥有以下架构权限：
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON SCHEMA [database.]schema[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
privilegeUSAGE：允许访问指定架构中的对象。然后可以授予被授予者对这些架构中的单个对象的访问权限，例如使用 GRANT TABLE 和 GRANT VIEW。
CREATE：在指定架构中创建和重命名对象，以及从其他架构中移动对象。
您还可以授予以下架构权限，以供表及其投影以及该架构的视图继承。如果数据库和架构启用了继承，这些权限会在创建时自动授予这些对象：
SELECT：查询表和视图。默认情况下，会将 SELECT 权限授予 PUBLIC 角色。
INSERT：插入行，或者使用
COPY 将数据加载到表中。
COPY FROM STDIN 允许具有 INSERT 权限的用户使用，而
COPY FROM 文件 需要管理员特权。
UPDATE：更新表行。
DELETE：删除表行。
REFERENCES：在此表上创建外键约束。必须对引用的和被引用的表上都设置此权限。
TRUNCATE：截断表内容。表的非所有者也可以对表执行以下分区操作：
ALTER：使用
ALTER TABLE 和
ALTER VIEW 分别修改表和视图的 DDL。
DROP：删除表和视图。
ALL [PRIVILEGES][EXTEND] 您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
[database.]schemagrantee指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户，为以下几项之一：
架构所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
授予用户 Joe 对架构 online_sales 的 USAGE 权限。
=> CREATE USER Joe;
CREATE USER
=> GRANT USAGE ON SCHEMA online_sales TO Joe;
GRANT PRIVILEGE
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON {
SEQUENCE [[database.]schema.]sequence[,...]
| ALL SEQUENCES IN SCHEMA [database.]schema[,...] }
TO grantee[,...]
[ WITH GRANT OPTION ]
ALTER：使用
ALTER SEQUENCE 修改序列的 DDL
DROP：使用
DROP SEQUENCE 删除此序列。
ALL [PRIVILEGES][EXTEND]您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
SEQUENCE sequenceALL SEQUENCES IN SCHEMA schema 指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
此示例说明如何授予用户 Joe 对序列 my_seq 的所有权限。
=> CREATE SEQUENCE my_seq START 100;
CREATE SEQUENCE
=> GRANT ALL PRIVILEGES ON SEQUENCE my_seq TO Joe;
GRANT PRIVILEGE
将用户定义的存储位置的权限授予用户和角色。有关详细信息，请参阅创建存储位置。
GRANT { privilege[,...] | ALL [ PRIVILEGES ] }
ON LOCATION 'path' [ ON node ]
TO grantee[,...]
[ WITH GRANT OPTION ]
READ：将数据从存储位置中的文件复制到表。
WRITE：将数据从数据库导出到存储位置。被授予者获得 WRITE 特权后，还可以将 COPY 语句被拒绝的数据和异常文件保存到存储位置。
ALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
ON LOCATION 'path' [ ON node] ON NODE 进行限定，Vertica 将授予对位于节点上的存储位置的访问权限。
如果未指定节点，则授予操作适用于指定路径上的所有节点。所有节点必须在指定路径上；否则，整个授权操作将回退。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
创建存储位置：
=> CREATE LOCATION '/home/dbadmin/UserStorage/BobStore' NODE 'v_mcdb_node0007' USAGE 'USER';
CREATE LOCATION
授予用户 Bob 对 /BobStore 位置的所有可用权限：
=> GRANT ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' TO Bob;
GRANT PRIVILEGE
取消授予 Bob 的全部存储位置特权：
=> REVOKE ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' FROM Bob;
REVOKE PRIVILEGE
再次授予 Bob 在 BobStore 位置的特权，指定节点：
=> GRANT ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' ON v_mcdb_node0007 TO Bob;
GRANT PRIVILEGE
取消授予 Bob的全部存储位置特权：
=> REVOKE ALL ON LOCATION '/home/dbadmin/UserStorage/BobStore' ON v_mcdb_node0007 FROM Bob;
REVOKE PRIVILEGE
将表权限授予用户和角色。同时必须将表架构的 USAGE 权限授予用户。
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON {
[ TABLE ] [[database.]schema.]table[,...]
| ALL TABLES IN SCHEMA [database.]schema[,...] }
TO grantee[,...]
[ WITH GRANT OPTION ]
ALL [PRIVILEGES][EXTEND] 您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
[database.]schemapublic。如果 schema 是除 public 以外的任何其他架构，则必须提供架构名称。例如：
myschema.thisDbObject
这里有一个例外：您可以指定系统表但不指定其架构名称。
如果指定一个数据库，它必须是当前数据库。
TABLE tableON ALL TABLES IN SCHEMA schema 指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
授予用户 Joe 对表 customer_dimension 的所有权限：
=> CREATE USER Joe;
CREATE USER
=> GRANT ALL PRIVILEGES ON TABLE customer_dimension TO Joe;
GRANT PRIVILEGE
授予用户 Joe 对所有系统表的 SELECT 权限：
=> GRANT SELECT on all tables in schema V_MONITOR, V_CATALOG TO Joe;
GRANT PRIVILEGE
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON {
UDx‑type [[database.]schema.]function( [arg‑list] )[,...]
| ALL FUNCTIONS IN SCHEMA schema[,...] }
TO grantee[,...]
[ WITH GRANT OPTION ]
ALL [PRIVILEGES] [EXTEND]您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
ON UDx‑typeFUNCTION （标量函数）
AGGREGATE FUNCTION
ANALYTIC FUNCTION
TRANSFORM FUNCTION
FILTER
PARSER
SOURCE
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
ON ALL FUNCTIONS IN SCHEMAschema[ argname ] argtype
如果过程未定义实参，请提供一个空的实参列表。
指定向谁授予权限，可以为以下值之一：
USAGE 权限。
WITH GRANT OPTION授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
将 myzeroifnullSQL 函数的 EXECUTE 权限授予用户 Bob 和 Jules 以及角色 Operator。该函数需要一个整数参数：
=> GRANT EXECUTE ON FUNCTION myzeroifnull (x INT) TO Bob, Jules, Operator;
将 zero-schema 架构中所有函数的 EXECUTE 权限授予用户 Bob：
=> GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA zero-schema TO Bob;
将tokenize转换函数的 EXECUTE 权限授予用户 Bob 和角色 Operator：
=> GRANT EXECUTE ON TRANSFORM FUNCTION tokenize(VARCHAR) TO Bob, Operator;
将 ExampleSource() 源的 EXECUTE 权限授予用户 Alice：
=> CREATE USER Alice;
=> GRANT USAGE ON SCHEMA hdfs TO Alice;
=> GRANT EXECUTE ON SOURCE ExampleSource() TO Alice;
将 ExampleSource() 源的所有权限授予用户 Alice：
=> GRANT ALL ON SOURCE ExampleSource() TO Alice;
将多态函数 Pagerank 的所有权限授予 dbadmin 角色：
=> GRANT ALL ON TRANSFORM FUNCTION Pagerank(z varchar) to dbadmin;
GRANT { privilege[,...] | ALL [ PRIVILEGES ] [ EXTEND ] }
ON [[database.]schema.]view[,...]
TO grantee[,...]
[ WITH GRANT OPTION ]
privilege ALL [PRIVILEGES][EXTEND]您可以使用两个可选关键字限定 ALL：
PRIVILEGES 符合 SQL 标准。
EXTEND 扩展 ALL 的语义以包括 ALTER 和 DROP 权限。未限定的 ALL 会排除这两个权限。此选项可向后兼容 9.2.1 之前的 Vertica 版本中的 GRANT ALL 用法。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
指定向谁授予权限，可以为以下值之一：
WITH GRANT OPTION 授予被授予者权限，以便将相同权限授予其他用户或角色的，也可以撤销它们。有关详细信息，请参阅授予权限。
非超级用户需要对架构的 USAGE 权限和以下权限之一：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
作为视图所有者，只有在以下情况之一为真时，您才能授予其他用户对视图的 SELECT 权限：
您拥有视图的基表。
您对视图的基表具有 SELECT...WITH GRANT OPTION 权限。
授予用户 Joe 对视图 ship 的所有权限。
=> CREATE VIEW ship AS SELECT * FROM public.shipping_dimension;
CREATE VIEW
=> GRANT ALL PRIVILEGES ON ship TO Joe;
GRANT PRIVILEGE
将值插入指定表的所有投影。每次只能插入一个完整的元组。如果没有与目标表关联的投影，Vertica 会创建一个超投影以存储插入值。
INSERT 适用于 flex 表以及常规原生表。如果表包含实际列，则会将标量类型的插入数据和标量类型的原生数组添加到实际列和 __raw__ 列。对于复杂类型的数据，不会将值添加到 __raw__ 列。
INSERT [ /*+LABEL (label‑string)*/ ] INTO [[database.]schema.]table-name
[ ( column-list ) ]
{ DEFAULT VALUES | VALUES ( values-list )[,...] | SELECT {{< codevar >}}query-expression{{< /codevar >}} }
LABEL将标签分配到语句，以便您可以在分析和调试时识别它。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table‑namecolumn‑listDEFAULT VALUES 对目标列列表无效。
DEFAULT VALUES不能使用此选项指定目标列的列表。
VALUES (values‑list) expression 将解析为要插入到目标列中的值。表达式不得嵌套其他表达式（包含 Vertica 元函数）或使用混合复杂类型。如果 Vertica 可以强制转换元素或字段类型，则值可能包括原生数组或 ROW 类型。
DEFAULT 将插入表定义中指定的默认值。
如果没有为列提供值，Vertica 会隐式添加 DEFAULT 值（如果已定义）。否则，Vertica 将插入 NULL 值。如果将列定义为 NOT NULL，则 INSERT 将返回错误。
您可以使用 INSERT 在目标表中插入多行，方法是指定多个以逗号分隔的 VALUES 列表：
INSERT INTO table-name
VALUES ( values-list ), ( values-list )[,...]
有关详细信息，请参阅下面的多行 INSERT。
SELECT query‑expression表所有者或具有 GRANT OPTION 权限的用户是授予者
对表的 INSERT 权限
包含表的架构上的 USAGE 权限
Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。
通过指定多个以逗号分隔的 VALUES 列表，您可以使用 INSERT 在目标表中插入多行。例如：
=> CREATE TABLE public.t1(a int, b int, c varchar(16));
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2, 'un, deux'), (3,4, 'trois, quatre');
OUTPUT
--------
2
(1 row)
=> COMMIT;
COMMIT
=> SELECT * FROM t1;
a | b | c
---+---+---------------
1 | 2 | un, deux
3 | 4 | trois, quatre
(4 rows)
Vertica 不支持将子查询作为 INSERT 语句的目标。
对在 SELECT 语句中使用 复杂类型的限制同样适用于 INSERT。使用无法强制转换为列类型的复杂值会导致错误。
如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。
如果插入会违反表或架构磁盘配额，则操作将失败。有关详细信息，请参阅磁盘配额。
=> INSERT INTO t1 VALUES (101, 102, 103, 104);
=> INSERT INTO customer VALUES (10, 'male', 'DPR', 'MA', 35);
=> INSERT INTO start_time VALUES (12, 'film','05:10:00:01');
=> INSERT INTO retail.t1 (C0, C1) VALUES (1, 1001);
=> INSERT INTO films SELECT * FROM tmp_films WHERE date_prod < '2004-05-07';
Vertica 不支持将子查询或嵌套的表达式作为 INSERT 语句的目标。例如，以下查询会返回一条错误消息：
=> INSERT INTO t1 (col1, col2) VALUES ('abc', (SELECT mycolumn FROM mytable));
ERROR 4821: Subqueries not allowed in target of insert
您可以重新编写以上查询，如下所示：
=> INSERT INTO t1 (col1, col2) (SELECT 'abc', mycolumn FROM mytable);
OUTPUT
--------
0
(1 row)
以下示例显示了如何将 INSERT...VALUES 与 flex 表一起使用：
=> CREATE FLEX TABLE flex1();
CREATE TABLE
=> INSERT INTO flex1(a,b) VALUES (1, 'x');
OUTPUT
--------
1
(1 row)
=> SELECT MapToString(__raw__) FROM flex1;
MapToString
---------------------------------
{
"a" : "1",
"b" : "x"
}
(1 row)
以下示例显示了如何将 INSERT...SELECT 与 flex 表一起使用：
=> CREATE FLEX TABLE flex2();
CREATE TABLE
=> INSERT INTO flex2(a, b) SELECT a, b, '2016-08-10 11:10' c, 'Hello' d, 3.1415 e, f from flex1;
OUTPUT
--------
1
(1 row)
=> SELECT MapToString(__raw__) FROM flex2;
MapToString
---------------------------------
{
"a" : "1",
"b" : "x",
"c" : "2016-08-10",
"d" : "Hello",
"e" : 3.1415,
"f" : null
}
(1 row)
以下示例使用复杂类型：
=> CREATE TABLE inventory(storeID INT, product ROW(name VARCHAR, code VARCHAR));
CREATE TABLE
--- LookUpProducts() returns a row(varchar, int), which is cast to row(varchar, varchar):
=> INSERT INTO inventory(product) SELECT LookUpProducts();
OUTPUT
--------
5
(1 row)
--- Cannot use with select...values:
=> INSERT INTO inventory(product) VALUES(LookUpProducts());
ERROR 2631: Column "product" is of type "row(varchar,varchar)" but expression is of type "row(varchar,int)"
--- Literal values are supported:
=> INSERT INTO inventory(product) VALUES(ROW('xbox',165));
OUTPUT
--------
1
(1 row)
=> SELECT product FROM inventory;
product
------------------------------
{"name":"xbox","code":"125"}
(1 row)
根据目标表与另一个数据集（例如表或视图）的联接结果，对其执行更新和插入操作。联接只能将一个源行与一个目标行匹配；否则，Vertica 将返回错误。
如果合并会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。
目标表不能包含复杂数据类型列。但源表可以，只要合并操作中不包含这些列。
MERGE [ /*+LABEL (label‑string)*/ ]
INTO [[database.]schema.]target‑table [ [AS] alias ]
USING source‑dataset
ON join-condition matching‑clause[ matching‑clause ]
更新或插入的目标表行数
LABEL将标签分配到语句，以便您可以在分析和调试时识别它。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
目标表[[database.]schema.]table [ [AS] alias ]
[[database.]schema.]view [ [AS] alias ]
(subquery) sq-alias
指定的数据集通常提供用于更新目标表和填充新行的数据。可以指定一个外部表。
ON join‑conditionMERGE 支持每个子句的一个实例，且必须至少包含一个实例。
WHEN MATCHED THEN UPDATE WHEN MATCHED [ AND update-filter ] THEN UPDATE
SET { column = expression }[,...]
update-filter 选择性地筛选匹配行的集合。更新筛选器可以指定任意数量的条件。Vertica 会根据此筛选器评估每个匹配行，并仅更新评估为 true 的行。有关详细信息，请参阅更新和插入筛选器。
Vertica 还支持用于指定更新筛选器的 Oracle 语法：
WHEN MATCHED THEN UPDATE
SET { <span class="code-variable">column</span> = <span class="code-variable">expression</span> }[,...]
[ WHERE <span class="code-variable">update‑filter </span>]
需要满足以下要求：
MERGE 语句只能包含一个 WHEN MATCHED 子句。
target‑column 只能指定目标表中的列名称。不能用表名称来限定。
有关详细信息，请参阅合并表数据。
WHEN NOT MATCHED THEN INSERT 在 target-table 中插入一个新行。
使用 values‑list 中指定的值填充每个新行。
WHEN NOT MATCHED [ AND insert-filter ] THEN INSERT
[ ( column‑list ) ] VALUES ( values‑list )
column‑list 是目标表中一个或多个目标列的逗号分隔列表，按任意顺序列出。MERGE 以相同的顺序将 column‑list 列映射到 values‑list 值，且每个列值对必须兼容。如果您忽略 column‑list，Vertica 将根据表定义中的列顺序将 values‑list 值映射到列。
insert-filter 选择性地筛选不匹配的行集。插入筛选器可以指定任意数量的条件。Vertica 根据此筛选器评估每个不匹配的源行。对于计算结果为 true 的每一行，Vertica 都会在目标表中插入一个新行。有关详细信息，请参阅更新和插入筛选器。
Vertica 还支持用于指定插入筛选器的 Oracle 语法：
WHEN NOT MATCHED THEN INSERT
[ ( <span class="code-variable">column‑list</span> ) ] VALUES ( <span class="code-variable">values‑list</span>
[ WHERE <span class="code-variable">insert‑filter </span>]
需要满足以下要求：
MERGE 语句只能包含一个 WHEN NOT MATCHED 子句。
column‑list 只能指定目标表中的列名称。不能用表名称来限定。
插入筛选条件只能引用源数据。如果任何条件引用目标表，Vertica 将返回错误。
有关详细信息，请参阅合并表数据。
MERGE 需要以下权限：
对源数据的 SELECT 权限以及对目标表的 INSERT、UPDATE 和 DELETE 权限。
自动约束强制执行要求具有对限制的表的 SELECT 权限。
如果语法中的条件从目标表中读取数据，则需要具有对目标表的 SELECT 权限。
例如，以下 GRANT 语句授予 user1 对 t2 表的访问权限。这将允许 user1 运行以下 MERGE 语句：
=> GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE t2 to user1;
GRANT PRIVILEGE
=>\c - user1
You are now connected as user "user1".
=> MERGE INTO t2 USING t1 ON t1.a = t2.a
WHEN MATCHED THEN UPDATE SET b = t1.b
WHEN NOT MATCHED THEN INSERT (a, b) VALUES (t1.a, t1.b);
您可以通过多种方式改善 MERGE 性能：
使用小于目标表的源数据集。
有关详细信息，请参阅MERGE 优化。
如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。
合并操作中不能指定以下列，否则将返回错误：
Identity/auto-increment 列，或默认值设置为命名序列的列。
Flex 表中的 Vmap 列，例如 __raw__。
复杂类型的列（ARRAY、SET、ROW）。
请参阅：
分析单个 SQL 语句。
PROFILE { sql-statement }
将分析摘要写入 stderr，将详细信息保存至系统编录
V_MONITOR.EXECUTION_ENGINE_PROFILES。
需要相同的权限运行已分析的语句
PROFILE 生成关于目标语句执行的详细信息，并将其保存在系统编录
V_MONITOR.EXECUTION_ENGINE_PROFILES 中。查询输出通过分析总结执行：分析标识符 transaction_id 和 statement_id、启动程序的查询内存以及需要的总内存。例如：
=> PROFILE SELECT customer_name, annual_income FROM public.customer_dimension WHERE (customer_gender, annual_income) IN (SELECT customer_gender, MAX(annual_income) FROM public.customer_dimension GROUP BY customer_gender);
NOTICE 4788: Statement is being profiled
HINT: Select * from v_monitor.execution_engine_profiles where transaction_id=45035996274683334 and statement_id=7;
NOTICE 3557: Initiator memory for query: [on pool general: 708421 KB, minimum: 554324 KB]
NOTICE 5077: Total memory required by query: [708421 KB]
customer_name | annual_income
------------------+---------------
Emily G. Vogel | 999998
James M. McNulty | 999979
(2 rows)
使用分析标识符在给定的查询中查询分析信息的表。
销毁保存点，而不撤销在建立保存点后所执行的命令的影响。
RELEASE [ SAVEPOINT ] savepoint_name
savepoint_name无
保存点一经销毁便不可用作回退点。
以下示例首先建立名为 my_savepoint 的保存点，然后将其销毁。值 101 和 102 均在提交时插入。
=> INSERT INTO product_key VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (102);
=> RELEASE SAVEPOINT my_savepoint;
=> COMMIT;
REVOKE AUTHENTICATION auth‑method‑name FROM grantee[,...]
超级用户
从用户 jsmith 撤销 v_ldap 身份验证：
=> REVOKE AUTHENTICATION v_ldap FROM jsmith;
从角色 DBprogrammer 撤销 v_gss 身份验证：
=> REVOKE AUTHENTICATION v_gss FROM DBprogrammer;
撤销 localpwd 作为默认客户端身份验证方法：
=> REVOKE AUTHENTICATION localpwd FROM PUBLIC;
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON DATABASE db‑spec
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
CREATE：创建架构。
TEMP：创建临时表。
ALL [PRIVILEGES]支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。
ON DATABASE db‑spec指定当前数据库，设置为数据库名称或DEFAULT。
grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Fred 在当前数据库中创建架构的权限：
=> REVOKE CREATE ON DATABASE DEFAULT FROM Fred;
撤销用户 Fred 在当前数据库中创建临时表的权限：
=> REVOKE TEMP ON DATABASE DEFAULT FROM Fred;
撤销用户或角色对加密密钥的权限。
要授予密钥权限，请参阅 GRANT（密钥）。
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] } ON KEY
key_name[,...]
FROM user[,...]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
权限，可为以下之一：
USAGE：允许用户执行以下操作：
密钥的 USAGE 还为将其用作私钥的证书提供了隐式 USAGE 权限。用户还可以从密钥或证书的所有权中获取此类权限。证书的 USAGE 权限允许用户执行以下操作：
指定向谁授予权限，可以为以下值之一：
非超级用户：
所有者
权限被授予者可以选择 (WITH GRANT OPTION) 将权限授予其他用户或角色。
以下示例撤销用户对密钥（以及扩展的相关证书）的 DROP 权限：
=> REVOKE USAGE ON KEY new_key FROM u1;
REVOKE PRIVILEGE
REVOKE [ GRANT OPTION FOR ] { USAGE | ALL [ PRIVILEGES ] }
ON LIBRARY [[database.]schema.]library[,...]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
USAGEALL [PRIVILEGES]PRIVILEGES 符合 SQL 标准。[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
库 grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
这些命令将展示如何新建一个库，然后如何授予和撤销用户 Fred 对该库的 USAGE 权限。
=> CREATE LIBRARY MyFunctions AS 'home/dbadmin/my_functions.so';
=> GRANT USAGE ON LIBRARY MyFunctions TO Fred;
=> REVOKE USAGE ON LIBRARY MyFunctions FROM Fred;
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON MODEL [[database.]schema.]model‑name [,...]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
USAGEALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
model‑name grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Fred 对模型 mySvmClassModel 的 USAGE 权限：
=> REVOKE USAGE ON mySvmClassModel FROM Fred;
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL PRIVILEGES }
ON PROCEDURE [[database.]schema.]procedure( [argument-list] )[,...]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
EXECUTE ALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema 数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
过程 argument-list [argname] argtype
如果过程未定义实参，请提供一个空的实参列表。
grantee指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
此示例将撤销用户 Bob 对 tokenize 过程的执行权限。
=> REVOKE EXECUTE ON PROCEDURE tokenize(varchar) FROM Bob;
Vertica 在运行时检查资源池权限。撤销用户对资源池的权限可立即对用户的当前会话产生影响。例如，用户查询可能需要使用资源池的 USAGE 权限。如果您撤销该用户的这些权限，则该用户随后执行该查询的尝试将失败并返回错误消息。
REVOKE [ GRANT OPTION FOR ] { USAGE | ALL PRIVILEGES }
ON RESOURCE POOL resource-pool[,...]
[FOR SUBCLUSTER subcluster | FOR CURRENT SUBCLUSTER]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
USAGEALL PRIVILEGES可选关键字 PRIVILEGES 符合 SQL 标准。
resource-pool subcluster grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Joe 对资源池 Joe_pool 的 USAGE 权限。
=> REVOKE USAGE ON RESOURCE POOL Joe_pool FROM Joe;
REVOKE PRIVILEGE
撤销用户 Joe 对子群集 sub1 的资源池 Joe_pool 的 USAGE 权限。
=> REVOKE USAGE ON RESOURCE POOL Joe_pool FOR SUBCLUSTER sub1 FROM Joe;
REVOKE PRIVILEGE
REVOKE [ ADMIN OPTION FOR ] role[,...]
FROM grantee[,...]
[ CASCADE ]
ADMIN OPTION FOR指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
以下几项之一：
超级用户
可以选择 (WITH ADMIN OPTION) 将这些权限扩展到其他用户的权限被授予者
此示例显示了如何撤销 dbadmin 用户的 pseudosuperuser 角色：
=> REVOKE pseudosuperuser from dbadmin;
此示例显示了如何撤销 dbadmin 用户对 pseudosuperuser 角色的管理访问权限。ADMIN OPTION 命令不会移除 pseudosuperuser 角色。
=> REVOKE ADMIN OPTION FOR pseudosuperuser FROM dbadmin;
如果尚未将尝试撤销的角色授予用户，Vertica 将返回一则通知：
=> REVOKE commentor FROM Sue;
NOTICE 2022: Role "commentor" was not already granted to user "Sue"
REVOKE ROLE
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON SCHEMA [database.]schema[,...]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
USAGE：访问指定架构中的对象。
CREATE：在指定的架构中创建对象。
您还可以撤销表和视图在创建时从该架构继承的权限。当您撤销在架构级别继承的权限时，Vertica 会自动将撤销应用于继承这些权限的所有表和视图。
SELECT：查询表和视图。默认情况下，会将 SELECT 权限授予 PUBLIC 角色。
INSERT：插入行，或者使用
COPY 将数据加载到表中。
COPY FROM STDIN 允许具有 INSERT 权限的用户使用，而
COPY FROM 文件 需要管理员特权。
UPDATE：更新表行。
DELETE：删除表行。
REFERENCES：在此表上创建外键约束。必须对引用的和被引用的表上都设置此权限。
TRUNCATE：截断表内容。表的非所有者也可以对表执行以下分区操作：
ALTER：使用
ALTER TABLE 和
ALTER VIEW 分别修改表和视图的 DDL。
DROP：删除表和视图。
ALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Joe 对架构 online_sales 的 USAGE 权限。
=> REVOKE USAGE ON SCHEMA online_sales FROM Joe;
REVOKE PRIVILEGE
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON {
SEQUENCE [[database.]schema.]sequence[,...]
| ALL SEQUENCES IN SCHEMA [database.]schema[,...] }
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
privilege ALTER：使用
ALTER SEQUENCE 修改序列的 DDL
DROP：使用
DROP SEQUENCE 删除此序列。
ALL [PRIVILEGES] 支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。
[database.]schema 数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
SEQUENCE sequenceALL SEQUENCES IN SCHEMA schema grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Joe 对序列 my_seq 的权限。
=> REVOKE ALL PRIVILEGES ON SEQUENCE my_seq FROM Joe;
REVOKE PRIVILEGE
撤销用户和角色对用户定义的存储位置的权限。有关详细信息，请参阅创建存储位置。
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON LOCATION 'path' [ ON node ]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
READ：将数据从存储位置中的文件复制到表。
WRITE：将数据从数据库导出到存储位置。被授予者获得 WRITE 特权后，还可以将 COPY 语句被拒绝的数据和异常文件保存到存储位置。
ALL [PRIVILEGES]支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。
ON LOCATION 'path' [ ON node ] ON NODE 进行限定，Vertica 将撤销对节点上的存储位置的访问权限。
如果未指定节点，撤销操作将适用于指定路径上的所有节点。所有节点必须位于指定路径上；否则，整个撤销操作将回退。
指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
请参阅GRANT（存储位置）。
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON {
[ TABLE ] [[database.]schema.]table[,...]
| ALL TABLES IN SCHEMA [database.]schema[,...] }
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
privilege ALL [PRIVILEGES] 支持使用可选关键字 PRIVILEGES 以符合 SQL 标准。
[database.]schemapublic。如果 schema 是除 public 以外的任何其他架构，则必须提供架构名称。例如：
myschema.thisDbObject
这里有一个例外：您可以指定系统表但不指定其架构名称。
如果指定一个数据库，它必须是当前数据库。
TABLE tableON ALL TABLES IN SCHEMA schema grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
所有权
对象的 GRANT OPTION 权限
撤销用户 Joe 对表 customer_dimension 的权限。
=> REVOKE ALL PRIVILEGES ON TABLE customer_dimension FROM Joe;
REVOKE PRIVILEGE
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL PRIVILEGES }
ON {
UDx‑type [[database.]schema.]function‑name( [argument‑list] )[,...]
| ALL FUNCTIONS IN SCHEMA schema[,...] }
FROM grantee[,...]
GRANT OPTION FOR撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
EXECUTE ALL [PRIVILEGES]可选关键字 PRIVILEGES 符合 SQL 标准。
ON UDx‑typeFUNCTION
AGGREGATE FUNCTION
ANALYTIC FUNCTION
TRANSFORM FUNCTION
FILTER
PARSER
SOURCE
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
ON ALL FUNCTIONS IN SCHEMA schema[argname] argtype
如果过程未定义实参，请提供一个空的实参列表。
指定其权限被撤销的用户，可以为以下用户之一：
CASCADEI如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
非超级用户，为以下之一：
目标函数的所有者
可以选择 (WITH GRANT OPTION) 将这些权限扩展到其他用户的权限被授予者
撤销用户 Bob 对函数 myzeroifnull 的 EXECUTE 权限：
=> REVOKE EXECUTE ON FUNCTION myzeroifnull (x INT) FROM Bob;
撤销用户 Doug 对函数 Pagerank 的所有权限：
=> REVOKE ALL ON TRANSFORM FUNCTION Pagerank (t float) FROM Doug;
撤销用户 Bob 对 zero-schema 架构中所有函数的 EXECUTE 权限：
=> REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA zero-schema FROM Bob;
撤销用户 Bob 对 tokenize 函数的 EXECUTE 权限：
=> REVOKE EXECUTE ON TRANSFORM FUNCTION tokenize(VARCHAR) FROM Bob;
撤销用户 Alice 对 ExampleSource() 源的所有权限：
=> REVOKE ALL ON SOURCE ExampleSource() FROM Alice;
REVOKE [ GRANT OPTION FOR ] { privilege[,...] | ALL [ PRIVILEGES ] }
ON [[database.]schema.]view[,...]
FROM grantee[,...]
[ CASCADE ]
GRANT OPTION FOR 撤销指定权限的授予选项。被授予者的当前权限不受影响。如果省略此子句，Vertica 将同时撤销授予选项和当前权限。
privilege SELECT：查询指定视图。
ALTER：使用 修改视图的 DDL
ALTER VIEW
DROP：使用
DROP VIEW 删除此视图。
ALL PRIVILEGES可选关键字 PRIVILEGES 符合 SQL 标准。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
视图 grantee 指定其权限被撤销的用户，可以为以下用户之一：
CASCADE I如果目标被授予者具有将指定权限扩展到其他用户的授予选项，则 CASCADE 会指定搜索这些用户并同时撤销他们的权限。
撤销用户 Joe 对视图 test_view 的 SELECT 权限。
=> REVOKE SELECT ON test_view FROM Joe;
REVOKE PRIVILEGE
结束当前事务，并丢弃在事务期间发生的所有更改。
ROLLBACK [ WORK | TRANSACTION ]
WORK | TRANSACTION 无
回退某项操作时，也会回退该操作获取的任何锁。
ABORT 是 ROLLBACK 的同义词。
此示例显示了如何从某项 DELETE 事务执行回退。
=> SELECT * FROM sample_table;
a
---
1
(1 row)
=> DELETE FROM sample_table WHERE a = 1;
=> SELECT * FROM sample_table;
a
---
(0 rows)
=> ROLLBACK;
=> SELECT * FROM sample_table;
a
---
1
(1 row)
此示例显示了如何回退自 BEGIN 语句以来所做的更改。
=> BEGIN TRANSACTION ISOLATION LEVEL READ COMMITTED READ ONLY;
BEGIN
=> ROLLBACK TRANSACTION;
ROLLBACK
回退自建立给定的保存点以来已在事务中输入的所有命令。
ROLLBACK TO [SAVEPOINT] savepoint_name
savepoint_name无
保存点将保持有效状态，如果将来需要，可以再次回退到该保存点。
回退某项操作时，也会回退该操作获取的任何锁。
ROLLBACK TO SAVEPOINT 隐式销毁在命名保存点之后建立的所有保存点。
以下示例回退了在建立保存点 my_savepoint 之后输入的值 102 和 103。在提交时仅插入了值 101 和 104。
=> INSERT INTO product_key VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (102);
=> INSERT INTO product_key VALUES (103);
=> ROLLBACK TO SAVEPOINT my_savepoint;
=> INSERT INTO product_key VALUES (104);
=> COMMIT;
保存输入查询以便与自定义定向查询相关联。
SAVE QUERY input-query
:v。SAVE QUERY 保存指定输入查询以供 CREATE DIRECTED QUERY CUSTOM 的下一个调用使用。CREATE DIRECTED QUERY CUSTOM 将已保存的查询与其带注释的查询实参匹配，以创建定向查询。两种语句必须在同一用户会话中发起。
已保存的查询保持可用，直至发生以下事件之一：
CREATE DIRECTED QUERY 的下一个调用，无论是通过 CUSTOM 还是 OPTIMIZER 调用。
SAVE QUERY 的另一个调用。
会话结束。
请参阅自定义定向查询。
在事务内创建称之为保存点的特殊标记。创建保存点后，它允许回退所有已执行的命令，将事务还原到创建保存点时其所在的状态。
SAVEPOINT savepoint_name
savepoint_name无
保存点是事务的局部保存点，只能在事务块内时才可创建。
可在事务内定义多个保存点。
如果具有相同名称的保存点已存在，则其会被新保存点替换。
以下示例显示了保存点如何确定事务内可回退的值。创建保存点“my_savepoint”后输入的值 102 和 103 已回退。在提交时仅插入了值 101 和 104。
=> INSERT INTO T1 (product_key) VALUES (101);
=> SAVEPOINT my_savepoint;
=> INSERT INTO T1 (product_key) VALUES (102);
=> INSERT INTO T1 (product_key) VALUES (103);
=> ROLLBACK TO SAVEPOINT my_savepoint;
=> INSERT INTO T1 (product_key) VALUES (104);
=> COMMIT;
=> SELECT product_key FROM T1;
.
.
.
101
104
(2 rows)
从一个或多个数据源返回结果集：表、视图、联接表和已命名查询。
[ AT epoch ] [ WITH-clause ] SELECT [ ALL | DISTINCT ]
{ * | { MATCH_COLUMNS('pattern') | expression [ [AS] alias ] }[,...] }
[ into-table-clause ]
[ from-clause ]
[ where-clause ]
[ time-series-clause ]
[ group-by-clause[,...] ]
[ having-clause[,...] ]
[ match-clause ]
[ union-clause ]
[ intersect-clause ]
[ except-clause ]
[ order-by-clause [ offset-clause ]]
[ limit-clause ]
[ FOR UPDATE [ OF table-name[,...] ] ]
SELECT 语句还可以嵌入各种指令或*提示*，可用于控制给定查询的处理方式，例如，联接提示（如强制执行联接类型（合并或哈希联接）的 JTYPE）。
有关使用 Vertica 提示的详细信息，请参阅提示。
AT epochEPOCH LATEST：返回数据直到当前时期（但不包括当前时期）。结果集包括来自最新提交的 DML 事务的数据。
EPOCH integer：返回数据直到 integer 指定的时期（包括该指定时期）。
TIME 'timestamp'：从 timestamp 指定的时期返回数据。
有关 Vertica 如何使用时期的详细信息，请参阅时期。
有关详细信息，请参阅历史查询。
ALL | DISTINCTALL （默认值）：保留结果集或组中的重复行。
DISTINCT：移除结果集或组中的重复行。
ALL 或 DISTINCT 限定符必须紧跟在 SELECT 关键字后。只能有一个关键字实例出现在选择列表中。*MATCH_COLUMNS('pattern')expression [[AS] alias]您可以选择性地为每个列表达式分配一个临时别名，并在 SELECT 语句的其他位置（例如，在查询谓词或 ORDER BY 子句中）引用该别名。Vertica 使用别名作为查询输出中的列标题。
FOR UPDATEREAD COMMITTED 隔离中使用。
FOR UPDATE 需要对查询的表具有更新/删除权限，且无法从只读事务中发出。
非超级用户：
对架构的 USAGE 权限
对表或视图的 SELECT 权限
作为视图所有者，只有在以下情况之一为真时，您才能授予其他用户对视图的 SELECT 权限：
您拥有视图的基表。
您对视图的基表具有 SELECT...WITH GRANT OPTION 权限。
当多个客户端在以下示例查询中运行事务时，如果未使用 FOR UPDATE，则将发生死锁。两个事务获取 S 锁，当两者尝试升级到 X 锁时，将遇到死锁：
=> SELECT balance FROM accounts WHERE account_id=3476 FOR UPDATE;
...
=> UPDATE accounts SET balance = balance+10 WHERE account_id=3476;
=> COMMIT;
合并两个或多个 SELECT 查询。EXCEPT 返回在右侧查询中未查找到的左侧查询特定结果。
SELECT
EXCEPT except‑query[...]
[ ORDER BY { column-name | ordinal-number } [ ASC | DESC ] [,...] ]
[ LIMIT { integer | ALL } ]
[ OFFSET integer ]
使用 EXCEPT 子句可从 SELECT 语句中筛选出特定结果。EXCEPT 查询对两个或更多 SELECT 查询的结果执行操作。它只返回不同时存在于右侧查询中的左侧查询中的行。
除非用括号另作指示，否则 Vertica 会从左向右评估同一 SELECT 查询中的多个 EXCEPT 子句。
不能将 ALL 关键字与 EXCEPT 查询一起使用。
各 SELECT 语句的结果必须是可合并的。各语句必须返回相同数量的列，且对应列的数据类型必须兼容。例如，不能对 INTEGER 类型的列和 VARCHAR 类型的列使用 EXCEPT 子句。如果语句不满足这些条件，Vertica 将返回错误。
您可以在 FROM、WHERE 和 HAVING 子句中使用 EXCEPT。
您可以通过在语句中加入 ORDER BY 操作的方式对 EXCEPT 操作的结果进行排序。编写 ORDER BY 列表时，请指定最左侧 SELECT 语句中的列名称，或者指定指示排序依据列的位置的整数。
由于最右侧的查询指定 Vertica 对 EXCEPT 操作的结果执行操作，因此 EXCEPT 查询中最右侧的 ORDER BY、LIMIT 或 OFFSET 子句不需要加括号。包含在 SELECT 查询中且之前出现在 EXCEPT 查询中的任何 ORDER BY、LIMIT 或 OFFSET 子句都必须括在圆括号中。
Vertica 支持 EXCEPT 非相关子查询谓词。例如：
=> SELECT * FROM T1
WHERE T1.x IN
(SELECT MAX(c1) FROM T2
EXCEPT
SELECT MAX(cc1) FROM T3
EXCEPT
SELECT MAX(d1) FROM T4);
假设有下面三个表：
Company_A
Id | emp_lname | dept | sales
------+-----------+----------------+-------
1234 | Stephen | auto parts | 1000
5678 | Alice | auto parts | 2500
9012 | Katherine | floral | 500
3214 | Smithson | sporting goods | 1500
(4 rows)
Company_B
Id | emp_lname | dept | sales
------+-----------+-------------+-------
4321 | Marvin | home goods | 250
8765 | Bob | electronics | 20000
9012 | Katherine | home goods | 500
3214 | Smithson | home goods | 1500
(4 rows)
Company_C
Id | emp_lname | dept | sales
------+-----------+----------------+-------
3214 | Smithson | sporting goods | 1500
5432 | Madison | sporting goods | 400
7865 | Cleveland | outdoor | 1500
1234 | Stephen | floral | 1000
(4 rows)
以下查询将返回存在于 Company_A 内但不存在于 Company_B 内的员工的 ID 和姓氏：
=> SELECT id, emp_lname FROM Company_A
EXCEPT
SELECT id, emp_lname FROM Company_B;
id | emp_lname
------+-----------
1234 | Stephen
5678 | Alice
(2 rows)
以下查询将按照员工的姓氏对上一查询的结果进行排序：
=> SELECT id, emp_lname FROM Company_A
EXCEPT
SELECT id, emp_lname FROM Company_B
ORDER BY emp_lname ASC;
id | emp_lname
------+-----------
5678 | Alice
1234 | Stephen
(2 rows)
如果按列位置排序，查询将返回相同结果：
=> SELECT id, emp_lname FROM Company_A
EXCEPT
SELECT id, emp_lname FROM Company_B
ORDER BY 2 ASC;
id | emp_lname
------+-----------
5678 | Alice
1234 | Stephen
(2 rows)
以下查询将返回存在于 Company_A 内但不存在于 Company_B 或 Company_C 内的员工的 ID 和姓氏：
=> SELECT id, emp_lname FROM Company_A
EXCEPT
SELECT id, emp_lname FROM Company_B
EXCEPT
SELECT id, emp_lname FROM Company_C;
id | emp_lname
------+-----------
5678 | Alice
(1 row)
以下查询将显示不匹配数据类型的结果：
=> SELECT id, emp_lname FROM Company_A
EXCEPT
SELECT emp_lname, id FROM Company_B;
ERROR 3429: For 'EXCEPT', types int and varchar are inconsistent
DETAIL: Columns: id and emp_lname
以下示例使用 VMart 示例数据库，将返回通过商店购买商品且购买金额已超过 500 美元的康涅狄格州客户，但不包括现金支付的客户：
=> SELECT customer_key, customer_name FROM public.customer_dimension
WHERE customer_key IN (SELECT customer_key FROM store.store_sales_fact
WHERE sales_dollar_amount > 500
EXCEPT
SELECT customer_key FROM store.store_sales_fact
WHERE tender_type = 'Cash')
AND customer_state = 'CT';
customer_key | customer_name
--------------+----------------------
15084 | Doug V. Lampert
21730 | Juanita F. Peterson
24412 | Mary U. Garnett
25840 | Ben Z. Taylor
29940 | Brian B. Dobisz
32225 | Ruth T. McNulty
33127 | Darlene Y. Rodriguez
40000 | Steve L. Lewis
44383 | Amy G. Jones
46495 | Kevin H. Taylor
(10 rows)
要查询的数据源的逗号分隔列表。
FROM dataset[,...] [ TABLESAMPLE(percent) ]
dataset TABLESAMPLE(percent) 数据的所有行被选中的机会均等。Vertica 在应用其他查询筛选器之前执行采样。
统计 customer_dimension 表中的所有记录：
=> SELECT COUNT(*) FROM customer_dimension;
COUNT
-------
50000
(1 row)
返回表 customer_dimension 中一小部分行的采样：
=> SELECT customer_name, customer_state FROM customer_dimension TABLESAMPLE(0.5) WHERE customer_state='IL';
customer_name | customer_state
---------------------+----------------
Amy Y. McNulty | IL
Daniel C. Nguyen | IL
Midori O. Greenwood | IL
Meghan U. Lampert | IL
Tiffany Y. Lang | IL
Laura S. King | IL
Steve T. Nguyen | IL
Craig S. Webber | IL
Luigi A. Lewis | IL
Mark W. Williams | IL
(10 rows)
[[database.]schema.]table[ [AS] alias]
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
[AS] alias指定如何联接表。
table‑reference [join-type] JOIN table-reference[ TABLESAMPLE(sampling‑pct) ] [ ON join‑predicate ]
INNER （默认值）。 INNER JOIN 等效于在 WHERE 子句中指定其联接谓词的查询。
LEFT [ OUTER ]
RIGHT [ OUTER ]
FULL [ OUTER ]
NATURAL
CROSS
TABLESAMPLETABLESAMPLE 选项仅可用于用户定义的表和数据收集器 (DC) 表。不支持视图和系统表。
开启 join‑predicateNATURAL 和 CROSS 联接无效，对于所有其他联接类型都是必需的。Vertica 支持两种较旧的联接语法约定：
WHERE 子句中的联接谓词指定的表联接
USING 子句指定的表联接
有关详细信息，请参阅联接语法。
下列 SELECT 语句使用 TABLESAMPLE 选项限定其 JOIN 子句：
=> SELECT user_id.id, user_name.name FROM user_name TABLESAMPLE(50)
JOIN user_id TABLESAMPLE(50) ON user_name.id = user_id.id;
id | name
------+--------
489 | Markus
2234 | Cato
763 | Pompey
(3 rows)
在 GROUP BY 中将 SELECT 子句与聚合函数一起使用可以收集多个记录中的数据。Vertica 将结果分组成为一个或多个与表达式匹配的行集。
不包含聚合的 GROUP BY 子句的使用方式类似于 SELECT DISTINCT。
ROLLUP 是对 GROUP BY 子句的扩展。 ROLLUP 执行小计聚合。
GROUP BY [/*+GBYTYPE(algorithm)*/] { expression | aggregate‑expression }[,...]
/*+GBYTYPE(algorithm)*/GROUP BY 子句时优先级高于 Vertica 查询优化器可能选择的算法的算法。可以将 algorithm 设置为以下值之一：
HASH：GROUPBY HASH 算法
PIPE：GROUPBY PIPELINED 算法
有关两种算法的详细信息，请参阅 GROUP BY 实施选项。
column,... column, (expression)
CUBE, GROUPING SETS 或 ROLLUP 聚合按顺序排列的列表。
可以将 CUBE 和 ROLLUP 聚合包括在一个 GROUPING SETS 聚合内。 CUBE 和 ROLLUP 聚合可产生大量输出。在这种情况下，使用 GROUPING SETS 仅返回某些结果。
不能将任何聚合包含在 CUBE 或 ROLLUP 表达式中。
可以将多个 GROUPING SETS、CUBE 或 ROLLUP 聚合附加到同一个查询中。例如：
GROUP BY a,b,c,d, ROLLUP(a,b)
GROUP BY a,b,c,d, CUBE((a,b),c,d)
GROUP BY a,b,c,d, CUBE(a,b), ROLLUP (c,d)
GROUP BY ROLLUP(a), CUBE(b), GROUPING SETS(c)
GROUP BY a,b,c,d, GROUPING SETS ((a,d),(b,c),CUBE(a,b))
GROUP BY a,b,c,d, GROUPING SETS ((a,d),(b,c),(a,b),(a),(b),())
表达式不能包括聚合函数。但是，可以将 GROUP BY 子句与 CUBE、GROUPING SETS 和 ROLLUP 一起使用，以返回每个组的汇总值。
创建 GROUP BY 子句时，必须包括 SELECT 列表中显示的所有非聚合列。
如果 GROUP BY 子句包括 WHERE 子句，Vertica 会忽略所有不满足 WHERE 子句的行。
此示例显示了如何将 WHERE 子句与 GROUP BY 一起使用。在这种情况下，示例检索姓氏以 S 开头的所有员工，忽略所有不符合此条件的行。GROUP BY 子句使用 ILIKE 函数仅检索以 S 开头的姓氏。聚合函数 SUM 计算每个组的总休假天数。
=> SELECT employee_last_name, SUM(vacation_days)
FROM employee_dimension
WHERE employee_last_name ILIKE 'S%'
GROUP BY employee_last_name;
employee_last_name | SUM
--------------------+------
Sanchez | 2892
Smith | 2672
Stein | 2660
(3 rows)
以下示例中的 GROUP BY 子句按供应商地区和供应商地区的最大交易对结果分组：
=> SELECT vendor_region, MAX(deal_size) AS "Biggest Deal"
FROM vendor_dimension
GROUP BY vendor_region;
vendor_region | Biggest Deal
---------------+--------------
East | 990889
MidWest | 699163
NorthWest | 76101
South | 854136
SouthWest | 609807
West | 964005
(6 rows)
以下查询使用 HAVING 子句修改上一个查询，该子句指定仅返回最大交易规模超过 $900,000 的组：
=> SELECT vendor_region, MAX(deal_size) as "Biggest Deal"
FROM vendor_dimension
GROUP BY vendor_region
HAVING MAX(deal_size) > 900000;
vendor_region | Biggest Deal
---------------+--------------
East | 990889
West | 964005
(2 rows)
可以将 GROUP BY 子句与标量类型的一维数组一起使用。在以下示例中，grants 为 ARRAY[VARCHAR]，grant_values 为 ARRAY[INT]。
=> CREATE TABLE employees (id INT, department VARCHAR(50), grants ARRAY[VARCHAR], grant_values ARRAY[INT]);
=> COPY employees FROM STDIN;
42|Physics|[US-7376,DARPA-1567]|[65000,135000]
36|Physics|[US-7376,DARPA-1567]|[10000,25000]
33|Physics|[US-7376]|[30000]
36|Astronomy|[US-7376,DARPA-1567]|[5000,4000]
\.
=> SELECT department, grants, SUM(apply_sum(grant_values)) FROM employees GROUP BY grants, department;
department | grants | SUM
------------+--------------------------+--------
Physics | ["US-7376","DARPA-1567"] | 235000
Astronomy | ["US-7376","DARPA-1567"] | 9000
Physics | ["US-7376"] | 30000
(3 rows)
不包含聚合的 GROUP BY 子句的使用方式类似于 SELECT DISTINCT。例如，以下两个查询返回相同的结果：
=> SELECT DISTINCT household_id FROM customer_dimension;
=> SELECT household_id FROM customer_dimension GROUP BY household_id;
作为 GROUP BY 子句的扩展来自动执行小计聚合。 ROLLUP 在单个 SQL 查询内的不同级别跨多个维度执行聚合。
您可以将 ROLLUP 子句与三个分组函数一起使用：
ROLLUP grouping-expression[,...]
一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：
column1, (column2+1), column3+column4
一个多级表达式，是以下几项之一：
ROLLUP
CUBE
GROUPING SETS
GROUP BY ROLLUP 不会对结果排序。要对数据进行排序，ORDER BY 子句必须跟在 GROUP BY 子句之后。
如果 n 为分组列的数量，则 ROLLUP 将生成 n+1 个小计和总计级别。由于 ROLLUP 将删除每一步中最右侧的列，所以请仔细指定列顺序。
假设 ROLLUP(A, B, C) 创建 4 个组：
(A, B, C)
(A, B)
(A)
()
由于 ROLLUP 将删除每一步中最右侧的列，所以没有 (A, C) 和 (B, C) 组。
如果将 2 个或更多的列括在圆括号内，GROUP BY 会将其视为单一实体。例如：
ROLLUP(A, B, C) 将创建 4 个组：
(A, B, C)
(A, B)
(A)
()
ROLLUP((A, B), C) 会将 (A, B) 视为单一实体并创建 3 个组：
(A, B, C)
(A, B)
()
以下示例显示了如何使用 GROUP BY 子句确定几年内家庭用电和书籍的开支。SUM 聚合函数计算每年在各类别上的总开销。
假设您有一个表，其中包含关于家庭书籍和用电开支的信息：
=> SELECT * FROM expenses ORDER BY Category, Year;
Year | Category | Amount
------+-------------+--------
2005 | Books | 39.98
2007 | Books | 29.99
2008 | Books | 29.99
2005 | Electricity | 109.99
2006 | Electricity | 109.99
2007 | Electricity | 229.98
对于 expenses 表，ROLLUP 计算 2005–2007 年之间各类别的小计：
书籍：$99.96
用电：$449.96
总计：$549.92。
使用 ORDER BY 子句对结果排序：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY ROLLUP(Category, Year) ORDER BY 1,2, GROUPING_ID();
Category | Year | SUM
-------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Books | | 99.96
Electricity | 2005 | 109.99
Electricity | 2006 | 109.99
Electricity | 2007 | 229.98
Electricity | | 449.96
| | 549.92
此示例说明如何将 ROLLUP 与 HAVING 子句一起使用，以限制 GROUP BY 结果。以下查询只生成 ROLLUP 类别，其中 year 根据 GROUPING 函数中的表达式得出小计：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY ROLLUP(Category,Year) HAVING GROUPING(Year)=1
ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
-------------+------+--------
Books | | 99.96
Electricity | | 449.96
| | 549.92
下一个示例对 (Category, Year) 而非完整结果进行汇总。GROUPING_ID 函数指定聚合 3 个以下的级别：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY ROLLUP(Category,Year) HAVING GROUPING_ID(Category,Year)<3
ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
-------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Books | | 99.96
Electricity | 2005 | 109.99
Electricity | 2006 | 109.99
Electricity | 2007 | 229.98
Electricity | | 449.96
作为 GROUP BY 子句的扩展，自动对指定列执行所有可能的聚合。
您可以将 ROLLUP 子句与三个分组函数一起使用：
GROUP BY group-expression[,...]
group-expression 一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：
column1, (column2+1), column3+column4
一个多级表达式，是以下几项之一：
ROLLUP
CUBE
GROUPING SETS
如果 n 是指分组列的数量，则 CUBE 将生成 2n 个聚合级别。例如：
CUBE (A, B, C) 将生成所有可能的分组，即产生以下八个组：
如果增加 CUBE 列数，则 CUBE 分组数会呈指数增加。CUBE 查询可能会占用大量资源，并产生不感兴趣的组合。在这种情况下，请考虑使用 GROUPING SETS 聚合，因为通过它可以选择特定的分组。
假设您有一个表，其中包含关于家庭书籍和用电开支的信息：
=> SELECT * FROM expenses ORDER BY Category, Year;
Year | Category | Amount
------+-------------+--------
2005 | Books | 39.98
2007 | Books | 29.99
2008 | Books | 29.99
2005 | Electricity | 109.99
2006 | Electricity | 109.99
2007 | Electricity | 229.98
使用 CUBE 聚合按类别和年份聚合数据：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY CUBE(Category, Year) ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
-------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Books | | 99.96
Electricity | 2005 | 109.99
Electricity | 2006 | 109.99
Electricity | 2007 | 229.98
Electricity | | 449.96
| 2005 | 149.97
| 2006 | 109.99
| 2007 | 259.97
| 2008 | 29.99
| | 549.92
结果会包含每个类别和年份的小计以及总计 ($549.92)。
此示例显示了如何限制 GROUP BY 结果以及如何将 CUBE 聚合与 HAVING 子句结合使用。此查询仅返回类别合计和总计：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY CUBE(Category,Year) HAVING GROUPING(Year)=1;
Category | Year | SUM
-------------+------+--------
Books | | 99.96
Electricity | | 449.96
| | 549.92
下一个查询仅返回每个年度两种类别的聚合。GROUPING ID 函数指定忽略总计 ($549.92)：
=> SELECT Category, Year, SUM (Amount) FROM expenses
GROUP BY CUBE(Category,Year) HAVING GROUPING_ID(Category,Year)<2
ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Books | | 99.96
Electrical | 2005 | 109.99
Electrical | 2006 | 109.99
Electrical | 2007 | 229.98
Electrical | | 449.96
GROUPING SETS 聚合是对在您指定的分组上自动执行小计聚合的
GROUP BY 子句的扩展。
您可以将 GROUPING SETS 子句与三个分组函数一起使用：
若要对数据排序，请使用
ORDER BY 子句。ORDER BY 子句必须跟在 GROUP BY 子句之后。
GROUP BY group-expression[,...]
group-expression 一个包含常数和 FROM 指定的表中的列引用且不是聚合或分组函数的表达式。例如：
column1, (column2+1), column3+column4
一个多级表达式，是以下几项之一：
ROLLUP
CUBE
GROUPING SETS
GROUPING SETS 允许您准确指定结果中需要哪些组。您还可以按照以下方式联接分组：
以下示例子句的分组结果将会显示。
此示例显示了如何仅选择您需要的分组。假设您仅希望聚合列，并且您不需要总计。第一个查询会忽略合计。在第二个查询中，您将 () 添加到 GROUPING SETS 列表以获得合计。使用 ORDER BY 子句按分组对结果进行排序：
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY GROUPING SETS((Category, Year), (Year))
ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Electrical | 2005 | 109.99
Electrical | 2006 | 109.99
Electrical | 2007 | 229.98
| 2005 | 149.97
| 2006 | 109.99
| 2007 | 259.97
| 2008 | 29.99
=> SELECT Category, Year, SUM(Amount) FROM expenses
GROUP BY GROUPING SETS((Category, Year), (Year), ())
ORDER BY 1, 2, GROUPING_ID();
Category | Year | SUM
------------+------+--------
Books | 2005 | 39.98
Books | 2007 | 29.99
Books | 2008 | 29.99
Electrical | 2005 | 109.99
Electrical | 2006 | 109.99
Electrical | 2007 | 229.98
| 2005 | 149.97
| 2006 | 109.99
| 2007 | 259.97
| 2008 | 29.99
| | 549.92
筛选 GROUP BY 子句的结果。根据语义，HAVING 子句必须发生在 GROUP BY 操作之后。该子句已添加到 SQL 标准，因为 WHERE 子句无法指定聚合函数。
HAVING condition[,...]
以下示例返回薪资大于 $800,000 的员工：
=> SELECT employee_last_name, MAX(annual_salary) as highest_salary FROM employee_dimension
GROUP BY employee_last_name HAVING MAX(annual_salary) > 800000 ORDER BY highest_salary DESC;
employee_last_name | highest_salary
--------------------+----------------
Sanchez | 992363
Vogel | 983634
Vu | 977716
Lewis | 957949
Taylor | 953373
King | 937765
Gauthier | 927335
Garnett | 903104
Bauer | 901181
Jones | 885395
Rodriguez | 861647
Young | 846657
Greenwood | 837543
Overstreet | 831317
Garcia | 811231
(15 rows)
计算两个或更多 SELECT 查询结果的交集。INTERSECT 返回 INTERSECT 操作数左右两侧查询的唯一值。
select‑stmt
INTERSECT query[...]
[ order-by-clause [ offset-clause ]]
[ limit-clause ]
INTERSECT 子句返回 SELECT 查询结果的交集。INTERSECT 查询对两个或更多 SELECT 查询的结果执行操作。INTERSECT 仅返回所有指定查询所得到的行。
不能将 ALL 关键字与 INTERSECT 查询一起使用。
每个 SELECT 查询的结果必须是联集兼容的；必须返回相同数目的列，而且相应的列必须含有兼容的数据类型。例如，不能对 INTERSECT 类型的列和 VARCHAR 类型的列使用 EXCEPT 子句。如果 SELECT 查询不满足这些条件，Vertica 将返回错误。
使用 ORDER BY 子句为 INTERSECT 操作结果进行排序。在 ORDER BY 列表中，指定最左侧 SELECT 语句的列，或指定所按照排序列的所在位置。
您可以在 FROM、WHERE 和 HAVING 子句中使用 INTERSECT。
由于最右侧的查询指定 Vertica 对 INTERSECT 操作的结果执行操作，因此 INTERSECT 查询的 ORDER BY、LIMIT 或者 OFFSET 子句不需要加括号。包含在 SELECT 查询中且之前出现在 INTERSECT 查询中的任何 ORDER BY、LIMIT 或 OFFSET 子句都必须括在圆括号中。
排序列名称来自于第一个 select。
Vertica 支持 INTERSECT 非相关子查询谓词。例如：
=> SELECT * FROM T1
WHERE T1.x IN
(SELECT MAX(c1) FROM T2
INTERSECT
SELECT MAX(cc1) FROM T3
INTERSECT
SELECT MAX(d1) FROM T4);
假设有下面三个表：
Company_A
id emp_lname dept sales
------+------------+----------------+-------
1234 | Stephen | auto parts | 1000
5678 | Alice | auto parts | 2500
9012 | Katherine | floral | 500
3214 | Smithson | sporting goods | 1500
Company_B
id emp_lname dept sales
------+------------+-------------+-------
4321 | Marvin | home goods | 250
9012 | Katherine | home goods | 500
8765 | Bob | electronics | 20000
3214 | Smithson | home goods | 1500
Company_C
id | emp_lname | dept | sales
------+-----------+----------------+-------
3214 | Smithson | sporting goods | 1500
5432 | Madison | sporting goods | 400
7865 | Cleveland | outdoor | 1500
1234 | Stephen | floral | 1000
以下查询返回 Company_A 和 Company_B 中都包含的 ID 号以及员工姓氏：
=> SELECT id, emp_lname FROM Company_A
INTERSECT
SELECT id, emp_lname FROM Company_B;
id | emp_lname
------+-----------
3214 | Smithson
9012 | Katherine
(2 rows)
接下来的查询返回相同的两个员工，销售额降序排列：
=> SELECT id, emp_lname, sales FROM Company_A
INTERSECT
SELECT id, emp_lname, sales FROM Company_B
ORDER BY sales DESC;
id | emp_lname | sales
------+-----------+-------
3214 | Smithson | 1500
9012 | Katherine | 500
(2 rows)
接下来的查询返回同时为两个公司工作而在 Company_B 公司中的销售额超过 1000 的员工姓名：
=> SELECT id, emp_lname, sales FROM Company_A
INTERSECT
(SELECT id, emp_lname, sales FROM company_B WHERE sales > 1000)
ORDER BY sales DESC;
id | emp_lname | sales
------+-----------+-------
3214 | Smithson | 1500
(1 row)
接下来的查询返回同时为三个公司工作的员工 ID 号以及员工姓氏。
=> SELECT id, emp_lname FROM Company_A
INTERSECT
SELECT id, emp_lname FROM Company_B
INTERSECT
SELECT id, emp_lname FROM Company_C;
id | emp_lname
------+-----------
3214 | Smithson
(1 row)
接下来的查询返回的是不匹配的数据类型结果；这两个查询不是联集兼容的：
=> SELECT id, emp_lname FROM Company_A
INTERSECT
SELECT emp_lname, id FROM Company_B;
ERROR 3429: For 'INTERSECT', types int and varchar are inconsistent
DETAIL: Columns: id and emp_lname
使用 VMart 示例数据库，接下来的查询返回有关通过在线销售渠道购买商品且购买金额超过 400 美元和 500 美金的所有康涅狄格州客户的信息：
=> SELECT customer_key, customer_name from public.customer_dimension
WHERE customer_key IN (SELECT customer_key
FROM online_sales.online_sales_fact
WHERE sales_dollar_amount > 400
INTERSECT
SELECT customer_key FROM online_sales.online_sales_fact
WHERE sales_dollar_amount > 500)
AND customer_state = 'CT' ORDER BY customer_key;
customer_key | customer_name
--------------+------------------------
39 | Sarah S. Winkler
44 | Meghan H. Overstreet
70 | Jack X. Cleveland
103 | Alexandra I. Vu
110 | Matt . Farmer
173 | Mary R. Reyes
188 | Steve G. Williams
233 | Theodore V. McNulty
250 | Marcus E. Williams
294 | Samantha V. Young
313 | Meghan P. Pavlov
375 | Sally N. Vu
384 | Emily R. Smith
387 | Emily L. Garcia
...
上一个查询和下一个查询是等效的，并且返回相同的结果：
=> SELECT customer_key,customer_name FROM public.customer_dimension
WHERE customer_key IN (SELECT customer_key
FROM online_sales.online_sales_fact
WHERE sales_dollar_amount > 400
AND sales_dollar_amount < 500)
AND customer_state = 'CT' ORDER BY customer_key;
从查询结果集中创建表。
永久表：
INTO [TABLE] [[database.]schema.]table
临时表：
INTO [scope] TEMP[ORARY] [TABLE] [[database.]schema.]table
[ ON COMMIT { DELETE | PRESERVE } ROWS ]
GLOBAL （默认值）：表定义对所有会话可见，并且持续存在，直到显式删除了该表。
LOCAL：表定义仅对在其中创建该表定义的会话可见，并在会话结束后删除。
不论此设置如何，都可通过 ON COMMIT DELETE ROWS 和 ON COMMIT PRESERVE ROWS 关键字（见下文）设置临时表数据保留策略。
有关详细信息，请参阅创建临时表。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
ON COMMIT { DELETE | PRESERVE } ROWSDELETE （默认）会将临时表标记为事务范围数据。每次提交之后，Vertica 会移除所有表数据。
PRESERVE 会将临时表标记为会话范围数据，这些数据在单个事务结束后仍会保存。但会话结束后，Vertica 会移除所有表数据。
以下 SELECT 语句包含一个 INTO TABLE 子句，该子句使用 customer_dimension 创建表 newTable：
=> SELECT * INTO TABLE newTable FROM customer_dimension;
以下 SELECT 语句将创建临时表 newTempTable。默认情况下，临时表是在全局范围创建的，因此该表定义对其他会话可见并一直存在，直到其被显式删除。不会将 customer_dimension 数据复制到新表中，且 Vertica 会发出相应的警告：
=> SELECT * INTO TEMP TABLE newTempTable FROM customer_dimension;
WARNING 4102: No rows are inserted into table "public"."newTempTable" because
ON COMMIT DELETE ROWS is the default for create temporary table
HINT: Use "ON COMMIT PRESERVE ROWS" to preserve the data in temporary table
CREATE TABLE
以下 SELECT 语句将创建本地临时表 newTempTableLocal。表仅对在其中创建该表的会话可见，并在会话结束后自动删除。INTO TABLE 子句包括 ON COMMIT PRESERVE ROWS，因此 Vertica 会将所有选择数据复制到新表中：
=> SELECT * INTO LOCAL TEMP TABLE newTempTableLocal ON COMMIT PRESERVE ROWS
FROM customer_dimension;
CREATE TABLE
指定要从整个结果集或从分区结果集的窗口返回的结果集行数最大值。
应用于整个结果集：
LIMIT { num-rows | ALL }
应用于分区结果集的窗口：
LIMIT num‑rows OVER ( PARTITION BY {{< codevar >}}column‑expr‑x{{< /codevar >}}, ORDER BY {{< codevar >}}column‑expr‑y{{< /codevar >}} [ASC | DESC]
ALLOVER()有关详细信息，请参阅下面的将 LIMIT 与窗口分区结合使用。
LIMIT 指定只返回已查询数据集中的前 k 行。行优先级通过查询的 ORDER BY 子句确定。
以下依赖项适用于：
始终将 ORDER BY 子句与 LIMIT 一起使用。否则，查询将返回结果集的一个不确定子集。ORDER BY 子句必须在 LIMIT 之前。
当 SELECT 语句同时指定 LIMIT 和 OFFSET 时，Vertica 首先处理 OFFSET，然后将 LIMIT 应用于其余行。
例如，以下查询将返回表 customer_dimension 中的前 10 行数据，按列 store_region 和 number_of_employees 的顺序排列：
=> SELECT store_region, store_city||', '||store_state location, store_name, number_of_employees
FROM store.store_dimension WHERE number_of_employees <= 12 ORDER BY store_region, number_of_employees LIMIT 10;
store_region | location | store_name | number_of_employees
--------------+----------------+------------+---------------------
East | Stamford, CT | Store219 | 12
East | New Haven, CT | Store66 | 12
East | New York, NY | Store122 | 12
MidWest | South Bend, IN | Store134 | 10
MidWest | Evansville, IN | Store30 | 11
MidWest | Green Bay, WI | Store27 | 12
South | Mesquite, TX | Store124 | 10
South | Cape Coral, FL | Store18 | 11
South | Beaumont, TX | Store226 | 11
South | Houston, TX | Store33 | 11
(10 rows)
您可以使用 LIMIT 对查询结果应用窗口分区，并限制每个窗口中返回的行数：
SELECT ... FROM dataset LIMIT num‑rows OVER ( PARTITION BY column‑expr‑x, ORDER BY column‑expr‑y [ASC | DESC] )
其中查询 dataset 在每个 column‑expr‑x 分区中返回具有最高或最低 column‑expr‑y 值的 num‑rows 个行。
例如，以下语句对表 store.store_dimension 进行了查询并在结果集上指定了窗口分区。LIMIT 设置为 2，所以每个窗口分区最多只能显示两行。OVER 子句指定按 store_region 对结果集进行分区，其中每个分区窗口显示某个区域中员工人数最少的两个商店：
=> SELECT store_region, store_city||', '||store_state location, store_name, number_of_employees FROM store.store_dimension
LIMIT 2 OVER (PARTITION BY store_region ORDER BY number_of_employees ASC);
store_region | location | store_name | number_of_employees
--------------+---------------------+------------+---------------------
West | Norwalk, CA | Store43 | 10
West | Lancaster, CA | Store95 | 11
East | Stamford, CT | Store219 | 12
East | New York, NY | Store122 | 12
SouthWest | North Las Vegas, NV | Store170 | 10
SouthWest | Phoenix, AZ | Store228 | 11
NorthWest | Bellevue, WA | Store200 | 19
NorthWest | Portland, OR | Store39 | 22
MidWest | South Bend, IN | Store134 | 10
MidWest | Evansville, IN | Store30 | 11
South | Mesquite, TX | Store124 | 10
South | Beaumont, TX | Store226 | 11
(12 rows)
允许您以搜索事件模式筛选大量历史数据的 SQL 扩展， MATCH 子句为解析分区、排序提供子类，并基于您定义的模式匹配结果表的行。
您指定一个由 DEFINE 子句中定义的事件类型组成的模式作为正则表达式，其中每个事件都与输入表中的一行对应。接下来，您可以在输入事件序列内搜索模式。模式匹配返回符合 PATTERN 子句的连续行序列。例如，模式 P (A B* C) 由三个事件类型组成：A、B 和 C，当 Vertica 在输入表中找到匹配时，相关模式实例必须是一个 A 类型事件，且后接零个或多个 B 类型事件和一个 C 类型事件。
如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。有关详细信息，请参阅事件系列模式匹配。
MATCH ( [ PARTITION BY table‑column ] ORDER BY table‑column
DEFINE event‑name AS boolean‑expr [,...]
PATTERN pattern‑name AS ( regexp )
[ rows‑match‑clause ] )
PARTITION BYORDER BYDEFINEDEFINE
Entry AS RefURL NOT ILIKE '%website2.com%' AND PageURL ILIKE
'%website2.com%',
Onsite AS PageURL ILIKE '%website2.com%' AND Action='V',
Purchase AS PageURL ILIKE '%website2.com%' AND Action='P'
DEFINE 子句最多可接受 52 个事件。有关示例，请参阅 事件系列模式匹配。
Entry, Onsite, Purchase。
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN pattern‑name PATTERN P AS (...)
PATTERN 是由名称和正则表达式组成的搜索模式。
DEFINE 子句中定义的事件类型和下面的一个或多个限定符组成。当 Vertica 评估 MATCH 子句时，正则表达式会识别满足表达式条件的行。
ROWS MATCH ALL EVENTS：如果单一行中的多个事件评估为真，Vertica 将返回以下错误：
ERROR: pattern events must be mutually exclusive
HINT: try using ROWS MATCH FIRST EVENT
ROWS MATCH FIRST EVENT：如果给定行中的多个事件评估为真，Vertica 将使用该行的 SQL 语句中的第一个事件。
SQL 子句的语意评估顺序是：FROM -> WHERE -> PATTERN MATCH -> SELECT。
数据根据 PARTITION BY 子句的规定分区。如果忽略分区子句，则将整个数据集视为单个分区。
对于每个分区，顺序子句指定如何针对模式匹配对输入数据排序。
对每一行的事件进行评估。一行可以具有 0、1 或 N 个事件评估为真。如果同一行中评估为真的事件超过一个，除非您指定 ROWS MATCH FIRST EVENT，否则 Vertica 将返回一个运行时错误。如果指定了 ROWS MATCH FIRST EVENT，且单一行中评估为真的事件多于一个，Vertica 将选择 SQL 语句中第一个定义的事件用于行。
Vertica 通过查找符合 PATTERN 子句中定义模式的连续行序列执行模式匹配。
对于每一个匹配，Vertica 将输出匹配行。并非匹配一部分的行（不满足一个或多个术语）不输出。
Vertica 仅报告非重叠匹配。如果发生重叠，Vertica 将选择输入流中发现的第一个匹配。查找到匹配后，Vertica 会在前一次匹配结束后，开始搜索下一个匹配。
Vertica 将报告最长可能匹配，而不是匹配的子集。例如，考虑模式：AB（包含输入）：AAAB。因为 A 使用贪婪正则表达式量词 ()，所以 Vertica 会报告所有 A 的输入 (AAAB)，而不是 AAB、AB 或 B。
模式匹配查询中不允许使用 DISTINCT 和 GROUP BY/HAVING 子句。
下面的表达式不可用于 DEFINE 子句：
子查询，如 DEFINE X AS c IN ELECT c FROM table
分析函数，如 DEFINE X AS c <EA1) OVER (ORDER BY 1)
聚合函数，如 DEFINE X AS c <A1)
不可使用相同的模式名称定义不同的事件，例如，X 不允许执行下文：
DEFINE X AS c1 < 3
X AS c1 >= 3
与 MATCH 子句一起使用，Vertica MATCH 子句函数 提供关于模式的额外数据。例如，您可是使用函数返回表示与输入行相匹配的事件名称、匹配的序列号或匹配模式实例的分区范围内唯一标识符。
例如，请参阅事件系列模式匹配。
搜索事件模式时，您可以使用 SQL MATCH 子句 语法来筛选大量历史数据。您可以将模式指定为正则表达式，然后可以在输入事件序列内搜索该模式。MATCH 提供了分析数据分区和排序的子句，以及对连续行集执行的模式匹配。
如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。典型的在线点击流漏斗是：
公司主页 -> 产品主页 -> 搜索 -> 结果 -> 在线购买
您可以使用此单击流漏斗，在用户的 Web 点击序列中搜索匹配并标识该用户：
登录公司主页
导航至产品页面
运行查询
单击搜索结果中的链接
购买
此主题中的示例使用了此点击流漏斗以及以下 clickstream_log 表架构：
=> CREATE TABLE clickstream_log (
uid INT, --user ID
sid INT, --browsing session ID, produced by previous sessionization computation
ts TIME, --timestamp that occurred during the user's page visit
refURL VARCHAR(20), --URL of the page referencing PageURL
pageURL VARCHAR(20), --URL of the page being visited
action CHAR(1) --action the user took after visiting the page ('P' = Purchase, 'V' = View)
);
INSERT INTO clickstream_log VALUES (1,100,'12:00','website1.com','website2.com/home', 'V');
INSERT INTO clickstream_log VALUES (1,100,'12:01','website2.com/home','website2.com/floby', 'V');
INSERT INTO clickstream_log VALUES (1,100,'12:02','website2.com/floby','website2.com/shamwow', 'V');
INSERT INTO clickstream_log values (1,100,'12:03','website2.com/shamwow','website2.com/buy', 'P');
INSERT INTO clickstream_log values (2,100,'12:10','website1.com','website2.com/home', 'V');
INSERT INTO clickstream_log values (2,100,'12:11','website2.com/home','website2.com/forks', 'V');
INSERT INTO clickstream_log values (2,100,'12:13','website2.com/forks','website2.com/buy', 'P');
COMMIT;
以下为 clickstream_log 表的输出：
=> SELECT * FROM clickstream_log;
uid | sid | ts | refURL | pageURL | action
-----+-----+----------+----------------------+----------------------+--------
1 | 100 | 12:00:00 | website1.com | website2.com/home | V
1 | 100 | 12:01:00 | website2.com/home | website2.com/floby | V
1 | 100 | 12:02:00 | website2.com/floby | website2.com/shamwow | V
1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy | P
2 | 100 | 12:10:00 | website1.com | website2.com/home | V
2 | 100 | 12:11:00 | website2.com/home | website2.com/forks | V
2 | 100 | 12:13:00 | website2.com/forks | website2.com/buy | P
(7 rows)
此示例包括 Vertica MATCH 子句函数，以便分析用户在 website2.com 上的浏览历史记录。它会确定用户执行以下任务的模式：
从其他网站登录 website2.com（进入）
浏览任意数量的其他页面（站内）
做出购买（购买）
在以下语句中，模式 P (Entry Onsite* Purchase) 包括三种事件类型：进入、站内和购买。当 Vertica 在输入表中找到匹配时，相关模式实例必须是一个进入事件类型，且后跟零个或多个站内事件类型以及一个购买事件类型
=> SELECT uid,
sid,
ts,
refurl,
pageurl,
action,
event_name(),
pattern_id(),
match_id()
FROM clickstream_log
MATCH
(PARTITION BY uid, sid ORDER BY ts
DEFINE
Entry AS RefURL NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
Onsite AS PageURL ILIKE '%website2.com%' AND Action='V',
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN
P AS (Entry Onsite* Purchase)
ROWS MATCH FIRST EVENT);
在以下输出中，前四行代表用户 1 的浏览活动的模式，而剩下三行显示了用户 2 的浏览习惯。
uid | sid | ts | refurl | pageurl | action | event_name | pattern_id | match_id
-----+-----+----------+----------------------+----------------------+--------+------------+------------+----------
1 | 100 | 12:00:00 | website1.com | website2.com/home | V | Entry | 1 | 1
1 | 100 | 12:01:00 | website2.com/home | website2.com/floby | V | Onsite | 1 | 2
1 | 100 | 12:02:00 | website2.com/floby | website2.com/shamwow | V | Onsite | 1 | 3
1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy | P | Purchase | 1 | 4
2 | 100 | 12:10:00 | website1.com | website2.com/home | V | Entry | 1 | 1
2 | 100 | 12:11:00 | website2.com/home | website2.com/forks | V | Onsite | 1 | 2
2 | 100 | 12:13:00 | website2.com/forks | website2.com/buy | P | Purchase | 1 | 3
(7 rows)
MINUS 是 EXCEPT 的别名。
从结果集的开头忽略指定的行数。
OFFSET rows
将 ORDER BY 子句与 OFFSET 一起使用。否则，查询将返回结果集的一个不确定子集。
在 SELECT 语句或 UNION 子句中，OFFSET 必须跟在 ORDER BY 子句之后。
当 SELECT 语句或 UNION 子句同时指定 LIMIT 和 OFFSET 时，Vertica 首先处理 OFFSET 语句，然后将 LIMIT 语句应用于其余行。
以下查询从 customer_dimension 表中返回 14 行：
=> SELECT customer_name, customer_gender FROM customer_dimension
WHERE occupation='Dancer' AND customer_city = 'San Francisco' ORDER BY customer_name;
customer_name | customer_gender
----------------------+-----------------
Amy X. Lang | Female
Anna H. Li | Female
Brian O. Weaver | Male
Craig O. Pavlov | Male
Doug Z. Goldberg | Male
Harold S. Jones | Male
Jack E. Perkins | Male
Joseph W. Overstreet | Male
Kevin . Campbell | Male
Raja Y. Wilson | Male
Samantha O. Brown | Female
Steve H. Gauthier | Male
William . Nielson | Male
William Z. Roy | Male
(14 rows)
如果修改上一个查询以指定偏移量 8 (OFFSET 8)，Vertica 将跳过上一个结果集的前八行。查询会返回以下结果：
=> SELECT customer_name, customer_gender FROM customer_dimension
WHERE occupation='Dancer' AND customer_city = 'San Francisco' ORDER BY customer_name OFFSET 8;
customer_name | customer_gender
-------------------+-----------------
Kevin . Campbell | Male
Raja Y. Wilson | Male
Samantha O. Brown | Female
Steve H. Gauthier | Male
William . Nielson | Male
William Z. Roy | Male
(6 rows)
对一个或多个列或列表达式的查询结果集进行排序。Vertica 使用当前区域设置和排序规则来对字符串值进行比较和排序。
ORDER BY expression [ ASC | DESC ] [,...]
SELECT 列表项的名称或序号。序号是指从左边开始计数的结果列的位置。这些序号用于对名称不唯一的列进行排序。序号对于分析函数的 OVER 子句的 ORDER BY 子句无效。
未出现在 SELECT 列表中的列的任意表达式。
CASE 表达式。
INTEGER、INT、DATE/TIME：NULL 具有最小值。
FLOAT、BOOLEAN、CHAR、VARCHAR、ARRAY、SET：NULL 具有最大值
下面的例子返回根据交易规模降序排列的客户媒体的全部城市和交易规模。
=> SELECT customer_city, deal_siz FROM customer_dimension WHERE customer_name = 'Metamedia'
ORDER BY deal_size DESC;
customer_city | deal_size
------------------+-----------
El Monte | 4479561
Athens | 3815416
Ventura | 3792937
Peoria | 3227765
Arvada | 2671849
Coral Springs | 2643674
Fontana | 2374465
Rancho Cucamonga | 2214002
Wichita Falls | 2117962
Beaumont | 1898295
Arvada | 1321897
Waco | 1026854
Joliet | 945404
Hartford | 445795
(14 rows)
以下示例使用转换函数。该示例返回了错误，因为 ORDER BY 列不在窗口分区中。
=> CREATE TABLE t(geom geometry(200), geog geography(200));
=> SELECT PolygonPoint(geom) OVER(PARTITION BY geom)
AS SEL_0 FROM t ORDER BY geog;
ERROR 2521: Cannot specify anything other than user defined transforms and partitioning expressions in the ORDER BY list
以下示例使用同一个表更正了此错误。
=> SELECT PolygonPoint(geom) OVER(PARTITION BY geom)
AS SEL_0 FROM t ORDER BY geom;
以下示例使用 ORDER BY 子句中的一个数组。
=> CREATE TABLE employees (id INT, department VARCHAR(50), grants ARRAY[VARCHAR], grant_values ARRAY[INT]);
=> COPY employees FROM STDIN;
42|Physics|[US-7376,DARPA-1567]|[65000,135000]
36|Physics|[US-7376,DARPA-1567]|[10000,25000]
33|Physics|[US-7376]|[30000]
36|Astronomy|[US-7376,DARPA-1567]|[5000,4000]
\.
=> SELECT * FROM employees ORDER BY grant_values;
id | department | grants | grant_values
----+------------+--------------------------+----------------
36 | Astronomy | ["US-7376","DARPA-1567"] | [5000,4000]
36 | Physics | ["US-7376","DARPA-1567"] | [10000,25000]
33 | Physics | ["US-7376"] | [30000]
42 | Physics | ["US-7376","DARPA-1567"] | [65000,135000]
(4 rows)
空白填充和插值 (GFI) 计算，这是时序分析计算的一个重要组件。有关详细信息和示例，请参阅时序分析。
TIMESERIES slice‑time AS 'length‑and‑time‑unit‑expr' OVER (
[ PARTITION BY (column‑expr[,...] ] ORDER BY time‑expr ) [ ORDER BY table‑column[,...] ]
TIMESERIES 子句产生的时间列，用于存储空白填充生成的时间片开始时间。
注意：此参数为别名，因此，您可以使用任何名称作为别名。
INTERVAL DAY TO SECOND 字面量，用于指定时间片计算的时间单位长度。例如：
TIMESERIES slice_time AS '3 seconds' ...
OVER()OVER() 还指定时序函数在查询结果集上的操作—换而言之，评估 FROM、WHERE、GROUP BY 和 HAVING 子句之后返回的行。PARTITION BY (column‑expr[,...] )ORDER BY time‑exprTIMESTAMP表达式 time-expr 对数据排序，以计算时序数据的时间信息。
TIMESERIES 子句要求在时间戳列上进行 ORDER BY 操作。
如果在 TIMESERIES OVER() 内没有为每个定义的时间片指定 window-partition-clause，则只产生一个输出记录；否则，则按每个时间片的每个分区产生一个输出记录。插值在该处计算。
如提供包含 TIMESERIES 子句的查询块，则以下是语义执行阶段（评估 FROM 和可选 WHERE 子句之后）：
计算 time-expression。
根据 time‑exp 和 'length‑and‑time‑unit‑expr' 的结果在每个输入记录上执行与 TIME_SLICE() 函数一样的计算。
执行空白填充以生成输入记录中缺失的时间片。
将此计算结果命名为 slice_time，表示空白填充之后生成的“时序”列（别名）。
按 expression、slice‑time 对数据分区。针对每个分区执行步骤 4。
按 time‑expr 对数据排序。插值在此处计算。
TIMESERIES 子句和 TIME_SLICE 函数之间存在语义重叠，主要区别如下：
TIMESERIES 仅支持间隔限定符DAY TO SECOND；不允许 YEAR TO MONTH。
与 TIME_SLICE 不同，length‑and‑time‑unit‑expr 中表示的时间片长度和时间单位必须为常量，以便很好地界定时间片间隙。
TIMESERIES 执行空白填充，而 TIME_SLICE 函数则不执行。
TIME_SLICE 可以根据其第四个输入参数 (start‑or‑end) 的值来返回时间片的开始和结束时间。TIMESERIES，另一方面，始终返回每个时间片的开始时间。要输出每个时间片的结束时间，请写入 SELECT 语句，如下所示：
=> SELECT slice_time + <slice_length>;
在 SQL 查询块中发生 TIMESERIES 子句时，仅以下子句可用于相同查询块中：
SELECT
FROM
WHERE
ORDER BY
不允许使用“GROUP BY”和“HAVING”子句。如果在间隙填充和插值 (GFI) 之前或之后需要执行“GROUP BY”操作，请使用子查询，并且将“GROUP BY”放入外部查询。例如： => SELECT symbol, AVG(first_bid) as avg_bid FROM ( SELECT symbol, slice_time, TS_FIRST_VALUE(bid1) AS first_bid FROM Tickstore WHERE symbol IN ('MSFT', 'IBM') TIMESERIES slice_time AS '5 seconds' OVER (PARTITION BY symbol ORDER BY ts) ) AS resultOfGFI GROUP BY symbol;
TIMESERIES 子句出现在 SQL 查询块时，SELECT 列表仅可包含以下：
时序聚合函数，例如
TS_FIRST_VALUE 和
TS_LAST_VALUE
slice_time 列
PARTITION BY 表达式
TIME_SLICE function
例如，以下两个查询返回语法错误，因为 bid1 不是 PARTITION BY 或 GROUP BY 列：
=> SELECT bid, symbol, TS_FIRST_VALUE(bid) FROM Tickstore
TIMESERIES slice_time AS '5 seconds' OVER (PARTITION BY symbol ORDER BY ts);
ERROR: column "Tickstore.bid" must appear in the PARTITION BY list of Timeseries clause or be used in a Timeseries Output function
=> SELECT bid, symbol, AVG(bid) FROM Tickstore
GROUP BY symbol;
ERROR: column "Tickstore.bid" must appear in the GROUP BY clause or be used in an aggregate function
例如，请参阅空白填充和插值 (GFI)。
合并多个 SELECT 语句的结果。您也可以在 FROM、WHERE 和 HAVING 子句中包含 UNION。
select‑stmt { UNION [ ALL | DISTINCT ] select-stmt }[...]
[ order-by-clause [ offset-clause ]]
[ limit-clause ]
SELECT 语句，具体取决于您指定的关键字是 DISTINCT 还是 ALL。
以下选项也适用：
第一个 SELECT 语句可以包含 LABEL 提示。Vertica 会忽略后续 SELECT 语句中的 LABEL 提示。
每个 SELECT 语句都可以指定自己的 ORDER BY、LIMIT 和 OFFSET 子句。包含一个或多个这些子句的 SELECT 语句必须用括号括起来。另请参阅：UNION 中的 ORDER BY、LIMIT 和 OFFSET 子句。
DISTINCT | ALLDISTINCT（默认）仅返回唯一行。
ALL 可连接所有行，包括重复行。为获得最佳性能，请使用 UNION ALL。
UNION 结果集的所有行都必须存在于至少一个其 SELECT 语句的结果集中。
每个 SELECT 语句必须指定相同的列数。
对应的 SELECT 语句列的数据类型必须兼容，否则 Vertica 将返回错误。
UNION 语句可以指定自己的 ORDER BY、LIMIT 和 OFFSET 子句。例如，对于以下示例中描述的表，以下查询将按 emp_name 对 UNION 结果集进行排序，并将输出限制为前两行：
=> SELECT id, emp_name FROM company_a UNION ALL SELECT id, emp_name FROM company_b ORDER BY emp_name LIMIT 2;
id | emp_name
------+----------
5678 | Alice
8765 | Bob
(2 rows)
UNION 子句中的每个 SELECT 语句都可以指定自己的 ORDER BY、LIMIT 和 OFFSET 子句。在这种情况下，SELECT 语句必须用括号括起来。Vertica 首先处理 SELECT 语句的 ORDER BY、LIMIT 和 OFFSET 子句，然后再处理 UNION 子句。
例如，以下 UNION 中的每个 SELECT 语句都指定了自己的 ORDER BY 和 LIMIT 子句。Vertica 处理单个查询，然后连接两个结果集：
=> (SELECT id, emp_name FROM company_a ORDER BY emp_name LIMIT 2)
UNION ALL
(SELECT id, emp_name FROM company_b ORDER BY emp_name LIMIT 2);
id | emp_name
------+-----------
5678 | Alice
9012 | Katherine
8765 | Bob
9012 | Katherine
(4 rows)
以下要求和限制用于确定 Vertica 处理包含 ORDER BY、LIMIT 和 OFFSET 子句的 UNION 子句的方式：
UNION 的 ORDER BY 子句必须使用第一个（最左侧的）SELECT 语句指定列。
始终将 ORDER BY 子句与 LIMIT 和 OFFSET 一起使用。否则，查询将返回结果集的一个不确定子集。
ORDER BY 必须位于 LIMIT 和 OFFSET 之前。
当 SELECT 或 UNION 语句同时指定 LIMIT 和 OFFSET 时，Vertica 首先处理 OFFSET 语句，然后将 LIMIT 语句应用于其余行。
Vertica 支持非相关子查询谓词中的 UNION。例如：
=> SELECT DISTINCT customer_key, customer_name FROM public.customer_dimension WHERE customer_key IN
(SELECT customer_key FROM store.store_sales_fact WHERE sales_dollar_amount > 500
UNION ALL
SELECT customer_key FROM online_sales.online_sales_fact WHERE sales_dollar_amount > 500)
AND customer_state = 'CT';
customer_key | customer_name
--------------+------------------------
7021 | Luigi T. Dobisz
1971 | Betty V. Dobisz
46284 | Ben C. Gauthier
33885 | Tanya Y. Taylor
5449 | Sarah O. Robinson
29059 | Sally Z. Fortin
11200 | Foodhope
15582 | John J. McNulty
24638 | Alexandra F. Jones
...
使用这两个表的示例：
company_a
ID emp_name dept sales
------+------------+-------------+-------
1234 | Stephen | auto parts | 1000
5678 | Alice | auto parts | 2500
9012 | Katherine | floral | 500
company_b
ID emp_name dept sales
------+------------+-------------+-------
4321 | Marvin | home goods | 250
9012 | Katherine | home goods | 500
8765 | Bob | electronics | 20000
UNION 语句指定选项 DISTINCT，将合并员工的唯一 ID 和姓氏；Katherine 同时为两个公司工作，所以她在结果集中只出现一次。DISTINCT 为默认值，可以忽略：
=> SELECT id, emp_name FROM company_a UNION DISTINCT SELECT id, emp_name FROM company_b ORDER BY id;
id | emp_name
------+-----------
1234 | Stephen
4321 | Marvin
5678 | Alice
8765 | Bob
9012 | Katherine
(5 rows)
下一个 UNION 语句指定选项 ALL。Katherine 同时为两个公司工作，因此查询返回两条与她相关的记录：
=> SELECT id, emp_name FROM company_a UNION ALL SELECT id, emp_name FROM company_b ORDER BY id;
id | emp_name
------+-----------
1234 | Stephen
5678 | Alice
9012 | Katherine
4321 | Marvin
9012 | Katherine
8765 | Bob
(6 rows)
每个 SELECT 语句都指定了自己的 ORDER BY 和 LIMIT 子句，因此 UNION 语句将连接每个查询返回的结果集：
=> (SELECT id, emp_name, sales FROM company_a ORDER BY sales DESC LIMIT 2)
UNION ALL
(SELECT id, emp_name, sales FROM company_b ORDER BY sales DESC LIMIT 2);
id | emp_name | sales
------+-----------+-------
8765 | Bob | 20000
5678 | Alice | 2500
1234 | Stephen | 1000
9012 | Katherine | 500
(4 rows)
UNION 语句指定其自己的 ORDER BY 子句，Vertica 将其应用于整个结果：
=> SELECT id, emp_name, sales FROM company_a
UNION
SELECT id, emp_name, sales FROM company_b
ORDER BY sales;
id | emp_name | sales
------+-----------+-------
4321 | Marvin | 250
9012 | Katherine | 500
1234 | Stephen | 1000
5678 | Alice | 2500
8765 | Bob | 20000
(5 rows)
每个 SELECT 语句都有自己的 GROUP BY 子句。UNION 将合并每个查询的聚合结果：
=> (SELECT 'Company A' as company, dept, SUM(sales) FROM company_a
GROUP BY dept)
UNION
(SELECT 'Company B' as company, dept, SUM(sales) FROM company_b
GROUP BY dept)
ORDER BY 1;
company | dept | sum
-----------+-------------+-------
Company A | auto parts | 3500
Company A | floral | 500
Company B | electronics | 20000
Company B | home goods | 750
(4 rows)
指定要包含在查询结果集中的行。
WHERE boolean-expression [ subquery ]...
使用圆括号将表达式、谓词和布尔运算符进行分组。例如：
... WHERE NOT (A=1 AND B=2) OR C=3;
以下示例返回所有名字以 Amer 字符串开头的东部地区顾客的名字：
=> SELECT DISTINCT customer_name
FROM customer_dimension
WHERE customer_region = 'East'
AND customer_name ILIKE 'Amer%';
customer_name
---------------
Americare
Americom
Americore
Americorp
Ameridata
Amerigen
Amerihope
Amerimedia
Amerishop
Ameristar
Ameritech
(11 rows)
WITH 子句定义了一个或多个已命名公用表表达式 (CTE)，其中每个 CTE 均封装了一个结果集，该结果集可以被同一个 WITH 子句中的另一个 CTE 引用或被主要查询引用。Vertica 可以对每个引用执行 CTE（内联展开），或将结果集实体化作为临时表，以供其所有引用重复使用。在这两种情况下，WITH 子句都可以帮助简化复杂查询并避免语句重复。
WITH [ /*+ENABLE_WITH_CLAUSE_MATERIALIZATION */ ] [ RECURSIVE ] {
cte‑identifier [ ( column-aliases ) ] AS (
[ subordinate-WITH-clause ]
query-expression )
} [,...]
/*+ENABLE_WITH_CLAUSE_MATERIALIZATION*/RECURSIVEcte‑identifier 同一 WITH 子句的所有 CTE 标识符必须是唯一的。例如，以下 WITH 子句定义了两个 CTE，因此它们需要唯一的标识符： regional_sales 和 top_regions：
WITH
-- query sale amounts for each region
regional_sales AS (SELECT ... ),
top_regions AS ( SELECT ... )
)
column-aliases 在以下示例中，revenue CTE 指定了两个列别名： vkey 和 total_revenue。这两个别名分别映射到列 vendor_key 和聚合表达式 SUM(total_order_cost)。主要查询将引用这些别名：
WITH revenue ( vkey, total_revenue ) AS (
SELECT vendor_key, SUM(total_order_cost)
FROM store.store_orders_fact
GROUP BY vendor_key ORDER BY vendor_key)
SELECT v.vendor_name, v.vendor_address, v.vendor_city, r.total_revenue
FROM vendor_dimension v JOIN revenue r ON v.vendor_key = r.vkey
WHERE r.total_revenue = (SELECT MAX(total_revenue) FROM revenue )
ORDER BY vendor_name;
subordinate‑WITH‑clause query-expression WITH 子句仅支持 SELECT 和 INSERT 语句。它们不支持 UPDATE 或 DELETE 语句。
包含 RECURSIVE 选项的 WITH 子句可以重复执行 UNION 或 UNION ALL 查询，从而迭代其自身的输出。递归查询在处理分层结构（例如，经理下属关系）或树状结构数据（如分类法）等自引用数据时十分有用。
配置参数 WithClauseRecursionLimit（默认设置为 8）将设置递归的最大深度。您可以分别使用 ALTER DATABASE 和 ALTER SESSION 在数据库和会话范围内设置此参数。递归将会继续，直到达到配置的最大深度为止，或者直到最后一次迭代返回没有数据为止。
可以按如下方式指定递归 WITH 子句：
WITH [ /*+ENABLE_WITH_CLAUSE_MATERIALIZATION*/ ] RECURSIVE
cte‑identifier [ ( column-aliases ) ] AS (
non-recursive-term
UNION [ ALL ]
recursive-term
)
非递归项和递归项由 UNION 或 UNION ALL 分隔：
non-recursive-term 查询将其结果集设置在 cte-identifier，在 recursive-term 中递归。
UNION 语句的 recursive-term 以递归方式迭代其自身输出。当递归完成时，所有迭代的结果均会编译并在 cte-identifier 中设置。
存在以下限制：
非递归项的 SELECT 列表不能包含通配符 *（星号）或函数 MATCH_COLUMNS。
递归项只能引用目标 CTE 一次。
递归引用不能出现在外联接中。
递归引用不能出现在子查询中。
WITH 子句不支持 UNION 选项 ORDER BY、LIMIT 和 OFFSET。
下面的 SQL 定义了一个包含单个 CTE 的 WITH 子句 revenue，该子句将聚合表 store.store_orders_fact 中的数据。主要查询将引用两次 WITH 子句结果集：在其 JOIN 子句和谓词中：
-- define WITH clause
WITH revenue ( vkey, total_revenue ) AS (
SELECT vendor_key, SUM(total_order_cost)
FROM store.store_orders_fact
GROUP BY vendor_key ORDER BY 1)
-- End WITH clause
-- primary query
SELECT v.vendor_name, v.vendor_address, v.vendor_city, r.total_revenue
FROM vendor_dimension v JOIN revenue r ON v.vendor_key = r.vkey
WHERE r.total_revenue = (SELECT MAX(total_revenue) FROM revenue )
ORDER BY vendor_name;
vendor_name | vendor_address | vendor_city | total_revenue
------------------+----------------+-------------+---------------
Frozen Suppliers | 471 Mission St | Peoria | 49877044
(1 row)
在以下示例中，WITH 子句包含两个 CTE：
regional_sales 每个地区的销售总量
top_regions 使用 regional_sales 的结果集确定销售总量最高的三个地区：
主要查询在 top_regions 结果集中按地区和部门聚合销量：
WITH
-- query sale amounts for each region
regional_sales (region, total_sales) AS (
SELECT sd.store_region, SUM(of.total_order_cost) AS total_sales
FROM store.store_dimension sd JOIN store.store_orders_fact of ON sd.store_key = of.store_key
GROUP BY store_region ),
-- query previous result set
top_regions AS (
SELECT region, total_sales
FROM regional_sales ORDER BY total_sales DESC LIMIT 3
)
-- primary query
-- aggregate sales in top_regions result set
SELECT sd.store_region AS region, pd.department_description AS department, SUM(of.total_order_cost) AS product_sales
FROM store.store_orders_fact of
JOIN store.store_dimension sd ON sd.store_key = of.store_key
JOIN public.product_dimension pd ON of.product_key = pd.product_key
WHERE sd.store_region IN (SELECT region FROM top_regions)
GROUP BY ROLLUP (region, department) ORDER BY region, product_sales DESC, GROUPING_ID();
region | department | product_sales
---------+----------------------------------+---------------
East | | 1716917786
East | Meat | 189837962
East | Produce | 170607880
East | Photography | 162271618
East | Frozen Goods | 141077867
East | Gifts | 137604397
East | Bakery | 136497842
East | Liquor | 130410463
East | Canned Goods | 128683257
East | Cleaning supplies | 118996326
East | Dairy | 118866901
East | Seafood | 109986665
East | Medical | 100404891
East | Pharmacy | 71671717
MidWest | | 1287550770
MidWest | Meat | 141446607
MidWest | Produce | 125156100
MidWest | Photography | 122666753
MidWest | Frozen Goods | 105893534
MidWest | Gifts | 103088595
MidWest | Bakery | 102844467
MidWest | Canned Goods | 97647270
MidWest | Liquor | 97306898
MidWest | Cleaning supplies | 90775242
MidWest | Dairy | 89065443
MidWest | Seafood | 82541528
MidWest | Medical | 76674814
MidWest | Pharmacy | 52443519
West | | 2159765937
West | Meat | 235841506
West | Produce | 215277204
West | Photography | 205949467
West | Frozen Goods | 178311593
West | Bakery | 172824555
West | Gifts | 172134780
West | Liquor | 164798022
West | Canned Goods | 163330813
West | Cleaning supplies | 148776443
West | Dairy | 145244575
West | Seafood | 139464407
West | Medical | 126184049
West | Pharmacy | 91628523
| | 5164234493
(43 rows)
以下 SQL 使用 WITH 子句将 JOIN 查询中的数据插入到表 total_store_sales 中：
CREATE TABLE total_store_sales (store_key int, region VARCHAR(20), store_sales numeric (12,2));
INSERT INTO total_store_sales
WITH store_sales AS (
SELECT sd.store_key, sd.store_region::VARCHAR(20), SUM (of.total_order_cost)
FROM store.store_dimension sd JOIN store.store_orders_fact of ON sd.store_key = of.store_key
GROUP BY sd.store_region, sd.store_key ORDER BY sd.store_region, sd.store_key)
SELECT * FROM store_sales;
=> SELECT * FROM total_store_sales ORDER BY region, store_key;
store_key | region | store_sales
-----------+-----------+-------------
2 | East | 47668303.00
6 | East | 48136354.00
12 | East | 46673113.00
22 | East | 48711211.00
24 | East | 48603836.00
31 | East | 46836469.00
36 | East | 48461449.00
37 | East | 48018279.00
41 | East | 48713084.00
44 | East | 47808362.00
49 | East | 46990023.00
50 | East | 47643329.00
9 | MidWest | 46851087.00
15 | MidWest | 48787354.00
27 | MidWest | 48497620.00
29 | MidWest | 47639234.00
30 | MidWest | 49013483.00
38 | MidWest | 48856012.00
42 | MidWest | 47297912.00
45 | MidWest | 48544521.00
46 | MidWest | 48887255.00
4 | NorthWest | 47580215.00
39 | NorthWest | 47136892.00
47 | NorthWest | 48477574.00
8 | South | 48131455.00
13 | South | 47605422.00
17 | South | 46054367.00
...
(50 rows)
SET 语句用于更改数据库的运行方式，例如更改自动提交设置或会话使用的资源池。
指定如何设置当前会话的日期/时间输出格式。使用
SHOW DATESTYLE 验证当前输出设置。
SET DATESTYLE TO { arg | 'arg' }[, arg | 'arg' ]
SET DATESTYLE 只有一个参数，该参数可以设置为一个或两个指定日期排序和样式的实参。每个实参可以单独指定或结合使用；如果结合，则可按任意顺序指定。
下表说明了每种样式及其支持的日期排序实参：
Vertica 将忽略 ISO 和 GERMAN 日期样式的顺序实参。如果日期样式为 SQL 或 POSTGRES，则顺序设置将决定以 MDY 还是 DMY 顺序输出日期。SQL 和 POSTGRES 都不支持 YMD 顺序。如果为 YMD 或 SQL 指定 POSTGRES，Vertica 将忽略该设置，并使用默认的 MDY 顺序。
日期样式和排序还会影响 Vertica 解释输入值的方式。有关详细信息，请参阅日期/时间字面量。
无
在某些情况下，输入格式会决定输出格式，而不管日期样式和顺序的设置：
Vertica 中 DATESTYLE 的 ISO 输出为 ISO 长格式，但也接受某些输入样式。如果输入中最先出现年份，则将对输入和输出使用 YMD，而不考虑 DATESTYLE 值。
INTERVAL 输入和输出共用同一格式，以下内容除外：
CENTURY 或 WEEK 等单位转换为年和日。
AGO 转换为相应符号。
如果日期样式设置为 ISO，输出将遵照以下格式：
[ quantity unit [...] ] [ days ] [ hours:minutes:seconds ]
=> CREATE TABLE t(a DATETIME);
CREATE TABLE
=> INSERT INTO t values ('3/16/2016');
OUTPUT
--------
1
(1 row)
=> SHOW DATESTYLE;
name | setting
-----------+----------
datestyle | ISO, MDY
(1 row)
=> SELECT * FROM t;
a
---------------------
2016-03-16 00:00:00
(1 row)
=> SET DATESTYLE TO German;
SET
=> SHOW DATESTYLE;
name | setting
-----------+-------------
datestyle | German, DMY
(1 row)
=> SELECT * FROM t;
a
---------------------
16.03.2016 00:00:00
(1 row)
=> SET DATESTYLE TO SQL;
SET
=> SHOW DATESTYLE;
name | setting
-----------+----------
datestyle | SQL, DMY
(1 row)
=> SELECT * FROM t;
a
---------------------
16/03/2016 00:00:00
(1 row)
=> SET DATESTYLE TO Postgres, MDY;
SET
=> SHOW DATESTYLE;
name | setting
-----------+---------------
datestyle | Postgres, MDY
(1 row)
=> SELECT * FROM t;
a
--------------------------
Wed Mar 16 00:00:00 2016
(1 row)
当前 会话期间，在字符串字面量中使用反斜杠时发出警告。
SET ESCAPE_STRING_WARNING TO { ON | OFF }
ON提示： 已升级较早版本的 Vertica 的组织可以将此参数用作调试工具，以查找过去被视为转义字符，但现在被视为字面量的反斜杠。
OFF无
此语句只能在 vsql 下使用。
请先关闭标准一致性字符串，然后再开启此参数。
以下示例显示了如何关闭会话的转义字符串警告。
=> SET ESCAPE_STRING_WARNING TO OFF;
指定是否在当前 会话的间隔输出中包含单位。
SET INTERVALSTYLE TO [ plain | units ]
INTERVALSTYLE 设置为单位时，DATESTYLE 参数将控制输出。如果启用了单位，但其未显示在输出中，请检查 DATESTYLE 参数值，该值必须设置为 ISO 或 POSTGRES 才能显示间隔单位。无
请参阅设置间隔单位显示。
指定当前 会话的区域设置。
还可以使用 vsql 命令
\locale 设置当前区域设置。
SET LOCALE TO ICU‑locale‑identifier
en_US@collation=binary
如果设置为空字符串，Vertica 会将区域设置设为 en_US_POSIX。
需要满足以下要求：
Vertica 仅支持 COLLATION 关键字。
指定排序规则必须使用单引号。
无
有关标识符选项的详细信息，请参阅关于区域设置。有关区域设置标识符的完整列表，请参阅 ICU 项目。
de_DEen_GBes_ESfr_FRpt_BRpt_PT ru_RUja_JP zh_CN zh_Hant_TW将会话区域设置为 en_GB：
=> SET LOCALE TO en_GB;
INFO 2567: Canonical locale: 'en_GB'
Standard collation: 'LEN'
English (United Kingdom)
SET
使用区域设置的缩写：
=> SET LOCALE TO LEN;
INFO 2567: Canonical locale: 'en'
Standard collation: 'LEN'
English
SET
指定排序规则：
=> SET LOCALE TO 'tr_tr@collation=standard';
INFO 2567: Canonical locale: 'tr_TR@collation=standard'
Standard collation: 'LTR'
Turkish (Turkey, collation=standard) Türkçe (Türkiye, Sıralama=standard)
SET
为用户的当前会话启用角色。用户可以访问授予该角色的特权。启用角色不会影响当前已启用的角色。
SET ROLE roles‑expression
roles‑expression NONE （默认值）：禁用所有角色。
roles‑list: 要启用的角色列表，以逗号分隔。您只能设置当前已授予您的角色。
ALL [EXCEPT roles‑list]: 启用当前已授予此用户的所有角色，不包括在可选 EXCEPT 子句中指定的任何以逗号分隔的角色。
DEFAULT：启用所有默认角色。根据定义，默认角色会自动启用，但如果使用 SET ROLE NONE 禁用了这些角色，要重新启用这些角色，此选项可能很有用。
无
示例如下：
SHOW AVAILABLE_ROLES; 会列出用户可使用的角色，但不启用。
SET ROLE applogs; 为用户启用 applogs 角色。
SHOW ENABLED_ROLES; 将 applogs 角色列为已为用户启用 (SET)。
SET ROLE appuser; 为用户启用 appuser 角色。
SHOW ENABLED_ROLES 将 applogs 和 appuser 列为用户的已启用角色。
SET ROLE NONE 禁用用户的所有已启用角色。
SHOW ENABLED_ROLES 显示没有为用户启用任何角色。
=> SHOW AVAILABLE_ROLES;
name | setting
-----------------+----------------------------
available roles | applogs, appadmin, appuser
(1 row)
=> SET ROLE applogs;
SET
=> SHOW ENABLED_ROLES;
name | setting
---------------+---------
enabled roles | applogs
(1 row)
=> SET ROLE appuser;
SET
=> SHOW ENABLED_ROLES;
name | setting
---------------+------------------
enabled roles | applogs, appuser
(1 row)
=> SET ROLE NONE;
SET
=> SHOW ENABLED_ROLES;
name | setting
---------------+---------
enabled roles |
(1 row)
设置用户默认角色
虽然通常是由 DBADMIN 用户负责设置用户默认角色，但作为用户，您可以设置自己的角色。例如，如果您运行 SET ROLE NONE，则您的所有已启用角色将被禁用。因而决定了您需要将 role1 作为默认角色进行访问。DBADMIN 使用 ALTER USER 向您分配默认角色：
=> ALTER USER user1 default role role1;
此示例将 role1 设置为 user1 的默认角色，因为 DBADMIN 使用 ALTER USER 分配了此默认角色。
user1 => SET ROLE default;
user1 => SHOW ENABLED_ROLES;
name | setting
-----------------------
enabled roles | role1
(1 row)
将所有角色设为默认值
此示例将所有授予 user1 的角色设为默认角色：
user1 => SET ROLE all;
user1 => show enabled roles;
name | setting
----------------------------------
enabled roles | role1, role2, role3
(1 row)
将所有角色设为默认值（含例外）
此示例将授予用户的所有角色设为默认角色，但 role1 除外。
user1 => set role all except role1;
user1 => SHOW ENABLED_ROLES
name | setting
----------------------------
enabled roles | role2, role3
(1 row)
指定当 SQL 语句指定不使用架构名称限定的表名称时 Vertica 搜索架构的顺序。 SET SEARCH_PATH 覆盖当前会话的搜索路径，该路径最初是在用户配置文件中设置的。此搜索路径一直有效，直到下一个 SET SEARCH_PATH 语句或会话结束为止。有关详细信息，请参阅设置搜索路径。
要查看当前搜索路径，请使用
SHOW SEARCH_PATH。
SET SEARCH_PATH { TO | = } { schema‑list | DEFAULT }
如果搜索路径中包含的架构不存在，或者用户缺少对该架构的访问权限，Vertica 会静默跳过该架构。
DEFAULT"$user", public, v_catalog, v_monitor, v_internal
无
显示当前搜索路径：
=> SHOW SEARCH_PATH;
name | setting
-------------+---------------------------------------------------
search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)
将搜索路径重置为架构 store 和 public：
=> SET SEARCH_PATH TO store, public;
=> SHOW SEARCH_PATH;
name | setting
-------------+-------------------------------------------------
search_path | store, public, v_catalog, v_monitor, v_internal
(1 row)
将搜索路径重置为数据库默认设置：
=> SET SEARCH_PATH TO DEFAULT;
SET
=> SHOW SEARCH_PATH;
name | setting
-------------+---------------------------------------------------
search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)
设置语句是否在完成时自动提交其事务。此语句主要由客户端驱动程序用于启用和禁用自动提交，您永远没有必要直接调用该语句。
SET SESSION AUTOCOMMIT TO { ON | OFF }
ONOFF无
此示例显示了如何将 AUTOCOMMIT 设置为“on”，然后再设置为“off”。
=> SET SESSION AUTOCOMMIT TO on;
SET
=> SET SESSION AUTOCOMMIT TO off;
SET
设置在此语句发出后开始的所有事务的隔离级别和访问模式。
事务将保留其隔离级别直至其完成，即使在事务处理期间会话的隔离级别发生更改也是如此。Vertica 内部进程（例如 Tuple Mover 和 刷新操作）以及 DDL 操作始终以 SERIALIZABLE 隔离级别运行以确保一致性。
SET SESSION CHARACTERISTICS AS TRANSACTION settings
ISOLATION LEVEL [argument](#IsolationArgs)
[READ ONLY | READ WRITE](#ReadWrite)
ISOLATION LEVEL 子句用于确定当同时运行其他多个事务时，此事务可以访问的数据。如果事务已运行，则不能在第一个查询 (SELECT) 或 DML 语句（INSERT、DELETE、UPDATE）之后更改隔离级别。
将 ISOLATION LEVEL 设置为以下实参之一：
SERIALIZABLE使用 SERIALIZABLE 的应用程序必须准备好在序列化失败后重试事务。对于正常的查询操作，不建议使用此隔离级别。
将事务隔离级别设置为 SERIALIZABLE 不会应用于临时表。临时表通过其事务范围进行隔离。
REPEATABLE READSERIALIZABLE。READ COMMITTEDREAD UNCOMMITTEDREAD COMMITTED。您可以将事务访问模式设置为以下几项之一：
READ WRITEREAD ONLY对任何非临时表的 INSERT、UPDATE、DELETE 和 COPY 操作。
CREATE、ALTER 和 DROP
GRANT、REVOKE
EXPLAIN（如果要解释的 SQL 语句需要写入权限）。
无
SHOW TRANSACTION_ISOLATION 和 SHOW TRANSACTION_READ_ONLY 可显示当前会话的事务设置：
=> SHOW TRANSACTION_ISOLATION;
name | setting
-----------------------+--------------
transaction_isolation | SERIALIZABLE
(1 row)
=> SHOW TRANSACTION_READ_ONLY;
name | setting
-----------------------+---------
transaction_read_only | true
(1 row)
设置会话套接字在等待给定查询的客户端输入或输出时保持拦截状态的时间。如果套接字在超过宽限期设置的一段连续时间内被拦截，服务器将关闭套接字并引发致命错误。然后会话终止。如果未设置宽限期，查询可以无限期地在套接字上保留它的块。
Vertica 独立应用会话的宽限期和
RUNTIMECAP 设置。如果未设置宽限期，则无论查询的 RUNTIMECAP 设置如何，查询都可以在会话套接字上无限期地阻塞。
SET SESSION GRACEPERIOD duration
'interval'：将当前会话查询的最长宽限期指定为间隔，最长 20 天。
=DEFAULT：将此会话中查询的宽限期设置为用户的 GRACEPERIOD 值。新会话最初将设置为此值。
NONE：仅对超级用户有效，将移除之前在会话查询中设置的任何宽限期。
无论数据库或节点设置如何，超级用户均可以将会话宽限期增加到任意值。
非超级用户只能将会话宽限期设置为不大于自己的用户设置的值。如果没有为用户显式设置宽限期，则该用户的宽限期将从节点或数据库设置继承。
请参阅《管理员指南》中的处理会话套接字阻止。
设置会话在退出之前可以保持空闲的最长时间。
SET SESSION IDLESESSIONTIMEOUT duration
NONE （默认值）：会话未设置空闲超时。
'interval'：指定为间隔，即会话可以保持空闲的最长时间。
=DEFAULT：将此会话的空闲超时时间设置为用户的 IDLESESSIONTIMEOUT 值。
无论数据库或节点设置如何，超级用户均可以将会话保持空闲的时间增加到任意值。
非超级用户只能将会话空闲时间设置为不大于自己的用户设置的值。如果没有为用户显式设置会话空闲时间，则该用户的会话空闲时间将从节点或数据库设置继承。
请参阅《管理员指南》中的管理客户端连接。
限制可以为当前 会话中的任何请求分配的内存量。此限制仅适用于当前会话；不限制多个会话使用的内存总量。
SET SESSION MEMORYCAP limit
'max‑expression'：一个字符串值，用于指定内存限制，为以下几项之一：
int% — 将最大值表示为
资源管理器可用总内存的百比，其中 int 为 0 至 100 之间的整数。例如：
MEMORYCAP '40%'
int{K|M|G|T} — 以 KB、MB、GB 或 TB 表示内存分配。例如：
MEMORYCAP '10G'
=DEFAULT：将此会话中查询的内存上限设置为用户的 MEMORYCAP 值。新会话最初将设置为此值。
NONE：移除此会话的内存上限。
超级用户可以将会话内存上限增加到任意值。
非超级用户只能将会话内存上限设置为不大于自己的用户设置的值。
将会话内存上限设置为 2 GB：
=> SET SESSION MEMORYCAP '2G';
SET
=> SHOW MEMORYCAP;
name | setting
-----------+---------
memorycap | 2097152
(1 row)
将内存上限恢复为用户配置文件中指定的默认设置：
=> SET MEMORYCAP=DEFAULT;
SET
=> SHOW MEMORYCAP;
name | setting
-----------+---------
memorycap | 2013336
(1 row)
启用或禁用在单一 JDBC 连接上执行多个活动结果集 (MARS)。使用此选项需要具有活动的 JDBC 连接。
SET SESSION MULTIPLEACTIVERESULTSETS TO { ON | OFF }
ONOFF无
此示例显示了如何将 MultipleActiveResultSets 设置为“on”，然后再设置为“off”：
=> SET SESSION MULTIPLEACTIVERESULTSETS TO on;
SET
=> SET SESSION MULTIPLEACTIVERESULTSETS TO off;
SET
将用户 会话与指定资源池关联。
SET SESSION RESOURCE_POOL = { pool-name | DEFAULT }
DEFAULT超级用户可以将其会话分配到任意可用的资源池。
非超级用户必须具有资源池的 USAGE 权限。
此示例将 ceo_pool 设置为会话资源池：
=> SET SESSION RESOURCE_POOL = ceo_pool;
SET
设置查询和存储过程可以在给定会话中运行的最长时间。如果查询或存储过程超出其会话的 RUNTIMECAP，Vertica 将终止它并返回错误。不能将 RUNTIMECAP 增加到超出用户配置文件中设置的限制。
RUNTIMECAP 设置。如果对查询或存储过程进行计时，您可能会发现其运行时间超出了 RUNTIMECAP 设置。
SET SESSION RUNTIMECAP duration
NONE （默认值）：移除所有当前会话查询的运行时限制。
'interval'：将当前会话查询的最长运行时间指定为间隔，最长为一年，例如，1 minute 或 100 seconds。
=DEFAULT：将此会话中查询的最长运行时间设置为用户的 RUNTIMECAP 值。
超级用户可以将会话 RUNTIMECAP 增加到任意值。
非超级用户只能将会话 RUNTIMECAP 设置为不大于自己的用户 RUNTIMECAP 的值。
将当前会话的最大查询运行时设置为 10 分钟：
=> SET SESSION RUNTIMECAP '10 minutes';
将会话 RUNTIMECAP 恢复为您的用户默认设置：
=> SET SESSION RUNTIMECAP =DEFAULT;
SET
=> SHOW RUNTIMECAP;
name | setting
------------+-----------
runtimecap | UNLIMITED
(1 row)
将 RUNTIMECAP 设置为 1 SECOND 并使用无限循环运行匿名过程：
=> SET SESSION RUNTIMECAP '1 SECOND';
SET
=> DO $$
BEGIN
LOOP
END LOOP;
END;
$$;
ERROR 0: Query exceeded maximum runtime
HINT: Change the maximum runtime using SET SESSION RUNTIMECAP
设置 会话发出的任何请求可以消耗的最大临时文件存储量。如果查询的执行计划所需的存储空间超出会话 TEMPSPACECAP，将会返回错误。
SET SESSION TEMPSPACECAP limit
限制 NONE （默认值）：临时存储不受限制
= DEFAULT：会话 TEMPSPACECAP 设置为用户的 TEMPSPACECAP 值。
用于指定存储限制的字符串，为以下几项之一：
int% 将最大值表示为资源管理器可用的临时总存储的百分比，其中 int 为 0 至 100 之间的整数值。例如：
SET SESSION TEMPSPACECAP '40%';
int{K|M|G|T} 以 KB、MB、GB 或 TB 表示存储分配。例如：
SET SESSION TEMPSPACECAP '10G';
非超级用户：
仅限于设置自己的会话
会话 TEMPSPACECAP 不能大于其自己的 TEMPSPACECAP。
将会话 TEMPSPACECAP 设置为 20 GB：
=> SET SESSION TEMPSPACECAP '20G';
SET
=> SHOW TEMPSPACECAP;
name | setting
--------------+----------
tempspacecap | 20971520
(1 row)
将会话 TEMPSPACECAP 设置为不受限制：
=> SET SESSION TEMPSPACECAP NONE;
SET
=> SHOW TEMPSPACECAP;
name | setting
--------------+-----------
tempspacecap | UNLIMITED
(1 row)
指定是否将反斜杠视为当前会话的转义字符。默认情况下，Vertica 符合 SQL 标准并支持 Unicode 转义中的 SQL:2008 字符串字面量。
SET STANDARD_CONFORMING_STRINGS TO { ON | OFF }
ONOFF无
此语句只能在 vsql 下使用。
标准-一致性字符串必须开启才可使用 Unicode 样式的字符串字面量 (U&'\nnnn')。
关闭会话的一致性字符串：
=> SET STANDARD_CONFORMING_STRINGS TO OFF;
验证当前设置：
=> SHOW STANDARD_CONFORMING_STRINGS;
name | setting
-----------------------------+---------
standard_conforming_strings | off
(1 row)
打开会话的一致性字符串：
=> SET STANDARD_CONFORMING_STRINGS TO ON;
更改当前
会话的 TIME ZONE 运行时参数。使用
SHOW TIMEZONE 显示会话的当前时区。
如果您使用 POSIX 格式设置时区，您使用的时区缩写将覆盖默认时区缩写。如果将日期样式设置为 POSTGRES，在将时间戳转换为字符串时，也会使用您使用的时区缩写。
SET TIME ZONE [TO] { value | 'value' }
TIME ZONE 和 TIMEZONE 视为同义词。
Vertica 支持的时区字面量。要查看默认的有效字面量列表，请参阅以下目录中的文件：
/opt/vertica/share/timezonesets
带符号整数，表示 UTC 偏移量（以小时为单位）
偏移量为带符号整数的时区字面量。例如：
=> SET TIME ZONE TO 'America/New York -3'; -- equivalent to Pacific time
America/NewYork + 150），Vertica 也不会返回错误。
常数 LOCAL 和 DEFAULT，分别将时区设置为环境变量 TZ 中指定的时区，或者如果 TZ 未定义，则设置为操作系统时区。
只有有效的（时区+偏移量）组合才能作为此函数的参数。
无
=> SET TIME ZONE TO DEFAULT;
=> SET TIME ZONE TO 'PST8PDT'; -- Berkeley, California
=> SET TIME ZONE TO 'Europe/Rome'; -- Italy
=> SET TIME ZONE TO '-7'; -- UDT offset equivalent to PDT
=> SET TIME ZONE TO INTERVAL '-08:00 HOURS';
Vertica 将下面列出的时区名称识别为 SQL 时区的有效设置（TIME ZONE 运行时参数）。
这些名称不同于
/opt/vertica/share/timezonesets 中显示的名称，后者以 date/time 输入值的形式获得 Vertica 识别。下面列出的 TIME ZONE 名称意味着本地夏令时规则，其中 date/time 输入名称代表 UTC 的固定偏移量。
在许多情况下，同一时区具有多个名称。这些名称位于同一个组中。列表主要按常用时区名称进行排序。
除了列表中的名称之外，Vertica 还接受以下时区名称之一：
STDoffset
STDoffsetDST
其中 STD 为时区缩写，offset 为从 UTC 往西的偏移量数值（以小时为单位），而 DST 为可选的夏令时时区缩写，假定代表比给定偏移量提前一小时。
例如，如果 EST5EDT 还不是公认的时区名称，Vertica 将接受它在功能上等同于美国东海岸时间。如果存在夏令时时区名称，Vertical 将假定该名称使用美国时区规则，因此此功能在北美以外地区的使用受到限制。
SET TIME ZONE TO FOOBANKO 可以使用 GMT 的一个比较奇特的缩写发挥作用，使系统高效运行。
CET
EET
GMT
GMT+0
GMT-0
GMT0
Greenwich
Etc/Greenwich
工厂
MET
UCT Etc
UCT
偏移量
Universal Zulu
Etc/UTC
Etc/Universal
Etc/Zulu
WET
显示当前会话的运行时参数。
SHOW { parameter | ALL }
ALL AUTOCOMMITAVAILABLE ROLESDATESTYLEENABLED ROLESESCAPE_STRING_WARNINGGRACEPERIODIDLESESSIONTIMEOUTINTERVALSTYLELOCALEMEMORYCAPMULTIPLEACTIVERESULTSETSRESOURCE POOL RUNTIMECAPSEARCH_PATH=> SHOW SEARCH_PATH;
name | setting
-------------+---------------------------------------------------
search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)
STANDARD_CONFORMING_STRINGSTEMPSPACECAP TIMEZONETRANSACTION_ISOLATION=> SHOW TRANSACTION_ISOLATION;
name | setting
-----------------------+----------------
transaction_isolation | READ COMMITTED
(1 row)
TRANSACTION_READ_ONLY => SHOW TRANSACTION_READ_ONLY;
name | setting
-----------------------+---------
transaction_read_only | false
(1 row)
无
显示所有当前运行时参数设置：
=> SHOW ALL;
name | setting
-----------------------------+-----------------------------------------------------------
locale | en_US@collation=binary (LEN_KBINARY)
autocommit | off
standard_conforming_strings | on
escape_string_warning | on
multipleactiveresultsets | off
datestyle | ISO, MDY
intervalstyle | plain
timezone | America/New_York
search_path | "$user", public, v_catalog, v_monitor, v_internal, v_func
transaction_isolation | READ COMMITTED
transaction_read_only | false
resource_pool | general
memorycap | UNLIMITED
tempspacecap | UNLIMITED
runtimecap | UNLIMITED
idlesessiontimeout | UNLIMITED
graceperiod | UNLIMITED
enabled roles | dbduser*, dbadmin*, pseudosuperuser*
available roles | dbduser*, dbadmin*, pseudosuperuser*
(19 rows)
显示在所有级别设置的活动配置参数值。Vertica 首先检查在会话级别设置的值。如果未在会话级别为配置参数设置值，Vertica 接下来将检查是否为您登录的节点设置值，然后检查数据库级别。如果未设置值，SHOW CURRENT 将显示配置参数的默认值。如果配置参数需要重新启动才能生效，显示的活动值可能不同于设置的值。
SHOW CURRENT { parameter‑name[,...] | ALL }
ALL非超级用户： SHOW CURRENT ALL 返回掩码参数设置。尝试查看特定参数设置会返回错误。
显示所有级别的配置参数及其设置。
=> SHOW CURRENT ALL;
level | name |setting
---------+---------------------------+---------
DEFAULT | ActivePartitionCount | 1
DEFAULT | AdvanceAHMInterval | 180
DEFAULT | AHMBackupManagement | 0
DATABASE | AnalyzeRowCountInterval | 3600
SESSION | ForceUDxFencedMode | 1
NODE | MaxClientSessions | 0
...
显示为数据库设置的配置参数值。
SHOW DATABASE db‑spec { parameter‑name[,...] | ALL }
指定当前数据库，设置为数据库名称或DEFAULT。
SHOW DATABASE...ALL 屏蔽的参数，否则 Vertica 将返回错误。
如果指定的参数未设置，SHOW DATABASE 会为该参数返回一个空行。
要获取数据库级别参数的名称，请查询系统表
CONFIGURATION_PARAMETERS。
ALL超级用户：显示所有数据库参数设置。
非超级用户：屏蔽只有超级用户可以访问的所有安全性参数设置。要确定哪些参数需要超级用户权限，请查询系统表
CONFIGURATION_PARAMETERS。
向非超级用户显示在数据库上设置的所有配置参数：
=> SHOW DATABASE DEFAULT ALL;
name | setting
--------------------------------+----------
AllowNumericOverflow | 1
CopyFaultTolerantExpressions | 1
GlobalHeirUsername | ********
MaxClientSessions | 50
NumericSumExtraPrecisionDigits | 0
(6 rows)
显示两个配置参数的设置：
=> SHOW DATABASE DEFAULT AllowNumericOverflow, NumericSumExtraPrecisionDigits;
name | setting
--------------------------------+---------
AllowNumericOverflow | 1
NumericSumExtraPrecisionDigits | 0
(2 rows)
显示为节点设置的配置参数值。如果指定的参数未设置，SHOW NODE 会为该参数返回一个空行。
SHOW NODE node‑name { parameter‑name [,...] | ALL }
CONFIGURATION_PARAMETERS。ALL无
查看节点 v_vmart_node0001 的所有配置参数及其设置：
=> SHOW NODE v_vmart_node0001 ALL;
name | setting
---------------------------+---------
DefaultIdleSessionTimeout | 5 hour
MaxClientSessions | 20
显示为当前会话设置的配置参数值。如果指定的参数未设置，SHOW SESSION 会为该参数返回一个空行。
SHOW SESSION { ALL | UDPARAMETER ALL }
ALLUDPARAMETER ALL无
查看当前会话的所有 Vertica 配置参数及其设置。不包括用户定义的参数：
=> SHOW SESSION ALL;
name | setting
----------------------------+---------------------------------------------------
locale | en_US@collation=binary (LEN_KBINARY)
autocommit | off
standard_conforming_strings | on
escape_string_warning | on
datestyle | ISO, MDY
intervalstyle | plain
timezone | America/New_York
search_path | "$user", public, v_catalog, v_monitor, v_internal
transaction_isolation | READ COMMITTED
transaction_read_only | false
resource_pool | general
memorycap | UNLIMITED
tempspacecap | UNLIMITED
runtimecap | UNLIMITED
enabled roles | dbduser*, dbadmin*, pseudosuperuser*
available roles | dbduser*, dbadmin*, pseudosuperuser*
ForceUDxFencedMode | 1
(17 rows)
显示数据库用户的配置参数设置。要获取用户级别参数的名称，请查询系统表 CONFIGURATION_PARAMETERS：
SELECT parameter_name, allowed_levels FROM configuration_parameters
WHERE allowed_levels ilike '%USER%' AND parameter_name ilike '%depot%';
parameter_name | allowed_levels
-------------------------+-------------------------
UseDepotForWrites | SESSION, USER, DATABASE
DepotOperationsForQuery | SESSION, USER, DATABASE
UseDepotForReads | SESSION, USER, DATABASE
(3 rows)
SHOW USER { user‑name | ALL } [PARAMETER] { cfg‑parameter [,...] | ALL }
user‑name | ALL [PARAMETER] parameter-listPARAMETER ALL非超级用户：只能查看自己的配置参数设置。
以下示例显示了 Yvonne 和 Ahmed 两个用户的配置参数设置：
=> SELECT user_name FROM v_catalog.users WHERE user_name != 'dbadmin';
user_name
-----------
Ahmed
Yvonne
(2 rows)
=> SHOW USER Yvonne PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Yvonne | DepotOperationsForQuery | Fetches
(1 row)
=> ALTER USER Yvonne SET PARAMETER UseDepotForWrites = 0;
ALTER USER
=> SHOW USER Yvonne PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Yvonne | DepotOperationsForQuery | Fetches
Yvonne | UseDepotForWrites | 0
(2 rows)
=> ALTER USER Ahmed SET PARAMETER DepotOperationsForQuery = 'Fetches';
ALTER USER
=> SHOW USER ALL PARAMETER ALL;
user | parameter | setting
--------+-------------------------+---------
Ahmed | DepotOperationsForQuery | Fetches
Yvonne | DepotOperationsForQuery | Fetches
Yvonne | UseDepotForWrites | 0
(3 rows)
启动事务块。
START TRANSACTION [ isolation_level ]
其中，*isolation_level *是以下几项之一：
ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }READ { ONLY | WRITE }
隔离级别（在下表中介绍）确定在其他事务并发运行时某个事务可以访问的数据。首个查询 (SELECT) 或 DML 语句（INSERT、DELETE 或 UPDATE）运行后，隔离级别不能更改。
事务将保留其隔离级别直至其完成，即使在事务处理期间会话的隔离级别发生更改也是如此。Vertica 内部进程（例如
刷新操作）以及 DDL 操作始终以 SERIALIZABLE 隔离级别运行以确保一致性。
WORK | TRANSACTIONISOLATION LEVEL { | SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED } READ {WRITE | ONLY}如果将事务会话模式设置为只读，将不允许使用以下 SQL 命令，但是不会阻止所有磁盘写入操作：
无
BEGIN 执行与 START TRANSACTION 相同的功能。
此示例显示如何启动事务处理。
= > START TRANSACTION ISOLATION LEVEL READ COMMITTED READ WRITE;
START TRANSACTION
=> CREATE TABLE sample_table (a INT);
CREATE TABLE
=> INSERT INTO sample_table (a) VALUES (1);
OUTPUT
--------
1
(1 row)
移除与目标表关联的所有存储，同时保留完整的表定义。在执行语句后，TRUNCATE TABLE 将自动提交当前事务，无法回退。
TRUNCATE TABLE 同时还会执行以下操作：
TRUNCATE TABLE [[database.]schema.]table‑name
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table‑name 非超级用户：
表所有者
对于表架构的 USAGE 权限
请参阅截断表。
对于满足指定条件的所有行，替换其指定列的值。表中所有其他列和行不变。若成功，UPDATE 将返回被更新的行数。为 0 的计数表示没有任何行与该条件匹配。
UPDATE [[database.]schema.]table-reference [AS] alias
SET set‑expression [,...]
[ FROM from-list ]
[ where‑clause ]
UPDATE 语句还可以嵌入以下提示：
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table‑reference视情况进行限定的表名，带有可选表别名、列别名和外联接。
外联接表。
您无法更新投影。
别名SET set‑expressioncolumn-name = { expression | DEFAULT }
其中：
column-name 是不含主键或外键 引用完整性约束的任意列，而且不是复杂类型。允许使用原生数组。
expression 指定要分配给列的值。该表达式可使用此表列或其他表列的当前值。例如：
=> UPDATE T1 SET C1 = C1+1
DEFAULT 将 column-name 设置为其默认值，或者如果没有为该列定义默认值，则将其忽略。
UPDATE 只修改通过 SET 子句指定的列。未指定的列保持不变。
FROM from‑listFROM 子句可以引用目标表，如下所示：
FROM DEFAULT [join-type] JOIN table-reference [ ON join-predicate ]
DEFAULT 指定要更新的表。此关键字只能在 FROM 子句中使用一次，且不能在 UPDATE 语句的其他位置使用。
表所有者或用户 WITH GRANT OPTION 是授予者。
对表的 UPDATE 权限
包含表的架构上的 USAGE 权限
执行在 WHERE 或 SET 子句中引用表列值的 UPDATE 语句时，对于表拥有 SELECT 权限
UPDATE 支持子查询和联接，这有利于根据存储在其他表中的值来更新表中的值。有关详细信息，请参阅UPDATE 和 DELETE 语句中的子查询。
Vertica 采用 SQL-92 事务模型，因此连续的 INSERT、UPDATE 和 DELETE 语句包含在同一个事务中。您无需显式启动此事务，但必须使用 COMMIT 显式结束它，或者使用 COPY 隐式结束它。否则，Vertica 将放弃在该事务中所做的所有更改。
不能更新不可变表。
不能更新复杂类型的列，原生数组除外。
如果 FROM 子句或 WHERE 谓词中指定的联接生成多个目标表中行的副本，则将任意选择表中该行的新值。
如果在目标表中启用了主键、唯一键或检查约束以自动强制实施，Vertica 会在您加载新数据时强制实施这些约束。如果发生违规，Vertica 会回滚操作并返回错误。
如果更新会违反表或架构磁盘配额，则操作将失败。有关详细信息，请参阅磁盘配额。
在 fact 表中，对于 cost 列值大于 100 的所有行，修改其 price 列值：
=> UPDATE fact SET price = price - cost * 80 WHERE cost > 100;
在 retail.customer 表中，若 CID 列值大于 100，则将 state 列设置为 NH：
=> UPDATE retail.customer SET state = 'NH' WHERE CID > 100;
要在 UPDATE 查询中使用表别名，请考虑以下两个表：
=> SELECT * FROM result_table;
cust_id | address
---------+--------------------
20 | Lincoln Street
30 | Beach Avenue
30 | Booth Hill Road
40 | Mt. Vernon Street
50 | Hillside Avenue
(5 rows)
=> SELECT * FROM new_addresses;
new_cust_id | new_address
-------------+---------------
20 | Infinite Loop
30 | Loop Infinite
60 | New Addresses
(3 rows)
以下查询和子查询使用表别名将 result_table（别名 address）中的 r 列更新为 new_addresses 表（别名 n）中相应列的新地址：
=> UPDATE result_table r
SET address=n.new_address
FROM new_addresses n
WHERE r.cust_id = n.new_cust_id;
result_table 显示了顾客 ID 20 和 30 的 address 字段更新：
=> SELECT * FROM result_table ORDER BY cust_id;
cust_id | address
---------+------------------
20 | Infinite Loop
30 | Loop Infinite
30 | Loop Infinite
40 | Mt. Vernon Street
50 | Hillside Avenue
(5 rows)
不能使用 UPDATE 更新原生数组的单个元素。只能替换整个数组值。以下示例使用 ARRAY_CAT 将元素添加到数组列：
=> SELECT * FROM singers;
lname | fname | bands
--------+-------+---------------------------------------------
Cher | | ["Sonny and Cher"]
Jagger | Mick | ["Rolling Stones"]
Slick | Grace | ["Jefferson Airplane","Jefferson Starship"]
(3 rows)
=> UPDATE singers SET bands=ARRAY_CAT(bands,ARRAY['something new'])
WHERE lname='Cher';
OUTPUT
--------
1
(1 row)
=> SELECT * FROM singers;
lname | fname | bands
--------+-------+---------------------------------------------
Jagger | Mick | ["Rolling Stones"]
Slick | Grace | ["Jefferson Airplane","Jefferson Starship"]
Cher | | ["Sonny and Cher","something new"]
(3 rows)