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

返回本页常规视图.

管理函数

Vertica 具有管理数据库操作各个方面的函数，例如会话、权限、投影和编录。

1 - 编录函数

此部分包含特定于 Vertica 的编录管理函数。

1.1 - DROP_LICENSE

从全局编录中删除许可证密钥。删除过期的密钥是可选的。如果安装了有效的备用许可证密钥，Vertica 会自动忽略过期的许可证密钥。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_LICENSE( 'license-name' )

参数

license‑name
要删除的许可证的名称。使用系统表 LICENSES 的 NAME 列中的名称（或长许可证密钥）。

超级用户

示例

=> SELECT DROP_LICENSE('9b2d81e2-aab1-4cfb-bc07-fa9a696e8f5e');

另请参阅

管理许可证

1.2 - DUMP_CATALOG

返回 Vertica 编录的内部表示。此函数用于诊断目的。

DUMP_CATALOG 仅返回用户可见的对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_CATALOG()

特权

无

示例

以下查询获取 Vertica 编录的内部表示：

=> SELECT DUMP_CATALOG();

输出写入指定文件：

\o /tmp/catalog.txt
SELECT DUMP_CATALOG();
\o

1.3 - EXPORT_CATALOG

生成 SQL 脚本，从而在其他群集上重新创建物理架构设计。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

  • 如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_CATALOG ( [ '[destination]' [, 'scope'] ] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串，将脚本写入标准输出。

  • SQL 输出文件的路径和名称，仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
确定要导出的内容。在指定范围内，EXPORT_CATALOG 导出您有权访问的所有对象：

  • DESIGN：导出所有编录对象，包括架构、表、约束、视图、访问策略、投影、SQL 宏和存储过程。

  • DESIGN_ALL：已弃用。

  • TABLES：导出所有表及其访问策略。另请参阅 EXPORT_TABLES。

  • DIRECTED_QUERIES：导出所有存储在数据库中的定向查询。有关详细信息，请参阅管理定向查询。

默认值： DESIGN

特权

无

示例

请参阅导出编录。

另请参阅

1.4 - EXPORT_OBJECTS

生成一个 SQL 脚本，可用于在其他群集上重新创建非虚拟编录对象。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

  • 如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_OBJECTS( ['[destination]' [, '[scope]'] [, 'mark-ksafe']] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串 ('') 将脚本写入标准输出。

  • SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
指定要导出为逗号分隔列表的一个或多个对象： 
{ [database.]schema[.object] | [[database.]schema]object }[,...]

  • 如果设置为空字符串，Vertica 会导出用户有权访问的所有对象。

  • 如果您仅指定一个架构，Vertica 会导出该架构中的所有对象。

  • 如果指定一个数据库，它必须是当前数据库。

mark-ksafe
Boolean 实参，指定生成的脚本是否调用 Vertica 函数 MARK_DESIGN_KSAFE。如果设置为 true（默认），MARK_DESIGN_KSAFE 为当前数据库使用正确的 K-safe 实参。

特权

无

示例

请参阅导出对象。

另请参阅

1.5 - EXPORT_TABLES

生成一个 SQL 脚本，可用于在其他群集上重新创建逻辑架构—架构、表、约束和视图。EXPORT_TABLES 仅导出用户有权访问的对象。

SQL 脚本符合以下要求：

  • 仅包括用户有权访问的对象。

  • 根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果一个表引用了一个命名序列，则 CREATE SEQUENCE 语句在 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EXPORT_TABLES( ['[destination]' [, '[scope]']] )

参数

destination
指定发送输出的位置，为以下之一：

  • 空字符串 ('') 将脚本写入标准输出。

  • SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。

scope
指定要导出的一个或多个表，如下所示： 
[database.]schema[.table][,...]
  • 如果设置为空字符串，Vertica 会导出您有权访问的所有非虚拟表对象，包括表架构、序列和约束。
  • 如果您指定架构，Vertica 会导出该架构中的所有非虚拟表对象。
  • 如果指定一个数据库，它必须是当前数据库。

特权

无

示例

请参阅导出表。

另请参阅

1.6 - INSTALL_LICENSE

在全局编录中安装许可证密钥。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INSTALL_LICENSE( 'filename' )

参数

filename
有效许可证文件的绝对路径名称。

超级用户

示例

=> SELECT INSTALL_LICENSE('/tmp/vlicense.dat');

另请参阅

管理许可证

1.7 - MARK_DESIGN_KSAFE

如果出现故障，在您的环境中启用或禁用高可用性。启用恢复以前， MARK_DESIGN_KSAFE 查询编录，确定群集物理模式设计是否满足下列要求：

  • 在所有节点上复制小的、未分段的表。

  • 大型表 超投影被分段，每个分段在不同的节点上。

  • 对于 K-safety=1，每个大型表投影至少有一个 伙伴实例投影（或者对于 K-safety=2，具有两个伙伴实例投影）。

    伙伴投影也在各数据库节点上进行分段，但对分配进行了修改，使包含相同数据的分段分配在不同节点上。请参阅使用投影的高可用性。

MARK_DESIGN_KSAFE 不改变物理架构。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MARK_DESIGN_KSAFE ( k )

参数

k
指定 K-safety 等级，是以下之一：

  • 2：如果架构设计满足 K-safety=2 的要求，则启用高可用性

  • 1：如果架构设计满足 K-safety=1 的要求，则启用高可用性

  • 0：禁用高可用性

超级用户

返回消息

如果您指定一个 1 或 2 的 k 值，Vertica 返回下列消息之一。

成功：

 Marked design n-safe

失败：

 The schema does not meet requirements for K=n.
 Fact table projection projection-name
 has insufficient "buddy" projections.

这里，n 是一个 K-safety 设置。

注意

  • 数据库内部恢复状态会在整个数据库启动过程中持续，但未在启动时检查。

  • 当标有 K-safe=1 的系统上的一个节点失败，其余节点仍可用于 DML 操作。

示例

=> SELECT MARK_DESIGN_KSAFE(1);
  mark_design_ksafe
----------------------
 Marked design 1-safe
(1 row)

如果物理模式设计不是 K-safe，消息显示不具有伙伴的投影：

=> SELECT MARK_DESIGN_KSAFE(1);
The given K value is not correct;
the schema is 0-safe
Projection pp1 has 0 buddies,
which is smaller that the given K of 1
Projection pp2 has 0 buddies,
which is smaller that the given K of 1
.
.
.
(1 row)

另请参阅

1.8 - RELOAD_ADMINTOOLS_CONF

更新群集中每个 UP 节点上的 admintools.conf。更新包括：

  • IP 地址和编录路径

  • 当前数据库中所有节点的节点名称

此函数提供了一种手动方法来指示服务器更新所有 UP 节点上的 admintools.conf。例如，如果您重启一个节点，调用此函数来确认它的 admintools.conf 文件是准确的。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELOAD_ADMINTOOLS_CONF()

特权

超级用户

示例

更新群集中每个 UP 节点上的 admintools.conf：

=> SELECT RELOAD_ADMINTOOLS_CONF();
  RELOAD_ADMINTOOLS_CONF
--------------------------
 admintools.conf reloaded
(1 row)

2 - 云函数

此部分包含管理云集成的函数。对于 HDFS，另请参阅 Hadoop 函数。

2.1 - AZURE_TOKEN_CACHE_CLEAR

清除 Azure 的缓存访问令牌。在更改 Azure 托管身份的配置后调用此函数。

Azure 对象存储可以支持和管理多个身份。如果正在使用多个身份，Vertica 会查找键为 VerticaManagedIdentityClientId 的 Azure 标记，其值必须是要使用的托管身份的 client_id 属性。如果 Azure 配置发生变化，请使用此函数清除缓存。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AZURE_TOKEN_CACHE_CLEAR ( )

超级用户

3 - 群集函数

此部分包含管理大型分布式数据库群集上的 spread 部署的函数以及控制群集如何组织数据以进行重新平衡的函数。

3.1 - CANCEL_REBALANCE_CLUSTER

停止任何正在进行中或正在等待执行的重新平衡任务。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_REBALANCE_CLUSTER()

超级用户

示例

=> SELECT CANCEL_REBALANCE_CLUSTER();
 CANCEL_REBALANCE_CLUSTER
--------------------------
 CANCELED
(1 row)

另请参阅

3.2 - DISABLE_LOCAL_SEGMENTS

禁用本地数据分段，本地数据分段会将节点上的投影分段拆分至可轻松移动到其他节点上的容器中。有关详细信息，请参阅局部数据分段。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISABLE_LOCAL_SEGMENTS()

超级用户

示例

=> SELECT DISABLE_LOCAL_SEGMENTS();
 DISABLE_LOCAL_SEGMENTS
------------------------
 DISABLED
(1 row)

3.3 - ENABLE_LOCAL_SEGMENTS

启用本地存储分段，本地存储分段可以将节点上的投影分段拆分到可以轻松移动至其他节点的容器中。有关详细信息，请参阅局部数据分段。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLE_LOCAL_SEGMENTS()

超级用户

示例

=> SELECT ENABLE_LOCAL_SEGMENTS();
 ENABLE_LOCAL_SEGMENTS
-----------------------
 ENABLED
(1 row)

3.4 - ENABLE_ELASTIC_CLUSTER

启用弹性群集调整，通过将一个节点的数据分段至可以轻松移动至其他主机的区块中，弹性群集调整可更为有效地扩大或缩小数据库群集的大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLE_ELASTIC_CLUSTER()

超级用户

示例

=> SELECT ENABLE_ELASTIC_CLUSTER();
 ENABLE_ELASTIC_CLUSTER
------------------------
 ENABLED
(1 row)

3.5 - REALIGN_CONTROL_NODES

启用大型群集时，使得 Vertica 重新评估群集或子群集中的哪些节点为 控制节点，以及哪些节点被分配给它们作为从属节点。在更改企业模式数据库中的故障组或更改任一数据库模式中的控制节点数后调用此函数。调用此函数后，查询 V_CATALOG.CLUSTER_LAYOUT 系统表以查看建议的群集中节点的新布局。在新的控制节点分配生效之前，您还必须采取其他步骤。有关详细信息，请参阅更改控制节点的数量并重新对齐。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

在 ** Enterprise 模式 下：**

REALIGN_CONTROL_NODES()

在 ** Eon 模式 下：**

REALIGN_CONTROL_NODES('subcluster_name')

参数

subcluster_name
要在其中重新调整控制节点的子群集的名称。只有该子群集中的节点受到影响。其他子群集不受影响。仅当数据库在 Eon 模式下运行时才允许。

特权

超级用户

示例

在 Enterprise 模式数据库中，从所有节点中选择控制节点，并将剩余节点分配给一个控制节点：

=> SELECT REALIGN_CONTROL_NODES();

在 Eon 模式数据库中，重新评估名为 analytics 的子群集中的控制节点分配：

=> SELECT REALIGN_CONTROL_NODES('analytics');

另请参阅

3.6 - REBALANCE_CLUSTER

一个会话前台任务，将同步重新平衡数据库群集。REBALANCE_CLUSTER 仅在重新平衡操作完成后返回。如果当前会话结束，则操作立即中止。要将群集重新平衡为后台任务，请调用 START_REBALANCE_CLUSTER()。

在大型群集排列中，您通常在流中调用 REBALANCE_CLUSTER（请参阅更改控制节点的数量并重新对齐）。在更改控制节点（spread 主机）的数量和分布后，运行 REBALANCE_CLUSTER 以实现容错。

有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_CLUSTER()

超级用户

示例

=> SELECT REBALANCE_CLUSTER();
REBALANCE_CLUSTER
-------------------
 REBALANCED
(1 row)

3.7 - RELOAD_SPREAD

更新对编录的 Spread 配置文件的群集更改。这些更改包括：

  • 新的或重新调整的控制节点

  • 新的 Spread 主机或容错组

  • 新的或删除的群集节点

此函数通常在多步进程中用于较大的弹性群集排列。调用此函数可能需要您重新启动数据库。然后，您必须重新平衡群集以实现容错。有关详细信息，请参阅定义和重新调整控制节点。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELOAD_SPREAD( true )

参数

true
将与控制消息责任相关的群集更改更新到 Spread 配置文件。

特权

超级用户

示例

使用更改来更新群集以控制消息传送：

=> SELECT reload_spread(true);
 reload_spread
---------------
 reloaded

(1 row)

另请参阅

REBALANCE_CLUSTER

3.8 - SET_CONTROL_SET_SIZE

设置启用大型群集时参与 spread 服务的 控制节点数。如果数据库在 Enterprise 模式下运行，该函数设置整个数据库群集的控制节点数。如果数据库在 Eon 模式下运行，则此函数设置您指定的子群集中的控制节点数。有关详细信息，请参阅大型群集。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

在 Enterprise 模式下：

SET_CONTROL_SET_SIZE( control_nodes )

在 Eon 模式下：

SET_CONTROL_SET_SIZE('subcluster_name', control_nodes )

参数

subcluster_name
要在其中设置控制节点数的子群集的名称。仅当数据库在 Eon 模式下运行时才允许。
control_nodes
分配给群集（在 Enterprise 模式下）或子群集（在 Eon 模式下）的控制节点数。值可以是以下之一：

  • 正整数值：Vertica 将您指定的控制节点数分配给群集或子群集。该值可以大于当前节点数。该值不能大于 120（数据库的最大控制节点数）。在 Eon 模式下，该值加上为所有其他子群集设置的控制节点数的总和不能超过 120。

  • -1：使群集或子群集中的每个节点都成为控制节点。该值可有效禁用群集或子群集的大型群集。

特权

超级用户

示例

在 Enterprise 模式数据库中，将整个群集的控制节点数设置为 5：

=> SELECT set_control_set_size(5);
 SET_CONTROL_SET_SIZE
----------------------
 Control size set
(1 row)

另请参阅

3.9 - SET_SCALING_FACTOR

设置比例因子，比例因子决定在重新平衡数据库和启用了使用局部数据分段时，所使用的存储容器数量。有关详细信息，请参阅群集扩展。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_SCALING_FACTOR( factor )

参数

factor
1 至 32 之间的整数值。Vertica 使用此值来计算进行重新平衡或启用了局部数据分段时，每个投影分解到多少个存储容器中。

超级用户

最佳实践

比例因子决定了在启用局部分段时，Vertica 在重新平衡期间用于跨数据库存储每个投影的存储容器的数量。在设置比例因子时，请遵循以下准则：

  • 存储容器的数量应大于或等于分区数量与本地分段数量的积：

    num‑storage‑containers >= ( num‑partitions * num‑local‑segments )

  • 若将比例因子设置得足够高，以便重新平衡可以传输本地分段以满足偏移阈值，但将值设置得很小，以便存储容器数量将不会产生过多的 ROS 容器，并导致 ROS 推回）。ROS 容器的最大数量（默认为 1024）由配置参数 ContainersPerProjectionLimit 设置。

示例

=> SELECT SET_SCALING_FACTOR(12);
 SET_SCALING_FACTOR
--------------------
 SET
(1 row)

3.10 - START_REBALANCE_CLUSTER()

一个后台任务，异步重新平衡数据库群集。此函数在重新平衡操作完成后立即返回。即使您关闭当前会话或数据库关闭，重新平衡也会持续到操作完成。在关闭的情况下，重新平衡会在群集重新启动后恢复。要停止重新平衡操作，请调用 CANCEL_REBALANCE_CLUSTER。

有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REBALANCE_CLUSTER()

超级用户

示例

=> SELECT START_REBALANCE_CLUSTER();
 START_REBALANCE_CLUSTER
-------------------------
 REBALANCING
(1 row)

另请参阅

REBALANCE_CLUSTER

4 - 数据收集器函数

Vertica 数据收集器是一款实用程序，通过提供记录事件的框架来扩展系统表的功能。该实用程序收集并保留有关数据库群集的监控信息，同时在系统表中提供这些信息，需要的配置参数调整很少，对性能的影响微乎其微。

收集的数据存储在磁盘 Vertica/catalog 路径下的 DataCollector 目录中。可使用数据收集器所保留的信息查询系统表的过去状态并提取聚合信息，还可以执行以下操作：

  • 查看用户已采取哪些操作

  • 找出性能瓶颈

  • 确定 Vertica 配置的潜在改进

数据收集器与名为工作负载分析器的顾问工具搭配使用，后者可以智能监控 SQL 查询和工作负载的性能，并通过观察实际工作负载的历史记录来建议优化操作。

默认情况下，数据收集器处于开启状态并保留所有会话的信息。如果出现性能问题，超级用户可以通过将设置配置参数 EnableDataCollector 设置为 0 来禁用数据收集器。

4.1 - CLEAR_DATA_COLLECTOR

从数据收集器表和日志中清除所有内存及磁盘记录，并重置系统表 DATA_COLLECTOR 中的收集统计信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DATA_COLLECTOR( [ 'component' ] )

参数

component
清除指定组件的内存和磁盘记录。如果您未提供实参，则该函数将清除所有组件的内存和磁盘记录。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

超级用户

示例

以下命令将清除 ResourceAcquisitions 组件的内存和磁盘记录：

=> SELECT clear_data_collector('ResourceAcquisitions');
 clear_data_collector
----------------------
 CLEAR
(1 row)

以下命令将清除所有组件的数据收集：

=> SELECT clear_data_collector();
 clear_data_collector
----------------------
 CLEAR
(1 row)

另请参阅

数据收集器实用程序

4.2 - DATA_COLLECTOR_HELP

返回有关数据收集器、 DATA_COLLECTOR 系统表和数据收集器控制函数的在线使用说明。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DATA_COLLECTOR_HELP()

特权

无

返回

DATA_COLLECTOR_HELP() 函数将返回以下信息：

=> SELECT DATA_COLLECTOR_HELP();

-----------------------------------------------------------------------------
Usage Data Collector
The data collector retains history of important system activities.
   This data can be used as a reference of what actions have been taken
      by users, but it can also be used to locate performance bottlenecks,
      or identify potential improvements to the Vertica configuration.
   This data is queryable via Vertica system tables.

Acccess a list of data collector components, and some statistics, by running:
   SELECT * FROM v_monitor.data_collector;

The amount of data retained by size and time can be controlled with several
functions.
   To just set the size amount:
      set_data_collector_policy(<component>,
                                <memory retention (KB)>,
                                <disk retention (KB)>);

   To set both the size and time amounts (the smaller one will dominate):
      set_data_collector_policy(<component>,
                                <memory retention (KB)>,
                                <disk retention (KB)>,
                                <interval>);

   To set just the time amount:
      set_data_collector_time_policy(<component>,
                                     <interval>);

   To set the time amount for all tables:
      set_data_collector_time_policy(<interval>);

The current retention policy for a component can be queried with:
   get_data_collector_policy(<component>);

Data on disk is kept in the "DataCollector" directory under the Vertica
\catalog path. This directory also contains instructions on how to load
the monitoring data into another Vertica database.

To move the data collector logs and instructions to other storage locations,
create labeled storage locations using add_location and then use:

   set_data_collector_storage_location(<storage_label>);

Additional commands can be used to configure the data collection logs.

The log can be cleared with:

clear_data_collector([<optional component>]);

The log can be synchronized with the disk storage using:

flush_data_collector([<optional component>]);

另请参阅

4.3 - FLUSH_DATA_COLLECTOR

等待内存日志移至磁盘后，刷新数据收集器，同时将日志与磁盘存储同步。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FLUSH_DATA_COLLECTOR( [ 'component' ] )

参数

component
刷新指定组件的数据。如果忽略此实参，则函数将刷新所有组件的数据。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

超级用户

示例

以下命令刷新 ResourceAcquisitions 组件的数据收集器。

=> SELECT flush_data_collector('ResourceAcquisitions');
 flush_data_collector
----------------------
 FLUSH
(1 row)

以下命令刷新所有组件的数据收集器。

=> SELECT flush_data_collector();
 flush_data_collector
----------------------
 FLUSH
(1 row)

另请参阅

数据收集器实用程序

4.4 - GET_DATA_COLLECTOR_POLICY

检索与指定组件的保留政策有关的简短声明。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_DATA_COLLECTOR_POLICY( 'component' )

参数

component
返回指定组件的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

特权

无

示例

以下查询通过指定 ResourceAcquisitions 组件返回所有资源获取的历史记录。

=> SELECT get_data_collector_policy('ResourceAcquisitions');
          get_data_collector_policy
----------------------------------------------
 1000KB kept in memory, 10000KB kept on disk.
(1 row)

另请参阅

4.5 - SET_DATA_COLLECTOR_POLICY

更新指定组件的以下保留策略属性：

  • MEMORY_BUFFER_SIZE_KB

  • DISK_SIZE_KB

  • INTERVAL_TIME

在更改保留策略之前，可通过查询系统表 DATA_COLLECTOR 或调用元函数 GET_DATA_COLLECTOR_POLICY 查看其当前设置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_POLICY('component', 'memory‑buffer‑size', 'disk‑size' [,'interval‑time']  )

参数

component
指定要更新的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
memory‑buffer‑size
指定在将数据移动到磁盘之前在内存中缓冲的最大数据量（以 KB 为单位）。策略保留策略属性 MEMORY_BUFFER_SIZE_KB 根据此值进行设置。

在以下情况下，请考虑将此参数设置为较高的值：

  • 异常高级别的数据收集。如果将 memory‑buffer‑size 设置为过低的值，数据收集器可能无法以足够快的速度将缓冲数据刷新到磁盘以与活动级别保持一致，这可能会导致内存中的数据丢失。

  • 非常大的数据收集器记录 — 例如，具有非常长的查询字符串的记录。数据收集器使用双缓冲，因此它无法在内存中保留比 memory‑buffer‑size 大 50% 以上的记录。

disk‑size
指定为此组件的数据收集器表分配的最大磁盘空间（以 KB 为单位）。策略保留策略属性 DISK_SIZE_KB 根据此值进行设置。如果设置为 0，数据收集器将仅保留其可以在内存中缓冲的组件数据，大小由 memory‑buffer‑size 指定。
interval‑time

INTERVAL 一种数据类型，用于指定给定组件的数据在该组件的数据收集器表中保留的时间。保留策略属性 INTERVAL_TIME 是根据该值设置的。如果将此参数设置为正值，它还会将策略属性 INTERVAL_SET 更改为 t (true)。

例如，如果指定组件 TupleMoverEvents 并将 interval-time 设置为两天的时间间隔 ('2 days'::interval)，则数据收集器 dc_tuple_mover_events 会保留过去 48 小时的 Tuple Mover 活动记录。旧 Tuple Mover 数据会自动从该表中删除。

要禁用 INTERVAL_TIME 策略属性，请将此参数设置为负整数。这样做会将两个保留策略属性恢复为其默认设置：

  • INTERVAL_SET：f

  • INTERVAL_TIME：0

如此设置这两个属性后，组件的数据收集器表将保留所有组件事件的数据，直到达到其最大限制，如保留策略属性 DISK_SIZE_KB 设置的那样。

超级用户

示例

请参阅配置数据保留策略。

4.6 - SET_DATA_COLLECTOR_TIME_POLICY

更新指定组件的保留策略属性 INTERVAL_TIME。调用此函数不会影响同一组件的其他属性。您可以使用此函数更新所有组件保留策略的 INTERVAL_TIME 属性。

要设置其他保留策略属性，请调用 SET_DATA_COLLECTOR_POLICY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_TIME_POLICY( ['component',] 'interval‑time' )

参数

component
指定要更新的保留策略。如果忽略此实参，Vertica 会更新所有数据收集器组件的保留策略。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
interval‑time

INTERVAL 一种数据类型，用于指定给定组件的数据在该组件的数据收集器表中保留的时间。保留策略属性 INTERVAL_TIME 是根据该值设置的。如果将此参数设置为正值，它还会将策略属性 INTERVAL_SET 更改为 t (true)。

例如，如果指定组件 TupleMoverEvents 并将 interval-time 设置为两天的时间间隔 ('2 days'::interval)，则数据收集器 dc_tuple_mover_events 会保留过去 48 小时的 Tuple Mover 活动记录。旧 Tuple Mover 数据会自动从该表中删除。

要禁用 INTERVAL_TIME 策略属性，请将此参数设置为负整数。这样做会将两个保留策略属性恢复为其默认设置：

  • INTERVAL_SET：f

  • INTERVAL_TIME：0

如此设置这两个属性后，组件的数据收集器表将保留所有组件事件的数据，直到达到其最大限制，如保留策略属性 DISK_SIZE_KB 设置的那样。

超级用户

示例

请参阅配置数据保留策略。

5 - 数据库函数

此部分包含特定于 Vertica 的数据库管理函数。

5.1 - CLEAR_RESOURCE_REJECTIONS

清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容。通常，只能在节点重新启动期间清除这些表。通过此函数，您可以在需要时随时清除这些表。例如，您可能想在解决导致磁盘资源拒绝的磁盘空间问题后清除系统表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

不可变

语法

CLEAR_RESOURCE_REJECTIONS();

超级用户

示例

以下命令可以清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容：

=> SELECT clear_resource_rejections();
clear_resource_rejections
---------------------------
 OK
(1 row)

另请参阅

5.2 - COMPACT_STORAGE

将现有数据 (.fdb) 和索引 (.pidx) 文件捆绑为 .gt 文件格式。默认情况下，为使用 7.2 或更高版本创建的数据文件启用 .gt 格式。如果要升级早期版本的数据库，请使用 COMPACT_STORAGE 将存储文件捆绑为 .gt 格式。您的数据库可以继续以混合文件存储格式运行。

如果为 COMPACT_STORAGE 指定的设置与在配置参数 MaxBundleableROSSizeKB 中指定的限值不同，则 Vertica 不会更改自动创建的捆绑包的大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT COMPACT_STORAGE ('[[[database.]schema.]object‑name]', min‑ros‑filesize‑kb, 'small‑or‑all‑files', 'simulate');

参数

[database.]schema

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

object‑name
指定要捆绑的表或投影。如果设置为空字符串，COMPACT_STORAGE 将评估数据库中所有投影的数据以进行捆绑。
min‑ros‑filesize‑kb
整数 ≥ 1，指定独立 ROS 文件的最小大小（以 KB 为单位）。COMPACT_STORAGE 可将低于此大小的存储容器 ROS 文件捆绑成一个文件。
small‑or‑all‑files
以下几项之一：

  • small：仅捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件

  • all：捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件，并捆绑大型存储容器的 .fdb 和 .pidx 文件。

simulate
指定是否模拟存储设置并生成描述这些设置的影响的报告。

  • true：生成有关指定捆绑包设置（未实际捆绑存储文件）的影响的报告。

  • false：按指定执行捆绑。

特权

超级用户

存储和性能影响

捆绑可使文件系统中的文件数至少减少 50%，并提高文件密集型操作的性能。增强的操作包括备份、还原以及合并。

Vertica 创建小文件的原因包括以下几点：

  • 表包含数百列。

  • 分区范围较小（按分钟分区）。

  • 启用了局部分段且系数设置为较高的值。

示例

以下示例描述了捆绑表 EMPLOYEES 的影响：

=> SELECT COMPACT_STORAGE('employees', 1024,'small','true');
Task: compact_storage

On node v_vmart_node0001:
Projection Name :public.employees_b0 | selected_storage_containers :0 |
selected_files_to_compact :0 | files_after_compact : 0 | modified_storage_KB :0

On node v_vmart_node0002:
Projection Name :public.employees_b0 | selected_storage_containers :1 |
selected_files_to_compact :6 | files_after_compact : 1 | modified_storage_KB :0

On node v_vmart_node0003:
Projection Name :public.employees_b0 | selected_storage_containers :2 |
selected_files_to_compact :12 | files_after_compact : 2 | modified_storage_KB :0

On node v_vmart_node0001:
Projection Name :public.employees_b1 | selected_storage_containers :2 |
selected_files_to_compact :12 | files_after_compact : 2 | modified_storage_KB :0

On node v_vmart_node0002:
Projection Name :public.employees_b1 | selected_storage_containers :0 |
selected_files_to_compact :0 | files_after_compact : 0 | modified_storage_KB :0

On node v_vmart_node0003:
Projection Name :public.employees_b1 | selected_storage_containers :1 |
selected_files_to_compact :6 | files_after_compact : 1 | modified_storage_KB :0

Success

(1 row)

5.3 - DUMP_LOCKTABLE

返回关于死锁的客户端及其等待的资源的信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_LOCKTABLE()

特权

无

注意

如果 Vertica 失去响应，请使用 DUMP_LOCKTABLE：

  1. 打开其他 vsql 连接。

  2. 执行查询：

    => SELECT DUMP_LOCKTABLE();

    输出被写入到 vsql。请参阅监控日志文件。

您还可以使用以下命令查看连接方：

=> SELECT * FROM SESSIONS;

使用以下命令关闭所有会话：

=> SELECT CLOSE_ALL_SESSIONS();

使用以下命令关闭单个会话：

=> SELECT CLOSE_SESSION('session_id');

您可以从 V_MONITOR.SESSIONS 系统表中获取到 session_id 值。

另请参阅

5.4 - DUMP_PARTITION_KEYS

转储系统中所有投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_PARTITION_KEYS( )

特权

用户必须具有表的选择权限或架构的使用权限。

示例

=> SELECT DUMP_PARTITION_KEYS( );
Partition keys on node v_vmart_node0001
  Projection 'states_b0'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: NH
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: MA
  Projection 'states_b1'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: VT
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: ME
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: CT

另请参阅

5.5 - GET_CONFIG_PARAMETER

获取指定级别的配置参数的值。如果在该级别未设置任何值，此函数将返回一个空行。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_CONFIG_PARAMETER( 'parameter-name' [, 'level' | NULL] )

参数

parameter‑name
要获取的配置参数值的名称。
级别
要获取的 parameter‑name 设置的级别，为以下字符串值之一：

  • user：当前用户

  • session：当前会话

  • node-name：数据库节点的名称

如果 level 被忽略或设置为 NULL，则 GET_CONFIG_PARAMETER 将返回数据库设置。

特权

无

示例

获取数据库级别的 AnalyzeRowCountInterval 参数：

=> SELECT GET_CONFIG_PARAMETER ('AnalyzeRowCountInterval');
 GET_CONFIG_PARAMETER
----------------------
 3600

获取会话级别的 MaxSessionUDParameterSize 参数：

=> SELECT GET_CONFIG_PARAMETER ('MaxSessionUDParameterSize','session');
 GET_CONFIG_PARAMETER
----------------------
 2000
(1 row)

获取用户级别的 UseDepotForReads 参数：

=> SELECT GET_CONFIG_PARAMETER ('UseDepotForReads', 'user');
 GET_CONFIG_PARAMETER
----------------------
 1
(1 row)

另请参阅

5.6 - KERBEROS_CONFIG_CHECK

测试 Vertica 群集的 Kerberos 配置。如果此函数可以同时使用 keytab 文件和当前用户的凭据调用 kinit，则此函数将成功，否则将报告错误。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

KERBEROS_CONFIG_CHECK( )

参数

此函数没有参数。

特权

此函数不需要权限。

示例

以下示例显示了 Kerberos 配置有效时的结果。

=> SELECT KERBEROS_CONFIG_CHECK();
    kerberos_config_check
-----------------------------------------------------------------------------
 ok: krb5 exists at [/etc/krb5.conf]
 ok: Vertica Keytab file is set to [/etc/vertica.keytab]
 ok: Vertica Keytab file exists at [/etc/vertica.keytab]
[INFO] KerberosCredentialCache [/tmp/vertica_D4/vertica450676899262134963.cc]
 Kerberos configuration parameters set in the database
        KerberosServiceName : [vertica]
        KerberosHostname : [data.hadoop.com]
        KerberosRealm : [EXAMPLE.COM]
        KerberosKeytabFile : [/etc/vertica.keytab]
 Vertica Principal: [vertica/data.hadoop.com@EXAMPLE.COM]
 [OK] Vertica can kinit using keytab file
 [OK] User [bob] has valid client authentication for kerberos principal [bob@EXAMPLE.COM]]

(1 row)

5.7 - MEMORY_TRIM

调用 glibc 函数 malloc_trim()，以从 malloc 中回收可用内存并将其返回给操作系统。删除操作的详细信息将被写入系统表 MEMORY_EVENTS。

除非关闭内存轮询，否则 Vertica 会自动检测 glibc 在其分配区域中积累过量可用内存的情况。发生这种情况时，Vertica 会整合大部分内存并将其返回给操作系统。如果禁用内存轮询并希望手动减少 glibc 分配的内存，请调用此函数。

有关详细信息，请参阅内存修剪。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MEMORY_TRIM()

特权

超级用户

示例

=> SELECT memory_trim();
                           memory_trim
-----------------------------------------------------------------
 Pre-RSS: [378822656] Post-RSS: [372129792] Benefit: [0.0176675]
(1 row)

5.8 - RUN_INDEX_TOOL

在 Vertica 数据库上运行索引工具以执行以下任务之一：

  • 对数据存储运行每块循环冗余检查 (CRC)，以验证数据完整性。

  • 检查 ROS 容器中的排列顺序是否正确。

此函数会将有关其操作的摘要信息写入标准输出；将结果的详细信息记录在当前节点的 vertica.log 中。有关评估工具输出的详细信息，请参阅：

您还可以通过 Linux 命令行对已关闭的数据库运行索引工具。有关详细信息，请参阅CRC 和排序顺序检查。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RUN_INDEX_TOOL ( 'taskType', global, '[projFilter]' [, numThreads ] );

参数

taskType
指定要运行的操作，为以下之一：

  • checkcrc：对现有数据存储上的每个块运行循环冗余检查 (CRC)，以检查 ROS 数据块的数据完整性。

  • checksort：评估每个 ROS 行，以确定其排序是否正确。如果 ROS 数据未按投影的顺序正确排序，则依赖于已排序数据的查询结果就会不正确。

global
布尔值，指定在所有节点 (true) 还是当前节点 (false) 上运行指定任务。
projFilter
指定操作的范围：

  • 空字符串 ('')：对所有投影运行检查。

  • 一个字符串，指定一个或多个投影，如下所示：

    • projection‑name：对此投影运行检查

    • projection‑prefix*：对所有以字符串 projection‑prefix 开头的投影运行检查。

numThreads
一个无符号（正）或带符号（负）整数，指定用于运行此操作的线程数：

  • n：线程数，≥1

  • -n：负整数，表示所有 CPU 内核的一部分，如下所示：

    num‑cores / n

    因此，-1 表示所有内核，-2 表示一半内核，-3 表示所有内核的三分之一，依此类推。

    默认值： 1

特权

超级用户

优化性能

您可以通过设置以下两个参数来优化元函数性能：

  • projFilter：将操作范围缩小到一个或多个投影。

  • numThreads：指定用于执行函数的线程数。

5.9 - PURGE

从 ROS 存储容器中永久移除删除向量，以便可以重新使用磁盘空间。 PURGE 移除 Ancient History Mark 时期（含）之前的所有历史数据。

PURGE 不会删除临时表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SELECT PURGE()

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

从 Vertica 表中删除数据后，该数据将被标记为删除。要查看标记为待删除的数据，请查询 DELETE_VECTORS 系统表。

运行 PURGE 以从 ROS 容器中移除删除向量。

=> SELECT * FROM test1;
 number
--------
      3
     12
     33
     87
     43
     99
(6 rows)

=> DELETE FROM test1 WHERE number > 50;
 OUTPUT
--------
      2
(1 row)

=> SELECT * FROM test1;
 number
--------
     43
      3
     12
     33
(4 rows)
=> SELECT node_name, projection_name, deleted_row_count FROM DELETE_VECTORS;
    node_name     | projection_name | deleted_row_count
------------------+-----------------+-------------------
 v_vmart_node0002 | test1_b1        |                 1
 v_vmart_node0001 | test1_b1        |                 1
 v_vmart_node0001 | test1_b0        |                 1
 v_vmart_node0003 | test1_b0        |                 1
(4 rows)

=> SELECT PURGE();
...
(Table: public.test1) (Projection: public.test1_b0)
(Table: public.test1) (Projection: public.test1_b1)
...
(4 rows)

Ancient History Mark (AHM) 推进后：

=> SELECT * FROM DELETE_VECTORS;
 (No rows)

另请参阅

5.10 - SECURITY_CONFIG_CHECK

返回各种安全相关参数的状态。使用此函数可验证您的 TLS 配置的完整性。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SECURITY_CONFIG_CHECK( 'db-component' )

参数

db-component
要检查的组件。目前，NETWORK 是唯一受支持的组件。

NETWORK：返回 spread 加密、节点间 TLS 和客户端-服务器 TLS 的状态和参数。

示例

在此示例中，SECURITY_CONFIG_CHECK 显示已禁用 spread 加密和数据通道 TLS，因为 EncryptSpreadComm 已禁用且未配置 data_channel TLS CONFIGURATION。

同样，客户端-服务器 TLS 也被禁用，因为 TLS CONFIGURATION“服务器”具有服务器证书，但其 TLSMODE 被禁用。将 TLSMODE 设置为“Enable”可启用服务器模式客户端-服务器 TLS。有关详细信息，请参阅TLS 协议。

=> SELECT SECURITY_CONFIG_CHECK('NETWORK');
                                            SECURITY_CONFIG_CHECK
----------------------------------------------------------------------------------------------------------------------
Spread security details:
* EncryptSpreadComm = []
Spread encryption is disabled
It is NOT safe to set/change other security config parameters while spread is not encrypted!
Please set EncryptSpreadComm to enable spread encryption first

Data Channel security details:
 TLS Configuration 'data_channel' TLSMODE is DISABLE
TLS on the data channel is disabled
Please set EncryptSpreadComm and configure TLS Configuration 'data_channel' to enable TLS on the data channel

Client-Server network security details:
* TLS Configuration 'server' TLSMODE is DISABLE
* TLS Configuration 'server' has a certificate set
Client-Server TLS is disabled
To enable Client-Server TLS set a certificate on TLS Configuration 'server' and/or set the tlsmode to 'ENABLE' or higher

(1 row)

另请参阅

5.11 - SET_CONFIG_PARAMETER

在指定级别设置或清除配置参数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_CONFIG_PARAMETER( 'param‑name', { param‑value | NULL}, ['level'| NULL])

参数

param‑name
要设置的配置参数的名称。
param‑value
要为 param‑name 设置的值，可以是字符串，也可以是整数。如果是字符串，则用单引号括起来；如果是整数，则单引号是可选的。

要在指定级别清除 param‑name，请将其设置为 NULL。

级别
要设置 param‑name 的级别，为以下字符串值之一：

  • user：当前用户。

  • session：当前会话，将覆盖数据库设置。

  • node-name：数据库节点的名称，将覆盖会话和数据库设置。

如果 level 被忽略或设置为 NULL，则会在数据库级别设置 param‑name。

特权

超级用户

示例

在数据库级别将 AnalyzeRowCountInterval 参数设置为 3600：

=> SELECT SET_CONFIG_PARAMETER('AnalyzeRowCountInterval',3600);
    SET_CONFIG_PARAMETER
----------------------------
 Parameter set successfully
(1 row)

在会话级别将 MaxSessionUDParameterSize 参数设置为 2000。

=> SELECT SET_CONFIG_PARAMETER('MaxSessionUDParameterSize',2000,'SESSION');
    SET_CONFIG_PARAMETER
----------------------------
 Parameter set successfully
(1 row)

另请参阅

5.12 - SET_SPREAD_OPTION

更改 spread 守护程序设置。此函数主要用于设置 spread 假设节点出现故障之前的超时。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_SPREAD_OPTION( option‑name, option‑value )

参数

option‑name
包含要更改的 spread 守护程序设置的字符串。

目前，此函数仅支持一个选项： TokenTimeout. 此设置控制 spread 在假设消息丢失之前等待节点响应消息的时间。有关详细信息，请参阅调整虚拟环境的 Spread 守护程序超时。

option‑value
option‑name 的新设置。

示例

=> SELECT SET_SPREAD_OPTION( 'TokenTimeout', '35000');
NOTICE 9003:  Spread has been notified about the change
                   SET_SPREAD_OPTION
--------------------------------------------------------
 Spread option 'TokenTimeout' has been set to '35000'.

(1 row)

=> SELECT * FROM V_MONITOR.SPREAD_STATE;
    node_name     | token_timeout
------------------+---------------
 v_vmart_node0001 |         35000
 v_vmart_node0002 |         35000
 v_vmart_node0003 |         35000
(3 rows);

另请参阅

5.13 - SHUTDOWN

关闭 Vertica 数据库。默认情况下，如果有任何用户连接，则关闭失败。您可以在 vertica.log 文件中查看关闭操作的状态。

在 Eon 模式下，您可以调用 SHUTDOWN_WITH_DRAIN 来执行优雅关闭，此操作会排空客户端连接，然后关闭数据库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN ( [ 'false' | 'true' ] )

参数

false
默认，如果用户已连接并中止关闭，则返回消息。
true
强制数据库关闭，以禁用其他连接。

超级用户

示例

以下命令尝试关闭数据库。由于用户已连接，命令失败：

=> SELECT SHUTDOWN('false');
NOTICE:  Cannot shut down while users are connected
          SHUTDOWN
-----------------------------
 Shutdown: aborting shutdown
(1 row)

另请参阅

SESSIONS

6 - Eon 模式函数

以下函数适用于 Eon 模式。

6.1 - ALTER_LOCATION_SIZE

仅限 Eon 模式

调整子群集中一个节点或所有节点或者数据库中所有节点的 存储库大小。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

不可变

语法

ALTER_LOCATION_SIZE( 'location', '[target]', 'size')

参数

location
指定要调整大小的位置，为以下之一：

  • depot：调整节点当前存储库的大小。

  • 存储库在 Linux 文件系统中的绝对路径。如果更改多个节点上的存储库大小并指定路径，则所有受影响节点上的路径必须相同。默认情况下，并非如此，因为节点的名称通常是此路径。例如，verticadb 数据库中节点 1 的默认存储库路径为 /vertica/data/verticadb/v_verticadb_node0001_depot。

目标值
要更改存储库的一个或多个节点，为以下之一：

  • 节点名称：调整指定节点的大小。

  • 子群集名称：调整指定子群集中所有节点的存储库大小。

  • 空字符串：调整数据库中所有存储库的大小。

size

仅当存储位置使用类型设置为 DEPOT 时才有效，指定存储库可以从存储位置的文件系统中分配的最大磁盘空间量。

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

  • integer%：存储位置的磁盘大小所占的百分比。

  • integer{K|M|G|T}：以千字节、兆字节、千兆字节或太字节为单位的存储位置的磁盘大小。

特权

超级用户

示例

将所有节点的存储库大小增加到文件系统的 80%：

=> SELECT node_name, location_label, location_path, max_size, disk_percent FROM storage_locations WHERE location_usage = 'DEPOT' ORDER BY node_name;
    node_name     | location_label  |      location_path      |  max_size   | disk_percent
------------------+-----------------+-------------------------+-------------+--------------
 v_vmart_node0001 | auto-data-depot | /home/dbadmin/verticadb | 36060108800 | 70%
 v_vmart_node0002 | auto-data-depot | /home/dbadmin/verticadb | 36059377664 | 70%
 v_vmart_node0003 | auto-data-depot | /home/dbadmin/verticadb | 36060108800 | 70%
(3 rows)

=> SELECT alter_location_size('depot', '','80%');
 alter_location_size
---------------------
 depotSize changed.
(1 row)

=> SELECT node_name, location_label, location_path, max_size, disk_percent FROM storage_locations WHERE location_usage = 'DEPOT' ORDER BY node_name;
    node_name     | location_label  |      location_path      |  max_size   | disk_percent
------------------+-----------------+-------------------------+-------------+--------------
 v_vmart_node0001 | auto-data-depot | /home/dbadmin/verticadb | 41211552768 | 80%
 v_vmart_node0002 | auto-data-depot | /home/dbadmin/verticadb | 41210717184 | 80%
 v_vmart_node0003 | auto-data-depot | /home/dbadmin/verticadb | 41211552768 | 80%
(3 rows)

将 analytics 子群集中所有节点的存储库大小更改为文件系统大小的 75%：

=> SELECT subcluster_name, subclusters.node_name, storage_locations.max_size, storage_locations.disk_percent FROM subclusters INNER JOIN storage_locations ON subclusters.node_name = storage_locations.node_name WHERE storage_locations.location_usage='DEPOT';
  subcluster_name   |      node_name       |   max_size  | disk_percent
--------------------+----------------------+----------------------------
 default_subcluster | v_verticadb_node0001 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0002 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0003 | 25264737485 | 60%
 analytics          | v_verticadb_node0004 | 25264737485 | 60%
 analytics          | v_verticadb_node0005 | 25264737485 | 60%
 analytics          | v_verticadb_node0006 | 25264737485 | 60%
 analytics          | v_verticadb_node0007 | 25264737485 | 60%
 analytics          | v_verticadb_node0008 | 25264737485 | 60%
 analytics          | v_verticadb_node0009 | 25264737485 | 60%
(9 rows)

=> SELECT ALTER_LOCATION_SIZE('depot','analytics','75%');
 ALTER_LOCATION_SIZE
---------------------
 depotSize changed.
(1 row)

=> SELECT subcluster_name, subclusters.node_name, storage_locations.max_size, storage_locations.disk_percent FROM subclusters INNER JOIN storage_locations ON subclusters.node_name = storage_locations.node_name WHERE storage_locations.location_usage='DEPOT';
  subcluster_name   |      node_name       |   max_size  | disk_percent
--------------------+----------------------+----------------------------
 default_subcluster | v_verticadb_node0001 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0002 | 25264737485 | 60%
 default_subcluster | v_verticadb_node0003 | 25264737485 | 60%
 analytics          | v_verticadb_node0004 | 31580921856 | 75%
 analytics          | v_verticadb_node0005 | 31580921856 | 75%
 analytics          | v_verticadb_node0006 | 31580921856 | 75%
 analytics          | v_verticadb_node0007 | 31580921856 | 75%
 analytics          | v_verticadb_node0008 | 31580921856 | 75%
 analytics          | v_verticadb_node0009 | 31580921856 | 75%
(9 rows)

另请参阅

Eon 模式体系结构

6.2 - BACKGROUND_DEPOT_WARMING

仅限 Eon 模式

强制正在预热其存储库的节点开始处理查询，同时继续在后台预热其存储库。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。此函数仅在以下情况下有效：

  • 数据库在 Eon 模式下运行。

  • 节点当前正在预热其存储库。

  • 该节点正在从公共存储中预热其存储库。当 UseCommunalStorageForBatchDepotWarming 配置参数设置为默认值 1 时就是这种情况。有关此参数的详细信息，请参阅 Eon 模式参数。

调用此函数后，节点在参与查询时将在后台对其存储库进行预热。

此函数对未预热其存储库的节点没有影响。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

BACKGROUND_DEPOT_WARMING('node-name' [, 'subscription-name'])

参数

node-name
您要在后台预热其存储库的节点的名称。
订购名称
节点订购的分片的名称，您希望节点在后台预热。您可以在 NODE_SUBSCRIPTIONS 系统表的 SHARD_NAME 列中找到节点订阅的分片的名称。

返回值

指示节点预热将在后台继续的消息。

特权

用户必须是 超级用户。

示例

以下示例演示了 verticadb 数据库的节点 6 在后台对其存储库进行预热：


=> SELECT BACKGROUND_DEPOT_WARMING('v_verticadb_node0006');
                          BACKGROUND_DEPOT_WARMING
----------------------------------------------------------------------------
 Depot warming running in background. Check monitoring tables for progress.
(1 row)

另请参阅

6.3 - CANCEL_DEPOT_WARMING

仅限 Eon 模式

取消节点上的存储库预热。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。您可以选择取消节点上的所有预热，或者取消特定分片订阅的预热。节点将结束其当前执行的任何数据传输，以对其存储库进行预热，并从其队列中移除与预热相关的待执行传输。它将保留已加载到其存储库中的所有数据。当取消对特定订阅的预热时，如果所有其他订阅都已预热，则将停止预热存储库。如果其他订阅未预热，节点会继续预热其他订阅。

此函数仅在以下情况下有效：

  • 数据库在 Eon 模式下运行。

  • 节点当前正在预热其存储库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_DEPOT_WARMING('node-name' [, 'subscription-name'])

参数

'node-name'
要取消其存储库预热的节点的名称。
'subscription-name'
希望节点停止预热的节点订阅的分片的名称。您可以在 NODE_SUBSCRIPTIONS 系统表的 SHARD_NAME 列中找到节点订阅的分片的名称。

返回值

返回一条消息，表明预热已被取消。

特权

用户必须是 超级用户。

用法注意事项

取消存储库预热会对查询的性能产生负面影响。具有冷存储库的节点可能需要从公共存储中检索其大部分数据，这比访问存储库要慢。

示例

下面演示了如何取消节点 7 上的存储库预热：


=> SELECT CANCEL_DEPOT_WARMING('v_verticadb_node0007');
   CANCEL_DEPOT_WARMING
--------------------------
 Depot warming cancelled.
(1 row)

另请参阅

6.4 - CANCEL_DRAIN_SUBCLUSTER

仅限 Eon 模式

取消一个或多个子群集的排空操作。此函数可以取消由 START_DRAIN_SUBCLUSTER 或 SHUTDOWN_WITH_DRAIN 函数的排空部分启动的排空操作。CANCEL_DRAIN_SUBCLUSTER 将指定子群集中的所有节点标记为未排空。先前排空的节点再次接受新的客户端连接以及从负载均衡重定向的连接。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_DRAIN_SUBCLUSTER( 'subcluster-name' )

参数

subcluster-name
要取消排空操作的子群集的名称。输入空字符串可取消对所有子群集的排空操作。

特权

超级用户

示例

以下示例演示了如何取消对子群集的排空操作。

首先，您可以查询 DRAINING_STATUS 系统表以查看当前正在排空哪些子群集：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | t
verticadb_node0005 | analytics          | t
verticadb_node0006 | analytics          | t

以下函数调用将取消 analytics 子群集的排空操作：


=> SELECT CANCEL_DRAIN_SUBCLUSTER('analytics');
             CANCEL_DRAIN_SUBCLUSTER
--------------------------------------------------------
Targeted subcluster: 'analytics'
Action: CANCEL DRAIN

(1 row)

要确认子群集不再进行排空，您可以再次查询 DRAINING_STATUS 系统表：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | f
verticadb_node0005 | analytics          | f
verticadb_node0006 | analytics          | f
(6 rows)

另请参阅

6.5 - CLEAN_COMMUNAL_STORAGE

仅限 Eon 模式

将公共存储中的无效数据标记为待删除，通常是由于 Vertica 清理机制失败而泄露的数据。需要调用此函数的事件包括：

  • 节点故障

  • 从 Enterprise 数据库到 Eon 数据库的迁移中断

  • 从备份中恢复对象

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAN_COMMUNAL_STORAGE ( ['actually‑delete'] )

参数

actually‑delete
BOOLEAN，指定是否将数据文件添加到删除队列中：

  • true （默认值）：将文件添加到 reaper 队列中并立即返回。排队的文件将通过 reaper 服务自动移除，或者可以通过调用 FLUSH_REAPER_QUEUE 手动移除。

  • false：报告有关额外文件的信息，但不会将其添加到删除排队中。

特权

超级用户

示例

=> SELECT CLEAN_COMMUNAL_STORAGE('true')
CLEAN_COMMUNAL_STORAGE
------------------------------------------------------------------
CLEAN COMMUNAL STORAGE
Task was canceled.
Total leaked files: 9265
Total size: 4236501526
Files have been queued for deletion.
Check communal_cleanup_records for more information.
(1 row)

6.6 - CLEAR_DATA_DEPOT

仅限 Eon 模式

删除指定的存储库数据。您可以从一个子群集、单个节点或整个数据库群集中清除单个表或所有表的存储库数据。清除存储库数据不会影响公共存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DATA_DEPOT( [ '[table‑name]' [, '[target-depots]'] ] )

参数

table‑name
要从目标存储库中删除的表的名称。如果忽略表名称或提供空字符串，则会从目标库中删除所有表的数据。
target-depots
指定此实参以清除指定存储库中的所有数据，为以下之一：

  • subcluster‑name：清除指定子群集中的存储库数据。

  • node-name：清除指定节点中的存储库数据。同一子群集中其他节点上的存储库数据不受影响。

（可选）此实参限定 table-name 的实参。如果忽略此实参或提供空字符串，Vertica 将清除数据库群集中的所有存储库数据。

特权

超级用户

示例

从子群集 subcluster_1 的存储库中清除表 t1 的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('t1', 'subcluster_1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除子群集 subcluster_1 中的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('', 'subcluster_1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除单个节点的所有存储库数据：

=> select clear_data_depot('','v_vmart_node0001');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除数据库群集中表 t1 的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT('t1');
 clear_data_depot
------------------
 Depot cleared
(1 row)

清除数据库群集中的所有存储库数据：

=> SELECT CLEAR_DATA_DEPOT();
 clear_data_depot
------------------
 Depot cleared
(1 row)

6.7 - CLEAR_DEPOT_PIN_POLICY_PARTITION

仅限 Eon 模式

从指定的表或投影分区中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。.

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_PARTITION( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, subcluster ] )

参数

[database.]schema

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

object‑name
具有要清除的分区固定策略的表或投影。
min‑range‑value max‑range‑value
从 table 中指定的分区键范围内清除固定策略，其中 min-range-value 必须 ≤ max‑range‑value。如果策略适用于单个分区，则 min‑range‑value 和 max‑range‑value 必须相等。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

6.8 - CLEAR_DEPOT_PIN_POLICY_PROJECTION

仅限 Eon 模式

从指定的投影中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_PROJECTION( '[[database.]schema.]projection' [, 'subcluster' ] )

参数

[database.]schema

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

projection
具有要清除的固定策略的投影。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

6.9 - CLEAR_DEPOT_PIN_POLICY_TABLE

仅限 Eon 模式

从指定的表中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_DEPOT_PIN_POLICY_TABLE( '[[database.]schema.]table' [, 'subcluster' ] )

参数

[database.]schema

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

表
具有要清除的固定策略的表。
subcluster
从 subcluster 存储库中清除指定的固定策略。如果省略此参数，系统将从所有数据库存储库中清除该策略。

特权

超级用户

另请参阅

6.10 - CLEAR_FETCH_QUEUE

仅限 Eon 模式

从公共存储中移除所有条目或数据获取请求队列中特定事务的条目。您可以通过查询 DEPOT_FETCH_QUEUE 系统表来查看提取队列。此函数会同步移除所有排队的请求。并会在所有提取都从队列中移除后返回。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_FETCH_QUEUE([transaction_id])

参数

transaction_id
将从队列中清除其提取的事务的 ID。如果未指定此值，则从提取队列中移除所有提取。

示例

此示例将清除所有事务的提取队列。

=> SELECT CLEAR_FETCH_QUEUE();

    CLEAR_FETCH_QUEUE

--------------------------

Cleared the fetch queue.

(1 row)

此示例将清除特定事务的提取队列。

=> SELECT node_name,transaction_id FROM depot_fetch_queue;
      node_name       |  transaction_id
----------------------+-------------------
 v_verticadb_node0001 | 45035996273719510
 v_verticadb_node0003 | 45035996273719510
 v_verticadb_node0002 | 45035996273719510
 v_verticadb_node0001 | 45035996273719777
 v_verticadb_node0003 | 45035996273719777
 v_verticadb_node0002 | 45035996273719777

(6 rows)

=> SELECT clear_fetch_queue(45035996273719510);
    clear_fetch_queue
--------------------------
 Cleared the fetch queue.
(1 row)

=> SELECT node_name,transaction_id from depot_fetch_queue;
      node_name       |  transaction_id
----------------------+-------------------
 v_verticadb_node0001 | 45035996273719777
 v_verticadb_node0003 | 45035996273719777
 v_verticadb_node0002 | 45035996273719777

(3 rows)

6.11 - DEMOTE_SUBCLUSTER_TO_SECONDARY

仅限 Eon 模式

将一个 主子群集转换为 辅助子群集。

如果以下任一情况为真，Vertica 将不允许对主子群集降级：

  • 子群集包含一个 关键节点。

  • 子群集是数据库中唯一的主子群集。您必须至少有一个主子群集。

  • 启动程序节点是指您尝试降级的子群集的成员。您必须从另一个子群集调用 DEMOTE_SUBCLUSTER_TO_SECONDARY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DEMOTE_SUBCLUSTER_TO_SECONDARY('subcluster-name')

参数

subcluster‑name
要降级为辅助子群集的主子群集的名称。

特权

超级用户

示例

以下示例将子群集 analytics_cluster 降级为辅助子群集：

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | t
 load_subcluster   | t
(2 rows)

=> SELECT DEMOTE_SUBCLUSTER_TO_SECONDARY('analytics_cluster');
 DEMOTE_SUBCLUSTER_TO_SECONDARY
--------------------------------
 DEMOTE SUBCLUSTER TO SECONDARY
(1 row)

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | f
 load_subcluster   | t
(2 rows)

尝试将包含启动程序节点的子群集降级会导致错误：

=> SELECT node_name FROM sessions WHERE user_name = 'dbadmin'
   AND client_type = 'vsql';
      node_name
----------------------
 v_verticadb_node0004
(1 row)

=> SELECT node_name, is_primary FROM subclusters WHERE subcluster_name = 'analytics';
      node_name       | is_primary
----------------------+------------
 v_verticadb_node0004 | t
 v_verticadb_node0005 | t
 v_verticadb_node0006 | t
(3 rows)

=> SELECT DEMOTE_SUBCLUSTER_TO_SECONDARY('analytics');
ERROR 9204:  Cannot promote or demote subcluster including the initiator node
HINT:  Run this command on another subcluster

另请参阅

6.12 - FINISH_FETCHING_FILES

仅限 Eon 模式

将排队等待从公共存储下载的所有文件提取到存储库。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FINISH_FETCHING_FILES()

特权

超级用户

示例

获取所有排队下载的文件：

=> SELECT FINISH_FETCHING_FILES();
      FINISH_FETCHING_FILES
---------------------------------
 Finished fetching all the files
(1 row)

另请参阅

Eon 模式概念

6.13 - FLUSH_REAPER_QUEUE

仅限 Eon 模式

删除数据库中所有标记为待删除的数据。使用此函数可在 reaper 服务删除磁盘文件之前移除所有标记为待删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

FLUSH_REAPER_QUEUE( [sync‑catalog] )

参数

sync‑catalog
指定在函数执行之前在所有节点的数据库编录中同步元数据：

  • true （默认值）：同步数据库编录

  • false：在未同步的情况下运行。

特权

超级用户

示例

移除所有标记为待删除的文件：

=> SELECT FLUSH_REAPER_QUEUE();
                 FLUSH_REAPER_QUEUE
-----------------------------------------------------
 Sync'd catalog and deleted all files in the reaper queue.
(1 row)

另请参阅

CLEAN_COMMUNAL_STORAGE

6.14 - MIGRATE_ENTERPRISE_TO_EON

仅限企业模式

将 Enterprise 数据库迁移到 Eon 模式数据库。MIGRATE_ENTERPRISE_TO_EON 在返回之前在前台运行；无论其返回成功或错误，它都会阻止源 Enterprise 数据库中同一会话中的所有操作。如果成功，MIGRATE_ENTERPRISE_TO_EON 将返回并显示迁移数据库中的节点列表。

如果迁移在元函数返回之前被中断，例如，客户端断开连接，或者发生网络中断，则迁移将返回错误。在这种情况下，请再次调用 MIGRATE_ENTERPRISE_TO_EON 以重新开始迁移。有关详细信息，请参阅处理中断迁移。

您可以多次重复迁移到同一个公共存储位置，以捕获上一次迁移期间源数据库中的更改。有关详细信息，请参阅重复迁移。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MIGRATE_ENTERPRISE_TO_EON ( 'communal‑storage‑location', 'depot‑location' [, is‑dry‑run] )
communal‑storage‑location
公共存储位置的 URI。有关每个受支持架构的 URI 语法示例，请参阅文件系统和对象存储。
depot‑location
Eon 存储库位置的路径，通常为： 
/vertica/depot
catalog‑location
/*pushed out to as yet unspecified release (http://jira.verticacorp.com:8080/jira/browse/VER-72507) */

Vertica 编录位置的完整路径。默认设置为：

communal‑storage‑location/metadata/database‑name/nodes/node‑name/Catalog/
is‑dry‑run
Boolean。如果设置为 true，MIGRATE_ENTERPRISE_TO_EON 将仅检查 Enterprise 源数据库是否符合所有迁移先决条件。如果元函数发现任何合规性问题，它会将这些问题写入数据库目录中的迁移错误日志 migrate_enterprise_to_eon_error.log 中。

默认值：false

特权

超级用户

示例

将 Enterprise 数据库迁移到 AWS 的 Eon 模式：

=> SELECT MIGRATE_ENTERPRISE_TO_EON ('s3://verticadbbucket', '/vertica/depot');
                      migrate_enterprise_to_eon
---------------------------------------------------------------------
 v_vmart_node0001,v_vmart_node0002,v_vmart_node0003,v_vmart_node0004
(1 row)

另请参阅

将企业数据库迁移到 Eon 模式

6.15 - PROMOTE_SUBCLUSTER_TO_PRIMARY

仅限 Eon 模式

将辅助子群集转换为 主子群集。不能使用此函数来提升包含 启动程序节点的子群集。必须在连接到另一个子群集中的节点时调用此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PROMOTE_SUBCLUSTER_TO_PRIMARY('subcluster-name')

参数

subcluster‑name
要提升为主子群集的辅助群集的名称。

特权

超级用户

示例

以下示例将名为 analytics_cluster 的子群集提升为主群集：

=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | f
 load_subcluster   | t
(2 rows)


=> SELECT PROMOTE_SUBCLUSTER_TO_PRIMARY('analytics_cluster');
 PROMOTE_SUBCLUSTER_TO_PRIMARY
-------------------------------
 PROMOTE SUBCLUSTER TO PRIMARY
(1 row)


=> SELECT DISTINCT subcluster_name, is_primary from subclusters;
  subcluster_name  | is_primary
-------------------+------------
 analytics_cluster | t
 load_subcluster   | t
(2 rows)

另请参阅

6.16 - REBALANCE_SHARDS

仅限 Eon 模式

在 Eon 模式下重新平衡子群集或整个群集中的分片分配。如果当前会话结束，则操作立即中止。根据数据库中对象的数量，重新平衡分片所需的时间以大致线性的方式增加。

在使用 ALTER NODE 修改群集或将节点添加到子群集后运行 REBALANCE_SHARDS。

重新平衡分片后，您将无法再从重新平衡之前的备份中还原对象。（始终可以执行完整备份。）重新平衡后，执行完整备份，以便将来能够从中还原对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_SHARDS(['subcluster-name'])

参数

subcluster‑name
将重新平衡分片的子群集的名称。如果您未提供此参数，则数据库中的所有子群集均会重新平衡其分片。

特权

超级用户

示例

以下示例显示新添加的 analytics 子群集中的节点尚未有分片订阅。然后它将调用 REBALANCE_SHARDS 来更新节点的订阅：

=> SELECT subcluster_name, n.node_name, shard_name, subscription_state FROM
   v_catalog.nodes n LEFT JOIN v_catalog.node_subscriptions ns ON (n.node_name
   = ns.node_name) ORDER BY 1,2,3;

   subcluster_name    |      node_name       | shard_name  | subscription_state
----------------------+----------------------+-------------+--------------------
 analytics_subcluster | v_verticadb_node0004 |             |
 analytics_subcluster | v_verticadb_node0005 |             |
 analytics_subcluster | v_verticadb_node0006 |             |
 default_subcluster   | v_verticadb_node0001 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0003 | ACTIVE
(12 rows)


=> SELECT REBALANCE_SHARDS('analytics_subcluster');
 REBALANCE_SHARDS
-------------------
 REBALANCED SHARDS
(1 row)

=> SELECT subcluster_name, n.node_name, shard_name, subscription_state FROM
   v_catalog.nodes n LEFT JOIN v_catalog.node_subscriptions ns ON (n.node_name
   = ns.node_name) ORDER BY 1,2,3;

   subcluster_name    |      node_name       | shard_name  | subscription_state
----------------------+----------------------+-------------+--------------------
 analytics_subcluster | v_verticadb_node0004 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0004 | segment0001 | ACTIVE
 analytics_subcluster | v_verticadb_node0004 | segment0003 | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | segment0001 | ACTIVE
 analytics_subcluster | v_verticadb_node0005 | segment0002 | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | replica     | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | segment0002 | ACTIVE
 analytics_subcluster | v_verticadb_node0006 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0001 | segment0003 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0001 | ACTIVE
 default_subcluster   | v_verticadb_node0002 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | replica     | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0002 | ACTIVE
 default_subcluster   | v_verticadb_node0003 | segment0003 | ACTIVE
(18 rows)

另请参阅

6.17 - RESHARD_DATABASE

仅限 Eon 模式

更改数据库中分片的数量。此函数在运行时需要使用全局编录锁 (GCLX)。运行时取决于编录的大小。

RESHARD_DATABASE 不会立即影响公共存储中的存储容器。重新分片后，新的分片仍然指向现有容器。如果增加数据库中分片的数量，多个分片将指向同一个存储容器。最终，Tuple Mover (TM) 合并任务会将存储容器与新的分片分段边界重新对齐。如果希望 TM 立即重新对齐存储容器，请调用 DO_TM_TASK 来运行“RESHARDMERGEOUT”任务。

此函数不会中断大多数查询。但是，全局编录锁可能会影响数据加载和 DDL 语句。

语法

RESHARD_DATABASE(shard-count)

参数

shard-count
一个正整数，即重新分片数据库中分片的数量。有关选择合适的 shard-count 的信息，请参阅选择分片数量和初始节点计数。

特权

超级用户

示例

请参阅更改数据库中的分片数。

6.18 - SET_DEPOT_PIN_POLICY_PARTITION

仅限 Eon 模式

将表或投影的指定分区固定到子群集存储库或所有数据库存储库，以减少存储库逐出的风险。

仅当组内的所有分区都单独固定时，才能固定分区组。如果更改或移除表分区，Vertica 会删除该表的所有分区固定策略。表的固定策略（如有）不受影响。

有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_PARTITION ( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, 'subcluster' ] [, 'download' ] )

参数

[database.]schema

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

object-name
要固定的表或投影。如果指定一个投影，则该投影必须存储分区键。
min‑range‑value
max‑range‑value
要固定的 object-name 中分区键的最小值和最大值，其中 min-range-value 必须 ≤ max‑range‑value。要指定单个分区，min‑range‑value 和 max‑range‑value 必须相等。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_PARTITION 会立即将指定的分区添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

固定策略的优先级

一般来说，涉及两个分区表的分区管理函数的优先级高于目标表的固定策略，如下所示：

例如，以下语句将分区从表 foo 复制到表 bar：

=> SELECT COPY_PARTITIONS_TO_TABLE('foo', '1', '5', 'bar');

在这种情况下，将应用以下逻辑：

  • 如果两个表具有不同的分区固定策略，则应用目标表 bar 的分区键 1-5 的固定策略。

  • 如果表 bar 不存在，Vertica 将基于表 foo 进行创建，并复制 foo 的分区键 1- 5 的策略。随后，如果从任一表中清除分区固定策略，该固定策略也会从另一个表中清除。

另请参阅

6.19 - SET_DEPOT_PIN_POLICY_PROJECTION

仅限 Eon 模式

将投影固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_PROJECTION ( '[[database.]schema.]projection' [, 'subcluster' ] [, download ] )

参数

[database.]schema

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

projection
要固定的投影。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_PROJECTION 会立即将指定的投影添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

另请参阅

6.20 - SET_DEPOT_PIN_POLICY_TABLE

仅限 Eon 模式

将表固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DEPOT_PIN_POLICY_TABLE ( '[[database.]schema.]table' [, 'subcluster' ] [, download ] )

参数

[database.]schema

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

表
要固定的表。
subcluster
在 subcluster 存储库上设置此固定策略。要在默认子群集上设置此策略，请指定 default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。
download
布尔值，如果设置为 true，SET_DEPOT_PIN_POLICY_TABLE 会立即将指定的表添加到从公共存储下载的队列中。

默认值：false

特权

超级用户

另请参阅

6.21 - SHUTDOWN_SUBCLUSTER

仅限 Eon 模式

关闭子群集。此函数将同步关闭子群集，并在关闭完成后返回子群集已关闭消息。如果子群集已关闭，此函数将不返回错误。

如果有活动用户会话连接到子群集，则停止子群集不会发出警告。此行为与停止单个节点相同。在停止子群集之前，确认没有用户连接到它。

如果想在关闭子群集之前排空客户端连接，则可以使用 SHUTDOWN_WITH_DRAIN 优雅地关闭子群集。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN_SUBCLUSTER('subcluster‑name')

参数

subcluster‑name
要关闭的子群集的名称。

特权

超级用户

示例

以下示例演示了如何关闭子群集 analytics：

=> SELECT subcluster_name, node_name, node_state FROM nodes order by 1,2;
  subcluster_name   |      node_name       | node_state
--------------------+----------------------+------------
 analytics          | v_verticadb_node0004 | UP
 analytics          | v_verticadb_node0005 | UP
 analytics          | v_verticadb_node0006 | UP
 default_subcluster | v_verticadb_node0001 | UP
 default_subcluster | v_verticadb_node0002 | UP
 default_subcluster | v_verticadb_node0003 | UP
(6 rows)

=> SELECT SHUTDOWN_SUBCLUSTER('analytics');
WARNING 4539:  Received no response from v_verticadb_node0004 in stop subcluster
WARNING 4539:  Received no response from v_verticadb_node0005 in stop subcluster
WARNING 4539:  Received no response from v_verticadb_node0006 in stop subcluster
 SHUTDOWN_SUBCLUSTER
---------------------
 Subcluster shutdown
(1 row)

=> SELECT subcluster_name, node_name, node_state FROM nodes order by 1,2;
  subcluster_name   |      node_name       | node_state
--------------------+----------------------+------------
 analytics          | v_verticadb_node0004 | DOWN
 analytics          | v_verticadb_node0005 | DOWN
 analytics          | v_verticadb_node0006 | DOWN
 default_subcluster | v_verticadb_node0001 | UP
 default_subcluster | v_verticadb_node0002 | UP
 default_subcluster | v_verticadb_node0003 | UP
(6 rows)

另请参阅

6.22 - SHUTDOWN_WITH_DRAIN

仅限 Eon 模式

优雅地关闭一个或多个子群集。此函数会排空子群集节点上的客户端连接，然后关闭子群集。这是关闭消息发送到子群集后返回的同步函数。

现有用户会话中的工作继续在正在清空的节点上进行，但节点拒绝新的客户端连接，并被排除在负载均衡操作之外。dbadmin 仍然可以连接到正在清空的节点。

现有连接完成其工作并关闭，或达到用户指定的超时后，将开始排空节点。一旦满足这些条件之一，此函数会立即继续关闭子群集。

有关正常关闭过程的详细信息，请参阅正常关闭。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SHUTDOWN_WITH_DRAIN( 'subcluster-name', timeout-seconds )

参数

subcluster-name
要关闭的子群集的名称。输入空字符串以关闭数据库中的所有子群集。
timeout-seconds
在强制关闭 subcluster-name 的客户端连接并关闭子群集之前等待的秒数。行为取决于 timeout-seconds 的符号：
  • 正整数：此函数会等到运行时达到 timeout-seconds 或客户端连接完成工作并关闭才开始运行。一旦满足这两个条件之一，此函数会立即继续关闭子群集。
  • 零：此函数会立即关闭任何打开的客户端连接并关闭子群集。
  • 负整数：此函数将子群集标记为排空，并无限期地等待关闭子群集，直到所有活动用户会话断开连接。

特权

超级用户

示例

在以下示例中，此函数将名为 analytics 的子群集标记为排空，然后在现有客户端连接关闭或 300 秒后立即将其关闭：

=> SELECT SHUTDOWN_WITH_DRAIN('analytics', 120);
NOTICE 0:  Draining has started on subcluster (analytics)
NOTICE 0:  Begin shutdown of subcluster (analytics)
                              SHUTDOWN_WITH_DRAIN
--------------------------------------------------------------------------------------------------------------------
Set subcluster (analytics) to draining state
Waited for 3 nodes to drain
Shutdown message sent to subcluster (analytics)

(1 row)

您可以查询 DC_DRAINING_EVENTS 表，以查看有关排空和关闭事件的详细信息，例如是否存在任何用户会话被强制关闭。开始关闭后，此子群集有一个活动用户会话，但其会在达到超时之前关闭：

=> SELECT event_type, event_type_name, event_description, event_result, event_result_name FROM dc_draining_events;
 event_type |       event_type_name        |                          event_description                          | event_result | event_result_name
------------+------------------------------+---------------------------------------------------------------------+--------------+-------------------
          0 | START_DRAIN_SUBCLUSTER       | START_DRAIN for SHUTDOWN of subcluster (analytics)                  |            0 | SUCCESS
          2 | START_WAIT_FOR_NODE_DRAIN    | Wait timeout is 120 seconds                                         |            4 | INFORMATIONAL
          4 | INTERVAL_WAIT_FOR_NODE_DRAIN | 1 sessions remain after 0 seconds                                   |            4 | INFORMATIONAL
          4 | INTERVAL_WAIT_FOR_NODE_DRAIN | 1 sessions remain after 30 seconds                                  |            4 | INFORMATIONAL
          3 | END_WAIT_FOR_NODE_DRAIN      | Wait for drain ended with 0 sessions remaining                      |            0 | SUCCESS
          5 | BEGIN_SHUTDOWN_AFTER_DRAIN   | Starting shutdown of subcluster (analytics) following drain         |            4 | INFORMATIONAL
(6 rows)

另请参阅

6.23 - START_DRAIN_SUBCLUSTER

仅限 Eon 模式

排空一个或多个子群集。此函数将指定子群集中的所有节点标记为排空。现有用户会话继续在排空节点上运行，但这些节点拒绝新的客户端连接，且被排除在负载均衡操作之外。但 dbadmin 仍然可以连接到排空节点。

在优雅关闭的过程中，要排空子群集上的连接，可调用 SHUTDOWN_WITH_DRAIN。有关详细信息，请参阅优雅关闭。

要取消对子群集的排空操作，请调用 CANCEL_DRAIN_SUBCLUSTER。如果停止子群集中的所有节点排空操作，则会在重新启动时将这些节点标记为未排空。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_DRAIN_SUBCLUSTER( 'subcluster-name' )

参数

subcluster-name
要排空的子群集的名称。输入空字符串将排空数据库中的所有子群集。

特权

超级用户

示例

以下示例演示了如何排空名为 analytics 的子群集：

=> SELECT subcluster_name, node_name, node_state FROM nodes;
subcluster_name    |      node_name     | node_state
-------------------+--------------------+------------
default_subcluster | verticadb_node0001 | UP
default_subcluster | verticadb_node0002 | UP
default_subcluster | verticadb_node0003 | UP
analytics          | verticadb_node0004 | UP
analytics          | verticadb_node0005 | UP
analytics          | verticadb_node0006 | UP
(6 rows)

=> SELECT START_DRAIN_SUBCLUSTER('analytics');
               START_DRAIN_SUBCLUSTER
-------------------------------------------------------
Targeted subcluster: 'analytics'
Action: START DRAIN
(1 row)

您可以通过查询 DRAINING_STATUS 系统表来确认子群集正在排空：


=> SELECT node_name, subcluster_name, is_draining FROM draining_status ORDER BY 1;
node_name          | subcluster_name    | is_draining
-------------------+--------------------+-------
verticadb_node0001 | default_subcluster | f
verticadb_node0002 | default_subcluster | f
verticadb_node0003 | default_subcluster | f
verticadb_node0004 | analytics          | t
verticadb_node0005 | analytics          | t
verticadb_node0006 | analytics          | t

另请参阅

6.24 - START_REAPING_FILES

仅限 Eon 模式

一个异步函数，在后台启动磁盘文件删除。默认情况下，此元函数会在开始删除之前同步编录。磁盘文件删除由 FLUSH_REAPER_QUEUE 在前台处理。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REAPING_FILES( [sync‑catalog] )

参数

sync‑catalog
指定在函数执行之前在所有节点的数据库编录中同步元数据：

  • true （默认值）：同步数据库编录

  • false：在未同步的情况下运行。

特权

超级用户

示例

启动 reaper 服务：

=> SELECT START_REAPING_FILES();

启动 reaper 服务并跳过初始编录同步：

=> SELECT START_REAPING_FILES(false);

6.25 - SYNC_CATALOG

仅限 Eon 模式

将编录同步到公共存储，以便在编录快要崩溃时恢复当前编录版本。Vertica 将所有待处理的检查点和事务日志同步到公共存储。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SYNC_CATALOG( [ 'node‑name' ] )

参数

node‑name
要同步的节点。如果忽略此实参，Vertica 会同步所有节点上的编录。

特权

超级用户

示例

同步所有节点上的编录：

=> SELECT SYNC_CATALOG();

同步一个节点上的编录：

=> SELECT SYNC_CATALOG( 'node001' );

7 - 时期函数

此部分包含 Vertica 专用的时期管理函数。

7.1 - ADVANCE_EPOCH

手动关闭当前时期并开始新的时期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ADVANCE_EPOCH ( [ integer ] )

参数

integer
指定要推进的时期数。

超级用户

注意

维护此函数主要是为了实现与 Vertica 较早版本的向后兼容性。

示例

以下命令将以 1 为增量递增时期编号：

=> SELECT ADVANCE_EPOCH(1);

7.2 - GET_AHM_EPOCH

返回 Ancient History Mark 所在 时期的编号。可以从物理存储中清除截至 AHM 时期（包括该时期）删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AHM_EPOCH()

特权

无

示例

=> SELECT GET_AHM_EPOCH();
    GET_AHM_EPOCH
----------------------
 Current AHM epoch: 0
(1 row)

7.3 - GET_AHM_TIME

返回代表 Ancient History Mark 的 TIMESTAMP 值。可以从物理存储中清除截至 AHM 时期（包括该时期）删除的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AHM_TIME()

特权

无

示例

=> SELECT GET_AHM_TIME();
                  GET_AHM_TIME
-------------------------------------------------
 Current AHM Time: 2010-05-13 12:48:10.532332-04
(1 row)

7.4 - GET_CURRENT_EPOCH

当前正在将数据（COPY、INSERT、UPDATE 和 DELETE 操作）写入到的时期。

返回当前时期的编号。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_CURRENT_EPOCH()

特权

无

示例

=> SELECT GET_CURRENT_EPOCH();
 GET_CURRENT_EPOCH
-------------------
               683
(1 row)

7.5 - GET_LAST_GOOD_EPOCH

返回 上一个完好的时期的编号。如果数据库没有投影，此函数将返回错误。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_LAST_GOOD_EPOCH()

特权

无

示例

=> SELECT GET_LAST_GOOD_EPOCH();
 GET_LAST_GOOD_EPOCH
---------------------
                 682
(1 row)

7.6 - MAKE_AHM_NOW

将 Ancient History Mark (AHM) 设置为允许的最大值。这使您可以清除所有已删除的数据。

MAKE_AHM_NOW 执行以下操作：

  • 推进时间。

  • 将 AHM 设置为 上一个完好的时期 (LGE)，至少设置为执行 MAKE_AHM_NOW 时的当前时期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MAKE_AHM_NOW ( [ true ] )

参数

true
当以下条件之一为 true 时，允许 AHM 推进：

  • 一个或多个节点发生故障。

  • 一个投影正在通过另一个投影进行刷新（保留刷新）。

在这两种情况下，必须将此实参提供给 MAKE_AHM_NOW，否则 Vertica 会返回错误。如果在保留刷新期间执行 MAKE_AHM_NOW(true)，Vertica 将回滚刷新操作并推进 AHM。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 MAKE_AHM_NOW；否则，函数将返回错误。

在以下示例中，即使节点发生故障，MAKE_AHM_NOW 仍会推进 AHM：

=> SELECT MAKE_AHM_NOW(true);
WARNING:  Received no response from v_vmartdb_node0002 in get cluster LGE
WARNING:  Received no response from v_vmartdb_node0002 in get cluster LGE
WARNING:  Received no response from v_vmartdb_node0002 in set AHM
         MAKE_AHM_NOW
------------------------------
 AHM set (New AHM Epoch: 684)
(1 row)

另请参阅

7.7 - SET_AHM_EPOCH

将 Ancient History Mark (AHM) 设置为指定的时期。此函数允许从物理存储中清除已删除数据，包括 AHM 时期。

SET_AHM_EPOCH 通常用于测试。相反，请考虑使用 SET_AHM_TIME，此函数更易于使用。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AHM_EPOCH ( epoch, [ true ] )

参数

epoch
指定下列内容之一：

  • 设置 AHM 所在的时期数

  • 零 (0)（默认值）表示禁用 PURGE

true
允许 AHM 在节点关闭时推进。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 SET_AHM_EPOCH；否则，函数将返回错误。

示例

以下命令可将 AHM 设置为数量为 12 的指定时期：

=> SELECT SET_AHM_EPOCH(12);

以下命令可将 AHM 设置为数量为 2 的指定时期，并且允许在节点发生故障时推进：

=> SELECT SET_AHM_EPOCH(2, true);

另请参阅

7.8 - SET_AHM_TIME

将 Ancient History Mark (AHM) 设置为与启动程序节点上指定时间相对应的时期。此函数允许从物理存储中清除历史数据，包括 AHM 时期。 SET_AHM_TIME 返回一个表示 AHM 时期终点的 TIMESTAMPTZ。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AHM_TIME ( time, [ true ] )

参数

time
会自动转换为相应时期数的 TIMESTAMP/TIMESTAMPTZ 值。
true
允许 AHM 在节点关闭时推进。

超级用户

在节点发生故障时设置 AHM

如果群集中的任何节点发生故障，则必须使用 true 实参调用 SET_AHM_TIME；否则，函数将返回错误。

示例

时期取决于配置的时期推进间隔。如果一个时期包含三分钟的时间范围，则清除操作仅精确到指定时间戳前三分钟内：

=> SELECT SET_AHM_TIME('2008-02-27 18:13');
           set_ahm_time
------------------------------------
 AHM set to '2008-02-27 18:11:50-05'
(1 row)

在上一示例中，AHM 时期实际于 18:11:50 结束，大约是指定时间戳前一分钟。这是因为 SET_AHM_TIME 选择了在指定时间戳或之前结束的时期。它没有选择在指定时间戳之后结束的时期，因为这样会清除 AHM 之后三分钟的已删除数据。

例如，在仅使用小时和分钟的情况下，假设时期 9000 从 08:50 运行至 11:50，时期 9001 从 11:50 运行至 15:50。 SET_AHM_TIME('11:51') 选择时期 9000，因为要在指定时间戳前一分钟左右结束。

在下一个示例中，假设某个节点在 2017 年 1 月 1 日上午 11:00:00 发生故障。中午，您将 AHM 推进到 11:15:00，但节点仍处于故障状态。

假设您尝试使用以下命令设置 AHM：

=> SELECT SET_AHM_TIME('2017-01-01 11:15:00');

然后您将收到一条错误消息。Vertica 会阻止您将 AHM 移动到超过节点出现故障的位置。Vertica 返回此错误以防止将 AHM 推进到超过故障节点的上一个完好的时期。您可以通过提供可选的其他参数来强制执行 AHM 推进：

=> SELECT SET_AHM_TIME('2017-01-01 11:15:00', true);

但是，如果强制 AHM 超过上一个完好的时期，则故障节点将不得不从头开始恢复。

另请参阅

8 - LDAP Link 函数

此部分包含与 Vertica LDAP Link 服务相关的函数。

8.1 - LDAP_LINK_DRYRUN_CONNECT

将一组 LDAP Link 连接参数作为实参，并开始在 LDAP 服务器和 Vertica 之间进行试运行连接。

通过为 LDAPLinkBindPswd 实参提供空字符串，您还可以执行匿名绑定（如果 LDAP 服务器允许未经身份验证的绑定）。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_CONNECT (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd'
)

特权

超级用户

示例

这将测试 CN=amir,OU=QA,DC=dc,DC=com 中 DN 为 ldap://example.dc.com 的 LDAP 服务器连接。

=> SELECT LDAP_LINK_DRYRUN_CONNECT('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','password');

                ldap_link_dryrun_connect
---------------------------------------------------------------------------------
Dry Run Connect Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查绑定的结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, role_name, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp       |       event_type      |      entry_name      | link_scope | search_base
------------------------------+-----------------------+----------------------+------------+-------------
2019-12-09 15:41:43.589398-05 | BIND_STARTED          | -------------------- | ---------- | -----------
2019-12-09 15:41:43.590504-05 | BIND_FINISHED         | -------------------- | ---------- | -----------

另请参阅

8.2 - LDAP_LINK_DRYRUN_SEARCH

将一组 LDAP Link 连接和搜索参数作为实参，并开始试运行搜索将从 LDAP 服务器导入的用户和组。

通过为 LDAPLinkBindPswd 实参提供空字符串，您还可以执行匿名搜索（如果 LDAP 服务器的访问控制列表 (ACL) 配置为允许未经身份验证的搜索）。允许匿名绑定的设置与允许匿名搜索的 ACL 设置不同。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_SEARCH (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd',
    'LDAPLinkSearchBase',
    'LDAPLinkScope',
    'LDAPLinkFilterUser',
    'LDAPLinkFilterGroup',
    'LDAPLinkUserName',
    'LDAPLinkGroupName',
    'LDAPLinkGroupMembers',
    [LDAPLinkSearchTimeout],
    ['LDAPLinkJoinAttr']
)

特权

超级用户

示例

这将在 LDAP 服务器中搜索用户和组。在这种情况下，LDAPLinkSearchBase 参数指定了 dc.com 域和子范围，它复制了 DN 下的整个子树。

为了进一步筛选结果，该函数将检查 objectClass 属性为 person 和 group 的用户和组。然后，它将搜索组属性 cn，使用 member 属性识别该组的成员，然后使用属性 uid 识别其中的个人用户。

=> SELECT LDAP_LINK_DRYRUN_SEARCH('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','$vertica$','dc=DC,dc=com','sub',
'(objectClass=person)','(objectClass=group)','uid','cn','member',10,'dn');

                ldap_link_dryrun_search
--------------------------------------------------------------------------------
Dry Run Search Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查搜索结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, ldapurihash, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp          |    event_type    |       entry_name       | ldapurihash | link_scope | search_base
---------------------------------+------------------+------------------------+-------------+------------+--------------
2020-01-03 21:03:26.411753+05:30 | BIND_STARTED     | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422188+05:30 | BIND_FINISHED    | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422223+05:30 | SYNC_STARTED     | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:26.422229+05:30 | SEARCH_STARTED   | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043107+05:30 | LDAP_GROUP_FOUND | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.04312+05:30  | LDAP_GROUP_FOUND | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043182+05:30 | LDAP_USER_FOUND  | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.043186+05:30 | LDAP_USER_FOUND  | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:03:32.04319+05:30  | SEARCH_FINISHED  | **********             |           0 | sub        | dc=DC,dc=com

另请参阅

8.3 - LDAP_LINK_DRYRUN_SYNC

将一组 LDAP Link 连接和搜索参数作为实参，并在数据库和 LDAP 服务器之间开始试运行同步，此操作可将 LDAP 服务器的用户和组与其在 Vertica 中的等效项进行映射和同步。此元函数还可以对 Vertica 中用户和角色的创建和孤立执行试运行。

您可以在系统表 LDAP_LINK_DRYRUN_EVENTS 中查看试运行的结果。

要取消正在进行的同步，请使用 LDAP_LINK_SYNC_CANCEL。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LDAP_LINK_DRYRUN_SYNC (
    'LDAPLinkURL',
    'LDAPLinkBindDN',
    'LDAPLinkBindPswd',
    'LDAPLinkSearchBase',
    'LDAPLinkScope',
    'LDAPLinkFilterUser',
    'LDAPLinkFilterGroup',
    'LDAPLinkUserName',
    'LDAPLinkGroupName',
    'LDAPLinkGroupMembers',
    [LDAPLinkSearchTimeout],
    ['LDAPLinkJoinAttr']
)

特权

超级用户

示例

要执行试运行以映射从 LDAP_LINK_DRYRUN_SEARCH 返回的用户和组，请将相同的参数作为实参传递给 LDAP_LINK_DRYRUN_SYNC。

=> SELECT LDAP_LINK_DRYRUN_SYNC('ldap://example.dc.com','CN=amir,OU=QA,DC=dc,DC=com','$vertica$','dc=DC,dc=com','sub',
'(objectClass=person)','(objectClass=group)','uid','cn','member',10,'dn');

                          LDAP_LINK_DRYRUN_SYNC
------------------------------------------------------------------------------------------
Dry Run Connect and Sync Completed. Query v_monitor.ldap_link_dryrun_events for results.

要检查同步结果，请查询系统表 LDAP_LINK_DRYRUN_EVENTS。

=> SELECT event_timestamp, event_type, entry_name, ldapurihash, link_scope, search_base from LDAP_LINK_DRYRUN_EVENTS;
        event_timestamp          |     event_type      |       entry_name       | ldapurihash | link_scope | search_base
---------------------------------+---------------------+------------------------+-------------+------------+--------------
2020-01-03 21:08:30.883783+05:30 | BIND_STARTED        | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890574+05:30 | BIND_FINISHED       | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890602+05:30 | SYNC_STARTED        | ---------------------- |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:30.890605+05:30 | SEARCH_STARTED      | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939369+05:30 | LDAP_GROUP_FOUND    | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939395+05:30 | LDAP_GROUP_FOUND    | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939461+05:30 | LDAP_USER_FOUND     | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939463+05:30 | LDAP_USER_FOUND     | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939468+05:30 | SEARCH_FINISHED     | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939718+05:30 | PROCESSING_STARTED  | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939887+05:30 | USER_CREATED        | user1                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939895+05:30 | USER_CREATED        | user2                  |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939949+05:30 | ROLE_CREATED        | Account Operators      |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.939959+05:30 | ROLE_CREATED        | Administrators         |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.940603+05:30 | PROCESSING_FINISHED | **********             |           0 | sub        | dc=DC,dc=com
2020-01-03 21:08:31.940613+05:30 | SYNC_FINISHED       | ---------------------- |           0 | sub        | dc=DC,dc=com

另请参阅

8.4 - LDAP_LINK_SYNC_START

立即开始 LDAP 服务器和 Vertica 之间的同步，而不是等待在 LDAPLinkInterval 中设置的时间间隔。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ldap_link_sync_start()

特权

必须是 dbaadmin 用户。

示例

=> SELECT ldap_link_sync_start();

另请参阅

LDAP Link 参数

8.5 - LDAP_LINK_SYNC_CANCEL

取消 LDAP 服务器和 Vertica 之间正在进行的 LDAP Link 同步（包括由 LDAP_LINK_DRYRUN_SYNC 启动的同步）。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ldap_link_sync_cancel()

特权

必须是 dbaadmin 用户。

示例

=> SELECT ldap_link_sync_cancel();

另请参阅

9 - 许可证函数

此部分包含用于监控 Vertica 许可证状态和合规性的函数。

9.1 - AUDIT

返回在审核数据库大小时计算的数据库、架构或表的原始数据大小（以字节为单位）。除非指定容错为 0，置信水平为 100%，否则 AUDIT 将仅返回可能随多次迭代不断变化的近似结果。

AUDIT 使用与 Vertica 相同的数据采样方法估计 Vertica 表中的数据大小，以确定数据库是否符合许可的数据库大小限额。Vertica 不使用这些结果来确定数据库的大小是否符合 Vertica 许可证的数据限额。有关详细信息，请参阅审核数据库大小。

对于基于 ORC 或 Parquet 格式存储在外部表中的数据，AUDIT 使用数据文件的总大小。永远不会估计此值，此值是从存储 ORC 或 Parquet 文件的文件系统（或者 Vertica 节点的本地文件系统、S3 或 HDFS）中读取的。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT('[[[database.]schema.]scope ]'[, 'granularity'] [, error‑tolerance[, confidence‑level]] )

参数

[database.]schema

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

scope
指定审核范围：

  • 空字符串 ('') 将审核整个数据库。

  • 要审核的架构或表的名称。

要审核的架构或表。要审核数据库，请将此参数设置为空字符串。

granularity
审核报告其结果的级别，为以下字符串之一：

  • database

  • schema

  • table

粒度级别必须等于或小于 scope 的粒度。如果忽略此参数，粒度将设置为与 scope 相同的级别。因此，如果 online_sales 为架构，则以下语句相同：

AUDIT('online_sales', 'schema');
AUDIT('online_sales');

如果 AUDIT 将粒度设置为低于目标对象的级别，则会返回一条消息，推荐您使用系统表 USER_AUDITS。有关详细信息，请参阅下文的查询 V_CATALOG.USER_AUDITS。

error‑tolerance
指定审核评估中允许的误差幅度百分比。以 0 与 100 之间的十进制数输入一个公差值。对于 5% 的误差幅度，默认值为 5。

此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。

将此值设置为 0 将导致全面数据库审核，由于 AUDIT 会分析整个数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。

confidence‑level
指定估计的统计置信水平百分比。以 0 与 100 之间的十进制数输入置信值。默认值为 99，表示置信水平为 99%。

此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。

置信度值越高，执行的数据采样越多，函数使用的资源也会越多。将此值设置为 100 将导致全面数据库审核，由于该函数会分析所有数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。

特权

超级用户，或以下权限：

  • 对目标表的 SELECT 权限

  • 对目标架构的 USAGE 权限

查询 V_CATALOG.USER_AUDITS

如果 AUDIT 将粒度设置为低于目标对象的级别，则会返回一条消息，推荐您使用系统表 USER_AUDITS。要获取指定粒度对象的审核数据，请查询该表。例如，以下查询试图审核 store 架构中的所有表：

=> SELECT AUDIT('store', 'table');
                           AUDIT
-----------------------------------------------------------
 See table sizes in v_catalog.user_audits for schema store
(1 row)

下一个查询将查询 USER_AUDITS 并获取这些表的最新审核结果：


=> SELECT object_name, AVG(size_bytes)::int size_bytes, MAX(audit_start_timestamp::date) audit_start
      FROM user_audits WHERE object_schema='store'
      GROUP BY rollup(object_name) HAVING GROUPING_ID(object_name) < 1 ORDER BY GROUPING_ID();
    object_name    | size_bytes | audit_start
-------------------+------------+-------------
 store_dimension   |      22067 | 2017-10-26
 store_orders_fact |   27201312 | 2017-10-26
 store_sales_fact  |  301260170 | 2017-10-26
(3 rows)

示例

请参阅审核数据库大小。

9.2 - AUDIT_FLEX

返回 __raw__ 列的估计 ROS 大小，等同于审核对象中 Flex 数据的导出大小。您可以审核数据库中的所有 Flex 数据，或将审核范围缩小到特定的 Flex 表、投影或架构。Vertica 将审核结果存储在系统表 USER_AUDITS 中。

审核不包括以下内容：

  • Flex 键

  • 审核表中的其他列。

  • 临时 Flex 表

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_FLEX ('[scope]')

参数

scope
指定审核范围：

  • 空字符串 ('') 表示将审核数据库中的所有 Flex 表。

  • 架构、投影或 Flex 表的名称。

特权

超级用户，或以下权限：

  • 对目标表的 SELECT 权限

  • 对目标架构的 USAGE 权限

示例

审核当前数据库中的所有 Flex 表：

dbs=> select audit_flex('');
 audit_flex
------------
 8567679
(1 row)

审核架构 public 中的 Flex 表：


dbs=> select audit_flex('public');
audit_flex
------------
8567679
(1 row)

审核投影 bakery_b0 中的 Flex 数据：

dbs=> select audit_flex('bakery_b0');
 audit_flex
------------
 8566723
(1 row)

审核 Flex 表 bakery：

dbs=> select audit_flex('bakery');
 audit_flex
------------
 8566723
(1 row)

为了报告 USER_AUDITS 中保存的所有审核的结果，下面显示系统表中的扩展显示部分，其中显示在名为 test 的架构以及整个数据库 dbs 上运行的审核：

dbs=> \x
Expanded display is on.

dbs=> select * from user_audits;
-[ RECORD 1 ]-------------------------+------------------------------
size_bytes                            | 0
user_id                               | 45035996273704962
user_name                             | release
object_id                             | 45035996273736664
object_type                           | SCHEMA
object_schema                         |
object_name                           | test
audit_start_timestamp                 | 2014-02-04 14:52:15.126592-05
audit_end_timestamp                   | 2014-02-04 14:52:15.139475-05
confidence_level_percent              | 99
error_tolerance_percent               | 5
used_sampling                         | f
confidence_interval_lower_bound_bytes | 0
confidence_interval_upper_bound_bytes | 0
sample_count                          | 0
cell_count                            | 0
-[ RECORD 2 ]-------------------------+------------------------------
size_bytes                            | 38051
user_id                               | 45035996273704962
user_name                             | release
object_id                             | 45035996273704974
object_type                           | DATABASE
object_schema                         |
object_name                           | dbs
audit_start_timestamp                 | 2014-02-05 13:44:41.11926-05
audit_end_timestamp                   | 2014-02-05 13:44:41.227035-05
confidence_level_percent              | 99
error_tolerance_percent               | 5
used_sampling                         | f
confidence_interval_lower_bound_bytes | 38051
confidence_interval_upper_bound_bytes | 38051
sample_count                          | 0
cell_count                            | 0
-[ RECORD 3 ]-------------------------+------------------------------
...

9.3 - AUDIT_LICENSE_SIZE

触发数据库大小的立即审核，以确定它是否符合 Vertica 许可证中的原始数据存储限额。

如果使用存储在 HDFS 中的 ORC 或 Parquet 数据，则仅当您以有权访问所有 HDFS 数据的用户身份运行此函数时，结果才准确。使用对所有此类数据具有读取权限的主体，或使用授予此访问权限的 Hadoop 委派令牌运行查询。有关使用委派令牌的详细信息，请参阅访问已进行 Kerberize 的 HDFS 数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_LICENSE_SIZE()

超级用户

示例

=> SELECT audit_license_size();
 audit_license_size
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

9.4 - AUDIT_LICENSE_TERM

触发立即审核，以确定 Vertica 许可证是否已过期。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

AUDIT_LICENSE_TERM()

超级用户

示例

=> SELECT audit_license_term();
 audit_license_term
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

9.5 - DISPLAY_LICENSE

返回 Vertica 许可证的期限。此函数显示的信息为：

  • 许可证的有效期开始日期和结束日期（如果许可证没有到期日，则显示“永久”(Perpetual)）。

  • 许可证期限到期后，可继续使用 Vertica 的天数（宽限期）

  • 在许可证包含数据限额的情况下，数据库可以存储的数据量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISPLAY_LICENSE()

特权

无

示例

=> SELECT DISPLAY_LICENSE();
                  DISPLAY_LICENSE
---------------------------------------------------
 Vertica Systems, Inc.
2007-08-03
Perpetual
500GB

(1 row)

9.6 - GET_AUDIT_TIME

报告自动审核数据库大小的时间。如果您的 Vertica 许可证包含数据大小限额，Vertica 将执行此审核。有关此审核的详细信息，请参阅《管理员指南》中的管理许可证。要更改审核运行的时间，请使用 SET_AUDIT_TIME 函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_AUDIT_TIME()

特权

无

示例

=> SELECT get_audit_time();
get_audit_time
-----------------------------------------------------
 The audit is scheduled to run at 11:59 PM each day.
(1 row)

9.7 - GET_COMPLIANCE_STATUS

显示您的数据库是否符合 Vertica 许可证协议要求。此信息包括 Vertica 最近对数据库大小的审核结果（如果您的许可证条款中具有数据限额）、许可证期限（如果您的许可证具有结束日期）和节点数（如果您的许可证具有节点限制）。

GET_COMPLIANCE_STATUS 按 TB 衡量数据限额（其中 1 TB 等于 10244 字节）。

GET_COMPLIANCE_STATUS 显示的信息包括：

  • 数据库的估计大小（有关大小估计的说明，请参阅审核数据库大小）。

  • Vertica 许可证所允许的原始数据大小。

  • 您的数据库目前使用的限额百分比。

  • 节点数和许可证限制。

  • 上次审核的日期和时间。

  • 您的数据库是否符合许可证协议的数据限额条款。

  • 许可证的结束日期。

  • 许可证到期之前的天数。

如果审核显示您的许可证不符合数据限额要求，应该删除数据以使数据库大小低于许可的数量，或升级您的许可证。如果您的许可证已到期，应该立即联系 Vertica 以续订许可证。有关更多详细信息，请参阅管理许可证。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_COMPLIANCE_STATUS()

特权

无

示例

=> SELECT GET_COMPLIANCE_STATUS();
 get_compliance_status
--------------------
Raw Data Size: 0.00TB +/- 0.00TB
License Size : 10.00TB
Utilization  : 0%
Audit Time   : 2015-09-24 12:19:15.425486-04
Compliance Status : The database is in compliance with respect to raw data size.

License End Date: 2015-11-23 00:00:00 Days Remaining: 60.53
(1 row)

以下示例显示了 Vertica for SQL on Apache Hadoop 群集的输出。

=> SELECT GET_COMPLIANCE_STATUS();
 get_compliance_status
--------------------
Node count : 4
License Node limit : 5
No size-compliance concerns for an Unlimited license

No expiration date for a Perpetual license
(1 row)

9.8 - SET_AUDIT_TIME

设置 Vertica 执行自动数据库大小审核的时间，以确定数据库大小是否符合 Vertica 许可证中的原始数据限额。如果当前计划在数据库活动高峰期进行审核，请使用此函数。这通常不是问题，因为自动审核对数据库性能几乎没有影响。

审核是由上一次审核计划的，因此更改审核时间不会影响下一次计划的审核。例如，如果您计划在晚上 11:59 进行下一次审核，然后您使用 SET_AUDIT_TIME 将审核计划更改为凌晨 3 点，则之前计划的晚上 11:59 的审核仍会运行。该审核完成后，它将计划在凌晨 3 点进行下一次审核。

即使使用 SET_AUDIT_TIME 更改审核时间，然后通过发出语句 SELECT AUDIT_LICENSE_SIZE 触发自动审核，Vertica 也会始终执行下一次计划的审核。只有在下一次计划的审核完成之后，Vertica 才会在您使用 SET_AUDIT_TIME 设置的新时间开始审核。此后，Vertica 在新时间进行审核。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_AUDIT_TIME(time)
time
包含 'HH:MM AM/PM' 格式的时间的字符串（例如，'1:00 AM'），表示审核每天的运行时间。

超级用户

示例

=> SELECT SET_AUDIT_TIME('3:00 AM');
                            SET_AUDIT_TIME
-----------------------------------------------------------------------
 The scheduled audit time will be set to 3:00 AM after the next audit.
(1 row)

10 - 通知程序函数

此部分包含用于使用和管理通知程序的函数。

10.1 - GET_DATA_COLLECTOR_NOTIFY_POLICY

列出在 数据收集器组件上设置的所有通知策略。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_DATA_COLLECTOR_NOTIFY_POLICY('component')
component
要检查其通知策略的数据收集器组件的名称。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)

示例

=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
                   GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------------------------------------------
 Notifiable;  Notifier: vertica_stats; Channel: vertica_notifications
(1 row)

以下示例显示了当组件未设置通知策略时函数的输出：


=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
 GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 Not notifiable;
(1 row)

另请参阅

10.2 - NOTIFY

向 NOTIFIER 发送指定消息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

NOTIFY ( 'message', 'notifier', 'target‑topic' )

参数

message
要发送到端点的消息。
notifier
NOTIFIER 的名称。
target‑topic
基于 notifier 类型指定以下内容之一的字符串：

  • Kafka：消息的现有目标 Kafka 主题的名称。

  • Syslog：ProblemDescription 主题和 channel 值。

超级用户

示例

发送消息以确认 ETL 作业已完成：

=> SELECT NOTIFY('ETL Done!', 'my_notifier', 'DB_activity_topic');

10.3 - SET_DATA_COLLECTOR_NOTIFY_POLICY

为 数据收集器组件创建/启用通知策略。当某些事件发生时，通知策略会自动向指定的 NOTIFIER 发送消息。

要查看数据收集器组件上的现有通知策略，请参阅 GET_DATA_COLLECTOR_NOTIFY_POLICY。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_DATA_COLLECTOR_NOTIFY_POLICY('component','notifier', 'topic', enabled)
component
将通过通知程序报告其更改的组件的名称。

查询系统表 DATA_COLLECTOR 的组件名称。例如：

=> SELECT DISTINCT component, description FROM data_collector WHERE component ilike '%Depot%' ORDER BY component;
   component    |          description
----------------+-------------------------------
 DepotEvictions | Files evicted from the Depot
 DepotFetches   | Files fetched to the Depot
 DepotUploads   | Files Uploaded from the Depot
(3 rows)
notifier
将发送消息的通知程序的名称。
topic
以下几项之一：

  • Kafka：将接收通知消息的 Kafka 主题的名称。

  • Syslog：字段 ProblemDescription 的主题。

enabled
布尔值，指定是否启用此策略。设置为 TRUE 表示启用报告组件更改。设置为 FALSE 表示禁用通知程序。

示例

Kafka 通知程序

要在登录尝试失败时收到通知，您可以创建一个通知程序，使其在 DC 组件 LoginFailures 更新时发送通知。TLSMODE 'verify-ca’ 将验证服务器的证书是否由受信任的 CA 签名。

=> CREATE NOTIFIER vertica_stats ACTION 'kafka://kafka01.example.com:9092' MAXMEMORYSIZE '10M' TLSMODE 'verify-ca';
CREATE NOTIFIER
=> SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','vertica_stats', 'vertica_notifications', true);
SET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 SET
(1 row)

以下示例显示如何禁用在上一个示例中创建的策略：

=> SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','vertica_stats', 'vertica_notifications', false);
 SET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 SET
(1 row)


=> SELECT GET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures');
 GET_DATA_COLLECTOR_NOTIFY_POLICY
----------------------------------
 Not notifiable;
(1 row)

Syslog 通知程序

以下示例创建了一个通知程序，当 数据收集器 (DC) 组件 LoginFailures 更新时，它会向 syslog 写入一条消息：

  1. 为当前数据库启用 syslog 通知程序：

    => ALTER DATABASE DEFAULT SET SyslogEnabled = 1;

  2. 创建并启用系统日志通知程序 v_syslog_notifier：

    => CREATE NOTIFIER v_syslog_notifier ACTION 'syslog'
    ENABLE
    MAXMEMORYSIZE '10M'
    IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
    PARAMETERS 'eventSeverity = 5';

  3. 配置 syslog 通知程序 v_syslog_notifier 以更新具有 SET_DATA_COLLECTOR_NOTIFY_POLICY 的 LoginFailures DC 组件：

    => SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','v_syslog_notifier', 'Login failed!', true);

    当用户未能以用户 Bob 身份进行身份验证时，此通知程序将以下消息写入 syslog（默认位置：/var/log/messages）：Apr 25 16:04:58 vertica_host_01 vertica： Event Posted: Event Code:21 Event Id:0 Event Severity: Notice [5] PostedTimestamp: 2022-04-25 16:04:58.083063 ExpirationTimestamp: 2022-04-25 16:04:58.083063 EventCodeDescription: Notifier ProblemDescription: (Login failed!) { "_db":"VMart", "_schema":"v_internal", "_table":"dc_login_failures", "_uuid":"f8b0278a-3282-4e1a-9c86-e0f3f042a971", "authentication_method":"Reject", "client_authentication_name":"default: Reject", "client_hostname":"::1", "client_label":"", "client_os_user_name":"dbadmin", "client_pid":523418, "client_version":"", "database_name":"dbadmin", "effective_protocol":"3.8", "node_name":"v_vmart_node0001", "reason":"REJECT", "requested_protocol":"3.8", "ssl_client_fingerprint":"", "ssl_client_subject":"", "time":"2022-04-25 16:04:58.082568-05", "user_name":"Bob" }#012 DatabaseName: VMart Hostname: vertica_host_01

另请参阅

11 - 分区函数

此部分包含 Vertica 专用的分区管理函数。

11.1 - CALENDAR_HIERARCHY_DAY

指定将 DATE 分区键分成年、月和日的层次结构。Vertica Tuple Mover 会定期根据当前日期评估分区键，并根据需要将分区合并到相应的年份和月份分区组中。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CALENDAR_HIERARCHY_DAY( partition‑expression[, active‑months[, active‑years] ] )

参数

partition‑expression
用于对分区键分组的 DATE 表达式，必须与表的 PARTITION BY 表达式相同。
active‑months
一个 ≥ 0 的整数，指定将 MONTH(CURRENT_DATE) 前多少个月的唯一分区键存储在单独的分区中。

如果指定为 1，则只将当月的分区键存储在单独的分区中。

如果指定为 0，则将当月的所有分区键合并到该月的分区组中。

有关详细信息，请参阅分层分区。

默认值： 2

active‑years
一个 ≥ 0 的整数，指定将 YEAR(CURRENT_DATE) 前多少年的分区键按月份分组到单独的分区中。

如果指定为 1，则只将当年的分区键存储在月份分区组中。

如果指定为 0，则将当前和以前年份的所有分区键合并到年份分区组中。

有关详细信息，请参阅分层分区。

默认值： 2

使用

在表分区子句中指定此函数，作为其 GROUP BY 表达式：

PARTITION BY partition‑expression
  GROUP BY CALENDAR_HIERARCHY_DAY(
     group‑expression
      [, active‑months[, active‑years] ] )

例如：

=> CREATE TABLE public.store_orders
(
    order_no int,
    order_date timestamp NOT NULL,
    shipper varchar(20),
    ship_date date
);
...
=> ALTER TABLE public.store_orders
      PARTITION BY order_date::DATE
      GROUP BY CALENDAR_HIERARCHY_DAY(order_date::DATE, 3, 2) REORGANIZE;

有关用法的详细信息，请参阅分层分区。

另请参阅

分层分区

11.2 - COPY_PARTITIONS_TO_TABLE

将分区从一个表复制到另一个表中。这种轻型分区复制可通过在两个表之间初始共享同一个存储来提高性能。完成复制操作后，各表彼此独立。用户对每个表执行操作时不会影响另一个表。这些操作可增加两个表所需的存储总量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COPY_PARTITIONS_TO_TABLE (
    '[[database.]schema.]source‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target‑table'
     [, 'force‑split']
)

参数

[database.]schema

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

source‑table
要复制的分区的源表。
min‑range‑value max‑range‑value
要复制的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要复制某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
要复制的分区的目标表。 如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 对源表的 TRUNCATE 权限（如果 force-split 为 true）和 SELECT 权限，对目标表的 INSERT 权限

如果目标表不存在，则必须在目标架构上具有 CREATE 权限以启用表创建。

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

如果调用 COPY_PARTITIONS_TO_TABLE 且目标表不存在，该函数将自动创建此表。在以下示例中，目标表 partn_backup.tradfes_200801 不存在。 COPY_PARTITIONS_TO_TABLE 创建该表并复制分区。Vertica 还会复制与源表关联的所有约束，外键约束除外。

=> SELECT COPY_PARTITIONS_TO_TABLE (
          'prod_trades',
          '200801',
          '200801',
          'partn_backup.trades_200801');
COPY_PARTITIONS_TO_TABLE
-------------------------------------------------
 1 distinct partition values copied at epoch 15.
(1 row)

另请参阅

存档分区

11.3 - DROP_PARTITIONS

删除指定的表分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_PARTITIONS (
    '[[database.]schema.]table‑name',
    'min‑range‑value',
    'max‑range‑value'
    [, 'force‑split']
)

参数

[database.]schema

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

table‑name
目标表。此表不能用作预联接投影中的维度表，且不能包含过期（未刷新）的投影。
min‑range‑value max‑range‑value
要删除的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要删除某个分区键，min‑range‑value 和 max‑range‑value 必须相等。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

以下几项之一：

  • DBADMIN

  • 表所有者

  • 对表架构的 USAGE 权限和对表的 TRUNCATE 权限

示例

请参阅删除分区。

另请参阅

PARTITION_TABLE

11.4 - DUMP_PROJECTION_PARTITION_KEYS

转储指定投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_PROJECTION_PARTITION_KEYS( '[[database.]schema.]projection-name')

参数

[database.]schema

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

projection‑name
投影名称

特权

非超级用户：对锚表的 TRUNCATE 权限

示例

下列语句将分别创建表和投影 online_sales.online_sales_fact 和 online_sales.online_sales_fact_rep，并将按列 call_center_key 对表数据进行分区：

=> CREATE TABLE online_sales.online_sales_fact
(
    sale_date_key int NOT NULL,
    ship_date_key int NOT NULL,
    product_key int NOT NULL,
    product_version int NOT NULL,
    customer_key int NOT NULL,
    call_center_key int NOT NULL,
    online_page_key int NOT NULL,
    shipping_key int NOT NULL,
    warehouse_key int NOT NULL,
    promotion_key int NOT NULL,
    pos_transaction_number int NOT NULL,
    sales_quantity int,
    sales_dollar_amount float,
    ship_dollar_amount float,
    net_dollar_amount float,
    cost_dollar_amount float,
    gross_profit_dollar_amount float,
    transaction_type varchar(16)
)
PARTITION BY (online_sales_fact.call_center_key);

=> CREATE PROJECTION online_sales.online_sales_fact_rep AS SELECT * from online_sales.online_sales_fact unsegmented all nodes;

下列 DUMP_PROJECTION_PARTITION_KEYS 语句将转储投影 online_sales.online_sales_fact_rep 中的分区键：

=> SELECT DUMP_PROJECTION_PARTITION_KEYS('online_sales.online_sales_fact_rep');

Partition keys on node v_vmart_node0001
  Projection 'online_sales_fact_rep'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 200
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 199
   ...
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 2
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 1

 Partition keys on node v_vmart_node0002
  Projection 'online_sales_fact_rep'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 200
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: 199
...
(1 row)

另请参阅

11.5 - DUMP_TABLE_PARTITION_KEYS

转储指定表的所有投影的分区键。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DUMP_TABLE_PARTITION_KEYS ( '[[database.]schema.]table‑name' )

参数

[database.]schema

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

table‑name
表的名称

特权

非超级用户：对表的 TRUNCATE 权限

示例

下列示例将创建一个名为 states 的简单表并按状态对数据进行分区：

=> CREATE TABLE states (year INTEGER NOT NULL,
       state VARCHAR NOT NULL)
       PARTITION BY state;
=> CREATE PROJECTION states_p (state, year) AS
       SELECT * FROM states
       ORDER BY state, year UNSEGMENTED ALL NODES;

现在转储表 states 上锚定的所有投影的分区键值：

=> SELECT DUMP_TABLE_PARTITION_KEYS( 'states' );
      DUMP_TABLE_PARTITION_KEYS                                                               --------------------------------------------------------------------------------------------
 Partition keys on node v_vmart_node0001
  Projection 'states_p'
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: VT
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: PA
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: NY
   Storage [ROS container]
     No of partition keys: 1
     Partition keys: MA

 Partition keys on node v_vmart_node0002
...
(1 row)

另请参阅

11.6 - MOVE_PARTITIONS_TO_TABLE

将分区从一个表移至另一个表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVE_PARTITIONS_TO_TABLE (
    '[[database.]schema.]source‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target-table'
     [, force‑split]
)

参数

[database.]schema

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

source‑table
需要移动的分区所在的源表。
min‑range‑value max‑range‑value
要移动的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要移动某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
分区移动的目标表。 如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 对源表的 SELECT 和 TRUNCATE 权限，对目标表的 INSERT 权限

如果目标表不存在，则必须在目标架构上具有 CREATE 权限以启用表创建。

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

请参阅存档分区。

另请参阅

11.7 - PARTITION_PROJECTION

拆分指定投影的 ROS 容器。 PARTITION_PROJECTION 如果在 AHM 时期之前应用了删除，则也会在对 ROS 容器分区时清除数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PARTITION_PROJECTION ( '[[database.]schema.]projection')

参数

[database.]schema

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

projection
要分区的投影。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

在此示例中，PARTITION_PROJECTION 会强制拆分 states_p 投影中的 ROS 容器：

=> SELECT PARTITION_PROJECTION ('states_p');
  PARTITION_PROJECTION
------------------------
 Projection partitioned
(1 row)

另请参阅

11.8 - PARTITION_TABLE

调用 Tuple Mover，以根据需要重新组织 ROS 存储容器以符合当前分区策略。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PARTITION_TABLE ( '[schema.]table‑name')

参数

[database.]schema

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

table‑name
要分区的表。

特权

  • 表所有者

  • 对架构的 USAGE 权限

限制

  • 不能在实时聚合投影或 Top-K 投影的锚表中运行 PARTITION_TABLE。

  • 要重新组织存储以符合新策略，请在更改分区 GROUP BY 表达式后运行 PARTITION_TABLE。

另请参阅

11.9 - PURGE_PARTITION

清除已删除行的表分区。类似 PURGE 和 PURGE_PROJECTION，该函数会从物理存储中移除已删除的数据，这样可以重复使用磁盘空间。 PURGE_PARTITION 仅移除 AHM 时期及更早时期的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_PARTITION ( '[[database.]schema.]table', partition‑key )

参数

[database.]schema

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

表
要清除的已分区的表。
partition‑key
要清除的分区的键。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例列出了表中每个分区已删除行的数量，然后调用 PURGE_PARTITION() 从数据清除已删除的行。

=> SELECT partition_key,table_schema,projection_name,sum(deleted_row_count)
   AS deleted_row_count FROM partitions
   GROUP BY partition_key,table_schema,projection_name
   ORDER BY partition_key;

 partition_key | table_schema | projection_name | deleted_row_count
---------------+--------------+-----------------+-------------------
 0             | public       | t_super         |                 2
 1             | public       | t_super         |                 2
 2             | public       | t_super         |                 2
 3             | public       | t_super         |                 2
 4             | public       | t_super         |                 2
 5             | public       | t_super         |                 2
 6             | public       | t_super         |                 2
 7             | public       | t_super         |                 2
 8             | public       | t_super         |                 2
 9             | public       | t_super         |                 1
(10 rows)
=> SELECT PURGE_PARTITION('t',5); -- Purge partition with key 5.
                            purge_partition
------------------------------------------------------------------------
 Task: merge partitions
(Table: public.t) (Projection: public.t_super)
(1 row)

=> SELECT partition_key,table_schema,projection_name,sum(deleted_row_count)
   AS deleted_row_count FROM partitions
   GROUP BY partition_key,table_schema,projection_name
   ORDER BY partition_key;


 partition_key | table_schema | projection_name | deleted_row_count
---------------+--------------+-----------------+-------------------
 0             | public       | t_super         |                 2
 1             | public       | t_super         |                 2
 2             | public       | t_super         |                 2
 3             | public       | t_super         |                 2
 4             | public       | t_super         |                 2
 5             | public       | t_super         |                 0
 6             | public       | t_super         |                 2
 7             | public       | t_super         |                 2
 8             | public       | t_super         |                 2
 9             | public       | t_super         |                 1
(10 rows)

另请参阅

11.10 - SWAP_PARTITIONS_BETWEEN_TABLES

在两个表之间切换分区。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SWAP_PARTITIONS_BETWEEN_TABLES (
    '[[database.]schema.]staging‑table',
    'min‑range‑value',
    'max‑range‑value',
    '[[database.]schema.]target‑table'
     [, force‑split]
)

参数

[database.]schema

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

临时表
用于切换分区的临时表。
min‑range‑value max‑range‑value
要交换的分区键的最小值和最大值，其中 min‑range‑value 必须 ≤ max‑range‑value。要交换某个分区，min‑range‑value 和 max‑range‑value 必须相等。
目标表
待切换分区的表。目标表不能与临时表相同。
force‑split

可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：

  • true：根据需要拆分 ROS 容器。

  • false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。

特权

非超级用户，为以下之一：

  • 源表和目标表的所有者

  • 目标表和源表：TRUNCATE、INSERT、SELECT

要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区子句

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。有关约束的详细信息，请参阅约束。

  • 检查约束。对于 MOVE_PARTITIONS_TO_TABLE 和 COPY_PARTITIONS_TO_TABLE，Vertica 仅在目标表上强制执行已启用的检查约束。对于 SWAP_PARTITIONS_BETWEEN_TABLES，Vertica 会在两个表上强制执行已启用的检查约束。如果违反了已启用的检查约束，Vertica 将回退此操作。

  • 文本索引的数量和定义。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有目标表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。

限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 目标表不能是不可变的。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

请参阅交换分区。

12 - 权限和访问函数

此部分包含用于管理用户和角色权限以及访问策略的函数。

12.1 - ENABLED_ROLE

检查是否启用了 Vertica 用户角色，并返回 true 或 false。当为数据库角色创建访问策略时，通常会使用此函数。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENABLED_ROLE ( 'role' )

参数

角色
要评估的角色。

特权

无

示例

请参阅：

另请参阅

CREATE ACCESS POLICY

12.2 - GET_PRIVILEGES_DESCRIPTION

返回当前用户对对象具有的有效权限，包括显式权限、隐式权限、继承的权限以及基于用户的权限。

因为此元函数仅返回有效权限，因此 GET_PRIVILEGES_DESCRIPTION 将只返回完全满足先决条件的权限。有关常见操作的先决条件列表，请参阅常用数据库操作所需的权限。

例如，用户必须具有以下权限才能查询表：

  • 架构： USAGE

  • 表： SELECT

如果用户 Brooke 对表 s1.t1 具有 SELECT 权限，但缺少对架构 s1 的 USAGE 权限，则 Brooke 将无法查询该表，且 GET_PRIVILEGES_DESCRIPTION 不会返回该表的 SELECT 权限。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PRIVILEGES_DESCRIPTION( 'type', '[[database.]schema.]name' );

参数

类型
指定对象类型，为以下之一：

  • database

  • table

  • schema

  • view

  • sequence

  • model

  • library

  • resource pool

[database.]schema
指定数据库和架构，默认情况下分别为当前数据库和 public。
name
目标对象的名称

特权

无

示例

在以下示例中，用户 Glenn 设置了 REPORTER 角色，并希望检查他对架构 s1 和表 s1.articles 的有效权限。

  • 表 s1.articles 从其架构 (s1) 继承权限。

  • REPORTER 角色具有以下权限：

    • 对架构的 SELECT 权限 s1

    • 对表的 INSERT WITH GRANT OPTION 权限 s1.articles

  • 用户 Glenn 具有以下权限：

    • 对架构 s1 的 UPDATE 和 USAGE 权限。

    • 对表 s1.articles 的 DELETE 权限。

GET_PRIVILEGES_DESCRIPTION 返回 Glenn 对架构 s1 的以下有效权限：

=> SELECT GET_PRIVILEGES_DESCRIPTION('schema', 's1');
   GET_PRIVILEGES_DESCRIPTION
--------------------------------
 SELECT, UPDATE, USAGE
(1 row)

GET_PRIVILEGES_DESCRIPTION 返回 Glenn 对表 s1.articles 的以下有效权限：


=> SELECT GET_PRIVILEGES_DESCRIPTION('table', 's1.articles');
   GET_PRIVILEGES_DESCRIPTION
--------------------------------
 INSERT*, SELECT, UPDATE, DELETE
(1 row)

另请参阅

12.3 - HAS_ROLE

检查是否已将 Vertica 用户角色授予指定的用户或角色，并返回 true 或 false。

您还可以查询系统表 ROLES、GRANTS 和 USERS，以获取有关用户及其角色分配的信息。有关详细信息，请参阅查看用户角色。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

HAS_ROLE( [ 'grantee' ,] 'verify‑role' );

参数

grantee
仅对超级用户有效，指定要查找的用户或角色的名称。如果忽略此实参，则函数将使用当前用户名 ( CURRENT_USER)。如果指定了角色，Vertica 会检查是否向此角色授予在 verify‑role 中指定的角色。
verify‑role
要为 grantee 验证的角色名称。

特权

无

示例

在以下示例中，dbadmin 用户检查是否为用户 MikeL 分配了 admnistrator 角色：

=> \c
You are now connected as user "dbadmin".
=> SELECT HAS_ROLE('MikeL', 'administrator');
 HAS_ROLE
----------
 t
(1 row)

用户 MikeL 检查其是否具有 regional_manager 角色：

=> \c - MikeL
You are now connected as user "MikeL".
=> SELECT HAS_ROLE('regional_manager');
 HAS_ROLE
----------
 f
(1 row)

dbadmin 将 regional_manager 角色授予 administrator 角色。再次检查时，MikeL 会验证他现在具有 regional_manager 角色：

dbadmin=> \c
You are now connected as user "dbadmin".
dbadmin=> GRANT regional_manager to administrator;
GRANT ROLE
dbadmin=> \c - MikeL
You are now connected as user "MikeL".
dbadmin=> SELECT HAS_ROLE('regional_manager');
 HAS_ROLE
----------
 t
(1 row)

另请参阅

12.4 - RELEASE_SYSTEM_TABLES_ACCESS

启用非超级用户对所有系统表的访问权限。调用此函数后，Vertica 将忽略表 SYSTEM_TABLES 中的 IS_ACCESSIBLE_DURING_LOCKDOWN 设置。要继续对非超级用户强制执行对系统表的访问限制，请调用 RESTRICT_SYSTEM_TABLES_ACCESS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_SYSTEM_TABLES_ACCESS()

特权

超级用户

12.5 - RESTRICT_SYSTEM_TABLES_ACCESS

检查系统表 SYSTEM_TABLES，以确定非超级用户可以访问哪些系统表。非超级用户对每个系统表的访问权限由布尔列 IS_ACCESSIBLE_DURING_LOCKDOWN 指定。当调用此函数时，Vertica 会检查每个系统表上的 IS_ACCESSIBLE_DURING_LOCKDOWN 设置，并相应地强制控制所有非超级用户的访问权限。

默认情况下，Vertica 强制应用 IS_ACCESSIBLE_DURING_LOCKDOWN 设置。要启用非超级用户对所有系统表的访问权限，必须显式调用 RELEASE_SYSTEM_TABLES_ACCESS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESTRICT_SYSTEM_TABLES_ACCESS()

特权

超级用户

13 - 投影函数

此部分包含 Vertica 专用的投影管理函数。

另请参阅

13.1 - CLEAR_PROJECTION_REFRESHES

从系统表 PROJECTION_REFRESHES 中清除信息投影刷新历史记录。

系统表 PROJECTION_REFRESHES 记录刷新操作成功和失败的相关信息。PROJECTION_REFRESHES 将保留投影刷新数据，直到出现以下事件之一为止：

  • 给定的投影中开始出现另一个刷新操作。

  • CLEAR_PROJECTION_REFRESHES PROJECTION_REFRESHES 被调用并清除所有投影的数据。

  • 已超出表的存储配额。

CLEAR_PROJECTION_REFRESHES 会检查 PROJECTION_REFRESHES 布尔列 IS_EXECUTING，以确定刷新操作是否仍在运行或已完成。该函数仅移除已完成的刷新操作的信息。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_PROJECTION_REFRESHES()

超级用户

示例

=> SELECT CLEAR_PROJECTION_REFRESHES();
 CLEAR_PROJECTION_REFRESHES
----------------------------
 CLEAR
(1 row)

另请参阅

13.2 - EVALUATE_DELETE_PERFORMANCE

针对潜在的 DELETE 和 UPDATE 性能问题对投影进行评估。如果 Vertica 发现任何问题，则会发出警告消息。在评估多个投影时，EVALUATE_DELETE_PERFORMANCE 将返回最多十个有问题的投影，以及列出其发现的所有问题的表的名称。

有关解决删除和更新性能问题的信息，请参阅 优化 DELETE 和 UPDATE。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

EVALUATE_DELETE_PERFORMANCE ( ['[[database.]schema.]scope'] )

参数

[database.]schema

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

scope
指定要评估的投影，为以下之一：

  • [table.]projection
    评估 projection。例如：

    SELECT EVALUATE_DELETE_PERFORMANCE('store.store_orders_fact.store_orders_fact_b1');

  • 表
    指定评估 table 的所有投影。例如：

    SELECT EVALUATE_DELETE_PERFORMANCE('store.store_orders_fact');

如果未提供实参，EVALUATE_DELETE_PERFORMANCE 将评估您可以访问的所有投影。根据数据库的大小，这可能会产生很大的开销。

特权

非超级用户：对锚表的 SELECT 权限

示例

EVALUATE_DELETE_PERFORMANCE 会针对潜在的 DELETE 和 UPDATE 性能问题对表 example 的所有投影进行评估。

=> create table example (A int, B int,C int);
CREATE TABLE
=> create projection one_sort (A,B,C) as (select A,B,C from example) order by A;
CREATE PROJECTION
=> create projection two_sort (A,B,C) as (select A,B,C from example) order by A,B;
CREATE PROJECTION
=> select evaluate_delete_performance('example');
            evaluate_delete_performance
---------------------------------------------------
 No projection delete performance concerns found.
(1 row)

上一示例表明，one_sort 和 two_sort 这两个投影不存在会引发 DELETE 性能降低的固有结构问题。但如果排序后的列不能唯一标识一行或小量行，则投影中包含的数据可能产生潜在删除问题。

在下面的示例中，Perl 用于通过嵌套的循环系列来为表填充数据：

  • 内部循环填充列 C.

  • 中间循环填充列 B。

  • 外部循环填充列 A。

结果为：列 A 仅包含三个非重复值（0、1 和 2），而列 B 在 20 和 0 之间缓慢变化，列 C 则在每行中均有变化：

=> \\! perl -e 'for ($i=0; $i<3; $i++) { for ($j=0; $j<21; $j++) { for ($k=0; $k<19; $k++) { printf "%d,%d,%d\n", $i,$j,$k;}}}' | /opt/vertica/bin/vsql -c "copy example from stdin delimiter ',' direct;"
Password:
=> select * from example;
 A | B  | C
---+----+----
 0 | 20 | 18
 0 | 20 | 17
 0 | 20 | 16
 0 | 20 | 15
 0 | 20 | 14
 0 | 20 | 13
 0 | 20 | 12
 0 | 20 | 11
 0 | 20 | 10
 0 | 20 |  9
 0 | 20 |  8
 0 | 20 |  7
 0 | 20 |  6
 0 | 20 |  5
 0 | 20 |  4
 0 | 20 |  3
 0 | 20 |  2
 0 | 20 |  1
 0 | 20 |  0
 0 | 19 | 18
 ...
 2 |  1 |  0
 2 |  0 | 18
 2 |  0 | 17
 2 |  0 | 16
 2 |  0 | 15
 2 |  0 | 14
 2 |  0 | 13
 2 |  0 | 12
 2 |  0 | 11
 2 |  0 | 10
 2 |  0 |  9
 2 |  0 |  8
 2 |  0 |  7
 2 |  0 |  6
 2 |  0 |  5
 2 |  0 |  4
 2 |  0 |  3
 2 |  0 |  2
 2 |  0 |  1
 2 |  0 |  0
=> SELECT COUNT (*) FROM example;
 COUNT
-------
  1197
(1 row)
=> SELECT COUNT (DISTINCT A) FROM example;
 COUNT
-------
     3
(1 row)

再次对投影运行 EVALUATE_DELETE_PERFORMANCE，以确定投影内的数据是否会引发任何潜在的 DELETE 性能问题。投影 one_sort 具有潜在的删除性能问题，因为它仅按照具有较少非重复值的列 A 进行排序。排序列中的各值与投影中的多个行对应，而这对 DELETE 性能有负面影响。相反，投影 two_sort 按照列 A 和列 B 进行排序，两个排序列中的每个值组合均可以仅标识少数行，便于删除操作快速执行：


=> select evaluate_delete_performance('example');
            evaluate_delete_performance
---------------------------------------------------
 The following projections exhibit delete performance concerns:
        "public"."one_sort_b1"
        "public"."one_sort_b0"
See v_catalog.projection_delete_concerns for more details.

=> \x
Expanded display is on.
dbadmin=> select * from projection_delete_concerns;
-[ RECORD 1 ]------+------------------------------------------------------------------------------------------------------------------------------------------------------------
projection_id      | 45035996273878562
projection_schema  | public
projection_name    | one_sort_b1
creation_time      | 2019-06-17 13:59:03.777085-04
last_modified_time | 2019-06-17 14:00:27.702223-04
comment            | The squared number of rows matching each sort key is about 159201 on average.
-[ RECORD 2 ]------+------------------------------------------------------------------------------------------------------------------------------------------------------------
projection_id      | 45035996273878548
projection_schema  | public
projection_name    | one_sort_b0
creation_time      | 2019-06-17 13:59:03.777279-04
last_modified_time | 2019-06-17 13:59:03.777279-04
comment            | The squared number of rows matching each sort key is about 159201 on average.

如果忘记向 EVALUATE_DELETE_PERFORMANCE 提供实参，它将评估您可以访问的所有投影：

=> select evaluate_delete_performance();
                          evaluate_delete_performance
---------------------------------------------------------------------------
 The following projections exhibit delete performance concerns:
        "public"."one_sort_b0"
        "public"."one_sort_b1"
See v_catalog.projection_delete_concerns for more details.
(1 row)

13.3 - GET_PROJECTION_SORT_ORDER

返回投影的 ORDER BY 子句中列的顺序。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTION_SORT_ORDER( '[[database.]schema.]projection' );

参数

[database.]schema

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

projection
目标投影。

特权

非超级用户：对锚表的 SELECT 权限

示例

=> SELECT get_projection_sort_order ('store_orders_super');
                                 get_projection_sort_order
--------------------------------------------------------------------------------------------
 public.store_orders_super [Sort Cols: "order_no", "order_date", "shipper", "ship_date"]

(1 row)

13.4 - GET_PROJECTION_STATUS

返回与 projection 的状态相关的信息：

  • 数据库的当前 K-safety 状态

  • 数据库中节点的数量

  • 投影是否已分段

  • 伙伴实例投影的数量和名称

  • 投影是否安全

  • 投影是否为最新

  • 是否已经为投影计算了统计信息

使用 [GET_PROJECTION_STATUS](#) 来监控投影数据刷新的进度。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTION_STATUS ( '[[database.]schema.]projection' );

参数

[database.]schema

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

projection
要显示其状态的投影。

示例

=> SELECT GET_PROJECTION_STATUS('public.customer_dimension_site01');
                                     GET_PROJECTION_STATUS
-----------------------------------------------------------------------------------------------
 Current system K is 1.
# of Nodes: 4.
public.customer_dimension_site01 [Segmented: No] [Seg Cols: ] [K: 3] [public.customer_dimension_site04, public.customer_dimension_site03,
public.customer_dimension_site02]
[Safe: Yes] [UptoDate: Yes][Stats: Yes]

13.5 - GET_PROJECTIONS

返回指定锚表的投影的上下文和投影信息。

上下文信息

  • 数据库 K-safety

  • 数据库节点数

  • 此表的投影的数量

投影数据
对于每个投影，指定：

  • 所有伙伴实例投影

  • 是否分段

  • 是否 安全

  • 是否为最新。

还可以使用 GET_PROJECTIONS 来监控投影数据的刷新进度。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_PROJECTIONS ( '[[database.]schema-name.]table' )

参数

[database.]schema

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

表
要列出的投影的锚表。

特权

无

示例

以下示例将获取有关 VMart 表 store.store_dimension 的投影的信息：

=> SELECT GET_PROJECTIONS('store.store_dimension');
-[ RECORD 1 ]---+
GET_PROJECTIONS | Current system K is 1.
# of Nodes: 3.
Table store.store_dimension has 2 projections.

Projection Name: [Segmented] [Seg Cols] [# of Buddies] [Buddy Projections] [Safe] [UptoDate] [Stats]
----------------------------------------------------------------------------------------------------
store.store_dimension_b1 [Segmented: Yes] [Seg Cols: "store.store_dimension.store_key"] [K: 1] [store.store_dimension_b0] [Safe: Yes] [UptoDate: Yes] [Stats: RowCounts]
store.store_dimension_b0 [Segmented: Yes] [Seg Cols: "store.store_dimension.store_key"] [K: 1] [store.store_dimension_b1] [Safe: Yes] [UptoDate: Yes] [Stats: RowCounts]

13.6 - PURGE_PROJECTION

从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。

有关清除操作的详细信息，请参阅 PURGE。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_PROJECTION ( '[[database.]schema.]projection' )

参数

[database.]schema

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

projection
要清除的投影。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例将清除 Ancient History Mark 时期之前的投影 tbl_p 中的所有历史数据。

=> CREATE TABLE tbl (x int, y int);
CREATE TABLE
=> INSERT INTO tbl VALUES(1,2);
 OUTPUT
--------
      1
(1 row)

=> INSERT INTO tbl VALUES(3,4);
 OUTPUT
--------
      1
(1 row)

dbadmin=> COMMIT;
COMMIT
=> CREATE PROJECTION tbl_p AS SELECT x FROM tbl UNSEGMENTED ALL NODES;
WARNING 4468: Projection <public.tbl_p> is not available for query processing.
Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION
=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
 Starting refresh background process.
=> DELETE FROM tbl WHERE x=1;
 OUTPUT
--------
      1
(1 row)

=> COMMIT;
COMMIT
=> SELECT MAKE_AHM_NOW();
         MAKE_AHM_NOW
-------------------------------
 AHM set (New AHM Epoch: 9066)
(1 row)

=> SELECT PURGE_PROJECTION ('tbl_p');
 PURGE_PROJECTION
-------------------
 Projection purged
(1 row)

另请参阅

13.7 - REFRESH

在前台同步刷新一个或多个表投影，并更新 PROJECTION_REFRESHES 系统表。如果在不使用实参的情况下运行 REFRESH，则它会刷新所有包含过时数据的投影。

有关投影刷新的详细信息，请参阅刷新投影。

如果刷新会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REFRESH ( [ '[[database.]schema.]table[,...]' ] )

参数

[database.]schema

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

表
要刷新的投影的锚表。如果指定多个表，REFRESH 会尝试并行刷新。此类调用将包含在 Database Designer 部署（和部署脚本）中。

返回

Projection Name
作为刷新目标的投影。
Anchor Table
投影的关联锚表。
Status
投影的刷新状态：

  • queued：排队等待刷新。

  • refreshing：正在刷新。

  • refreshed：已成功完成刷新。

  • failed：未成功完成刷新。

Refresh Method
用于刷新投影的方法。
Error Count
投影刷新失败的次数。
Duration (sec)
投影刷新运行的时间（以秒为单位）。

特权

刷新方法

Vertica 可以刷新其伙伴实例之一中的投影（如有）。在这种情况下，目标投影将获取源伙伴实例的历史数据。否则，将使用刷新操作时的最新时期数据从头开始刷新投影。在这种情况下，投影不能参与刷新操作之前的任何时期的历史查询。

要确定用来刷新给定投影的方法，请查询 PROJECTION_REFRESHES 系统表中的 REFRESH_METHOD 列。

示例

以下示例将刷新两个表中的投影：

=> SELECT REFRESH('t1, t2');
                                             REFRESH
----------------------------------------------------------------------------------------
Refresh completed with the following outcomes:

Projection Name: [Anchor Table] [Status] [Refresh Method] [Error Count] [Duration (sec)]
----------------------------------------------------------------------------------------

"public"."t1_p": [t1] [refreshed] [scratch] [0] [0]"public"."t2_p": [t2] [refreshed] [scratch] [0] [0]

在以下示例中，仅刷新了一个表中的投影：

=> SELECT REFRESH('allow, public.deny, t');
                                               REFRESH
----------------------------------------------------------------------------------------

Refresh completed with the following outcomes:

Projection Name: [Anchor Table] [Status] [Refresh Method] [Error Count] [Duration (sec)]
----------------------------------------------------------------------------------------
"n/a"."n/a": [n/a] [failed: insufficient permissions on table "allow"] [] [1] [0]
"n/a"."n/a": [n/a] [failed: insufficient permissions on table "public.deny"] [] [1] [0]
"public"."t_p1": [t] [refreshed] [scratch] [0] [0]

另请参阅

13.8 - REFRESH_COLUMNS

刷新使用约束 SET USING 或 DEFAULT USING 定义的表列。与 REFRESH_COLUMNS 调用关联的所有刷新操作属于同一个事务。因此，必须刷新 REFRESH_COLUMNS 指定的所有表和列；否则，整个操作将回退。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REFRESH_COLUMNS ( 'table‑list', '[column‑list]'
   [, '[refresh‑mode ]' [, min‑partition‑key, max‑partition‑key] ]
)

参数

table‑list
要刷新的表的逗号分隔列表：

[[database.]schema.]table[,...]

column‑list
要刷新的列的逗号分隔列表，指定如下：
  • [[[database.]schema.]table.]column[,...]
  • [[database.]schema.]table.*

其中星号 (*) 指定刷新 表 中的所有 SET USING/DEFAULT USING 列。例如：

SELECT REFRESH_COLUMNS ('t1, t2', 't1.*, t2.b', 'REBUILD');

如果 column‑list 设置为空字符串 ('')，REFRESH_COLUMNS 会刷新指定表中的所有 SET USING/DEFAULT USING 列。

需要满足以下要求：

  • 所有指定列必须具有 SET USING 或 DEFAULT USING 约束。

  • 如果 REFRESH_COLUMNS 指定多个表，则所有列名必须通过其表名进行限定。如果目标表跨越多个架构，则所有列名必须通过其架构和表名完全限定。例如：

    SELECT REFRESH_COLUMNS ('t1, t2', 't1.a, t2.b', 'REBUILD');

如果指定一个数据库，它必须是当前数据库。

refresh‑mode
指定如何刷新 SET USING 列：

  • UPDATE ：将原始行标记为已删除并用新行替换它们。为了保存这些更新，您必须发出 COMMIT 语句。

  • REBUILD: 替换指定列中的所有数据。重建操作是自动提交的。

如果设置为空字符串或被忽略，则在 UPDATE 模式下执行 REFRESH_COLUMNS。如果指定多个表，则必须显式指定 REBUILD 模式。

在这两种情况下，如果任何 SET USING 列定义为 强制执行约束的表中的主键或唯一键，则 REFRESH_COLUMNS 将返回错误。

有关使用 REBUILD 选项的限制，请参阅 REBUILD 模式限制。

min‑partition‑key
max‑partition‑key
限定 REBUILD 模式，将重建操作限定在一个或多个分区。要指定分区范围，max-partition-key 必须大于 min-partition-key。要更新某个分区，两个实参必须相等。

需要满足以下要求：

  • 函数只能指定一个表进行刷新。

  • 表必须在指定的键上进行分区。

您可以使用这些实参通过最近加载的数据（即最新分区中的数据）刷新列。定期使用此选项可以显著降低因重建大型表中的整个列而产生的开销。

有关详细信息，请参阅下文中的基于分区的 REBUILD。

特权

  • 查询表和平展表的架构：USAGE

  • 查询表：SELECT

  • 平展表：SELECT、UPDATE

UPDATE 与 REBUILD 模式

通常，当对 SET USING 列数据的更改仅限于相对较少的行数时，选择 UPDATE 模式较为妥当。如果大量 SET USING 列数据过时且必须更新，请使用 REBUILD 模式。无论在任何新 SET USING 列上使用 REBUILD 调用 REFRESH_COLUMNS 都是一种很好的做法 — 例如，在使用 ALTER TABLE...ADD COLUMN 添加 SET USING 列之后对其进行填充。

REBUILD 模式限制

如果在 SET USING 列上调用 REFRESH_COLUMNS 并将刷新模式指定为 REBUILD，则 Vertica 会在以下任何一项中指定该列时返回错误：

基于分区的 REBUILD 操作

如果对平展表进行分区，则可通过指定一个或多个分区键来降低在 REBUILD 模式下调用 REFRESH_COLUMNS 的开销。这样做会将重建操作限制到指定的分区。例如，通过 SET USING 列 cust_name 定义表 public.orderFact。此表在列 order_date 上进行分区，其中分区子句调用 Vertica 函数 CALENDAR_HIERARCHY_DAY。因此，您可以对此表的特定时间分隔分区调用 REFRESH_COLUMNS — 在本例中，是指对过去两个月的订单调用：

=> SELECT REFRESH_COLUMNS ('public.orderFact',
                        'cust_name',
                        'REBUILD',
                        TO_CHAR(ADD_MONTHS(current_date, -2),'YYYY-MM')||'-01',
                        TO_CHAR(LAST_DAY(ADD_MONTHS(current_date, -1))));
      REFRESH_COLUMNS
---------------------------
 refresh_columns completed
(1 row)

重写 SET USING 查询

当您在平展表的 SET USING（或 DEFAULT USING）列中调用 REFRESH_COLUMNS 时，它将通过联接目标表和源表来执行 SET USING 查询。默认情况下，源表始终为联接的内表。大多数情况下，源表的基数小于目标表，因此 REFRESH_COLUMNS 有效地执行联接。

有时，特别是当您在分区表上调用 REFRESH_COLUMNS 时，源表有可能比目标表更大。在这种情况下，联接操作的性能可能欠佳。

您可以通过启用配置参数 RewriteQueryForLargeDim 来解决此问题。启用 (1) 后，Vertica 将反转目标表和源表之间的内部和外部联接，以此重写查询。

示例

请参阅 修整表示例 和 DEFAULT 与 SET USING。

13.9 - START_REFRESH

使用各自 锚表的最新数据刷新 当前架构中的投影。START_REFRESH 在后台异步运行，并更新PROJECTION_REFRESHES 系统表。正在运行刷新时，则此函数无效。

要仅刷新特定表的投影，请使用 REFRESH。当通过 Database Designer 部署设计 时，将自动刷新其投影。

如果刷新会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

START_REFRESH()

特权

无

要求

所有节点必须开启。

刷新方法

Vertica 可以刷新其伙伴实例之一中的投影（如有）。在这种情况下，目标投影将获取源伙伴实例的历史数据。否则，将使用刷新操作时的最新时期数据从头开始刷新投影。在这种情况下，投影不能参与刷新操作之前的任何时期的历史查询。

要确定用来刷新给定投影的方法，请查询 PROJECTION_REFRESHES 系统表中的 REFRESH_METHOD 列。

示例

=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
 Starting refresh background process.
(1 row)

另请参阅

14 - 会话函数

此部分包含 Vertica 专用的会话管理函数。

另请参阅 SQL 系统表 V_MONITOR.SESSIONS。

14.1 - CANCEL_REFRESH

取消 START_REFRESH 和 REFRESH 启动的刷新相关内部操作。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CANCEL_REFRESH()

特权

无

注意

  • 刷新任务在内部会话的后台线程中运行，因此不能使用 INTERRUPT_STATEMENT 取消这些语句。相反，使用 CANCEL_REFRESH 取消通过刷新相关内部会话运行的语句。

  • 在启动 START_REFRESH() 的同一节点上运行 CANCEL_REFRESH()。

  • CANCEL_REFRESH() 取消在节点上运行的刷新操作，等待完成取消并返回 SUCCESS。

  • 任何时候，一个节点上都只能运行一组刷新操作。

示例

取消后台执行的刷新操作。

=> SELECT START_REFRESH();
             START_REFRESH
----------------------------------------
Starting refresh background process.
(1 row)

=> SELECT CANCEL_REFRESH();
              CANCEL_REFRESH
----------------------------------------
Stopping background refresh process.
(1 row)

另请参阅

14.2 - CLOSE_ALL_SESSIONS

关闭所有外部会话（除发布此函数的外部会话以外）。关闭 Vertica 数据库之前调用此函数。

Vertica 异步关闭会话，因此可以在返回此函数之前打开其他会话。在这种情况下，请重新发出此函数。要查看所有打开会话的状态，请查询系统表 SESSIONS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_ALL_SESSIONS()

特权

非超级用户：设置为“无 (None)”以关闭自己的会话

示例

在单独的节点上打开两个用户会话：

=> SELECT * FROM sessions;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0002
user_name                  | dbadmin
client_hostname            | 127.0.0.1:57174
client_pid                 | 30117
login_timestamp            | 2011-01-03 15:33:00.842021-05
session_id                 | stress05-27944:0xc1a
client_label               |
transaction_start          | 2011-01-03 15:34:46.538102
transaction_id             | -1
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n';)
statement_start            | 2011-01-03 15:34:46.538862
statement_id               |
last_statement_duration_us | 26250
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n';
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 3 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               |
last_statement_duration_us | 1591403
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

关闭所有会话：

=> \x
Expanded display is off.
=> SELECT CLOSE_ALL_SESSIONS();
                           CLOSE_ALL_SESSIONS
-------------------------------------------------------------------------
 Close all sessions command sent. Check v_monitor.sessions for progress.
(1 row)

发出 CLOSE_ALL_SESSIONS 之后的会话内容：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (SELECT * FROM sessions;)
statement_start            | 2011-01-03 16:19:56.720071
statement_id               | 25
last_statement_duration_us | 15605
current_statement          | SELECT * FROM SESSIONS;
ssl_state                  | None
authentication_method      | Trust

另请参阅

14.3 - CLOSE_SESSION

中断指定的外部会话，回退当前事务（如果有），并关闭套接字。您只能关闭自己的会话。

关闭会话可能需要花费一些时间。要查看所有打开会话的状态，请查询系统表 SESSIONS。

有关会话管理选项的详细信息，请参阅 管理会话。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_SESSION ( 'sessionid')

参数

sessionid
指定要关闭的会话的字符串。此标识符在群集的任何时间点都唯一，但是可以在会话关闭时重复使用。

特权

无

示例

用户会话已打开。记录 2 显示运行 COPY DIRECT 语句的用户会话。

=> SELECT * FROM sessions;
-[ RECORD 1 ]--------------+-----------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (SELECT * FROM sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+-----------------------------------------------
node_name                  | v_vmartdb_node0002
user_name                  | dbadmin
client_hostname            | 127.0.0.1:57174
client_pid                 | 30117
login_timestamp            | 2011-01-03 15:33:00.842021-05
session_id                 | stress05-27944:0xc1a
client_label               |
transaction_start          | 2011-01-03 15:34:46.538102
transaction_id             | -1
transaction_description    | user dbadmin (COPY ClickStream_Fact FROM
                             '/data/clickstream/1g/ClickStream_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:34:46.538862
statement_id               |
last_statement_duration_us | 26250
current_statement          | COPY ClickStream_Fact FROM '/data/clickstream
                             /1g/ClickStream_Fact.tbl' DELIMITER '|' NULL
                             '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

关闭用户会话 stress05-27944:0xc1a

=> \x
Expanded display is off.
=> SELECT CLOSE_SESSION('stress05-27944:0xc1a');
                           CLOSE_SESSION
--------------------------------------------------------------------
 Session close command sent. Check v_monitor.sessions for progress.
(1 row)

再次查询会话表以了解当前状态，您可以看到第二个会话已被关闭：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+--------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from SESSIONS;)
statement_start            | 2011-01-03 16:12:07.841298
statement_id               | 20
last_statement_duration_us | 2099
current_statement          | SELECT * FROM SESSIONS;
ssl_state                  | None
authentication_method      | Trust

另请参阅

14.4 - CLOSE_USER_SESSIONS

停止用户会话，回退当前正在运行的任何事务，并关闭连接。要确定要关闭的会话的状态，请查询 SESSIONS 表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLOSE_USER_SESSIONS ( 'user‑name' )

参数

user‑name
指定要关闭其会话的用户。如果指定自己的用户名，Vertica 将关闭所有会话，但发出此函数的会话除外。

特权

DBADMIN

示例

此示例将关闭用户 u1 的所有活动会话：

=> SELECT close_user_sessions('u1');

另请参阅

14.5 - GET_NUM_ACCEPTED_ROWS

返回在当前会话的上一个已完成加载中加载到数据库的行数。GET_NUM_ACCEPTED_ROWS 是一个 元函数。请勿将其用作 INSERT 查询中的值。

对于当前正在处理的加载，无法获得已接受的行数。在 LOAD_STREAMS 系统表中检查其状态。

此元函数支持来自 STDIN 的负载、来自 Vertica 客户端的 COPY LOCAL 或发起程序上的单个文件。对于多节点加载，无法使用 GET_NUM_ACCEPTED_ROWS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_NUM_ACCEPTED_ROWS();

特权

无

示例

此示例显示了 vmart_load_data.sql 元命令接受的行数。

=> \i vmart_load_data.sql;

=> SELECT GET_NUM_ACCEPTED_ROWS ();
GET_NUM_ACCEPTED_ROWS
-----------------------
300000
(1 row)

另请参阅

14.6 - GET_NUM_REJECTED_ROWS

返回在当前会话的上一个已完成加载期间拒绝的行数。GET_NUM_REJECTED_ROWS 是一个 元函数。请勿将其用作 INSERT 查询中的值。

对于当前正在运行的加载，已拒绝的行的信息不可用。对于当前正在处理的加载，无法获得拒绝的行数。在 LOAD_STREAMS 系统表中检查其状态。

此元函数支持来自 STDIN 的负载、来自 Vertica 客户端的 COPY LOCAL 或发起程序上的单个文件。对于多节点加载，无法使用 GET_NUM_REJECTED_ROWS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

GET_NUM_REJECTED_ROWS();

特权

无

示例

此示例显示了 vmart_load_data.sql 元命令拒绝的行数。

=>  \i vmart_load_data.sql

=> SELECT GET_NUM_REJECTED_ROWS ();
GET_NUM_REJECTED_ROWS
-----------------------
0
(1 row)

另请参阅

14.7 - INTERRUPT_STATEMENT

中断用户会话中的指定语句，回滚当前事务，把成功/失败消息写入日志文件。

执行语句过程中可以中断会话。中断只可针对用户会话运行的语句。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INTERRUPT_STATEMENT( 'session‑id', statement‑id)

参数

session‑id
标识要中断的会话。在任何时间点，群集标识符都是唯一的。
statement‑id
标识要中断的语句。如果 statement‑id 有效，则可中断语句，INTERRUPT_STATEMENT 将返回成功消息。否则，系统将返回错误消息：

超级用户

消息

你可能会遇到的消息列表见下文：

示例

两个用户对话是打开状态。RECORD 1 表示用户会话正在运行 SELECT FROM SESSION，RECORD 2 表示用户会话正在运行 COPY DIRECT：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               | 5
last_statement_duration_us | 1591403
current_statement          | COPY Mart_Fact FROM '/data/Mart_Fact.tbl' DELIMITER '|'
                             NULL '\\n' DIRECT;
ssl_state                  | None
authentication_method      | Trust

中断会话 stress06-25663:0xbec 中运行的 COPY DIRECT 语句：

=> \x
Expanded display is off.
=> SELECT INTERRUPT_STATEMENT('stress06-25663:0x1537', 5);
                       interrupt_statement
------------------------------------------------------------------
 Statement interrupt sent. Check v_monitor.sessions for progress.
(1 row)

确认语句已被成功中断，不再处于激活状态。可检查 SESSIONS 系统表中的 current_statement 列。语句被中断后，该列为空：

=> SELECT * FROM SESSIONS;
-[ RECORD 1 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0001
user_name                  | dbadmin
client_hostname            | 127.0.0.1:52110
client_pid                 | 4554
login_timestamp            | 2011-01-03 14:05:40.252625-05
session_id                 | stress04-4325:0x14
client_label               |
transaction_start          | 2011-01-03 14:05:44.325781
transaction_id             | 45035996273728326
transaction_description    | user dbadmin (select * from sessions;)
statement_start            | 2011-01-03 15:36:13.896288
statement_id               | 10
last_statement_duration_us | 14978
current_statement          | select * from sessions;
ssl_state                  | None
authentication_method      | Trust
-[ RECORD 2 ]--------------+----------------------------------------------------
node_name                  | v_vmartdb_node0003
user_name                  | dbadmin
client_hostname            | 127.0.0.1:56367
client_pid                 | 1191
login_timestamp            | 2011-01-03 15:31:44.939302-05
session_id                 | stress06-25663:0xbec
client_label               |
transaction_start          | 2011-01-03 15:34:51.05939
transaction_id             | 54043195528458775
transaction_description    | user dbadmin (COPY Mart_Fact FROM '/data/Mart_Fact.tbl'
                             DELIMITER '|' NULL '\\n' DIRECT;)
statement_start            | 2011-01-03 15:35:46.436748
statement_id               | 5
last_statement_duration_us | 1591403
current_statement          |
ssl_state                  | None
authentication_method      | Trust

另请参阅

14.8 - RELEASE_ALL_JVM_MEMORY

强制所有会话释放其 Java 虚拟机 (JVM) 所用的内存。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_ALL_JVM_MEMORY();

特权

必须为 超级用户。

示例

以下示例演示了查看所有打开的会话中的 JVM 内存使用情况，然后调用 RELEASE_ALL_JVM_MEMORY() 释放内存的过程：

=> select user_name,external_memory_kb FROM V_MONITOR.SESSIONS;
 user_name | external_memory_kb
-----------+---------------
 dbadmin   |         79705
(1 row)

=> SELECT RELEASE_ALL_JVM_MEMORY();
                           RELEASE_ALL_JVM_MEMORY
-----------------------------------------------------------------------------
 Close all JVM sessions command sent. Check v_monitor.sessions for progress.
(1 row)

=> SELECT user_name,external_memory_kb FROM V_MONITOR.SESSIONS;
 user_name | external_memory_kb
-----------+---------------
 dbadmin   |             0
(1 row)

另请参阅

14.9 - RELEASE_JVM_MEMORY

终止 Java 虚拟机 (JVM)，使 JVM 所用的内存变为可用状态。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RELEASE_JVM_MEMORY();

特权

无。

示例

用户会话已打开。RECORD 2 将显示运行 COPY DIRECT 语句的用户会话。

=> SELECT RELEASE_JVM_MEMORY();

           release_jvm_memory

-----------------------------------------
Java process killed and memory released

(1 row)

另请参阅

14.10 - RESERVE_SESSION_RESOURCE

保留 General 资源池中的内存资源，以仅供 Vertica 备份和还原进程使用。其他任何 Vertica 进程都不能访问保留的资源。如果可用的资源量不足，Vertica 会将保留请求排入队列。

此元函数是会话级别的保留。当会话结束时，Vertica 会自动释放该会话中保留的任何资源。由于该元函数在会话级别运行，因此多个会话之间的资源名称无需唯一确定。

可通过查询 SESSIONS 表来查看保留的资源。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESERVE_SESSION_RESOURCE ( 'name', memory)

参数

name
要保留的资源的名称。
memory
要分配给资源的内存量（以 KB 为单位）。

特权

无

示例

将 1024 KB 的内存保留用于备份和还原进程：

=> SELECT reserve_session_resource('VBR_RESERVE',1024);
   -[ RECORD 1 ]------------+----------------
   reserve_session_resource | Grant succeed

14.11 - RESET_SESSION

将默认的连接字符串配置设置应用于当前会话。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESET_SESSION()

示例

以下示例显示了如何使用 RESET_SESSION。

将当前客户端连接字符串重置为默认的连接字符串设置：

=> SELECT RESET_SESSION();
    RESET_SESSION
----------------------
 Reset session: done.
(1 row)

15 - 存储函数

此部分包含 Vertica 专用的存储管理函数。

15.1 - ALTER_LOCATION_LABEL

将标签添加到存储位置，或者更改或移除现有标签。如果任何存储策略未指定位置标签，则可进行更改。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ALTER_LOCATION_LABEL ( 'path' , '[node]' , '[location‑label]' )

参数

路径
存储位置路径。
节点
应用标签更改的节点。如果提供空字符串，Vertica 会将更改应用于所有群集节点。
location‑label
要分配给指定存储位置的标签。如果提供空字符串，Vertica 会移除该存储位置的标签。

超级用户

限制

只有当这两个条件都为真时，您才能移除位置标签：

  • 未在数据库对象的存储策略中指定标签。

  • 标记的位置不是其关联对象的最后一个可用存储。

示例

以下 ALTER_LOCATION_LABEL 语句将标签 SSD 应用于存储位置 /home/dbadmin/SSD/tables 的所有群集节点：

=> SELECT ALTER_LOCATION_LABEL('/home/dbadmin/SSD/tables','', 'SSD');
          ALTER_LOCATION_LABEL
---------------------------------------
 /home/dbadmin/SSD/tables label changed.
(1 row)

另请参阅

15.2 - ALTER_LOCATION_USE

更改存储位置保存的数据类型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ALTER_LOCATION_USE ( 'path' , '[node]' , 'usage' )

参数

路径
挂载存储位置的位置。
节点
要更改存储位置的 Vertica 节点。要在单个事务中更改所有群集节点的位置，请使用空字符串 ('')。如果 usage 为 SHARED TEMP 或 SHARED USER，则必须在所有节点上进行更改。
usage
以下几项之一：

  • DATA：该存储位置仅存储数据文件。

  • TEMP：该位置仅存储加载或查询期间创建的临时文件。

  • DATA,TEMP：该位置可同时存储两种类型的文件。

超级用户

您不能更改 USER 使用类型的存储位置（如果存储位置是以这种方式创建的），也不能将存储位置更改为 USER 类型（如果存储位置不是以这种方式创建的）。可以更改 USER 存储位置以指定 DATA（不支持存储 TEMP 文件）。但是，这样做不会影响 USER 存储位置的主要目标可由具有已分配权限的非 dbadmin 用户访问。

您不能将存储位置从 SHARED TEMP 或 SHARED USER 更改为 SHARED DATA，反之亦然。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

以下示例将跨所有群集节点将存储位置更改为仅存储数据：

=> SELECT ALTER_LOCATION_USE ('/thirdSL/' , '' , 'DATA');

另请参阅

15.3 - CLEAR_CACHES

清除 Vertica 内部缓存文件。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_CACHES ( )

超级用户

注意

如果要为查询运行基准测试，除清除内部 Vertica 缓存文件之外，还要清除 Linux 文件系统缓存。内核使用未分配的内存作为缓存以保持磁盘块纯净。如果运行的是 Linux 2.6.16 或更高版本且具有 root 访问权限，则可清除内核文件系统缓存，如下所示：

  1. 确保缓存中的所有数据均已写入磁盘：

    # sync

  2. 写入 drop_caches 文件会导致内核从内存中删除干净缓存、条目和 iNode，使该内存进入空闲状态，如下所示：

    • 要清除页面缓存，请执行以下操作：

      # echo 1 > /proc/sys/vm/drop_caches

    • 要清除条目和 iNode，请执行以下操作：

      # echo 2 > /proc/sys/vm/drop_caches

    • 要清除页面缓存、条目和 iNode，请执行以下操作：

      # echo 3 > /proc/sys/vm/drop_caches

示例

以下示例清除 Vertica 内部缓存文件：

=> SELECT CLEAR_CACHES();
 CLEAR_CACHES
--------------
 Cleared
(1 row)

15.4 - CLEAR_OBJECT_STORAGE_POLICY

从指定的数据库、架构或表中移除用户定义的存储策略。先前策略标记位置的存储容器将移动到默认位置。默认情况下，此移动发生在所有挂起的合并任务返回之后。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

CLEAR_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] [, 'enforce‑storage‑move' ] )

参数

object‑name
要清除的对象，为以下之一：

  • database：清除存储策略的 database。

  • [database.]schema: 清除存储策略的 schema。

  • [[database.]schema.]table: 清除存储策略的 table。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。

在所有情况下，database 必须为当前数据库的名称。

key‑min
key‑max
仅当 object‑name 为表时有效，指定存储在标记位置的表分区键值的范围。
enforce‑storage‑move
指定 Tuple Mover 将指定对象的所有现有存储容器移动到其默认存储位置的时间：

  • false （默认值）：仅在所有待定合并任务返回后移动存储容器。

  • true：立即将所有存储容器移动到新位置。

超级用户

示例

以下语句可清除表 store.store_orders_fact 的存储策略。true 实参指定立即实施移动策略：

=> SELECT CLEAR_OBJECT_STORAGE_POLICY ('store.store_orders_fact', 'true');
                         CLEAR_OBJECT_STORAGE_POLICY
-----------------------------------------------------------------------------
 Object storage policy cleared.
Task: moving storages
(Table: store.store_orders_fact) (Projection: store.store_orders_fact_b0)
(Table: store.store_orders_fact) (Projection: store.store_orders_fact_b1)

(1 row)

另请参阅

15.5 - DO_TM_TASK

运行 Tuple Mover (TM) 操作并提交当前事务。您可以将此操作限定于特定表或投影。开始使用此函数时，TM 会使用 GENERAL 资源池而不是 TM 资源池。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DO_TM_TASK('task'[, '[[database.]schema.]{ table | projection}]' )

参数

task
指定以下 Tuple Mover 操作之一：

  • mergeout：合并 ROS 容器并清除删除的记录。有关详细信息，请参阅合并。

  • reshardmergeout：重新调整存储容器，使其符合通过 RESHARD_DATABASE 调用创建的分片定义。指定表或投影以及分区值范围，限制 reshardmergeout 操作的范围。

  • analyze_row_count：收集一组最少的统计信息并聚合指定投影的行计数，然后将其保存在数据库编录中。收集指定投影中的行数。如果指定一个表名，DO_TM_TASK 会返回该表所有投影的行计数。有关详细信息，请参阅分析行计数。

  • update_storage_catalog （仅推荐用于 Eon 模式）：使用捆绑表数据的元数据更新编录。有关详细信息，请参阅将捆绑包元数据写入编录。

[database.]schema

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

table | projection
将 task 应用到指定表或投影。如果指定了投影，但未查找到该投影，则 DO_TM_TASK 会查找具有该名称的表，如果能够找到，则会将任务应用至该表及与该表相关联的所有投影。

如果未指定表或投影，则会将该任务应用于所有数据库表及其投影。

特权

  • 架构：USAGE

  • 表：INSERT、UPDATE 或 DELETE 之一

示例

以下示例对表中的所有投影执行合并：

=> SELECT DO_TM_TASK('mergeout', 't1');

您可以对表的一系列分区执行重新分片合并任务：

=> SELECT DO_TM_TASK('reshardmergeout', 'store_orders', '2001', '2005');

15.6 - DROP_LOCATION

永久移除已停用的存储位置。此操作无法撤消。必须先使用 RETIRE_LOCATION 停用存储位置，然后再将其删除；不能删除正在使用的存储位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DROP_LOCATION ( 'path', 'node' )

参数

路径
要删除的存储位置所挂载的位置。
节点
要在其上删除位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。

超级用户

带有临时文件和数据文件的存储位置

如果使用某存储位置来存储数据，之后将其更改为仅存储临时文件，则该位置仍会包含数据文件。Vertica 不允许删除含数据文件的存储位置。您可以使用 MOVE_RETIRED_LOCATION_DATA 函数手动合并存储位置中的数据文件，或者您也可以删除分区。删除数据文件操作无效。

示例

下列示例展示如何删除 v_vmart_node0003 上之前停用的存储位置：

=> SELECT DROP_LOCATION('/data', 'v_vmart_node0003');

另请参阅

15.7 - ENFORCE_OBJECT_STORAGE_POLICY

仅限企业模式

立即应用指定对象的存储策略。默认情况下，Tuple Mover 在所有挂起的合并操作完成后强制执行对象存储策略。调用此函数相当于在使用 RETIRE_LOCATION 时设置 enforce 实参。此函数通常用作删除存储位置前的最后一步。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ENFORCE_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] )

参数

object‑name
要应用其存储策略的数据库对象，为以下之一：

  • database：应用 database 存储策略。

  • [database.]schema: 应用 schema 存储策略。

  • [[database.]schema.]table: 应用 table存储策略。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。

在所有情况下，database 必须为当前数据库的名称。

key‑min, key‑max
仅当 object‑name 为表时有效，指定要执行移动的表分区键值的范围。

特权

以下几项之一：

  • 超级用户

  • 对象所有者及对其存储位置的访问权限。

示例

将存储策略更新应用于 test 表：

=> SELECT ENFORCE_OBJECT_STORAGE_POLICY ('test');

另请参阅

15.8 - MEASURE_LOCATION_PERFORMANCE

测量存储位置的磁盘性能。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MEASURE_LOCATION_PERFORMANCE ( 'path', 'node' )

参数

路径
指定测量的存储位置。
节点
测量位置可用的 Vertica 节点。要获取群集上所有节点名称的列表，请查询系统表 DISK_STORAGE。

超级用户

注意

  • 如果您试图基于预测或测量访问模式，创建将投影、列和分区存储在不同磁盘的磁盘分层结构，您需要对每一个存放数据的存储位置的性能进行测量。您无需测量临时数据存储位置的性能，因为临时文件基于可用空间进行存储。

  • 测量存储位置性能的方法仅适用于已配置的群集。如果您想在配置群集以前测量磁盘，请参阅 测量存储性能。

  • 存储位置性能等同于从磁盘读取写入 1MB 数据所耗费的时长。这个时间等同于：

    IO‑time = (time‑to‑read‑write‑1MB + time‑to‑seek) = (1/throughput + 1/latency)

    吞吐量为顺序读写的平均吞吐量（以每秒兆字节表示）。

    延迟适用于随机读取（仅在查找中，单位为每秒查找次数）。

示例

下面的例子测量 v_vmartdb_node0004 上的一个存储位置的性能：

=> SELECT MEASURE_LOCATION_PERFORMANCE('/secondVerticaStorageLocation/' , 'v_vmartdb_node0004');
WARNING:  measure_location_performance can take a long time. Please check logs for progress
           measure_location_performance
--------------------------------------------------
 Throughput : 122 MB/sec. Latency : 140 seeks/sec

另请参阅

15.9 - MOVE_RETIRED_LOCATION_DATA

从数据库中指定的停用存储位置或从全部停用存储位置移出全部数据。 MOVE_RETIRED_LOCATION_DATA 根据存储数据对象的存储策略，将数据移动至非停用存储位置。此函数仅在完成所有受影响的存储位置数据的迁移后才返回。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

MOVE_RETIRED_LOCATION_DATA( ['location‑path'] [, 'node'] )

参数

location‑path
系统表 STORAGE_LOCATIONS 的 LOCATION_PATH 列所指定的存储位置的路径。此存储位置必须标记为已停用。

如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有停用的存储位置移出数据。

节点
要在其上移动停用存储位置的数据的节点。如果 node 上未定义 location-path，则此函数返回错误。

如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有节点的 location-path 移出数据。

超级用户

示例

  1. 查询系统表 STORAGE_LOCATIONS，显示停用的存储位置：

    => SELECT node_name, location_path, location_label, is_retired FROM STORAGE_LOCATIONS
   WHERE is_retired = 't';
    node_name     |    location_path     | location_label | is_retired
------------------+----------------------+----------------+------------
 v_vmart_node0001 | /home/dbadmin/SSDLoc | ssd            | t
 v_vmart_node0002 | /home/dbadmin/SSDLoc | ssd            | t
 v_vmart_node0003 | /home/dbadmin/SSDLoc | ssd            | t
(3 rows)

  2. 查询系统表 STORAGE_LOCATIONS 获取消息表的位置，消息表目前存储在停用存储位置 ssd：

    => SELECT node_name, total_row_count, location_label FROM STORAGE_CONTAINERS
   WHERE projection_name ILIKE 'messages%';
    node_name     | total_row_count | location_label
------------------+-----------------+----------------
 v_vmart_node0001 |          333514 | ssd
 v_vmart_node0001 |          333255 | ssd
 v_vmart_node0002 |          333255 | ssd
 v_vmart_node0002 |          333231 | ssd
 v_vmart_node0003 |          333231 | ssd
 v_vmart_node0003 |          333514 | ssd
(6 rows)

  3. 调用 MOVE_RETIRED_LOCATION_DATA，将数据移出 ssd 存储位置。

    => SELECT MOVE_RETIRED_LOCATION_DATA('/home/dbadmin/SSDLoc');
          MOVE_RETIRED_LOCATION_DATA
-----------------------------------------------
 Move data off retired storage locations done

(1 row)

  4. 重复前述查询，验证消息表的存储位置：

    
=> SELECT node_name, total_row_count, storage_type, location_label FROM storage_containers
   WHERE projection_name ILIKE 'messages%';
    node_name     | total_row_count | location_label
------------------+-----------------+----------------
 v_vmart_node0001 |          333255 | base
 v_vmart_node0001 |          333514 | base
 v_vmart_node0003 |          333514 | base
 v_vmart_node0003 |          333231 | base
 v_vmart_node0002 |          333231 | base
 v_vmart_node0002 |          333255 | base
(6 rows)

另请参阅

15.10 - RESTORE_LOCATION

恢复之前使用 RETIRE_LOCATION 停用的存储位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RESTORE_LOCATION ( 'path', 'node' )

参数

路径
挂载停用的存储位置的位置。
节点
要在其上还原位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。

如果删除任何位置，该操作将会失败。

超级用户

还原之前停用的位置的影响

在还原存储位置之后，Vertica 会对所有群集存储位置重新排名。它将使用新恢复的位置来处理根据其排名确定的查询。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

在 node4 上还原停用的存储位置：

=> SELECT RESTORE_LOCATION ('/thirdSL/' , 'v_vmartdb_node0004');

另请参阅

15.11 - RETIRE_LOCATION

停用指定的存储位置。要获取所有现有存储位置的列表，请查询 STORAGE_LOCATIONS 系统表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

RETIRE_LOCATION ( 'path', 'node' [, enforce ] )

参数

路径
要停用的存储位置所挂载的位置。
节点
要在其上停用位置的 Vertica 节点。要在所有节点上执行此操作，请使用空字符串 ('')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。
enforce
如果为 true，位置标签将设为空字符串，并且将数据移到其他位置。然后可以删除该位置，而不会出现错误或警告。使用此实参加快删除位置。

超级用户

停用存储位置的影响

RETIRE_LOCATION 检查确认该位置不是唯一的数据和临时文件存储。每个节点上必须至少存在一个用于存储数据和临时文件的位置。但可以将这两种文件存储在同一位置或单独的位置。

如果某个位置是最后一个可用于存储其关联对象的位置，则只有将 enforce 设置为 true 才能将其停用。

在停用存储位置时：

  • 停用的位置不会存储任何新数据，除非首先使用 RESTORE_LOCATION 对其进行还原。

  • 默认情况下，如果当前停用的存储位置包含存储的数据，该数据将不会移动。因此不能删除该存储位置。相反，Vertica 将通过一次或多次合并来移除存储的数据。要在停用位置后立即将其删除，请将 enforce 设置为 true。

  • 如果当前停用的存储位置仅用于临时文件，或者使用了 enforce，则可以删除该位置。请参阅 删除存储位置 和 DROP_LOCATION。

有关每个节点使用的磁盘存储信息，请查询 DISK_STORAGE 系统表。

示例

以下示例显示了停用存储位置的两种方法：

您可以停用存储位置，未来将自动移出其数据：

=> SELECT RETIRE_LOCATION ('/data' , 'v_vmartdb_node0004');

您可以指定存储位置中要立即移动的数据，这样无需等待即可删除该位置：

=> SELECT RETIRE_LOCATION ('/data' , 'v_vmartdb_node0004', true);

另请参阅

15.12 - SET_LOCATION_PERFORMANCE

设置存储位置的磁盘性能。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_LOCATION_PERFORMANCE ( 'path', 'node' , 'throughput', 'average‑latency')

参数

路径
指定要设置的存储位置的装载位置。
节点
指定存在要设置的位置的 Vertica 节点。
throughput
指定位置的吞吐量，设置为值 ≥1。
average‑latency
指定位置的平均延迟，设置为值 ≥1。

超级用户

示例

以下示例将 node2 上的存储位置性能设置为每秒吞吐 122 MB 和每秒延迟 140 次寻道。

=> SELECT SET_LOCATION_PERFORMANCE('/secondVerticaStorageLocation/','node2','122','140');

另请参阅

15.13 - SET_OBJECT_STORAGE_POLICY

通过为数据库对象分配一个标记存储位置来创建或更改其存储策略。Tuple Mover 使用此位置存储此对象的新数据和现有数据。如果对象已具有活动存储策略，调用 SET_OBJECT_STORAGE_POLICY 会将此对象的默认存储设置为新的标记位置。对象的现有数据将移动到新位置。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

SET_OBJECT_STORAGE_POLICY (
  '[[database.]schema.]object‑name', 'location‑label'
   [,'key‑min', 'key‑max'] [, 'enforce‑storage‑move' ] )

参数

[database.]schema

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

object‑name
识别分配到标记存储位置的数据库对象。object‑name 可以解析为数据库、架构或表。
location‑label
object-name 的存储位置的标签。
key‑min
key‑max
仅当 object‑name 为表时有效，指定存储在标记位置的表分区键值的范围。
enforce‑storage‑move
指定 Tuple Mover 将 object‑name 的所有现有存储容器移动到标记存储位置的时间：

  • false （默认值）：仅在所有待定合并任务返回后移动存储容器。

  • true：立即将所有存储容器移动到新位置。

特权

以下几项之一：

  • 超级用户

  • 对象所有者及对其存储位置的访问权限。

示例

请参阅 清除存储策略

另请参阅

16 - 表函数

此部分包含用于管理表和约束的函数。

另请参阅 V_CATALOG.TABLE_CONSTRAINTS 系统表。

16.1 - ANALYZE_CONSTRAINTS

在指定范围内分析和报告约束违规

您可以在执行 INSERT、UPDATE、MERGE 或 COPY 语句时启用自动强制执行主键约束、唯一键约束和检查约束。另外，您可以在发出这些语句后使用 ANALYZE_CONSTRAINTS 验证约束。参考约束强制执行了解更多信息。

ANALYZE_CONSTRAINTS 以 SELECT * FROM t1 持有表 t1 的锁定的相同方式执行锁定。有关其他信息，请参阅 LOCKS。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

ANALYZE_CONSTRAINTS ('[[[database.]schema.]table ]' [, 'column[,...]'] )

参数

[database.]schema

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

表
标识要分析的表。如果忽略指定架构，Vertica 将使用当前架构搜索路径。如果设置为空字符串，Vertica 将分析当前架构中的所有表。
列
table 中要分析的列。可以指定多个逗号分隔列。Vertica 将分析范围缩小到指定的列。如果忽略指定列，Vertica 将分析 table 中的所有列。

特权

  • 架构：USAGE

  • 表：SELECT

在加载进程中检测约束违规

Vertica 在运行查询（而不是加载数据）时检查约束违规。要在加载进程中检测违反约束，使用 COPY 语句的 NO COMMIT 选项。通过加载数据但不提交数据，可以使用 ANALYZE_CONSTRAINTS 函数对数据执行加载后检查。如果此函数发现违反约束，由于您尚未提交数据，因此可以回退加载。

如果 ANALYZE_CONSTRAINTS 发现冲突，比如当您在主键中插入一个重复值时，则可以使用以下函数更正错误。效果仅持续到会话结束为止：

返回值

ANALYZE_CONSTRAINTS 返回一个结构集中的结果（参阅下表），其中列出造成违规的架构名称、表名称、列名称、约束名称、约束类型和列值。

如果结果集为空，则不存在违反约束；例如：

> SELECT ANALYZE_CONSTRAINTS ('public.product_dimension', 'product_key');
Schema Name | Table Name | Column Names | Constraint Name | Constraint Type | Column Values
-------------+------------+--------------+-----------------+-----------------+---------------
(0 rows)

下面的结果集显示主键冲突，以及导致冲突的值 ('10')：

=> SELECT ANALYZE_CONSTRAINTS ('');
Schema Name | Table Name | Column Names | Constraint Name | Constraint Type | Column Values
-------------+------------+--------------+-----------------+-----------------+---------------
store         t1           c1             pk_t1             PRIMARY           ('10')
(1 row)

结果集列在下表中详细描述：

示例

请参阅检测约束违规。

16.2 - ANALYZE_CORRELATIONS

分析紧密相关的列对的指定表。ANALYZE_CORRELATIONS 存储相关性最强的 20 对。ANALYZE_CORRELATIONS 还分析统计信息。

ANALYZE_CORRELATIONS 只能分析成对的单列相关。

例如，州名与国家/地区名称列紧密相关，因为通过市名通常（但并非始终）可以确认州名。康舍霍肯市与宾夕法尼亚州唯一相关，相比较而言，佐治亚州、印地安那州、肯塔基州、纽约州、弗吉尼亚州和马萨诸塞州则都有波士顿市。在本例中，市名与州名紧密相关。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

稳定

语法

ANALYZE_CORRELATIONS ('[[[database.]schema.]table ]' [, 'recalculate'] )

参数

[database.]schema

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

table-name
标识要分析的表。如果忽略指定架构，Vertica 将使用当前架构搜索路径。如果设置为空字符串，Vertica 将分析当前架构中的所有表。
recalculate
布尔值，指定是否分析之前已分析的相关列。

默认值： false

特权

以下几项之一：

示例

在下例中，ANALYZE_CORRELATIONS 分析 public 架构中所有表的列相关，即使当前不存在相关性：

=> SELECT ANALYZE_CORRELATIONS ('public.*', 'true');
 ANALYZE_CORRELATIONS
----------------------
                    0
(1 row)

16.3 - COPY_TABLE

将一个表复制到另一个表。此轻量级内存函数从源表复制 DDL 及所有用户创建的投影。同时，还会复制源表的投影统计信息。因此，源表和目标表最初具有相同的定义并共享同一个存储。

完成复制操作后，源表与复制表相互独立，因此可以对一个表执行 DML 操作而不会影响另一个表。这些操作可增加两个表所需的存储总量。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

COPY_TABLE (
    '[[database.]schema.]source-table',
    '[[database.]schema.]target-table'
)

参数

[database.]schema

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

source‑table
要复制的源表。Vertica 将此表中的所有数据复制到目标表。
目标表
源表的目标表。如果目标表已存在，Vertica 会将源附加到现有表。

如果该表不存在，Vertica 将根据源表的定义，通过调用 CREATE TABLE 包含 LIKE 和 INCLUDING PROJECTIONS 子句来创建一个表。该新表会从源表中继承所有权。有关详细信息，请参阅复制表。

特权

非超级用户：

  • 源表：SELECT

  • 目标架构/表（新建）： CREATE

  • 目标表（现有）：INSERT

表属性要求

两个表的以下属性必须完全相同：

  • 列定义，其中包括 NULL/NOT NULL 约束

  • 分段

  • 分区表达式

  • 投影数量

  • 投影排序顺序

  • 主键和唯一键约束。但是，不必以完全相同的方式启用键约束。

  • 文本索引的数量和定义。

  • 如果目标表已存在，则源表和目标表必须具有相同的访问策略。

此外，如果源表上存在访问策略，则必须满足以下条件：

  • 两个表上的访问策略必须相同。

  • 以下其中一项必须为真：

    • 执行用户拥有源表。

    • AccessPolicyManagementSuperuserOnly 设置为 true。有关详细信息，请参阅管理访问策略。

表限制

以下限制适用于源表和目标表：

  • 如果源分区和目标分区位于不同的存储层中，Vertica 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。

  • 如果源表包含序列，Vertica 会先将序列转换为整数，然后再将其复制到目标表。如果目标表包含自动增量、标识或命名序列列，Vertica 将取消复制并显示错误消息。

  • 不能将以下表用作源表或目标表：

    • 临时表

    • 虚拟表

    • 系统表

    • 外部表

示例

如果调用 COPY_TABLE 且目标表不存在，该函数将自动创建此表。在下例中，COPY_TABLE 创建目标表 public.newtable。Vertica 还会复制与源表 public.product_dimension 关联的所有约束，外键约束除外：

=> SELECT COPY_TABLE ( 'public.product_dimension', 'public.newtable');
-[ RECORD 1 ]--------------------------------------------------
copy_table | Created table public.newtable.
Copied table public.product_dimension to public.newtable

另请参阅

从其他表创建表

16.4 - DISABLE_DUPLICATE_KEY_ERROR

禁止 Vertica 在运行时找到重复主键值或唯一键值的情况下传送错误消息（与未自动启用的键约束一起使用）。视作架构不定义有任何约束，执行查询。影响限定在会话范围内。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

DISABLE_DUPLICATE_KEY_ERROR();

超级用户

示例

当您调用 DISABLE_DUPLICATE_KEY_ERROR 时，Vertica 会发出警告，通知您将忽略重复值，且结果可能会不正确。 DISABLE_DUPLICATE_KEY_ERROR 仅用于未自动启用的键约束。

=> select DISABLE_DUPLICATE_KEY_ERROR();
WARNING 3152:  Duplicate values in columns marked as UNIQUE will now be ignored for the remainder of your session or until reenable_duplicate_key_error() is called
WARNING 3539:  Incorrect results are possible. Please contact Vertica Support if unsure
 disable_duplicate_key_error
------------------------------
 Duplicate key error disabled
(1 row)

另请参阅

ANALYZE_CONSTRAINTS

16.5 - INFER_EXTERNAL_TABLE_DDL

检查 Parquet、ORC 或 Avro 格式的文件并返回可用于读取文件的 CREATE EXTERNAL TABLE AS COPY 语句。此语句可能不完整。它还可以包含更多列或名称长度超出 Vertica 支持范围的列；此函数不强制执行 Vertica 系统限制。使用它创建表之前，请始终检查输出并解决各类问题。

此函数支持 Parquet、ORC 和 Avro 格式的分区列，从输入路径推断。由于通过目录结构完成分区，所以可能不具备充足的信息来推断分区列的类型。在这种情况下，此函数显示这些列的数据类型为 UNKNOWN 并发出警告。

函数可处理大多数数据类型，包括复杂类型。如果 Vertica 不支持输入类型，则函数将发出警告。

默认情况下，函数对复杂类型使用强类型。您可以将 vertica_type_for_complex_type 参数设置为 LONG VARBINARY，将列视为灵活复杂类型。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INFER_EXTERNAL_TABLE_DDL( path USING PARAMETERS param=value[,...] )

参数

路径
文件或目录的路径。任何对 COPY 有效并使用此函数支持的文件格式的路径都有效。

参数

format
输入格式（字符串），"Parquet"、"ORC" 或 "Avro" 之一。此参数为必填。
table_name
要创建的外部表的名称。此参数为必填。

不要将架构名称作为表名的一部分；使用 table_schema 参数。

table_schema
在其中创建外部表的架构。如果忽略，则函数的输出中不包含架构。
vertica_type_for_complex_type
用于表示所有复杂类型列的类型，如果不想完全展开的话。唯一支持的值为 LONG VARBINARY。有关详细信息，请参阅可变复杂类型。

特权

非超级用户：对于用户可访问的存储位置的读取权限。

示例

在下例中，输入文件包含具有两个整数列的表的数据。可以完全推断表定义，也可以按原样使用返回的 SQL 语句。

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/orders/*.orc'
        USING PARAMETERS format = 'orc', table_name = 'orders');

                INFER_EXTERNAL_TABLE_DDL
--------------------------------------------------------------------------------------------------
create external table "orders" (
  "id" int,
  "quantity" int
) as copy from '/data/orders/*.orc' orc;
(1 row)

要在架构中创建表，请使用 table_schema 参数。不要将其添加到表名中；函数将其视为带有句点的名称，而不是架构。

以下示例显示了复杂类型的输出。您可以按原样使用定义，也可以修改 VARCHAR 大小：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/people/*.parquet'
        USING PARAMETERS format = 'parquet', table_name = 'employees');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                    INFER_EXTERNAL_TABLE_DDL
-------------------------------------------------------------------------
 create external table "employees"(
  "employeeID" int,
  "personal" Row(
    "name" varchar,
    "address" Row(
      "street" varchar,
      "city" varchar,
      "zipcode" int
    ),
    "taxID" int
  ),
  "department" varchar
 ) as copy from '/data/people/*.parquet' parquet;
(1 row)

在下例中，输入文件的 "prods" 列中包含映射。您可以将映射读取为行数组：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/orders.parquet'
    USING PARAMETERS format='parquet', table_name='orders');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                INFER_EXTERNAL_TABLE_DDL
------------------------------------------------------------------------
 create external table "orders"(
  "orderkey" int,
  "custkey" int,
  "prods" Array[Row(
    "key" varchar,
    "value" numeric(12,2)
  )],
  "orderdate" date
 ) as copy from '/data/orders.parquet' parquet;
(1 row)

在下例中，按区域对数据进行分区。函数无法推断数据类型，报告 UNKNOWN：

=> SELECT INFER_EXTERNAL_TABLE_DDL('/data/sales/*/*
        USING PARAMETERS format = 'parquet', table_name = 'sales');
WARNING 9262: This generated statement is incomplete because of one or more unknown column types.
Fix these data types before creating the table
                INFER_EXTERNAL_TABLE_DDL
------------------------------------------------------------------------
 create external table "sales"(
  "tx_id" int,
  "date" date,
  "region" UNKNOWN
) as copy from '/data/sales/*/*' PARTITION COLUMNS region parquet;
(1 row)

对于 VARCHAR 和 VARBINARY 列，此函数不指定长度。这些类型的 Vertica 默认长度为 80 字节。如果数据值较长，则使用这个未经修改的表定义可能会导致数据截断。始终查看 VARCHAR 和 VARBINARY 列，以确定是否需要指定长度。如果输入文件包含以下类型的列，则此函数将发出警告：

WARNING 9311: This generated statement contains one or more varchar/varbinary columns which default to length 80

16.6 - INFER_TABLE_DDL

检查 Parquet、ORC、JSON 或 Avro 格式的文件，并根据其内容返回 CREATE TABLE 或 CREATE EXTERNAL TABLE 语句。

如果输入数据包含不明确或未知的数据类型，则返回的语句可能不完整。它还可以包含更多列或名称长度超出 Vertica 支持范围的列；此函数不强制执行 Vertica 系统限制。使用它创建表之前，请始终检查输出并解决各类问题。

此函数支持从输入路径推断出的分区列。由于通过目录结构完成分区，所以可能不具备充足的信息来推断分区列的类型。在这种情况下，此函数显示这些列的数据类型为 UNKNOWN 并发出警告。

函数可处理大多数数据类型，包括复杂类型。如果 Vertica 不支持输入类型，则函数将发出警告。

对于 VARCHAR 和 VARBINARY 列，此函数不指定长度。这些类型的 Vertica 默认长度为 80 字节。如果数据值较长，则使用返回且未经修改的表定义可能会导致数据截断。始终查看 VARCHAR 和 VARBINARY 列，以确定是否需要指定长度。如果输入文件包含以下类型的列，则此函数将发出警告：

WARNING 9311: This generated statement contains one or more varchar/varbinary columns which default to length 80

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

INFER_TABLE_DDL( path USING PARAMETERS param=value[,...] )

参数

路径
文件或 glob 的路径。任何对 COPY 有效并使用此函数支持的文件格式的路径都有效。对于除 JSON 以外的所有格式，如果 glob 指定多个文件，则此函数将读取一个任意选择的文件。对于 JSON，函数可能会读取多个文件。请参阅 JSON。

参数

format
输入格式（字符串），"Parquet"、"ORC"、"Avro" 或 "JSON" 之一。此参数为必填。
table_name
要创建的表的名称。此参数为必填。

不要将架构名称作为表名的一部分；使用 table_schema 参数。

table_schema
在其中创建表的架构。如果忽略，则函数的输出中不包含架构。
table_type
要创建的表的类型，“原生”或“外部”。

默认值： “native”

with_copy_statement
对于原生表，是否在 CREATE TABLE 语句之外包含 COPY 语句。

默认值：false

one_line_result
是否将 DDL 作为单行返回，而不是整齐打印。单行格式可能更便于复制到 SQL 脚本中。

默认值： false（整齐打印）

max_files
（仅限 JSON。）如果 path 为 glob，则为 path 中要检查的最大文件数。使用此参数可增加函数考虑的数据量，例如，如果怀疑文件之间存在差异。文件从 glob 中任意选择而来。有关详细信息，请参阅 JSON。

默认值： 1

max_candidates
（仅限 JSON。）要显示的备选表定义的数量。函数仅为每个文件生成一个备选项，因此如果增加 max_candidates，还会增加 max_files。有关详细信息，请参阅 JSON。

默认值： 1

特权

非超级用户：对于用户可访问的存储位置的读取权限。

JSON

与其他受支持的格式不同，JSON 不会在数据文件中嵌入架构。此函数通过检查原始数据来推断 JSON 表 DDL。由于原始数据可能不明确或不一致，因此函数对此格式采用不同的方法。

对于每个输入文件，函数循环访问记录以开发备选表定义。任何记录中显示的顶级字段都将作为列包含在其中，即使并非所有记录都使用顶级字段也是如此。如果同一字段以不同类型显示到文件中，则函数选择与观察到的所有实例一致的类型。

假设一个文件包含餐厅数据：

{
    "name" : "Pizza House",
    "cuisine" : "Italian",
    "location_city" : [],
    "chain" : true,
    "hours" : [],
    "menu" : [{"item" : "cheese pizza", "price" : 7.99},
              {"item" : "spinach pizza", "price" : 8.99},
              {"item" : "garlic bread", "price" : 4.99}]
}
{
    "name" : "Sushi World",
    "cuisine" : "Asian",
    "location_city" : ["Pittsburgh"],
    "chain" : false,
    "menu" : [{"item" : "maki platter", "price" : "21.95"},
              {"item" : "tuna roll", "price" : "4.95"}]
}

第一条记录包含两个空数组，因此没有足够的信息来确定元素类型。第二条记录包含其中一个数组的字符串值，因此函数可为其推断出一种 VARCHAR 类型。其他数组元素类型仍然未知。

在第一条记录中，菜单价格为数字，但在第二条记录中，菜单价格为字符串。FLOAT 和字符串都可以强制转换为 NUMERIC，因此函数返回 NUMERIC：

=> SELECT INFER_TABLE_DDL ('/data/restaurants.json'
    USING PARAMETERS table_name='restaurants', format='json');
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/1 of total files(s):
  create table "restaurants"(
    "chain" bool,
    "cuisine" varchar,
    "hours" Array[UNKNWON],
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" numeric
    )],
    "name" varchar
  );

(1 row)

所有标量类型都可以强制转换为 VARCHAR，因此如果无法更明确地解决冲突（如在 NUMERIC 示例中），函数仍然可以返回类型。然而，并不总能通过这种方式对复杂类型进行解析。在下例中，文件中的记录包含相互冲突的 hours 字段定义：

{
    "name" : "Sushi World",
    "cuisine" : "Asian",
    "location_city" : ["Pittsburgh"],
    "chain" : false,
    "hours" : {"open" : "11:00", "close" : "22:00" }
}
{
    "name" : "Greasy Spoon",
    "cuisine" : "American",
    "location_city" : [],
    "chain" : "false",
    "hours" : {"open" : ["11:00","12:00"], "close" : ["21:00","22:00"] },
}

在第一条记录中，值为 ROW，包含两个 TIME 字段。在第二条记录中，值为 ROW，包含两个 ARRAY[TIME] 字段（代表工作日和周末时间）。这些类型相互不兼容，因此函数使用 LONG VARBINARY 推荐 灵活复杂类型：

=> SELECT INFER_TABLE_DDL ('/data/restaurants.json'
    USING PARAMETERS table_name='restaurants', format='json');
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/1 of total files(s):
  create table "restaurants"(
    "chain" bool,
    "cuisine" varchar,
    "hours" long varbinary,
    "location_city" Array[varchar],
    "name" varchar
  );

(1 row)

如果使用 glob 调用函数，默认读取一个文件。将 max_files 设置为更大的数字，以检查更多的数据。函数为每个文件计算一个备选表定义，返回涵盖最多文件的定义。

增加文件数量本身并不会增加函数返回的备选项数量。文件越多，函数可以考虑的备选项越多，但默认情况下，返回代表最多文件的单个备选项。要查看多个可能的表定义，还要设置 max_candidates。将 max_candidates 设置为大于 max_files 没有任何益处。

在下例中，glob 包含两个文件，菜单列结构截然不同。在第一个文件中，菜单字段包含两个字段：

{
    "name" : "Bob's pizzeria",
    "cuisine" : "Italian",
    "location_city" : ["Cambridge", "Pittsburgh"],
    "menu" : [{"item" : "cheese pizza", "price" : 8.25},
              {"item" : "spinach pizza", "price" : 10.50}]
}

在第二个文件中，一天当中不同时段的菜品有所不同：

{
    "name" : "Greasy Spoon",
    "cuisine" : "American",
    "location_city" : [],
    "menu" : [{"time" : "breakfast",
           "items" :
           [{"item" : "scrambled eggs", "price" : "3.99"}]
          },
          {"time" : "lunch",
           "items" :
           [{"item" : "grilled cheese", "price" : "3.95"},
        {"item" : "tuna melt", "price" : "5.95"},
        {"item" : "french fries", "price" : "1.99"}]}]
}

要查看两个备选项，请同时提出 max_files 和 max_candidates：

=> SELECT INFER_TABLE_DDL ('/data/*.json'
    USING PARAMETERS table_name='restaurants', format='json',
max_files=3, max_candidates=3);
WARNING 0:  This generated statement contains one or more float types which might lose precision
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" float
    )],
    "name" varchar
  );
Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "items" Array[Row(
        "item" varchar,
        "price" numeric
      )],
      "time" varchar
    )],
    "name" varchar
  );

(1 row)

示例

在下例中，输入路径包含具有两个整数列的表的数据。可以完全推断外部表定义，也可以按原样使用返回的 SQL 语句。函数从输入路径读取一个文件：

=> SELECT INFER_TABLE_DDL('/data/orders/*.orc'
    USING PARAMETERS format = 'orc', table_name = 'orders', table_type = 'external');

                INFER_TABLE_DDL
------------------------------------------------------------------------
create external table "orders" (
  "id" int,
  "quantity" int
) as copy from '/data/orders/*.orc' orc;
(1 row)

要在架构中创建表，请使用 table_schema 参数。不要将其添加到表名中；函数将其视为带有句点的名称，而不是架构。

以下示例显示了复杂类型的输出。您可以按原样使用定义，也可以修改 VARCHAR 大小：

=> SELECT INFER_TABLE_DDL('/data/people/*.parquet'
    USING PARAMETERS format = 'parquet', table_name = 'employees');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 create table "employees"(
  "employeeID" int,
  "personal" Row(
    "name" varchar,
    "address" Row(
      "street" varchar,
      "city" varchar,
      "zipcode" int
    ),
    "taxID" int
  ),
  "department" varchar
 );
(1 row)

在下例中，输入文件的 "prods" 列中包含映射。您可以将映射读取为行数组：

=> SELECT INFER_TABLE_DDL('/data/orders.parquet'
    USING PARAMETERS format='parquet', table_name='orders');
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80
                INFER_TABLE_DDL
------------------------------------------------------------------------
 create table "orders"(
  "orderkey" int,
  "custkey" int,
  "prods" Array[Row(
    "key" varchar,
    "value" numeric(12,2)
  )],
  "orderdate" date
 );
(1 row)

以下示例返回原生表定义和 COPY 语句，将表定义添加到一行，简化剪切和粘贴到脚本的过程：

=> SELECT INFER_TABLE_DDL('/data/orders/*.orc'
    USING PARAMETERS format = 'orc', table_name = 'orders',
                         table_type = 'native', with_copy_statement = true, one_line_result=true);

                INFER_TABLE_DDL
-----------------------------------------------------------------------
create table "orders" ("id" int, "quantity" int);
copy "orders" from '/data/orders/*.orc' orc;
(1 row)

在下例中，按区域对数据进行分区。函数无法推断数据类型，报告 UNKNOWN：

=> SELECT INFER_TABLE_DDL('/data/sales/*/*
    USING PARAMETERS format = 'orc', table_name = 'sales', table_type = 'external');
WARNING 9262:  This generated statement is incomplete because of one or more unknown column types. Fix these data types before creating the table
WARNING 9311:  This generated statement contains one or more varchar/varbinary columns which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 create external table "sales"(
  "orderkey" int,
  "custkey" int,
  "prodkey" Array[varchar],
  "orderprices" Array[numeric(12,2)],
  "orderdate" date,
  "region" UNKNOWN
 ) as copy from '/data/sales/*/*' PARTITION COLUMNS region orc;
(1 row)

在下例中，函数读取多个 JSON 文件，这些 JSON 文件呈现 menu 列的方式有所不同：

=> SELECT INFER_TABLE_DDL ('/data/*.json'
    USING PARAMETERS table_name='restaurants', format='json',
max_files=3, max_candidates=3);
WARNING 0:  This generated statement contains one or more float types which might lose precision
WARNING 0:  This generated statement contains one or more varchar/varbinary types which default to length 80

                INFER_TABLE_DDL
------------------------------------------------------------------------
 Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "item" varchar,
      "price" float
    )],
    "name" varchar
  );
Candidate matched 1/2 of total files(s):
  create table "restaurants"(
    "cuisine" varchar,
    "location_city" Array[varchar],
    "menu" Array[Row(
      "items" Array[Row(
        "item" varchar,
        "price" numeric
      )],
      "time" varchar
    )],
    "name" varchar
  );

(1 row)

16.7 - LAST_INSERT_ID

返回 AUTO_INCREMENT/IDENTITY 列的最后一个值。如果多个会话并行加载同一个包含 AUTO_INCREMENT/IDENTITY 列的表，则函数返回为该列生成的最后一个值。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

LAST_INSERT_ID()

特权

  • 表所有者

  • 对表架构的 USAGE 权限

示例

请参阅AUTO_INCREMENT 和 IDENTITY 序列。

16.8 - PURGE_TABLE

从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。

清除指定表的所有投影。不能使用此函数清除临时表。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

PURGE_TABLE ( '[[database.]schema.]table' )

参数

[database.]schema

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

表
要清除的表。

特权

  • 表所有者

  • 对架构的 USAGE 权限

示例

以下示例清理了 Vmart 架构中的商店销售事实表的所有投影：

=> SELECT PURGE_TABLE('store.store_sales_fact');

另请参阅

16.9 - REBALANCE_TABLE

同步重新平衡指定表中的数据。

再平衡操作执行以下任务：

  • 基于下列内容分配数据：

  • 在所有节点之间重新分配数据库投影的数据。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REBALANCE_TABLE('[[database.]schema.]table‑name')

参数

架构

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

table‑name
要重新平衡的表。

超级用户

执行重新平衡的时间

执行以下任务后，重新平衡很有用，甚至十分必要：

  • 在准备从群集移除一个或多个节点时，将其标记为临时节点。

  • 向群集添加一个或多个节点，以便 Vertica 可以使用数据填充空节点。

  • 更改弹性群集的比例因子，该比例因子可确定用于跨数据库存储投影的存储容器的数目。

  • 设置控制节点大小或重新调整大型群集布局上的控制节点

  • 向容错组添加节点或从中移除节点。

示例

以下命令显示如何重新平衡指定表上的数据。

=> SELECT REBALANCE_TABLE('online_sales.online_sales_fact');
REBALANCE_TABLE
-------------------
 REBALANCED
(1 row)

另请参阅

16.10 - REENABLE_DUPLICATE_KEY_ERROR

通过逆转 DISABLE_DUPLICATE_KEY_ERROR 的影响来恢复错误报告的默认行为。影响限定在会话范围内。

这是元函数。您必须在顶级 SELECT 语句中调用元函数。

行为类型

易变

语法

REENABLE_DUPLICATE_KEY_ERROR();

超级用户

示例

=> SELECT REENABLE_DUPLICATE_KEY_ERROR();
 REENABLE_DUPLICATE_KEY_ERROR
------------------------------
 Duplicate key error enabled
(1 row)

另请参阅

ANALYZE_CONSTRAINTS