函数从数据库返回信息。此部分介绍 Vertica 支持的函数。除了元函数之外，您可以在任何允许表达式的地方使用函数。
元函数通常访问 Vertica 的内部状态。其只能在顶级 SELECT 语句中使用，并且该语句不能包含其他子句，例如 FROM 或 WHERE。元函数在其参考页面上进行标记。
每个参考页面上的“行为类型”部分将函数的返回行为分类为以下一项或多项：
以下列表按字母顺序显示了所有 Vertica 函数。
跳转到字母： A - B - C - D - E - F - G - H - I - J - K - L - M - N - O - P - Q - R - S - T - U - V - W - X - Y - Z
聚合函数通过行组汇总查询结果集的数据。这些组使用 GROUP BY 子句指定。其只允许出现在选择列表以及 SELECT 语句的 HAVING 和 ORDER BY 子句中（如 聚合表达式 中所述）。
如果未选择行，则这些函数将返回 null 值，COUNT 除外。尤其是，未选择行时 SUM 将返回 NULL，而不是零。
在某些情况下，您可以将包含多个聚合的表达式替换为表达式的单个聚合。例如，SUM(x) + SUM(y) 可以表示为 SUM(x+y)（其中 x 和 y 为 NOT NULL）。
Vertica 不支持嵌套聚合函数。
指定如何对按聚合函数分组的行进行排序，为以下之一：
用户定义的聚合函数也支持此子句。
排序子句仅在每个组的结果集中指定顺序。查询可以有自己的 ORDER BY 子句，该子句优先于 WITHIN GROUP ORDER BY 指定的顺序，并对最终结果集进行排序。
WITHIN GROUP (ORDER BY
{ column‑expression [ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] ]
}[,...])
ASC | DESC NULLS {FIRST | LAST | AUTO} 升序默认： NULLS LAST
降序默认： NULLS FIRST
如果您指定了 NULLS AUTO，Vertica 选择对于此查询最有效的位置排放，即 NULLS FIRST 或 NULLS LAST。
如果您省略所有的排序限定符，Vertica 将使用 ASC NULLS LAST。
有关使用示例，请参阅以下函数：
返回数据集中不同的非 NULL 值数量。
APPROXIMATE_COUNT_DISTINCT ( expression[, error-tolerance ] )
表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。
您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。
如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。
APPROXIMATE_COUNT_DISTINCT 和 DISTINCT 聚合不能在同一查询块中。
APPROXIMATE_COUNT_DISTINCT(x, error‑tolerance) 返回的值等于
COUNT(DISTINCT x)，而误差以标准差呈对数正态分布。
参数 error‑tolerance 是可选参数。提供此实参以指定所需的标准偏差。error‑tolerance 被定义为 2.17 个标准偏差，对应 97% 的置信区间：
standard-deviation = error‑tolerance / 2.17
例如：
error‑tolerance = 1
Default setting, corresponds to a standard deviation
97 percent of the time, APPROXIMATE_COUNT_DISTINCT(x,5) returns a value between:
COUNT(DISTINCT x) * 0.99
COUNT(DISTINCT x) * 1.01
error‑tolerance = 5
97% 的时间，
APPROXIMATE_COUNT_DISTINCT(x) 返回介于以下两者之间的值：
COUNT(DISTINCT x) * 0.95
COUNT(DISTINCT x) * 1.05
99% 的置信区间对应 2.58 个标准偏差。要将 error-tolerance 设置为对应于 99%（而不是 97） 的置信水平，请将 error-tolerance 乘以 2.17 / 2.58 = 0.841。
例如，如果您将
error-tolerance 指定为 5 * 0.841 = 4.2，则
APPROXIMATE_COUNT_DISTINCT(x,4.2) 返回的值是介于以下结果之间的时间的 99%：
COUNT (DISTINCT x) * 0.95
COUNT (DISTINCT x) * 1.05
计算表 store.store_sales_fact 的 product_key 列中不同值的总数：
=> SELECT COUNT(DISTINCT product_key) FROM store.store_sales_fact;
COUNT
-------
19982
(1 row)
计算具有不同容错值的 product_key 中不同值的近似值。容错值越小，近似值越接近实际值：
=> SELECT APPROXIMATE_COUNT_DISTINCT(product_key,5) AS five_pct_accuracy,
APPROXIMATE_COUNT_DISTINCT(product_key,1) AS one_pct_accuracy,
APPROXIMATE_COUNT_DISTINCT(product_key,.88) AS point_eighteight_pct_accuracy
FROM store.store_sales_fact;
five_pct_accuracy | one_pct_accuracy | point_eighteight_pct_accuracy
-------------------+------------------+-------------------------------
19431 | 19921 | 19921
(1 row)
汇总不同非 NULL 值的信息并将结果集实体化为 VARBINARY 或 LONG VARBINARY 概要对象。计算结果在规定的容错范围内。将概要对象保存在 Vertica 表中以供 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 使用。
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS ( expression[, error‑tolerance] )
表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。
您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。
如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。
有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 和 DISTINCT 聚合不能在同一查询块中。
请参阅APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS。
将多个概要聚合成一个新的概要。此函数类似于 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS，但返回一个概要而不是数量估计。此函数的优势是其在调用 APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 时加快了最终估计。
例如，如果您需要在较长一段时间（例如几年）内定期估计不同用户的数量，您可以将天数的概要预先累积到一个一年的概要中。
APPROXIMATE_COUNT_DISTINCT_SYNOPSIS_MERGE ( synopsis-obj [, error‑tolerance] )
表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。
您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。
如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。
有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。
请参阅近似计数区分函数。
从由 APPROXIMATE_COUNT_DISTINCT_SYNOPSIS 创建的概要对象中计算不同的非 NULL 值的数量。
APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS ( synopsis-obj[, error-tolerance ] )
表示所需容错百分比的数字值，分布在此函数返回的值周围。容错值越小，近似值越接近实际值。
您可以将 error‑tolerance 设置为最小值 0.88。Vertica 不实施最大值限制，但大于 5 的任何值都以 5% 的容错实现。
如果省略此实参，则 Vertica 将使用 1.25(%) 的容错率。
有关更多详细信息，请参阅 APPROXIMATE_COUNT_DISTINCT。
APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS 和 DISTINCT 聚合不能在同一查询块中。
下例查看并比较获得表列中唯一值的数量的不同方法：
返回表 store.store_sales_fact 的 product_key 列中唯一值的确切数量：
=> \timing
Timing is on.
=> SELECT COUNT(DISTINCT product_key) from store.store_sales_fact;
count
-------
19982
(1 row)
Time: First fetch (1 row): 553.033 ms. All rows formatted: 553.075 ms
返回 product_key 列中唯一值的近似数量：
=> SELECT APPROXIMATE_COUNT_DISTINCT(product_key) as unique_product_keys
FROM store.store_sales_fact;
unique_product_keys
---------------------
19921
(1 row)
Time: First fetch (1 row): 394.562 ms. All rows formatted: 394.600 ms
创建一个表示一组具有唯一 product_key 值的 store.store_sales_fact 数据的概要对象，将概要存储在新表 my_summary 中：
=> CREATE TABLE my_summary AS SELECT APPROXIMATE_COUNT_DISTINCT_SYNOPSIS (product_key) syn
FROM store.store_sales_fact;
CREATE TABLE
Time: First fetch (0 rows): 582.662 ms. All rows formatted: 582.682 ms
从保存的概要返回数量：
=> SELECT APPROXIMATE_COUNT_DISTINCT_OF_SYNOPSIS(syn) FROM my_summary;
ApproxCountDistinctOfSynopsis
-------------------------------
19921
(1 row)
Time: First fetch (1 row): 105.295 ms. All rows formatted: 105.335 ms
计算一组行中表达式的近似中间值。该函数返回一个 FLOAT 值。
APPROXIMATE_MEDIAN 是 APPROXIMATE_PERCENTILE [聚合] 的别名，参数为 0.5。
APPROXIMATE_MEDIAN ( expression )
GROUP BY 时获得最佳性能，请验证您的表是否按 GROUP BY 列排序。
以下示例使用此表：
CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;
计算此表中所有销售额的近似中间值：
=> SELECT APPROXIMATE_MEDIAN (sales) FROM allsales;
APROXIMATE_MEDIAN
--------------------
20
(1 row)
您可以修改此查询，按州对销售进行分组，然后获取每组的近似中间值：
=> SELECT state, APPROXIMATE_MEDIAN(sales) FROM allsales GROUP BY state;
state | APPROXIMATE_MEDIAN
-------+--------------------
MA | 35
NY | 20
(2 rows)
计算一组行中表达式的近似百分值。此函数返回一个 FLOAT 值。
APPROXIMATE_PERCENTILE ( column-expression USING PARAMETERS percentiles='percentile-values' )
percentilesFLOAT 常量，范围从 0 到 1（包含），指定要计算的百分值。percentile，只接受一个浮点数，继续支持向后兼容性。
GROUP BY 时获得最佳性能，请验证您的表是否按 GROUP BY 列排序。
以下示例使用此表：
=> CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;
=> SELECT * FROM allsales;
state | name | sales
-------+------+-------
MA | A | 60
NY | B | 20
NY | C | 15
NY | F | 40
MA | D | 20
MA | E | 50
MA | G | 10
(7 rows)
计算每个州的销售的近似百分值：
=> SELECT state, APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0.5') AS median
FROM allsales GROUP BY state;
state | median
-------+--------
MA | 35
NY | 20
(2 rows)
计算每个州的销售的多个近似百分值：
=> SELECT state, APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0.5,1.0')
FROM allsales GROUP BY state;
state | APPROXIMATE_PERCENTILE
-------+--------
MA | [35.0,60.0]
NY | [20.0,40.0]
(2 rows)
计算每个州的销售的多个近似百分值，并在单独的列中显示每个百分值的结果：
=> SELECT ps[0] as q0, ps[1] as q1, ps[2] as q2, ps[3] as q3, ps[4] as q4
FROM (SELECT APPROXIMATE_PERCENTILE(sales USING PARAMETERS percentiles='0, 0.25, 0.5, 0.75, 1')
AS ps FROM allsales GROUP BY state) as s1;
q0 | q1 | q2 | q3 | q4
------+------+------+------+------
10.0 | 17.5 | 35.0 | 52.5 | 60.0
15.0 | 17.5 | 20.0 | 30.0 | 40.0
(2 rows)
在用户指定的某些错误范围内，计算列的加权近似百分值数组。此算法类似于 APPROXIMATE_PERCENTILE [聚合]（但其返回一个百分值）。
此函数的性能完全取决于指定的 epsilon 和所提供数组的大小。
此函数的 OVER 子句必须为空。
APPROXIMATE_QUANTILES ( column USING PARAMETERS [nquantiles=n], [epsilon=error] ) OVER() FROM table
INTEGER 或 FLOAT 列。忽略 NULL 值。默认值： 11
⌊(φ-ε)N⌋ ≤ r ≤ ⌊(φ+ε)N⌋
对于 n 分位数，如果指定误差 ε，使得 ε > 1/n，此函数将返回非确定性结果。
默认值： 0.001
以下示例使用此表：
=> CREATE TABLE allsales(state VARCHAR(20), name VARCHAR(20), sales INT) ORDER BY state;
INSERT INTO allsales VALUES('MA', 'A', 60);
INSERT INTO allsales VALUES('NY', 'B', 20);
INSERT INTO allsales VALUES('NY', 'C', 15);
INSERT INTO allsales VALUES('MA', 'D', 20);
INSERT INTO allsales VALUES('MA', 'E', 50);
INSERT INTO allsales VALUES('NY', 'F', 40);
INSERT INTO allsales VALUES('MA', 'G', 10);
COMMIT;
=> SELECT * FROM allsales;
state | name | sales
-------+------+-------
MA | A | 60
NY | B | 20
NY | C | 15
NY | F | 40
MA | D | 20
MA | E | 50
MA | G | 10
(7 rows)
对 APPROXIMATE_QUANTILES 的调用返回一个由近似百分值组成的 6 元素数组，每个分位数一个。每个分位数与百分值的关系为 100 倍。例如，输出中的第二个条目指示 15 是输入列的 0.2 分位数，因此 15 是输入列的第 20 个百分值。
=> SELECT APPROXIMATE_QUANTILES(sales USING PARAMETERS nquantiles=6) OVER() FROM allsales;
Quantile | Value
----------+-------
0 | 10
0.2 | 15
0.4 | 20
0.6 | 40
0.8 | 50
1 | 60
(6 rows)
接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。ARGMAX_AGG 在 target 中查找具有最大非 null 值的行，并返回该行中的 arg 值。如果多行包含最高 target 值，则 ARGMAX_AGG 将返回它找到的第一行中的 arg。使用 WITHIN GROUP ORDER BY 子句控制 ARGMAX_AGG 先查找哪一行。
不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在组内解析为唯一值的一列或一组列；否则为 易变。
ARGMAX_AGG ( target, arg ) [ within‑group‑order‑by‑clause ]
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])
sort‑qualifiers：
{ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }
此子句用于确定当多行包含最高目标值时返回哪一行；否则，结果可能会随着同一查询的每次迭代而变化。
以下示例在 WITH 子句 中调用 ARGMAX_AGG 以查找每个区域中的哪些员工已达到或接近退休年龄。如果每个区域内有多个员工的年龄相同，ARGMAX_AGG 会选择工资水平最高的员工并返回其 ID。主要查询返回有关从每个区域中选择的员工的详细信息：
=> WITH r AS (SELECT employee_region, ARGMAX_AGG(employee_age, employee_key)
WITHIN GROUP (ORDER BY annual_salary DESC) emp_id
FROM employee_dim GROUP BY employee_region ORDER BY employee_region)
SELECT r.employee_region, ed.annual_salary AS highest_salary, employee_key,
ed.employee_first_name||' '||ed.employee_last_name AS employee_name, ed.employee_age
FROM r JOIN employee_dim ed ON r.emp_id = ed.employee_key ORDER BY ed.employee_region;
employee_region | highest_salary | employee_key | employee_name | employee_age
----------------------------------+----------------+--------------+------------------+--------------
East | 927335 | 70 | Sally Gauthier | 65
MidWest | 177716 | 869 | Rebecca McCabe | 65
NorthWest | 100300 | 7597 | Kim Jefferson | 65
South | 196454 | 275 | Alexandra Harris | 65
SouthWest | 198669 | 1043 | Seth Stein | 65
West | 197203 | 681 | Seth Jones | 65
(6 rows)
接受两个实参 target 和 arg，其中两者都是查询数据集中的列或列表达式。ARGMIN_AGG 在 target 中查找具有最小非 null 值的行，并返回该行中的 arg 值。如果多行包含最低 target 值，则 ARGMIN_AGG 将返回它找到的第一行中的 arg。使用 WITHIN GROUP ORDER BY 子句控制 ARGMMIN_AGG 先查找哪一行。
不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在组内解析为唯一值的一列或一组列；否则为 易变。
ARGMIN_AGG ( target, arg ) [ within‑group‑order‑by‑clause ]
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])
sort‑qualifiers：
{ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }
此子句用于确定当多行包含最低目标值时返回哪一行；否则，结果可能会随着同一查询的每次迭代而变化。
以下示例在 WITH 子句中调用 ARGMIN_AGG，以查找每个地区所有员工中的最低工资，并返回最低工资员工的 ID。主要查询返回工资金额和员工姓名：
=> WITH msr (employee_region, emp_id) AS
(SELECT employee_region, argmin_agg(annual_salary, employee_key) lowest_paid_employee FROM employee_dim GROUP BY employee_region)
SELECT msr.employee_region, ed.annual_salary AS lowest_salary, ed.employee_first_name||' '||ed.employee_last_name AS employee_name
FROM msr JOIN employee_dim ed ON msr.emp_id = ed.employee_key ORDER BY annual_salary DESC;
employee_region | lowest_salary | employee_name
----------------------------------+---------------+-----------------
NorthWest | 20913 | Raja Garnett
SouthWest | 20750 | Seth Moore
West | 20443 | Midori Taylor
South | 20363 | David Bauer
East | 20306 | Craig Jefferson
MidWest | 20264 | Dean Vu
(6 rows)
计算一组行中表达式的平均值（算术平均值）。AVG 始终返回 DOUBLE PRECISION 值。
AVG 聚合函数与 AVG 分析函数不同，它计算一个 窗口内一组行中表达式的平均值。
AVG ( [ ALL | DISTINCT ] expression )
ALLDISTINCT默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。
以下查询返回客户表的平均收入：
=> SELECT AVG(annual_income) FROM customer_dimension;
AVG
--------------
2104270.6485
(1 row)
采用所有非空输入值的按位 AND。如果输入参数为 NULL，那么返回值也将为 NULL。
BIT_AND ( expression )
BIT_AND 返回：
与实参数据类型相同的值。
1 — 对于比较的每个位，如果所有位为 1，否则为 0。
如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，BIT_AND 将忽略 null 值并将值 f 扩展为 f0。
示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：
=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));
查询表 t 以查看列 c 输出：
=> SELECT TO_HEX(c) FROM t;
TO_HEX
--------
ff00
ffff
f00f
(3 rows)
查询表 t 以获取列 c 的 AND 值：
=> SELECT TO_HEX(BIT_AND(c)) FROM t;
TO_HEX
--------
f000
(1 row)
该函数将成对应用于组中的所有值，由此导致 f000，具体由以下条件确定：
ff00 （记录 1）与 ffff（记录 2）进行比较，得到 ff00。
从上一比较中得到的结果与 f00f（记录 3）进行比较，得到 f000。
采用所有非空输入值的按位 OR。如果输入参数为 NULL，那么返回值也将为 NULL。
BIT_OR ( expression )
BIT_OR 返回：
与实参数据类型相同的值。
1 — 对于比较的每个位，如果任意位为 1，否则为 0。
如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，该函数将忽略 null 值并将值 f 扩展为 f0。
示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：
=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));
查询表 t 以查看列 c 输出：
=> SELECT TO_HEX(c) FROM t;
TO_HEX
--------
ff00
ffff
f00f
(3 rows)
查询表t以获取列c的 OR 值：
=> SELECT TO_HEX(BIT_OR(c)) FROM t;
TO_HEX
--------
ffff
(1 row)
该函数将成对应用于组中的所有值，由此导致 ffff，具体由以下条件确定：
ff00 （记录 1）与 ffff 进行比较，得到 ffff。
从上一比较中得到的 ff00 结果与 f00f（记录 3）进行比较，得到 ffff。
采用所有非空输入值的按位 XOR。如果输入参数为 NULL，那么返回值也将为 NULL。
BIT_XOR ( expression )
BINARY 或 VARBINARY 输入值。 BIT_XOR 以显式方式对 VARBINARY 类型进行操作，并通过 casts 以隐式方式对 BINARY 类型进行操作。BIT_XOR 返回：
与实参数据类型相同的值。
1 — 对于比较的每个位，如果有奇数个实参包含设置位；否则为 0。
如果列具有不同长度，那么处理这些这些返回值时，会将其当作长度相同且使用零字节向右扩展的值。例如，假设组中包含十六进制值 ff、null 和 f，该函数将忽略 null 值并将值 f 扩展为 f0。
首先创建一个包含二进制列的示例表和投影：
示例使用 t 表，该表在单个列中包含了 VARBINARY 数据类型：
=> CREATE TABLE t ( c VARBINARY(2) );
=> INSERT INTO t values(HEX_TO_BINARY('0xFF00'));
=> INSERT INTO t values(HEX_TO_BINARY('0xFFFF'));
=> INSERT INTO t values(HEX_TO_BINARY('0xF00F'));
查询表 t 以查看列 c 输出：
=> SELECT TO_HEX(c) FROM t;
TO_HEX
--------
ff00
ffff
f00f
(3 rows)
查询表 t 以获取列 c 的 XOR 值：
=> SELECT TO_HEX(BIT_XOR(c)) FROM t;
TO_HEX
--------
f0f0
(1 row)
处理布尔值并返回布尔值结果。如果所有输入值都为 true，则 BOOL_AND 返回 t。否则返回 f (false)。
BOOL_AND ( expression )
以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。
=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE
将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。
=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
OUTPUT
--------
8
(1 row)
查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。
=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;
model | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
advanced | f | t | t
beginner | f | f | f
intermediate | t | t | f
professional | f | t | t
(4 rows)
处理布尔值并返回布尔值结果。如果至少一个输入值为 true，则 BOOL_OR 返回 t。否则，它返回 f。
BOOL_OR ( expression )
以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。
=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE
将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。
=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
OUTPUT
--------
8
(1 row)
查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。
=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;
model | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
advanced | f | t | t
beginner | f | f | f
intermediate | t | t | f
professional | f | t | t
(4 rows)
处理布尔值并返回布尔值结果。特别是只有一个输入值为 true 时，BOOL_XOR 返回 t。否则，它返回 f。
BOOL_XOR ( expression )
以下示例显示了如何使用聚合函数 BOOL_AND、BOOL_OR 和 BOOL_XOR。示例表 mixers 包含模型和颜色列。
=> CREATE TABLE mixers(model VARCHAR(20), colors VARCHAR(20));
CREATE TABLE
将示例数据插入到表中。该示例为每个模型添加了两个颜色字段。
=> INSERT INTO mixers
SELECT 'beginner', 'green'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'intermediate', 'blue'
UNION ALL
SELECT 'advanced', 'green'
UNION ALL
SELECT 'advanced', 'blue'
UNION ALL
SELECT 'professional', 'blue'
UNION ALL
SELECT 'professional', 'green'
UNION ALL
SELECT 'beginner', 'green';
OUTPUT
--------
8
(1 row)
查询该表。结果显示有两个蓝色混合器的模型 (BOOL_AND)，有一个或两个蓝色混合器的模型 (BOOL_OR)，以及专门显示有不超过一个蓝色混合器的模型 (BOOL_XOR)。
=> SELECT model,
BOOL_AND(colors= 'blue')AS two_blue,
BOOL_OR(colors= 'blue')AS one_or_two_blue,
BOOL_XOR(colors= 'blue')AS specifically_not_more_than_one_blue
FROM mixers
GROUP BY model;
model | two_blue | one_or_two_blue | specifically_not_more_than_one_blue
--------------+----------+-----------------+-------------------------------------
advanced | f | t | t
beginner | f | f | f
intermediate | t | t | f
professional | f | t | t
(4 rows)
根据 Pearson 相关系数，返回一组表达式对的 DOUBLE PRECISION 相关系数。 CORR 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。
CORR ( expression1, expression2 )
=> SELECT CORR (Annual_salary, Employee_age) FROM employee_dimension;
CORR
----------------------
-0.00719153413192422
(1 row)
返回为 BIGINT，这是每个组中表达式不为 NULL 的行数。如果查询没有 GROUP BY 子句，则 COUNT 返回表中的行数。
COUNT 聚合函数与 COUNT 分析函数不同，它返回 窗口中一组行的数量。
COUNT ( [ * ] [ ALL | DISTINCT ] expression )
*ALL | DISTINCTALL （默认值）：在表达式计算结果为非 NULL 值的情况下对所有行计数。
DISTINCT：在表达式计算结果为不同的非 NULL 值的情况下对所有行计数。
以下查询会返回 date_dimension 表的 date_key 列中不同值的数量：
=> SELECT COUNT (DISTINCT date_key) FROM date_dimension;
COUNT
-------
1826
(1 row)
此示例会返回对所有 inventory_fact 记录计算表达式 x+y 得到的所有不同值。
=> SELECT COUNT (DISTINCT date_key + product_key) FROM inventory_fact;
COUNT
-------
21560
(1 row)
可以使用 LIMIT 关键字限制返回的行数来创建等同的查询：
=> SELECT COUNT(date_key + product_key) FROM inventory_fact GROUP BY date_key LIMIT 10;
COUNT
-------
173
31
321
113
286
84
244
238
145
202
(10 rows)
此查询会返回具有特定不同 date_key 值的所有记录中不同 product_key 值的数量。
=> SELECT product_key, COUNT (DISTINCT date_key) FROM inventory_fact
GROUP BY product_key LIMIT 10;
product_key | count
-------------+-------
1 | 12
2 | 18
3 | 13
4 | 17
5 | 11
6 | 14
7 | 13
8 | 17
9 | 15
10 | 12
(10 rows)
该查询通过常数 1 对 product_key 表中每个不同的 inventory_fact 值进行计数。
=> SELECT product_key, COUNT (DISTINCT product_key) FROM inventory_fact
GROUP BY product_key LIMIT 10;
product_key | count
-------------+-------
1 | 1
2 | 1
3 | 1
4 | 1
5 | 1
6 | 1
7 | 1
8 | 1
9 | 1
10 | 1
(10 rows)
该查询会选择每个不同的 date_key 值，并针对具有特定 product_key 值的所有记录为不同的product_key 值进行计数。然后，它会对具有特定 qty_in_stock 值的所有记录中的 product_key 值进行求和，并按照 date_key 对结果进行分组。
=> SELECT date_key, COUNT (DISTINCT product_key), SUM(qty_in_stock) FROM inventory_fact
GROUP BY date_key LIMIT 10;
date_key | count | sum
----------+-------+--------
1 | 173 | 88953
2 | 31 | 16315
3 | 318 | 156003
4 | 113 | 53341
5 | 285 | 148380
6 | 84 | 42421
7 | 241 | 119315
8 | 238 | 122380
9 | 142 | 70151
10 | 202 | 95274
(10 rows)
该查询会选择每个不同的 product_key 值，然后针对具有特定 date_key 值的所有记录为不同的product_key 值进行计数。它还会对具有特定 warehouse_key 值的所有记录中的不同 product_key 值进行计数。
=> SELECT product_key, COUNT (DISTINCT date_key), COUNT (DISTINCT warehouse_key) FROM inventory_fact
GROUP BY product_key LIMIT 15;
product_key | count | count
-------------+-------+-------
1 | 12 | 12
2 | 18 | 18
3 | 13 | 12
4 | 17 | 18
5 | 11 | 9
6 | 14 | 13
7 | 13 | 13
8 | 17 | 15
9 | 15 | 14
10 | 12 | 12
11 | 11 | 11
12 | 13 | 12
13 | 9 | 7
14 | 13 | 13
15 | 18 | 17
(15 rows)
该查询会选择每个不同的 product_key 值，为具有特定 date_key 值的所有记录的不同 warehouse_key 和 product_key 值进行计数，然后对具有特定 qty_in_stock 值的记录中的所有 product_key 值进行求和。然后，它会返回具有特定 product_version 值的记录中 product_key 值的数量。
=> SELECT product_key, COUNT (DISTINCT date_key),
COUNT (DISTINCT warehouse_key),
SUM (qty_in_stock),
COUNT (product_version)
FROM inventory_fact GROUP BY product_key LIMIT 15;
product_key | count | count | sum | count
-------------+-------+-------+-------+-------
1 | 12 | 12 | 5530 | 12
2 | 18 | 18 | 9605 | 18
3 | 13 | 12 | 8404 | 13
4 | 17 | 18 | 10006 | 18
5 | 11 | 9 | 4794 | 11
6 | 14 | 13 | 7359 | 14
7 | 13 | 13 | 7828 | 13
8 | 17 | 15 | 9074 | 17
9 | 15 | 14 | 7032 | 15
10 | 12 | 12 | 5359 | 12
11 | 11 | 11 | 6049 | 11
12 | 13 | 12 | 6075 | 13
13 | 9 | 7 | 3470 | 9
14 | 13 | 13 | 5125 | 13
15 | 18 | 17 | 9277 | 18
(15 rows)
以下示例会返回 warehouse 维度表中的仓库数。
=> SELECT COUNT(warehouse_name) FROM warehouse_dimension;
COUNT
-------
100
(1 row)
下一个示例会返回供应商总数：
=> SELECT COUNT(*) FROM vendor_dimension;
COUNT
-------
50
(1 row)
返回一组表达式对的总体方差。返回值的类型为 DOUBLE PRECISION。 COVAR_POP 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。
SELECT COVAR_POP ( expression1, expression2 )
=> SELECT COVAR_POP (Annual_salary, Employee_age)
FROM employee_dimension;
COVAR_POP
-------------------
-9032.34810730019
(1 row)
返回一组表达式对的样本方差。返回值的类型为 DOUBLE PRECISION。 COVAR_SAMP 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。
SELECT COVAR_SAMP ( expression1, expression2 )
=> SELECT COVAR_SAMP (Annual_salary, Employee_age)
FROM employee_dimension;
COVAR_SAMP
-------------------
-9033.25143244343
(1 row)
唯一标识返回重复分组集的重复 GROUP BY 查询集。此函数返回一个或多个以零 (0) 开头的整数作为标识符。
对于特定分组的重复数量 n，GROUP_ID 返回一组连续的数字 0 到 n–1。对于它遇到的每个第一个唯一组，GROUP_ID 返回值 0。如果 GROUP_ID 再次发现了相同的分组，函数会返回 1，然后对下一个发现的分组返回 2，以此类推。
GROUP_ID ()
此示例显示了 GROUP_ID 如何在查询产生重复分组时创建唯一标识符。对于费用表，以下查询按照费用类别和年份对结果进行分组，并 为这两个列计算汇总值。这些结果在类别和 NULL 方面具有重复分组。第一个分组的 GROUP_ID 为 0，第二个分组的 GROUP_ID 为 1。
=> SELECT Category, Year, SUM(Amount), GROUPING_ID(Category, Year),
GROUP_ID() FROM expenses GROUP BY Category, ROLLUP(Category,Year)
ORDER BY Category, Year, GROUPING_ID();
Category | Year | SUM | GROUPING_ID | GROUP_ID
-------------+------+--------+-------------+----------
Books | 2005 | 39.98 | 0 | 0
Books | 2007 | 29.99 | 0 | 0
Books | 2008 | 29.99 | 0 | 0
Books | | 99.96 | 1 | 0
Books | | 99.96 | 1 | 1
Electricity | 2005 | 109.99 | 0 | 0
Electricity | 2006 | 109.99 | 0 | 0
Electricity | 2007 | 229.98 | 0 | 0
Electricity | | 449.96 | 1 | 1
Electricity | | 449.96 | 1 | 0
当具有多级别聚合的 GROUP BY 查询生成 NULL 值以确定分组列中的小计时，消除 NULL 值的使用。这些来自于原始数据的 NULL 值也会发生在行中。 GROUPING 返回 1 — 在 expression 的值为以下值时：
NULL，表示聚合的值
0 — 对任何其他值，包括行中的 NULL 值
GROUPING ( expression )
GROUP BY 子句中的表达式以下查询使用 GROUPING 函数，将 GROUP BY 表达式之一作为实参。对于每一行，GROUPING 返回以下值之一：
0：列是该行的组的一部分
1：列不是该行的组的一部分
GROUPING(Year) 列中电力和书籍的值为 1，表示这些值是小计。GROUPING(Category) 和 GROUPING(Year) 最右边的列值为 1。此值表示两个列都不会成为 GROUP BY 的结果。最终行表示总销售量。
=> SELECT Category, Year, SUM(Amount),
GROUPING(Category), GROUPING(Year) FROM expenses
GROUP BY ROLLUP(Category, Year) ORDER BY Category, Year, GROUPING_ID();
Category | Year | SUM | GROUPING | GROUPING
-------------+------+--------+----------+----------
Books | 2005 | 39.98 | 0 | 0
Books | 2007 | 29.99 | 0 | 0
Books | 2008 | 29.99 | 0 | 0
Books | | 99.96 | 0 | 1
Electricity | 2005 | 109.99 | 0 | 0
Electricity | 2006 | 109.99 | 0 | 0
Electricity | 2007 | 229.98 | 0 | 0
Electricity | | 449.96 | 0 | 1
| | 549.92 | 1 | 1
将 GROUPING 函数生成的布尔值集连接到位向量。 GROUPING_ID 将位向量作为二进制数字进行处理，并将其作为可以确认分组集组合的十进制值返回。
通过使用 GROUPING_ID，不再需要多个单独的 GROUPING 函数。 GROUPING_ID 可以简化行筛选条件，因为使用
GROUPING_ID = n 的单一返回来确定感兴趣的行。使用 GROUPING_ID 确定分组组合。
GROUPING_ID ( [expression[,...] )
GROUP BY 子句中表达式之一的表达式。
如果 GROUP BY 子句包含表达式列表，GROUPING_ID 将会返回一个与关联到行的 GROUPING 位向量对应的数字。
此示例显示如何调用 GROUPING_ID，示例中不使用返回与完整的多级别聚合表达式集关联的 GROUPING 位向量的表达式。GROUPING_ID 值与 GROUPING_ID(a,b) 差不多，因为 GROUPING_ID() 包括 GROUP BY ROLLUP 中的所有列：
=> SELECT a,b,COUNT(*), GROUPING_ID() FROM T GROUP BY ROLLUP(a,b);
在以下查询中，GROUPING(Category) 和 GROUPING(Year) 列具有三个组合：
0,0
0,1
1,1
=> SELECT Category, Year, SUM(Amount),
GROUPING(Category), GROUPING(Year) FROM expenses
GROUP BY ROLLUP(Category, Year) ORDER BY Category, Year, GROUPING_ID();
Category | Year | SUM | GROUPING | GROUPING
-------------+------+--------+----------+----------
Books | 2005 | 39.98 | 0 | 0
Books | 2007 | 29.99 | 0 | 0
Books | 2008 | 29.99 | 0 | 0
Books | | 99.96 | 0 | 1
Electricity | 2005 | 109.99 | 0 | 0
Electricity | 2006 | 109.99 | 0 | 0
Electricity | 2007 | 229.98 | 0 | 0
Electricity | | 449.96 | 0 | 1
| | 549.92 | 1 | 1
GROUPING_ID 按照以下方式转换这些值：
以下查询返回 gr_id 列中显示的针对每个 GROUP BY 级别的单个数字：
=> SELECT Category, Year, SUM(Amount),
GROUPING(Category),GROUPING(Year),GROUPING_ID(Category,Year) AS gr_id
FROM expenses GROUP BY ROLLUP(Category, Year);
Category | Year | SUM | GROUPING | GROUPING | gr_id
-------------+------+--------+----------+----------+-------
Books | 2008 | 29.99 | 0 | 0 | 0
Books | 2005 | 39.98 | 0 | 0 | 0
Electricity | 2007 | 229.98 | 0 | 0 | 0
Books | 2007 | 29.99 | 0 | 0 | 0
Electricity | 2005 | 109.99 | 0 | 0 | 0
Electricity | | 449.96 | 0 | 1 | 1
| | 549.92 | 1 | 1 | 3
Electricity | 2006 | 109.99 | 0 | 0 | 0
Books | | 99.96 | 0 | 1 | 1
gr_id 值决定了每一行的 GROUP BY 级别：
您也可以通过单独比较每个搜索值，使用 DECODE 函数赋予这些值更多的含义。
=> SELECT Category, Year, SUM(AMOUNT), DECODE(GROUPING_ID(Category, Year),
3, 'Total',
1, 'Category',
0, 'Category,Year')
AS GROUP_NAME FROM expenses GROUP BY ROLLUP(Category, Year);
Category | Year | SUM | GROUP_NAME
-------------+------+--------+---------------
Electricity | 2006 | 109.99 | Category,Year
Books | | 99.96 | Category
Electricity | 2007 | 229.98 | Category,Year
Books | 2007 | 29.99 | Category,Year
Electricity | 2005 | 109.99 | Category,Year
Electricity | | 449.96 | Category
| | 549.92 | Total
Books | 2005 | 39.98 | Category,Year
Books | 2008 | 29.99 | Category,Year
将一组行中的非空值转换为由逗号（默认）或可配置分隔符分隔的值列表。LISTAGG 可用于将行非标准化为串联值字符串。
不可变 — 如果 WITHIN GROUP ORDER BY 子句指定在聚合列表内解析为唯一值的一列或一组列；否则为 易变。
LISTAGG ( aggregate‑expression [ USING PARAMETERS parameter=value][,...] ] ) [ within‑group‑order‑by‑clause ]
LISTAGG 不直接支持空间数据类型。为了传递这种类型的列数据，使用地理空间函数 ST_AsText 将数据转换为字符串。
separator 参数设置为另一个字符来覆盖此默认值。
WITHIN GROUP (ORDER BY { column‑expression[ sort-qualifiers ] }[,...])
sort‑qualifiers：
{ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }
无
在以下查询中，CityState 列中的聚合结果使用字符串“|”作为分隔符。外部的 GROUP BY 子句根据其 Region 值对输出行进行分组。在每个组中，根据 WITHIN GROUP ORDER BY 子句，聚合列表项根据其 city 值进行排序：
=> \x
Expanded display is on.
=> WITH cd AS (SELECT DISTINCT (customer_city) city, customer_state, customer_region FROM customer_dimension)
SELECT customer_region Region, LISTAGG(city||', '||customer_state USING PARAMETERS separator=' | ')
WITHIN GROUP (ORDER BY city) CityAndState FROM cd GROUP BY region ORDER BY region;
-[ RECORD 1 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | East
CityAndState | Alexandria, VA | Allentown, PA | Baltimore, MD | Boston, MA | Cambridge, MA | Charlotte, NC | Clarksville, TN | Columbia, SC | Elizabeth, NJ | Erie, PA | Fayetteville, NC | Hartford, CT | Lowell, MA | Manchester, NH | Memphis, TN | Nashville, TN | New Haven, CT | New York, NY | Philadelphia, PA | Portsmouth, VA | Stamford, CT | Sterling Heights, MI | Washington, DC | Waterbury, CT
-[ RECORD 2 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | MidWest
CityAndState | Ann Arbor, MI | Cedar Rapids, IA | Chicago, IL | Columbus, OH | Detroit, MI | Evansville, IN | Flint, MI | Gary, IN | Green Bay, WI | Indianapolis, IN | Joliet, IL | Lansing, MI | Livonia, MI | Milwaukee, WI | Naperville, IL | Peoria, IL | Sioux Falls, SD | South Bend, IN | Springfield, IL
-[ RECORD 3 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | NorthWest
CityAndState | Bellevue, WA | Portland, OR | Seattle, WA
-[ RECORD 4 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | South
CityAndState | Abilene, TX | Athens, GA | Austin, TX | Beaumont, TX | Cape Coral, FL | Carrollton, TX | Clearwater, FL | Coral Springs, FL | Dallas, TX | El Paso, TX | Fort Worth, TX | Grand Prairie, TX | Houston, TX | Independence, MS | Jacksonville, FL | Lafayette, LA | McAllen, TX | Mesquite, TX | San Antonio, TX | Savannah, GA | Waco, TX | Wichita Falls, TX
-[ RECORD 5 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | SouthWest
CityAndState | Arvada, CO | Denver, CO | Fort Collins, CO | Gilbert, AZ | Las Vegas, NV | North Las Vegas, NV | Peoria, AZ | Phoenix, AZ | Pueblo, CO | Topeka, KS | Westminster, CO
-[ RECORD 6 ]+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Region | West
CityAndState | Berkeley, CA | Burbank, CA | Concord, CA | Corona, CA | Costa Mesa, CA | Daly City, CA | Downey, CA | El Monte, CA | Escondido, CA | Fontana, CA | Fullerton, CA | Inglewood, CA | Lancaster, CA | Los Angeles, CA | Norwalk, CA | Orange, CA | Palmdale, CA | Pasadena, CA | Provo, UT | Rancho Cucamonga, CA | San Diego, CA | San Francisco, CA | San Jose, CA | Santa Clara, CA | Simi Valley, CA | Sunnyvale, CA | Thousand Oaks, CA | Vallejo, CA | Ventura, CA | West Covina, CA | West Valley City, UT
返回一组行表达式的最大值。返回值的类型与表达式数据类型相同。
MAX 分析函数与聚合函数的不同之处在于，它返回
窗口内一组行的表达式的最大值。
聚合函数 MIN 和 MAX 可以使用布尔值运行。MAX 可以执行布尔数据类型或可以隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN 返回 t (true)。否则返回 f。
MAX ( expression )
以下查询返回列 sales_dollar_amount 中的最大值。
=> SELECT MAX(sales_dollar_amount) AS highest_sale FROM store.store_sales_fact;
highest_sale
--------------
600
(1 row)
以下示例显示了当您将 MIN 和 MAX 聚合函数与布尔值一起使用时，它们之间的区别。该示例创建一个表，添加两行数据，并显示 MIN 和 MAX 的示例输出。
=> CREATE TABLE min_max_functions (torf BOOL);
=> INSERT INTO min_max_functions VALUES (1);
=> INSERT INTO min_max_functions VALUES (0);
=> SELECT * FROM min_max_functions;
torf
------
t
f
(2 rows)
=> SELECT min(torf) FROM min_max_functions;
min
-----
f
(1 row)
=> SELECT max(torf) FROM min_max_functions;
max
-----
t
(1 row)
返回一组行表达式的最小值。返回值的类型与表达式数据类型相同。
MIN分析函数与聚合函数的不同之处在于，它返回
窗口内一组行的表达式的最小值。
聚合函数 MIN 和 MAX 可以使用布尔值运行。MAX 可以执行布尔数据类型或可以隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN 返回 t (true)。否则返回 f。
MIN ( expression )
以下查询返回 employee 维度表的最低工资。
此示例说明如何查询以返回 employee 维度表的最低工资。
=> SELECT MIN(annual_salary) AS lowest_paid FROM employee_dimension;
lowest_paid
-------------
1200
(1 row)
以下示例显示了当您将 MIN 和 MAX 聚合函数与布尔值一起使用时，它们之间的区别。该示例创建一个表，添加两行数据，并显示 MIN 和 MAX 的示例输出。
=> CREATE TABLE min_max_functions (torf BOOL);
=> INSERT INTO min_max_functions VALUES (1);
=> INSERT INTO min_max_functions VALUES (0);
=> SELECT * FROM min_max_functions;
torf
------
t
f
(2 rows)
=> SELECT min(torf) FROM min_max_functions;
min
-----
f
(1 row)
=> SELECT max(torf) FROM min_max_functions;
max
-----
t
(1 row)
返回表达式对中独立表达式的 DOUBLE PRECISION 平均值。 REGR_AVGX 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_AVGX 返回 NULL。
SELECT REGR_AVGX ( expression1, expression2 )
=> SELECT REGR_AVGX (Annual_salary, Employee_age)
FROM employee_dimension;
REGR_AVGX
-----------
39.321
(1 row)
返回表达式对中依赖表达式的 DOUBLE PRECISION 平均值。该函数消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 NULL。
REGR_AVGY ( expression1, expression2 )
=> SELECT REGR_AVGY (Annual_salary, Employee_age)
FROM employee_dimension;
REGR_AVGY
------------
58354.4913
(1 row)
返回表达式对中所有行的计数。该函数消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，则该函数返回 0。
SELECT REGR_COUNT ( expression1, expression2 )
=> SELECT REGR_COUNT (Annual_salary, Employee_age) FROM employee_dimension;
REGR_COUNT
------------
10000
(1 row)
返回由一组表达式对确定的回归线的 y 截距。返回值的类型为 DOUBLE PRECISION。 REGR_INTERCEPT 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_INTERCEPT 返回 NULL。
SELECT REGR_INTERCEPT ( expression1, expression2 )
=> SELECT REGR_INTERCEPT (Annual_salary, Employee_age) FROM employee_dimension;
REGR_INTERCEPT
------------------
59929.5490163437
(1 row)
返回一组表达式对的相关系数的平方。返回值的类型为 DOUBLE PRECISION。 REGR_R2 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_R2 返回 NULL。
SELECT REGR_R2 ( expression1, expression2 )
=> SELECT REGR_R2 (Annual_salary, Employee_age) FROM employee_dimension;
REGR_R2
----------------------
5.17181631706311e-05
(1 row)
返回由一组表达式对确定的回归线的斜率。返回值的类型为 DOUBLE PRECISION。 REGR_SLOPE 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SLOPE 返回 NULL。
SELECT REGR_SLOPE ( expression1, expression2 )
=> SELECT REGR_SLOPE (Annual_salary, Employee_age) FROM employee_dimension;
REGR_SLOPE
------------------
-40.056400303749
(1 row)
返回独立表达式 (expression2) 与其平均值之差的平方和。
即，REGR_SXX 返回： ∑[(expression2 - average(expression2)(expression2 - average(expression2)]
返回值的类型为 DOUBLE PRECISION。 REGR_SXX 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SXX 返回 NULL。
SELECT REGR_SXX ( expression1, expression2 )
=> SELECT REGR_SXX (Annual_salary, Employee_age) FROM employee_dimension;
REGR_SXX
------------
2254907.59
(1 row)
返回依赖表达式 (expression1) 与其平均值之间的差值以及独立表达式 (expression2) 与其平均值之间的差值的乘积之和。
即，REGR_SXY 返回： ∑[(expression1 - average(expression1)(expression2 - average(expression2))]
返回值的类型为 DOUBLE PRECISION。 REGR_SXY 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SXY 返回 NULL。
SELECT REGR_SXY ( expression1, expression2 )
=> SELECT REGR_SXY (Annual_salary, Employee_age) FROM employee_dimension;
REGR_SXY
-------------------
-90323481.0730019
(1 row)
返回依赖表达式 (expression1) 与其平均值之间的差值的平方和。
即，REGR_SYY 返回：∑[(expression1 - average(expression1)(expression1 - average(expression1)]
返回值的类型为 DOUBLE PRECISION。 REGR_SYY 消除表达式对中任一表达式为 NULL 的表达式对。如果没有剩余行，REGR_SYY 返回 NULL。
SELECT REGR_SYY ( expression1, expression2 )
=> SELECT REGR_SYY (Annual_salary, Employee_age) FROM employee_dimension;
REGR_SYY
------------------
69956728794707.2
(1 row)
求出组中每个成员的统计样本标准差。返回值与
VAR_SAMP 的平方根相同：
STDDEV(expression) = SQRT(VAR_SAMP(expression))
STDDEV ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV 返回与 expression 相同的数据类型。提供非标准函数 STDDEV，以便和其他数据库兼容。它在语义上与
STDDEV_SAMP 相同。
当
VAR_SAMP 返回 NULL 时，STDDEV 返回 NULL。
以下示例从 customer_dimension VMart 示例数据库表返回每个家庭 ID 的统计样本标准差：
=> SELECT STDDEV(household_id) FROM customer_dimension;
STDDEV
-----------------
8651.5084240071
求出组中每个成员的统计总体标准差。
STDDEV_POP ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV_POP 返回与 expression 相同的数据类型。此函数与分析函数
STDDEV_POP 不同，它计算
窗口内一组行中每个成员的统计总体标准差。
STDDEV_POP 返回与
VAR_POP 的平方根相同的值：
STDDEV_POP(expression) = SQRT(VAR_POP(expression))
当
VAR_SAMP 返回 NULL 时，此函数将返回 NULL。
以下示例返回 customer 表中每个家庭 ID 的统计总体标准差。
=> SELECT STDDEV_POP(household_id) FROM customer_dimension;
STDDEV_POP
------------------
8651.41895973367
(1 row)
求出组中每个成员的统计样本标准差。返回值与
VAR_SAMP 的平方根相同：
STDDEV_SAMP(expression) = SQRT(VAR_SAMP(expression))
STDDEV_SAMP ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 STDDEV_SAMP 返回与 expression 相同的数据类型。STDDEV_SAMP 在语义上与非标准函数
STDDEV 相同，它是为了与其他数据库兼容而提供的。
此聚合函数与分析函数
STDDEV_SAMP 不同，它计算当前行相对于
窗口内的一组行的统计样本标准偏差。
当
VAR_SAMP 返回 NULL 时，STDDEV_SAMP 返回 NULL。
以下示例从 customer 维度表返回每个家庭 ID 的统计样本标准差。
=> SELECT STDDEV_SAMP(household_id) FROM customer_dimension;
stddev_samp
------------------
8651.50842400771
(1 row)
基于行组计算表达式的总和 SUM 返回浮点表达式的 DOUBLE PRECISION 值。否则，返回值与表达式数据类型相同。
SUM 聚合函数与
SUM 分析函数不同，它计算一个
窗口内一组行的表达式总和。
SUM ( [ ALL | DISTINCT ] expression )
ALLDISTINCTNUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。如果在使用 SUM() 时遇到数据溢出问题，请使用
SUM_FLOAT 将数据转换为浮点数。
默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。
以下查询返回 product_cost 列的总和。
=> SELECT SUM(product_cost) AS cost FROM product_dimension;
cost
---------
9042850
(1 row)
计算一组行的表达式的总和并返回 DOUBLE PRECISION 值。
SUM_FLOAT ( [ ALL | DISTINCT ] expression )
ALLDISTINCTDOUBLE PRECISION 类型。默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。
以下查询从产品表返回平均价格浮点总和：
=> SELECT SUM_FLOAT(average_competitor_price) AS cost FROM product_dimension;
cost
----------
18181102
(1 row)
处理属于每个时间片的数据。时序聚合 (TSA) 函数，TS_FIRST_VALUE 返回时间片开始时的值，其中插值方案在缺少时间片时应用，在这种情况下，根据常数（线性）插值方案由对应于上一个（和下一个）时间片的值来确定值。
TS_FIRST_VALUE 将为每个时间片返回一个输出行，如果指定了分区表达式，则为每个时间片的每个分区返回一个输出行。
TS_FIRST_VALUE ( expression [ IGNORE NULLS ] [, { 'CONST' | 'LINEAR' } ] )
INTEGER 或 FLOAT 表达式。IGNORE NULLSIGNORE NULLS 行为将根据 CONST 或 LINEAR 插值方案发生变化。有关详细信息，请参阅分析数据中的时序数据何时包含 NULL 值。'CONST' | 'LINEAR'CONST （默认值）：基于以前的输入记录内插新值。
LINEAR：基于指定的时间片将值内插到线性斜率中。
您必须将 ORDER BY 子句与 TIMESTAMP 列一起使用。
同一个查询可以调用多个时序聚合函数。按照 TIMESERIES 子句的定义，它们共享同一个空白填充策略；然而，每个时序聚合函数可以指定自己的插值策略。例如：
=> SELECT slice_time, symbol,
TS_FIRST_VALUE(bid, 'const') fv_c,
TS_FIRST_VALUE(bid, 'linear') fv_l,
TS_LAST_VALUE(bid, 'const') lv_c
FROM TickStore
TIMESERIES slice_time AS '3 seconds'
OVER(PARTITION BY symbol ORDER BY ts);
请参阅分析数据中的空白填充和插值。
处理属于每个时间片的数据。时序聚合 (TSA) 函数，TS_LAST_VALUE 返回时间片结束时的值，其中插值方案在缺少时间片时应用。在这种情况下，根据常数（线性）插值方案由对应于上一个（和下一个）时间片的值来确定值。
TS_LAST_VALUE 将为每个时间片返回一个输出行，如果指定了分区表达式，则为每个时间片的每个分区返回一个输出行。
TS_LAST_VALUE ( expression [ IGNORE NULLS ] [, { 'CONST' | 'LINEAR' } ] )
INTEGER 或 FLOAT 表达式。IGNORE NULLSIGNORE NULLS 行为将根据 CONST 或 LINEAR 插值方案发生变化。有关详细信息，请参阅分析数据中的时序数据何时包含 NULL 值。'CONST' | 'LINEAR'CONST （默认值）：基于以前的输入记录内插新值。
LINEAR：基于指定的时间片将值内插到线性斜率中。
您必须将 ORDER BY 子句与 TIMESTAMP 列一起使用。
同一个查询可以调用多个时序聚合函数。按照 TIMESERIES 子句的定义，它们共享同一个空白填充策略；然而，每个时序聚合函数可以指定自己的插值策略。例如：
=> SELECT slice_time, symbol,
TS_FIRST_VALUE(bid, 'const') fv_c,
TS_FIRST_VALUE(bid, 'linear') fv_l,
TS_LAST_VALUE(bid, 'const') lv_c
FROM TickStore
TIMESERIES slice_time AS '3 seconds'
OVER(PARTITION BY symbol ORDER BY ts);
请参阅分析数据中的空白填充和插值。
求出组内每个成员的总体方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数：
(SUM(expression*expression) - SUM(expression)*SUM(expression) / COUNT(expression)) / COUNT(expression)
VAR_POP ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VAR_POP 返回与 expression 相同的数据类型。此聚合函数与分析函数
VAR_POP 不同，它计算当前行相对于
窗口内的一组行的总体方差。
下述示例返回 customer 表中每个 household ID 的总体方差。
=> SELECT VAR_POP(household_id) FROM customer_dimension;
var_pop
------------------
74847050.0168393
(1 row)
求出组中每行的样本方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数减去 1：
(SUM(expression*expression) - SUM(expression) *SUM(expression) / COUNT(expression)) / (COUNT(expression) -1)
VAR_SAMP ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VAR_SAMP 返回与 expression 相同的数据类型。以下示例返回 customer 表中每个家庭 ID 的样本方差。
=> SELECT VAR_SAMP(household_id) FROM customer_dimension;
var_samp
------------------
74848598.0106764
(1 row)
求出组中每行的样本方差。它定义为 expression 与 expression 均值之差的平方和除以剩余行数减去 1。
(SUM(expression*expression) - SUM(expression) *SUM(expression) /COUNT(expression)) / (COUNT(expression) -1)
VARIANCE ( expression )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。 VARIANCE 返回与 expression 相同的数据类型。提供非标准函数 VARIANCE，以便和其他数据库兼容。它在语义上与
VAR_SAMP 相同。
此聚合函数与分析函数
VARIANCE 不同，它计算当前行相对于
窗口内的一组行的样本方差。
以下示例返回 customer 表中每个家庭 ID 的样本方差。
=> SELECT VARIANCE(household_id) FROM customer_dimension;
variance
------------------
74848598.0106764
(1 row)
Vertica 分析是基于 ANSI 99 标准的 SQL 函数。这些函数用于处理复杂的分析和报告任务，例如：
对处于特殊状态的合作时间最长的客户进行排序。
计算指定的一段时间内零售额的移动平均值。
查找同一年级所有学生的最高分数。
对销售人员当前收到的销售奖金与其以前收到的销售奖金进行比较。
分析函数将返回聚合结果，但并不对结果集进行分组。它们会多次返回组值，每个记录一个组值。可以使用 window ORDER BY 子句排序组值或分区，但此顺序仅影响函数结果集，而不影响整个查询结果集。
一般
analytic‑function(arguments) OVER(
[ window-partition-clause ]
[ window-order-clause [ window-frame-clause ] ]
)
对于指定窗口
analytic‑function(arguments) OVER(
[ named‑window [ window‑frame‑clause ] ]
)
analytic‑function(arguments) OVERFROM、WHERE、GROUP BY 和 HAVING 子句求值之后返回的结果集。
空的 OVER 子句将提供单个节点中的单线程查询最佳性能。
如果忽略此子句，不会进行任何分组，分析函数将所有输入行作为一个分区处理。
OVER 子句还包括分区子句，则在每个分区中对行进行排序。window‑frame‑clauseOVER 子句的分析函数时，命名窗口很有用。
窗口名称子句不能指定窗口框架子句。然而，您可以用窗口框架子句将命名窗口限定在 OVER 子句中。
以下要求适用于分析函数：
全部需要 OVER 子句。每个函数都有自己的 OVER 子句要求。例如，您可以为一些分析聚合函数（如
SUM）提供一个空的 OVER 子句。对于其他函数，可能需要窗口框架和命令子句，也可能无效。
只有查询的 SELECT 和 ORDER BY 子句才能调用分析函数。
分析函数不可嵌套。例如，不允许下面的查询：
=> SELECT MEDIAN(RANK() OVER(ORDER BY sal) OVER()).
WHERE、GROUP BY 和 HAVING 运算符从技术上讲不是分析函数的一部分。不过，它们可以确定该函数的输入内容。
当指定了窗口分区子句时，它将基于用户提供的表达式拆分函数输入的行。如果没有提供表达式，分区子句可通过使用并行度来提升查询性能。
窗口分区与 GROUP BY 子句相似，区别在于它仅为每个输入行返回一个结果行。如果没有指定窗口分区子句，则会将所有输入行都视为一个分区。
当与分析函数一起使用时，将根据分区计算结果，并在下一个分区开始时重新开始。
{ PARTITION BY expression[,...] | PARTITION BEST | PARTITION NODES }
PARTITION BY expressionPARTITION BY 。PARTITION BESTOVER(PARTITION BEST) 提供多个节点中的多线程查询最佳性能。
以下注意事项适用于使用 PARTITION BEST：
对于无分区要求且线程安全的分析函数（如一对多转换），使用 PARTITION BEST。
对于非线程安全的用户定义转换函数 (UDTF)，不要使用 PARTITION BEST。这样做会导致出现错误或不正确的结果。如果 UDTF 非线程安全，使用 PARTITION NODES 。
PARTITION NODESOVER(PARTITION NODES) 提供多个节点中的单线程查询最佳性能。
请参阅窗口分区。
指定如何对提供给分析函数的行进行排序。如果 OVER 子句也包含窗口分区子句，则会在每个分区中对行进行排序。
窗口顺序子句仅在窗口结果集中指定顺序。除 OVER 子句以外，查询可以拥有自己的 ORDER BY 子句。它优先于窗口顺序子句，并对最终结果集进行排序。
如果没有显式指定任何窗口框架，窗口顺序子句还会创建默认窗口框架。
ORDER BY { expression [ ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] ]
}[,...]
ASC | DESC NULLS {FIRST | LAST | AUTO} 升序默认： NULLS LAST
降序默认： NULLS FIRST
如果您指定了 NULLS AUTO，Vertica 选择对于此查询最有效的位置排放，即 NULLS FIRST 或 NULLS LAST。
如果您省略所有的排序限定符，Vertica 将使用 ASC NULLS LAST。
有关详细信息，请参阅：
请参阅窗口排序。
指定窗口框架，其中包含一组与分析函数当前正在评估的行相对的行。函数处理此行及其窗口之后，Vertica 会将当前行向前移动，并相应地调整窗口边界。如果 OVER 子句还指定了分区，Vertica 也会检查窗口边界是否跨越了分区边界。此过程将不断重复，直到函数评估了最后一个分区的最后一个行。
{ ROWS | RANGE } { BETWEEN start‑point AND end‑point } | start‑point
start-point / end‑point：
{ UNBOUNDED {PRECEDING | FOLLOWING}
| CURRENT ROW
| constant-value {PRECEDING | FOLLOWING}}
ROWS | RANGEBETWEEN start‑point AND end‑pointUNBOUNDED {PRECEDING | FOLLOWING}
CURRENT ROW
constant-value {PRECEDING | FOLLOWING}
start-point 必须解析为小于或等于 end-point 的行或值。
UNBOUNDED PRECEDINGROWS 或 RANGE 仅指定了一个起点，Vertica 将使用当前行作为终点，并相应地创建窗口框架。在这种情况下，start-point 必须解析为小于或等于当前行的行。UNBOUNDED FOLLOWINGCURRENT ROWconstant‑value {PRECEDING | FOLLOWING} ROWS 或 RANGE 而定。
其他依赖项也适用，具体视您是否指定了 ROWS 和 RANGE 而定。有关详细信息，请参阅下方的 ROWS 与 RANGE。
要指定窗口框架，OVER 还必须指定窗口顺序 (ORDER BY) 子句。如果 OVER 子句没有指定窗口框架，则函数会创建从当前分区的当前行扩展到第一行的默认窗口。它等同于以下子句：
RANGE UNBOUNDED PRECEDING AND CURRENT ROW
当前行的窗口框架偏移可能是物理或逻辑偏移：
ROWS 将窗口的 start‑point 和 end‑point 指定为相对于当前行的行数。如果 start-point 和 end-point 以常数值表示，则该值的计算结果必须为正整数。
RANGE 将窗口指定为逻辑偏移，比如时间。范围值必须与窗口顺序 (ORDER BY) 子句数据类型匹配：NUMERIC、DATE/TIME、FLOAT 或 INTEGER。
使用 ROWS 或 RANGE 对于将窗口起点和终点设置为常数值实施了特定要求：
为 ROWS 设置常数值
常数的计算结果必须为正 INTEGER。
为 RANGE 设置常数值
需要满足以下要求：
常数的计算结果必须为正数值或 INTERVAL 字面量。
如果常数的计算结果为 NUMERIC 值，则 ORDER BY 列类型必须为 NUMERIC 数据类型。
如果常数的计算结果为 INTERVAL DAY TO SECOND 子类，则 ORDER BY 列类型必须为以下之一：TIMESTAMP、TIME、DATE 或 INTERVAL DAY TO SECOND。
如果常数的计算结果为 INTERVAL YEAR TO MONTH，则 ORDER BY 列类型必须为以下之一：TIMESTAMP、DATE 或 INTERVAL YEAR TO MONTH。
窗口顺序子句只可指定一个表达式。
请参阅窗口框架。
定义命名窗口，为分析函数指定窗口分区和顺序子句。此窗口在函数的 OVER 子句中指定。当您编写通过类似的 OVER 子句调用多个分析函数的查询时——例如，它们使用相同的 (PARTITION BY) 分区子句，命名窗口非常有用。
WINDOW window‑name AS ( window-partition-clause [window-order-clause] )
WINDOW window‑namewindow‑partition‑clause [window‑order‑clause]OVER 子句引用此窗口时调用的子句。
如果窗口忽略了窗口顺序子句，则 OVER 子句可以指定自己的顺序子句。
WINDOW 子句不能包含窗口框架子句。
同一个查询中的每个 WINDOW 子句都必须拥有唯一的名称。
WINDOW 子句可引用另一个已经命名的窗口。例如，下述查询先命名 w1，再命名 w2。因此，定义 WINDOW 的 w2 子句可引用 w1：
=> SELECT RANK() OVER(w1 ORDER BY sal DESC), RANK() OVER w2
FROM EMP WINDOW w1 AS (PARTITION BY deptno), w2 AS (w1 ORDER BY sal);
请参阅命名窗口。
此函数是仿照数学函数
argmax(f(x)) 设计的，返回可使
f(x) 成为最大值的 x 值。同样地，ARGMAX 使用两个实参 target 和 arg，这两个实参均为查询数据集中的列或列表达式。ARGMAX 在 target 中查找具有最大非 null 值的行，并返回该行中的 arg 值。如果有多行包含最大 target 值，ARGMAX 将返回其找到的第一行中的 arg 值。
ARGMAX ( target, arg ) OVER ( [ PARTITION BY expression[,...] ] [ window-order-clause ] )
OVER()
PARTITION BY expression：根据 expression 中的值对输入行进行分组（分区），该 expression 解析为查询数据集中的一列或多列。如果忽略此子句，ARGMAX 会将所有输入行作为单分区处理。
window-order-clause：指定如何对输入行进行排序。如果 OVER 子句还包括分区子句，则会单独在每个分区中对行进行排序。
有关详细信息，请参阅分析函数。
创建并填充表 service_info，其中包含有关各项服务、服务各自的开发组以及服务用户群的信息。users 列中的 NULL 表示该服务尚未发布，因此不会有用户。
=> CREATE TABLE service_info(dev_group VARCHAR(10), product_name VARCHAR(30), users INT);
=> COPY t FROM stdin NULL AS 'null';
>> iris|chat|48193
>> aspen|trading|3000
>> orchid|cloud|990322
>> iris|video call| 10203
>> daffodil|streaming|44123
>> hydrangea|password manager|null
>> hydrangea|totp|1837363
>> daffodil|clip share|3000
>> hydrangea|e2e sms|null
>> rose|crypto|null
>> iris|forum|48193
>> \.
ARGMAX 返回 product_name 列中的值，该值可使 users 列中的值最大。在此示例中，ARGMAX 将返回 totp，表示 totp 服务拥有最大的用户群：
=> SELECT dev_group, product_name, users, ARGMAX(users, product_name) OVER (ORDER BY dev_group ASC) FROM service_info;
dev_group | product_name | users | ARGMAX
-----------+------------------+---------+--------
aspen | trading | 3000 | totp
daffodil | clip share | 3000 | totp
daffodil | streaming | 44123 | totp
hydrangea | e2e sms | | totp
hydrangea | password manager | | totp
hydrangea | totp | 1837363 | totp
iris | chat | 48193 | totp
iris | forum | 48193 | totp
iris | video call | 10203 | totp
orchid | cloud | 990322 | totp
rose | crypto | | totp
(11 rows)
下一个查询对 dev_group 上的数据进行分区，以确定每个开发组创建的最受欢迎的服务。如果分区的 users 列仅包含 NULL 值并使用分区顶部 product_name 中的第一个值打破关系，ARGMAX 将返回 NULL。
=> SELECT dev_group, product_name, users, ARGMAX(users, product_name) OVER (PARTITION BY dev_group ORDER BY product_name ASC) FROM service_info;
dev_group | product_name | users | ARGMAX
-----------+------------------+---------+-----------
iris | chat | 48193 | chat
iris | forum | 48193 | chat
iris | video call | 10203 | chat
orchid | cloud | 990322 | cloud
aspen | trading | 3000 | trading
daffodil | clip share | 3000 | streaming
daffodil | streaming | 44123 | streaming
rose | crypto | |
hydrangea | e2e sms | | totp
hydrangea | password manager | | totp
hydrangea | totp | 1837363 | totp
(11 rows)
此函数是仿照数学函数
argmin(f(x)) 设计的，返回可使
f(x) 成为最小值的 x 值。同样地，ARGMIN 使用两个实参 target 和 arg，这两个实参均为查询数据集中的列或列表达式。ARGMIN 在 target 中查找具有最小非 null 值的行，并返回该行中的 arg 值。如果有多行包含最小 target 值，ARGMIN 将返回其找到的第一行中的 arg 值。
ARGMIN ( target, arg ) OVER ( [ PARTITION BY expression[,...] ] [ window-order-clause ] )
OVER()
PARTITION BY expression：根据 expression 中的值对输入行进行分组（分区），该 expression 解析为查询数据集中的一列或多列。如果忽略此子句，ARGMIN 会将所有输入行作为单分区处理。
window-order-clause：指定如何对输入行进行排序。如果 OVER 子句还包括分区子句，则会单独在每个分区中对行进行排序。
有关详细信息，请参阅分析函数。
创建并填充表 service_info，其中包含有关各项服务、服务各自的开发组以及服务用户群的信息。users 列中的 NULL 表示该服务尚未发布，因此不会有用户。
=> CREATE TABLE service_info(dev_group VARCHAR(10), product_name VARCHAR(30), users INT);
=> COPY t FROM stdin NULL AS 'null';
>> iris|chat|48193
>> aspen|trading|3000
>> orchid|cloud|990322
>> iris|video call| 10203
>> daffodil|streaming|44123
>> hydrangea|password manager|null
>> hydrangea|totp|1837363
>> daffodil|clip share|3000
>> hydrangea|e2e sms|null
>> rose|crypto|null
>> iris|forum|48193
>> \.
ARGMIN 返回 product_name 列中的值，该值可使 users 列中的值最小。在此示例中，ARGMIN 将返回 totp，表示 totp 服务具有最小的用户群：
=> SELECT dev_group, product_name, users, ARGMIN(users, product_name) OVER (ORDER BY dev_group ASC) FROM service_info;
dev_group | product_name | users | ARGMIN
-----------+------------------+---------+---------
aspen | trading | 3000 | trading
daffodil | clip share | 3000 | trading
daffodil | streaming | 44123 | trading
hydrangea | e2e sms | | trading
hydrangea | password manager | | trading
hydrangea | totp | 1837363 | trading
iris | chat | 48193 | trading
iris | forum | 48193 | trading
iris | video call | 10203 | trading
orchid | cloud | 990322 | trading
rose | crypto | | trading
(11 rows)
下一个查询对 dev_group 上的数据进行分区，以确定每个开发组创建的最不受欢迎的服务。如果分区的 users 列仅包含 NULL 值并使用分区顶部 product_name 中的第一个值打破关系，ARGMIN 将返回 NULL。
=> SELECT dev_group, product_name, users, ARGMIN(users, product_name) OVER (PARTITION BY dev_group ORDER BY product_name ASC) FROM service_info;
dev_group | product_name | users | ARGMIN
-----------+------------------+---------+------------
iris | chat | 48193 | video call
iris | forum | 48193 | video call
iris | video call | 10203 | video call
orchid | cloud | 990322 | cloud
aspen | trading | 3000 | trading
daffodil | clip share | 3000 | clip share
daffodil | streaming | 44123 | clip share
rose | crypto | |
hydrangea | e2e sms | | totp
hydrangea | password manager | | totp
hydrangea | totp | 1837363 | totp
(11 rows)
计算
窗口内一组中表达式的平均值。 AVG 返回与表达式的数字数据类型相同的数据类型。
AVG 分析函数不同于
AVG 聚合函数，后者计算一组行中表达式的平均值。
AVG ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
OVER()默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。
以下查询查找该日历月的销售，并使用默认的 RANGE UNBOUNDED PRECEDING AND CURRENT ROW 窗口返回一个运行/累计平均值（有时称为移动平均值）：
=> SELECT calendar_month_number_in_year Mo, SUM(product_price) Sales,
AVG(SUM(product_price)) OVER (ORDER BY calendar_month_number_in_year)::INTEGER Average
FROM product_dimension pd, date_dimension dm, inventory_fact if
WHERE dm.date_key = if.date_key AND pd.product_key = if.product_key GROUP BY Mo;
Mo | Sales | Average
----+----------+----------
1 | 23869547 | 23869547
2 | 19604661 | 21737104
3 | 22877913 | 22117374
4 | 22901263 | 22313346
5 | 23670676 | 22584812
6 | 22507600 | 22571943
7 | 21514089 | 22420821
8 | 24860684 | 22725804
9 | 21687795 | 22610470
10 | 23648921 | 22714315
11 | 21115910 | 22569005
12 | 24708317 | 22747281
(12 rows)
要返回不是运行（累计）平均值的移动平均值，该窗口应指定 ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING：
=> SELECT calendar_month_number_in_year Mo, SUM(product_price) Sales,
AVG(SUM(product_price)) OVER (ORDER BY calendar_month_number_in_year
ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)::INTEGER Average
FROM product_dimension pd, date_dimension dm, inventory_fact if
WHERE dm.date_key = if.date_key AND pd.product_key = if.product_key GROUP BY Mo;
Mo | Sales | Average
----+----------+----------
1 | 23869547 | 22117374
2 | 19604661 | 22313346
3 | 22877913 | 22584812
4 | 22901263 | 22312423
5 | 23670676 | 22694308
6 | 22507600 | 23090862
7 | 21514089 | 22848169
8 | 24860684 | 22843818
9 | 21687795 | 22565480
10 | 23648921 | 23204325
11 | 21115910 | 22790236
12 | 24708317 | 23157716
(12 rows)
返回
窗口内表达式的布尔值。如果所有输入值都为 true，则 BOOL_AND 返回 t。否则，它返回 f。
BOOL_AND ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。
=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE
将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。
=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
OUTPUT
--------
10
(1 row)
查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。
=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;
emptype | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
contractor1 | t | t | f
contractor2 | f | t | t
contractor3 | f | t | t
contractor4 | t | t | f
contractor5 | f | f | f
(5 rows)
返回
窗口内表达式的布尔值。如果至少一个输入值为 true，则 BOOL_OR 返回 t。否则，它返回 f。
BOOL_OR ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。
=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE
将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。
=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
OUTPUT
--------
10
(1 row)
查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。
=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;
emptype | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
contractor1 | t | t | f
contractor2 | f | t | t
contractor3 | f | t | t
contractor4 | t | t | f
contractor5 | f | f | f
(5 rows)
返回
窗口内表达式的布尔值。如果只有一个输入值为真，BOOL_XOR 将返回 t。否则，它返回 f。
BOOL_XOR ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
以下示例说明了如何使用 BOOL_AND、BOOL_OR 和 BOOL_XOR 分析函数。示例表 employee 包含一个用于表示员工类型和年薪的列。
=> CREATE TABLE employee(emptype VARCHAR, yearspaid VARCHAR);
CREATE TABLE
将样本数据插入表中以显示年薪。在多种情况下，员工可以在一年内多次获得报酬。
=> INSERT INTO employee
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2015'
UNION ALL
SELECT 'contractor3', '2014'
UNION ALL
SELECT 'contractor1', '2014'
UNION ALL
SELECT 'contractor2', '2014'
UNION ALL
SELECT 'contractor3', '2015'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor4', '2014'
UNION ALL
SELECT 'contractor5', '2015'
UNION ALL
SELECT 'contractor5', '2016';
OUTPUT
--------
10
(1 row)
查询该表。结果显示在 2014 年获得了两次报酬的员工 (BOOL_AND)，在 2014 年获得了一次或两次报酬的员工 (BOOL_OR)，以及专门显示在 2014 年获得不超过一次报酬的员工 (BOOL_XOR)。
=> SELECT DISTINCT emptype,
BOOL_AND(yearspaid='2014') OVER (PARTITION BY emptype) AS paidtwicein2014,
BOOL_OR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidonceortwicein2014,
BOOL_XOR(yearspaid='2014') OVER (PARTITION BY emptype) AS paidjustoncein2014
FROM employee;
emptype | paidtwicein2014 | paidonceortwicein2014 | paidjustoncein2014
-------------+-----------------+-----------------------+--------------------
contractor1 | t | t | f
contractor2 | f | t | t
contractor3 | f | t | t
contractor4 | t | t | f
contractor5 | f | f | f
(5 rows)
从 0 开始向每个行分配一个事件窗口编号，并在当前行中评估参数表达式的结果与上一行不同时，以 1 为增量递增事件窗口编号。
CONDITIONAL_CHANGE_EVENT ( expression ) OVER (
[ window-partition-clause ]
window-order-clause )
expressionOVER()分析 window-order-clause 是必需的，但 window-partition-clause 是可选的。
=> SELECT CONDITIONAL_CHANGE_EVENT(bid)
OVER (PARTITION BY symbol ORDER BY ts) AS cce
FROM TickStore;
没有 ORDER BY 子句时，系统将返回错误：
=> SELECT CONDITIONAL_CHANGE_EVENT(bid)
OVER (PARTITION BY symbol) AS cce
FROM TickStore;
ERROR: conditional_change_event must contain an
ORDER BY clause within its analytic clause
有关更多示例，请参阅事件窗口。
从 0 开始向每个行分配一个事件窗口编号，并在当 boolean 参数表达式的结果评估为 true 时，以 1 为增量递增事件窗口编号。例如，假定某列的值的顺序如下：
( 1, 2, 3, 4, 5, 6 )
CONDITIONAL_TRUE_EVENT(a > 3) returns 0, 0, 0, 1, 2, 3.
CONDITIONAL_TRUE_EVENT ( boolean-expression ) OVER (
[ window-partition-clause ]
window-order-clause )
OVER()分析 window-order-clause 是必需的，但 window-partition-clause 是可选的。
> SELECT CONDITIONAL_TRUE_EVENT(bid > 10.6)
OVER(PARTITION BY bid ORDER BY ts) AS cte
FROM Tickstore;
如果忽略 ORDER BY 子句，系统将返回错误：
> SELECT CONDITIONAL_TRUE_EVENT(bid > 10.6)
OVER(PARTITION BY bid) AS cte
FROM Tickstore;
ERROR: conditional_true_event must contain an ORDER BY
clause within its analytic clause
有关更多示例，请参阅事件窗口。
对
窗口中组内的出现次数进行计数。如果指定 * 或某个非 NULL 常数，COUNT() 会对所有行进行计数。
COUNT ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
OVER()使用 窗口框架 中定义的架构时，以下 COUNT 函数将忽略窗口顺序子句和窗口框架子句；否则 Vertica 会将其视为窗口聚合。将报告聚合的窗口视为 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。
=> SELECT deptno, sal, empno, COUNT(sal)
OVER (PARTITION BY deptno) AS count FROM emp;
deptno | sal | empno | count
--------+-----+-------+-------
10 | 101 | 1 | 2
10 | 104 | 4 | 2
20 | 110 | 10 | 6
20 | 110 | 9 | 6
20 | 109 | 7 | 6
20 | 109 | 6 | 6
20 | 109 | 8 | 6
20 | 109 | 11 | 6
30 | 105 | 5 | 3
30 | 103 | 3 | 3
30 | 102 | 2 | 3
使用 ORDER BY sal 会创建包含默认窗口的移动窗口查询： RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW.
=> SELECT deptno, sal, empno, COUNT(sal)
OVER (PARTITION BY deptno ORDER BY sal) AS count
FROM emp;
deptno | sal | empno | count
--------+-----+-------+-------
10 | 101 | 1 | 1
10 | 104 | 4 | 2
20 | 100 | 11 | 1
20 | 109 | 7 | 4
20 | 109 | 6 | 4
20 | 109 | 8 | 4
20 | 110 | 10 | 6
20 | 110 | 9 | 6
30 | 102 | 2 | 1
30 | 103 | 3 | 2
30 | 105 | 5 | 3
使用 VMart 架构时，以下查询会查找其每小时工资小于或等于当前员工的员工数。该查询使用默认窗口 RANGE UNBOUNDED PRECEDING AND CURRENT ROW 返回运行/累计平均数（有时称为移动平均数）：
=> SELECT employee_last_name AS "last_name", hourly_rate, COUNT(*)
OVER (ORDER BY hourly_rate) AS moving_count from employee_dimension;
last_name | hourly_rate | moving_count
------------+-------------+--------------
Gauthier | 6 | 4
Taylor | 6 | 4
Jefferson | 6 | 4
Nielson | 6 | 4
McNulty | 6.01 | 11
Robinson | 6.01 | 11
Dobisz | 6.01 | 11
Williams | 6.01 | 11
Kramer | 6.01 | 11
Miller | 6.01 | 11
Wilson | 6.01 | 11
Vogel | 6.02 | 14
Moore | 6.02 | 14
Vogel | 6.02 | 14
Carcetti | 6.03 | 19
...
要返回不是运行（累计）平均数的移动平均数，窗口应指定 ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING：
=> SELECT employee_last_name AS "last_name", hourly_rate, COUNT(*)
OVER (ORDER BY hourly_rate ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
AS moving_count from employee_dimension;
计算 窗口内同一分区中当前行的累计分布或相对于其他行的排序。
CUME_DIST() 返回大于 0 且小于等于 1 的数字，其中该数字表示指定行在由 n 行组成的组中的相对位置。对于第 x 行（假定 ASC 排序），CUME_DIST 的 x 为数值小于等于 x 的行数除以整个分区的总行数。例如，在由三行组成的组中，返回的累计分布值应为 1/3、2/3 和 3/3。
CUME_DIST ( ) OVER (
[ window-partition-clause ]
window-order-clause )
OVER()以下示例返回第一季度每月内不同交易类型销售额的累计分布。
=> SELECT calendar_month_name AS month, tender_type, SUM(sales_quantity),
CUME_DIST()
OVER (PARTITION BY calendar_month_name ORDER BY SUM(sales_quantity)) AS
CUME_DIST
FROM store.store_sales_fact JOIN date_dimension
USING(date_key) WHERE calendar_month_name IN ('January','February','March')
AND tender_type NOT LIKE 'Other'
GROUP BY calendar_month_name, tender_type;
month | tender_type | SUM | CUME_DIST
----------+-------------+--------+-----------
March | Credit | 469858 | 0.25
March | Cash | 470449 | 0.5
March | Check | 473033 | 0.75
March | Debit | 475103 | 1
January | Cash | 441730 | 0.25
January | Debit | 443922 | 0.5
January | Check | 446297 | 0.75
January | Credit | 450994 | 1
February | Check | 425665 | 0.25
February | Debit | 426726 | 0.5
February | Credit | 430010 | 0.75
February | Cash | 430767 | 1
(12 rows)
在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。DENSE_RANK 函数返回无间隙的排名数字序列。
DENSE_RANK 按以下方式执行：
按 ORDER BY 子句指定的顺序对分区行进行排序。
比较前一行与当前行的 ORDER BY 值，并按以下方式对当前行进行排名：
如果 ORDER BY 值相同，则当前行获得的排名与前一行相同。
如果 ORDER BY 值不同，DENSE_RANK 会依据升序或降序的排序顺序，将当前行的排名增加或减少 1 个名次。
DENSE_RANK 始终将排名更改 1 个名次，因此排名序列中不会出现间隙。最大排名值是查询返回的唯一 ORDER BY 值的数量。
DENSE_RANK() OVER (
[ window-partition-clause ]
window-order-clause )
OVER()请参阅分析函数
RANK 会在排名序列中留下间隙，而 DENSE_RANK 不会出现该情况。以下示例将两种函数的运算操作进行了比较。
以下查询调用 RANK 和 DENSE_RANK，按照年收入对客户进行排名。两种函数返回了不同的排名，如下所示：
如果 annual_salary 包含重复值，RANK() 会插入重复排名，然后跳过一个或多个值，例如从 4 跳到 6，从 7 跳到 9。
在平行列 Dense Rank 中，DENSE_RANK() 也会插入重复排名，但不会在排名序列中留下间隙：
=> SELECT employee_region region, employee_key, annual_salary,
RANK() OVER (PARTITION BY employee_region ORDER BY annual_salary) Rank,
DENSE_RANK() OVER (PARTITION BY employee_region ORDER BY annual_salary) "Dense Rank"
FROM employee_dimension;
region | employee_key | annual_salary | Rank | Dense Rank
----------------------------------+--------------+---------------+------+------------
West | 5248 | 1200 | 1 | 1
West | 6880 | 1204 | 2 | 2
West | 5700 | 1214 | 3 | 3
West | 9857 | 1218 | 4 | 4
West | 6014 | 1218 | 4 | 4
West | 9221 | 1220 | 6 | 5
West | 7646 | 1222 | 7 | 6
West | 6621 | 1222 | 7 | 6
West | 6488 | 1224 | 9 | 7
West | 7659 | 1226 | 10 | 8
West | 7432 | 1226 | 10 | 8
West | 9905 | 1226 | 10 | 8
West | 9021 | 1228 | 13 | 9
...
West | 56 | 963104 | 2794 | 2152
West | 100 | 992363 | 2795 | 2153
East | 8353 | 1200 | 1 | 1
East | 9743 | 1202 | 2 | 2
East | 9975 | 1202 | 2 | 2
East | 9205 | 1204 | 4 | 3
East | 8894 | 1206 | 5 | 4
East | 7740 | 1206 | 5 | 4
East | 7324 | 1208 | 7 | 5
East | 6505 | 1208 | 7 | 5
East | 5404 | 1208 | 7 | 5
East | 5010 | 1208 | 7 | 5
East | 9114 | 1212 | 11 | 6
...
使用平滑系数 X 计算表达式 E 的指数移动平均线 (EMA)。EMA 与简单移动平均线不同，它提供了更稳定的图像，可显示数据随时间的变化。
通过将上一个 EMA 值添加到按照平滑系数成比例变化的当前数据点，可以计算 EMA 值，如以下公式所示：
EMA = EMA0 + (X * (E - EMA0))
其中：
E 是当前数据点
EMA0 是上一行的 EMA 值。
X 是平滑系数。
此函数也可以在行级别工作。例如，EMA 假设给定列中的数据是按照均匀间隔取样的。如果用户的数据点是按照不均匀间隔取样的，则应该在 EMA() 之前运行时间序列空白填充和插值 (GFI) 操作
EXPONENTIAL_MOVING_AVERAGE ( E, X ) OVER (
[ window-partition-clause ]
window-order-clause )
INTEGER、FLOAT 或 NUMERIC 类型，并且必须是常数。FLOAT 值。OVER()以下示例首先在子查询中使用时间序列空白填充和插值 (GFI)，然后对子查询结果执行 EXPONENTIAL_MOVING_AVERAGE 操作。
创建一个简单的四列表：
=> CREATE TABLE ticker(
time TIMESTAMP,
symbol VARCHAR(8),
bid1 FLOAT,
bid2 FLOAT );
插入一些数据，包括 NULL，以便于 GFI 可以执行插值和空白填充：
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:00', 'ABC', 60.45, 60.44);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:01', 'ABC', 60.49, 65.12);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:02', 'ABC', 57.78, 59.25);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:03', 'ABC', null, 65.12);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:04', 'ABC', 67.88, null);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:00', 'XYZ', 47.55, 40.15);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:01', 'XYZ', 44.35, 46.78);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:02', 'XYZ', 71.56, 75.78);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:03', 'XYZ', 85.55, 70.21);
=> INSERT INTO ticker VALUES ('2009-07-12 03:00:04', 'XYZ', 45.55, 58.65);
=> COMMIT;
IGNORE NULLS，并且您的数据包含一个实值和一个 NULL 值，则结果为 NULL。如果任意一侧中有值为 NULL，则结果为 NULL。有关详细信息，请参阅当时间序列数据包含空值时。
查询您刚创建的表，以便于看到输出：
=> SELECT * FROM ticker;
time | symbol | bid1 | bid2
---------------------+--------+-------+-------
2009-07-12 03:00:00 | ABC | 60.45 | 60.44
2009-07-12 03:00:01 | ABC | 60.49 | 65.12
2009-07-12 03:00:02 | ABC | 57.78 | 59.25
2009-07-12 03:00:03 | ABC | | 65.12
2009-07-12 03:00:04 | ABC | 67.88 |
2009-07-12 03:00:00 | XYZ | 47.55 | 40.15
2009-07-12 03:00:01 | XYZ | 44.35 | 46.78
2009-07-12 03:00:02 | XYZ | 71.56 | 75.78
2009-07-12 03:00:03 | XYZ | 85.55 | 70.21
2009-07-12 03:00:04 | XYZ | 45.55 | 58.65
(10 rows)
以下查询处理表 trades 的列 a 中的每个 2 秒时间片所包含的第一个和最后一个值。查询然后使用平滑系数 50% 计算表达式 fv 和 lv 的指数移动平均线：
=> SELECT symbol, slice_time, fv, lv,
EXPONENTIAL_MOVING_AVERAGE(fv, 0.5)
OVER (PARTITION BY symbol ORDER BY slice_time) AS ema_first,
EXPONENTIAL_MOVING_AVERAGE(lv, 0.5)
OVER (PARTITION BY symbol ORDER BY slice_time) AS ema_last
FROM (
SELECT symbol, slice_time,
TS_FIRST_VALUE(bid1 IGNORE NULLS) as fv,
TS_LAST_VALUE(bid2 IGNORE NULLS) AS lv
FROM ticker TIMESERIES slice_time AS '2 seconds'
OVER (PARTITION BY symbol ORDER BY time) ) AS sq;
symbol | slice_time | fv | lv | ema_first | ema_last
--------+---------------------+-------+-------+-----------+----------
ABC | 2009-07-12 03:00:00 | 60.45 | 65.12 | 60.45 | 65.12
ABC | 2009-07-12 03:00:02 | 57.78 | 65.12 | 59.115 | 65.12
ABC | 2009-07-12 03:00:04 | 67.88 | 65.12 | 63.4975 | 65.12
XYZ | 2009-07-12 03:00:00 | 47.55 | 46.78 | 47.55 | 46.78
XYZ | 2009-07-12 03:00:02 | 71.56 | 70.21 | 59.555 | 58.495
XYZ | 2009-07-12 03:00:04 | 45.55 | 58.65 | 52.5525 | 58.5725
(6 rows)
用于选择表或分区的第一个值（由 window-order-clause 确定），无需使用自联接。当您希望使用第一个值作为计算的基线时，此函数很有用。
将 FIRST_VALUE() 与 window-order-clause 结合使用，以生成具有确定性的结果。如果没有为当前行指定
窗口，则默认窗口为 UNBOUNDED PRECEDING AND CURRENT ROW。
FIRST_VALUE ( expression [ IGNORE NULLS ] ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
IGNORE NULLSNULL，则返回 NULL。如果忽略此选项，且集合中的第一个值为 NULL，函数将返回 NULL。OVER()以下查询希望获得“在星期几进行分区”值集的第一个值，并说明 FIRST_VALUE() 的潜在不确定性：
=> SELECT calendar_year, date_key, day_of_week, full_date_description,
FIRST_VALUE(full_date_description)
OVER(PARTITION BY calendar_month_number_in_year ORDER BY day_of_week)
AS "first_value"
FROM date_dimension
WHERE calendar_year=2003 AND calendar_month_number_in_year=1;
返回的第一个值为 2003 年 1 月 31 日；但是下次运行相同的查询时，第一个值可能是 1 月 24 日或 1 月 3 日，或 10 日或 17 日。这是因为分析 ORDER BY 列 day_of_week 会返回包含关系（多个星期五）的行。这些重复的值使 ORDER BY 求值结果具有不确定性，因为包含关系的行可以按照任何方式排序，这些行中的任何一个都符合称为 day_of_week 的第一个值的条件。
calendar_year | date_key | day_of_week | full_date_description | first_value
--------------+----------+-------------+-----------------------+------------------
2003 | 31 | Friday | January 31, 2003 | January 31, 2003
2003 | 24 | Friday | January 24, 2003 | January 31, 2003
2003 | 3 | Friday | January 3, 2003 | January 31, 2003
2003 | 10 | Friday | January 10, 2003 | January 31, 2003
2003 | 17 | Friday | January 17, 2003 | January 31, 2003
2003 | 6 | Monday | January 6, 2003 | January 31, 2003
2003 | 27 | Monday | January 27, 2003 | January 31, 2003
2003 | 13 | Monday | January 13, 2003 | January 31, 2003
2003 | 20 | Monday | January 20, 2003 | January 31, 2003
2003 | 11 | Saturday | January 11, 2003 | January 31, 2003
2003 | 18 | Saturday | January 18, 2003 | January 31, 2003
2003 | 25 | Saturday | January 25, 2003 | January 31, 2003
2003 | 4 | Saturday | January 4, 2003 | January 31, 2003
2003 | 12 | Sunday | January 12, 2003 | January 31, 2003
2003 | 26 | Sunday | January 26, 2003 | January 31, 2003
2003 | 5 | Sunday | January 5, 2003 | January 31, 2003
2003 | 19 | Sunday | January 19, 2003 | January 31, 2003
2003 | 23 | Thursday | January 23, 2003 | January 31, 2003
2003 | 2 | Thursday | January 2, 2003 | January 31, 2003
2003 | 9 | Thursday | January 9, 2003 | January 31, 2003
2003 | 16 | Thursday | January 16, 2003 | January 31, 2003
2003 | 30 | Thursday | January 30, 2003 | January 31, 2003
2003 | 21 | Tuesday | January 21, 2003 | January 31, 2003
2003 | 14 | Tuesday | January 14, 2003 | January 31, 2003
2003 | 7 | Tuesday | January 7, 2003 | January 31, 2003
2003 | 28 | Tuesday | January 28, 2003 | January 31, 2003
2003 | 22 | Wednesday | January 22, 2003 | January 31, 2003
2003 | 29 | Wednesday | January 29, 2003 | January 31, 2003
2003 | 15 | Wednesday | January 15, 2003 | January 31, 2003
2003 | 1 | Wednesday | January 1, 2003 | January 31, 2003
2003 | 8 | Wednesday | January 8, 2003 | January 31, 2003
(31 rows)
day_of_week 结果按照字母顺序返回。每天都不是按照 7 天一周的周期（例如，从星期天开始，然后是星期一、星期二等）的顺序显示，这样的事实对结果没有影响。
要返回具有确定性的结果，请修改查询，使其对唯一 字段（如 date_key）执行分析 ORDER BY 操作：
=> SELECT calendar_year, date_key, day_of_week, full_date_description,
FIRST_VALUE(full_date_description) OVER
(PARTITION BY calendar_month_number_in_year ORDER BY date_key) AS "first_value"
FROM date_dimension WHERE calendar_year=2003;
FIRST_VALUE() 针对一月份分区返回第一个值 1 月 1 日，针对二月份分区返回第一个值 2 月 1 日 。此外，full_date_description 列不包含关系：
calendar_year | date_key | day_of_week | full_date_description | first_value
---------------+----------+-------------+-----------------------+------------
2003 | 1 | Wednesday | January 1, 2003 | January 1, 2003
2003 | 2 | Thursday | January 2, 2003 | January 1, 2003
2003 | 3 | Friday | January 3, 2003 | January 1, 2003
2003 | 4 | Saturday | January 4, 2003 | January 1, 2003
2003 | 5 | Sunday | January 5, 2003 | January 1, 2003
2003 | 6 | Monday | January 6, 2003 | January 1, 2003
2003 | 7 | Tuesday | January 7, 2003 | January 1, 2003
2003 | 8 | Wednesday | January 8, 2003 | January 1, 2003
2003 | 9 | Thursday | January 9, 2003 | January 1, 2003
2003 | 10 | Friday | January 10, 2003 | January 1, 2003
2003 | 11 | Saturday | January 11, 2003 | January 1, 2003
2003 | 12 | Sunday | January 12, 2003 | January 1, 2003
2003 | 13 | Monday | January 13, 2003 | January 1, 2003
2003 | 14 | Tuesday | January 14, 2003 | January 1, 2003
2003 | 15 | Wednesday | January 15, 2003 | January 1, 2003
2003 | 16 | Thursday | January 16, 2003 | January 1, 2003
2003 | 17 | Friday | January 17, 2003 | January 1, 2003
2003 | 18 | Saturday | January 18, 2003 | January 1, 2003
2003 | 19 | Sunday | January 19, 2003 | January 1, 2003
2003 | 20 | Monday | January 20, 2003 | January 1, 2003
2003 | 21 | Tuesday | January 21, 2003 | January 1, 2003
2003 | 22 | Wednesday | January 22, 2003 | January 1, 2003
2003 | 23 | Thursday | January 23, 2003 | January 1, 2003
2003 | 24 | Friday | January 24, 2003 | January 1, 2003
2003 | 25 | Saturday | January 25, 2003 | January 1, 2003
2003 | 26 | Sunday | January 26, 2003 | January 1, 2003
2003 | 27 | Monday | January 27, 2003 | January 1, 2003
2003 | 28 | Tuesday | January 28, 2003 | January 1, 2003
2003 | 29 | Wednesday | January 29, 2003 | January 1, 2003
2003 | 30 | Thursday | January 30, 2003 | January 1, 2003
2003 | 31 | Friday | January 31, 2003 | January 1, 2003
2003 | 32 | Saturday | February 1, 2003 | February 1, 2003
2003 | 33 | Sunday | February 2, 2003 | February 1,2003
...
(365 rows)
在 窗口内当前行之前按照给定的偏移量返回该输入表达式的值。此函数允许您同时访问表中的多行。这对于在可以可靠地知道行的相对位置时比较值很有用。借助它还可以避免成本较高的自联接，从而加快查询处理速度。
有关获取后续行的信息，请参阅 LEAD。
LAG ( expression[, offset ] [, default ] ) OVER (
[ window-partition-clause ]
window-order-clause )
这个例子计算了表中按照日期所剩下的余额的总和，同时计算了最后一天的先前余额的总和。依照接下来的输入，数据满足以下条件：
对于每个 some_id，每个由 month_date 表示的日期都有 1 个行。
对于每个 some_id，日期都是连续的；也就是说，如果 2 月 24 号有一行，2 月 26 号有一行，则 2 月 25 号也有一行。
每个 some_id 都有相同的一组日期。
=> CREATE TABLE balances (
month_date DATE,
current_bal INT,
some_id INT);
=> INSERT INTO balances values ('2009-02-24', 10, 1);
=> INSERT INTO balances values ('2009-02-25', 10, 1);
=> INSERT INTO balances values ('2009-02-26', 10, 1);
=> INSERT INTO balances values ('2009-02-24', 20, 2);
=> INSERT INTO balances values ('2009-02-25', 20, 2);
=> INSERT INTO balances values ('2009-02-26', 20, 2);
=> INSERT INTO balances values ('2009-02-24', 30, 3);
=> INSERT INTO balances values ('2009-02-25', 20, 3);
=> INSERT INTO balances values ('2009-02-26', 30, 3);
现在使用 LAG 计算当前每一个日期的余额的总和，以及最后一天的先前余额的总和：
=> SELECT month_date,
SUM(current_bal) as current_bal_sum,
SUM(previous_bal) as previous_bal_sum FROM
(SELECT month_date, current_bal,
LAG(current_bal, 1, 0) OVER
(PARTITION BY some_id ORDER BY month_date)
AS previous_bal FROM balances) AS subQ
GROUP BY month_date ORDER BY month_date;
month_date | current_bal_sum | previous_bal_sum
------------+-----------------+------------------
2009-02-24 | 60 | 0
2009-02-25 | 50 | 60
2009-02-26 | 60 | 50
(3 rows)
对于相同的示例数据来说，不可使用接下来的查询，原因是 LAG 嵌套在一个聚合函数中：
=> SELECT month_date,
SUM(current_bal) as current_bal_sum,
SUM(LAG(current_bal, 1, 0) OVER
(PARTITION BY some_id ORDER BY month_date)) AS previous_bal_sum
FROM some_table GROUP BY month_date ORDER BY month_date;
下面的示例使用了 VMart 数据库。LAG 首先返回前一行的年收入值，然后计算当前行收入与前一行收入的差：
=> SELECT occupation, customer_key, customer_name, annual_income,
LAG(annual_income, 1, 0) OVER (PARTITION BY occupation
ORDER BY annual_income) AS prev_income, annual_income -
LAG(annual_income, 1, 0) OVER (PARTITION BY occupation
ORDER BY annual_income) AS difference
FROM customer_dimension ORDER BY occupation, customer_key LIMIT 20;
occupation | customer_key | customer_name | annual_income | prev_income | difference
------------+--------------+----------------------+---------------+-------------+------------
Accountant | 15 | Midori V. Peterson | 692610 | 692535 | 75
Accountant | 43 | Midori S. Rodriguez | 282359 | 280976 | 1383
Accountant | 93 | Robert P. Campbell | 471722 | 471355 | 367
Accountant | 102 | Sam T. McNulty | 901636 | 901561 | 75
Accountant | 134 | Martha B. Overstreet | 705146 | 704335 | 811
Accountant | 165 | James C. Kramer | 376841 | 376474 | 367
Accountant | 225 | Ben W. Farmer | 70574 | 70449 | 125
Accountant | 270 | Jessica S. Lang | 684204 | 682274 | 1930
Accountant | 273 | Mark X. Lampert | 723294 | 722737 | 557
Accountant | 295 | Sharon K. Gauthier | 29033 | 28412 | 621
Accountant | 338 | Anna S. Jackson | 816858 | 815557 | 1301
Accountant | 377 | William I. Jones | 915149 | 914872 | 277
Accountant | 438 | Joanna A. McCabe | 147396 | 144482 | 2914
Accountant | 452 | Kim P. Brown | 126023 | 124797 | 1226
Accountant | 467 | Meghan K. Carcetti | 810528 | 810284 | 244
Accountant | 478 | Tanya E. Greenwood | 639649 | 639029 | 620
Accountant | 511 | Midori P. Vogel | 187246 | 185539 | 1707
Accountant | 525 | Alexander K. Moore | 677433 | 677050 | 383
Accountant | 550 | Sam P. Reyes | 735691 | 735355 | 336
Accountant | 577 | Robert U. Vu | 616101 | 615439 | 662
(20 rows)
接下来的示例使用了 LEAD 和 LAG 返回了当前行工资后的第三行以及当前行工资之前的第五行：
=> SELECT hire_date, employee_key, employee_last_name,
LEAD(hire_date, 1) OVER (ORDER BY hire_date) AS "next_hired" ,
LAG(hire_date, 1) OVER (ORDER BY hire_date) AS "last_hired"
FROM employee_dimension ORDER BY hire_date, employee_key;
hire_date | employee_key | employee_last_name | next_hired | last_hired
------------+--------------+--------------------+------------+------------
1956-04-11 | 2694 | Farmer | 1956-05-12 |
1956-05-12 | 5486 | Winkler | 1956-09-18 | 1956-04-11
1956-09-18 | 5525 | McCabe | 1957-01-15 | 1956-05-12
1957-01-15 | 560 | Greenwood | 1957-02-06 | 1956-09-18
1957-02-06 | 9781 | Bauer | 1957-05-25 | 1957-01-15
1957-05-25 | 9506 | Webber | 1957-07-04 | 1957-02-06
1957-07-04 | 6723 | Kramer | 1957-07-07 | 1957-05-25
1957-07-07 | 5827 | Garnett | 1957-11-11 | 1957-07-04
1957-11-11 | 373 | Reyes | 1957-11-21 | 1957-07-07
1957-11-21 | 3874 | Martin | 1958-02-06 | 1957-11-11
(10 rows)
用于选择表或分区的最后一个值（由 window-order-clause 确定），无需使用自联接。 LAST_VALUE 在窗口顺序子句统计后，取分区的最后一个记录。然后此函数根据最后一个记录计算表达式，并返回结果。如果要使用最后值做为计算的基准，该函数非常有帮助。
将 LAST_VALUE() 与 window-order-clause 结合使用，以生成具有确定性的结果。如果没有为当前行指定
窗口，则默认窗口为 UNBOUNDED PRECEDING AND CURRENT ROW。
LAST_VALUE 并非总是会返回分区的最后一个值。如果在分析子句中忽略 窗口框架子句，则 LAST_VALUE 会在此默认窗口中运行。虽然结果并不返回当前分区的最后一个值使其看起来并不直观，但是它返回了窗口的最后一个值，并且此值随当前正在处理的输入行而不断变化。如果您要返回分区的最后一个值，请使用 UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING。请看下方示例。
LAST_VALUE ( expression [ IGNORE NULLS ] ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
IGNORE NULLSNULL，则返回 NULL。如果忽略此选项且集合中的最后一个值为 NULL，则函数将返回 NULL。OVER()如果在分析数据时使用在 窗口框架 中定义的架构，以下查询并不会按照部门显示最高工资数；它会按照部门和工资显示最高工资数。
=> SELECT deptno, sal, empno, LAST_VALUE(sal)
OVER (PARTITION BY deptno ORDER BY sal) AS lv
FROM emp;
deptno | sal | empno | lv
--------+-----+-------+--------
10 | 101 | 1 | 101
10 | 104 | 4 | 104
20 | 100 | 11 | 100
20 | 109 | 7 | 109
20 | 109 | 6 | 109
20 | 109 | 8 | 109
20 | 110 | 10 | 110
20 | 110 | 9 | 110
30 | 102 | 2 | 102
30 | 103 | 3 | 103
30 | 105 | 5 | 105
如果包含了窗口框架子句 ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING， LAST_VALUE() 按部门返回最高工资，是信息的准确表达。
=> SELECT deptno, sal, empno, LAST_VALUE(sal)
OVER (PARTITION BY deptno ORDER BY sal
ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING) AS lv
FROM emp;
deptno | sal | empno | lv
--------+-----+-------+--------
10 | 101 | 1 | 104
10 | 104 | 4 | 104
20 | 100 | 11 | 110
20 | 109 | 7 | 110
20 | 109 | 6 | 110
20 | 109 | 8 | 110
20 | 110 | 10 | 110
20 | 110 | 9 | 110
30 | 102 | 2 | 105
30 | 103 | 3 | 105
30 | 105 | 5 | 105
更多示例，请访问 FIRST_VALUE()。
从 窗口内当前行之后的行返回值，以便您可以同时访问表中的多行。这对于在可以可靠地知道行的相对位置时比较值很有用。借助它还可以避免成本较高的自联接，从而加快查询处理速度。
LEAD ( expression[, offset ] [, default ] ) OVER (
[ window-partition-clause ]
window-order-clause )
LEAD 在当前行之后找到了员工的雇佣日期：
=> SELECT employee_region, hire_date, employee_key, employee_last_name,
LEAD(hire_date, 1) OVER (PARTITION BY employee_region ORDER BY hire_date) AS "next_hired"
FROM employee_dimension ORDER BY employee_region, hire_date, employee_key;
employee_region | hire_date | employee_key | employee_last_name | next_hired
-------------------+------------+--------------+--------------------+------------
East | 1956-04-08 | 9218 | Harris | 1957-02-06
East | 1957-02-06 | 7799 | Stein | 1957-05-25
East | 1957-05-25 | 3687 | Farmer | 1957-06-26
East | 1957-06-26 | 9474 | Bauer | 1957-08-18
East | 1957-08-18 | 570 | Jefferson | 1957-08-24
East | 1957-08-24 | 4363 | Wilson | 1958-02-17
East | 1958-02-17 | 6457 | McCabe | 1958-06-26
East | 1958-06-26 | 6196 | Li | 1958-07-16
East | 1958-07-16 | 7749 | Harris | 1958-09-18
East | 1958-09-18 | 9678 | Sanchez | 1958-11-10
(10 rows)
接下来的示例使用 LEAD 和 LAG 返回了当前行工资后的第三行以及当前行工资之前的第五行。
=> SELECT hire_date, employee_key, employee_last_name,
LEAD(hire_date, 1) OVER (ORDER BY hire_date) AS "next_hired" ,
LAG(hire_date, 1) OVER (ORDER BY hire_date) AS "last_hired"
FROM employee_dimension ORDER BY hire_date, employee_key;
hire_date | employee_key | employee_last_name | next_hired | last_hired
------------+--------------+--------------------+------------+------------
1956-04-11 | 2694 | Farmer | 1956-05-12 |
1956-05-12 | 5486 | Winkler | 1956-09-18 | 1956-04-11
1956-09-18 | 5525 | McCabe | 1957-01-15 | 1956-05-12
1957-01-15 | 560 | Greenwood | 1957-02-06 | 1956-09-18
1957-02-06 | 9781 | Bauer | 1957-05-25 | 1957-01-15
1957-05-25 | 9506 | Webber | 1957-07-04 | 1957-02-06
1957-07-04 | 6723 | Kramer | 1957-07-07 | 1957-05-25
1957-07-07 | 5827 | Garnett | 1957-11-11 | 1957-07-04
1957-11-11 | 373 | Reyes | 1957-11-21 | 1957-07-07
1957-11-21 | 3874 | Martin | 1958-02-06 | 1957-11-11
(10 rows)
以下例子返回员工名和工资，以及最高工资和最低工资。
=> SELECT employee_last_name, annual_salary,
NVL(LEAD(annual_salary) OVER (ORDER BY annual_salary),
MIN(annual_salary) OVER()) "Next Highest",
NVL(LAG(annual_salary) OVER (ORDER BY annual_salary),
MAX(annual_salary) OVER()) "Next Lowest"
FROM employee_dimension;
employee_last_name | annual_salary | Next Highest | Next Lowest
--------------------+---------------+--------------+-------------
Nielson | 1200 | 1200 | 995533
Lewis | 1200 | 1200 | 1200
Harris | 1200 | 1202 | 1200
Robinson | 1202 | 1202 | 1200
Garnett | 1202 | 1202 | 1202
Weaver | 1202 | 1202 | 1202
Nielson | 1202 | 1202 | 1202
McNulty | 1202 | 1204 | 1202
Farmer | 1204 | 1204 | 1202
Martin | 1204 | 1204 | 1204
(10 rows)
下一个例子在员工表中每一个助理总监，在当前行总监之后入职的总监的雇用日期。例如，Jackson 被雇佣日期是 2016/12/28，下一个雇佣的总监是 Bauer：
=> SELECT employee_last_name, hire_date,
LEAD(hire_date, 1) OVER (ORDER BY hire_date DESC) as "NextHired"
FROM employee_dimension WHERE job_title = 'Assistant Director';
employee_last_name | hire_date | NextHired
--------------------+------------+------------
Jackson | 2016-12-28 | 2016-12-26
Bauer | 2016-12-26 | 2016-12-11
Miller | 2016-12-11 | 2016-12-07
Fortin | 2016-12-07 | 2016-11-27
Harris | 2016-11-27 | 2016-11-15
Goldberg | 2016-11-15 |
(5 rows)
返回 窗口内某个表达式的最大值。返回值的类型与表达式数据类型相同。
分析函数 MIN() 和 MAX() 可以使用布尔值运行。MAX() 函数可以执行 布尔数据类型 或可隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX() 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN() 函数返回 t (true)。否则，它返回 f。
MAX ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
下面的查询计算员工年薪与马萨诸塞州最高年薪之间的偏差。
=> SELECT employee_state, annual_salary,
MAX(annual_salary)
OVER(PARTITION BY employee_state ORDER BY employee_key) max,
annual_salary- MAX(annual_salary)
OVER(PARTITION BY employee_state ORDER BY employee_key) diff
FROM employee_dimension
WHERE employee_state = 'MA';
employee_state | annual_salary | max | diff
----------------+---------------+--------+---------
MA | 1918 | 995533 | -993615
MA | 2058 | 995533 | -993475
MA | 2586 | 995533 | -992947
MA | 2500 | 995533 | -993033
MA | 1318 | 995533 | -994215
MA | 2072 | 995533 | -993461
MA | 2656 | 995533 | -992877
MA | 2148 | 995533 | -993385
MA | 2366 | 995533 | -993167
MA | 2664 | 995533 | -992869
(10 rows)
以下示例显示了当您将 MIN 和 MAX 分析函数与布尔值一起使用时，它们之间的区别。该示例创建了一个包含两列的表，添加了两行数据，并显示了 MIN 和 MAX 的示例输出。
CREATE TABLE min_max_functions (emp VARCHAR, torf BOOL);
INSERT INTO min_max_functions VALUES ('emp1', 1);
INSERT INTO min_max_functions VALUES ('emp1', 0);
SELECT DISTINCT emp,
min(torf) OVER (PARTITION BY emp) AS worksasbooleanand,
Max(torf) OVER (PARTITION BY emp) AS worksasbooleanor
FROM min_max_functions;
emp | worksasbooleanand | worksasbooleanor
------+-------------------+------------------
emp1 | f | t
(1 row)
对于每一行，返回每个分区内值集的中值。 MEDIAN 用最高的数字优先级确定实参，将剩余实参隐式转换为该数据类型，并返回该数据类型。
MEDIAN 是实参为 0.5 (50%) 的
PERCENTILE_CONT [analytic] 的一个别名。
MEDIAN ( expression ) OVER ( [ window‑partition‑clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回中值或排序后成为中值的内插值。计算中忽略空值。OVER()OVER 子句指定 window-partition-clause，MEDIAN 会根据一个或多个列或表达式对输入行进行分组。如果忽略此子句，则不会进行分组，且 MEDIAN 会将所有输入行作为单分区处理。请参阅 计算中间值
返回 窗口内某个表达式的最小值。返回值的类型与表达式数据类型相同。
分析函数 MIN() 和 MAX() 可以使用布尔值运行。MAX() 函数可以执行 布尔数据类型 或可隐式转换为布尔值的值。如果至少一个输入值为真，则 MAX() 返回 t (true)。否则，它返回 f (false)。在同一场景中，如果所有输入值都为真，则 MIN() 函数返回 t (true)。否则，它返回 f。
MIN ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
下面的示例显示了如何查询以确定员工年薪与马萨诸塞州最低年薪之间的偏差：
=> SELECT employee_state, annual_salary,
MIN(annual_salary)
OVER(PARTITION BY employee_state ORDER BY employee_key) min,
annual_salary- MIN(annual_salary)
OVER(PARTITION BY employee_state ORDER BY employee_key) diff
FROM employee_dimension
WHERE employee_state = 'MA';
employee_state | annual_salary | min | diff
----------------+---------------+------+------
MA | 1918 | 1204 | 714
MA | 2058 | 1204 | 854
MA | 2586 | 1204 | 1382
MA | 2500 | 1204 | 1296
MA | 1318 | 1204 | 114
MA | 2072 | 1204 | 868
MA | 2656 | 1204 | 1452
MA | 2148 | 1204 | 944
MA | 2366 | 1204 | 1162
MA | 2664 | 1204 | 1460
(10 rows)
以下示例显示了当您将 MIN 和 MAX 分析函数与布尔值一起使用时，它们之间的区别。该示例创建了一个包含两列的表，添加了两行数据，并显示了 MIN 和 MAX 的示例输出。
CREATE TABLE min_max_functions (emp VARCHAR, torf BOOL);
INSERT INTO min_max_functions VALUES ('emp1', 1);
INSERT INTO min_max_functions VALUES ('emp1', 0);
SELECT DISTINCT emp,
min(torf) OVER (PARTITION BY emp) AS worksasbooleanand,
Max(torf) OVER (PARTITION BY emp) AS worksasbooleanor
FROM min_max_functions;
emp | worksasbooleanand | worksasbooleanor
------+-------------------+------------------
emp1 | f | t
(1 row)
将有序数据集（分区）等分成
窗口内的
{value} 个子集，其中子集通过参数 constant‑value 编号为 1。例如，如果 constant-value= 4，且分区包含 20 行，则 NTILE 会将分区行分成四个相等的子集（每个子集包含五行）。 NTILE 为行指定一个从 1 到 4 的数字，然后将每一行分配给其中一个子集。为第一个子集中的行分配 1，为第二个子集中的五行分配 2，依此类推。
如果分区行数无法被子集数整除，则任何子集的行数不得比任何其他子集多超过 1，且最小的子集具有多余行数。例如，如果 constant-value = 4，且行数 = 21，则第一个子集有 6 行，第二个子集有 5 行，依此类推。
如果子集数大于行数，则对等同于行数的子集进行填充，剩余的子集留空。
NTILE ( constant‑value ) OVER (
[ window-partition-clause ]
window-order-clause )
OVER()下面的查询将每个月的销售额分配至四个子集之一。
=> SELECT calendar_month_name AS MONTH, SUM(sales_quantity),
NTILE(4) OVER (ORDER BY SUM(sales_quantity)) AS NTILE
FROM store.store_sales_fact JOIN date_dimension
USING(date_key)
GROUP BY calendar_month_name
ORDER BY NTILE;
MONTH | SUM | NTILE
-----------+---------+-------
November | 2040726 | 1
June | 2088528 | 1
February | 2134708 | 1
April | 2181767 | 2
January | 2229220 | 2
October | 2316363 | 2
September | 2323914 | 3
March | 2354409 | 3
August | 2387017 | 3
July | 2417239 | 4
May | 2492182 | 4
December | 2531842 | 4
(12 rows)
在窗口的第 n 行（从第 1 行开始计数）上求值并返回求值结果。如果指定的行不存在，NTH_VALUE 将返回 NULL。
NTH_VALUE ( expression, row‑number [ IGNORE NULLS ] ) OVER (
[ window-frame-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
IGNORE NULLSNULL 值，如果所有值均为 NULL，则返回 NULL。OVER()在以下示例中，对于表 t1 中的每个元组（当前行），窗口框架子句将窗口定义如下：
ORDER BY b ROWS BETWEEN 3 PRECEDING AND CURRENT ROW
对于每个窗口，第 n 个值中的 n 为 a+1。 a 是元组中列 a 的值。
NTH_VALUE 返回表达式 b+1 的结果，其中 b 是第 n 行（即窗口中的 a+1 行）中列 b 的值。
=> SELECT * FROM t1 ORDER BY a;
a | b
---+----
1 | 10
2 | 20
2 | 21
3 | 30
4 | 40
5 | 50
6 | 60
(7 rows)
=> SELECT NTH_VALUE(b+1, a+1) OVER
(ORDER BY b ROWS BETWEEN 3 PRECEDING AND CURRENT ROW) FROM t1;
?column?
----------
22
31
(7 rows)
通过用行的排名（减去 1）除以分区中的行数（也减去 1），计算
窗口内组中给定行的行相对排名。PERCENT_RANK 始终返回 0 到 1 之间的值（包含）。任何集中的第一行具有为 0 的 PERCENT_RANK。返回值为 NUMBER。
( rank - 1 ) / ( [ rows ] - 1 )
在前面的公式中，rank 为组中行的排名位置，rows 为 OVER() 语句定义的分区中行的总数量。
PERCENT_RANK ( ) OVER (
[ window-partition-clause ]
window-order-clause )
OVER()以下示例可得出第一季度每个月不同状态的毛利润百分比排名：
=> SELECT calendar_month_name AS MONTH, store_state,
SUM(gross_profit_dollar_amount),
PERCENT_RANK() OVER (PARTITION BY calendar_month_name
ORDER BY SUM(gross_profit_dollar_amount)) AS PERCENT_RANK
FROM store.store_sales_fact JOIN date_dimension
USING(date_key)
JOIN store.store_dimension
USING (store_key)
WHERE calendar_month_name IN ('January','February','March')
AND store_state IN ('OR','IA','DC','NV','WI')
GROUP BY calendar_month_name, store_state
ORDER BY calendar_month_name, PERCENT_RANK;
MONTH | store_state | SUM | PERCENT_RANK
----------+-------------+--------+--------------
February | IA | 418490 | 0
February | OR | 460588 | 0.25
February | DC | 616553 | 0.5
February | WI | 619204 | 0.75
February | NV | 838039 | 1
January | OR | 446528 | 0
January | IA | 474501 | 0.25
January | DC | 628496 | 0.5
January | WI | 679382 | 0.75
January | NV | 871824 | 1
March | IA | 460282 | 0
March | OR | 481935 | 0.25
March | DC | 716063 | 0.5
March | WI | 771575 | 0.75
March | NV | 970878 | 1
(15 rows)
以下示例计算了不同职位每名员工的工资百分比排名。
=> SELECT job_title, employee_last_name, annual_salary,
PERCENT_RANK()
OVER (PARTITION BY job_title ORDER BY annual_salary DESC) AS percent_rank
FROM employee_dimension
ORDER BY percent_rank, annual_salary;
job_title | employee_last_name | annual_salary | percent_rank
--------------------+--------------------+---------------+---------------------
Cashier | Fortin | 3196 | 0
Delivery Person | Garnett | 3196 | 0
Cashier | Vogel | 3196 | 0
Customer Service | Sanchez | 3198 | 0
Shelf Stocker | Jones | 3198 | 0
Custodian | Li | 3198 | 0
Customer Service | Kramer | 3198 | 0
Greeter | McNulty | 3198 | 0
Greeter | Greenwood | 3198 | 0
Shift Manager | Miller | 99817 | 0
Advertising | Vu | 99853 | 0
Branch Manager | Jackson | 99858 | 0
Marketing | Taylor | 99928 | 0
Assistant Director | King | 99973 | 0
Sales | Kramer | 99973 | 0
Head of PR | Goldberg | 199067 | 0
Regional Manager | Gauthier | 199744 | 0
Director of HR | Moore | 199896 | 0
Head of Marketing | Overstreet | 199955 | 0
VP of Advertising | Meyer | 199975 | 0
VP of Sales | Sanchez | 199992 | 0
Founder | Gauthier | 927335 | 0
CEO | Taylor | 953373 | 0
Investor | Garnett | 963104 | 0
Co-Founder | Vu | 977716 | 0
CFO | Vogel | 983634 | 0
President | Sanchez | 992363 | 0
Delivery Person | Li | 3194 | 0.00114155251141553
Delivery Person | Robinson | 3194 | 0.00114155251141553
Custodian | McCabe | 3192 | 0.00126582278481013
Shelf Stocker | Moore | 3196 | 0.00128040973111396
Branch Manager | Moore | 99716 | 0.00186567164179104
...
一个逆分布函数，在此函数中，对于每行，PERCENTILE_CONT 将返回 窗口内每个分区中的一组值中落入指定百分位的值。例如，如果函数的实参值为 0.5，则函数的结果为数据集的中间值（第 50 个百分位）。PERCENTILE_CONT 假设了连续分布的数据模型。忽略 NULL 值。
PERCENTILE_CONT 通过首先计算百分位存在的行的行数来计算百分位。例如：
row‑number = 1 + percentile‑value * (num‑partition‑rows -1)
如果 row‑number 为完整数（误差范围 0.00001），则百分位为行 row‑number 的值。
否则，Vertica 会在
CEILING(row‑number) 行的值和
FLOOR(row‑number) 行的值之间插入百分位值。换句话说，将按以下方式计算百分位：
( CEILING( row‑number) - row‑number ) * ( value of FLOOR(row‑number) row )
+ ( row‑number - FLOOR(row‑number) ) * ( value of CEILING(row‑number) row)
PERCENTILE_CONT ( percentile ) WITHIN GROUP ( ORDER BY expression [ ASC | DESC ] ) OVER ( [ window-partition-clause ] )
WITHIN GROUP (ORDER BY expression)WITHIN GROUP(ORDER BY) 子句不能保证 SQL 结果的顺序。要对最终结果进行排序，请使用 SQL ORDER BY 子句集。
ASC | DESC只要 percentile 不是 0.5，在 WITHIN GROUP 子句中指定 ASC 或 DESC 会影响到结果。
OVER()该查询会计算威斯康星和哥伦比亚区的前 300 位客户的每组的年收入中间值。
=> SELECT customer_state, customer_key, annual_income, PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY annual_income)
OVER (PARTITION BY customer_state) AS PERCENTILE_CONT
FROM customer_dimension WHERE customer_state IN ('DC','WI') AND customer_key < 300
ORDER BY customer_state, customer_key;
customer_state | customer_key | annual_income | PERCENTILE_CONT
----------------+--------------+---------------+-----------------
DC | 52 | 168312 | 483266.5
DC | 118 | 798221 | 483266.5
WI | 62 | 283043 | 377691
WI | 139 | 472339 | 377691
(4 rows)
该查询会计算威斯康星和哥伦比亚区全部客户的每组的年收入中间值。
=> SELECT customer_state, customer_key, annual_income, PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY annual_income)
OVER (PARTITION BY customer_state) AS PERCENTILE_CONT
FROM customer_dimension WHERE customer_state IN ('DC','WI') ORDER BY customer_state, customer_key;
customer_state | customer_key | annual_income | PERCENTILE_CONT
----------------+--------------+---------------+-----------------
DC | 52 | 168312 | 483266.5
DC | 118 | 798221 | 483266.5
DC | 622 | 220782 | 555088
DC | 951 | 178453 | 555088
DC | 972 | 961582 | 555088
DC | 1286 | 760445 | 555088
DC | 1434 | 44836 | 555088
...
WI | 62 | 283043 | 377691
WI | 139 | 472339 | 377691
WI | 359 | 42242 | 517717
WI | 364 | 867543 | 517717
WI | 403 | 509031 | 517717
WI | 455 | 32000 | 517717
WI | 485 | 373129 | 517717
...
(1353 rows)
一个逆分布函数，在此函数中，对于每行，PERCENTILE_DISC 将返回
窗口内每个分区中的一组值中落入指定百分位的值。 PERCENTILE_DISC() 假设一个离散分布数据模型。 NULL 值将被忽略。
PERCENTILE_DISC 会检查每组中的累计离散值，直到找到大于或等于指定百分位的值。Vertica 会计算每一行的百分位，PERCENTILE_DISC 会输出 WITHIN GROUP(ORDER BY) 列的第一个值，其 CUME_DIST（累计离散）值大于等于实参 FLOAT 值（如 0.4）：
PERCENTILE_DIST(0.4) WITHIN GROUP (ORDER BY salary) OVER(PARTITION BY deptno)...
给定以下查询：
SELECT CUME_DIST() OVER(ORDER BY salary) FROM table-name;
最小的大于 0.4 的 CUME_DIST 值也为 PERCENTILE_DISC。
PERCENTILE_DISC ( percentile ) WITHIN GROUP (
ORDER BY expression [ ASC | DESC ] ) OVER (
[ window-partition-clause ] )
FLOAT 常数。WITHIN GROUP(ORDER BY expression)ORDER BY 仅使用数据类型为 INTEGER、FLOAT、INTERVAL 或 NUMERIC 的列/表达式。 NULL 值将被丢弃。
WITHIN GROUP(ORDER BY) 子句不能保证 SQL 结果的顺序。要对最终结果进行排序，请使用 SQL
ORDER BY 子句集。
ASC | DESCOVER()该查询会计算威斯康星和哥伦比亚区的前 300 位客户的每组的第 20 个百分值年收入。
=> SELECT customer_state, customer_key, annual_income,
PERCENTILE_DISC(.2) WITHIN GROUP(ORDER BY annual_income)
OVER (PARTITION BY customer_state) AS PERCENTILE_DISC
FROM customer_dimension
WHERE customer_state IN ('DC','WI')
AND customer_key < 300
ORDER BY customer_state, customer_key;
customer_state | customer_key | annual_income | PERCENTILE_DISC
----------------+--------------+---------------+-----------------
DC | 104 | 658383 | 417092
DC | 168 | 417092 | 417092
DC | 245 | 670205 | 417092
WI | 106 | 227279 | 227279
WI | 127 | 703889 | 227279
WI | 209 | 458607 | 227279
(6 rows)
在每个窗口分区内，按窗口的 ORDER BY 子句指定的顺序对查询结果集中的所有行进行排名。
RANK 按以下方式执行：
按 ORDER BY 子句指定的顺序对分区行进行排序。
比较前一行与当前行的 ORDER BY 值，并按以下方式对当前行进行排名：
如果 ORDER BY 值相同，则当前行获得的排名与前一行相同。
如果 ORDER BY 值不同，DENSE_RANK 将按 1 递增或递减当前行的排名，再加上在其之前的行中的连续重复值数量。
最大排名值等于查询返回的总行数。
RANK() OVER (
[ window-partition-clause ]
window-order-clause )
OVER()RANK 会在排名序列中留下间隙，而
DENSE_RANK 不会出现这种情况。
以下查询按州对自 2007 年以来成为公司客户的所有客户进行排名。在 customer_since 日期相同的行中，RANK 将为这些行分配相同的排名。当 customer_since 日期发生更改时，RANK 会跳过一个或多个排名 — 例如，在 CA 内从第 12 名到跳到第 14 名，以及从第 17 名跳到第 19 名。
=> SELECT customer_state, customer_name, customer_since,
RANK() OVER (PARTITION BY customer_state ORDER BY customer_since) AS rank
FROM customer_dimension WHERE customer_type='Company' AND customer_since > '01/01/2007'
ORDER BY customer_state;
customer_state | customer_name | customer_since | rank
----------------+---------------+----------------+------
AZ | Foodshop | 2007-01-20 | 1
AZ | Goldstar | 2007-08-11 | 2
CA | Metahope | 2007-01-05 | 1
CA | Foodgen | 2007-02-05 | 2
CA | Infohope | 2007-02-09 | 3
CA | Foodcom | 2007-02-19 | 4
CA | Amerihope | 2007-02-22 | 5
CA | Infostar | 2007-03-05 | 6
CA | Intracare | 2007-03-14 | 7
CA | Infocare | 2007-04-07 | 8
...
CO | Goldtech | 2007-02-19 | 1
CT | Foodmedia | 2007-02-11 | 1
CT | Metatech | 2007-02-20 | 2
CT | Infocorp | 2007-04-10 | 3
...
为 窗口分区中的每一行分配一系列唯一编号，从 1 开始。通常情况下，ROW_NUMBER 和 RANK 可以互换，但有以下区别：
ROW_NUMBER 为有序集中的每一行分配一个唯一的序号，从 1 开始。
ROW_NUMBER() 为 Vertica 扩展，而 RANK 符合 SQL-99 标准。
ROW_NUMBER () OVER (
[ window-partition-clause ]
[ window-order-clause ] )
OVER()以下 ROW_NUMBER 查询按 customer_region 对 VMart 表 customer_dimension 中的客户进行分区。在每个分区中，该函数按其窗口顺序子句指定的资历顺序对这些客户进行排名：
=> SELECT * FROM
(SELECT ROW_NUMBER() OVER (PARTITION BY customer_region ORDER BY customer_since) AS most_senior,
customer_region, customer_name, customer_since FROM public.customer_dimension WHERE customer_type = 'Individual') sq
WHERE most_senior <= 5;
most_senior | customer_region | customer_name | customer_since
-------------+-----------------+----------------------+----------------
1 | West | Jack Y. Perkins | 1965-01-01
2 | West | Linda Q. Winkler | 1965-01-02
3 | West | Marcus K. Li | 1965-01-03
4 | West | Carla R. Jones | 1965-01-07
5 | West | Seth P. Young | 1965-01-09
1 | East | Kim O. Vu | 1965-01-01
2 | East | Alexandra L. Weaver | 1965-01-02
3 | East | Steve L. Webber | 1965-01-04
4 | East | Thom Y. Li | 1965-01-05
5 | East | Martha B. Farmer | 1965-01-07
1 | SouthWest | Martha V. Gauthier | 1965-01-01
2 | SouthWest | Jessica U. Goldberg | 1965-01-07
3 | SouthWest | Robert O. Stein | 1965-01-07
4 | SouthWest | Emily I. McCabe | 1965-01-18
5 | SouthWest | Jack E. Miller | 1965-01-25
1 | NorthWest | Julie O. Greenwood | 1965-01-08
2 | NorthWest | Amy X. McNulty | 1965-01-25
3 | NorthWest | Kevin S. Carcetti | 1965-02-09
4 | NorthWest | Sam K. Carcetti | 1965-03-16
5 | NorthWest | Alexandra X. Winkler | 1965-04-05
1 | MidWest | Michael Y. Meyer | 1965-01-01
2 | MidWest | Joanna W. Bauer | 1965-01-06
3 | MidWest | Amy E. Harris | 1965-01-08
4 | MidWest | Julie W. McCabe | 1965-01-09
5 | MidWest | William . Peterson | 1965-01-09
1 | South | Dean . Martin | 1965-01-01
2 | South | Ruth U. Williams | 1965-01-02
3 | South | Steve Y. Farmer | 1965-01-03
4 | South | Mark V. King | 1965-01-08
5 | South | Lucas Y. Young | 1965-01-10
(30 rows)
计算当前行相对于
窗口内组的统计样本标准偏差。 STDDEV_SAMP 返回值与为
VAR_SAMP 函数定义的方差的平方根相同：
STDDEV( expression ) = SQRT(VAR_SAMP( expression ))
当 VAR_SAMP 返回 NULL 时，此函数将返回 NULL。
STDDEV ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。OVER()以下示例返回雇员维度表中副经理的薪资标准差：
=> SELECT employee_last_name, annual_salary,
STDDEV(annual_salary) OVER (ORDER BY hire_date) as "stddev"
FROM employee_dimension
WHERE job_title = 'Assistant Director';
employee_last_name | annual_salary | stddev
--------------------+---------------+------------------
Bauer | 85003 | NaN
Reyes | 91051 | 4276.58181261624
Overstreet | 53296 | 20278.6923394976
Gauthier | 97216 | 19543.7184537642
Jones | 82320 | 16928.0764028285
Fortin | 56166 | 18400.2738421652
Carcetti | 71135 | 16968.9453554483
Weaver | 74419 | 15729.0709901852
Stein | 85689 | 15040.5909495309
McNulty | 69423 | 14401.1524291943
Webber | 99091 | 15256.3160166536
Meyer | 74774 | 14588.6126417355
Garnett | 82169 | 14008.7223268494
Roy | 76974 | 13466.1270356647
Dobisz | 83486 | 13040.4887828347
Martin | 99702 | 13637.6804131055
Martin | 73589 | 13299.2838158566
...
计算统计总体标准差，并返回
窗口内总体方差的平方根。STDDEV_POP() 返回值与 VAR_POP() 函数的平方根相同：
STDDEV_POP( expression ) = SQRT(VAR_POP( expression ))
VAR_POP 返回 Null 时，STDDEV_POP 返回 Null。
STDDEV_POP ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。OVER()以下示例返回雇员维度表中副经理的薪资总体标准差：
=> SELECT employee_last_name, annual_salary,
STDDEV_POP(annual_salary) OVER (ORDER BY hire_date) as "stddev_pop"
FROM employee_dimension WHERE job_title = 'Assistant Director';
employee_last_name | annual_salary | stddev_pop
--------------------+---------------+------------------
Goldberg | 61859 | 0
Miller | 79582 | 8861.5
Goldberg | 74236 | 7422.74712548456
Campbell | 66426 | 6850.22125098891
Moore | 66630 | 6322.08223926257
Nguyen | 53530 | 8356.55480080699
Harris | 74115 | 8122.72288970008
Lang | 59981 | 8053.54776538731
Farmer | 60597 | 7858.70140687825
Nguyen | 78941 | 8360.63150784682
计算当前行相对于
窗口内组的统计样本标准偏差。STDDEV_SAM的返回值与为 VAR_SAMP 函数定义的方差的平方根相同：
STDDEV( expression ) = SQRT(VAR_SAMP( expression ))
当 VAR_SAMP 返回 NULL 时，STDDEV_SAMP 将返回 NULL。
STDDEV_SAMP ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回与实参数字数据类型相同的数据类型。OVER()以下示例返回 employee 维度表中副经理薪资的样本标准差：
=> SELECT employee_last_name, annual_salary,
STDDEV(annual_salary) OVER (ORDER BY hire_date) as "stddev_samp"
FROM employee_dimension WHERE job_title = 'Assistant Director';
employee_last_name | annual_salary | stddev_samp
--------------------+---------------+------------------
Bauer | 85003 | NaN
Reyes | 91051 | 4276.58181261624
Overstreet | 53296 | 20278.6923394976
Gauthier | 97216 | 19543.7184537642
Jones | 82320 | 16928.0764028285
Fortin | 56166 | 18400.2738421652
Carcetti | 71135 | 16968.9453554483
Weaver | 74419 | 15729.0709901852
Stein | 85689 | 15040.5909495309
McNulty | 69423 | 14401.1524291943
Webber | 99091 | 15256.3160166536
Meyer | 74774 | 14588.6126417355
Garnett | 82169 | 14008.7223268494
Roy | 76974 | 13466.1270356647
Dobisz | 83486 | 13040.4887828347
...
计算
窗口内一组行的表达式总和。它将返回浮点表达式的 DOUBLE PRECISION 值。否则，返回值与表达式数据类型相同。
SUM ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同。OVER()如果在使用 SUM 时遇到数据溢出问题，请使用
SUM_FLOAT 将数据转换为浮点。
默认情况下，当您对数值数据类型调用此函数时，Vertica 允许静默数值溢出。有关此行为以及如何更改它的更多信息，请参阅SUM、SUM_FLOAT 和 AVG 的数字数据类型溢出。
以下查询返回店面 1 月份所有收益的累计和：
=> SELECT calendar_month_name AS month, transaction_type, sales_quantity,
SUM(sales_quantity)
OVER (PARTITION BY calendar_month_name ORDER BY date_dimension.date_key) AS SUM
FROM store.store_sales_fact JOIN date_dimension
USING(date_key) WHERE calendar_month_name IN ('January')
AND transaction_type= 'return';
month | transaction_type | sales_quantity | SUM
---------+------------------+----------------+------
January | return | 7 | 651
January | return | 3 | 651
January | return | 7 | 651
January | return | 7 | 651
January | return | 7 | 651
January | return | 3 | 651
January | return | 7 | 651
January | return | 5 | 651
January | return | 1 | 651
January | return | 6 | 651
January | return | 6 | 651
January | return | 3 | 651
January | return | 9 | 651
January | return | 7 | 651
January | return | 6 | 651
January | return | 8 | 651
January | return | 7 | 651
January | return | 2 | 651
January | return | 4 | 651
January | return | 5 | 651
January | return | 7 | 651
January | return | 8 | 651
January | return | 4 | 651
January | return | 10 | 651
January | return | 6 | 651
...
返回 窗口内组中非 null 数字集（忽略 null 值）的统计总体方差。结果的计算方法为 expression 与 expression 均值之差的平方和除以剩余行数：
(SUM( expression * expression ) - SUM( expression ) * SUM( expression ) / COUNT( expression )) / COUNT( expression )
VAR_POP ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同OVER()下述示例计算 2007 年 1 月商店销售事实表的累计总体方差：
=> SELECT date_ordered,
VAR_POP(SUM(total_order_cost))
OVER (ORDER BY date_ordered) "var_pop"
FROM store.store_orders_fact s
WHERE date_ordered BETWEEN '2007-01-01' AND '2007-01-31'
GROUP BY s.date_ordered;
date_ordered | var_pop
--------------+------------------
2007-01-01 | 0
2007-01-02 | 89870400
2007-01-03 | 3470302472
2007-01-04 | 4466755450.6875
2007-01-05 | 3816904780.80078
2007-01-06 | 25438212385.25
2007-01-07 | 22168747513.1016
2007-01-08 | 23445191012.7344
2007-01-09 | 39292879603.1113
2007-01-10 | 48080574326.9609
(10 rows)
为
窗口内组中的每行返回非 NULL 数字集（将忽略集中的 NULL 值）的样本方差。结果的计算方法如下所示：
(SUM( expression * expression ) - SUM( expression ) * SUM( expression ) / COUNT( expression ) )
/ (COUNT( expression ) - 1 )
此函数与
VARIANCE 在一个方面有所不同：对于某个元素的输入集，VARIANCE 返回 0，而 VAR_SAMP 返回 NULL。
VAR_SAMP ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
NUMERIC 数据类型或可隐式转换为数字数据类型的任何非数字数据类型。函数返回的数据类型与参数的数字数据类型相同OVER()VAR_SAMP 丢弃一组数字中的 NULL 值，然后返回剩余数据的样本方差。
如果将此函数应用于空集，则会返回 NULL。
下述示例计算 2007 年 12 月商店销售订单事实表的样本方差：
=> SELECT date_ordered,
VAR_SAMP(SUM(total_order_cost))
OVER (ORDER BY date_ordered) "var_samp"
FROM store.store_orders_fact s
WHERE date_ordered BETWEEN '2007-12-01' AND '2007-12-31'
GROUP BY s.date_ordered;
date_ordered | var_samp
--------------+------------------
2007-12-01 | NaN
2007-12-02 | 90642601088
2007-12-03 | 48030548449.3359
2007-12-04 | 32740062504.2461
2007-12-05 | 32100319112.6992
2007-12-06 | 26274166814.668
2007-12-07 | 23017490251.9062
2007-12-08 | 21099374085.1406
2007-12-09 | 27462205977.9453
2007-12-10 | 26288687564.1758
(10 rows)
为
窗口内组中的每行返回非 NULL 数字集（将忽略集中的 NULL 值）的样本方差。结果的计算方法如下所示：
( SUM( expression * expression ) - SUM( expression ) * SUM( expression ) / COUNT( expression )) / (COUNT( expression ) - 1 )
VARIANCE 返回 expression 的方差，按以下方式计算：
如果 expression 中行数等于 1，则为 0
VAR_SAMP 如果 expression 中行数大于 1
VAR_SAMP ( expression ) OVER (
[ window-partition-clause ]
[ window-order-clause ]
[ window-frame-clause ] )
OVER()下述示例计算 2007 年 12 月商店销售订单事实表的累计方差：
=> SELECT date_ordered,
VARIANCE(SUM(total_order_cost))
OVER (ORDER BY date_ordered) "variance"
FROM store.store_orders_fact s
WHERE date_ordered BETWEEN '2007-12-01' AND '2007-12-31'
GROUP BY s.date_ordered;
date_ordered | variance
--------------+------------------
2007-12-01 | NaN
2007-12-02 | 2259129762
2007-12-03 | 1809012182.33301
2007-12-04 | 35138165568.25
2007-12-05 | 26644110029.3003
2007-12-06 | 25943125234
2007-12-07 | 23178202223.9048
2007-12-08 | 21940268901.1431
2007-12-09 | 21487676799.6108
2007-12-10 | 21521358853.4331
(10 rows)
此部分包含 Vertica 专用的客户端连接管理函数。
关闭多个活动结果集 (MARS) 中的所有结果集会话，并为其他结果集释放 MARS 存储。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SELECT CLOSE_ALL_RESULTSETS ('session_id')
session_id无；但是，在不具备超级用户权限的情况下，您只能关闭您自己会话的结果。
此示例显示了如何查看 MARS 结果集，然后关闭该结果集，再确认该结果集已被关闭。
查询 MARS 存储表。一个会话 ID 处于打开状态，并在输出中显示三个结果集。
=> SELECT * FROM SESSION_MARS_STORE;
node_name | session_id | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
v_vmart_node0001 | server1.company.-83046:1y28gu9 | dbadmin | 7 | 777460 | 776460 | 89692848
v_vmart_node0001 | server1.company.-83046:1y28gu9 | dbadmin | 8 | 324349 | 323349 | 81862010
v_vmart_node0001 | server1.company.-83046:1y28gu9 | dbadmin | 9 | 277947 | 276947 | 32978280
(1 row)
关闭会话 server1.company.-83046:1y28gu9 的所有结果集：
=> SELECT CLOSE_ALL_RESULTSETS('server1.company.-83046:1y28gu9');
close_all_resultsets
-------------------------------------------------------------
Closing all result sets from server1.company.-83046:1y28gu9
(1 row)
再次查询 MARS 存储表，以了解当前状态。您可以看到，该会话和结果集已被关闭：
=> SELECT * FROM SESSION_MARS_STORE;
node_name | session_id | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
(0 rows)
关闭多个活动结果集 (MARS) 中的某一特定结果集，并释放其他结果集的 MARS 存储。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SELECT CLOSE_RESULTSET ('session_id', ResultSetID)
session_idResultSetID无；但是，在不具备超级用户权限的情况下，您只能关闭您自己会话的结果。
此示例显示了一个处于打开状态的 MARS 存储表。一个 session_id 目前处于打开状态，并在输出中显示一个结果集。
=> SELECT * FROM SESSION_MARS_STORE;
node_name | session_id | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
v_vmart_node0001 | server1.company.-83046:1y28gu9 | dbadmin | 1 | 318718 | 312718 | 80441904
(1 row)
关闭用户会话 server1.company.-83046:1y28gu9 和结果集 1：
=> SELECT CLOSE_RESULTSET('server1.company.-83046:1y28gu9', 1);
close_resultset
-------------------------------------------------------------
Closing result set 1 from server1.company.-83046:1y28gu9
(1 row)
再次查询 MARS 存储表，以了解当前状态。您可以看到，结果集 1 现已关闭：
SELECT * FROM SESSION_MARS_STORE;
node_name | session_id | user_name | resultset_id | row_count | remaining_row_count | bytes_used
------------------+-----------------------------------+-----------+--------------+-----------+---------------------+------------
(0 rows)
评估是否有任何负载均衡路由规则适用于给定的 IP 地址和 描述如何处理客户端连接。当您评估已创建的连接负载均衡策略，以确保它们按您期望的方式工作时，此函数很有用。
您向此函数传递一个客户端连接的 IP 地址，它使用负载均衡路由规则来确定如何处理该连接。此函数使用的逻辑与 Vertica 负载均衡客户端连接时使用的逻辑相同，包括确定哪些节点可用于处理客户端连接。
此函数假定客户端连接已选择负载均衡。如果实际客户端未选择负载均衡，则不会重定向连接。 有关在客户端启用负载均衡的信息，请参阅 ADO.NET 中的负载均衡、JDBC 中的负载均衡和负载均衡。对于 vsql，使用 -C 命令行选项来启用负载均衡。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESCRIBE_LOAD_BALANCE_DECISION('ip_address')
'ip_address'逐步描述如何评估负载均衡规则，包括最终决定选择数据库中的哪个节点来为连接提供服务。
无。
以下示例演示了使用三个不同的 IP 地址调用 DESCRIBE_LOAD_BALANCE_DECISION，其中两个由不同的路由规则处理，一个不由任何规则处理。
=> SELECT describe_load_balance_decision('192.168.1.25');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248] port [5433]
(1 row)
=> SELECT describe_load_balance_decision('192.168.2.25');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [192.168.2.25]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address does not match source ip filter for this rule.
Considered rule [subnet_192] source ip filter [192.0.0.0/8]... input address
matches this rule
Matched to load balance group [group_all] the group has policy [ROUNDROBIN]
number of addresses [3]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
(2) LB Address: [10.20.100.249]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248] port [5433]
(1 row)
=> SELECT describe_load_balance_decision('1.2.3.4');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [1.2.3.4]
Load balance cache internal version id (node-local): [2]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address does not match source ip filter for this rule.
Considered rule [subnet_192] source ip filter [192.0.0.0/8]... input address
does not match source ip filter for this rule.
Routing table decision: No matching routing rules: input address does not match
any routing rule source filters. Details: [Tried some rules but no matching]
No rules matched. Falling back to classic load balancing.
Classic load balance decision: Classic load balancing considered, but either
the policy was NONE or no target was available. Details: [NONE or invalid]
(1 row)
以下示例演示了使用相同 IP 地址重复调用 DESCRIBE_LOAD_BALANCE_DECISION。您可以看到负载均衡组的 ROUNDROBIN 负载均衡策略让它在负载均衡组的两个节点之间切换：
=> SELECT describe_load_balance_decision('192.168.1.25');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248]
port [5433]
(1 row)
=> SELECT describe_load_balance_decision('192.168.1.25');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [0]
Routing table decision: Success. Load balance redirect to: [10.20.100.247]
port [5433]
(1 row)
=> SELECT describe_load_balance_decision('192.168.1.25');
describe_load_balance_decision
--------------------------------------------------------------------------------
Describing load balance decision for address [192.168.1.25]
Load balance cache internal version id (node-local): [1]
Considered rule [etl_rule] source ip filter [10.20.100.0/24]... input address
does not match source ip filter for this rule.
Considered rule [internal_clients] source ip filter [192.168.1.0/24]... input
address matches this rule
Matched to load balance group [group_1] the group has policy [ROUNDROBIN]
number of addresses [2]
(0) LB Address: [10.20.100.247]:5433
(1) LB Address: [10.20.100.248]:5433
Chose address at position [1]
Routing table decision: Success. Load balance redirect to: [10.20.100.248]
port [5433]
(1 row)
返回当前会话的客户端连接标签。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_CLIENT_LABEL()
无
返回当前的客户端连接标记：
=> SELECT GET_CLIENT_LABEL();
GET_CLIENT_LABEL
-----------------------
data_load_application
(1 row)
重置群集中的每个主机所维护的计数器，该计数器用于跟踪当本机连接负载均衡方案设置为 ROUNDROBIN 时将客户端指向的主机。要重置计数器，请在所有群集节点上运行此函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESET_LOAD_BALANCE_POLICY()
超级用户
=> SELECT RESET_LOAD_BALANCE_POLICY();
RESET_LOAD_BALANCE_POLICY
-------------------------------------------------------------------------
Successfully reset stateful client load balance policies: "roundrobin".
(1 row)
将标签分配到当前会话的客户端连接。您可以使用此标签来区分客户端连接。
标签显示在 v_monitor.sessions 表中。但是，这些标签不会在 数据收集器表中更新，因为更改发生在 Vertica 建立连接之后。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_CLIENT_LABEL('label‑name')
无
将标签 data_load_application 分配到当前客户端连接：
=> SELECT SET_CLIENT_LABEL('data_load_application');
SET_CLIENT_LABEL
-------------------------------------------
client_label set to data_load_application
(1 row)
设置本机连接负载均衡如何选择主机来处理客户端连接。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_LOAD_BALANCE_POLICY('policy')
NONE （默认值）：禁用本机连接负载均衡。
ROUNDROBIN：从群集中处于启动状态的主机循环列表中选择下一个主机。例如，在包含三节点的群集中，依次迭代节点 1、节点 2 和节点 3，然后返回到节点 1。群集中的每个主机都在循环链表中维护自己的指向下一个主机的指针，而不存在一个群集范围内的状态。
RANDOM：从群集中所有处于启动的主机中随机选择一个主机。
NONE 的项，客户端也必须通过设置连接属性，以指示其连接要进行负载均衡。
超级用户
以下示例演示了如何通过将负载均衡方案设置为 ROUNDROBIN 来在服务器上启用本机连接负载均衡：
=> SELECT SET_LOAD_BALANCE_POLICY('ROUNDROBIN');
SET_LOAD_BALANCE_POLICY
--------------------------------------------------------------------------------
Successfully changed the client initiator load balancing policy to: roundrobin
(1 row)
Vertica 提供了用于特定数据类型的函数，如此部分所述。
此部分中的函数适用于集合类型（数组和集合）。
某些函数将聚合操作（例如 sum）应用于集合。这些函数名称都以 APPLY 开头。
此部分中的其他函数专门对数组或集合进行操作，如各个参考页所示。数组函数对原生数组值和外部表中的数组值进行操作。
数组是从 0 开始索引的。第一个元素在 0 中的序号位置，第二个是 1，依此类推。索引对集合没有意义。
除非另有说明，否则函数仅适用于一维 (1D) 集合。要使用多维数组，您必须首先取消对一维数组类型的引用。集合只能是一维的。
返回具有数值的 集合（数组或集合） 中所有元素的平均值。
APPLY_AVG(collection)
以下情况返回 NULL：
如果输入集合为 NULL
如果输入集合仅包含 null 值
如果输入集合为空
如果输入集合包含空元素和非空元素组合，则在计算平均值时仅考虑非空值。
=> SELECT apply_avg(ARRAY[1,2.4,5,6]);
apply_avg
-----------
3.6
(1 row)
返回 集合（数组或集合） 中非空元素的总数。要计算包括空值在内的所有元素，请使用 APPLY_COUNT_ELEMENTS (ARRAY_LENGTH)。
APPLY_COUNT(collection)
ARRAY_COUNT 是 APPLY_COUNT 的同义词。
空值不包括在计数中。
此示例中的数组包含 6 个元素，其中一个为空值：
=> SELECT apply_count(ARRAY[1,NULL,3,7,8,5]);
apply_count
-------------
5
(1 row)
返回 集合（数组或集合） 中的元素总数，包括 NULL。要仅计算非空值，请使用 APPLY_COUNT (ARRAY_COUNT)。
APPLY_COUNT_ELEMENTS(collection)
ARRAY_LENGTH 是 APPLY_COUNT_ELEMENTS 的同义词。
此函数计算所有成员，包括空值。
空集合（ARRAY[] 或 SET[]）的长度为 0。包含单个空值（ARRAY[null] 或 SET[null]）的集合的长度为 1。
以下数组有 6 个元素，包括一个空值：
=> SELECT apply_count_elements(ARRAY[1,NULL,3,7,8,5]);
apply_count_elements
---------------------
6
(1 row)
如上例所示，空元素是一个元素。因此，一个只包含一个空元素的数组只有一个元素：
=> SELECT apply_count_elements(ARRAY[null]);
apply_count_elements
---------------------
1
(1 row)
集合不包含重复项。如果您构造一个集合并将其直接传递给此函数，则结果可能与输入的数量不同：
=> SELECT apply_count_elements(SET[1,1,3]);
apply_count_elements
---------------------
2
(1 row)
返回 集合（数组或集合） 中最大的非空元素。该函数类似于 MAX [聚合] 函数；APPLY_MAX 对集合的元素进行操作，MAX 对诸如列选择之类的表达式进行操作。
APPLY_MAX(collection)
此函数忽略空元素。如果所有元素都为空值或集合为空白，则此函数返回空值。
=> SELECT apply_max(ARRAY[1,3.4,15]);
apply_max
-----------
15.0
(1 row)
返回 集合（数组或集合） 中最小的非空元素。该函数类似于 MIN [聚合] 函数；APPLY_MIN 对集合的元素进行操作，而 MIN 对诸如列选择之类的表达式进行操作。
APPLY_MIN(collection)
此函数忽略空元素。如果所有元素都为空值或集合为空白，则此函数返回空值。
=> SELECT apply_min(ARRAY[1,3.4,15]);
apply_min
-----------
1.0
(1 row)
计算数值（INTEGER、FLOAT、NUMERIC 或 INTERVAL）的 集合（数组或集合） 中所有元素的总和。
APPLY_SUM(collection)
以下情况返回 NULL：
如果输入集合为 NULL
如果输入集合仅包含 null 值
如果输入集合为空
=> SELECT apply_sum(ARRAY[12.5,3,4,1]);
apply_sum
-----------
20.5
(1 row)
连接元素类型和维度相同的两个数组。例如，ROW 元素必须具有相同的字段。
如果输入都是有界限的，则结果的界限是输入的界限之和。
如果任何输入均无界限，则结果是无界限的，其二进制大小是输入大小的总和。
ARRAY_CAT(array1,array2)
如果任一输入为 NULL，则函数返回 NULL。
如有必要，类型会被强制转换，如第二个示例所示。
=> SELECT array_cat(ARRAY[1,2], ARRAY[3,4,5]);
array_cat
-----------------------
[1,2,3,4,5]
(1 row)
=> SELECT array_cat(ARRAY[1,2], ARRAY[3,4,5.0]);
array_cat
-----------------------
["1.0","2.0","3.0","4.0","5.0"]
(1 row)
如果在数组中找到指定的元素，则返回 true，否则返回 false。两个实参都必须为非空，但数组可能为空白。
返回输入数组的维度。
ARRAY_DIMS(array)
=> SELECT array_dims(ARRAY[[1,2],[2,3]]);
array_dims
------------
2
(1 row)
返回数组中指定元素的序号位置，如果未找到，则返回 -1。数组可以为空白，但不能为 NULL。此函数在测试元素时使用空安全等同性检查。
ARRAY_FIND(array, val_to_find)
=> SELECT array_find(array[1,2,3],2);
array_find
------------
1
(1 row)
该函数返回指定元素的第一个实例。但是，没有什么可以确保值在数组中是唯一的。
=> SELECT array_find(ARRAY[1,2,7,5,7],7);
array_find
------------
2
(1 row)
如果未找到指定的元素，该函数将返回 -1。
=> SELECT array_find(ARRAY[1,3,5,7],4);
array_find
------------
-1
(1 row)
您可以搜索复杂的元素类型：
=> SELECT ARRAY_FIND(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,2,3]);
ARRAY_FIND
------------
0
(1 row)
=> SELECT ARRAY_FIND(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,null,4]);
ARRAY_FIND
------------
1
(1 row)
第二个示例，比较数组与空元素，找到匹配项，因为 ARRAY_FIND 在评估元素时使用空安全等同性检查。
如前面的示例所示，第一个实参可以是原始类型的字面量多维数组。字面量数组不能包含 ROW 元素，如直接构造语法（字面量）中所述，但表中的数组可以。有关相关示例，请参阅 CONTAINS。
如果在集合中找到指定的元素，则返回 true，否则返回 false。集合可以为空白，但不能为 NULL。此函数在测试元素时使用空安全等同性检查。
CONTAINS(collection, val_to_test)
=> SELECT CONTAINS(SET[1,2,3,4],2);
contains
----------
t
(1 row)
您可以搜索 NULL 作为元素值：
=> SELECT CONTAINS(ARRAY[1,null,2],null);
contains
----------
t
(1 row)
您可以搜索复杂的元素类型：
=> SELECT CONTAINS(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,2,3]);
CONTAINS
----------
t
(1 row)
=> SELECT CONTAINS(ARRAY[ARRAY[1,2,3],ARRAY[1,null,4]], ARRAY[1,null,4]);
CONTAINS
----------
t
(1 row)
第二个示例，比较数组与空元素，返回 true，因为 CONTAINS 在评估元素时使用空安全等同性检查。
如前面的示例所示，第一个实参可以是原始类型的字面量多维数组。字面量数组不能包含 ROW 元素，如直接构造语法（字面量）中所述，但表中的数组可以。在以下示例中，orders 表具有以下定义：
=> CREATE EXTERNAL TABLE orders(
orderid int,
accountid int,
shipments Array[
ROW(
shipid int,
address ROW(
street varchar,
city varchar,
zip int
),
shipdate date
)
]
) AS COPY FROM '...' PARQUET;
以下查询测试特定订单。将 ROW 字面量作为第二个实参传递时，转换任何不明确的字段以确保类型匹配：
=> SELECT CONTAINS(shipments,
ROW(1,ROW('911 San Marcos St'::VARCHAR,
'Austin'::VARCHAR, 73344),
'2020-11-05'::DATE))
FROM orders;
CONTAINS
----------
t
f
f
(3 rows)
使用查询中指定的任何其他列，将集合中的一列或多列（ARRAY 或 SET）扩展为单独的表行，每个元素一行。对于每个分解的集合，结果包括两列，一列用于元素索引，另一列用于该位置的值。如果函数分解单个集合，这些列默认命名为 position 和 value。如果函数分解两个或多个集合，则每个集合的列被命名为
pos_column-name 和
val_column-name。您可以在 SELECT 中使用 AS 子句来更改这些列名。
此函数需要 OVER() 子句。
EXPLODE (column[,...] [USING PARAMETERS param=value])
OVER ( [window-partition-clause] )
explode_count 参数的值一样多的集合列。不是集合的列将不加修改地传递。explode_countexplode_count 的值大于指定的集合列数，则函数返回错误。此函数将集合中的每个元素展开为一行，包括空值。如果要分解的列是 NULL（非空白），则该函数不会为该集合生成任何行。
以下示例说明了将 EXPLODE() 与 OVER(PARTITION BEST) 子句一起使用。
考虑一个订单表，其中包含订单键、客户键、产品键、订单价格和电子邮件地址的列，其中一些包含数组。Vertica 中的基本查询结果如下：
=> SELECT orderkey, custkey, prodkey, orderprices, email_addrs FROM orders LIMIT 5;
orderkey | custkey | prodkey | orderprices | email_addrs
------------+---------+-----------------------------------------------+-----------------------------------+----------------------------------------------------------------------------------------------------------------
113-341987 | 342799 | ["MG-7190 ","VA-4028 ","EH-1247 ","MS-7018 "] | ["60.00","67.00","22.00","14.99"] | ["bob@example,com","robert.jones@example.com"]
111-952000 | 342845 | ["ID-2586 ","IC-9010 ","MH-2401 ","JC-1905 "] | ["22.00","35.00",null,"12.00"] | ["br92@cs.example.edu"]
111-345634 | 342536 | ["RS-0731 ","SJ-2021 "] | ["50.00",null] | [null]
113-965086 | 342176 | ["GW-1808 "] | ["108.00"] | ["joe.smith@example.com"]
111-335121 | 342321 | ["TF-3556 "] | ["50.00"] | ["789123@example-isp.com","alexjohnson@example.com","monica@eng.example.com","sara@johnson.example.name",null]
(5 rows)
此示例按升序扩展指定客户的 orderprices 列。custkey 和 email_addrs 列对每个数组元素重复。
=> SELECT EXPLODE(orderprices, custkey, email_addrs) OVER(PARTITION BEST) AS (position, orderprices, custkey, email_addrs)
FROM orders WHERE custkey='342845' ORDER BY orderprices;
position | orderprices | custkey | email_addrs
----------+-------------+---------+------------------------------
2 | | 342845 | ["br92@cs.example.edu",null]
3 | 12.00 | 342845 | ["br92@cs.example.edu",null]
0 | 22.00 | 342845 | ["br92@cs.example.edu",null]
1 | 35.00 | 342845 | ["br92@cs.example.edu",null]
(4 rows)
展开包含空值的列时，null 值显示为空。
您可以通过指定 explode_count 参数来展开多个列。
=> SELECT EXPLODE(orderkey, prodkey, orderprices USING PARAMETERS explode_count=2)
OVER(PARTITION BEST)
AS (orderkey,pk_idx,pk_val,ord_idx,ord_val)
FROM orders
WHERE orderkey='113-341987';
orderkey | pk_idx | pk_val | ord_idx | ord_val
------------+--------+----------+---------+---------
113-341987 | 0 | MG-7190 | 0 | 60.00
113-341987 | 0 | MG-7190 | 1 | 67.00
113-341987 | 0 | MG-7190 | 2 | 22.00
113-341987 | 0 | MG-7190 | 3 | 14.99
113-341987 | 1 | VA-4028 | 0 | 60.00
113-341987 | 1 | VA-4028 | 1 | 67.00
113-341987 | 1 | VA-4028 | 2 | 22.00
113-341987 | 1 | VA-4028 | 3 | 14.99
113-341987 | 2 | EH-1247 | 0 | 60.00
113-341987 | 2 | EH-1247 | 1 | 67.00
113-341987 | 2 | EH-1247 | 2 | 22.00
113-341987 | 2 | EH-1247 | 3 | 14.99
113-341987 | 3 | MS-7018 | 0 | 60.00
113-341987 | 3 | MS-7018 | 1 | 67.00
113-341987 | 3 | MS-7018 | 2 | 22.00
113-341987 | 3 | MS-7018 | 3 | 14.99
(16 rows)
以下示例使用多维数组：
=> SELECT name, pingtimes FROM network_tests;
name | pingtimes
------+-------------------------------------------------------
eng1 | [[24.24,25.27,27.16,24.97],[23.97,25.01,28.12,29.5]]
eng2 | [[27.12,27.91,28.11,26.95],[29.01,28.99,30.11,31.56]]
qa1 | [[23.15,25.11,24.63,23.91],[22.85,22.86,23.91,31.52]]
(3 rows)
=> SELECT EXPLODE(name, pingtimes USING PARAMETERS explode_count=1) OVER()
FROM network_tests;
name | position | value
------+----------+---------------------------
eng1 | 0 | [24.24,25.27,27.16,24.97]
eng1 | 1 | [23.97,25.01,28.12,29.5]
eng2 | 0 | [27.12,27.91,28.11,26.95]
eng2 | 1 | [29.01,28.99,30.11,31.56]
qa1 | 0 | [23.15,25.11,24.63,23.91]
qa1 | 1 | [22.85,22.86,23.91,31.52]
(6 rows)
接受任何标量类型的一列并返回一个无界数组。结合 GROUP BY，此函数可用于反转 EXPLODE 操作。
IMPLODE (input-column [ USING PARAMETERS param=value[,...] ] )
[ within-group-order-by-clause ]
WITHIN GROUP (ORDER BY { column-expression[ sort-qualifiers ] }[,...])
sort-qualifiers: { ASC | DESC [ NULLS { FIRST | LAST | AUTO } ] }
allow_truncate即使此参数设置为 true，如果任何单个数组元素过大，IMPLODE 也会返回错误。截断从输出数组中移除元素，但不改变单个元素。
max_binary_size考虑使用包含以下内容的表：
=> SELECT * FROM filtered;
position | itemprice | itemkey
----------+-----------+---------
0 | 14.99 | 345
0 | 27.99 | 567
1 | 18.99 | 567
1 | 35.99 | 345
2 | 14.99 | 123
(5 rows)
以下查询调用 IMPLODE 将价格组合为数组（按键分组）：
=> SELECT itemkey AS key, IMPLODE(itemprice) AS prices
FROM filtered GROUP BY itemkey ORDER BY itemkey;
key | prices
-----+-------------------
123 | ["14.99"]
345 | ["35.99","14.99"]
567 | ["27.99","18.99"]
(3 rows)
您可以通过包括 WITHIN GROUP ORDER BY 子句来修改此查询，该子句指定如何对每个组中的数组元素进行排序：
=> SELECT itemkey AS key, IMPLODE(itemprice) WITHIN GROUP (ORDER BY itemprice) AS prices
FROM filtered GROUP BY itemkey ORDER BY itemkey;
key | prices
-----+-------------------
123 | ["14.99"]
345 | ["14.99","35.99"]
567 | ["18.99","27.99"]
(3 rows)
有关更完整的示例，请参阅数组和集（集合）。
返回包含两个输入集的所有元素的 SET。
如果输入都是有界限的，则结果的界限是输入的界限之和。
如果任何输入均无界限，则结果是无界限的，其二进制大小是输入大小的总和。
SET_UNION(set1,set2)
空实参会被忽略。如果输入之一为空，则函数返回非空输入。换言之，NULL 的实参等价于 SET[]。
如果两个输入均为空值，则函数返回 null。
=> SELECT SET_UNION(SET[1,2,4], SET[2,3,4,5.9]);
set_union
-----------------------
["1.0","2.0","3.0","4.0","5.9"]
(1 row)
拆分包含数组值的字符串并返回原生一维数组。输出不包括“ARRAY”关键字。此函数不支持嵌套（多维）数组。
默认情况下，此函数将数组元素作为字符串返回。您可以转换为其他类型，如下例所示：
=> SELECT STRING_TO_ARRAY('[1,2,3]')::ARRAY[INT];
STRING_TO_ARRAY(string [USING PARAMETERS param=value[,...]])
以下语法已弃用：
STRING_TO_ARRAY(string, delimiter)
除非元素被单独引用，否则字符串中的空格将被移除。例如，' a,b,c' 等价于 'a,b,c'。要保留空间，请使用 '" a","b","c"'。
这些参数的行为方式与加载分隔数据时的相应选项相同（请参阅 DELIMITED）。
任何参数不得与任何其他参数具有相同的值。
collection_delimiter默认值： 逗号 (',')。
collection_open, collection_close默认值： 方括号（'[' 和 ']'）。
collection_null_element默认值： 'null'
collection_enclose默认： 双引号（'"'）
该函数使用逗号作为默认分隔符。您可以指定不同的值：
=> SELECT STRING_TO_ARRAY('[1,3,5]');
STRING_TO_ARRAY
-----------------
["1","3","5"]
(1 row)
=> SELECT STRING_TO_ARRAY('[t|t|f|t]' USING PARAMETERS collection_delimiter = '|');
STRING_TO_ARRAY
-------------------
["t","t","f","t"]
(1 row)
边界括号是可选的：
=> SELECT STRING_TO_ARRAY('t|t|f|t' USING PARAMETERS collection_delimiter = '|');
STRING_TO_ARRAY
-------------------
["t","t","f","t"]
(1 row)
输入可以使用其他字符进行打开和关闭：
=> SELECT STRING_TO_ARRAY('{NASA-1683,NASA-7867,SPX-76}' USING PARAMETERS collection_open = '{', collection_close = '}');
STRING_TO_ARRAY
------------------------------------
["NASA-1683","NASA-7867","SPX-76"]
(1 row)
默认情况下，输入中的字符串 'null' 被视为空值：
=> SELECT STRING_TO_ARRAY('{"us-1672",null,"darpa-1963"}' USING PARAMETERS collection_open = '{', collection_close = '}');
STRING_TO_ARRAY
-------------------------------
["us-1672",null,"darpa-1963"]
(1 row)
在以下示例中，输入来自列：
=> SELECT STRING_TO_ARRAY(name USING PARAMETERS collection_delimiter=' ') FROM employees;
STRING_TO_ARRAY
-----------------------
["Howard","Wolowitz"]
["Sheldon","Cooper"]
(2 rows)
返回复杂类型实参的 JSON 表示，包括混合和嵌套的复杂类型。这与复杂类型列的查询返回的格式相同。
TO_JSON(value)
这些示例查询下表：
=> SELECT name, contact FROM customers;
name | contact
--------------------+-----------------------------------------------------------------------------------------------------------------------
Missy Cooper | {"street":"911 San Marcos St","city":"Austin","zipcode":73344,"email":["missy@mit.edu","mcooper@cern.gov"]}
Sheldon Cooper | {"street":"100 Main St Apt 4B","city":"Pasadena","zipcode":91001,"email":["shelly@meemaw.name","cooper@caltech.edu"]}
Leonard Hofstadter | {"street":"100 Main St Apt 4A","city":"Pasadena","zipcode":91001,"email":["hofstadter@caltech.edu"]}
Leslie Winkle | {"street":"23 Fifth Ave Apt 8C","city":"Pasadena","zipcode":91001,"email":[]}
Raj Koothrappali | {"street":null,"city":"Pasadena","zipcode":91001,"email":["raj@available.com"]}
Stuart Bloom |
(6 rows)
您可以在列或特定字段或数组元素上调用 TO_JSON：
=> SELECT TO_JSON(contact) FROM customers;
to_json
-----------------------------------------------------------------------------------------------------------------------
{"street":"911 San Marcos St","city":"Austin","zipcode":73344,"email":["missy@mit.edu","mcooper@cern.gov"]}
{"street":"100 Main St Apt 4B","city":"Pasadena","zipcode":91001,"email":["shelly@meemaw.name","cooper@caltech.edu"]}
{"street":"100 Main St Apt 4A","city":"Pasadena","zipcode":91001,"email":["hofstadter@caltech.edu"]}
{"street":"23 Fifth Ave Apt 8C","city":"Pasadena","zipcode":91001,"email":[]}
{"street":null,"city":"Pasadena","zipcode":91001,"email":["raj@available.com"]}
(6 rows)
=> SELECT TO_JSON(contact.email) FROM customers;
to_json
---------------------------------------------
["missy@mit.edu","mcooper@cern.gov"]
["shelly@meemaw.name","cooper@caltech.edu"]
["hofstadter@caltech.edu"]
[]
["raj@available.com"]
(6 rows)
使用 SET 调用 TO_JSON 时，请注意移除重复项并且可以重新排序元素：
=> SELECT TO_JSON(SET[1683,7867,76,76]);
TO_JSON
----------------
[76,1683,7867]
(1 row)
日期和时间函数进行日期和时间数据类型的转换、提取或处理操作，可以返回日期和时间信息。
TIME 或 TIMESTAMP 输入函数有两种变体：
TIME WITH TIME ZONE 或者 TIMESTAMP WITH TIME ZONE
TIME WITHOUT TIME ZONE 或者 TIMESTAMP WITHOUT TIME ZONE
简洁起见，这些变体不单独显示。
DATE + INTEGER和 INTEGER + DATE。每个交换对仅显示其中一个运算符。将 INTERVAL 值添加到（或从中扣除 INTERVAL 值）TIMESTAMP WITH TIME ZONE 值时，白天组件按指定天数增加（或递减）TIMESTAMP WITH TIME ZONE 的日期。在多次夏令时更改（会话时区设置为识别 DST 的时区）中，这意味着 INTERVAL '1 day' 不一定等于 INTERVAL '24 hours'。
例如，会话时区设置为 CST7CDT 时：
TIMESTAMP WITH TIME ZONE '2014-04-02 12:00-07' + INTERVAL '1 day'
会生成
TIMESTAMP WITH TIME ZONE '2014-04-03 12:00-06'
将 INTERVAL '24 hours' 添加到相同的开头字母 TIMESTAMP WITH TIME ZONE 会生成
TIMESTAMP WITH TIME ZONE '2014-04-03 13:00-06',
出现此结果是因为在时区 2014-04-03 02:00 中 CST7CDT 的夏令时发生了变化。
某些日期/时间函数（例如
CURRENT_TIMESTAMP 和
NOW）会返回当前事务的开始时间；在该事务的时间段内，这些函数会返回相同的值。其他日期/时间函数（例如
TIMEOFDAY）总是返回当前时间。
将指定的月数添加到日期并以 DATE 的形式返回总和。通常，ADD_MONTHS 返回与开始日期具有相同日部分的日期。例如：
=> SELECT ADD_MONTHS ('2015-09-15'::date, -2) "2 Months Ago";
2 Months Ago
--------------
2015-07-15
(1 row)
有两个例外：
如果开始日期的日部分大于结果月份的最后一天，则 ADD_MONTHS 返回结果月份的最后一天。例如：
=> SELECT ADD_MONTHS ('31-Jan-2016'::TIMESTAMP, 1) "Leap Month";
Leap Month
------------
2016-02-29
(1 row)
如果开始日期的日部分是该月的最后一天，并且结果月份的天数比开始日期月份的天数多，则 ADD_MONTHS 返回结果月份的最后一天。例如：
=> SELECT ADD_MONTHS ('2015-09-30'::date,-1) "1 Month Ago";
1 Month Ago
-------------
2015-08-31
(1 row)
ADD_MONTHS ( start‑date, num‑months );
DATE
TIMESTAMP
TIMESTAMPTZ
在当前日期上加一个月：
=> SELECT CURRENT_DATE Today;
Today
------------
2016-05-05
(1 row)
VMart=> SELECT ADD_MONTHS(CURRENT_TIMESTAMP,1);
ADD_MONTHS
------------
2016-06-05
(1 row)
从当前日期减去四个月：
=> SELECT ADD_MONTHS(CURRENT_TIMESTAMP, -4);
ADD_MONTHS
------------
2016-01-05
(1 row)
2016 年 1 月 31 日加一个月：
=> SELECT ADD_MONTHS('31-Jan-2016'::TIMESTAMP, 1) "Leap Month";
Leap Month
------------
2016-02-29
(1 row)
以下示例将时区设置为 EST；然后它将 24 个月添加到指定 PST 时区的 TIMESTAMPTZ，因此 ADD_MONTHS 会考虑时间变化：
=> SET TIME ZONE 'America/New_York';
SET
VMart=> SELECT ADD_MONTHS('2008-02-29 23:30 PST'::TIMESTAMPTZ, 24);
ADD_MONTHS
------------
2010-03-01
(1 row)
返回两个日期之间的月份差，以整数表示。
AGE_IN_MONTHS ( [ date1,] date2 )
DATE
TIMESTAMP
TIMESTAMPTZ
如果 date1 < date2，AGE_IN_MONTHS 将返回负值。
获取 1972 年 3 月 2 日出生的人截至 1990 年 6 月 21 日的月龄：
=> SELECT AGE_IN_MONTHS('1990-06-21'::TIMESTAMP, '1972-03-02'::TIMESTAMP);
AGE_IN_MONTHS
---------------
219
(1 row)
如果第一个日期小于第二个日期，AGE_IN_MONTHS 将返回负值
=> SELECT AGE_IN_MONTHS('1972-03-02'::TIMESTAMP, '1990-06-21'::TIMESTAMP);
AGE_IN_MONTHS
---------------
-220
(1 row)
获取 1939 年 11 月 21 日出生的人截至今天的月龄：
=> SELECT AGE_IN_MONTHS ('1939-11-21'::DATE);
AGE_IN_MONTHS
---------------
930
(1 row)
返回两个日期之间的年份差，以整数表示。
AGE_IN_YEARS( [ date1,] date2 )
DATE
TIMESTAMP
TIMESTAMPTZ
如果 date1 < date2，AGE_IN_YEARS 将返回负值。
获取 1972 年 3 月 2 日出生的人截至 1990 年 6 月 21 日的年龄：
=> SELECT AGE_IN_YEARS('1990-06-21'::TIMESTAMP, '1972-03-02'::TIMESTAMP);
AGE_IN_YEARS
--------------
18
(1 row)
如果第一个日期早于第二个日期，AGE_IN_YEARS 将返回负数：
=> SELECT AGE_IN_YEARS('1972-03-02'::TIMESTAMP, '1990-06-21'::TIMESTAMP);
AGE_IN_YEARS
--------------
-19
(1 row)
获取 1939 年 11 月 21 日出生的人截至今天的年龄：
=> SELECT AGE_IN_YEARS('1939-11-21'::DATE);
AGE_IN_YEARS
--------------
77
(1 row)
返回 TIMESTAMP WITH TIMEZONE 类型的值，该值表示当前系统时钟时间。
CLOCK_TIMESTAMP 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间应相同。每次调用时，值都会更改。
CLOCK_TIMESTAMP()
以下命令返回系统上的当前时间：
SELECT CLOCK_TIMESTAMP() "Current Time";
Current Time
------------------------------
2010-09-23 11:41:23.33772-04
(1 row)
每当调用函数时，都会得到不同的结果。此示例中的差异以微秒为单位：
SELECT CLOCK_TIMESTAMP() "Time 1", CLOCK_TIMESTAMP() "Time 2";
Time 1 | Time 2
-------------------------------+-------------------------------
2010-09-23 11:41:55.369201-04 | 2010-09-23 11:41:55.369202-04
(1 row)
返回当前交易的开始日期（date-type 值）。
CURRENT_DATE()
SELECT CURRENT_DATE;
?column?
------------
2010-09-23
(1 row)
返回 TIME WITH TIMEZONE 类型值，代表当前事务的开始时间。
事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIME 将返回相同的时间戳。
CURRENT_TIME [ ( precision ) ]
=> SELECT CURRENT_TIME(1) AS Time;
Time
---------------
06:51:45.2-07
(1 row)
=> SELECT CURRENT_TIME(5) AS Time;
Time
-------------------
06:51:45.18435-07
(1 row)
返回 TIME WITH TIMEZONE 类型值，代表当前事务的开始时间。
事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIMESTAMP 将返回相同的时间戳。
CURRENT_TIMESTAMP ( precision )
=> SELECT CURRENT_TIMESTAMP(1) AS time;
time
--------------------------
2017-03-27 06:50:49.7-07
(1 row)
=> SELECT CURRENT_TIMESTAMP(5) AS time;
time
------------------------------
2017-03-27 06:50:49.69967-07
(1 row)
从日期/时间表达式中提取子字段（如年或小时），等同于 SQL 标准函数
EXTRACT。
DATE_PART ( 'field', date )
DATE （转换为 TIMESTAMP）
按照 ISO-8601 标准，一周的开始时间是星期一，一年的第一周包含 1 月 4 日。因此，一月初的日期有时可能会位于上一个历年的第 52 周或第 53 周。例如：
=> SELECT YEAR_ISO('01-01-2016'::DATE), WEEK_ISO('01-01-2016'), DAYOFWEEK_ISO('01-01-2016');
YEAR_ISO | WEEK_ISO | DAYOFWEEK_ISO
----------+----------+---------------
2015 | 53 | 5
(1 row)
提取日期值：
SELECT DATE_PART('DAY', TIMESTAMP '2009-02-24 20:38:40') "Day";
Day
-----
24
(1 row)
提取月份值：
SELECT DATE_PART('MONTH', '2009-02-24 20:38:40'::TIMESTAMP) "Month";
Month
-------
2
(1 row)
提取年份值：
SELECT DATE_PART('YEAR', '2009-02-24 20:38:40'::TIMESTAMP) "Year";
Year
------
2009
(1 row)
提取小时：
SELECT DATE_PART('HOUR', '2009-02-24 20:38:40'::TIMESTAMP) "Hour";
Hour
------
20
(1 row)
提取分钟：
SELECT DATE_PART('MINUTES', '2009-02-24 20:38:40'::TIMESTAMP) "Minutes";
Minutes
---------
38
(1 row)
提取季度日期 (DOQ)：
SELECT DATE_PART('DOQ', '2009-02-24 20:38:40'::TIMESTAMP) "DOQ";
DOQ
-----
55
(1 row)
将输入值转换为
DATE 数据类型。
DATE ( value )
TIMESTAMP、TIMESTAMPTZ、VARCHAR 或另一个 DATE。
整数：Vertica 将整数视为自 01/01/0001 以来的天数并返回日期。
=> SELECT DATE (1);
DATE
------------
0001-01-01
(1 row)
=> SELECT DATE (734260);
DATE
------------
2011-05-03
(1 row)
=> SELECT DATE('TODAY');
DATE
------------
2016-12-07
(1 row)
将日期和时间值截断为指定的精度。返回值与输入值的数据类型相同。所有小于指定精度的字段均设置为 0，或设置为 1 表示日和月。
DATE_TRUNC( precision, trunc‑target )
MILLENNIUMCENTURY一世纪始于 0001-01-01 00:00:00 AD。此定义适用于所有采用公历的国家/地区。
DECADEYEAR0 AD，因此将 AD 年份相应地从 BC 年份中减去。QUARTERMONTHtimestamp 值，为年份第几月 (1–12)；对于 interval 值，为月份数，模数 12 (0-11)。WEEK按照 ISO-8601 标准，一周的开始时间是星期一，一年的第一周包含 1 月 4 日。因此，一月初的日期有时可能会位于上一个历年的第 52 周或第 53 周。例如：
=> SELECT YEAR_ISO('01-01-2016'::DATE), WEEK_ISO('01-01-2016'), DAYOFWEEK_ISO('01-01-2016');
YEAR_ISO | WEEK_ISO | DAYOFWEEK_ISO
----------+----------+---------------
2015 | 53 | 5
(1 row)
DAYHOURMINUTESECONDMILLISECONDSMICROSECONDS以下示例将字段值设置为小时并返回小时，截断分钟和秒：
=> SELECT DATE_TRUNC('HOUR', TIMESTAMP '2012-02-24 13:38:40') AS HOUR;
HOUR
---------------------
2012-02-24 13:00:00
(1 row)
以下示例从输入 timestamptz '2012-02-24 13:38:40' 返回年份。函数还将月份和日期默认为 1 月 1 日，截断时间戳的时：分：秒，并附加时区（-05）：
=> SELECT DATE_TRUNC('YEAR', TIMESTAMPTZ '2012-02-24 13:38:40') AS YEAR;
YEAR
------------------------
2012-01-01 00:00:00-05
(1 row)
以下示例返回年份和月份，将默认月份日期设置为 1，截断字符串的其余部分：
=> SELECT DATE_TRUNC('MONTH', TIMESTAMP '2012-02-24 13:38:40') AS MONTH;
MONTH
---------------------
2012-02-01 00:00:00
(1 row)
以指定的间隔返回两个日期之间的时间跨度。 DATEDIFF 在其计算中不包括开始日期。
DATEDIFF ( datepart, start, end );
DATEDIFF 返回的日期或时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：
DATEDIFF((expression), start, end;
datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：
year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us
start, end如果 end < start，则 DATEDIFF 返回负值。
year、quarter 或 month，则 TIME 和 INTERVAL 数据类型对开始日期和结束日期无效。
下表显示了可匹配为开始日期和结束日期的数据类型：
例如，如果将开始日期设置为 INTERVAL 数据类型，则结束日期也必须为 INTERVAL，否则 Vertica 将返回错误：
SELECT DATEDIFF(day, INTERVAL '26 days', INTERVAL '1 month ');
datediff
----------
4
(1 row)
DATEDIFF 使用 datepart 实参计算两个日期之间的间隔数，而不是二者之间的实际时间量。 DATEDIFF 使用以下截止点计算这些间隔：
year：1 年 1 月
quarter：1 月 1 日、4 月 1 日、7 月 1 日、10 月 1 日
month：当月的第一天
week：周日午夜 (24:00)
例如，如果 datepart 设置为 year，则 DATEDIFF 使用 1 月 1 日计算两个日期之间的年数。以下 DATEDIFF 语句将 datepart 设置为 year，并将时间跨度指定为 2005 年 1 月 1 日到 2008 年 6 月 15 日：
SELECT DATEDIFF(year, '01-01-2005'::date, '12-31-2008'::date);
datediff
----------
3
(1 row)
DATEDIFF 在计算间隔时始终排除开始日期 — 在本例中为 2005 年 1 月 1。 DATEDIFF 计算过程中只考虑开始日历年，因此本例中只计算 2006、2007 和 2008 年。函数返回 3，尽管实际时间跨度接近四年。
如果将开始日期和结束日期分别更改为 2004 年 12 月 31 日和 2009 年 1 月 1 日，则 DATEDIFF 还会计算 2005 年和 2009 年。这一次，返回 5，尽管实际时间跨度刚刚超过四年：
=> SELECT DATEDIFF(year, '12-31-2004'::date, '01-01-2009'::date);
datediff
----------
5
(1 row)
同样，DATEDIFF 在计算两个日期之间的月数时使用月份开始日期。因此，在以下语句中，DATEDIFF 计算 2 月到 9 月之间的月份并返回 8：
=> SELECT DATEDIFF(month, '01-31-2005'::date, '09-30-2005'::date);
datediff
----------
8
(1 row)
以整数形式从输入值中返回日期。
DAY ( value )
TIMESTAMP、TIMESTAMPTZ、INTERVAL、VARCHAR 或 INTEGER。=> SELECT DAY (6);
DAY
-----
6
(1 row)
=> SELECT DAY(TIMESTAMP 'sep 22, 2011 12:34');
DAY
-----
22
(1 row)
=> SELECT DAY('sep 22, 2011 12:34');
DAY
-----
22
(1 row)
=> SELECT DAY(INTERVAL '35 12:34');
DAY
-----
35
(1 row)
以整数形式返回月份第几日。
DAYOFMONTH ( date )
处理日期，具有以下一种数据类型：
=> SELECT DAYOFMONTH (TIMESTAMP 'sep 22, 2011 12:34');
DAYOFMONTH
------------
22
(1 row)
以整数形式返回星期几，其中星期日是第 1 天。
DAYOFWEEK ( date )
处理日期，具有以下一种数据类型：
=> SELECT DAYOFWEEK (TIMESTAMP 'sep 17, 2011 12:34');
DAYOFWEEK
-----------
7
(1 row)
以整数形式返回 ISO 8061 星期几，其中星期一是第 1 天。
DAYOFWEEK_ISO ( date )
处理日期，具有以下一种数据类型：
=> SELECT DAYOFWEEK_ISO(TIMESTAMP 'Sep 22, 2011 12:34');
DAYOFWEEK_ISO
---------------
4
(1 row)
以下示例显示了如何组合 DAYOFWEEK_ISO、WEEK_ISO 和 YEAR_ISO 函数以查找 ISO 星期几、星期和年：
=> SELECT DAYOFWEEK_ISO('Jan 1, 2000'), WEEK_ISO('Jan 1, 2000'),YEAR_ISO('Jan1,2000');
DAYOFWEEK_ISO | WEEK_ISO | YEAR_ISO
---------------+----------+----------
6 | 52 | 1999
(1 row)
以整数形式返回年份第几日，其中 1 月 1 日是第 1 天。
DAYOFYEAR ( date )
处理日期，具有以下一种数据类型：
=> SELECT DAYOFYEAR (TIMESTAMP 'SEPT 22,2011 12:34');
DAYOFYEAR
-----------
265
(1 row)
返回指定日期的整数值，其中 1 AD 为 1。如果日期早于 1 AD，则 DAYS 返回负整数。
DAYS ( date )
处理日期，具有以下一种数据类型：
=> SELECT DAYS (DATE '2011-01-22');
DAYS
--------
734159
(1 row)
=> SELECT DAYS (DATE 'March 15, 0044 BC');
DAYS
--------
-15997
(1 row)
返回子字段，例如日期/时间值中的年份或小时，然后返回类型为
NUMERIC 的值。 EXTRACT 旨在用于计算处理，而不是用于格式化日期/时间值以进行显示。
EXTRACT ( field FROM date )
DATE （转换为 TIMESTAMP）
从当前 TIMESTAMP 中提取季度中的星期几和日期：
=> SELECT CURRENT_TIMESTAMP AS NOW;
NOW
-------------------------------
2016-05-03 11:36:08.829004-04
(1 row)
=> SELECT EXTRACT (DAY FROM CURRENT_TIMESTAMP);
date_part
-----------
3
(1 row)
=> SELECT EXTRACT (DOQ FROM CURRENT_TIMESTAMP);
date_part
-----------
33
(1 row)
从当前时间中提取时区小时：
=> SELECT CURRENT_TIMESTAMP;
?column?
-------------------------------
2016-05-03 11:36:08.829004-04
(1 row)
=> SELECT EXTRACT(TIMEZONE_HOUR FROM CURRENT_TIMESTAMP);
date_part
-----------
-4
(1 row)
提取从 01-01-1970 00:00 至今的秒数：
=> SELECT EXTRACT(EPOCH FROM '2001-02-16 20:38:40-08'::TIMESTAMPTZ);
date_part
------------------
982384720.000000
(1 row)
提取 01-01-1970 00:00 和在此之前 5 天 3 小时之间的秒数：
=> SELECT EXTRACT(EPOCH FROM -'5 days 3 hours'::INTERVAL);
date_part
----------------
-442800.000000
(1 row)
将上个示例中的结果转换为 TIMESTAMP：
=> SELECT 'EPOCH'::TIMESTAMPTZ -442800 * '1 second'::INTERVAL;
?column?
------------------------
1969-12-26 16:00:00-05
(1 row)
以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。此函数与
SYSDATE 相同。
GETDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETDATE 将
STATEMENT_TIMESTAMP 从 TIMESTAMPTZ 转换为 TIMESTAMP。
GETDATE()
=> SELECT GETDATE();
GETDATE
----------------------------
2011-03-07 13:21:29.497742
(1 row)
以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。
GETUTCDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETUTCDATE 于 TIME ZONE 'UTC' 转换
STATEMENT_TIMESTAMP。
GETUTCDATE()
=> SELECT GETUTCDATE();
GETUTCDATE
----------------------------
2011-03-07 20:20:26.193052
(1 row)
以整数形式返回指定日期的小时部分，其中 0 指 00:00 到 00:59。
HOUR( date )
处理日期，具有以下一种数据类型：
=> SELECT HOUR (TIMESTAMP 'sep 22, 2011 12:34');
HOUR
------
12
(1 row)
=> SELECT HOUR (INTERVAL '35 12:34');
HOUR
------
12
(1 row)
=> SELECT HOUR ('12:34');
HOUR
------
12
(1 row)
测试特殊 TIMESTAMP 常量 INFINITY 并返回 BOOLEAN 类型的值。
ISFINITE ( timestamp )
SELECT ISFINITE(TIMESTAMP '2009-02-16 21:28:30');
ISFINITE
----------
t
(1 row)
SELECT ISFINITE(TIMESTAMP 'INFINITY');
ISFINITE
----------
f
(1 row)
根据儒略历返回指定日期的整数值，其中 1 代表儒略时期的第一天，即公元前 4713 年 1 月 1 日（对于公历，则为公元前 4714 年 11 月 24 日）。
JULIAN_DAY ( date )
处理日期，具有以下一种数据类型：
=> SELECT JULIAN_DAY (DATE 'MARCH 15, 0044 BC');
JULIAN_DAY
------------
1705428
(1 row)
=> SELECT JULIAN_DAY (DATE '2001-01-01');
JULIAN_DAY
------------
2451911
(1 row)
返回指定日期内月份的最后一天。
LAST_DAY ( date )
SQL 不支持任何函数返回给定日期当月第一天。必须使用其他函数解决此限制。例如：
=> SELECT DATE ('2022/07/04') - DAYOFMONTH ('2022/07/04') +1;
?column?
------------
2022-07-01
(1 row)
=> SELECT LAST_DAY('1929/06/06') - (SELECT DAY(LAST_DAY('1929/06/06'))-1);
?column?
------------
1929-06-01
(1 row)
以下示例将 2 月的最后一天返回为 29，因为 2016 年是闰年：
=> SELECT LAST_DAY('2016-02-28 23:30 PST') "Last Day";
Last Day
------------
2016-02-29
(1 row)
以下示例返回非闰年 2 月的最后一天：
> SELECT LAST_DAY('2017/02/03') "Last";
Last
------------
2017-02-28
(1 row)
以下示例将字符串值转换为指定的 DATE 类型后返回 3 月的最后一天：
=> SELECT LAST_DAY('2003/03/15') "Last";
Last
------------
2012-03-31
(1 row)
返回 TIME 类型值，代表当前事务的开始时间。
事务处理过程中返回值保持不变。因此，在同一事务中多次调用 LOCALTIME 将返回相同的时间戳。
LOCALTIME [ ( precision ) ]
=> CREATE TABLE t1 (a int, b int);
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2);
OUTPUT
--------
1
(1 row)
=> SELECT LOCALTIME time;
time
-----------------
15:03:14.595296
(1 row)
=> INSERT INTO t1 VALUES (3,4);
OUTPUT
--------
1
(1 row)
=> SELECT LOCALTIME;
time
-----------------
15:03:14.595296
(1 row)
=> COMMIT;
COMMIT
=> SELECT LOCALTIME;
time
-----------------
15:03:49.738032
(1 row)
返回 TIMESTAMP/TIMESTAMPTZ 类型值，代表当前事务的开始时间，并在事务关闭之前保持不变。因此，在给定事务中多次调用 LOCALTIMESTAMP 将返回相同的时间戳。
LOCALTIMESTAMP [ ( precision ) ]
=> CREATE TABLE t1 (a int, b int);
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2);
OUTPUT
--------
1
(1 row)
=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
local timestamp
------------------------
2021-03-05 10:48:58.26
(1 row)
=> INSERT INTO t1 VALUES (3,4);
OUTPUT
--------
1
(1 row)
=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
local timestamp
------------------------
2021-03-05 10:48:58.26
(1 row)
=> COMMIT;
COMMIT
=> SELECT LOCALTIMESTAMP(2) AS 'local timestamp';
local timestamp
------------------------
2021-03-05 10:50:08.99
(1 row)
以整数形式返回指定日期的微秒部分。
MICROSECOND ( date )
=> SELECT MICROSECOND (TIMESTAMP 'Sep 22, 2011 12:34:01.123456');
MICROSECOND
-------------
123456
(1 row)
在指定日期内，返回午夜与日期时间部分之间的秒数。
MIDNIGHT_SECONDS ( date )
处理日期，具有以下一种数据类型：
获取自午夜以来的秒数：
=> SELECT MIDNIGHT_SECONDS(CURRENT_TIMESTAMP);
MIDNIGHT_SECONDS
------------------
36480
(1 row)
获取 2016 年 3 月 3 日午夜和正午之间的秒数：
=> SELECT MIDNIGHT_SECONDS('3-3-2016 12:00'::TIMESTAMP);
MIDNIGHT_SECONDS
------------------
43200
(1 row)
以整数形式返回指定日期的分钟部分。
MINUTE ( date )
处理日期，具有以下一种数据类型：
=> SELECT MINUTE('12:34:03.456789');
MINUTE
--------
34
(1 row)
=>SELECT MINUTE (TIMESTAMP 'sep 22, 2011 12:34');
MINUTE
--------
34
(1 row)
=> SELECT MINUTE(INTERVAL '35 12:34:03.456789');
MINUTE
--------
34
(1 row)
以整数形式返回指定日期的月份部分。
MONTH ( date )
处理日期，具有以下一种数据类型：
在下例中，Vertica 返回指定字符串的月份部分。例如，'6-9' 表示 9 月 6 日。
=> SELECT MONTH('6-9');
MONTH
-------
9
(1 row)
=> SELECT MONTH (TIMESTAMP 'sep 22, 2011 12:34');
MONTH
-------
9
(1 row)
=> SELECT MONTH(INTERVAL '2-35' year to month);
MONTH
-------
11
(1 row)
返回两个日期之间的月份数。 MONTHS_BETWEEN 可返回整数或 FLOAT：
整数：date1 和 date2 的日期部分相同，且两个日期都不是本月的最后一天。 MONTHS_BETWEEN 如果 date1 和 date2 中的两个日期都是各自月份的最后一个，也返回整数。例如，MONTHS_BETWEEN 将 4 月 30 日到 3 月 31 日之间的差异计算为 1 个月。
FLOAT：date1 和 date2 的日期部分不同，且其中一个或两个日期并非各自月份的最后一天。例如，4 月 2 日和 3 月 1 日之间的差异为 1.03225806451613。为计算月份部分，MONTHS_BETWEEN 假设所有月份都包含 31 天。
MONTHS_BETWEEN 忽略时间戳时间部分。
MONTHS_BETWEEN ( date1 , date2 );
DATE
TIMESTAMP
TIMESTAMPTZ
如果 date1 < date2，则 MONTHS_BETWEEN 返回负值。
返回 2016 年 4 月 7 日到 2015 年 1 月 7 日之间的月份数：
=> SELECT MONTHS_BETWEEN ('04-07-16'::TIMESTAMP, '01-07-15'::TIMESTAMP);
MONTHS_BETWEEN
----------------
15
(1 row)
返回 2016 年 3 月 31 日到 2016 年 2 月 28 日之间的月份数（MONTHS_BETWEEN 假设两个月都包含 31 天）：
=> SELECT MONTHS_BETWEEN ('03-31-16'::TIMESTAMP, '02-28-16'::TIMESTAMP);
MONTHS_BETWEEN
------------------
1.09677419354839
(1 row)
返回 2016 年 3 月 31 日到 2016 年 2 月 29 日之间的月份数：
=> SELECT MONTHS_BETWEEN ('03-31-16'::TIMESTAMP, '02-29-16'::TIMESTAMP);
MONTHS_BETWEEN
----------------
1
(1 row)
将时间戳值从一个时区转换为另一个时区并返回一个 TIMESTAMP。
NEW_TIME( 'timestamp' , 'timezone1' , 'timezone2')
DATE
可转换为 TIMESTAMP 的字符串，例如 May 24, 2012 10:00。
/opt/vertica/share/timezonesets 中定义的字符串之一。例如：
GMT： 格林威治标准时间
AST / ADT： 大西洋标准/夏令时
EST / EDT： 东部标准/夏令时
CST / CDT： 中部标准/夏令时
MST / MDT： 山区标准/夏令时
PST / PDT： 太平洋标准/夏令时
将指定的时间从东部标准时间 (EST) 转换为太平洋标准时间 (PST)：
=> SELECT NEW_TIME('05-24-12 13:48:00', 'EST', 'PST');
NEW_TIME
---------------------
2012-05-24 10:48:00
(1 row)
将 2012 年 1 月凌晨 1:00 从 EST 转换为 PST：
=> SELECT NEW_TIME('01-01-12 01:00:00', 'EST', 'PST');
NEW_TIME
---------------------
2011-12-31 22:00:00
(1 row)
将 EST 当前时间转换为 PST：
=> SELECT NOW();
NOW
-------------------------------
2016-12-09 10:30:36.727307-05
(1 row)
=> SELECT NEW_TIME('NOW', 'EDT', 'CDT');
NEW_TIME
----------------------------
2016-12-09 09:30:36.727307
(1 row)
以下示例以格林威治标准时间返回“公元前 45 年”，并将其转换为纽芬兰标准时间：
=> SELECT NEW_TIME('April 1, 45 BC', 'GMT', 'NST')::DATE;
NEW_TIME
---------------
0045-03-31 BC
(1 row)
返回指定日期之后一周中特定一天的第一个实例的日期。
NEXT_DAY( 'date', 'day‑string')
处理日期，具有以下一种数据类型：
获取 2016 年 4 月 29 日之后的第一个星期一的日期：
=> SELECT NEXT_DAY('4-29-2016'::TIMESTAMP,'Monday') "NEXT DAY" ;
NEXT DAY
------------
2016-05-02
(1 row)
获取今天之后的第一个星期二：
SELECT NEXT_DAY(CURRENT_TIMESTAMP,'tues') "NEXT DAY" ;
NEXT DAY
------------
2016-05-03
(1 row)
返回一个 TIMESTAMP WITH TIME ZONE 类型的值，它表示当前事务的开始时间。NOW 等于
CURRENT_TIMESTAMP，除非不接受精度参数。
事务处理过程中返回值保持不变。因此，在同一事务中多次调用 CURRENT_TIMESTAMP 将返回相同的时间戳。
NOW()
=> CREATE TABLE t1 (a int, b int);
CREATE TABLE
=> INSERT INTO t1 VALUES (1,2);
OUTPUT
--------
1
(1 row)
=> SELECT NOW();
NOW
------------------------------
2016-12-09 13:00:08.74685-05
(1 row)
=> INSERT INTO t1 VALUES (3,4);
OUTPUT
--------
1
(1 row)
=> SELECT NOW();
NOW
------------------------------
2016-12-09 13:00:08.74685-05
(1 row)
=> COMMIT;
COMMIT
dbadmin=> SELECT NOW();
NOW
-------------------------------
2016-12-09 13:01:31.420624-05
(1 row)
计算两个时间段，并在其重叠时返回 true，否则返回 false。
( start, end ) OVERLAPS ( start, end )
( start, interval) OVERLAPS ( start, interval )
DATE、TIME 或 TIMESTAMP/TIMESTAMPTZ 值，用于指定时间段的开始日期。DATE、TIME 或 TIMESTAMP/TIMESTAMPTZ 值，用于指定时间段的结束日期。求值日期范围 2016 年 2 月 16 日 - 12 月 21 日与 2008 年 10 月 10 日 - 2016 年 10 月 3 日是否重叠：
=> SELECT (DATE '2016-02-16', DATE '2016-12-21') OVERLAPS (DATE '2008-10-30', DATE '2016-10-30');
overlaps
----------
t
(1 row)
求值日期范围 2016 年 2 月 16 日 - 12 月 21 日与 2008 年 1 月 1 日 - 10 月 30 日 - 2016 年 10 月 3 日是否重叠：
=> SELECT (DATE '2016-02-16', DATE '2016-12-21') OVERLAPS (DATE '2008-01-30', DATE '2008-10-30');
overlaps
----------
f
(1 row)
求值日期范围 2016 年 2 月 2 日 + 1 周与 2016 年 10 月 16 日 - 8 个月的日期范围是否重叠：
=> SELECT (DATE '2016-02-16', INTERVAL '1 week') OVERLAPS (DATE '2016-10-16', INTERVAL '-8 months');
overlaps
----------
t
(1 row)
以整数形式返回指定日期的日历季度，其中一月至三月的季度为 1。
QUARTER ( date )
处理日期，具有以下一种数据类型：
=> SELECT QUARTER (TIMESTAMP 'sep 22, 2011 12:34');
QUARTER
---------
3
(1 row)
舍入指定的日期或时间。如果省略精度实参，ROUND 将舍入到天 (DD) 精度。
ROUND( rounding‑target[, 'precision'] )
世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS
DATE 表达式不支持时、分和秒舍入。
五入到最近的小时：
=> SELECT ROUND(CURRENT_TIMESTAMP, 'HH');
ROUND
---------------------
2016-04-28 15:00:00
(1 row)
五入到最近的月份：
=> SELECT ROUND('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
ROUND
---------------------
2011-10-01 00:00:00
(1 row)
以整数形式返回指定日期的秒部分。
SECOND ( date )
不可变，TIMESTAMPTZ 实参除外，TIMESTAMPTZ 实参为 稳定。
=> SELECT SECOND ('23:34:03.456789');
SECOND
--------
3
(1 row)
=> SELECT SECOND (TIMESTAMP 'sep 22, 2011 12:34');
SECOND
--------
0
(1 row)
=> SELECT SECOND (INTERVAL '35 12:34:03.456789');
SECOND
--------
3
(1 row)
类似于
TRANSACTION_TIMESTAMP，返回 TIMESTAMP WITH TIME ZONE 类型值，代表当前语句的开始时间。
语句执行过程中返回值保持不变。因此，语句执行的不同阶段始终具有相同的时间戳。
STATEMENT_TIMESTAMP()
=> SELECT foo, bar FROM (SELECT STATEMENT_TIMESTAMP() AS foo)foo, (SELECT STATEMENT_TIMESTAMP() as bar)bar;
foo | bar
-------------------------------+-------------------------------
2016-12-07 14:55:51.543988-05 | 2016-12-07 14:55:51.543988-05
(1 row)
以 TIMESTAMP 值的形式返回当前语句的开始日期和时间。此函数与
GETDATE 相同。
SYSDATE 使用所连接服务器的操作系统提供的日期和时间，所有服务器的日期和时间相同。在内部，GETDATE 将
STATEMENT_TIMESTAMP 从 TIMESTAMPTZ 转换为 TIMESTAMP。
SYSDATE()
=> SELECT SYSDATE;
sysdate
----------------------------
2016-12-12 06:11:10.699642
(1 row)
按照不同的固定时间间隔聚合数据，并将向上舍入的输入 TIMESTAMP 值返回到与时间片间隔开始或结束时间相对应的值。
提供输入 TIMESTAMP 值，例如 2000-10-28 00:00:01，3 秒时间片间隔的开始时间为 2000-10-28 00:00:00，同一时间片结束时间为 2000-10-28 00:00:03。
TIME_SLICE( expression, slice-length [, 'time‑unit' [, 'start‑or‑end' ] ] )
列类型 TIMESTAMP
可解析为 TIMESTAMP 值的字符串常量。例如：
'2004/10/19 10:23:54'
Vertica 对每一行的表达式求值。
HOUR
MINUTE
SECOND （默认值）
MILLISECOND
MICROSECOND
START （默认值）
END
TIME_SLICE 按如下所示处理 null 实参：
TIME_SLICE 在任何一个 slice-length、time-unit 或 start-or-end 参数为 null 时返回错误。
如果表达式为 null 且 slice-length、time‑unit 或 start‑or‑end 包含合法值，则 TIME_SLICE 返回 NULL 值而不是错误。
以下命令返回（默认） 3 秒时间片的开始时间：
=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3);
TIME_SLICE
---------------------
2009-09-19 00:00:00
(1 row)
以下命令返回 3 秒时间片的结束时间：
=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'SECOND', 'END');
TIME_SLICE
---------------------
2009-09-19 00:00:03
(1 row)
此命令返回使用 3 秒时间片的结果（毫秒）：
=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'ms');
TIME_SLICE
-------------------------
2009-09-19 00:00:00.999
(1 row)
此命令返回使用 9 秒时间片的结果（毫秒）：
=> SELECT TIME_SLICE('2009-09-19 00:00:01', 3, 'us');
TIME_SLICE
----------------------------
2009-09-19 00:00:00.999999
(1 row)
下一个示例使用 3 秒间隔，输入值为 '00:00:01'。为了特别突出秒数，该示例忽略日期，但所有值均隐含为时间戳的一部分，规定输入为 '00:00:01'：
'00:00:00 ' 是 3 秒时间片的开始时间
'00:00:03 ' 是 3 秒时间片的结束时间。
'00:00:03' 也是 3 秒时间片的 second 开始时间。在时间片界限中，时间片的结束值不属于该时间片，它是下一个时间片的开始值。
时间片间隔不是 60 秒的因数，例如以下示例中，规定片长度为 9，该时间片不会始终以 00 秒数开始或结束：
=> SELECT TIME_SLICE('2009-02-14 20:13:01', 9);
TIME_SLICE
---------------------
2009-02-14 20:12:54
(1 row)
这是预期行为，因为所有时间片的以下属性为真：
长度相同
连续（时间片之间没有间隙）
无重叠
为强制上述示例 ('2009-02-14 20:13:01') 的开始时间为 '2009-02-14 20:13:00'，请调整输出时间戳值，使剩余 54 计数至 60：
=> SELECT TIME_SLICE('2009-02-14 20:13:01', 9 )+'6 seconds'::INTERVAL AS time;
time
---------------------
2009-02-14 20:13:00
(1 row)
或者，您可以使用能被 60 整除的不同片长度，例如 5：
=> SELECT TIME_SLICE('2009-02-14 20:13:01', 5);
TIME_SLICE
---------------------
2009-02-14 20:13:00
(1 row)
TIMESTAMPTZ 值隐式强制转换为 TIMESTAMP。例如，以下两个语句的效果相同。
=> SELECT TIME_SLICE('2009-09-23 11:12:01'::timestamptz, 3);
TIME_SLICE
---------------------
2009-09-23 11:12:00
(1 row)
=> SELECT TIME_SLICE('2009-09-23 11:12:01'::timestamptz::timestamp, 3);
TIME_SLICE
---------------------
2009-09-23 11:12:00
(1 row)
您可以使用 SQL 分析函数
FIRST_VALUE 和
LAST_VALUE 来找到每个时间片组（属于相同时间片的行集合）内的第一个/最后一个价格。如果您要通过从每个时间片组选择一行来取样输入数据，此结构很实用。
=> SELECT date_key, transaction_time, sales_dollar_amount,TIME_SLICE(DATE '2000-01-01' + date_key + transaction_time, 3),
FIRST_VALUE(sales_dollar_amount)
OVER (PARTITION BY TIME_SLICE(DATE '2000-01-01' + date_key + transaction_time, 3)
ORDER BY DATE '2000-01-01' + date_key + transaction_time) AS first_value
FROM store.store_sales_fact
LIMIT 20;
date_key | transaction_time | sales_dollar_amount | time_slice | first_value
----------+------------------+---------------------+---------------------+-------------
1 | 00:41:16 | 164 | 2000-01-02 00:41:15 | 164
1 | 00:41:33 | 310 | 2000-01-02 00:41:33 | 310
1 | 15:32:51 | 271 | 2000-01-02 15:32:51 | 271
1 | 15:33:15 | 419 | 2000-01-02 15:33:15 | 419
1 | 15:33:44 | 193 | 2000-01-02 15:33:42 | 193
1 | 16:36:29 | 466 | 2000-01-02 16:36:27 | 466
1 | 16:36:44 | 250 | 2000-01-02 16:36:42 | 250
2 | 03:11:28 | 39 | 2000-01-03 03:11:27 | 39
3 | 03:55:15 | 375 | 2000-01-04 03:55:15 | 375
3 | 11:58:05 | 369 | 2000-01-04 11:58:03 | 369
3 | 11:58:24 | 174 | 2000-01-04 11:58:24 | 174
3 | 11:58:52 | 449 | 2000-01-04 11:58:51 | 449
3 | 19:01:21 | 201 | 2000-01-04 19:01:21 | 201
3 | 22:15:05 | 156 | 2000-01-04 22:15:03 | 156
4 | 13:36:57 | -125 | 2000-01-05 13:36:57 | -125
4 | 13:37:24 | -251 | 2000-01-05 13:37:24 | -251
4 | 13:37:54 | 353 | 2000-01-05 13:37:54 | 353
4 | 13:38:04 | 426 | 2000-01-05 13:38:03 | 426
4 | 13:38:31 | 209 | 2000-01-05 13:38:30 | 209
5 | 10:21:24 | 488 | 2000-01-06 10:21:24 | 488
(20 rows)
TIME_SLICE 将事务处理时间四舍五入至 3 秒片长度。
以下示例使用分析（窗口） OVER 子句来返回每个 3 秒时间片分区中的最后交易价格（按 TickTime 排序的最后一行）：
=> SELECT DISTINCT TIME_SLICE(TickTime, 3), LAST_VALUE(price)OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING);
LAST_VALUE 默认为 RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW。结果似乎并不直观，因为与当前分区底部返回值不一样，该函数返回 window 顶部，而且随着正处理的当前输入行持续变化。有关详细信息，请参阅时序分析和 SQL 分析。
在下一个示例中，会对每个输入记录求一次 FIRST_VALUE 的值，而且按升序值对数据进行排序。使用 SELECT DISTINCT 移除重复值，每个 TIME_SLICE 仅返回一个输出记录：
=> SELECT DISTINCT TIME_SLICE(TickTime, 3), FIRST_VALUE(price)OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ASC)
FROM tick_store;
TIME_SLICE | ?column?
---------------------+----------
2009-09-21 00:00:06 | 20.00
2009-09-21 00:00:09 | 30.00
2009-09-21 00:00:00 | 10.00
(3 rows)
上述查询的信息输出也可以返回每个时间片内的 MIN、MAX 和 AVG 交易价格。
=> SELECT DISTINCT TIME_SLICE(TickTime, 3),FIRST_VALUE(Price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)
ORDER BY TickTime ASC),
MIN(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)),
MAX(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3)),
AVG(price) OVER (PARTITION BY TIME_SLICE(TickTime, 3))
FROM tick_store;
以文本字符串的形式返回时钟时间。事务处理过程中函数结果提前。
TIMEOFDAY()
=> SELECT TIMEOFDAY();
TIMEOFDAY
-------------------------------------
Mon Dec 12 08:18:01.022710 2016 EST
(1 row)
将指定数量的间隔添加到 TIMESTAMP 或 TIMESTAMPTZ 值，并返回相同数据类型的结果。
TIMESTAMPADD ( datepart, count, start‑date );
TIMESTAMPADD 添加到指定开始日期的时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：
TIMESTAMPADD((expression), interval, start;
datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：
year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us
向当前日期添加两个月：
=> SELECT CURRENT_TIMESTAMP AS Today;
Today
-------------------------------
2016-05-02 06:56:57.923045-04
(1 row)
=> SELECT TIMESTAMPADD (MONTH, 2, (CURRENT_TIMESTAMP)) AS TodayPlusTwoMonths;;
TodayPlusTwoMonths
-------------------------------
2016-07-02 06:56:57.923045-04
(1 row)
向当月月初添加 14 天：
=> SELECT TIMESTAMPADD (DD, 14, (SELECT TRUNC((CURRENT_TIMESTAMP), 'MM')));
timestampadd
---------------------
2016-05-15 00:00:00
(1 row)
以指定的间隔返回两个 TIMESTAMP 或 TIMESTAMPTZ 值之间的时间跨度。 TIMESTAMPDIFF 在其计算中不包括开始日期。
TIMESTAMPDIFF ( datepart, start, end );
TIMESTAMPDIFF 返回的日期或时间间隔类型。如果 datepart 为表达式，则必须用括号括起来：
TIMESTAMPDIFF((expression), start, end );
datepart 的求值结果必须为以下字符串字面量之一，无论带引号还是不带引号：
year | yy | yyyy
quarter | qq | q
month | mm | m
day | dayofyear | dd | d | dy | y
week | wk | ww
hour | hh
minute | mi | n
second | ss | s
millisecond | ms
microsecond | mcs | us
start, endTIMESTAMP/TIMESTAMPTZ
TIMESTAMPTZ
如果 end < start，则 TIMESTAMPDIFF 返回负值。
TIMESTAMPDIFF 使用 datepart 实参计算两个日期之间的间隔数，而不是二者之间的实际时间量。有关详细信息，请参阅
DATEDIFF。
=> SELECT TIMESTAMPDIFF (YEAR,'1-1-2006 12:34:00', '1-1-2008 12:34:00');
timestampdiff
---------------
2
(1 row)
DATEDIFF
对指定的 TIMESTAMP 进行四舍五入。如果省略精度实参，TIMESTAMP_ROUND 将舍入到天 (DD) 精度。
TIMESTAMP_ROUND ( rounding‑target[, 'precision'] )
世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS
DATE 表达式不支持时、分和秒舍入。
五入到最近的小时：
=> SELECT TIMESTAMP_ROUND(CURRENT_TIMESTAMP, 'HH');
ROUND
---------------------
2016-04-28 15:00:00
(1 row)
五入到最近的月份：
=> SELECT TIMESTAMP_ROUND('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
ROUND
---------------------
2011-10-01 00:00:00
(1 row)
截断指定的 TIMESTAMP。如果省略精度实参，TIMESTAMP_TRUNC 将截断到天 (DD) 精度。
TIMESTAMP_TRUNC( trunc‑target[, 'precision'] )
世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
日期： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS
DATE 表达式不支持时、分和秒截断。
截断到当前小时：
=> SELECT TIMESTAMP_TRUNC(CURRENT_TIMESTAMP, 'HH');
TIMESTAMP_TRUNC
---------------------
2016-04-29 08:00:00
(1 row)
截断到月份：
=> SELECT TIMESTAMP_TRUNC('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
TIMESTAMP_TRUNC
---------------------
2011-09-01 00:00:00
(1 row)
返回
TIME WITH TIMEZONE 类型的值，代表当前事务的开始时间。
事务处理过程中返回值保持不变。因此，在同一事务中多次调用 TRANSACTION_TIMESTAMP 将返回相同的时间戳。
TRANSACTION_TIMESTAMP 等于
CURRENT_TIMESTAMP，除非不接受精度参数。
TRANSACTION_TIMESTAMP()
=> SELECT foo, bar FROM (SELECT TRANSACTION_TIMESTAMP() AS foo)foo, (SELECT TRANSACTION_TIMESTAMP() as bar)bar;
foo | bar
-------------------------------+-------------------------------
2016-12-12 08:18:00.988528-05 | 2016-12-12 08:18:00.988528-05
(1 row)
截断指定的日期或时间。如果省略精度实参，TRUNC 将截断到天 (DD) 精度。
TRUNC( trunc‑target[, 'precision'] )
世纪： CC | SCC
年： SYYY | YYYY | YEAR | YYY | YY | Y
ISO 年： IYYY | IYY | IY | I
季度： Q
月： MONTH | MON | MM | RM
与一年的第 1 天相同的工作日： WW
与 ISO 年的第一天相同的工作日： IW
与当月第一天相同的工作日： W
天（默认）： DDD | DD | J
第一个工作日： DAY | DY | D
时： HH | HH12 | HH24
分： MI
秒： SS
DATE 表达式不支持时、分和秒截断。
截断到当前小时：
=> => SELECT TRUNC(CURRENT_TIMESTAMP, 'HH');
TRUNC
---------------------
2016-04-29 10:00:00
(1 row)
截断到月份：
=> SELECT TRUNC('9-22-2011 12:34:00'::TIMESTAMP, 'MM');
TIMESTAMP_TRUNC
---------------------
2011-09-01 00:00:00
(1 row)
以整数形式返回指定日期为一年中的第几周，其中第一周从 1 月 1 日或之前的第一个星期日开始。
WEEK ( date )
处理日期，具有以下一种数据类型：
1 月 2 日是星期六，所以 WEEK 返回 1：
=> SELECT WEEK ('1-2-2016'::DATE);
WEEK
------
1
(1 row)
1 月 3 日是 2016 年的第二个星期日，所以 WEEK 返回 2：
=> SELECT WEEK ('1-3-2016'::DATE);
WEEK
------
2
(1 row)
以整数形式返回指定日期为一年中的第几周，其中第一周从星期一开始，包含 1 月 4 日。此函数符合 ISO 8061 标准。
WEEK_ISO ( date )
处理日期，具有以下一种数据类型：
2016 年的第一周自 1 月 4 日星期一开始：
=> SELECT WEEK_ISO ('1-4-2016'::DATE);
WEEK_ISO
----------
1
(1 row)
2016 年 1 月 3 日返回上一年（2015 年）的第 53 周：
=> SELECT WEEK_ISO ('1-3-2016'::DATE);
WEEK_ISO
----------
53
(1 row)
2015 年 1 月 4 日是星期日，因此 2015 年的第一周自上一个星期一（2014 年 12 月 29 日）开始：
=> SELECT WEEK_ISO ('12-29-2014'::DATE);
WEEK_ISO
----------
1
(1 row)
返回表示指定日期的年份部分的整数。
YEAR( date )
处理日期，具有以下一种数据类型：
=> SELECT YEAR(CURRENT_DATE::DATE);
YEAR
------
2016
(1 row)
返回表示指定日期的年份部分的整数。返回值基于 ISO 8061 标准。
ISO 年的第一周是包含 1 月 4 日的一周。
YEAR_ISO ( date )
处理日期，具有以下一种数据类型：
> SELECT YEAR_ISO(CURRENT_DATE::DATE);
YEAR_ISO
----------
2016
(1 row)
IP 函数对 IP、网络和子网地址执行转换、计算和处理操作。
将包含 IPv4 网络地址的点分表示的字符串转换为 INTEGER。剪裁字符串中周边的任何空格。如果字符串为 NULL 或包含除点分 IPv4 地址以外的任何内容，则此函数返回 NULL。
INET_ATON ( expression )
expression=> SELECT INET_ATON('209.207.224.40');
inet_aton
------------
3520061480
(1 row)
=> SELECT INET_ATON('1.2.3.4');
inet_aton
-----------
16909060
(1 row)
=> SELECT TO_HEX(INET_ATON('1.2.3.4'));
to_hex
---------
1020304
(1 row)
将 INTEGER 值转换为 IPv4 网络地址的 VARCHAR 点分表示。如果整数值为 NULL、负数或大于 232 (4294967295)，则 INET_NTOA 返回 NULL。
INET_NTOA ( expression )
=> SELECT INET_NTOA(16909060);
inet_ntoa
-----------
1.2.3.4
(1 row)
=> SELECT INET_NTOA(03021962);
inet_ntoa
-------------
0.46.28.138
(1 row)
将包含以冒号分隔的 IPv6 网络地址的字符串转换为 VARBINARY 字符串。IPv6 地址周围的所有空格都会被剪裁。如果输入值为 NULL 或无法解析为 IPv6 地址，则此函数返回 NULL。此函数依赖 Linux 函数 inet_pton。
V6_ATON ( expression )
=> SELECT V6_ATON('2001:DB8::8:800:200C:417A');
v6_aton
------------------------------------------------------
\001\015\270\000\000\000\000\000\010\010\000 \014Az
(1 row)
=> SELECT V6_ATON('1.2.3.4');
v6_aton
------------------------------------------------------------------
\000\000\000\000\000\000\000\000\000\000\377\377\001\002\003\004
(1 row)
SELECT TO_HEX(V6_ATON('2001:DB8::8:800:200C:417A'));
to_hex
----------------------------------
20010db80000000000080800200c417a
(1 row)
=> SELECT V6_ATON('::1.2.3.4');
v6_aton
------------------------------------------------------------------
\000\000\000\000\000\000\000\000\000\000\000\000\001\002\003\004
(1 row)
将表示为变长二进制的 IPv6 地址转换为字符串。
V6_NTOA ( expression )
expressionVARBINARY) 是要转换的二进制字符串。下述语法将表示为 VARBINARY B 的 IPv6 地址转换为字符串 A。
V6_NTOA 在 B 右侧填充 0 至 16 字节（若必要），并调用 Linux 函数 inet_ntop。
=> V6_NTOA(VARBINARY B) -> VARCHAR A
如果 B 为 NULL 或超过 16 个字节，则结果为 NULL。
Vertica 自动将格式 "::ffff:1.2.3.4" 转换为 "1.2.3.4"。
=> SELECT V6_NTOA(' \001\015\270\000\000\000\000\000\010\010\000 \014Az');
v6_ntoa
---------------------------
2001:db8::8:800:200c:417a
(1 row)
=> SELECT V6_NTOA(V6_ATON('1.2.3.4'));
v6_ntoa
---------
1.2.3.4
(1 row)
=> SELECT V6_NTOA(V6_ATON('::1.2.3.4'));
v6_ntoa
-----------
::1.2.3.4
(1 row)
从二进制或字母数字 IPv6 地址返回一个包含 CIDR（无类别域间路由）格式的子网地址的 VARCHAR。如果任一参数为 NULL、地址无法解析为 IPv6 地址或子网值超出 0 到 128 的范围，则返回 NULL。
V6_SUBNETA ( address, subnet)
=> SELECT V6_SUBNETA(V6_ATON('2001:db8::8:800:200c:417a'), 28);
v6_subneta
---------------
2001:db0::/28
(1 row)
从变长二进制或字母数字 IPv6 地址计算无类别域间路由 (CIDR) 格式的子网地址。
V6_SUBNETN ( address, subnet-size)
下述语法屏蔽 BINARY IPv6 地址 B，使得 S 最左侧的 N 位形成子网地址，而剩余最右侧的位被清除。
V6_SUBNETN 在 B 右侧填充 0 至 16 字节 （若必要）并屏蔽 B，保留其 N 位子网前缀。
=> V6_SUBNETN(VARBINARY B, INT8 N) -> VARBINARY(16) S
若 B 是 NULL 或长于 16 字节，或者 N 不在 0 到 128 之间（包含），则结果为 NULL。
S = [B]/N 用无类别域间路由 符号（CIDR 符号）表示。
下述语法屏蔽字母数字 IPv6 地址 A ，使得最左侧的 N 位形成子网地址，而剩余最右侧的位被清除。
=> V6_SUBNETN(VARCHAR A, INT8 N) -> V6_SUBNETN(V6_ATON(A), N) -> VARBINARY(16) S
这个示例在使用 V6_ATON 将 VARCHAR 字符串转换为 VARBINARY 之后返回 VARBINARY：
=> SELECT V6_SUBNETN(V6_ATON('2001:db8::8:800:200c:417a'), 28);
v6_subnetn
---------------------------------------------------------------
\001\015\260\000\000\000\000\000\000\000\000\000\000\000\000
返回 INTEGER 值，该值对传递给它的网络地址类型进行分类，如 IETF RFC 4291 第 2.4 部分中所定义。例如，如果将字符串 127.0.0.1 传递给此函数，则返回 2，表示该地址为环回地址。此函数接受 IPv4 和 IPv6 地址。
V6_TYPE ( address)
函数返回的值为：
返回值取决于下表的 IP 地址范围：
如果将 NULL 值或无效地址传递给此函数，则此函数返回 NULL。
=> SELECT V6_TYPE(V6_ATON('192.168.2.10'));
v6_type
---------
1
(1 row)
=> SELECT V6_TYPE(V6_ATON('2001:db8::8:800:200c:417a'));
v6_type
---------
0
(1 row)
序列函数提供了简单多用户安全方法，从序列对象获取连续序列值。
返回所有节点中的最后一个值，由当前会话中此序列的 NEXTVAL 进行设置。如果 NEXTVAL 自创建后从未在此序列中调用，Vertica 将返回错误。
CURRVAL ('[[database.]schema.]sequence-name')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
sequence-name 对序列的 SELECT 权限
对序列架构的 USAGE 权限
在以下情况下，不能在 SELECT 语句中调用 CURRVAL：
WHERE 子句
GROUP BY 子句
ORDER BY 子句
DISTINCT 子句
UNION
子查询
也不能调用 CURRVAL 处理以下项中的序列：
UPDATE 或 DELETE 子查询
视图
请参阅创建和使用命名序列。
返回序列中的下一个值。创建序列并使用默认值初始化后，调用 NEXTVAL。接下来，调用 NEXTVAL 增加序列值，进行升序排列，或减少值，进行降序排列。
NEXTVAL ('[[database.]schema.]sequence')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
序列对序列的 SELECT 权限
对序列架构的 USAGE 权限
在以下情况下，不能在 SELECT 语句中调用 NEXTVAL：
WHERE 子句
GROUP BY 子句
ORDER BY 子句
DISTINCT 子句
UNION
子查询
也不能调用 NEXTVAL 处理以下项中的序列：
UPDATE 或 DELETE 子查询
视图
您可以使用子查询解决部分限制。例如，要将序列与 DISTINCT 使用使用：
=> SELECT t.col1, shift_allocation_seq.NEXTVAL FROM (
SELECT DISTINCT col1 FROM av_temp1) t;
请参阅创建和使用命名序列。
字符串函数执行字符串转换、提取或处理操作，或返回有关字符串的信息。
此部分描述了用于检查和处理字符串值的函数和运算符。在此文中的字符串包括 CHAR、VARCHAR、BINARY 和 VARBINARY 类型的值。
除非另行说明，否则此部分列出的所有函数适用于所有四种数据类型。与某些其它 SQL 实施相对的是，Vertica 内部维持不填充 CHAR 字符串，至在最终输出填充。因此，转换 CHAR(3) 'ab' 为 VARCHAR(5)，长度 2 而不是长度 3（包括一个行尾空格）的 VARCHAR。
此处描述的部分函数可以通过先将非字符串类型的数据转换为字符串表示形式，从而适用于此类数据。部分函数仅适用于字符形式的字符串，另一部分函数则仅适用于二进制字符串。很多函数适用于两者。BINARY 和 VARBINARY 函数忽略了多字节 UTF-8 字符界限。
非二进制字符形式的字符串函数处理 Unicode Consortium 规定的规范化多字节 UTF-8 字符。除非另有说明，否则这些相关的字符形式字符串函数可选择性地指定 VARCHAR 实参应解释为八位字节（字节）序列还是对于区域设置敏感的 UTF-8 字符序列。为此，您可以将“USING OCTETS”或“USING CHARACTERS”（默认值）添加为函数形参。
部分字符形式的字符串函数为 稳定，因为 UTF-8 大小写转换、搜索和排序通常可以取决于区域设置。因此，LOWER 为稳定函数，而 LOWERB 为 不可变函数。USING OCTETS 子句将这些函数转换为 "B" 形式，因此成为不可变函数。如果区域设置为默认设置 collation=binary，则所有字符串函数（除 CHAR_LENGTH/CHARACTER_LENGTH、LENGTH、SUBSTR 和 OVERLAY 以外）转换为各自的 "B" 形式，因此成为不可变函数。
BINARY 隐式转换为 VARBINARY，因此采用 VARBINARY 实参的函数可与 BINARY 使用。
有关对字符串（而非 VARBINARY）进行操作的其他函数，请参阅 正则表达式函数。
将 VARCHAR 数据类型的第一个字符转换为 INTEGER。此函数与 CHR 函数相对。
ASCII 对 UTF-8 字符和单字节 ASCII 字符进行操作。针对 UTF-8 的 ASCII 子集返回相同的结果。
ASCII ( expression )
此示例返回以 L 开头的员工姓氏。L 的 ASCII 等效值为 76：
=> SELECT employee_last_name FROM employee_dimension
WHERE ASCII(SUBSTR(employee_last_name, 1, 1)) = 76
LIMIT 5;
employee_last_name
--------------------
Lewis
Lewis
Lampert
Lampert
Li
(5 rows)
按位（字节数 * 8）返回字符串表达式的长度作为 INTEGER 数据类型。BIT_LENGTH 适用于 VARCHAR 和 VARBINARY 字段的内容。
BIT_LENGTH ( expression )
expressionSELECT BIT_LENGTH('abc'::varbinary);24
SELECT BIT_LENGTH('abc'::binary);8
SELECT BIT_LENGTH(''::varbinary);0
SELECT BIT_LENGTH(''::binary);8
SELECT BIT_LENGTH(null::varbinary);SELECT BIT_LENGTH(null::binary);SELECT BIT_LENGTH(VARCHAR 'abc');24
SELECT BIT_LENGTH(CHAR 'abc');24
SELECT BIT_LENGTH(CHAR(6) 'abc');48
SELECT BIT_LENGTH(VARCHAR(6) 'abc');24
SELECT BIT_LENGTH(BINARY(6) 'abc');48
SELECT BIT_LENGTH(BINARY 'abc');24
SELECT BIT_LENGTH(VARBINARY 'abc');24
SELECT BIT_LENGTH(VARBINARY(6) 'abc');24
在给定的 VARBINARY 值中返回一个二进制位数（有时称为设置位）。这也被称为种群统计。
BITCOUNT ( expression )
expression=> SELECT BITCOUNT(HEX_TO_BINARY('0x10'));
BITCOUNT
----------
1
(1 row)
=> SELECT BITCOUNT(HEX_TO_BINARY('0xF0'));
BITCOUNT
----------
4
(1 row)
=> SELECT BITCOUNT(HEX_TO_BINARY('0xAB'));
BITCOUNT
----------
5
(1 row)
将给定的 VARCHAR 位字符串表示转换为 VARBINARY 值。此函数是
TO_BITSTRING 的反函数。
BITSTRING_TO_BINARY ( expression )
如果十六进制值中有奇数个字符，第一个字符被视为第一个（最左边）字节的下半字节。
=> SELECT BITSTRING_TO_BINARY('0110000101100010');
BITSTRING_TO_BINARY
---------------------
ab
(1 row)
从字符串的开头和结尾删除仅包含指定字符的最长字符串。
BTRIM ( expression [ , characters-to-remove ] )
expressioncharacters-to-remove=> SELECT BTRIM('xyxtrimyyx', 'xy');
BTRIM
-------
trim
(1 row)
CHARACTER_LENGTH() 函数：
对于 CHAR 和 VARCHAR 列，返回以 UTF-8 字符数表示的字符串长度
对于 BINARY 和 VARBINARY 列，返回以字节（八位字节）表示的字符串长度
去掉 CHAR 表达式中的填充值，但是不去掉 VARCHAR 表达式中的填充值
与用于 CHAR 和 VARCHAR 的 LENGTH() 相同。对于二进制类型，CHARACTER_LENGTH() 与 OCTET_LENGTH() 相同。
如果为 USING OCTETS，则是
不可变，否则为
稳定。
[ CHAR_LENGTH | CHARACTER_LENGTH ] ( expression ... [ USING { CHARACTERS | OCTETS } ] )
expressionUSING CHARACTERS | OCTETS=> SELECT CHAR_LENGTH('1234 '::CHAR(10) USING OCTETS);
octet_length
--------------
4
(1 row)
=> SELECT CHAR_LENGTH('1234 '::VARCHAR(10));
char_length
-------------
6
(1 row)
=> SELECT CHAR_LENGTH(NULL::CHAR(10)) IS NULL;
?column?
----------
t
(1 row)
将 INTEGER 数据类型的第一个字符转换为 VARCHAR。
CHR ( expression )
expressionCHR 与 ASCII 函数相对。
CHR 对 UTF-8 字符进行操作，而不仅仅是单字节 ASCII 字符。对于 UTF-8 的 ASCII 子集，继续获取相同的结果。
此示例从员工表返回 CHR 表达式 65 和 97 的 VARCHAR 数据类型：
=> SELECT CHR(65), CHR(97) FROM employee;
CHR | CHR
-----+-----
A | a
A | a
A | a
A | a
A | a
A | a
A | a
A | a
A | a
A | a
A | a
A | a
(12 rows)
可将一个排序规则应用于两个或更多字符串。COLLATION 可与 ORDER BY、GROUP BY 和相等子句一起使用。
COLLATION ( 'expression' [ , 'locale_or_collation_name' ] )
'expression'CHAR 或 VARCHAR 类型的值进行求值的任何表达式。'locale_or_collation_name'COLLATION 将使用与会话区域设置相关联的排序规则。
要确定当前的会话区域设置，请输入 vsql 元命令 \locale：
=> \locale
en_US@collation=binary
要设置区域设置和排序规则，请使用 \locale，具体如下所示：
=> \locale en_US@collation=binary
INFO 2567: Canonical locale: 'en_US'
Standard collation: 'LEN_KBINARY'
English (United States)
用于 COLLATION 的区域设置可以是以下类型之一：
默认区域设置
会话区域设置
您在调用 COLLATION 时指定的区域设置。如果您指定了区域设置，Vertica 会将与该区域规则相关联的排序规则应用于数据。 COLLATION 不会修改表中任何其他列的排序规则。
有关有效 ICU 区域设置的列表，请访问区域设置浏览器 (ICU)。
Vertica 默认区域设置为 en_US@collation=binary，使用 二进制排序规则。二进制排序规则将对字符串的二进制表示法进行比较。二进制排序规则速度较快，但它可能会导致 K 排在 c 之前的排序顺序，因为 K 的二进制表示法小于 c。
对于非二进制排序规则，Vertica 将按区域设置规则或指定排序规则转换数据，然后应用排序规则。假设区域设置排序规则为非二进制，而您请求对字符串数据进行 GROUP BY 操作。在这种情况下，无论是否在查询中指定函数，Vertica 都会调用 COLLATION。
有关排序规则命名的信息，请参阅排序器命名架构。
以下示例基于 Premium_Customer 表，包含以下数据：
=> SELECT * FROM Premium_Customer;
ID | LName | FName
----+--------+---------
1 | Mc Coy | Bob
2 | Mc Coy | Janice
3 | McCoy | Jody
4 | McCoy | Peter
5 | McCoy | Brendon
6 | Mccoy | Cameron
7 | Mccoy | Lisa
第一个语句显示了 COLLATION 如何将适用于 EN_US 区域设置的排序规则应用于区域设置 LName 的 EN_US 列。Vertica 将对 GROUP BY 的输出进行排序，具体如下所示：
包含空格的姓氏
“coy”以小写字母开头的姓氏
“Coy”以大写字母开头的姓氏
=> SELECT * FROM Premium_Customer ORDER BY COLLATION(LName, 'EN_US'), FName;
ID | LName | FName
----+--------+---------
1 | Mc Coy | Bob
2 | Mc Coy | Janice
6 | Mccoy | Cameron
7 | Mccoy | Lisa
5 | McCoy | Brendon
3 | McCoy | Jody
4 | McCoy | Peter
下一个语句显示了 COLLATION 如何针对区域设置 LName 对 LEN_AS 列进行排序：
LEN 表示语言 (L) 为英语 (EN)。
AS （转换替代字母）指示 COLLATION 小写字母出现在大写（转换）字母之前。
在结果中，“coy”以小写字母开头的姓氏将出现在“Coy”以大写字母开头的姓氏之前。
=> SELECT * FROM Premium_Customer ORDER BY COLLATION(LName, 'LEN_AS'), FName;
ID | LName | FName
----+--------+---------
6 | Mccoy | Cameron
7 | Mccoy | Lisa
1 | Mc Coy | Bob
5 | McCoy | Brendon
2 | Mc Coy | Janice
3 | McCoy | Jody
4 | McCoy | Peter
在以下查询中，COLLATION 将在对两个英文字符串进行比较时删除空格和标点。随后它将确定这两个字符串在删除标点后是否仍然包含相同的值：
=> SELECT COLLATION ('U.S.A', 'LEN_AS') = COLLATION('USA', 'LEN_AS');
?column?
----------
t
下表包含使用德语字符 eszett（即 ß）的数据：
=> SELECT * FROM t1;
a | b | c
------------+---+----
ßstringß | 1 | 10
SSstringSS | 2 | 20
random1 | 3 | 30
random1 | 4 | 40
random2 | 5 | 50
当您指定排序规则 LDE_S1 时：
LDE 表示语言 (L) 为德语 (DE)。
S1 表示强度 (S) 为 1（主）。此值表示排序规则无需考虑重音和大小写。
查询将按以下顺序返回数据：
=> SELECT a FROM t1 ORDER BY COLLATION(a, 'LDE_S1'));
a
------------
random1
random1
random2
SSstringSS
ßstringß
连接两个字符串并返回 varchar 数据类型。如果任一实参为 NULL，则 CONCAT 返回 NULL。
CONCAT ('string‑expression1, string‑expression2)
string‑expression1, string‑expression2以下示例使用名为 alphabet 的示例表，其中包含两个 VARCHAR 列：
=> CREATE TABLE alphabet (letter1 varchar(2), letter2 varchar(2));
CREATE TABLE
=> COPY alphabet FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> A|B
>> C|D
>> \.
=> SELECT * FROM alphabet;
letter1 | letter2
---------+---------
C | D
A | B
(2 rows)
用字符串连接第一列的内容：
=> SELECT CONCAT(letter1, ' is a letter') FROM alphabet;
CONCAT
---------------
A is a letter
C is a letter
(2 rows)
连接两个嵌套 CONCAT 函数的输出：
=> SELECT CONCAT(CONCAT(letter1, ' and '), CONCAT(letter2, ' are both letters')) FROM alphabet;
CONCAT
--------------------------
C and D are both letters
A and B are both letters
(2 rows)
连接日期和字符串：
=> SELECT current_date today;
today
------------
2021-12-10
(1 row)
=> SELECT CONCAT('2021-12-31'::date - current_date, ' days until end of year 2021');
CONCAT
--------------------------------
21 days until end of year 2021
(1 row)
逐一比较每个搜索值的表达式。如果表达式等同于搜索内容，则函数返回相应的结果。如果未找到匹配，则函数返回默认值。如果忽略了默认值，则函数返回 null。
DECODE 与 IF-THEN-ELSE 和 CASE 表达式相类似：
CASE expression
[WHEN search THEN result]
[WHEN search THEN result]
...
[ELSE default];
实参可以包含 Vertica 支持的所有数据类型。单独结果的类型会被提升到可用于表示全部结果的最不常见的类型。这样会产生字符串类型、精确数字类型、近似数字类型或 DATETIME 类型，其中所有的结果实参必须属于同一类型的分组。
DECODE ( expression, search, result [ , search, result ]...[, default ] )
expression search result default 以下示例将 product_dimension 表中权重列的数值在输出中转换为描述值。
=> SELECT product_description, DECODE(weight,
2, 'Light',
50, 'Medium',
71, 'Heavy',
99, 'Call for help',
'N/A')
FROM product_dimension
WHERE category_description = 'Food'
AND department_description = 'Canned Goods'
AND sku_number BETWEEN 'SKU-#49750' AND 'SKU-#49999'
LIMIT 15;
product_description | case
-----------------------------------+---------------
Brand #499 canned corn | N/A
Brand #49900 fruit cocktail | Medium
Brand #49837 canned tomatoes | Heavy
Brand #49782 canned peaches | N/A
Brand #49805 chicken noodle soup | N/A
Brand #49944 canned chicken broth | N/A
Brand #49819 canned chili | N/A
Brand #49848 baked beans | N/A
Brand #49989 minestrone soup | N/A
Brand #49778 canned peaches | N/A
Brand #49770 canned peaches | N/A
Brand #4977 fruit cocktail | N/A
Brand #49933 canned olives | N/A
Brand #49750 canned olives | Call for help
Brand #49777 canned tomatoes | N/A
(15 rows)
计算并返回两个字符串之间的 Levenshtein 距离。返回值表示将一个字符串更改为另一个字符串所需的最小单字符编辑次数（插入、删除或替换）。
EDIT_DISTANCE ( string-expression1, string-expression2 )
kitten 与 knitting 之间的 Levenshtein 距离为 3：
=> SELECT EDIT_DISTANCE ('kitten', 'knitting');
EDIT_DISTANCE
---------------
3
(1 row)
EDIT_DISTANCE 计算出将 kitten 转换为 knitting 需要不少于三项更改：
kitten → knitten （在 k 之后插入 n）
knitten → knittin （用 i 替换 e）
knittin → knitting （附加 g）
返回任何数据类型的表达式列表中的最大值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。
GREATEST ( { * | expression[,...] } )
* | expression[,...]* （星号）
对查询表中的所有列进行求值。
表达式
任何数据类型的表达式。expression 中包含的函数必须具有确定性。
GREATEST 返回 10 作为列表中的最大值：
=> SELECT GREATEST(7,5,10);
GREATEST
----------
10
(1 row)
如果在整数表达式周围添加引号，GREATEST 会将值作为字符串进行比较，并返回 "7" 作为最大值：
=> SELECT GREATEST('7', '5', '10');
GREATEST
----------
7
(1 row)
下一个示例返回 FLOAT 1.5 作为最大值，因为整数隐式转换为浮点类型：
=> SELECT GREATEST(1, 1.5);
GREATEST
----------
1.5
(1 row)
GREATEST 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最大值：
=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_width, shelf_height, shelf_depth, greatest(*) FROM query1 WHERE shelf_width = 1;
shelf_width | shelf_height | shelf_depth | greatest
-------------+--------------+-------------+----------
1 | 3 | 1 | 3
1 | 3 | 3 | 3
1 | 5 | 4 | 5
1 | 2 | 2 | 2
1 | 1 | 3 | 3
1 | 2 | 2 | 2
1 | 2 | 3 | 3
1 | 1 | 5 | 5
1 | 1 | 4 | 4
1 | 5 | 3 | 5
1 | 4 | 2 | 4
1 | 4 | 5 | 5
1 | 5 | 3 | 5
1 | 2 | 5 | 5
1 | 4 | 2 | 4
1 | 4 | 4 | 4
1 | 1 | 2 | 2
1 | 4 | 3 | 4
...
使用二进制排序返回任何数据类型的表达式列表中的最大值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。
GREATEST ( { * | expression[,...] } )
* | expression[,...]* （星号）
对查询表中的所有列进行求值。
表达式
任何数据类型的表达式。expression 中包含的函数必须具有确定性。
以下命令选择 straße 作为输入序列中的最大值：
=> SELECT GREATESTB('straße', 'strasse');
GREATESTB
-----------
straße
(1 row)
GREATESTB 返回 10 作为列表中的最大值：
=> SELECT GREATESTB(7,5,10);
GREATESTB
-----------
10
(1 row)
如果在整数表达式周围添加引号，GREATESTB 会将值作为字符串进行比较，并返回 "7" 作为最大值：
=> SELECT GREATESTB('7', '5', '10');
GREATESTB
-----------
7
(1 row)
下一个示例返回 FLOAT 1.5 作为最大值，因为整数隐式转换为浮点类型：
=> SELECT GREATESTB(1, 1.5);
GREATESTB
-----------
1.5
(1 row)
GREATESTB 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最大值：
=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_width, shelf_height, shelf_depth, greatestb(*) FROM query1 WHERE shelf_width = 1;
shelf_width | shelf_height | shelf_depth | greatestb
-------------+--------------+-------------+-----------
1 | 3 | 1 | 3
1 | 3 | 3 | 3
1 | 5 | 4 | 5
1 | 2 | 2 | 2
1 | 1 | 3 | 3
1 | 2 | 2 | 2
1 | 2 | 3 | 3
1 | 1 | 5 | 5
1 | 1 | 4 | 4
1 | 5 | 3 | 5
1 | 4 | 2 | 4
1 | 4 | 5 | 5
1 | 5 | 3 | 5
1 | 2 | 5 | 5
1 | 4 | 2 | 4
...
将给定的 VARCHAR 十六进制表示方式转换为 VARBINARY 值。
HEX_TO_BINARY ( [ 0x ] expression )
expression0xVARBINARY HEX_TO_BINARY(VARCHAR) 将数据从十六进制格式字符类型转换为二进制类型。此函数是 TO_HEX 的反函数。
HEX_TO_BINARY(TO_HEX(x)) = x)
TO_HEX(HEX_TO_BINARY(x)) = x)
如果十六进制值中存在奇数个字符，则将第一个字符处理为第一个（最左边）字节的低效半字节。
如果给定的字符串以“0x”开头，将忽略前缀。例如：
=> SELECT HEX_TO_BINARY('0x6162') AS hex1, HEX_TO_BINARY('6162') AS hex2;
hex1 | hex2
------+------
ab | ab
(1 row)
如果给出的是无效的十六进制值，Vertica 将会返回“无效的二进制表达方式”错误；例如：
=> SELECT HEX_TO_BINARY('0xffgf');
ERROR: invalid hex string "0xffgf"
将给定的 VARCHAR 十六进制表示方式转换为 INTEGER 值。
Vertica 按如下方式完成此转换：
如果输入中未指定，则添加 0x 前缀
将 VARCHAR 字符串转换为 NUMERIC
将 NUMERIC 转换为 INTEGER
HEX_TO_INTEGER ( [ 0x ] expression )
expression0x您可以输入带有或不带有 Ox 前缀的字符串。例如：
=> SELECT HEX_TO_INTEGER ('0aedc')
AS hex1,HEX_TO_INTEGER ('aedc') AS hex2;
hex1 | hex2
-------+-------
44764 | 44764
(1 row)
如果向函数传递无效十六进制值，Vertica 将返回 invalid input syntax 错误；例如：
=> SELECT HEX_TO_INTEGER ('0xffgf');
ERROR 3691: Invalid input syntax for numeric: "0xffgf"
使每个字母数字单词的首字母大写，并使其余字母小写。
INITCAP ( expression )
expression具体取决于区域设置的排序规则设置。
INITCAP 限定为 32750 个八位字节输入，因为以 UTF-8 表示的结果大小可能会翻倍。
使每个字母数字单词的首字母大写，并使其余字母小写。多字节字符不会转换，而是跳过。
INITCAPB ( expression )
expression具体取决于区域设置的排序规则设置。
SELECT INITCAPB('étudiant');éTudiant
SELECT INITCAPB('high speed database');High Speed Database
SELECT INITCAPB('LINUX TUTORIAL');Linux Tutorial
SELECT INITCAPB('abc DEF 123aVC 124Btd,lAsT');Abc Def 123Avc 124Btd,Last
SELECT INITCAPB('');SELECT INITCAPB(null);将一个字符串插入另一个字符串的指定位置。
INSERT( 'string1', n, m, 'string2' )
string1nmstring2以下示例使用 INSERT 函数将字符串 Warehouse 更改为 Storehouse：
=> SELECT INSERT ('Warehouse',1,3,'Stor');
INSERT
------------
Storehouse
(1 row)
搜索字符串中的子字符串，并返回一个整数，指示字符串中第一次出现的字符的位置。返回值代表被指定字符出现的位置。
INSTR ( string , substring [, position [, occurrence ] ] )
string substring position occurrence position 和 occurrence 都必须是能够解析为整数的类型。两个参数的默认值都是 1，代表 Vertica 开始搜索字符串的第一个字符在子字符串中首次出现的位置。返回值与 position 值无关，从字符串的开端开始计算，并且是一个字符。
如果搜索不成功（即子字符串未在 string 的 position 字符后显示出现次数，则返回值为 0。
第一个例子是在字符串 ‘abc’ 中从左到右搜索子字符串 ‘b’。搜索 ‘b’ 在 ‘abc’ 中出现的位置，或 position 2。以为没有提供 position 参数， 搜索默认从 position 1 ，‘a’ 开始。
=> SELECT INSTR('abc', 'b');
INSTR
-------
2
(1 row)
接下来的是哪个例子使用字符位置来从右到左搜索子字符串的位置。
第一个例子中， 函数从字符串最后一个字符 ‘c’ 开始，从右到左开始数一个字符。函数随后向后搜索第一次出现的‘a’，在搜索字符串中的第一个位置找到了该字符。
=> SELECT INSTR('abc', 'a', -1);
INSTR
-------
1
(1 row)
第二个例子中，函数从字符串最后一个字符 ‘c’ 开始，从右到左开始数一个字节。函数随后向后搜索第一次出现的‘a’，在搜索字符串中的第一个位置找到了该字符。
=> SELECT INSTR(VARBINARY 'abc', VARBINARY 'a', -1);
INSTR
-------
1
(1 row)
第三个例子中，函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字符，并且从右到左搜索子字符串 ‘bc’，并发现在所搜索字符串的第二个位置。
=> SELECT INSTR('abcb', 'bc', -1);
INSTR
-------
2
(1 row)
第四个例子中，函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字符， 并且从右到左搜索子字符串 ‘bcef’，并没有搜索到。结果为 0。
=> SELECT INSTR('abcb', 'bcef', -1);
INSTR
-------
0
(1 row)
第五个例子中，函数从函数从字符串最后一个字符 ‘b’ 开始，从右到左开始数一个字节，并且从右到左搜索子字符串 ‘bcef’，并没有搜索到。结果为 0。
=> SELECT INSTR(VARBINARY 'abcb', VARBINARY 'bcef', -1);
INSTR
-------
0
(1 row)
多字节字符被认为是一个单独的字符：
=> SELECT INSTR('aébc', 'b');
INSTR
-------
3
(1 row)
使用 INSTRB 将多字节字符做为二进制处理。
=> SELECT INSTRB('aébc', 'b');
INSTRB
--------
4
(1 row)
在 string 中搜索 substring，并返回一个指示八位字节在字符串中首次出现位置的整数。返回值取决于八位字节中标识字节的位置。
INSTRB ( string , substring [, position [, occurrence ] ] )
string substring position occurrence position 和 occurrence 都必须是能够解析为整数的类型。两个参数的默认值都是 1，代表 Vertica 开始搜索字符串的第一个字节在子字符串中首次出现的位置。返回值与 position 值无关，从字符串的开端开始计算，并且是一个八位字节。
如果搜索不成功（即子字符串未在 string 的 position 字符后显示出现次数，则返回值为 0。
=> SELECT INSTRB('straße', 'ß');
INSTRB
--------
5
(1 row)
测试字符串是否是有效的 UTF-8 字符串。如果字符串符合 UTF-8 标准，则返回 ture， 否则返回 false。此函数可以在操作正则表达式函数之前，用来检验字符串是否符合 UTF-8 标准，例如 REGEXP_LIKE 默认是 UTF-8 字符。
ISUTF8 会按照 UTF-8 规则来检查无效的 UTF8 字节序列：
无效字节
意外的延续字节
开始字节后没有足够的延续字节
重载编码
无效 UTF-8 字节序列返回 false 值
要将字符串强制转换为 UTF-8，请使用 MAKEUTF8。
ISUTF8( string );
string=> SELECT ISUTF8(E'\xC2\xBF'); \-- UTF-8 INVERTED QUESTION MARK ISUTF8
--------
t
(1 row)
=> SELECT ISUTF8(E'\xC2\xC0'); \-- UNDEFINED UTF-8 CHARACTER
ISUTF8
--------
f
(1 row)
返回任何数据类型的表达式列表中的最小值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。
LEAST ( { * | expression[,...] } )
* | expression[,...]* （星号）
对查询表中的所有列进行求值。
表达式
任何数据类型的表达式。expression 中包含的函数必须具有确定性。
LEASTB 返回 5 作为列表中的最小值：
=> SELECT LEASTB(7, 5, 10);
LEASTB
--------
5
(1 row)
如果在整数表达式周围添加引号，LEASTB 会将值作为字符串进行比较，并返回 "10" 作为最小值：
=> SELECT LEASTB('7', '5', '10');
LEASTB
--------
10
(1 row)
LEAST 返回 1.5，因为 INTEGER 2 隐式转换为 FLOAT：
=> SELECT LEAST(2, 1.5);
LEAST
-------
1.5
(1 row)
LEAST 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最小值：
=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_height, shelf_width, shelf_depth, least(*) FROM query1 WHERE shelf_height = 5;
shelf_height | shelf_width | shelf_depth | least
--------------+-------------+-------------+-------
5 | 3 | 4 | 3
5 | 4 | 3 | 3
5 | 1 | 4 | 1
5 | 4 | 1 | 1
5 | 2 | 4 | 2
5 | 2 | 3 | 2
5 | 1 | 3 | 1
5 | 1 | 3 | 1
5 | 5 | 1 | 1
5 | 2 | 4 | 2
5 | 4 | 5 | 4
5 | 2 | 4 | 2
5 | 4 | 4 | 4
5 | 3 | 4 | 3
...
使用二进制排序返回任何数据类型的表达式列表中的最小值。列表中的所有数据类型必须相同或兼容。任一表达式中的 NULL 值都将返回 NULL。结果可能各不相同，具体取决于区域设置的排序规则设置。
LEASTB ( { * | expression[,...] } )
* | expression[,...]* （星号）
对查询表中的所有列进行求值。
表达式
任何数据类型的表达式。expression 中包含的函数必须具有确定性。
以下命令选择 strasse 作为列表中的最小值：
=> SELECT LEASTB('straße', 'strasse');
LEASTB
---------
strasse
(1 row)
LEASTB 返回 5 作为列表中的最小值：
=> SELECT LEAST(7, 5, 10);
LEAST
-------
5
(1 row)
如果在整数表达式周围添加引号，LEAST 会将值作为字符串进行比较，并返回 "10" 作为最小值：
=> SELECT LEASTB('7', '5', '10');
LEAST
-------
10
(1 row)
下一个示例返回 1.5，因为 INTEGER 2 隐式转换为 FLOAT：
=> SELECT LEASTB(2, 1.5);
LEASTB
--------
1.5
(1 row)
LEASTB 根据 VMart 表 product_dimension 查询视图中的所有列，并返回每一行中的最小值：
=> CREATE VIEW query1 AS SELECT shelf_width, shelf_height, shelf_depth FROM product_dimension;
CREATE VIEW
=> SELECT shelf_height, shelf_width, shelf_depth, leastb(*) FROM query1 WHERE shelf_height = 5;
shelf_height | shelf_width | shelf_depth | leastb
--------------+-------------+-------------+--------
5 | 3 | 4 | 3
5 | 4 | 3 | 3
5 | 1 | 4 | 1
5 | 4 | 1 | 1
5 | 2 | 4 | 2
5 | 2 | 3 | 2
5 | 1 | 3 | 1
5 | 1 | 3 | 1
5 | 5 | 1 | 1
5 | 2 | 4 | 2
5 | 4 | 5 | 4
5 | 2 | 4 | 2
5 | 4 | 4 | 4
5 | 3 | 4 | 3
5 | 5 | 4 | 4
5 | 5 | 1 | 1
5 | 3 | 1 | 1
...
返回字符串左侧指定字符。
LEFT ( string‑expr, length )
=> SELECT LEFT('vertica', 3);
LEFT
------
ver
(1 row)
SELECT DISTINCT(
LEFT (customer_name, 4)) FnameTruncated
FROM customer_dimension ORDER BY FnameTruncated LIMIT 10;
FnameTruncated
----------------
Alex
Amer
Amy
Anna
Barb
Ben
Bett
Bria
Carl
Crai
(10 rows)
返回字符串的长度。LENGTH 的行为因输入数据类型而异：
CHAR 和 VARCHAR：与
CHARACTER_LENGTH 相同，返回以 UTF-8 字符数表示的字符串长度，
CHAR：去掉填充值。
BINARY 和 VARBINARY：与
OCTET_LENGTH 相同，返回以字节（八位字节）数表示的字符串长度。
LENGTH ( expression )
BIT_LENGTH
接受一个字符串值并返回一个转换为小写的 VARCHAR 值。
LOWER ( expression )
在实践中，expression 不得超过 32,500 个八位字节。LOWER 不使用区域设置的排序规则设置（例如，"collation=binary"）标识其编码，而是将输入实参视为 UTF-8 编码字符串。输入值的 UTF-8 表示可能是其原始宽度的两倍。因此，如果输入值超过 32,500 个八位字节，LOWER 将返回错误。
另请注意，如果 expression 为表列，则 LOWER 根据定义的列宽度而不是列数据计算其大小。如果列宽度大于 VARCHAR(32500)，Vertica 将返回错误。
=> SELECT LOWER('AbCdEfG');
LOWER
---------
abcdefg
(1 row)
=> SELECT LOWER('The Bat In The Hat');
LOWER
--------------------
the bat in the hat
(1 row)
=> SELECT LOWER('ÉTUDIANT');
LOWER
----------
étudiant
(1 row)
返回一个所有 ASCII 字符都转换为小写的字符串。跳过（而非转换）多字节字符。
LOWERB ( expression )
在下例中，多字节 UTF-8 字符 É 未转换为小写：
=> SELECT LOWERB('ÉTUDIANT');
LOWERB
----------
Étudiant
(1 row)
=> SELECT LOWER('ÉTUDIANT');
LOWER
----------
étudiant
(1 row)
=> SELECT LOWERB('AbCdEfG');
LOWERB
---------
abcdefg
(1 row)
=> SELECT LOWERB('The Vertica Database');
LOWERB
----------------------
the vertica database
(1 row)
返回一个 VARCHAR 值，该值表示在左侧用特定字符填充的特定长度的字符串。
LPAD ( expression , length [ , fill ] )
expressionlengthfill=> SELECT LPAD('database', 15, 'xzy');
LPAD
-----------------
xzyxzyxdatabase
(1 row)
如果字符串大于指定长度，则在右侧截断：
=> SELECT LPAD('establishment', 10, 'abc');
LPAD
------------
establishm
(1 row)
返回一个表示从左侧（前部）移除空格的字符串的 VARCHAR 值。
LTRIM ( expression [ , characters ] )
expressioncharacters=> SELECT LTRIM('zzzyyyyyyxxxxxxxxtrim', 'xyz');
LTRIM
-------
trim
(1 row)
通过移除或替换非 UTF-8 字符，将字符串强制转换为 UTF-8。
MAKEUTF8 逐字节标记无效的 UTF-8 字符。例如，字节序列 0xE0 0x7F 0x80 为无效三字节 UTF-8 序列，但中间字节 0x7F 为有效单字节 UTF-8 字符。在本例中，0x7F 被保留，另外两个字节被移除或替换。
MAKEUTF8( string‑expression [USING PARAMETERS param=value] );
replacement_stringname 列中的所有非 UTF 字符替换为字符串 ^：=> SELECT MAKEUTF8(name USING PARAMETERS replacement_string='^') FROM people;
计算字符串的 MD5 哈希值，将结果以十六进制的 VARCHAR 字符串形式返回。
MD5 ( string )
string=> SELECT MD5('123');
MD5
----------------------------------
202cb962ac59075b964b07152d234b70
(1 row)
=> SELECT MD5('Vertica'::bytea);
MD5
----------------------------------
fc45b815747d8236f9f6fdb9c2c3f676
(1 row)
将一个实参作为输入，并返回所有字符串类型的字符串长度（八位字节）。
OCTET_LENGTH ( expression )
expression如果 expression 的数据类型是 CHAR、VARCHAR 或 VARBINARY，结果与八位字节 expression 的实际长度相同。对于 CHAR，长度不包含任何结尾空格。
如果 expression 的数据类型是 BINARY，结果与 expression 的固定长度相同。
如果 expression 的值为 NULL，则结果为 NULL。
将一个字符串的一部分替换为另一个字符串，并将新的字符串值以 VARCHAR 形式返回。
OVERLAY ( input‑string PLACING replace‑string FROM position [ FOR extent ] [ USING { CHARACTERS | OCTETS } ] )
input‑stringreplace‑stringposition extent例如，比较以下 OVERLAY 调用：
OVERLAY 省略 FOR 子句。输入字符串中替换的字符数等于替换字符串 ABC 中的字符数：
dbadmin=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5);
overlay
-----------
1234ABC89
(1 row)
OVERLAY 包括 FOR 子句，指定使用替换字符串替换输入字符串中的 4 个字符。替换字符串的长度为三个字符，因此 OVERLAY 返回的字符串比输入字符串少 1 个字符：
=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5 FOR 4);
overlay
----------
1234ABC9
(1 row)
OVERLAY 包括 FOR 子句，指定使用替换字符串替换输入字符串中的 -2 个字符。函数返回的字符串比输入字符串多 2 个字符：
=> SELECT OVERLAY ('123456789' PLACING 'ABC' FROM 5 FOR -2);
overlay
----------------
1234ABC3456789
(1 row)
USING CHARACTERS | OCTETS=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2);
overlay
-----------
1xxx56789
(1 row)
=> SELECT OVERLAY('123456789' PLACING 'XXX' FROM 2 USING OCTETS);
overlayb
-----------
1XXX56789
(1 row)
=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 4);
overlay
----------
1xxx6789
(1 row)
=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 5);
overlay
---------
1xxx789
(1 row)
=> SELECT OVERLAY('123456789' PLACING 'xxx' FROM 2 FOR 6);
overlay
---------
1xxx89
(1 row)
将一个字符串的一部分替换为另一个字符串，并将新的字符串以八位字节值的形式返回。
OVERLAYB 函数将多字节字符串视为八位字节（字节）串，并使用八进制数作为输入和输出的位置及长度说明符。字符串本身是 VARCHAR 类型，但把每个字节视为一个单独的字符串。
OVERLAYB ( input‑string, replace‑string, position [, extent ] )
input‑stringreplace‑stringposition extent=> SELECT OVERLAYB('123456789', 'ééé', 2);
OVERLAYB
----------
1ééé89
(1 row)
=> SELECT OVERLAYB('123456789', 'ßßß', 2);
OVERLAYB
----------
1ßßß89
(1 row)
=> SELECT OVERLAYB('123456789', 'xxx', 2);
OVERLAYB
-----------
1xxx56789
(1 row)
=> SELECT OVERLAYB('123456789', 'xxx', 2, 4);
OVERLAYB
----------
1xxx6789
(1 row)
=> SELECT OVERLAYB('123456789', 'xxx', 2, 5);
OVERLAYB
----------
1xxx789
(1 row)
=> SELECT OVERLAYB('123456789', 'xxx', 2, 6);
OVERLAYB
----------
1xxx89
(1 row)
返回示带字符串的特定子字符串的字符位置的 INTEGER 值表（从 1 开始计数）。
POSITION ( substring IN string [ USING { CHARACTERS | OCTETS } ] )
USING CHARACTERS | OCTETSPOSITION ( substring IN string )
当字符串和子字符串为 CHAR 或 VARCHAR 时，返回值基于字符或子字符串的八进制数位置。
当字符串和子字符串为 VARBINARY 时，返回值通常基于子字符串的八进制数位置。
字符串和子字符串必须一致。不要将 VARBINARY 与 CHAR 或 VARCHAR 混合。
POSITION 类似于 STRPOS，尽管 POSITION 允许通过字符和八进制数查找。
如果未找到字符串，则返回值为零。
=> SELECT POSITION('é' IN 'étudiant' USING CHARACTERS);
position
----------
1
(1 row)
=> SELECT POSITION('ß' IN 'straße' USING OCTETS);
positionb
-----------
5
(1 row)
=> SELECT POSITION('c' IN 'abcd' USING CHARACTERS);
position
----------
3
(1 row)
=> SELECT POSITION(VARBINARY '456' IN VARBINARY '123456789');
position
----------
4
(1 row)
SELECT POSITION('n' in 'León') as 'default',
POSITIONB('León', 'n') as 'POSITIONB',
POSITION('n' in 'León' USING CHARACTERS) as 'pos_chars',
POSITION('n' in 'León' USING OCTETS) as 'pos_oct',INSTR('León','n'),
INSTRB('León','n'), REGEXP_INSTR('León','n');
default | POSITIONB | pos_chars | pos_oct | INSTR | INSTRB | REGEXP_INSTR
---------+-----------+-----------+---------+-------+--------+--------------
4 | 5 | 4 | 5 | 4 | 5 | 4
(1 row)
返回一个 INTEGER 值，该值表示指定子字符串的八位字节在字符串中的位置（从 1 开始计数）。
POSITIONB ( string, substring )
stringsubstring=> SELECT POSITIONB('straße', 'ße');
POSITIONB
-----------
5
(1 row)
=> SELECT POSITIONB('étudiant', 'é');
POSITIONB
-----------
1
(1 row)
以在 SQL 语句中将字符串用作标识符所需的格式返回指定的字符串实参。根据需要添加引号 — 例如，如果字符串包含非标识符字符，或者为 SQL 或 Vertica 预留关键字：
1time
Next week
SELECT
嵌入的双引号将会加倍。
SQL 标识符（例如表名称和列名称）以创建的形式存储，并使用不区分大小写的比较方法来解析对它们的引用。因此，无需使用双引号将混合大小写的标识符括起。
Vertica 引用所有保留关键字，即使未使用。
QUOTE_IDENT( 'string' )
string引用的标识符不区分大小写，并且 Vertica 不提供引号：
=> SELECT QUOTE_IDENT('VErtIcA');
QUOTE_IDENT
-------------
VErtIcA
(1 row)
=> SELECT QUOTE_IDENT('Vertica database');
QUOTE_IDENT
--------------------
"Vertica database"
(1 row)
嵌入的双引号将会加倍：
=> SELECT QUOTE_IDENT('Vertica "!" database');
QUOTE_IDENT
--------------------------
"Vertica ""!"" database"
(1 row)
以下示例使用了 SQL 关键 SELECT，因此结果使用双引号括起：
=> SELECT QUOTE_IDENT('select');
QUOTE_IDENT
-------------
"select"
(1 row)
返回以适当方式引用的给定字符串，以便用作 SQL 语句字符串中的一个字符串字面量。嵌入的单引号和反斜杠将会加倍。根据 SQL 标准，函数将字符串字面量中的两个连续单引号识别为单引号字符。
QUOTE_LITERAL ( string )
string-expressionstring-expression在下例中，第一个查询没有返回 Cher 或 Sting 的名字；第二个查询使用 QUOTE_LITERAL，通过单引号设置字符串值，包括空字符串。在这种情况下，Sting 的 fname 设置为空字符串 ('')，而 Cher 的 fname 为空，表示设置为 NULL 值：
=> SELECT * FROM lead_vocalists ORDER BY lname ASC;
fname | lname | band
--------+---------+-------------------------------------------------
| Cher | ["Sonny and Cher"]
Mick | Jagger | ["Rolling Stones"]
Diana | Ross | ["Supremes"]
Grace | Slick | ["Jefferson Airplane","Jefferson Starship"]
| Sting | ["Police"]
Stevie | Winwood | ["Spencer Davis Group","Traffic","Blind Faith"]
(6 rows)
=> SELECT QUOTE_LITERAL (fname) "First Name", QUOTE_NULLABLE (lname) "Last Name", band FROM lead_vocalists ORDER BY lname ASC;
First Name | Last Name | band
------------+-----------+-------------------------------------------------
| 'Cher' | ["Sonny and Cher"]
'Mick' | 'Jagger' | ["Rolling Stones"]
'Diana' | 'Ross' | ["Supremes"]
'Grace' | 'Slick' | ["Jefferson Airplane","Jefferson Starship"]
'' | 'Sting' | ["Police"]
'Stevie' | 'Winwood' | ["Spencer Davis Group","Traffic","Blind Faith"]
(6 rows)
返回适当引用的给定字符串，用作 SQL 语句字符串中的字符串字面量；或者，如果实参为 NULL，则返回不带引号的字符串 NULL。嵌入的单引号和反斜杠将会适当加倍。
QUOTE_NULLABLE ( string-expression )
string-expressionNULL。
=======string-expressionNULL。以下示例使用表 lead_vocalists，其中 Cher 和 Sting 的名字 (fname) 分别设置为 NULL 和空字符串。
=> SELECT * from lead_vocalists ORDER BY lname DESC;
fname | lname | band
--------+---------+-------------------------------------------------
Stevie | Winwood | ["Spencer Davis Group","Traffic","Blind Faith"]
| Sting | ["Police"]
Grace | Slick | ["Jefferson Airplane","Jefferson Starship"]
Diana | Ross | ["Supremes"]
Mick | Jagger | ["Rolling Stones"]
| Cher | ["Sonny and Cher"]
(6 rows)
=> SELECT * FROM lead_vocalists WHERE fname IS NULL;
fname | lname | band
-------+-------+--------------------
| Cher | ["Sonny and Cher"]
(1 row)
=> SELECT * FROM lead_vocalists WHERE fname = '';
fname | lname | band
-------+-------+------------
| Sting | ["Police"]
(1 row)
以下查询使用 QUOTE_NULLABLE。与 QUOTE_LITERAL 类似，QUOTE_NULLABLE 使用单引号设置字符串值，包括空字符串。与 QUOTE_LITERAL 不同，QUOTE_NULLABLE 对 NULL 值输出 NULL：
=> SELECT QUOTE_NULLABLE (fname) "First Name", QUOTE_NULLABLE (lname) "Last Name", band FROM lead_vocalists ORDER BY fname DESC;
First Name | Last Name | band
------------+-----------+-------------------------------------------------
NULL | 'Cher' | ["Sonny and Cher"]
'Stevie' | 'Winwood' | ["Spencer Davis Group","Traffic","Blind Faith"]
'Mick' | 'Jagger' | ["Rolling Stones"]
'Grace' | 'Slick' | ["Jefferson Airplane","Jefferson Starship"]
'Diana' | 'Ross' | ["Supremes"]
'' | 'Sting' | ["Police"]
(6 rows)
将字符串复制指定次数并连接复制的值作为单个字符串。返回值采用字符串实参的数据类型。非 LONG 数据类型和 LONG 数据类型的返回值的长度分别最多可达 65000 和 32000000 字节。如果
string * count 的长度超出这些限制，Vertica 将静默截断结果。
REPEAT ( 'string', count )
CHAR
VARCHAR
BINARY
VARBINARY
LONG VARCHAR
LONG VARBINARY
以下示例将重复 vmart 三次：
=> SELECT REPEAT ('vmart', 3);
REPEAT
-----------------
vmartvmartvmart
(1 row)
将字符串中的所有字符实例替换为另一组字符。
REPLACE ('string', 'target', 'replacement' )
replacement=> SELECT REPLACE('Documentation%20Library', '%20', ' ');
REPLACE
-----------------------
Documentation Library
(1 row)
=> SELECT REPLACE('This & That', '&', 'and');
REPLACE
---------------
This and That
(1 row)
=> SELECT REPLACE('straße', 'ß', 'ss');
REPLACE
---------
strasse
(1 row)
从字符串右侧返回指定的字符。
RIGHT ( string‑expr, length )
以下查询将返回字符串 "vertica" 的最后三个字符：
=> SELECT RIGHT('vertica', 3);
RIGHT
-------
ica
(1 row)
以下查询从表 store.store_orders_fact 查询日期列 date_ordered。将日期强制转换为字符串并从每个字符串提取最后五个字符。然后，返回所有不同的字符串：
SELECT DISTINCT(
RIGHT(date_ordered::varchar, 5)) MonthDays
FROM store.store_orders_fact ORDER BY MonthDays;
MonthDays
-----------
01-01
01-02
01-03
01-04
01-05
01-06
01-07
01-08
01-09
01-10
02-01
02-02
02-03
...
11-08
11-09
11-10
12-01
12-02
12-03
12-04
12-05
12-06
12-07
12-08
12-09
12-10
(120 rows)
返回一个 VARCHAR 值，表示在右侧填充了特定字符的特定长度的字符串。
RPAD ( expression , length [ , fill ] )
expressionlengthfill=> SELECT RPAD('database', 15, 'xzy');
RPAD
-----------------
databasexzyxzyx
(1 row)
如果字符串大于指定长度，则在右侧截断：
=> SELECT RPAD('database', 6, 'xzy');
RPAD
--------
databa
(1 row)
返回 VARCHAR 值，表示已从右侧（末尾）移除尾随空格的字符串。
RTRIM ( expression [ , characters ] )
expressioncharacters=> SELECT RTRIM('trimzzzyyyyyyxxxxxxxx', 'xyz');
RTRIM
-------
trim
(1 row)
使用美国安全哈希算法 1 计算字符串的 SHA1 哈希。以十六进制 VARCHAR 字符串形式返回结果。
SHA1 ( string )
stringVARCHAR 或 VARBINARY 字符串。以下示例计算提供的字符串的 SHA1 哈希：
=> SELECT SHA1('123');
SHA1
------------------------------------------
40bd001563085fc35165329ea1ff5c5ecbdbbeef
(1 row)
=> SELECT SHA1('Vertica'::bytea);
SHA1
------------------------------------------
ee2cff8d3444995c6c301546c4fc5ee152d77c11
(1 row)
使用美国安全哈希算法 2 计算字符串的 SHA224 哈希。以十六进制 VARCHAR 字符串形式返回结果。
SHA224 ( string )
stringVARCHAR 或 VARBINARY 字符串。以下示例计算提供的字符串的 SHA224 哈希：
=> SELECT SHA224('abc');
SHA224
----------------------------------------------------------
78d8045d684abd2eece923758f3cd781489df3a48e1278982466017f
(1 row)
=> SELECT SHA224('Vertica'::bytea);
SHA224
----------------------------------------------------------
135ac268f64ff3124aeeebc3cc0af0a29fd600a3be8e29ed97e45e25
(1 row)
=> SELECT sha224(''::varbinary) = 'd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f' AS "TRUE";
TRUE
------
t
(1 row)
使用美国安全哈希算法 2 计算字符串的 SHA256 哈希。以十六进制 VARCHAR 字符串形式返回结果。
SHA256 ( string )
stringVARCHAR 或 VARBINARY 字符串。以下示例计算提供的字符串的 SHA256 哈希：
=> SELECT SHA256('abc');
SHA256
------------------------------------------------------------------
a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3
(1 row)
=> SELECT SHA256('Vertica'::bytea);
SHA256
------------------------------------------------------------------
9981b0b7df9f5be06e9e1a7f4ae2336a7868d9ab522b9a6ca6a87cd9ed95ba53
(1 row)
=> SELECT sha256('') = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855' AS "TRUE";
TRUE
------
t
(1 row)
使用美国安全哈希算法 2 计算字符串的 SHA384 哈希。以十六进制 VARCHAR 字符串形式返回结果。
SHA384 ( string )
stringVARCHAR 或 VARBINARY 字符串。以下示例计算提供的字符串的 SHA384 哈希：
=> SELECT SHA384('123');
SHA384
--------------------------------------------------------------------------------------------------
9a0a82f0c0cf31470d7affede3406cc9aa8410671520b727044eda15b4c25532a9b5cd8aaf9cec4919d76255b6bfb00f
(1 row)
=> SELECT SHA384('Vertica'::bytea);
SHA384
--------------------------------------------------------------------------------------------------
3431a717dc3289862bbd636a064d26980b47ebe4684b800cff4756f0c24985866ef97763eafd548fedb0ce28722c96bb
(1 row)
使用美国安全哈希算法 2 计算字符串的 SHA512 哈希。以十六进制 VARCHAR 字符串形式返回结果。
SHA512 ( string )
stringVARCHAR 或 VARBINARY 字符串。以下示例计算提供的字符串的 SHA512 哈希：
=> SELECT SHA512('123');
SHA512
----------------------------------------------------------------------------------------------------------------------------------
3c9909afec25354d551dae21590bb26e38d53f2173b8d3dc3eee4c047e7ab1c1eb8b85103e3be7ba613b31bb5c9c36214dc9f14a42fd7a2fdb84856bca5c44c2
(1 row)
=> SELECT SHA512('Vertica'::bytea);
SHA512
----------------------------------------------------------------------------------------------------------------------------------
c4ee2b2d17759226a3897c9c30d7c6df1145c4582849bb5191ee140bce05b83d3d869890cc3619b534fea6f97ff28a739d8b568a5ade66e756b3243ef97d3f00
(1 row)
接受一个 VARCHAR 实参并返回一个四字符代码，该代码可以将该实参与其他 SOUNDEX 编码的字符串进行比较，这些字符串的英语拼写不同，但在语音上相似。SOUNDEX 实施由 Robert C. Russell 和 Margaret King Odell 开发的算法，并在 计算机编程艺术（第 3 卷）中进行了介绍。
SOUNDEX ( string-expression )
Vertica 使用以下 Soundex 编码算法，该算法符合大多数 SQL 实施策略：
保存第一个字母。将所有出现的 a、e、i、o、u、y、h、w 映射到零 (0)。
使用数字替换所有辅音字母（包括第一个字母）：
b、f、p、v → 1
c、g、j、k、q、s、x、z → 2
d、t → 3
l → 4
m、n → 5
r → 6
使用一位数字替换所有相邻的相同数字，然后移除所有零 (0) 数字
如果保存的字母的数字与生成的第一个数字相同，则移除数字（保留字母）。
如果结果包含的数字少于 3 个，则附加 3 个零。移除除第一个字母及其后面 3 个数字以外的所有内容。
在 employee_dimension 表中查找与 Lee 发音相似的姓氏：
SELECT employee_last_name, employee_first_name, employee_state
FROM public.employee_dimension
WHERE SOUNDEX(employee_last_name) = SOUNDEX('Lee')
ORDER BY employee_state, employee_last_name, employee_first_name;
Lea | James | AZ
Li | Sam | AZ
Lee | Darlene | CA
Lee | Juanita | CA
Li | Amy | CA
Li | Barbara | CA
Li | Ben | CA
...
比较两个字符串的 Soundex 编码。然后，函数返回整数，以相同的顺序表示匹配字符的数量。返回值为 0 到 4（包含），其中 0 表示不匹配，4 表示完全匹配。
有关 Vertica 如何实施 Soundex 编码的详细信息，请参阅 Soundex 编码算法。
SOUNDEX_MATCHES ( string-expression1, string-expression2 )
string-expression1, string-expression2确定两个字符串的 Soundex 编码匹配程度：
比较 Lewis 与 Li 的 Soundex 编码：
> SELECT SOUNDEX_MATCHES('Lewis', 'Li');
SOUNDEX_MATCHES
-----------------
3
(1 row)
比较 Lee 与 Li 的 Soundex 编码：
=> SELECT SOUNDEX_MATCHES('Lee', 'Li');
SOUNDEX_MATCHES
-----------------
4
(1 row)
在 employee_dimension 表中查找其 Soundex 编码与 Lewis 编码中至少 3 个字符匹配的姓氏：
=> SELECT DISTINCT(employee_last_name)
FROM public.employee_dimension
WHERE SOUNDEX_MATCHES (employee_last_name, 'Lewis' ) >= 3 ORDER BY employee_last_name;
employee_last_name
--------------------
Lea
Lee
Leigh
Lewis
Li
Reyes
(6 rows)
返回指定数量的空格，通常用于插入字符串。
SPACE(n)
以下示例连接字符串 x 和 y 并在二者之间插入 10 个空格：
=> SELECT 'x' || SPACE(10) || 'y' AS Ten_spaces;
Ten_spaces
--------------
x y
(1 row)
使用分隔符拆分字符串，并返回指定字段开头位置的字符串（从 1 开始计数）。
SPLIT_PART ( string , delimiter , field )
stringdelimiterfield将其用于子字段的字符形式。
指定整数 2 返回第二个字符串或 def。
=> SELECT SPLIT_PART('abc~@~def~@~ghi', '~@~', 2);
SPLIT_PART
------------
def
(1 row)
在下一个示例中，指定 3，返回第三个字符串或 789。
=> SELECT SPLIT_PART('123~|~456~|~789', '~|~', 3);
SPLIT_PART
------------
789
(1 row)
波形符仅用于可读性。如果省略，则返回相同结果：
=> SELECT SPLIT_PART('123|456|789', '|', 3);
SPLIT_PART
------------
789
(1 row)
看看如果指定超出字符串数目的整数，会发生什么：结果不是 NULL，而是空字符串。
=> SELECT SPLIT_PART('123|456|789', '|', 4);
SPLIT_PART
------------
(1 row)
=> SELECT SPLIT_PART('123|456|789', '|', 4) IS NULL;
?column?
----------
f
(1 row)
如果 SPLIT_PART 返回 NULL，则 LENGTH 也应返回 0。
=> SELECT LENGTH (SPLIT_PART('123|456|789', '|', 4));
LENGTH
--------
0
(1 row)
如果数据库的区域设置为 BINARY，则 SPLIT_PART 调用 SPLIT_PARTB：
=> SHOW LOCALE;
name | setting
--------+--------------------------------------
locale | en_US@collation=binary (LEN_KBINARY)
(1 row)
=> SELECT SPLIT_PART('123456789', '5', 1);
split_partb
-------------
1234
(1 row)
=> SET LOCALE TO 'en_US@collation=standard';
INFO 2567: Canonical locale: 'en_US@collation=standard'
Standard collation: 'LEN'
English (United States, collation=standard)
SET
=> SELECT SPLIT_PART('123456789', '5', 1);
split_part
------------
1234
(1 row)
以分隔符字符分割输入字符串并返回第 N 个分段，从 1 开始计数。VARCHAR 实参视为八位字节，而不是 UTF-8 字符。
SPLIT_PARTB ( string, delimiter, part-number)
以下示例返回其输入的第三部分：
=> SELECT SPLIT_PARTB('straße~@~café~@~soupçon', '~@~', 3);
SPLIT_PARTB
-------------
soupçon
(1 row)
波形符仅用于可读性。如果省略，则返回相同结果：
=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 3);
SPLIT_PARTB
-------------
soupçon
(1 row)
如果请求的部分编号大于部分总数，则函数返回空字符串：
=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 4);
SPLIT_PARTB
-------------
(1 row)
=> SELECT SPLIT_PARTB('straße @ café @ soupçon', '@', 4) IS NULL;
?column?
----------
f
(1 row)
如果数据库的区域设置为 BINARY，则 SPLIT_PART 调用 SPLIT_PARTB：
=> SHOW LOCALE;
name | setting
--------+--------------------------------------
locale | en_US@collation=binary (LEN_KBINARY)
(1 row)
=> SELECT SPLIT_PART('123456789', '5', 1);
split_partb
-------------
1234
(1 row)
=> SET LOCALE TO 'en_US@collation=standard';
INFO 2567: Canonical locale: 'en_US@collation=standard'
Standard collation: 'LEN'
English (United States, collation=standard)
SET
=> SELECT SPLIT_PART('123456789', '5', 1);
split_part
------------
1234
(1 row)
返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数）。如果未找到子字符串，则 STRPOS 返回 0。
STRPOS 类似于 POSITION；但 POSITION 允许按字符和八位字节查找。
STRPOS ( string‑expression , substring )
=> SELECT ship_type, shipping_key, strpos (ship_type, 'DAY') FROM shipping_dimension WHERE strpos > 0 ORDER BY ship_type, shipping_key;
ship_type | shipping_key | strpos
--------------------------------+--------------+--------
NEXT DAY | 1 | 6
NEXT DAY | 13 | 6
NEXT DAY | 19 | 6
NEXT DAY | 22 | 6
NEXT DAY | 26 | 6
NEXT DAY | 30 | 6
NEXT DAY | 34 | 6
NEXT DAY | 38 | 6
NEXT DAY | 45 | 6
NEXT DAY | 51 | 6
NEXT DAY | 67 | 6
NEXT DAY | 69 | 6
NEXT DAY | 80 | 6
NEXT DAY | 90 | 6
NEXT DAY | 96 | 6
NEXT DAY | 98 | 6
TWO DAY | 9 | 5
TWO DAY | 21 | 5
TWO DAY | 28 | 5
TWO DAY | 32 | 5
TWO DAY | 40 | 5
TWO DAY | 43 | 5
TWO DAY | 49 | 5
TWO DAY | 50 | 5
TWO DAY | 52 | 5
TWO DAY | 53 | 5
TWO DAY | 61 | 5
TWO DAY | 73 | 5
TWO DAY | 81 | 5
TWO DAY | 83 | 5
TWO DAY | 84 | 5
TWO DAY | 85 | 5
TWO DAY | 94 | 5
TWO DAY | 100 | 5
(34 rows)
返回一个 INTEGER 值，该值表示指定子字符串在字符串中的位置（从 1 开始计数），其中字符串中的每个八位字节也被计算在内（与字符相反）。
STRPOSB ( string , substring )
stringsubstring除实参顺序以外，STRPOSB 与 POSITIONB 相同。
=> SELECT STRPOSB('straße', 'e');
STRPOSB
---------
7
(1 row)
=> SELECT STRPOSB('étudiant', 'tud');
STRPOSB
---------
3
(1 row)
返回 VARCHAR 或 VARBINARY 值，表示指定字符串的子字符串。
SUBSTR ( string , position [ , extent ] )
stringpositionextentSUBSTR 可以截断 DOUBLE PRECISION 输入值。
=> SELECT SUBSTR('abc'::binary(3),1);
substr
--------
abc
(1 row)
=> SELECT SUBSTR('123456789', 3, 2);
substr
--------
34
(1 row)
=> SELECT SUBSTR('123456789', 3);
substr
---------
3456789
(1 row)
=> SELECT SUBSTR(TO_BITSTRING(HEX_TO_BINARY('0x10')), 2, 2);
substr
--------
00
(1 row)
=> SELECT SUBSTR(TO_HEX(10010), 2, 2);
substr
--------
71
(1 row)
返回一个八位字节值，表示指定字符串的子字符串。
SUBSTRB ( string , position [ , extent ] )
stringpositionextent此函数将多字节字符形式字符串视为八位字节，并且使用八位字节数字作为传入和传出位置说明符与长度。字符串本身为 VARCHAR 类型，但视为每个八位字节都是单独字符。
SUBSTRB 可以截断 DOUBLE PRECISION 输入值。
=> SELECT SUBSTRB('soupçon', 5);
SUBSTRB
---------
çon
(1 row)
=> SELECT SUBSTRB('soupçon', 5, 2);
SUBSTRB
---------
ç
(1 row)
如果使用 BINARY/VARBINARY，Vertica 返回以下错误消息：
=>SELECT SUBSTRB('abc'::binary(3),1);
ERROR: function substrb(binary, int) does not exist, or permission is denied for substrb(binary, int)
HINT: No function matches the given name and argument types. You may need to add explicit type casts.
给定值、位置和可选长度的条件下，返回表示指定字符串在给定位置的子字符串的值。SUBSTRING 可以截断 DOUBLE PRECISION 输入值。
SUBSTRING ( string, position[, length ]
[USING {CHARACTERS | OCTETS } ] )
SUBSTRING ( string FROM position [ FOR length ]
[USING { CHARACTERS | OCTETS } ] )
USING CHARACTERS | OCTETS => SELECT SUBSTRING('abc'::binary(3),1);
substring
-----------
abc
(1 row)
=> SELECT SUBSTRING('soupçon', 5, 2 USING CHARACTERS);
substring
-----------
ço
(1 row)
=> SELECT SUBSTRING('soupçon', 5, 2 USING OCTETS);
substring
-----------
ç
(1 row)
如果使用负数位置，则函数从不存在的位置开始。在此示例中，这表示从位置 -4 开始计数 8 个字符。因此，函数从空位置 -4 开始，并且计五个字符，包括同样为空的 0 位置。这将返回三个字符。
=> SELECT SUBSTRING('1234567890', -4, 8);
substring
-----------
123
(1 row)
将 string_to_replace 中的单个字符替换为其他字符。
TRANSLATE ( string_to_replace , from_string , to_string );
string_to_replacefrom_stringto_string=> SELECT TRANSLATE('straße', 'ß', 'ss');
TRANSLATE
-----------
strase
(1 row)
将 BTRIM、LTRIM 和 RTRIM 函数合并为单个函数。
TRIM ( [ [ LEADING | TRAILING | BOTH ] characters FROM ] expression )
LEADINGTRAILINGBOTHcharactersexpression=> SELECT '-' || TRIM(LEADING 'x' FROM 'xxdatabasexx') || '-';
?column?
--------------
-databasexx-
(1 row)
=> SELECT '-' || TRIM(TRAILING 'x' FROM 'xxdatabasexx') || '-';
?column?
--------------
-xxdatabase-
(1 row)
=> SELECT '-' || TRIM(BOTH 'x' FROM 'xxdatabasexx') || '-';
?column?
------------
-database-
(1 row)
=> SELECT '-' || TRIM('x' FROM 'xxdatabasexx') || '-';
?column?
------------
-database-
(1 row)
=> SELECT '-' || TRIM(LEADING FROM ' database ') || '-';
?column?
--------------
-database -
(1 row)
=> SELECT '-' || TRIM(' database ') || '-'; ?column?
------------
-database-
(1 row)
返回 VARCHAR 值，其中包含被转换为大写字母的实参。
自 5.1 版本开始，此函数将 string 实参视为 UTF-8 编码字符串，而不是根据区域设置的排序规则设置（例如 collation=binary）来识别编码。
UPPER ( expression )
expressionUPPER 限定为 32500 个八位字节输入，因为以 UTF-8 表示的结果大小可能会翻倍。
=> SELECT UPPER('AbCdEfG');
UPPER
----------
ABCDEFG
(1 row)
=> SELECT UPPER('étudiant');
UPPER
----------
ÉTUDIANT
(1 row)
返回一个字符串，其中所有 ASCII 字符都转换为大写。多字节字符不会转换，而是跳过。
UPPERB ( expression )
expression在下例中，多字节 UTF-8 字符 é 未转换为大写：
=> SELECT UPPERB('étudiant');
UPPERB
----------
éTUDIANT
(1 row)
=> SELECT UPPERB('AbCdEfG');
UPPERB
---------
ABCDEFG
(1 row)
=> SELECT UPPERB('The Vertica Database');
UPPERB
----------------------
THE VERTICA DATABASE
(1 row)
此部分的函数遵循 RFC 3986 标准，用于对统一资源标识符 (URI) 进行百分比编码。
根据 RFC 3986 标准，对百分比编码的通用资源标识符 (URI) 进行解码。
URI_PERCENT_DECODE (expression)
expression以下示例在 URI 表的 Websites 列上调用 uri_percent_decode 并返回解码 URI：
=> SELECT URI_PERCENT_DECODE(Websites) from URI;
URI_PERCENT_DECODE
-----------------------------------------------
http://www.faqs.org/rfcs/rfc3986.html x xj%a%
(1 row)
以下示例返回“网站 (Websites)”列中的原始 URI 及其解码版本：
=> SELECT Websites, URI_PERCENT_DECODE (Websites) from URI;
Websites | URI_PERCENT_DECODE
---------------------------------------------------+---------------------------------------------
http://www.faqs.org/rfcs/rfc3986.html+x%20x%6a%a% | http://www.faqs.org/rfcs/rfc3986.html x xj%a%
(1 row)
根据百分比编码的 RFC 3986 标准，对通用资源标识符 (URI) 进行编码。为与旧版编码器兼容，此函数将 + 转换为空格；将空格转换为 %20。
URI_PERCENT_ENCODE (expression)
expression以下示例显示了如何在 URI 表的“网站 (Websites)”列上调用 uri_percent_encode 函数并返回编码 URI：
=> SELECT URI_PERCENT_ENCODE(Websites) from URI;
URI_PERCENT_ENCODE
------------------------------------------
http%3A%2F%2Fexample.com%2F%3F%3D11%2F15
(1 row)
以下示例返回“网站 (Websites)”列中的原始 URI 及其编码形式：
=> SELECT Websites, URI_PERCENT_ENCODE(Websites) from URI; Websites | URI_PERCENT_ENCODE
----------------------------+------------------------------------------
http://example.com/?=11/15 | http%3A%2F%2Fexample.com%2F%3F%3D11%2F15
(1 row)
目前，Vertica 提供了一个函数来支持 UUID 数据类型
UUID_GENERATE。
返回新的通用唯一标识符 (UUID)，该标识符基于 /dev/urandom 的高质量随机功能生成。
UUID_GENERATE()
=> CREATE TABLE Customers(
cust_id UUID DEFAULT UUID_GENERATE(),
lname VARCHAR(36),
fname VARCHAR(24));
CREATE TABLE
=> INSERT INTO Customers VALUES (DEFAULT, 'Kearney', 'Thomas');
OUTPUT
--------
1
(1 row)
=> COPY Customers (lname, fname) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Pham|Duc
>> Garcia|Mary
>> \.
=> SELECT * FROM Customers;
cust_id | lname | fname
--------------------------------------+---------+--------
03fe0794-ac5d-42d4-8246-54f7ec81ed0c | Pham | Duc
6950313d-c77e-4c11-a86e-0a54aa3ec114 | Kearney | Thomas
9c9653ce-c2e4-4441-b0f7-0137b54cc28c | Garcia | Mary
(3 rows)
Database Designer 函数通常按以下顺序执行以下操作：
有关详细信息，请参阅 以编程方式运行 Database Designer 的工作流程。有关所需权限的信息，请参阅 运行 Database Designer 函数的权限
DESIGNER_CREATE_DESIGN 指示 Database Designer 创建设计。
以下函数可让您指定设计属性：
DESIGNER_SET_DESIGN_TYPE：指定设计是全面设计，还是增量设计。
DESIGNER_DESIGN_PROJECTION_ENCODINGS：在指定投影中分析编码，并创建用于实施编码建议的脚本。
DESIGNER_SET_DESIGN_KSAFETY：为全面设计设置 K-safety 值。
DESIGNER_SET_OPTIMIZATION_OBJECTIVE：指定是否针对查询或加载性能优化设计。
DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS：允许设计中包含未分段的投影。
以下函数可用来向 Database Designer 设计中添加表和查询：
DESIGNER_ADD_DESIGN_TABLES：将指定表添加到设计中。
DESIGNER_ADD_DESIGN_QUERY、DESIGNER_ADD_DESIGN_QUERIES、DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS：将查询添加到设计并对其加权。
以下函数将填充 Database Designer 工作区，并创建设计和部署脚本。您还可以分析统计信息，自动部署设计，以及在部署之后删除工作区：
DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY：填充设计并创建设计和部署脚本。
DESIGNER_WAIT_FOR_DESIGN：等待当前正在运行的设计完成。
DESIGNER_RESET_DESIGN 会丢弃上一次 Database Designer 构建或部署的指定设计的所有运行特定信息，但会保留其配置。
下列函数将显示有关 Database Designer 所创建的投影和脚本的信息：
DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS：发送到用于定义设计投影的标准输出 DDL 语句。
DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT：将设计的部署脚本发送到标准输出。
以下函数将取消任何正在运行的 Database Designer 操作或者删除 Database Designer 设计及其所有内容：
DESIGNER_CANCEL_POPULATE_DESIGN：如果指定设计当前正在运行，取消对指定设计的填充和部署操作。
DESIGNER_DROP_DESIGN：移除与指定设计及其所有内容相关联的架构。
DESIGNER_DROP_ALL_DESIGNS：移除所有与当前用户关联的 Database Designer 相关的架构。
读取并评估某个输入文件中的查询，并将其接受的查询添加到指定设计中。所有接受的查询均分配了权重 1。
需要满足以下要求：
所有查询的表都必须预先添加到包含 DESIGNER_ADD_DESIGN_TABLES 的设计中。
如果设计类型为增量类型，Database Designer 将仅读取输入文件中的前 100 个查询，并忽略该数量以外的所有查询。
所有接受的查询都必须添加到系统表 DESIGN_QUERIES 中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_ADD_DESIGN_QUERIES ( 'design‑name', 'queries‑file' [, return‑results] )
已接受的查询数
引用非设计表的查询数
不受支持的查询数
非法查询数
非超级用户：设计创作者 具有执行 input‑file 中的查询所需的所有权限。
在以下情况下 Database Designer 会返回错误：
查询包含非法语法。
查询参考：
仅限外部或系统表
本地临时表或其他非设计表
DELETE 或 UPDATE 包含一个或多个子查询。
INSERT 查询不包含 SELECT 子句的。
Database Designer 无法优化查询。
以下示例将来自 vmart_queries.sql 的查询添加到 VMART_DESIGN 设计中。该文件包含九个查询。该语句包含第三个实参 true，因此 Database Designer 将返回添加操作的结果：
=> SELECT DESIGNER_ADD_DESIGN_QUERIES ('VMART_DESIGN', '/tmp/examples/vmart_queries.sql', 'true');
...
DESIGNER_ADD_DESIGN_QUERIES
----------------------------------------------------
Number of accepted queries =9
Number of queries referencing non-design tables =0
Number of unsupported queries =0
Number of illegal queries =0
(1 row)
执行指定的查询并计算以下列中的结果：
QUERY_TEXT （必需）：潜在设计查询的文本。
QUERY_WEIGHT （可选）：分配给每个查询的权重，表示其相对于其他查询的重要性，为大于 0 且小于等于 1 的实数。Database Designer 在创建设计时使用此设置来确定查询的优先级。如果 DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS 返回任何忽略此值的结果，Database Designer 会将其权重设置为 1。
评估 QUERY_TEXT 中的查询之后，DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS 会将所有接受的查询添加到设计中。可以在设计中添加无数查询。
将查询添加到设计中之前，必须使用
DESIGNER_ADD_DESIGN_TABLES 添加查询表。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS ( 'design‑name', 'query' )
QUERY_TEXT 和 QUERY_WEIGHT 列（可选）的有效 SQL 查询。非超级用户：设计创作者 具有执行指定查询以及此函数返回的所有查询所需的所有权限
在以下情况下 Database Designer 会返回错误：
查询包含非法语法。
查询参考：
仅限外部或系统表
本地临时表或其他非设计表
DELETE 或 UPDATE 包含一个或多个子查询。
INSERT 查询不包含 SELECT 子句的。
Database Designer 无法优化查询。
以下示例将查询系统表
QUERY_REQUESTS 以获取所有运行时间较长（大于 100 万微秒）的查询，并将其添加到 VMART_DESIGN 设计中。该查询不返回有关查询权重的信息，因此为所有查询分配了权重 1：
=> SELECT DESIGNER_ADD_DESIGN_QUERIES_FROM_RESULTS ('VMART_DESIGN',
'SELECT request as query_text FROM query_requests where request_duration_ms > 1000000 AND request_type =
''QUERY'';');
读取和解析指定的查询，如果已接受，将其添加到设计。将查询添加到设计中之前，必须使用
DESIGNER_ADD_DESIGN_TABLES 添加查询表。
所有接受的查询均添加到系统表
DESIGN_QUERIES 中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_ADD_DESIGN_QUERY ( 'design‑name', 'design‑query' [, query‑weight] )
如果忽略此参数，Database Designer 将分配权重 1。
非超级用户：设计创作者 具有执行指定查询所需的所有权限
在以下情况下 Database Designer 会返回错误：
查询包含非法语法。
查询参考：
仅限外部或系统表
本地临时表或其他非设计表
DELETE 或 UPDATE 包含一个或多个子查询。
INSERT 查询不包含 SELECT 子句的。
Database Designer 无法优化查询。
以下示例将指定的查询添加到 VMART_DESIGN 设计中，并为该查询分配 0.5 的权重：
=> SELECT DESIGNER_ADD_DESIGN_QUERY (
'VMART_DESIGN',
'SELECT customer_name, customer_type FROM customer_dimension ORDER BY customer_name ASC;', 0.5
);
将指定表添加到设计中。将设计查询添加到设计中之前，必须先运行 DESIGNER_ADD_DESIGN_TABLES。如果未向设计中添加表，Vertica 将不接受设计查询。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_ADD_DESIGN_TABLES ( 'design‑name', '[ table‑spec[,...] ]' [, 'analyze‑statistics'] )
table‑spec[,...]
[schema.]table
将 table 添加到设计中。
schema.*
添加 schema 中的所有表。
如果设置为空字符串，Vertica 会添加用户有权访问的数据库中的所有表。
ANALYZE_STATISTICS，默认设置为 false。
准确的统计信息可帮助 Database Designer 优化压缩和查询性能。更新统计信息需要花费时间和资源。
非超级用户：设计创作者 具有设计表架构的 USAGE 权限，且是设计表的所有者
以下示例将架构 online_sales 和 store 中的所有表添加到设计 VMART_DESIGN 中，并分析这些表的统计信息：
=> SELECT DESIGNER_ADD_DESIGN_TABLES('VMART_DESIGN', 'online_sales.*, store.*','true');
DESIGNER_ADD_DESIGN_TABLES
----------------------------
7
(1 row)
如果指定设计当前正在运行，取消对指定设计的填充和部署操作。取消部署时，Database Designer 将取消投影刷新操作。不会回退已部署或已刷新的投影。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_CANCEL_POPULATE_DESIGN ( 'design‑name' )
以下示例取消了 VMART_DESIGN 当前正在运行的设计，然后删除该设计：
=> SELECT DESIGNER_CANCEL_POPULATE_DESIGN ('VMART_DESIGN');
=> SELECT DESIGNER_DROP_DESIGN ('VMART_DESIGN', 'true');
使用指定名称创建设计。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_CREATE_DESIGN ( 'design‑name' )
两个用户不能同时拥有名称相同的设计。
超级用户
对 design-name 的存储位置具有 WRITE 权限的 DBDUSER。
如果以前的设计中不存在以下任何
V_MONITOR 表，则 DESIGNER_CREATE_DESIGN 会创建它们：
DESIGNS
DESIGN_TABLES
DEPLOYMENT_PROJECTIONS
DEPLOYMENT_PROJECTION_STATEMENTS
DESIGN_QUERIES
OUTPUT_DEPLOYMENT_STATUS
OUTPUT_EVENT_HISTORY
以下示例创建了设计 VMART_DESIGN：
=> SELECT DESIGNER_CREATE_DESIGN('VMART_DESIGN');
DESIGNER_CREATE_DESIGN
------------------------
0
(1 row)
在指定投影中分析编码，创建脚本以实施编码建议并选择性地部署建议。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_DESIGN_PROJECTION_ENCODINGS ( '[ proj‑spec[,... ] ]', '[destination]' [, 'deploy'] [, 'reanalyze-encodings'] )
proj‑spec[,...]
[[schema.]table.]projection
指定分析 projection。
schema.*
指定分析命名架构中的所有投影。
[schema.]table
指定分析命名表的所有投影。
如果设置为空字符串，Vertica 会分析数据库中用户有权访问的所有投影。
例如，以下语句指定分析架构 private 中的所有投影，并将结果发送到文件 encodings.sql：
=> SELECT DESIGNER_DESIGN_PROJECTION_ENCODINGS ('mydb.private.*','encodings.sql');
空字符串 ('') 将脚本写入标准输出。
SQL 输出文件的路径名。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。
默认值：false
DESIGNER_DESIGN_PROJECTION_ENCODINGS 是否分析所有列都已编码的投影中的编码：
false：如果所有列都已编码，则不分析任何列并且不生成任何建议。
true：忽略现有编码并生成建议。
默认值：false
具有以下权限的超级用户或 DBDUSER：
要分析的所有投影的 OWNER
指定投影架构上的 USAGE 权限
以下示例要求 Database Designer 分析表 online_sales.call_center_dimension 的编码：
第二个参数 destination 设置为空字符串，因此脚本被发送到标准输出（如下截断所示）。
最后两个参数 deploy 和 reanalyze-encodings 被忽略，因此 Database Designer 不会执行脚本或重新分析现有编码：
=> SELECT DESIGNER_DESIGN_PROJECTION_ENCODINGS ('online_sales.call_center_dimension','');
DESIGNER_DESIGN_PROJECTION_ENCODINGS
----------------------------------------------------------------
CREATE PROJECTION call_center_dimension_DBD_1_seg_EncodingDesign /*+createtype(D)*/
(
call_center_key ENCODING COMMONDELTA_COMP,
cc_closed_date,
cc_open_date,
cc_name ENCODING ZSTD_HIGH_COMP,
cc_class ENCODING ZSTD_HIGH_COMP,
cc_employees,
cc_hours ENCODING ZSTD_HIGH_COMP,
cc_manager ENCODING ZSTD_HIGH_COMP,
cc_address ENCODING ZSTD_HIGH_COMP,
cc_city ENCODING ZSTD_COMP,
cc_state ENCODING ZSTD_FAST_COMP,
cc_region ENCODING ZSTD_HIGH_COMP
)
AS
SELECT call_center_dimension.call_center_key,
call_center_dimension.cc_closed_date,
call_center_dimension.cc_open_date,
call_center_dimension.cc_name,
call_center_dimension.cc_class,
call_center_dimension.cc_employees,
call_center_dimension.cc_hours,
call_center_dimension.cc_manager,
call_center_dimension.cc_address,
call_center_dimension.cc_city,
call_center_dimension.cc_state,
call_center_dimension.cc_region
FROM online_sales.call_center_dimension
ORDER BY call_center_dimension.call_center_key
SEGMENTED BY hash(call_center_dimension.call_center_key) ALL NODES KSAFE 1;
select refresh('online_sales.call_center_dimension');
select make_ahm_now();
DROP PROJECTION online_sales.call_center_dimension CASCADE;
ALTER PROJECTION online_sales.call_center_dimension_DBD_1_seg_EncodingDesign RENAME TO call_center_dimension;
(1 row)
移除所有与当前用户关联的 Database Designer 相关的架构。在一个或多个 Database Designer 会话完成执行后，使用此函数移除数据库对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_DROP_ALL_DESIGNS()
无。
以下示例将移除所有架构以及和当前用户相关的内容。 DESIGNER_DROP_ALL_DESIGNS 返回已删除设计的数量：
=> SELECT DESIGNER_DROP_ALL_DESIGNS();
DESIGNER_DROP_ALL_DESIGNS
---------------------------
2
(1 row)
移除与指定设计及其所有内容相关联的架构。在 Database Designer 设计或部署成功完成后使用 DESIGNER_DROP_DESIGN。您还必须使用它来删除一个设计，然后再以相同的名称创建另一个设计。
要删除您创建的所有设计，请使用
DESIGNER_DROP_ALL_DESIGNS。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_DROP_DESIGN ( 'design‑name' [, force‑drop ] )
false。以下示例删除了 Database Designer 设计 VMART_DESIGN 及其所有内容：
=> SELECT DESIGNER_DROP_DESIGN ('VMART_DESIGN');
在标准输出中显示定义设计投影的 DDL 语句。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS ( 'design‑name' )
超级用户或 DBDUSER
以下示例返回了 vmart_design 的设计投射 DDL 语句：
=> SELECT DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS('vmart_design');
CREATE PROJECTION customer_dimension_DBD_1_rep_VMART_DESIGN /*+createtype(D)*/
(
customer_key ENCODING DELTAVAL,
customer_type ENCODING AUTO,
customer_name ENCODING AUTO,
customer_gender ENCODING REL,
title ENCODING AUTO,
household_id ENCODING DELTAVAL,
customer_address ENCODING AUTO,
customer_city ENCODING AUTO,
customer_state ENCODING AUTO,
customer_region ENCODING AUTO,
marital_status ENCODING AUTO,
customer_age ENCODING DELTAVAL,
number_of_children ENCODING BLOCKDICT_COMP,
annual_income ENCODING DELTARANGE_COMP,
occupation ENCODING AUTO,
largest_bill_amount ENCODING DELTAVAL,
store_membership_card ENCODING BLOCKDICT_COMP,
customer_since ENCODING DELTAVAL,
deal_stage ENCODING AUTO,
deal_size ENCODING DELTARANGE_COMP,
last_deal_update ENCODING DELTARANGE_COMP
)
AS
SELECT customer_key,
customer_type,
customer_name,
customer_gender,
title,
household_id,
customer_address,
customer_city,
customer_state,
customer_region,
marital_status,
customer_age,
number_of_children,
annual_income,
occupation,
largest_bill_amount,
store_membership_card,
customer_since,
deal_stage,
deal_size,
last_deal_update
FROM public.customer_dimension
ORDER BY customer_gender,
annual_income
UNSEGMENTED ALL NODES;
CREATE PROJECTION product_dimension_DBD_2_rep_VMART_DESIGN /*+createtype(D)*/
(
...
DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT
在标准输出中显示指定设计的部署脚本。如果设计已部署，Vertica 将忽略此函数。
要在设计脚本中仅输出 CREATE PROJECTION 命令，请使用
DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT ( 'design‑name' )
以下示例显示了 VMART_DESIGN 的部署脚本：
=> SELECT DESIGNER_OUTPUT_DEPLOYMENT_SCRIPT('VMART_DESIGN');
CREATE PROJECTION customer_dimension_DBD_1_rep_VMART_DESIGN /*+createtype(D)*/
...
CREATE PROJECTION product_dimension_DBD_2_rep_VMART_DESIGN /*+createtype(D)*/
...
select refresh('public.customer_dimension,
public.product_dimension,
public.promotion.dimension,
public.date_dimension');
select make_ahm_now();
DROP PROJECTION public.customer_dimension_super CASCADE;
DROP PROJECTION public.product_dimension_super CASCADE;
...
DESIGNER_OUTPUT_ALL_DESIGN_PROJECTIONS
丢弃上一次 Database Designer 构建或部署的指定设计的所有运行特定信息，但会保留其配置。您可以根据需要对设计进行更改，例如，在重新运行设计之前更改参数或添加更多表和/或查询。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_RESET_DESIGN ( 'design‑name' )
以下示例重置了 Database Designer 设计 VMART_DESIGN：
=> SELECT DESIGNER_RESET_DESIGN ('VMART_DESIGN');
填充设计并创建设计和部署脚本。DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY 还可以分析统计信息，部署设计，以及在部署之后删除工作空间。
此函数输出的文件具有 666 或 rw-rw-rw- 权限，允许节点上的任何 Linux 用户对其进行读取或写入。强烈建议您将文件保存在安全的目录中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY (
'design‑name',
'output‑design‑file',
'output‑deployment‑file'
[ , 'analyze‑statistics']
[ , 'deploy']
[ , 'drop‑design‑workspace']
[ , 'continue‑after‑error']
)
默认值：false
默认值： true
默认值： true
默认值：false
非超级用户：设计创作者 对设计和部署脚本的存储位置具有 WRITE 权限
调用此函数之前，您必须：
创建设计或带表格的逻辑架构。
将表与设计相关联。
加载设计查询。
设置设计属性（K-安全级别、模式和策略）。
以下示例为 VMART_DESIGN 创建投射并部署该设计，同时分析有关设计表的统计信息。
=> SELECT DESIGNER_RUN_POPULATE_DESIGN_AND_DEPLOY (
'VMART_DESIGN',
'/tmp/examples/vmart_design_files/design_projections.sql',
'/tmp/examples/vmart_design_files/design_deploy.sql',
'true',
'true',
'false',
'false'
);
为全面设计设置 K-safety 并将 K-safety 值存储在
DESIGNS 表中。对于增量设计，Database Designer 会忽略此函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_SET_DESIGN_KSAFETY ( 'design‑name' [, k‑level ] )
k‑level = 0：≥ 1 个节点
k‑level = 1：≥ 3 个节点
k‑level = 2：≥ 5 个节点
如果忽略此参数，Vertica 会根据节点数将此设计的 K-safety 设置为 0 或 1：如果群集包含 ≥ 3 个节点，则为 1，否则为 0。
如果您是 DBADMIN 用户并且 k-level 与系统 K-safety 不同，Vertica 会按如下方式更改系统 K-safety：
如果 k-level 小于系统 K-safety，Vertica 会在部署设计后将系统 K-safety 更改为较低级别。
如果 k-level 大于系统 K-safety 并且对数据库群集有效，Vertica 会为此设计中的表创建所需数量的伙伴实例投影。如果设计适用于所有数据库表，或者数据库中的所有表都具有所需数量的伙伴实例投影，则 Database Designer 将系统 K-safety 更改为 k-level。
如果设计排除了一些数据库表并且它们的伙伴实例投影数量小于 k-level，Database Designer 将系统 K-safety 保持不变。它会返回警告并指出哪些表需要新的伙伴实例投影以调整系统 K-safety。
如果您是 DBDUSER，Vertica 会忽略此参数。
以下示例将 VMART_DESIGN 设计的 K-safety 设置为 1：
=> SELECT DESIGNER_SET_DESIGN_KSAFETY('VMART_DESIGN', 1);
指定 Database Designer 是创建全面设计还是增量设计。 DESIGNER_SET_DESIGN_TYPE 将设计模式存储在
DESIGNS 表中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_SET_DESIGN_TYPE ( 'design‑name', 'mode' )
COMPREHENSIVE：为指定架构中的所有表创建初始或替换设计。您通常为新数据库创建全面设计。
INCREMENTAL：使用针对新查询或修改后的查询进行优化的附加投影来修改现有设计。
有关详细信息，请参阅设计类型。
以下示例显示了 VMART_DESIGN 设计的两种设计模式选项：
=> SELECT DESIGNER_SET_DESIGN_TYPE(
'VMART_DESIGN',
'COMPREHENSIVE');
DESIGNER_SET_DESIGN_TYPE
--------------------------
0
(1 row)
=> SELECT DESIGNER_SET_DESIGN_TYPE(
'VMART_DESIGN',
'INCREMENTAL');
DESIGNER_SET_DESIGN_TYPE
--------------------------
0
(1 row)
仅对全面数据库设计有效，用于指定 Database Designer 使用的优化目标。对于增量设计，Database Designer 会忽略此函数。
DESIGNER_SET_OPTIMIZATION_OBJECTIVE 将优化目标存储在
DESIGNS 表中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_SET_OPTIMIZATION_OBJECTIVE ( 'design‑name', 'policy' )
QUERY：优化查询性能。此操作会导致数据库存储占用空间增大，因为可能会创建更多投影。
LOAD：优化加载性能，以便最大限度缩小数据库大小。此操作会导致查询性能下降。
BALANCED：平衡查询性能和数据库大小的设计。
以下示例将 VMART_DESIGN 设计的优化目标选项设置为 QUERY：
=> SELECT DESIGNER_SET_OPTIMIZATION_OBJECTIVE( 'VMART_DESIGN', 'QUERY');
DESIGNER_SET_OPTIMIZATION_OBJECTIVE
------------------------------------
0
(1 row)
指定设计是否可以包含未分段的投影。Vertica 在单节点群集上忽略此函数，其中所有投影都必须不分段。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS ( 'design‑name', unsegmented )
DESIGNS 中的 propose_unsegmented_projections 值设置为 true。如果 DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS 将此值设置为 false，则 Database Designer 仅建议分段的投影。以下示例指定 Database Designer 只能为设计 VMART_DESIGN 中的表建议分段的投影：
=> SELECT DESIGNER_SET_PROPOSE_UNSEGMENTED_PROJECTIONS('VMART_DESIGN', false);
评估在指定时间跨度内完成执行的所有查询，并返回可用于部署的设计。此设计包含建议用于优化评估查询的投影。除非您重定向输出，否则 DESIGNER_SINGLE_RUN 会将设计返回到 STDOUT。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_SINGLE_RUN ('interval')
超级用户或 DBUSER
-----------------------------------------------------------------------
-- SSBM dataset test
-----------------------------------------------------------------------
-- create ssbm schema
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_schema.sql' > /dev/null 2>&1
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_constraints.sql' > /dev/null 2>&1
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_funcdeps.sql' > /dev/null 2>&1
-- run these queries
\! $TARGET/bin/vsql -f 'sql/SSBM/SSBM_queries.sql' > /dev/null 2>&1
-- Run single API
select designer_single_run('1 minute');
...
designer_single_run
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
CREATE PROJECTION public.part_DBD_1_rep_SingleDesign /*+createtype(D)*/
(
p_partkey ENCODING AUTO,
p_name ENCODING AUTO,
p_mfgr ENCODING AUTO,
p_category ENCODING AUTO,
p_brand1 ENCODING AUTO,
p_color ENCODING AUTO,
p_type ENCODING AUTO,
p_size ENCODING AUTO,
p_container ENCODING AUTO
)
AS
SELECT p_partkey,
p_name,
p_mfgr,
p_category,
p_brand1,
p_color,
p_type,
p_size,
p_container
FROM public.part
ORDER BY p_partkey
UNSEGMENTED ALL NODES;
CREATE PROJECTION public.supplier_DBD_2_rep_SingleDesign /*+createtype(D)*/
(
s_suppkey ENCODING AUTO,
s_name ENCODING AUTO,
s_address ENCODING AUTO,
s_city ENCODING AUTO,
s_nation ENCODING AUTO,
s_region ENCODING AUTO,
s_phone ENCODING AUTO
)
AS
SELECT s_suppkey,
s_name,
s_address,
s_city,
s_nation,
s_region,
s_phone
FROM public.supplier
ORDER BY s_suppkey
UNSEGMENTED ALL NODES;
CREATE PROJECTION public.customer_DBD_3_rep_SingleDesign /*+createtype(D)*/
(
c_custkey ENCODING AUTO,
c_name ENCODING AUTO,
c_address ENCODING AUTO,
c_city ENCODING AUTO,
c_nation ENCODING AUTO,
c_region ENCODING AUTO,
c_phone ENCODING AUTO,
c_mktsegment ENCODING AUTO
)
AS
SELECT c_custkey,
c_name,
c_address,
c_city,
c_nation,
c_region,
c_phone,
c_mktsegment
FROM public.customer
ORDER BY c_custkey
UNSEGMENTED ALL NODES;
CREATE PROJECTION public.dwdate_DBD_4_rep_SingleDesign /*+createtype(D)*/
(
d_datekey ENCODING AUTO,
d_date ENCODING AUTO,
d_dayofweek ENCODING AUTO,
d_month ENCODING AUTO,
d_year ENCODING AUTO,
d_yearmonthnum ENCODING AUTO,
d_yearmonth ENCODING AUTO,
d_daynuminweek ENCODING AUTO,
d_daynuminmonth ENCODING AUTO,
d_daynuminyear ENCODING AUTO,
d_monthnuminyear ENCODING AUTO,
d_weeknuminyear ENCODING AUTO,
d_sellingseason ENCODING AUTO,
d_lastdayinweekfl ENCODING AUTO,
d_lastdayinmonthfl ENCODING AUTO,
d_holidayfl ENCODING AUTO,
d_weekdayfl ENCODING AUTO
)
AS
SELECT d_datekey,
d_date,
d_dayofweek,
d_month,
d_year,
d_yearmonthnum,
d_yearmonth,
d_daynuminweek,
d_daynuminmonth,
d_daynuminyear,
d_monthnuminyear,
d_weeknuminyear,
d_sellingseason,
d_lastdayinweekfl,
d_lastdayinmonthfl,
d_holidayfl,
d_weekdayfl
FROM public.dwdate
ORDER BY d_datekey
UNSEGMENTED ALL NODES;
CREATE PROJECTION public.lineorder_DBD_5_rep_SingleDesign /*+createtype(D)*/
(
lo_orderkey ENCODING AUTO,
lo_linenumber ENCODING AUTO,
lo_custkey ENCODING AUTO,
lo_partkey ENCODING AUTO,
lo_suppkey ENCODING AUTO,
lo_orderdate ENCODING AUTO,
lo_orderpriority ENCODING AUTO,
lo_shippriority ENCODING AUTO,
lo_quantity ENCODING AUTO,
lo_extendedprice ENCODING AUTO,
lo_ordertotalprice ENCODING AUTO,
lo_discount ENCODING AUTO,
lo_revenue ENCODING AUTO,
lo_supplycost ENCODING AUTO,
lo_tax ENCODING AUTO,
lo_commitdate ENCODING AUTO,
lo_shipmode ENCODING AUTO
)
AS
SELECT lo_orderkey,
lo_linenumber,
lo_custkey,
lo_partkey,
lo_suppkey,
lo_orderdate,
lo_orderpriority,
lo_shippriority,
lo_quantity,
lo_extendedprice,
lo_ordertotalprice,
lo_discount,
lo_revenue,
lo_supplycost,
lo_tax,
lo_commitdate,
lo_shipmode
FROM public.lineorder
ORDER BY lo_suppkey
UNSEGMENTED ALL NODES;
(1 row)
等待正在填充和部署设计的操作完成。Ctrl+C 会取消此操作并将控制权返回给用户。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DESIGNER_WAIT_FOR_DESIGN ( 'design‑name' )
拥有设计架构 USAGE 权限的超级用户或 DBDUSER
以下示例要求等待当前正在运行的 VMART_DESIGN 设计完成：
=> SELECT DESIGNER_WAIT_FOR_DESIGN ('VMART_DESIGN');
以下元函数可用于将查询计划作为定向查询从一个 Vertica 数据库批量导出，并将这些定向查询导入其他数据库。
生成 SQL，用于通过一组输入查询创建定向查询。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_DIRECTED_QUERIES('input-file', '[output-file]')
您提供给 EXPORT_DIRECTED_QUERIES 的输入文件包含一个或多个输入查询。对于每个输入查询，您可以选择指定两个字段，这两个字段将用于生成的定向查询中：
DirQueryName 提供了定向查询的唯一标识符，即一个符合标识符中所述惯例的字符串。
DirQueryComment 指定了一个最多 128 个字符并以引号分隔的字符串。
您可以按如下方式设置每个输入查询的格式：
--DirQueryName=query-name
--DirQueryComment='comment'
input-query
EXPORT_DIRECTED_QUERIES 会将生成用于创建定向查询的 SQL，并将此 SQL 写入到指定文件或标准输出中。对于这两种情况，输出都遵循以下格式：
/* Query: directed-query-name */
/* Comment: directed-query-comment */
SAVE QUERY input-query;
CREATE DIRECTED QUERY CUSTOM 'directed-query-name'
COMMENT 'directed-query-comment'
OPTVER 'vertica-release-num'
PSDATE 'timestamp'
annotated-query
如果给定的输入查询省略了 DirQueryName 和 DirQueryComment 字段，则 EXPORT_DIRECTED_QUERIES 会自动生成以下输出：
/* Query: Autoname:时间戳
.n */，其中 n 为基于零的整数索引，用于确保具有相同时间戳的自动生成名称具有唯一性。
/* Comment: Optimizer-generated directed query */
如果在执行 EXPORT_DIRECTED_QUERIES 期间发生任何错误或警告，它会返回一条类似于以下内容的消息：
1 queries successfully exported.
1 warning message was generated.
Queries exported to /home/dbadmin/outputQueries.
See error report, /home/dbadmin/outputQueries.err for details.
EXPORT_DIRECTED_QUERIES 会将所有错误或警告都写入到一个在与输出文件相同的路径下所创建的文件中，并使用输出文件的基名。
例如：
---------------------------------------------------------------------------------------------------
WARNING: Name field not supplied. Using auto-generated name: 'Autoname:2016-04-25 15:03:32.115317.0'
Input Query: SELECT employee_dimension.employee_first_name, employee_dimension.employee_last_name, employee_dimension.job_title FROM public.employee_dimension WHERE (employee_dimension.employee_city = 'Boston'::varchar(6)) ORDER BY employee_dimension.job_title;
END WARNING
请参阅导出定向查询。
从 EXPORT_DIRECTED_QUERIES 生成的 SQL 文件导入到数据库编录定向查询。如果未指定定向查询，Vertica 将列出 SQL 文件中的所有定向查询。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPORT_DIRECTED_QUERIES( 'export-file'[, 'directed-query-name'[,...] ] )
EXPORT_DIRECTED_QUERIES 生成的 SQL 文件。运行文件时，Vertica 在当前数据库编录中创建指定的定向查询。如果省略此参数，Vertica 将列出 export‑file 中所有定向查询的名称。
请参阅导入定向查询。
错误处理函数接受字符串并在执行查询时返回该字符串。
返回用户定义的错误消息。
在多节点群集中，很少会导致错误消息的顺序不同。
THROW_ERROR ( message )
遇到 CASE 语句时，返回错误消息：
=> CREATE TABLE pitcher_err (some_text varchar);
CREATE TABLE
=> COPY pitcher_err FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> big foo value
>> bigger foo other value
>> bar another foo value
>> \.
=> SELECT (CASE WHEN true THEN THROW_ERROR('Failure!!!') ELSE some_text END) FROM pitcher_err;
ERROR 7137: USER GENERATED ERROR: Failure!!!
遇到使用 REGEXP_LIKE 的 CASE 语句时，返回错误消息：
=> SELECT (CASE WHEN REGEXP_LIKE(some_text, 'other') THEN THROW_ERROR('Failure at "' || some_text || '"') END) FROM pitcher_err;
ERROR 4566: USER GENERATED ERROR: Failure at "bar another foo value"
此部分包含用于处理复杂类型的 Flex 表和 Flex 列的 Helper 函数。您可以将这些函数与 Flex 表和其关联的 flex_table_keys 表和 flex_table_view 视图以及外部表中的 Flex 列配合使用。这些函数不适用于其他表。
有关 Flex 表的详细信息，请参阅 Flex 表。有关复杂类型的 Flex 列的详细信息，请参阅 可变复杂类型。
Flex 函数可用于管理和查询 Flex 表。也可以使用映射函数来查询非 Flex 表中的复杂类型 Flex 列。
Flex 表数据 Helper 函数提供了直接在 Flex 表中查询数据所需的信息。计算键并利用原始数据创建视图之后，可直接在查询中使用字段名称，而不是使用映射函数提取数据。
每个 Flex 表具有两个依赖对象，一个键表和一个视图。虽然这两个对象均依赖于其父表，您可以独立删除其中任一对象。删除父表将同时移除这两个依赖项，而无需使用层叠 (CASCADE) 选项。
如果 Helper 函数与父表在内部相链接，则其可自动使用相关的表和视图。当您创建 Flex 表时，也将同时创建上述两项。您可以删除键表或视图，然后重新创建同名的对象。但如果您执行此操作，新的对象不会与父 Flex 表在内部相链接。
在这种情况下，您可以恢复这些对象到父表的内部链接。为此，请在调用 RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW 函数之前删除键表和视图。调用此函数可重新创建键表和视图。
其余 Helper 函数执行本节所述的任务。
创建或重新创建默认或用户定义键表的视图，忽略任何空键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BUILD_FLEXTABLE_VIEW ('[[database.]schema.]flex-table'
[ [,'view-name'] [,'user-keys-table'] ])
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
flex_table_keys 表的当前内容构建或重建输入表的视图。flex_table_keys 默认表）映射数据创建一个自定义键表，则使用此选项。函数从 user_keys 中（而不是从 flex_table_keys 中）的键构建视图。下面的示例显示如何用 1、2 或 3 实参调用 BUILD_FLEXTABLE_VIEW。
要创建或重新创建一个默认视图：
使用输入 Flex 表调用函数：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata');
build_flextable_view
-----------------------------------------------------
The view public.darkdata_view is ready for querying
(1 row)
函数从 darkdata_keys 表创建具有默认名称 (darkdata_view) 的视图。
从新视图或更新视图查询键名：
=> SELECT "user.id" FROM darkdata_view;
user.id
-----------
340857907
727774963
390498773
288187825
164464905
125434448
601328899
352494946
(12 rows)
要使用自定义名称创建或重建视图：
用两个实参、一个输入弹性表 darkdata以及要创建的视图名称 dd_view 调用函数：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view');
build_flextable_view
-----------------------------------------------
The view public.dd_view is ready for querying
(1 row)
从新视图或更新视图 (user.lang) 查询键名 (dd_view)：
=> SELECT "user.lang" FROM dd_view;
user.lang
-----------
tr
en
es
en
en
it
es
en
(12 rows)
要使用 BUILD_FLEXTABLE_VIEW 从自定义键表创建一个视图，此自定义表必须具有与默认表 (darkdata_keys) 相同的架构和表定义。使用下面三种方法中的任何一种创建一个自定义键表：
使用弹性表 (darkdata_keys) 的默认键表中的所有键创建一个柱状表：
=> CREATE TABLE new_darkdata_keys AS SELECT * FROMdarkdata_keys;
CREATE TABLE
从弹性表 (LIMIT 0) 的默认键表创建一个不含内容的柱状表 (darkdata_keys)：
=> CREATE TABLE new_darkdata_keys AS SELECT * FROM darkdata_keys LIMIT 0;
CREATE TABLE
kdb=> SELECT * FROM new_darkdata_keys;
key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)
从默认键表创建一个不含内容的柱状表 (LIMIT 0)，并将两个值 ('user.lang', 'user.name') 插入 key_name 列：
=> CREATE TABLE dd_keys AS SELECT * FROM darkdata_keys limit 0;
CREATE TABLE
=> INSERT INTO dd_keys (key_name) values ('user.lang');
OUTPUT
--------
1
(1 row)
=> INSERT INTO dd_keys (key_name) values ('user.name');
OUTPUT
--------
1
(1 row)
=> SELECT * FROM dd_keys;
key_name | frequency | data_type_guess
-----------+-----------+-----------------
user.lang | |
user.name | |
(2 rows)
创建一个自定义键表后，用所有实参（输入 Flex 表、新视图名称、自定义键表）调用 BUILD_FLEXTABLE_VIEW：
=> SELECT BUILD_FLEXTABLE_VIEW('darkdata', 'dd_view', 'dd_keys');
build_flextable_view
-----------------------------------------------
The view public.dd_view is ready for querying
(1 row)
查询新视图：
=> SELECT * FROM dd_view;
计算来自 flex 表 VMap 数据的虚拟列（键和值）。使用此函数可计算键，而不必创建关联的表视图。如需生成视图，请使用 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW。
函数将其结果存储到关联的 Flex 键表 (
flexTableName_keys)，其中包含以下列：
key_name
frequency
data_type_guess
有关详细信息，请参阅计算 Flex 表键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
COMPUTE_FLEXTABLE_KEYS ('[[database.]schema.]flex-table')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
flex-tabledata_type_guess 列中的结果取决于 EnableBetterFlexTypeGuessing 配置参数。默认情况下，参数为 1 (ON)。此设置会导致函数采用以下类型之一（以及 数据类型 中列出的其他类型）返回 data_type_guess 列中的所有非字符串键：
BOOLEAN
INTEGER
FLOAT
TIMESTAMP
DATE
将配置参数设置为 0 (OFF) 会导致函数仅返回键表 data_type_guess 列中所有值的字符串类型 ([LONG]VARCHAR) 或 ([LONG] VARBINARY)。
使用此部分中的示例 CSV 数据来比较使用或不使用 EnableBetterFlexTypeGuessing 配置参数的结果。当参数为 ON 时，该函数可以更准确地确定地图数据中的关键非字符串数据类型。该参数的默认值为 1 (ON)。
Year,Quarter,Region,Species,Grade,Pond Value,Number of Quotes,Available
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,1P,$615.12 ,12,No
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,SM,$610.78 ,12,Yes
2015,1,2 - Northwest Oregon & Willamette,Douglas-fir,2S,$596.00 ,20,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,P,$520.00 ,6,Yes
2015,1,2 - Northwest Oregon & Willamette,Hemlock,SM,$510.00 ,6,No
2015,1,2 - Northwest Oregon & Willamette,Hemlock,2S,$490.00 ,14,No
要比较数据类型分配结果，请完成以下步骤：
保存此 CSV 数据文件（此处保存为 trees.csv）。
创建 Flex 表 (trees) 并使用 fcsvparser 加载 trees.csv：
=> CREATE FLEX TABLE trees();
=> COPY trees FROM '/home/dbadmin/tempdat/trees.csv' PARSER fcsvparser();
将 COMPUTE_FLEXTABLE_KEYS 用于 trees Flex 表。
=> SELECT COMPUTE_FLEXTABLE_KEYS('trees');
COMPUTE_FLEXTABLE_KEYS
-----------------------------------------------
Please see public.trees_keys for updated keys
(1 row)
查询 trees_keys 表输出：
=> SELECT * FROM trees_keys;
key_name | frequency | data_type_guess
------------------+-----------+-----------------
Year | 6 | Integer
Quarter | 6 | Integer
Region | 6 | Varchar(66)
Available | 6 | Boolean
Number of Quotes | 6 | Integer
Grade | 6 | Varchar(20)
Species | 6 | Varchar(22)
Pond Value | 6 | Numeric(8,3)
(8 rows)
将 EnableBetterFlexTypeGuessing 参数设置为 0（OFF）。
再次使用 trees Flex 表调用 COMPUTE_FLEXTABLE_KEYS。
查询 trees_keys 表，将 data_type_guess 的值与之前的结果进行比较。如果没有配置参数集，所有非字符串数据类型都是各种长度的 VARCHARS：
=> SELECT * FROM trees_keys;
key_name | frequency | data_type_guess
------------------+-----------+-----------------
Year | 6 | varchar(20)
Quarter | 6 | varchar(20)
Region | 6 | varchar(66)
Available | 6 | varchar(20)
Grade | 6 | varchar(20)
Number of Quotes | 6 | varchar(20)
Pond Value | 6 | varchar(20)
Species | 6 | varchar(22)
(8 rows)
要保持非字符串数据类型的准确结果，请将 EnableBetterFlexTypeGuessing 参数重新设置为 1 (ON)。
有关 EnableBetterFlexTypeGuessing 配置参数的详细信息，请参阅 EnableBetterFlexTypeGuessing。
可合并 BUILD_FLEXTABLE_VIEW 和 COMPUTE_FLEXTABLE_KEYS 的功能，以便计算来自 Flex 表 Vmap 数据的虚拟列（键），并构建视图。使用此函数创建视图将忽略空键。如果不需要一起执行这两项操作，请改为使用单操作函数之一。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW ('flex-table')
此示例显示如何调用 darkdata Flex 表的函数。
=> SELECT COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW('darkdata');
compute_flextable_keys_and_build_view
-----------------------------------------------------------------------
Please see public.darkdata_keys for updated keys
The view public.darkdata_view is ready for querying
(1 row)
使用 COMPUTE_FLEXTABLE_KEYS 或 COMPUTE_FLEXTABLE_KEYS_AND_BUILD_VIEW 实体化执行计算的 flextable_keys 表中作为 key_names 列出的虚拟列。
AUDIT() 或 AUDIT_FLEX() 函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MATERIALIZE_FLEXTABLE_COLUMNS ('[[database.]schema.]flex-table' [, n-columns [, keys-table-name] ])
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
跳过已实体化的任何列
忽略所有空键
实体化键表中的 n-columns 列
跳过已实体化的任何列
按频率降序排列实体化结果
以下示例显示了如何调用 MATERIALIZE_FLEXTABLE_COLUMNS 实体化列。首先，将 tweets 样本文件 (tweets_10000.json) 载入 flex 表 twitter_r。加载数据并计算样本 Flex 表的键以后，调用 MATERIALIZE_FLEXTABLE_COLUMNS，实体化前四列：
=> COPY twitter_r FROM '/home/release/KData/tweets_10000.json' parser fjsonparser();
Rows Loaded
-------------
10000
(1 row)
=> SELECT compute_flextable_keys ('twitter_r');
compute_flextable_keys
---------------------------------------------------
Please see public.twitter_r_keys for updated keys
(1 row)
=> SELECT MATERIALIZE_FLEXTABLE_COLUMNS('twitter_r', 4);
MATERIALIZE_FLEXTABLE_COLUMNS
-------------------------------------------------------------------------------
The following columns were added to the table public.twitter_r:
contributors
entities.hashtags
entities.urls
For more details, run the following query:
SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';
(1 row)
例子的最后一条消息推荐查询 MATERIALIZE_FLEXTABLE_COLUMNS_RESULTS 系统表，查看列实体化的结果，如下所示：
=> SELECT * FROM v_catalog.materialize_flextable_columns_results WHERE table_schema = 'public' and table_name = 'twitter_r';
table_id | table_schema | table_name | creation_time | key_name | status | message
-------------------+--------------+------------+------------------------------+-------------------+--------+---------------------
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945484-05| contributors | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.94551-05 | entities.hashtags | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945519-05| entities.urls | ADDED | Added successfully
45035996273733172 | public | twitter_r | 2013-11-20 17:00:27.945532-05| created_at | EXISTS | Column of same name already
(4 rows)
恢复键表和视图。无论删除任一表，函数还会将键表与其关联的 Flex 表链接起来。该函数还会指示其恢复了一个对象还是同时恢复了两个对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW ('flex-table')
flex-table此示例显示如何使用现有的 Flex 表调用此函数，还原键表和视图：
=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
----------------------------------------------------------------------------------
The keys table public.darkdata_keys was restored successfully.
The view public.darkdata_view was restored successfully.
(1 row)
此示例描述函数恢复了 darkdata_view，但不需要恢复 darkdata_keys：
=> SELECT RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW('darkdata');
RESTORE_FLEXTABLE_DEFAULT_KEYS_TABLE_AND_VIEW
------------------------------------------------------------------------------------
The keys table public.darkdata_keys already exists and is linked to darkdata.
The view public.darkdata_view was restored successfully.
(1 row)
还原键表之后，其中没有任何内容。要填充 Flex 键，请调用 COMPUTE_FLEXTABLE_KEYS 函数。
=> SELECT * FROM darkdata_keys;
key_name | frequency | data_type_guess
----------+-----------+-----------------
(0 rows)
Flex Extractor 标量函数可处理多结构数据。每个函数均接受以下输入数据：
现有数据库内容
表
从表达式返回
直接输入
这些函数不解析来自外部文件源的数据。所有函数均返回单一 VMap 值。Extractor 函数可以返回带 NULL 指定列的数据。
用分隔符和其他可选实参提取数据，并返回单一的 VMap 值。
MAPDELIMITEDEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])
delimiter默认值： |
header_names默认值：
ucoln，其中 n 为列偏移数，第一列以 0 开头。
trim默认值： true
treat_empty_val_as_nullNULL 而不是空字符串 ('')。
默认值： true
这些示例使用了一个简短的分隔数据集：
Name|CITY|New city|State|zip
Tom|BOSTON|boston|MA|01
Eric|Burlington|BURLINGTON|MA|02
Jamie|cambridge|CAMBRIDGE|MA|08
首先，将此数据保存为 delim.dat。
创建一个 Flex 表 dflex：
=> CREATE FLEX TABLE dflex();
CREATE TABLE
使用 COPY 加载 delim.dat 文件。使用 Flex 表 fdelimitedparser 的 header='false' 选项：
=> COPY dflex FROM '/home/release/kmm/flextables/delim.dat' parser fdelimitedparser(header='false');
Rows Loaded
-------------
4
(1 row)
创建列式表 dtab，它具有一个表示身份的 id 列、一个 delim 列和一个用于存储 VMap 的 vmap 列：
=> CREATE TABLE dtab (id IDENTITY(1,1), delim varchar(128), vmap long varbinary(512));
CREATE TABLE
使用 COPY 将 delim.dat 文件加载到 dtab 表中。MAPDELIMITEDEXTRACTOR 使用 header_names 参数以及 delimiter '!' 为示例数据指定标题行：
=> COPY dtab(delim, vmap AS MAPDELIMITEDEXTRACTOR (delim
USING PARAMETERS header_names='Name|CITY|New City|State|Zip')) FROM '/home/dbadmin/data/delim.dat'
DELIMITER '!';
Rows Loaded
-------------
4
(1 row)
将 MAPTOSTRING 用于 Flex 表 dflex，以查看 __raw__ 列内容。请注意使用中的默认标题名 (ucol0 – ucol4)，因为您在加载 Flex 表时指定 header='false'：
=> SELECT MAPTOSTRING(__raw__) FROM dflex limit 10;
maptostring
-------------------------------------------------------------------------------------
{
"ucol0" : "Jamie",
"ucol1" : "cambridge",
"ucol2" : "CAMBRIDGE",
"ucol3" : "MA",
"ucol4" : "08"
}
{
"ucol0" : "Name",
"ucol1" : "CITY",
"ucol2" : "New city",
"ucol3" : "State",
"ucol4" : "zip"
}
{
"ucol0" : "Tom",
"ucol1" : "BOSTON",
"ucol2" : "boston",
"ucol3" : "MA",
"ucol4" : "01"
}
{
"ucol0" : "Eric",
"ucol1" : "Burlington",
"ucol2" : "BURLINGTON",
"ucol3" : "MA",
"ucol4" : "02"
}
(4 rows)
再次使用 MAPTOSTRING，这次将其用于 dtab 表的 vmap 列。将此输出的结果与 Flex 表的结果进行比较。请注意，MAPTOSTRING 返回了您在加载数据时指定的 header_name 参数值：
=> SELECT MAPTOSTRING(vmap) FROM dtab;
maptostring
------------------------------------------------------------------------------------------------------------------------
{
"CITY" : "CITY",
"Name" : "Name",
"New City" : "New city",
"State" : "State",
"Zip" : "zip"
}
{
"CITY" : "BOSTON",
"Name" : "Tom",
"New City" : "boston",
"State" : "MA",
"Zip" : "02121"
}
{
"CITY" : "Burlington",
"Name" : "Eric",
"New City" : "BURLINGTON",
"State" : "MA",
"Zip" : "02482"
}
{
"CITY" : "cambridge",
"Name" : "Jamie",
"New City" : "CAMBRIDGE",
"State" : "MA",
"Zip" : "02811"
}
(4 rows)
查询 delim 列，以不同的方式查看其内容：
=> SELECT delim FROM dtab;
delim
-------------------------------------
Name|CITY|New city|State|zip
Tom|BOSTON|boston|MA|02121
Eric|Burlington|BURLINGTON|MA|02482
Jamie|cambridge|CAMBRIDGE|MA|02811
(4 rows)
提取重复 JSON 数据对象（包括嵌套映射）或具有 JSON 元素外部列表的数据的内容。您可以设置一个或多个可选参数来控制提取过程。
MAPJSONEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])
flatten_maps.) 分隔映射层级。
默认值： true
flatten_arrays默认值： false
reject_on_duplicatefalse)，或拒绝重复记录 (true)。在任何一种情况下，加载都不受影响。
默认值： false
reject_on_empty_key默认值： false
omit_empty_keys默认值： false
start_pointstart_point 值之前的所有数据。解析器会处理第一个实例后面的数据，最多到第二个，便会忽略任何保留的数据。
默认值： 无
这些示例使用以下示例 JSON 数据：
{ "id": "5001", "type": "None" }
{ "id": "5002", "type": "Glazed" }
{ "id": "5005", "type": "Sugar" }
{ "id": "5007", "type": "Powdered Sugar" }
{ "id": "5004", "type": "Maple" }
将此示例数据保存为 bake_single.json，然后加载该文件。
创建一个 Flex 表 flexjson：
=> CREATE FLEX TABLE flexjson();
CREATE TABLE
通过 fjsonparser 解析器，使用 COPY 加载 bake_single.json 文件：
=> COPY flexjson FROM '/home/dbadmin/data/bake_single.json' parser fjsonparser();
Rows Loaded
-------------
5
(1 row)
创建列式表 coljson，它具有一个身份列 (id)、一个 json 列和一个用于存储 VMap 的 vmap 列：
=> CREATE TABLE coljson(id IDENTITY(1,1), json varchar(128), vmap long varbinary(10000));
CREATE TABLE
利用 MAPJSONEXTRACTOR，使用 COPY 将 bake_single.json 文件加载到 coljson 表中：
=> COPY coljson (json, vmap AS MapJSONExtractor(json)) FROM '/home/dbadmin/data/bake_single.json';
Rows Loaded
-------------
5
(1 row)
将 MAPTOSTRING 函数用于 Flex 表 flexjson 以将 __raw__ 列的内容输出为字符串：
=> SELECT MAPTOSTRING(__raw__) FROM flexjson limit 5;
maptostring
-----------------------------------------------------
{
"id" : "5001",
"type" : "None"
}
{
"id" : "5002",
"type" : "Glazed"
}
{
"id" : "5005",
"type" : "Sugar"
}
{
"id" : "5007",
"type" : "Powdered Sugar"
}
{
"id" : "5004",
"type" : "Maple"
}
(5 rows)
再次使用 MAPTOSTRING，这次将其用于 coljson 表的 vmap 列，并比较结果。元素顺序有所不同：
=> SELECT MAPTOSTRING(vmap) FROM coljson limit 5;
maptostring
-----------------------------------------------------
{
"id" : "5001",
"type" : "None"
}
{
"id" : "5002",
"type" : "Glazed"
}
{
"id" : "5004",
"type" : "Maple"
}
{
"id" : "5005",
"type" : "Sugar"
}
{
"id" : "5007",
"type" : "Powdered Sugar"
}
(5 rows)
使用正则表达式提取数据，并以 VMap 的形式返回结果。
MAPREGEXEXTRACTOR (record-value [ USING PARAMETERS param=value[,...] ])
pattern默认值： 空字符串 ('')
use_jit默认值： false
record_terminator默认值： \n
logline_column默认值： 空字符串 ('')
这些示例使用以下正则表达式，它们搜索包括 timestamp、date、thread_name 和 thread_id 字符串的信息。
此示例表达式加载任何 thread_id 十六进制值，无论其是否包含 0x 前缀 (<thread_id>(?:0x)?[0-9a-f]+)。
'^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
(?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'
为了方便显示，以下示例可能包含换行符。
创建一个 Flex 表 flogs：
=> CREATE FLEX TABLE flogs();
CREATE TABLE
使用 Flex 表 fregexparser 时，利用 COPY 加载示例日志文件 (vertica.log)。请注意，此示例包括为显示长文本行而添加的行字符。
=> COPY flogs FROM '/home/dbadmin/tempdat/vertica.log' PARSER FREGEXPARSER(pattern='
^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+) (?<thread_name>[A-Za-z ]+):
(?<thread_id>(?:0x)?[0-9a-f])-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )?(?<text>.*)');
Rows Loaded
-------------
81399
(1 row)
用于返回通过正则表达式调用 MAPREGEXEXTRACTOR 的结果。输出以字符串格式返回函数的结果。
=> SELECT MAPTOSTRING(MapregexExtractor(E'2014-04-02 04:02:51.011
TM Moveout:0x2aab9000f860-a0000000002067 [Txn] <INFO>
Begin Txn: a0000000002067 \'Moveout: Tuple Mover\'' using PARAMETERS
pattern='^(?<time>\d\d\d\d-\d\d-\d\d \d\d:\d\d:\d\d\.\d+)
(?<thread_name>[A-Za-z ]+):(?<thread_id>(?:0x)?[0-9a-f]+)
-?(?<transaction_id>[0-9a-f])?(?:[(?<component>\w+)]
\<(?<level>\w+)\> )?(?:<(?<elevel>\w+)> @[?(?<enode>\w+)]?: )
?(?<text>.*)'
)) FROM flogs where __identity__=13;
maptostring
--------------------------------------------------------------------------------------------------
{
"component" : "Txn",
"level" : "INFO",
"text" : "Begin Txn: a0000000002067 'Moveout: Tuple Mover'",
"thread_id" : "0x2aab9000f860",
"thread_name" : "TM Moveout",
"time" : "2014-04-02 04:02:51.011",
"transaction_id" : "a0000000002067"
}
(1 row)
Flex 映射函数允许您提取和操作嵌套映射数据。
所有 Flex 映射函数的第一个实参（EMPTYMAP 和 MAPAGGREGATE 除外）均包含 VMap。VMap 可以源自 Flex 表中的 __raw__ 列，或从映射或提取函数返回。
所有映射函数（EMPTYMAP 和 MAPAGGREGATE 除外）均接受 LONG VARBINARY 或 LONG VARCHAR 映射实参。
在以下示例中，外部 MAPLOOKUP 函数对从内部 MAPLOOKUP 函数返回的 VMap 数据进行操作：
=> MAPLOOKUP(MAPLOOKUP(ret_map, 'batch'), 'scripts')
您可以将 Flex 映射函数专门用于：
Flex 表
关联的 _keys 表和 _view 视图
复杂类型 Flex 列
构建一个有一行但无键值或数据的 VMap。使用此转换函数可填充映射，而无需使用 flex 解析器。但可以使用来自 SQL 查询或存储于数据库中其他位置的映射数据。
EMPTYMAP()
创建空映射
=> SELECT EMPTYMAP();
emptymap
------------------------------------------------------------------
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(1 row)
从现有 Flex 表创建空映射
如果从现有 flex 表创建空映射，则新映射的行数与用于创建该映射的表相同。
此示例展示了从 darkdata 表创建空映射将得到的结果，表中包含 12 行 JSON 数据：
=> SELECT EMPTYMAP() FROM darkdata;
emptymap
------------------------------------------------------------------
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
\001\000\000\000\004\000\000\000\000\000\000\000\000\000\000\000
(12 rows)
返回从 VARCHAR 的两个输入列提供的具有键和值对的 LONG VARBINARY VMap。此函数需要 OVER 子句。
MAPAGGREGATE (keys-column1, values-column2 [USING PARAMETERS param=value[,...]])
keys-columnVMap 数据的键/值对的键的表列。值为 NULL 的键排除在外。如果存在重复键，则使用查询结果中最先出现的重复键和值，省略其他重复键和值。values-columnVMap 数据的键/值对的值的表列。max_vmap_length默认值： 130000
on_overflowmax_vmap_length 时的溢出行为。值必须为以下字符串之一：
max_vmap_length，则停止键/值对聚合。执行查询但生成的 VMap 未包含所有键/值对。当提供的 max_vmap_length 不足以存储空 VMap 时，返回的结果为 NULL。请注意，需要在 OVER 子句中指定顺序条件才能获得一致的结果。默认值： 'ERROR'
以下示例使用此输入表：
=> SELECT * FROM inventory;
product | stock
--------------+--------
Planes | 100
Trains | 50
Automobiles | 200
(3 rows)
按如下所述的方法调用 MAPAGGREGATE，返回生成的 VMap 的 raw_map 数据：
=> SELECT raw_map FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM inventory) inventory;
raw_map
------------------------------------------------------------------------------------------------------------
\001\000\000\000\030\000\000\000\003\000\000\000\020\000\000\000\023\000\000\000\026\000\000\00020010050\003
\000\000\000\020\000\000\000\033\000\000\000!\000\000\000AutomobilesPlanesTrains
(1 row)
要将返回的 raw_map 数据转换为字符串表示形式，请使用具有 MAPTOSTRING 的 MAPAGGREGATE：
=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock) OVER(ORDER BY product) FROM
inventory) inventory;
MAPTOSTRING
--------------------------------------------------------------
{
"Automobiles": "200",
"Planes": "100",
"Trains": "50"
}
(1 row)
如果运行上述查询时将 on_overflow 保留为默认值且 max_vmap_length 小于返回的 VMap 大小，则函数返回错误消息，表示需要增加 VMap长度：
=> SELECT MAPTOSTRING(raw_map) FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60)
OVER(ORDER BY product) FROM inventory) inventory;
----------------------------------------------------------------------------------------------------------
ERROR 5861: Error calling processPartition() in User Function MapAggregate at [/data/jenkins/workspace
/RE-PrimaryBuilds/RE-Build-Master_2/server/udx/supported/flextable/Dict.cpp:1324], error code: 0, message:
Exception while finalizing map aggregation: Output VMap length is too small [60]. HINT: Set the parameter
max_vmap_length=71 and retry your query
切换 on_overflow 的值可更改 MAPAGGREGATE 在溢出情况下的行为方式。例如，将 on_overflow 改为 'RETURN_NULL' 可执行上述查询并返回 NULL：
SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='RETURN_NULL') OVER(ORDER BY product) FROM inventory) inventory;
?column?
----------
t
(1 row)
如果 on_overflow 设置为 'TRUNCATE'，则生成的 VMap 有足够的空间容纳两个键/值对，但必须删除第三个键/值对：
SELECT raw_map IS NULL FROM (SELECT MAPAGGREGATE(product, stock USING PARAMETERS max_vmap_length=60,
on_overflow='TRUNCATE') OVER(ORDER BY product) FROM inventory) inventory;
MAPTOSTRING
---------------------------------------------
{
"Automobiles": "200",
"Planes": "100"
}
(1 row)
确定 VMap 是否含有虚拟列（键）。如果存在虚拟列，此标量函数返回 true (t)；如果不存在，则返回 false (f) 。调用 maplookup() 前确定键的存在可区分 NULL 返回。maplookup() 函数用于非存在键和具有 NULL 值的存在键。
MAPCONTAINSKEY (VMap-data, 'virtual-column-name')
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
virtual-column-name本例显示如何使用 mapcontainskey() 函数和 maplookup()。查看两个函数返回的结果。检查 maplookup() 返回的空字段是表示行 (t) 的 NULL 值还是无值 (f)：
您可以在调用 maplookup() 之前使用 mapcontainskey( ) 确定键的存在。maplookup() 函数使用 NULL 返回和具有 NULL 值的存在键，表示一个不存在的键。
=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
maplookup | mapcontainskey
-----------+----------------
| t
| t
| t
| t
Chile | t
Narnia | t
Uptown.. | t
chicago | t
| f
| f
| f
| f
(12 rows)
确定 VMap 是否含有指定值。如果值存在，则使用此标量函数返回 true (t)，否则返回 false (f)。
MAPCONTAINSVALUE (VMap-data, 'virtual-column-value')
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
本例显示如何使用 mapcontainsvalue() 确定虚拟列是否含有特定值。创建一个 flex 表 (ftest)，填充一些虚拟列和值。为虚拟列 one命名：
=> CREATE FLEX TABLE ftest();
CREATE TABLE
=> copy ftest from stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"one":1, "two":2}
>> {"one":"one","2":"2"}
>> \.
在 mapcontainsvalue() 映射数据上调用 ftest 。查询对第一个虚拟列返回 false (f) ，对含有值 t的第二个返回 true (one)。
=> SELECT MAPCONTAINSVALUE(__raw__, 'one') FROM ftest;
mapcontainsvalue
------------------
f
t
(2 rows)
返回关于 VMap 中各项目的信息。使用具有一个或多个可选自变量的转换函数访问 VMap 数据中的聚结构值。该函数需要
over() 子句。
MAPITEMS (VMap-data [, passthrough-arg[,...] ])
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，确定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。max_value_length__raw__ 列中，确定函数可以返回的值的最大长度。大于
max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。passthrough-argVMap-data 映射数据中键的一个或多个实参。以下示例说明如何使用带有 over(PARTITION BEST) 子句的 MAPITEMS()。
此示例使用标记为 darkmountain 的 Flex 表确定映射数据中的虚拟列数。使用 count() 函数查询返回映射数据中的虚拟列数：
=> SELECT COUNT(keys) FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM
darkmountain) AS a;
count
-------
19
(1 row)
下一个示例确定映射数据中存在哪些项：
=> SELECT * FROM (SELECT MAPITEMS(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
keys | values
-------------+---------------
hike_safety | 50.6
name | Mt Washington
type | mountain
height | 17000
hike_safety | 12.2
name | Denali
type | mountain
height | 29029
hike_safety | 34.1
name | Everest
type | mountain
height | 14000
hike_safety | 22.8
name | Kilimanjaro
type | mountain
height | 29029
hike_safety | 15.4
name | Mt St Helens
type | volcano
(19 rows)
以下示例显示如何将返回值的长度限制为 100000：
=> SELECT LENGTH(keys), LENGTH(values) FROM (SELECT MAPITEMS(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM t1) x;
LENGTH | LENGTH
--------+--------
9 | 98899
(1 row)
在 VMap 中直接查询关键值
查看以下 JSON 输入文件 simple.json。特别注意 three_Array 队列及其四个值：
{
"one": "one",
"two": 2,
"three_Array":
[
"three_One",
"three_Two",
3,
"three_Four"
],
"four": 4,
"five_Map":
{
"five_One": 51,
"five_Two": "Fifty-two",
"five_Three": "fifty three",
"five_Four": 54,
"five_Five": "5 x 5"
},
"six": 6
}
创建 flex 表，映射：
=> CREATE FLEX TABLE mapper();
CREATE TABLE
将 simple.json 载入 flex 表映射：
=> COPY mapper FROM '/home/dbadmin/data/simple.json' parser fjsonparser (flatten_arrays=false,
flatten_maps=false);
Rows Loaded
-------------
1
(1 row)
在 Flex 表的 __raw__ 列上调用 MAPKEYS，查看 Flex 表的键，但不是键子映射。返回值显示 three_Array 是虚拟列之一：
=> SELECT MAPKEYS(__raw__) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
在 Flex 表 mapper 上调用 mapitems，将 three_Array 作为函数的传递实参。调用返回这些队列值：
=> SELECT __identity__, MAPITEMS(three_Array) OVER(PARTITION BY __identity__) FROM mapper;
__identity__ | keys | values
--------------+------+------------
1 | 0 | three_One
1 | 1 | three_Two
1 | 2 | 3
1 | 3 | three_Four
(4 rows)
返回任何 VMap 数据中存在的虚拟列（和值）。此转换函数需要 OVER(PARTITION BEST) 子句。
MAPKEYS (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，指定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。确定映射数据的虚拟列数
本例显示如何创建查询，使用 over(PARTITION BEST) 子句和 flex 表、 darkdata ，查找映射数据的虚拟列数。使用 JSON tweet 数据填充表。
=> SELECT COUNT(keys) FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
count
-------
550
(1 row)
查询映射中所有虚拟列的有序列表
本例显示您查询映射中所有虚拟列的有序列表时，返回数据的片段。
=> SELECT * FROM (SELECT MAPKEYS(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
keys
-------------------------------------
contributors
coordinates
created_ at
delete.status.id
delete.status.id_str
delete.status.user_id
delete.status.user_id_str
entities.hashtags
entities.media
entities.urls
entities.user_mentions
favorited
geo
id
.
.
.
user.statuses_count
user.time_zone
user.url
user.utc_offset
user.verified
(125 rows)
指定 MAPKEYS 可以返回的键的最大长度
=> SELECT MAPKEYS(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
从给定映射中返回虚拟列信息。此转换函数需要 OVER(PARTITION BEST) 子句。
MAPKEYSINFO (VMap-data)
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_key_length__raw__ 列中，确定函数可以返回的键的最大长度。长度超过
max_key_length 的键会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。此函数是 MAPKEYS() 函数的超集。返回下列关于每个虚拟列的信息：
本例显示您查询映射中所有虚拟列的有序列表时接收到的返回数据的片段。
=> SELECT * FROM (SELECT MAPKEYSINFO(darkdata.__raw__) OVER(PARTITION BEST) FROM darkdata) AS a;
keys | length | type_oid | row_num | field_num
----------------------------------------------------------+--------+----------+---------+-----------
contributors | 0 | 116 | 1 | 0
coordinates | 0 | 116 | 1 | 1
created_at | 30 | 116 | 1 | 2
entities.hashtags | 93 | 199 | 1 | 3
entities.media | 772 | 199 | 1 | 4
entities.urls | 16 | 199 | 1 | 5
entities.user_mentions | 16 | 199 | 1 | 6
favorited | 1 | 116 | 1 | 7
geo | 0 | 116 | 1 | 8
id | 18 | 116 | 1 | 9
id_str | 18 | 116 | 1 | 10
.
.
.
delete.status.id | 18 | 116 | 11 | 0
delete.status.id_str | 18 | 116 | 11 | 1
delete.status.user_id | 9 | 116 | 11 | 2
delete.status.user_id_str | 9 | 116 | 11 | 3
delete.status.id | 18 | 116 | 12 | 0
delete.status.id_str | 18 | 116 | 12 | 1
delete.status.user_id | 9 | 116 | 12 | 2
delete.status.user_id_str | 9 | 116 | 12 | 3
(550 rows)
指定 MAPKEYSINFO 可以返回的键的最大长度
=> SELECT MAPKEYSINFO(__raw__ USING PARAMETERS max_key_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
从 VMAP 数据中返回单个键值。如果具有值，此标量函数返回 LONG VARCHAR；如果虚拟列没有值，则返回 NULL。
对于虚拟列名，使用 maplookup 不区分大小写。为了避免加载同名值，请在数据加载时将 fjsonparser 解析器 reject_on_duplicate 参数设置为 true。
通过 fjsonparser 或 favroparser 分析器及其 flatten-arrays 实参加载数据时，您可以控制 VMAP 中非标量值（例如数组）的行为。请参阅 JSON 数据 和 FJSONPARSER 参考。
有关使用 maplookup() 访问嵌套 JSON 数据的信息，请参阅查询嵌套数据。
MAPLOOKUP (VMap-data, 'virtual-column-name' [USING PARAMETERS [case_sensitive={false | true}] [, buffer_size=n] ] )
任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
buffer_sizebuffer_size) 任何返回值字节数的 =>。所有长度大于 buffer_size 的返回值将被拒绝。
默认值： 0（buffer_size 无限制）
case_sensitive如果键在不同情况下存在，指定是否返回 virtual-column-name 的值。
示例：
(... USING PARAMETERS case_sensitive=true)
默认值： false
此示例返回一个虚拟列 user.location 的值：
=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata ORDER BY 1;
maplookup
-----------
Chile
Nesnia
Uptown
.
.
chicago
(12 rows)
使用 maplookup buffer_size
使用 buffer_size= 参数表示映射查询为指定虚拟列返回的任何值的最大长度。如果返回键值均不大于 n 字节，则使用该参数分配 n 字节作为 buffer_size。
对于下一个示例，将此 JSON 数据保存到文件 simple_name.json：
{
"name": "sierra",
"age": "63",
"eyes": "brown",
"weapon": "doggie"
}
{
"name": "janis",
"age": "10",
"eyes": "blue",
"weapon": "humor"
}
{
"name": "ben",
"age": "43",
"eyes": "blue",
"weapon": "sword"
}
{
"name": "jen",
"age": "38",
"eyes": "green",
"weapon": "shopping"
}
创建 flex 表 logs。
使用 simple_name.json 将 logs 数据载入 fjsonparser。指定 flatten_arrays 选项作为 True：
=> COPY logs FROM '/home/dbadmin/data/simple_name.json'
PARSER fjsonparser(flatten_arrays=True);
对 maplookup 表的 buffer_size=0 键使用 logs 的 name 。此查询返回所有值：
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=0) FROM logs;
MapLookup
-----------
sierra
ben
janis
jen
(4 rows)
接下来，调用 maplookup() 3次，将 buffer_size 参数分别指定为 3、5 和 6。现在，maplookup() 返回字节长度小于或等于 (<=) buffer_size 的值：
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=3) FROM logs;
MapLookup
-----------
ben
jen
(4 rows)
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=5) FROM logs;
MapLookup
-----------
janis
jen
ben
(4 rows)
=> SELECT MAPLOOKUP(__raw__, 'name' USING PARAMETERS buffer_size=6) FROM logs;
MapLookup
-----------
sierra
janis
jen
ben
(4 rows)
消除空输出行的歧义
此示例展示如何解释空行。如果在没有首先检查密钥是否存在的情况下使用 maplookup，则可能产生歧义。查看下列输出（12 个空行）时，您无法确定 user.location 键是否具有：
非 NULL 值
NULL 值
无值
=> SELECT MAPLOOKUP(__raw__, 'user.location') FROM darkdata;
maplookup
-----------
(12 rows)
消除空输出行，使用 mapcontainskey() 函数和 maplookup()。当 maplookup 返回空字段时，mapcontainskey 的相应值使用 t 表示 NULL 或其他值，或使用 f 表示无值。
以下使用全部两个函数的示例输出将具有 NULL 或名称值的行列为 t，将没有值的行列为 f：
=> SELECT MAPLOOKUP(__raw__, 'user.location'), MAPCONTAINSKEY(__raw__, 'user.location')
FROM darkdata ORDER BY 1;
maplookup | mapcontainskey
-----------+----------------
| t
| t
| t
| t
Chile | t
Nesnia | t
Uptown | t
chicago | t
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
| f >>>>>>>>>>No value
(12 rows)
检查区分大小写的虚拟列
在键名称不同的情况下，您可以使用具有 maplookup() 参数的 case_sensitive 返回结果。
将下列实例内容保存为 JSON 文件。本例将文件保存为 repeated_key_name.json：
{
"test": "lower1"
}
{
"TEST": "upper1"
}
{
"TEst": "half1"
}
{
"test": "lower2",
"TEst": "half2"
}
{
"TEST": "upper2",
"TEst": "half3"
}
{
"test": "lower3",
"TEST": "upper3"
}
{
"TEst": "half4",
"test": "lower4",
"TEST": "upper4"
}
{
"TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttest":"1",
"TesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttestTesttest
TesttestTesttestTesttestTesttestTest12345":"2"
}
创建 Flex 表 dupe，并加载 JSON 文件：
=> CREATE FLEX TABLE dupe();
CREATE TABLE
dbt=> COPY dupe FROM '/home/release/KData/repeated_key_name.json' parser fjsonparser();
Rows Loaded
-------------
8
(1 row)
接受一个 VMap 和一个或多个键/值对，并返回一个添加了键/值对的新 VMap。键必须使用辅助函数 SetMapKeys() 设置，并且只能是常量字符串。如果 VMap 有任何新的输入键，则原始值将被新的值替换。
MAPPUT (VMap-data, value[,...] USING PARAMETERS keys=SetMapKeys('key'[,...])
VMap-dataFlex 表的 __raw__ 列
从 MAPLOOKUP 等映射函数返回的数据。
其他数据库内容
value[,...]VMap-data 中指定的 VMap 的一个或多个值。keysSetMapKeys() 的结果。 SetMapKeys() 接受一个或多个常量字符串实参。以下示例展示了如何创建 Flex 表并使用 COPY 输入一些基本的 JSON 数据。创建第二个 Flex 表后，插入来自 mapput() 的新 VMap 结果，以及附加的键/值对。
创建样本表：
=> CREATE FLEX TABLE vmapdata1();
CREATE TABLE
从 STDIN 加载样本 JSON 数据：
=> COPY vmapdata1 FROM stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"aaa": 1, "bbb": 2, "ccc": 3}
>> \.
创建另一个 Flex 表并使用该函数将数据插入其中： => CREATE FLEX TABLE vmapdata2(); => INSERT INTO vmapdata2 SELECT MAPPUT(__raw__, '7','8','9' using parameters keys=SetMapKeys('xxx','yyy','zzz')) from vmapdata1;
查看原始 Flex 表和新 Flex 表之间的差异：
=> SELECT MAPTOSTRING(__raw__) FROM vmapdata1;
maptostring
-----------------------------------------------------
{
"aaa" : "1",
"bbb" : "2",
"ccc" : "3"
}
(1 row)
=> SELECT MAPTOSTRING(__raw__) from vmapdata2;
maptostring
-------------------------------------------------------
{
"mapput" : {
"aaa" : "1",
"bbb" : "2",
"ccc" : "3",
"xxx" : "7",
"yyy" : "8",
"zzz" : "9"
}
}
返回任何 VMap 数据中存在的虚拟列数。使用标量函数确定键的大小。
MAPSIZE (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
本例显示从 flex 表 darkmountain 中返回键数的大小：
=> SELECT MAPSIZE(__raw__) FROM darkmountain;
mapsize
---------
3
4
4
4
4
(5 rows)
递归地构建 VMap 数据的字符串表示形式，包括嵌套 JSON 映射。使用此转换函数以 LONG VARCHAR 格式显示 VMap 内容。在使用 MAPVALUES 查询虚拟列之前，您可以使用 MAPTOSTRING 查看映射数据是如何嵌套的。
MAPTOSTRING ( VMap-data [ USING PARAMETERS param=value ] )
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
canonical_json默认值： true
以下示例使用此表定义和示例数据：
=> CREATE FLEX TABLE darkdata();
CREATE TABLE
=> COPY darkdata FROM stdin parser fjsonparser();
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> {"aaa": 1, "aaa": 2, "AAA": 3, "bbb": "aaa\"bbb"}
>> \.
使用默认值 canonical_json 调用 MAPTOSTRING 仅返回重复键的第一个实例：
=> SELECT MAPTOSTRING (__raw__) FROM darkdata;
maptostring
------------------------------------------------------------
{
"AAA" : "3",
"aaa" : "1",
"bbb" : "aaa\"bbb"
}
(1 row)
canonical_json 设置为 false，函数返回所有键，包括重复键：
=> SELECT MAPTOSTRING(__raw__ using parameters canonical_json=false) FROM darkdata;
maptostring
---------------------------------------------------------------
{
"aaa": "1",
"aaa": "2",
"AAA": "3",
"bbb": "aaa"bbb"
}
(1 row)
返回表示来自 VMap 顶层值的字符串。此转换函数需要 OVER() 子句。
MAPVALUES (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
max_value_length__raw__ 列中，指定函数可以返回的值的最大长度。大于
max_value_length 的值会导致查询失败。默认为 VMap 列长度和 65K 中较小的值。下面的例子显示如何使用具有 darkmountain 的 over() 子句查询 over(PARTITION BEST) flex 表（在本例中使用 mapvalues() 子句）。
=> SELECT * FROM (SELECT MAPVALUES(darkmountain.__raw__) OVER(PARTITION BEST) FROM darkmountain) AS a;
values
---------------
29029
34.1
Everest
mountain
29029
15.4
Mt St Helens
volcano
17000
12.2
Denali
mountain
14000
22.8
Kilimanjaro
mountain
50.6
Mt Washington
mountain
(19 rows)
指定 MAPVALUES 可以返回的值的最大长度
=> SELECT MAPVALUES(__raw__ USING PARAMETERS max_value_length=100000) OVER() FROM mapper;
keys
-------------
five_Map
four
one
six
three_Array
two
(6 rows)
返回任何映射数据的版本或无效性。本标量函数返回映射版本（如 1），如果映射数据无效，则返回 -1。
MAPVERSION (VMap-data)
VMap-data任何 Vmap 数据。Vmap 的存在形式可以是：
Flex 表的 __raw__ 列
从映射函数返回的数据（示例） MAPLOOKUP
其他数据库内容
下面的例子显示如何使用 mapversion() 和 darkmountain flex 表，返回 flex 表映射数据的 mapversion 1。
=> SELECT MAPVERSION(__raw__) FROM darkmountain;
mapversion
------------
1
1
1
1
1
(5 rows)
格式化函数是一个强大的工具集，可以将各种数据类型 (DATE/TIME, INTEGER, FLOATING POINT) 转换为格式化的字符串，以及将格式化的字符串转换为特定数据类型。
返回 VARCHAR，表示位字符串格式的给定 VARBINARY 值。此函数是
BITSTRING_TO_BINARY 的反函数。
TO_BITSTRING ( expression )
=> SELECT TO_BITSTRING('ab'::BINARY(2));
to_bitstring
------------------
0110000101100010
(1 row)
=> SELECT TO_BITSTRING(HEX_TO_BINARY('0x10'));
to_bitstring
--------------
00010000
(1 row)
=> SELECT TO_BITSTRING(HEX_TO_BINARY('0xF0'));
to_bitstring
--------------
11110000
(1 row)
将日期/时间和数字值转换成文本字符串。
TO_CHAR ( expression [, pattern ] )
存在以下限制：
TO_CHAR 不支持二进制数据类型 BINARY 和 VARBINARY
TO_CHAR 不支持将 V 与小数点结合使用，例如， 99.9V99
Vertica 使用前置空格填充 TO_CHAR 输出，因此正值和负值具有相同的长度。要抑制填充，请使用 FM 前缀。
如果您将 TIME 显式转换为 TIMESTAMP 并将 TIMETZ 转换为 TIMESTAMPTZ，则 TO_CHAR 接受 TIME 和 TIMETZ 数据类型作为输入。
=> SELECT TO_CHAR(TIME '14:34:06.4','HH12:MI am'), TO_CHAR(TIMETZ '14:34:06.4+6','HH12:MI am');
TO_CHAR | TO_CHAR
----------+----------
02:34 pm | 04:34 am
(1 row)
您可以从 TIMETZ 提取时区小时：
=> SELECT EXTRACT(timezone_hour FROM TIMETZ '10:30+13:30');
date_part
-----------
13
(1 row)
普通字面量允许用于 TO_CHAR 模板，并且将当做字面量输出。您可以将子字符串放入双引号中，以强制它转换为字面量，即使包含模式关键词。在以下示例中，YYYY 被替换为年份数据，但 Year 中的 Y 不是：
=> SELECT to_char(CURRENT_TIMESTAMP, '"Hello Year " YYYY');
to_char
------------------
Hello Year 2021
(1 row)
如果规定 INTERVAL 类型，TO_CHAR 以 HH 和 HH12 作为一天的小时数，而 HH24 可输出超过一天的小时数，例如 >24。
要在输出中包含双引号 (") 字符，请在其前面加上双反斜杠 (\\)。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\"YYYY Month\\"'
四舍五入时，如果数字正好是两者的中间值，舍入表示形式的最后一位数应选择偶数。
转换字符串值为 DATE 类型。
TO_DATE ( expression , pattern )
CHAR 或 VARCHAR。CHAR 或 VARCHAR。请参阅：
TO_DATE 需要 CHAR 或 VARCHAR 表达式。对于其他输入类型，请先使用
TO_CHAR 来执行显式强制转换为 CHAR 或 VARCHAR，才能使用此函数。
'\\\"YYYY Month\\\"'TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：
TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。
TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。
如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：
=> SELECT TO_DATE('200001131','YYYYMMDD');
TO_DATE
------------
2000-01-13
(1 row)
应在年份后使用非数字分隔符。例如：
=> SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
TO_DATE
-------------
20000-12-01
(1 row)
在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。
=> SELECT TO_DATE('13 Feb 2000', 'DD Mon YYYY');
to_date
------------
2000-02-13
(1 row)
返回 VARCHAR 或 VARBINARY，表示等同于数值的十六进制值。此函数是 HEX_TO_BINARY 的反转函数。
TO_HEX ( number )
=> SELECT TO_HEX(123456789);
TO_HEX
---------
75bcd15
(1 row)
对于 VARBINARY 输入，返回值没有 0x 前缀。例如：
=> SELECT TO_HEX('ab'::binary(2));
TO_HEX
--------
6162
(1 row)
将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP 类型。
TO_TIMESTAMP ( { expression, pattern } | unix‑epoch )
在从字符串到 TIMESTAMP 的转换中，毫秒 (MS) 和微秒 (US) 值用作秒小数点后面的部分。例如 TO_TIMESTAMP('12:3', 'SS:MS') 不是指 3 毫秒，而是指 300 毫秒，因为转换将其算作 12 + 0.3 秒。这意味着，对于 SS:MS 格式而言，输入值 12:3、12:30 和 12:300 指定的是相同的毫秒数。要得到 3 毫秒，请使用 12:003，转换将其算作 12 + 0.003 = 12.003 秒。
下面是一个更为复杂的示例： TO_TIMESTAMP('15:12:02.020.001230', 'HH:MI:SS.MS.US') 表示 15 小时 12 分钟零 2 秒 + 20 毫秒 + 1230 微秒 = 2.021230 秒。
要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'
TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：
TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。
TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。
如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：
=> SELECT TO_DATE('200001131','YYYYMMDD');
TO_DATE
------------
2000-01-13
(1 row)
应在年份后使用非数字分隔符。例如：
=> SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
TO_DATE
-------------
20000-12-01
(1 row)
在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。
=> SELECT TO_TIMESTAMP('13 Feb 2009', 'DD Mon YYYY');
TO_TIMESTAMP
---------------------
1200-02-13 00:00:00
(1 row)
=> SELECT TO_TIMESTAMP(200120400);
TO_TIMESTAMP
---------------------
1976-05-05 01:00:00
(1 row)
将字符串值或 UNIX/POSIX 时期值转换为 TIMESTAMP WITH TIME ZONE 类型。
TO_TIMESTAMP_TZ ( { expression, pattern } | unix‑epoch )
在从字符串到 TIMESTAMP 的转换中，毫秒 (MS) 和微秒 (US) 值用作秒小数点后面的部分。例如 TO_TIMESTAMP('12:3', 'SS:MS') 不是指 3 毫秒，而是指 300 毫秒，因为转换将其算作 12 + 0.3 秒。这意味着，对于 SS:MS 格式而言，输入值 12:3、12:30 和 12:300 指定的是相同的毫秒数。要得到 3 毫秒，请使用 12:003，转换将其算作 12 + 0.003 = 12.003 秒。
下面是一个更为复杂的示例： TO_TIMESTAMP('15:12:02.020.001230', 'HH:MI:SS.MS.US') 表示 15 小时 12 分钟零 2 秒 + 20 毫秒 + 1230 微秒 = 2.021230 秒。
要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'
TO_TIMESTAMP如果不使用 FX 选项，则、TO_TIMESTAMP_TZ 和 TO_DATE 会跳过输入字符串中的多个空格。必须将 FX 指定为模板中的第一项。例如：
TO_TIMESTAMP('2000 JUN', 'YYYY MON') 是正确的。
TO_TIMESTAMP('2000 JUN', 'FXYYYY MON') 返回错误，因为 TO_TIMESTAMP 仅接受一个空格。
如果使用多于四个数字的年份，则从字符串到 TIMESTAMP 或 DATE 的 YYYY 转换存在限制。在 YYYY 之后必须使用非数字字符或模板，否则会始终将年份解释成四个数字。例如，给定以下实参，TO_DATE 将五位数年份 20000 解释为四位数年份：
=> SELECT TO_DATE('200001131','YYYYMMDD');
TO_DATE
------------
2000-01-13
(1 row)
应在年份后使用非数字分隔符。例如：
=> SELECT TO_DATE('20000-1131', 'YYYY-MMDD');
TO_DATE
-------------
20000-12-01
(1 row)
在从字符串到 TIMESTAMP 或 DATE 的转换中，如果存在 YYY、YYYY 或 Y,YYY 字段，则会忽略 CC 字段。如果将 CC 与 YY 或 Y 一起使用，则将按 (CC–1)*100+YY 计算年份。
=> SELECT TO_TIMESTAMP_TZ('13 Feb 2009', 'DD Mon YYY');
TO_TIMESTAMP_TZ
------------------------
1200-02-13 00:00:00-05
(1 row)
=> SELECT TO_TIMESTAMP_TZ(200120400);
TO_TIMESTAMP_TZ
------------------------
1976-05-05 01:00:00-04
(1 row)
转换字符串值为 DOUBLE PRECISION。
TO_NUMBER ( expression, [ pattern ] )
TO_NUMBER 返回浮点数。要在输出中使用双引号字符，请在它前面加上双反斜杠。这样做很有必要，因为反斜杠在字符串常数中已经具有特殊含义。例如： '\\\"YYYY Month\\\"'
=> SELECT TO_NUMBER('MCML', 'rn');
TO_NUMBER
-----------
1950
(1 row)
如果省略了 pattern 参数，则函数返回浮点。例如：
=> SELECT TO_NUMBER('-123.456e-01');
TO_NUMBER
-----------
-12.3456
在输出模板字符串（用于 TO_CHAR）中，某些得到确认的模式会以待格式化值的合适格式化数据替代。非模板模式的文本将逐字复制。同样，在输入模板字符串（用于除 TO_CHAR 之外的任何情形）中，模板模式会识别待查看的输入数据字符串部分，以及要找到的值。
Vertica 对 Vertica 日志文件中的日期/时间字段使用 ISO 8601:2004 样式。例如：
2020-03-25 05:04:22.372 Init Session:0x7f8fcefec700-a000000013dcd4 [Txn] <INFO> Begin Txn: a000000013dcd4 'read role info'
某些修饰符可应用于任何日期/时间模板模式以改变其行为。例如，FMMonth 是带 Month 修饰符的 FM 模式。
使用 TO_TIMESTAMP 来转换使用模式 'YYY MON' 的表达式：
=> SELECT TO_TIMESTAMP('2017 JUN', 'YYYY MON');
TO_TIMESTAMP
---------------------
2017-06-01 00:00:00
(1 row)
使用 TO_DATE 来转换使用模式 'YYY-MMDD' 的表达式：
=> SELECT TO_DATE('2017-1231', 'YYYY-MMDD');
TO_DATE
------------
2017-12-31
(1 row)
使用 SG、PL 或 MI 格式化的符号不能锚定在数字上。例如：
=> SELECT to_char(-12, 'S9999'), to_char(-12, 'MI9999');
to_char | to_char
---------+---------
-12 | - 12
(1 row)
TO_CHAR(-12, 'S9999') 生成 ' -12'
TO_CHAR(-12, 'MI9999') 生成 '- 12'
由于有 9 个 S，因此会生成 9 个相同位数的值。如果一个数字不可用，则会输出一个空格。
TH 不会转换小于 0 的值，而且不会转换分数。
V 表示使用输入值乘以 10^n，其中 n 是 V 后面的数字位数。TO_CHAR 不支持使用 V 结合小数点。例如：99.9V99。
地理空间函数处理复杂的二维空间对象，并根据开放地理空间联盟 (OGC) 标准将它们存储在数据库中。
地理空间函数使用以下命名约定：
大多数 ST_function‑name 函数符合最新 OGC 标准 OGC SFA-SQL 版本 1.2.1（参考编号为 OGC 06-104r4，日期：2010 年 8 月 4 日）。当前，一些 ST_function‑name 函数可能不支持所有数据类型。每个函数页包含了关于支持的数据类型的详细信息。
STV_function‑name 函数专门用于 Vertica 并且不符合 OGC 标准。每个函数页详细说明了其功能。
许多空间函数不会验证其参数。如果将无效的空间对象传递给 ST_ 或 STV_ 函数，函数可能会返回错误或生成错误的结果。
为避免这种问题，Vertica 建议您首先对所有空间对象运行 ST_IsValid 以验证参数。如果对象无效，则运行 STV_IsValidReason 以获取关于无效性原因的信息。
创建空间对象的熟知文本 (WKT) 表示。当需要指定 ASCII 形式的空间对象时可使用此函数。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范定义了 WKT 字符串的格式。
ST_AsText( g )
gLONG VARCHAR
以下示例显示了 ST_AsText 的用法。
检索 WKB 和 WKT 表示：
=> CREATE TABLE locations (id INTEGER, name VARCHAR(100), geom1 GEOMETRY(800),
geom2 GEOGRAPHY);
CREATE TABLE
=> COPY locations
(id, geom1x FILLER LONG VARCHAR(800), geom1 AS ST_GeomFromText(geom1x), geom2x FILLER LONG VARCHAR (800),
geom2 AS ST_GeographyFromText(geom2x))
FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(2 3)|
>> 2|LINESTRING(2 4,1 5)|
>> 3||POLYGON((-70.96 43.27,-70.67 42.95,-66.90 44.74,-67.81 46.08,-67.81 47.20,-69.22 47.43,-71.09 45.25,-70.96 43.27))
>> \\.
=> SELECT id, ST_AsText(geom1),ST_AsText(geom2) FROM locations ORDER BY id ASC;
id | ST_AsText | ST_AsText
----+-----------------------+---------------------------------------------
1 | POINT (2 3) |
2 | LINESTRING (2 4, 1 5) |
3 | | POLYGON ((-70.96 43.27, -70.67 42.95, -66.9 44.74, -67.81 46.08, -67.81 47.2, -69.22 47.43, -71.09 45.25, -70.96 43.27))
(3 rows)
使用 Vertica SQL 函数 LENGTH 计算 WKT 的长度：
=> SELECT LENGTH(ST_AsText(St_GeomFromText('POLYGON ((-1 2, 0 3, 1 2,
0 1, -1 2))')));
LENGTH
--------
37
(1 row)
计算空间对象的面积。
单位为：
GEOMETRY 对象：空间参照系标识符 (SRID) 单位
GEOGRAPHY 对象：平方米
ST_Area( g )
gFLOAT
以下示例显示了 ST_Area 的用法。
计算多边形的面积：
=> SELECT ST_Area(ST_GeomFromText('POLYGON((0 0,1 0,1 1,0 1,0 0))'));
ST_Area
---------
1
(1 row)
计算多边形集合的面积：
=> SELECT ST_Area(ST_GeomFromText('MultiPolygon(((0 0,1 0,1 1,0 1,0 0)),
((2 2,2 3,4 6,3 3,2 2)))'));
ST_Area
---------
3
(1 row)
如下图所示，假定多边形包含一个孔。
计算不包括孔面积在内的面积：
=> SELECT ST_Area(ST_GeomFromText('POLYGON((2 2,5 5,8 2,2 2),
(4 3,5 4,6 3,4 3))'));
ST_Area
---------
8
(1 row)
计算几何图形集合的面积：
=> SELECT ST_Area(ST_GeomFromText('GEOMETRYCOLLECTION(POLYGON((20.5 20.45,
20.51 20.52,20.69 20.32,20.5 20.45)),POLYGON((10 20,30 40,25 50,10 20)))'));
ST_Area
----------
150.0073
(1 row)
计算地理对象的面积：
=> SELECT ST_Area(ST_GeographyFromText('POLYGON((20.5 20.45,20.51 20.52,
20.69 20.32,20.5 20.45))'));
ST_Area
------------------
84627437.116037
(1 row)
创建空间对象的熟知二进制 (WKB) 表示。当需要将对象转换为二进制格式以便与其他应用程序移植空间数据时，可使用此函数。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范定义了 WKB 表示的格式。
ST_AsBinary( g )
gLONG VARBINARY
以下示例显示了 ST_AsBinary 的用法。
检索 WKB 和 WKT 表示：
=> CREATE TABLE locations (id INTEGER, name VARCHAR(100), geom1 GEOMETRY(800), geom2 GEOGRAPHY);
CREATE TABLE
=> COPY locations
(id, geom1x FILLER LONG VARCHAR(800), geom1 AS ST_GeomFromText(geom1x), geom2x FILLER LONG VARCHAR (800),
geom2 AS ST_GeographyFromText(geom2x))
FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(2 3)|
>> 2|LINESTRING(2 4,1 5)|
>> 3||POLYGON((-70.96 43.27,-70.67 42.95,-66.90 44.74,-67.81 46.08,-67.81 47.20,-69.22 47.43,-71.09 45.25,-70.96 43.27))
>> \\.
=> SELECT id, ST_AsText(geom1),ST_AsText(geom2) FROM locations ORDER BY id ASC;
id | ST_AsText | ST_AsText
----+-----------------------+---------------------------------------------
1 | POINT (2 3) |
2 | LINESTRING (2 4, 1 5) |
3 | | POLYGON ((-70.96 43.27, -70.67 42.95, -66.9 44.74, -67.81 46.08, -67.81 47.2, -69.22 47.43, -71.09 45.25, -70.96 43.27))
=> SELECT id, ST_AsBinary(geom1),ST_AsBinary(geom2) FROM locations ORDER BY id ASC;
.
.
.
(3 rows)
使用 Vertica SQL 函数 LENGTH 计算 WKB 的长度：
=> SELECT LENGTH(ST_AsBinary(St_GeomFromText('POLYGON ((-1 2, 0 3, 1 2,
0 1, -1 2))')));
LENGTH
--------
93
(1 row)
计算指定 GEOMETRY 对象的边界。对象边界是指定义对象限制的点集。
对于线串，边界是起点和终点。对于多边形，边界是在同一点开始和结束的线串。
ST_Boundary( g )
gGEOMETRY
以下示例显示了 ST_Boundary 的用法。
返回表示边界的线串：
=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON((-1 -1,2 2,
0 1,-1 -1))')));
ST_AsText
--------------
LINESTRING(-1 -1, 2 2, 0 1, -1 -1)
(1 row)
返回包含两个多边形边界的线串集合：
=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON((2 2,5 5,8 2,2 2),
(4 3,5 4,6 3,4 3))')));
ST_AsText
------------------------------------------------------------------
MULTILINESTRING ((2 2, 5 5, 8 2, 2 2), (4 3, 5 4, 6 3, 4 3))
(1 row)
线串的边界是其起点和终点：
=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText(
'LINESTRING(1 1,2 2,3 3,4 4)')));
ST_AsText
-----------------------
MULTIPOINT (1 1, 4 4)
(1 row)
封闭的线串没有边界，因为它没有起点和终点：
=> SELECT ST_AsText(ST_Boundary(ST_GeomFromText(
'LINESTRING(1 1,2 2,3 3,4 4,1 1)')));
ST_AsText
------------------
MULTIPOINT EMPTY
(1 row)
创建与某个空间对象边界的距离大于或等于指定距离的 GEOMETRY 对象。该距离使用笛卡尔坐标单位测量。ST_Buffer 不接受大于 +1e15 或小于 –1e15 的距离大小。
ST_Buffer( g, d )
gdGEOMETRY
如果指定正距离，则 ST_Buffer 将返回表示对象外部距离小于或等于指定距离的点的多边形。如果指定负距离，则 ST_Buffer 将返回表示对象内部距离小于或等于指定距离的点的多边形。
对于点、多点、线串和多线串，如果指定负距离，ST_Buffer 将返回空多边形。
Vertica Place 版本的 ST_Buffer 将返回多边形形式的缓冲区，因此缓冲区对象在其顶点处包含拐角。它不包含圆角。
以下示例显示了 ST_Buffer 的用法。
返回 GEOMETRY 对象：
=> SELECT ST_AsText(ST_Buffer(ST_GeomFromText('POLYGON((0 1,1 4,4 3,0 1))'),1));
ST_AsText
------------------------------------------------------------------------------
POLYGON ((-0.188847498856 -0.159920845081, -1.12155598386 0.649012935089, 0.290814745534 4.76344136152,
0.814758063466 5.02541302048, 4.95372324225 3.68665254814, 5.04124517538 2.45512549204, -0.188847498856 -0.159920845081))
(1 row)
计算空间对象的几何中心（即质心）。如果几何图形除多边形外还存在点、线串或同时存在此二者，则质心计算仅考虑多边形。类似地，如果除线串外还存在点，则质心计算不考虑点。
要计算 GEOGRAPHY 对象的质心，请参阅 STV_Geometry 和 STV_Geography 的示例。
ST_Centroid( g )
gGEOMETRY（仅 POINT）
以下示例显示了 ST_Centroid 的用法。
计算多边形的质心：
=> SELECT ST_AsText(ST_Centroid(ST_GeomFromText('POLYGON((-1 -1,2 2,-1 2,
-1 -1))')));
ST_AsText
------------
POINT (-0 1)
(1 row)
计算多边形集合的质心：
=> SELECT ST_AsText(ST_Centroid(ST_GeomFromText('MULTIPOLYGON(((1 0,2 1,2 0,
1 0)),((-1 -1,2 2,-1 2,-1 -1)))')));
ST_AsText
--------------------------------------
POINT (0.166666666667 0.933333333333)
(1 row)
此图显示了多边形集合的质心。
确定空间对象是否完全在另一个空间对象内部，并且不仅仅在其边界上存在。两个参数必须是相同的空间数据类型。要么指定两个 GEOMETRY 对象，要么指定两个 GEOGRAPHY 对象。
如果某个对象（例如点或线串）仅沿空间对象的边界存在，则 ST_Contains 将返回 False。线串的内部是线串上除起点和终点以外的所有点。
ST_Contains(g1, g2) 在功能上等同于 ST_Within(g2, g1)。
不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。
ST_Contains( g1, g2
[USING PARAMETERS spheroid={true | false}] )
g1g2spheroid = {true | false}（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
BOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 ST_Contains 的用法。
第一个多边形未完全包含第二个多边形：
=> SELECT ST_Contains(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'),
ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))'));
ST_Contains
-------------
f
(1 row)
如果点在线串上，但不在终点上：
=> SELECT ST_Contains(ST_GeomFromText('LINESTRING(20 20,30 30)'),
ST_GeomFromText('POINT(25 25)'));
ST_Contains
--------------
t
(1 row)
如果点在多边形的边界上：
=> SELECT ST_Contains(ST_GeographyFromText('POLYGON((20 20,30 30,30 25,20 20))'),
ST_GeographyFromText('POINT(20 20)'));
ST_Contains
--------------
f
(1 row)
两个在空间上等效的多边形：
=> SELECT ST_Contains (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
ST_GeomFromText('POLYGON((0 3, -1 2, 0 1, 0 3))'));
ST_Contains
--------------
t
(1 row)
计算包含 GEOMETRY 对象的最小凸 GEOMETRY 对象。
ST_ConvexHull( g )
gGEOMETRY
以下示例显示了 ST_ConvexHull 的用法。
对于几何图形集合中的点对：
=> SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText('GEOMETRYCOLLECTION(
POINT(1 1),POINT(0 0))')));
ST_AsText
-----------------------
LINESTRING (1 1, 0 0)
(1 row)
对于几何图形集合：
=> SELECT ST_AsText(ST_ConvexHull(ST_GeomFromText('GEOMETRYCOLLECTION(
LINESTRING(2.5 3,-2 1.5), POLYGON((0 1,1 3,1 -2,0 1)))')));
ST_AsText
---------------------------------------------
POLYGON ((1 -2, -2 1.5, 1 3, 2.5 3, 1 -2))
(1 row)
实线表示原始几何图形集合，虚线表示凸包。
确定一个 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上交叉。如果两个对象仅在边界上接触，则 ST_Crosses 将返回 FALSE。
如果以下两项均成立，则表示两个对象在空间上交叉：
两个对象具有部分但非全部的公共内点。
它们的相交结果的尺寸小于两个对象的最大尺寸。
ST_Crosses( g1, g2 )
g1g2BOOLEAN
以下示例显示了 ST_Crosses 的用法。
=> SELECT ST_Crosses(ST_GeomFromText('LINESTRING(-1 3,1 4)'),
ST_GeomFromText('LINESTRING(-1 4,1 3)'));
ST_Crosses
------------
t
(1 row)
=> SELECT ST_Crosses(ST_GeomFromText('LINESTRING(-1 1,1 2)'),
ST_GeomFromText('POLYGON((1 1,0 -1,3 -1,2 1,1 1))'));
ST_Crosses
------------
f
(1 row)
=> SELECT ST_Crosses(ST_GeomFromText('POINT(-1 4)'),
ST_GeomFromText('LINESTRING(-1 4,1 3)'));
ST_ Crosses
------------
f
(1 row)
计算空间对象没有与另一个空间对象相交的部分。
ST_Difference( g1, g2 )
g1g2GEOMETRY
以下示例显示了 ST_Difference 的用法。
两个重叠的线串：
=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('LINESTRING(0 0,0 2)'),
ST_GeomFromText('LINESTRING(0 1,0 2)')));
ST_AsText
-----------------------
LINESTRING (0 0, 0 1)
(1 row)
=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('LINESTRING(0 0,0 3)'),
ST_GeomFromText('LINESTRING(0 1,0 2)')));
ST_AsText
------------------------------------------
MULTILINESTRING ((0 0, 0 1), (0 2, 0 3))
(1 row)
两个重叠的多边形：
=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('POLYGON((0 1,0 3,2 3,2 1,0 1))'),
ST_GeomFromText('POLYGON((0 0,0 2,2 2,2 0,0 0))')));
ST_AsText
-------------------------------------
POLYGON ((0 2, 0 3, 2 3, 2 2, 0 2))
(1 row)
两个未相交的多边形：
=> SELECT ST_AsText(ST_Difference(ST_GeomFromText('POLYGON((1 1,1 3,3 3,3 1,
1 1))'),ST_GeomFromText('POLYGON((1 5,1 7,-1 7,-1 5,1 5))')));
ST_AsText
-------------------------------------
POLYGON ((1 1, 1 3, 3 3, 3 1, 1 1))
(1 row)
确定两个 GEOMETRY 对象是否未相交也未接触。
如果 ST_Disjoint 针对一对 GEOMETRY 对象返回 TRUE，则 ST_Intersects 将针对这两个相同的对象返回 FALSE。
不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。
ST_Disjoint( g1, g2
[USING PARAMETERS spheroid={true | false}] )
g1g2spheroid = {true | false}（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
BOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 ST_Disjoint 的用法。
两个未相交或接触的多边形：
=> SELECT ST_Disjoint (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((1 0, 1 1, 2 2, 1 0))'));
ST_Disjoint
-------------
t
(1 row)
两个相交的线串：
=> SELECT ST_Disjoint(ST_GeomFromText('LINESTRING(-1 2,0 3)'),
ST_GeomFromText('LINESTRING(0 2,-1 3)'));
ST_Disjoint
-------------
f
(1 row)
两个在一个点接触的多边形：
=> SELECT ST_Disjoint (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
ST_GeomFromText('POLYGON((0 2, 1 1, 1 2, 0 2))'));
ST_Disjoint
--------------
f
(1 row)
计算两个空间对象之间的最短距离。对于 GEOMETRY 对象，距离使用笛卡尔坐标单位测量。对于 GEOGRAPHY 对象，距离以米为单位测量。
g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。
ST_Distance( g1, g2
[USING PARAMETERS spheroid={ true | false } ] )
g1g2spheroid = { true | false } （可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
FLOAT
兼容的 GEOGRAPHY 对：
Vertica 建议在使用 ST_Distance 之前裁剪无效的数据。无效的地理值可能返回无保证的结果。
以下示例显示了 ST_Distance 的用法。
两个多边形之间的距离：
=> SELECT ST_Distance(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
ST_GeomFromText('POLYGON((5 2,7 4,5 5,5 2))'));
ST_Distance
-------------
3
(1 row)
点和线串之间的距离（以米为单位）：
=> SELECT ST_Distance(ST_GeographyFromText('POINT(31.75 31.25)'),
ST_GeographyFromText('LINESTRING(32 32,32 35,40.5 35,32 35,32 32)'));
ST_Distance
------------------
86690.3950562969
(1 row)
计算包含指定的 GEOMETRY 对象的最小边界矩形。
ST_Envelope( g )
gGEOMETRY
以下示例显示了 ST_Envelope 的用法。
返回最小边界矩形：
=> SELECT ST_AsText(ST_Envelope(ST_GeomFromText('POLYGON((0 0,1 1,1 2,2 2,
2 1,3 0,1.5 -1.5,0 0))')));
ST_AsText
-------------------------------------------
POLYGON ((0 -1.5, 3 -1.5, 3 2, 0 2, 0 -1.5))
(1 row)
确定两个空间对象在空间上是否等效。ST_Equals 的两个对象的坐标及其 WKT/WKB 表示必须完全匹配才能返回 TRUE。
在确定空间等价关系时点的顺序不重要：
LINESTRING(1 2, 4 3) 等于 LINESTRING(4 3, 1 2)。
POLYGON ((0 0, 1 1, 1 2, 2 2, 2 1, 3 0, 1.5 -1.5, 0 0)) 等于 POLYGON((1 1 , 1 2, 2 2, 2 1, 3 0, 1.5 -1.5, 0 0, 1 1))。
MULTILINESTRING((1 2, 4 3),(0 0, -1 -4)) 等于 MULTILINESTRING((0 0, -1 -4),(1 2, 4 3))。
坐标存储为 FLOAT 类型。因此，在导入熟知文本 (WKT) 值时，由于浮点数表示的限制，预期会出现舍入误差。
g1 和 g2 必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。此外，g1 和 g2 不能都是 GeometryCollection 类型。
ST_Equals( g1, g2 )
g1g2 相比的空间对象，类型为 GEOMETRY 或 GEOGRAPHYg2g1 相比的空间对象，类型为 GEOMETRY 或 GEOGRAPHYBOOLEAN
以下示例显示了 ST_Equals 的用法。
两个线串：
=> SELECT ST_Equals (ST_GeomFromText('LINESTRING(-1 2, 0 3)'),
ST_GeomFromText('LINESTRING(0 3, -1 2)'));
ST_Equals
--------------
t
(1 row)
两个多边形：
=> SELECT ST_Equals (ST_GeographyFromText('POLYGON((43.22 42.21,40.3 39.88,
42.1 50.03,43.22 42.21))'),ST_GeographyFromText('POLYGON((43.22 42.21,
40.3 39.88,42.1 50.31,43.22 42.21))'));
ST_Equals
--------------
f
(1 row)
将熟知文本 (WKT) 字符串转换为其对应的 GEOGRAPHY 对象。使用此函数可将 WKT 字符串转换为 Vertica Place 函数所需的格式。
GEOGRAPHY 对象是在地球表面使用坐标 (longitude, latitude) 定义的空间对象。坐标使用划分地球的参考平面的度数（经度、纬度）表示。
GEOGRAPHY 对象的最大大小为 10 MB。如果将 WKT 传递给 ST_GeographyFromText 并且生成大小超过 10 MB 的空间对象，ST_GeographyFromText 将会返回错误。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 7 节定义了 WKT 字符串的格式。
ST_GeographyFromText( wkt [ USING PARAMETERS ignore_errors={'y'|'n'} ] )
wktignore_errorsNULL—如果 wkt 无效并且 ignore_errors='y'。
Error—如果 wkt 无效并且 ignore_errors='n' 或未指定。
GEOGRAPHY
以下示例显示了 ST_GeographyFromText 的用法。
将 WKT 转换为 GEOGRAPHY 对象：
=> CREATE TABLE wkt_ex (g GEOGRAPHY);
CREATE TABLE
=> INSERT INTO wkt_ex VALUES(ST_GeographyFromText('POLYGON((1 2,3 4,2 3,1 2))'));
OUTPUT
--------
1
(1 row)
将熟知二进制 (WKB) 值转换为其对应的 GEOGRAPHY 对象。使用此函数可将 WKB 转换为 Vertica Place 函数所需的格式。
GEOGRAPHY 对象是在地球表面定义的空间对象。坐标使用划分地球的参考平面的度数（经度、纬度）表示。所有的计算都以米为单位。
GEOGRAPHY 对象的最大大小为 10 MB。如果将 WKB 传递给 ST_GeographyFromWKB 并且生成大小超过 10 MB 的空间对象，ST_GeographyFromWKB 将会返回错误。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 8 节定义了 WKB 表示的格式。
ST_GeographyFromWKB( wkb [ USING PARAMETERS ignore_errors={'y'|'n'} ] )
wkbignore_errorsNULL—如果 wkb 无效并且 ignore_errors='y'。
Error—如果 wkb 无效并且 ignore_errors='n' 或未指定。
GEOGRAPHY
以下示例显示了 ST_GeographyFromWKB 的用法。
将 WKB 转换为 GEOGRAPHY 对象：
=> CREATE TABLE wkb_ex (g GEOGRAPHY);
CREATE TABLE
=> INSERT INTO wkb_ex VALUES(ST_GeographyFromWKB(X'0103000000010000000 ... );
OUTPUT
--------
1
(1 row)
以指定的几何图形形状返回 GeoHash。
ST_GeoHash( SpatialObject [ USING PARAMETERS numchars=n] )
GEOHASH
以下示例显示了如何使用 ST_PointFromGeoHash。
为指定几何图形生成全精度 GeoHash：
=> SELECT ST_GeoHash(ST_GeographyFromText('POINT(3.14 -1.34)'));
ST_GeoHash
----------------------
kpf0rkn3zmcswks75010
(1 row)
根据指定几何图形的前五个字符生成 GeoHash：
=> select ST_GeoHash(ST_GeographyFromText('POINT(3.14 -1.34)')USING PARAMETERS numchars=5);
ST_GeoHash
------------
kpf0r
(1 row)
返回几何图形对象内的第 n 个几何图形。
如果 n 超出索引范围，则返回 NULL。
ST_GeometryN( g , n )
g n GEOMETRY
以下示例显示了 ST_GeometryN 的用法。
返回多边形集合中的第二个几何图形：
=> CREATE TABLE multipolygon_geom (gid int, geom GEOMETRY(1000));
CREATE TABLE
=> COPY multipolygon_geom(gid, gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>9|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\.
=> SELECT gid, ST_AsText(ST_GeometryN(geom, 2)) FROM multipolygon_geom;
gid | ST_AsText
-----+--------------------------------
9 | POLYGON ((0 0, 0 5, 1 0, 0 0))
(1 row)
返回多边形集合内的所有几何图形：
=> CREATE TABLE multipolygon_geom (gid int, geom GEOMETRY(1000));
CREATE TABLE
=> COPY multipolygon_geom(gid, gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>9|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\.
=> CREATE TABLE series_numbers (numbs int);
CREATE TABLE
=> COPY series_numbers FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1
>> 2
>> 3
>> 4
>> 5
>> \.
=> SELECT numbs, ST_AsText(ST_GeometryN(geom, numbs))
FROM multipolygon_geom, series_numbers
WHERE ST_AsText(ST_GeometryN(geom, numbs)) IS NOT NULL
ORDER BY numbs ASC;
numbs | ST_AsText
-------+------------------------------------------
1 | POLYGON ((2 6, 2 9, 6 9, 7 7, 4 6, 2 6))
2 | POLYGON ((0 0, 0 5, 1 0, 0 0))
3 | POLYGON ((0 2, 2 5, 4 5, 0 2))
(3 rows)
确定空间对象的类。
ST_GeometryType( g )
gVARCHAR
以下示例显示了 ST_GeometryType 的用法。
返回空间类：
=> SELECT ST_GeometryType(ST_GeomFromText('GEOMETRYCOLLECTION(LINESTRING(1 1,
2 2), POLYGON((1 3,4 5,2 2,1 3)))'));
ST_GeometryType
-----------------------
ST_GeometryCollection
(1 row)
以指定的 GeoHash 形状返回多边形。
ST_GeomFromGeoHash(GeoHash)
GEOGRAPHY
以下示例显示了如何使用 ST_GeomFromGeoHash。
将 GeoHash 字符串转换为 Geography 对象并转换回 GeoHash
=> SELECT ST_GeoHash(ST_GeomFromGeoHash(‘vert1c9’));
ST_GeoHash
--------------------
vert1c9
(1 row)
返回指定 GeoHash 的多边形并使用 ST_AsText 将多边形、矩形图块转换为熟知文本：
=> SELECT ST_AsText(ST_GeomFromGeoHash('drt3jj9n4dpcbcdef'));
ST_AsText
------------------------------------------------------------------------------------------------------------------------------------------------------------------
POLYGON ((-71.1459699298 42.3945346513, -71.1459699297 42.3945346513, -71.1459699297 42.3945346513, -71.1459699298 42.3945346513, -71.1459699298 42.3945346513))
(1 row)
返回指定 GeoHash 的多个多边形及其面积。高级 GeoHash (1234) 的多边形面积很大，而低级 GeoHash (1234567890bcdefhjkmn) 的面积为零。
=> SELECT ST_Area(short) short_area, ST_AsText(short) short_WKT, ST_Area(long) long_area, ST_AsText(long) long_WKT from (SELECT ST_GeomFromGeoHash('1234') short, ST_GeomFromGeoHash('1234567890bcdefhjkmn') long) as foo;
-[ RECORD 1 ]---------------------------------------------------------------------------------------------------------------------------------------------------------------------
short_area | 24609762.8991076
short_WKT | POLYGON ((-122.34375 -88.2421875, -121.9921875 -88.2421875, -121.9921875 -88.06640625, -122.34375 -88.06640625, -122.34375 -88.2421875))
long_area | 0
long_WKT | POLYGON ((-122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551, -122.196077187 -88.2297377551))
将标准格式的 GeoJSON 记录的几何图形部分转换为 GEOMETRY 对象。当您提供 GeoJSON 功能或 FeatureCollection 对象时，此函数会返回错误。
ST_GeomFromGeoJSON( geojson [, srid] [ USING PARAMETERS param=value[,...] ] );
Vertica 接受以下 GeoJSON 键值：
类型
坐标
几何形状
其他键值被忽略。
GEOMETRY 对象的空间参照系标识符 (SRID)，类型为 INTEGER。
SRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。
该实参在不执行操作时是可选的。
ignore_3dtrue：从返回的 GEOMETRY 对象中移除 3D 和更高维数据。
false（默认值）：当 GeoJSON 包含 3D 或更高维数据时返回错误。
ignore_errorstrue：在 GeoJSON 解析期间忽略错误并返回 NULL。
false（默认值）：如果 GeoJSON 解析失败，则返回错误。
ignore_errors 设置优先于 ignore_3d 设置。例如，如果 ignore_errors 设置为 true 并且 ignore_3d 设置为 false，如果 GeoJSON 对象包含 3D 和更高维数据，则该函数返回 NULL。
GEOMETRY
Point
Multipoint
Linestring
Multilinestring
Polygon
Multipolygon
GeometryCollection
以下示例显示了如何使用 ST_GeomFromGeoJSON。
以下示例使用 ST_IsValid 验证 ST_GeomFromGeoJSON 语句。该语句包含 SRID 4326 以指示点数据类型表示纬度和经度坐标，并将 ignore_3d 设置为 true 以忽略表示高度的最后一个值：
=> SELECT ST_IsValid(ST_GeomFromGeoJSON('{"type":"Point","coordinates":[35.3606, 138.7274, 29032]}', 4326 USING PARAMETERS ignore_3d=true));
ST_IsValid
------------
t
(1 row)
以下示例处理来自 STDIN 的 GeoJSON 类型并将它们存储在 GEOMETRY 数据类型表列中：
创建一个名为 polygons 的表，用于存储 GEOMETRY 空间类型：
=> CREATE TABLE polygons(geom GEOMETRY(1000));
CREATE TABLE
使用 COPY 从 STDIN 读取支持的 GEOMETRY 数据类型并将它们存储在名为 geom 的对象中：
=> COPY polygons(geojson filler VARCHAR(1000), geom as ST_GeomFromGeoJSON(geojson)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> { "type": "Polygon", "coordinates": [ [ [100.0, 0.0], [101.0, 0.0], [101.0, 1.0], [100.0, 1.0], [100.0, 0.0] ] ] }
>> { "type": "Point", "coordinates": [1, 2] }
>> { "type": "Polygon", "coordinates": [ [ [1, 3], [3, 2], [1, 1], [3, 0], [1, 0], [1, 3] ] ] }
>> \.
查询 polygons 表。下面的示例使用 ST_AsText 返回 geom 对象的 熟知文本 (WKT) 表示形式，并且使用 ST_IsValid 来验证每个对象：
=> SELECT ST_AsText(geom), ST_IsValid(geom) FROM polygons;
ST_AsText | ST_IsValid
-----------------------------------------------+------------
POINT (1 2) | t
POLYGON ((1 3, 3 2, 1 1, 3 0, 1 0, 1 3)) | f
POLYGON ((100 0, 101 0, 101 1, 100 1, 100 0)) | t
(3 rows)
将熟知文本 (WKT) 字符串转换为其对应的 GEOMETRY 对象。使用此函数可将 WKT 字符串转换为 Vertica Place 函数所需的格式。
GEOMETRY 对象是按平面坐标定义的空间对象。坐标表示为笛卡尔平面上的点 (x,y)。SRID 值为 0 至 232-1 是有效的。超出此范围的 SRID 值将会生成错误。
GEOMETRY 对象的最大大小为 10 MB。如果将 WKT 传递给 ST_GeomFromText 并且生成大小超过 10 MB 的空间对象，ST_GeomFromText 将会返回错误。
开放地理空间联盟 (OGC) 定义了 WKT 表示的格式。请参见 简易功能访问第 1 部分 - 通用架构规范第 7 节。
ST_GeomFromText( wkt [, srid] [ USING PARAMETERS ignore_errors={'y'|'n'} ])
wktsridGEOMETRY 对象的空间参照系标识符 (SRID)，类型为 INTEGER。
SRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。
ignore_errorsNULL—如果 wkt 无效并且 ignore_errors='y'。
Error—如果 wkt 无效并且 ignore_errors='n' 或未指定。
GEOMETRY
以下示例显示了 ST_GeomFromText 的用法。
将 WKT 转换为 GEOMETRY 对象：
=> SELECT ST_Area(ST_GeomFromText('POLYGON((1 1,2 3,3 5,0 5,1 -2,0 0,1 1))'));
ST_Area
---------
6
(1 row)
将熟知二进制 (WKB) 值转换为其对应的 GEOMETRY 对象。使用此函数可将 WKB 转换为许多 Vertica Place 函数所需的格式。
GEOMETRY 对象是在笛卡尔平面中定义的使用 (x,y) 坐标的空间对象。
GEOMETRY 对象的最大大小为 10 MB。如果将 WKB 传递给 ST_GeomFromWKB 并且生成大小超过 10 MB 的空间对象，ST_GeomFromWKB 将会返回错误。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 8 节定义了 WKB 表示的格式。
ST_GeomFromWKB( wkb[, srid] [ USING PARAMETERS ignore_errors={'y'|'n'} ])
wkbsridSRID 将存储在 GEOMETRY 对象中，但不影响空间计算的结果。
ignore_errorsST_GeomFromWKB 将基于提供的参数返回以下结果：
NULL—如果 wkb 无效并且 ignore_errors='y'。
Error—如果 wkb 无效并且 ignore_errors='n' 或未指定。
GEOMETRY
以下示例显示了 ST_GeomFromWKB 的用法。
将 GEOMETRY 转换为 WKT：
=> CREATE TABLE t(g GEOMETRY);
CREATE TABLE
=> INSERT INTO t VALUES(
ST_GeomFromWKB(X'0103000000010000000400000000000000000000000000000000000000000000000000f
03f0000000000000000f64ae1c7022db544000000000000f03f00000000000000000000000000000000'));
OUTPUT
--------
1
(1 row)
=> SELECT ST_AsText(g) from t;
ST_AsText
------------------------------------
POLYGON ((0 0, 1 0, 1e+23 1, 0 0))
(1 row)
计算两个 GEOMETRY 对象共有的点集。
ST_Intersection( g1, g2 )
g1g2GEOMETRY
以下示例显示了 ST_Intersection 的用法。
两个多边形相交于一个点：
=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,
0 2))'),ST_GeomFromText('POLYGON((-1 2,0 0,-2 0,-1 2))')));
ST_AsText
-----------------
POINT(0 0)
(1 row)
两个多边形：
=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('POLYGON((1 2,1 5,4 5,
4 2,1 2))'), ST_GeomFromText('POLYGON((3 1,3 3,5 3,5 1,3 1))')));
ST_AsText
------------------
POLYGON ((4 3, 4 2, 3 2, 3 3, 4 3))
(1 row)
两个未相交的线串：
=> SELECT ST_AsText(ST_Intersection(ST_GeomFromText('LINESTRING(1 1,1 3,3 3)'),
ST_GeomFromText('LINESTRING(1 5,1 7,-1 7)')));
ST_AsText
--------------------------
GEOMETRYCOLLECTION EMPTY
(1 row)
确定两个 GEOMETRY 或 GEOGRAPHY 对象是否在一个点相交或接触。对于相同的 GEOMETRY 或 GEOGRAPHY 对象，如果 ST_Disjoint 返回 TRUE，则 ST_Intersects 将返回 FALSE。
不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。
ST_Intersects( g1, g2
[USING PARAMETERS bbox={true | false}, spheroid={true | false}])
g1g2bbox = {true | false}g1 和 g2 的边界框相交。
默认值： False
spheroid = {true | false}（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
BOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 ST_Intersects 的用法。
两个多边形未相交或接触：
=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((1 0,1 1,2 2,1 0))'));
ST_Intersects
--------------
f
(1 row)
两个多边形在一个点接触：
=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((1 0,1 1,0 1,1 0))'));
ST_Intersects
--------------
t
(1 row)
两个多边形相交：
=> SELECT ST_Intersects (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
ST_GeomFromText('POLYGON((0 2, -1 3, -2 0, 0 2))'));
ST_Intersects
--------------
t
(1 row)
确定空间对象是否表示空集。空对象没有维度。
ST_IsEmpty( g )
gBOOLEAN
以下示例显示了 ST_IsEmpty 的用法。
空多边形：
=> SELECT ST_IsEmpty(ST_GeomFromText('GeometryCollection EMPTY'));
ST_IsEmpty
------------
t
(1 row)
确定空间对象是否未与自身相交，也未接触其自身边界上的任何点。
ST_IsSimple( g )
gBOOLEAN
以下示例显示了 ST_IsSimple 的用法。
多边形未与自身相交：
=> SELECT ST_IsSimple(ST_GeomFromText('POLYGON((-1 2,0 3,1 2,1 -2,-1 2))'));
ST_IsSimple
--------------
t
(1 row)
线串与自身相交：
=> SELECT ST_IsSimple(ST_GeographyFromText('LINESTRING(10 10,25 25,26 34.5,
10 30,10 20,20 10)'));
St_IsSimple
-------------
f
(1 row)
线串在一个或多个位置接触其内部：
=> SELECT ST_IsSimple(ST_GeomFromText('LINESTRING(0 0,0 1,1 0,2 1,2 0,0 0)'));
ST_IsSimple
-------------
f
(1 row)
确定空间对象的格式是否正确或其是否有效。如果对象有效，则 ST_IsValid 返回 TRUE；否则它将返回 FALSE。使用 STV_IsValidReason 以确定无效性原因。
空间有效性仅适用于多边形和多边形集合。如果以下所有项均成立，则多边形或多边形集合是有效的：
多边形是封闭的；其起点与终点相同。
其边界是一组线串。
边界不触及或穿越本身。
内部的任何多边形都未接触外部多边形边界除顶点以外的任何位置。
开放地理空间联盟 (OGC) 在 OGC 简易功能访问第 1 部分 - 通用架构规范的第 6.1.11.1 节定义了多边形的有效性。
如果不确定多边形是否有效，请先运行 ST_IsValid。如果将无效的空间对象传递给 Vertica Place 函数，函数将会失败或返回错误的结果。
ST_IsValid( g )
gBOOLEAN
以下示例显示了 ST_IsValid 的用法。
有效的多边形：
=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,1 3,3 3,3 1,1 1))'));
ST_IsValid
------------
t
(1 row)
无效的多边形：
=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 3,3 2,1 1,3 0,1 0,1 3))'));
ST_IsValid
------------
f
(1 row)
无效的多边形：
=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((0 0,2 2,0 2,2 0,0 0))'));
ST_IsValid
------------
f
(1 row)
无效的多边形集合：
=> SELECT ST_IsValid(ST_GeomFromText('MULTIPOLYGON(((0 0, 0 1, 1 1, 0 0)),
((0.5 0.5, 0.7 0.5, 0.7 0.7, 0.5 0.7, 0.5 0.5)))'));
ST_IsValid
------------
f
(1 row)
包含孔的有效多边形：
=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,3 3,6 -1,0.5 -1,1 1),
(1 1,3 1,2 0,1 1))'));
ST_IsValid
------------
t
(1 row)
包含孔的无效多边形：
=> SELECT ST_IsValid(ST_GeomFromText('POLYGON((1 1,3 3,6 -1,0.5 -1,1 1),
(1 1,4.5 1,2 0,1 1))'));
ST_IsValid
------------
f
(1 row)
计算空间对象的长度。对于 GEOMETRY 对象，长度使用笛卡尔坐标单位测量。对于 GEOGRAPHY 对象，长度以米为单位测量。
按以下方法计算长度：
点或点集合对象的长度为 0。
线串的长度是每个线段的长度之和；而线段的长度是起点到终点的距离。
多边形的长度是外部边界和任何内部边界的长度之和。
线串集合、多边形集合或 geometrycollection 的长度是它所包含的所有对象的长度之和。
ST_Length( g )
gFLOAT
以下示例显示了 ST_Length 的用法。
返回以笛卡尔坐标单位为单位的长度：
=> SELECT ST_Length(ST_GeomFromText('LINESTRING(-1 -1,2 2,4 5,6 7)'));
ST_Length
------------------
10.6766190873295
(1 row)
返回以米为单位的长度：
=> SELECT ST_Length(ST_GeographyFromText('LINESTRING(-56.12 38.26,-57.51 39.78,
-56.37 45.24)'));
ST_Length
------------------
821580.025733461
(1 row)
返回空间对象内包含的几何图形数量。单个 GEOMETRY 或 GEOGRAPHY 对象将返回 1，空对象将返回 NULL。
ST_NumGeometries( g )
gGEOMETRY 或 GEOGRAPHY 类型的空间对象
INTEGER
以下示例显示了 ST_NumGeometries 的用法。
返回几何图形的数量：
=> SELECT ST_NumGeometries(ST_GeomFromText('MULTILINESTRING ((1 5, 2 4, 5 3, 6 6), (3 5, 3 7))'));
ST_NumGeometries
------------------
2
(1 row)
计算空间对象的顶点数，空对象则返回 NULL。
多边形和多边形集合的第一个顶点和最后一个顶点单独计数。
ST_NumPoints( g )
gINTEGER
以下示例显示了 ST_NumPoints 的用法。
返回线串中的顶点数：
=> SELECT ST_NumPoints(ST_GeomFromText('LINESTRING(1.33 1.56,2.31 3.4,2.78 5.82,
3.76 3.9,4.11 3.27,5.85 4.34,6.9 4.231,7.61 5.77)'));
ST_NumPoints
--------------
8
(1 row)
使用 ST_Boundary 和 ST_NumPoints 返回多边形的顶点数：
=> SELECT ST_NumPoints(ST_Boundary(ST_GeomFromText('POLYGON((1 2,1 4,
2 5,3 6,4 6,5 5,4 4,3 3,1 2))')));
ST_NumPoints
--------------
9
(1 row)
确定 GEOMETRY 对象是否与另一个 GEOMETRY 对象共享空间但未完全包含在该对象范围内。它们必须在其内部重叠。如果两个对象在单个点接触，或仅仅沿边界相交，则二者没有重叠。两个参数必须具有相同的维度；否则 ST_Overlaps 将返回 FALSE。
ST_Overlaps ( g1, g2 )
g1g2BOOLEAN
以下示例显示了 ST_Overlaps 的用法。
Polygon_1 与 Polygon_2 重叠但未完全包含 Polygon_2：
=> SELECT ST_Overlaps(ST_GeomFromText('POLYGON((0 0, 0 1, 1 1, 0 0))'),
ST_GeomFromText('POLYGON((0.5 0.5, 0.7 0.5, 0.7 0.7, 0.5 0.7, 0.5 0.5))'));
ST_Overlaps
-------------
t
(1 row)
具有不同维度的两个对象：
=> SELECT ST_Overlaps(ST_GeomFromText('LINESTRING(2 2,4 4)'),
ST_GeomFromText('POINT(3 3)'));
ST_Overlaps
-------------
f
(1 row)
返回指定 GeoHash 的中心点。
ST_PointFromGeoHash(GeoHash)
GEOGRAPHY POINT
以下示例显示了如何使用 ST_PointFromGeoHash。
返回高级 GeoHash 的地理点并使用 ST_AsText 将该点转换为熟知文本：
=> SELECT ST_AsText(ST_PointFromGeoHash('dr'));
ST_AsText
-------------------------
POINT (-73.125 42.1875)
(1 row)
返回详细 GeoHash 的地理点并使用 ST_AsText 将该点转换为熟知文本：
=> SELECT ST_AsText(ST_PointFromGeoHash('1234567890bcdefhjkmn'));
ST_AsText
---------------------------------------
POINT (-122.196077187 -88.2297377551)
(1 row)
查找空间对象的第 n 个点。如果传递负数、零或大于线串上的总点数的数字，ST_PointN 将返回 NULL。
顶点顺序基于空间对象的熟知文本 (WKT) 表示。
ST_PointN( g, n )
gnGEOMETRY 或 GEOGRAPHY
以下示例显示了 ST_PointN 的用法。
返回第 5 个点：
=> SELECT ST_AsText(ST_PointN(ST_GeomFromText('
POLYGON(( 2 6, 2 9, 6 9, 7 7, 4 6, 2 6))'), 5));
ST_AsText
-------------
POINT (4 6)
(1 row)
返回第 2 个点：
=> SELECT ST_AsText(ST_PointN(ST_GeographyFromText('
LINESTRING(23.41 24.93,34.2 32.98,40.7 41.19)'), 2));
ST_AsText
--------------------
POINT (34.2 32.98)
(1 row)
基于指定的 DE-9IM 模式矩阵字符串，确定给定的 GEOMETRY 对象是否与另一个 GEOMETRY 对象在空间上相关。
DE-9IM 标准确定了两个对象彼此在空间上的相关性。
ST_Relate( g1, g2, matrix )
g1g2matrixT
F
0
1
2
*
BOOLEAN
以下示例显示了 ST_Relate 的用法。
“等于”对应的 DE-9IM 模式为'T*F**FFF2'：
=> SELECT ST_Relate(ST_GeomFromText('LINESTRING(0 1,2 2)'),
ST_GeomFromText('LINESTRING(2 2,0 1)'), 'T*F**FFF2');
ST_Relate
--------------
t
(1 row)
“重叠”对应的 DE-9IM 模式为'T*T***T**'：
=> SELECT ST_Relate(ST_GeomFromText('POLYGON((-1 -1,0 1,2 2,-1 -1))'),
ST_GeomFromText('POLYGON((0 1,1 -1,1 1,0 1))'), 'T*T***T**');
ST_Relate
-----------
t
(1 row)
确定随空间对象存储的空间参照系标识符 (SRID)。
将 SRID 传递给 ST_GeomFromText 或 ST_GeomFromWKB 后才能确定 GEOMETRY 对象的 SRID。ST_SRID 将返回此存储值。SRID 值为 0 至 232-1 是有效的。
ST_SRID( g )
gINTEGER
以下示例显示了 ST_SRID 的用法。
GEOMETRY 对象的默认 SRID 为 0：
=> SELECT ST_SRID(ST_GeomFromText(
'POLYGON((-1 -1,2 2,0 1,-1 -1))'));
ST_SRID
---------
0
(1 row)
GEOGRAPHY 对象的默认 SRID 为 4326：
=> SELECT ST_SRID(ST_GeographyFromText(
'POLYGON((22 35,24 35,26 32,22 35))'));
ST_SRID
---------
4326
(1 row)
计算两个 GEOMETRY 对象中除它们共有的点之外的其他所有点，包括这两个对象的边界。
该结果被称为对称差，在数学上表示为： Closure (*g1 *– g2) È Closure (*g2 *– g1)
ST_SymDifference( g1, g2 )
g1g2GEOMETRY
以下示例显示了 ST_SymDifference 的用法。
返回两个线串：
=> SELECT ST_AsText(ST_SymDifference(ST_GeomFromText('LINESTRING(30 40,
30 55)'),ST_GeomFromText('LINESTRING(30 32.5,30 47.5)')));
ST_AsText
-----------------
MULTILINESTRING ((30 47.5, 30 55),(30 32.5,30 40))
(1 row)
返回四个正方形：
=> SELECT ST_AsText(ST_SymDifference(ST_GeomFromText('POLYGON((2 1,2 4,3 4,
3 1,2 1))'),ST_GeomFromText('POLYGON((1 2,1 3,4 3,4 2,1 2))')));
ST_AsText
-------------------------------------------------------------------------
MULTIPOLYGON (((2 1, 2 2, 3 2, 3 1, 2 1)), ((1 2, 1 3, 2 3, 2 2, 1 2)),
((2 3, 2 4, 3 4, 3 3, 2 3)), ((3 2, 3 3, 4 3, 4 2, 3 2)))
(1 row)
确定两个 GEOMETRY 对象是否在一个点接触或沿边界接触，但没有内部相交。
不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。
ST_Touches( g1, g2
[USING PARAMETERS spheroid={true | false}] )
g1g2spheroid = {true | false}（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
BOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 ST_Touches 的用法。
两个多边形在一个点接触：
=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((1 3,0 3,1 2,1 3))'));
ST_Touches
------------
t
(1 row)
两个多边形仅在沿部分边界接触：
=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((1 2,0 3,0 1,1 2))'));
ST_Touches
------------
t
(1 row)
两个多边形未在任何点接触：
=> SELECT ST_Touches(ST_GeomFromText('POLYGON((-1 2,0 3,0 1,-1 2))'),
ST_GeomFromText('POLYGON((0 2,-1 3,-2 0,0 2))'));
ST_Touches
------------
f
(1 row)
返回一个新的 GEOMETRY，其坐标转换为 srid 实参使用的空间参考系统标识符 (SRID)。
此函数支持以下转换：
EPSG 4326 (WGS84) 到 EPSG 3857 (Web Mercator)
EPSG 3857 (Web Mercator) 到 EPSG 4326 (WGS84)
对于 EPSG 4326 (WGS84)，除非坐标处于以下范围内，否则转换会失败：
ST_Transform( g1, srid )
g1srid GEOMETRY
以下示例显示了如何将数据从 Web Mercator (3857) 转换为 WGS84 (4326)：
=> SELECT ST_AsText(ST_Transform(STV_GeometryPoint(7910240.56433, 5215074.23966, 3857), 4326));
ST_AsText
-------------------------
POINT (71.0589 42.3601)
(1 row)
以下示例显示了如何将表中的线串数据从 WGS84 (4326) 转换为 Web Mercator (3857)：
=> CREATE TABLE transform_line_example (g GEOMETRY);
CREATE TABLE
=> COPY transform_line_example (gx FILLER LONG VARCHAR, g AS ST_GeomFromText(gx, 4326)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> LINESTRING(0 0, 1 1, 2 2, 3 4)
>> \.
=> SELECT ST_AsText(ST_Transform(g, 3857)) FROM transform_line_example;
ST_AsText
-------------------------------------------------------------------------------------------------------------------------
LINESTRING (0 -7.08115455161e-10, 111319.490793 111325.142866, 222638.981587 222684.208506, 333958.47238 445640.109656)
(1 row)
以下示例显示了如何将表中的点数据从 WGS84 (4326) 转换为 Web Mercator (3857)：
=> CREATE TABLE transform_example (x FLOAT, y FLOAT, srid INT);
CREATE TABLE
=> COPY transform_example FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42.3601|71.0589|4326
>> 122.4194|37.7749|4326
>> 94.5786|39.0997|4326
>> \.
=> SELECT ST_AsText(ST_Transform(STV_GeometryPoint(x, y, srid), 3857)) FROM transform_example;
ST_AsText
-------------------------------------
POINT (4715504.76195 11422441.5961)
POINT (13627665.2712 4547675.35434)
POINT (10528441.5919 4735962.8206)
(3 rows)
计算两个空间对象中所有点的联合。
该结果在数学上表示为：g1 È *g2 *
ST_Union( g1, g2 )
g1g2GEOMETRY
以下示例显示了 ST_Union 的用法。
返回表示这两个多边形中包含的所有点的多边形：
=> SELECT ST_AsText(ST_Union(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,-1 1,0 2))'),
ST_GeomFromText('POLYGON((-1 2, 0 0, -2 0, -1 2))')));
ST_AsText
------------------------------------------------------------------------------
POLYGON ((0 2, 1 1, 0 -1, -0.5 0, -2 0, -1 2, -0.666666666667 1.33333333333, 0 2))
(1 row)
如果空间对象 g1 完全在空间对象 g2 内部，则 ST_Within 将返回 True。两个参数必须是相同的空间数据类型。要么指定两个 GEOMETRY 对象，要么指定两个 GEOGRAPHY 对象。
如果某个对象（例如点或线串）仅沿多边形边界存在，则 ST_Within 将返回 False。线串的内部是线串上除起点和终点以外的所有点。
ST_Within(g``g is functionally equivalent to ST_Contains(g``g.
不支持顶点或边界位于国际日期变更线 (IDL) 或南、北极的 GEOGRAPHY 多边形。
ST_Within( g1, g2
[USING PARAMETERS spheroid={true | false}] )
g1g2spheroid = {true | false}（可选）用于指定是否使用理想球体或 WGS84 的 BOOLEAN 值。
默认值：False
BOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 ST_Within 的用法。
第一个多边形完全包含在第二个多边形范围内：
=> SELECT ST_Within(ST_GeomFromText('POLYGON((0 2,1 1,0 -1,0 2))'),
ST_GeomFromText('POLYGON((-1 3,2 1,0 -3,-1 3))'));
ST_Within
-----------
t
(1 row)
点位于多边形顶点之上但不在其内部：
=> SELECT ST_Within (ST_GeographyFromText('POINT(30 25)'),
ST_GeographyFromText('POLYGON((25 25,25 35,32.2 35,30 25,25 25))'));
ST_Within
-----------
f
(1 row)
两个多边形在空间上等效：
=> SELECT ST_Within (ST_GeomFromText('POLYGON((-1 2, 0 3, 0 1, -1 2))'),
ST_GeomFromText('POLYGON((0 3, -1 2, 0 1, 0 3))'));
ST_Within
-----------
t
(1 row)
确定 GEOMETRY 点的 x 坐标或 GEOGRAPHY 点的经度值。
ST_X( g )
gFLOAT
以下示例显示了 ST_X 的用法。
返回 x 坐标：
=> SELECT ST_X(ST_GeomFromText('POINT(3.4 1.25)'));
ST_X
-----
3.4
(1 row)
返回经度值：
=> SELECT ST_X(ST_GeographyFromText('POINT(25.34 45.67)'));
ST_X
-------
25.34
(1 row)
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 x 坐标。
对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (MAX(longitude), ST_YMin(GEOGRAPHY)) 到 (MAX(longitude), ST_YMax(GEOGRAPHY)) 的大圆弧的最大经度来计算最大坐标。这种情况下，MAX(longitude) 是地理对象的最大经度值。
如果纬度或经度超出范围，ST_XMax 将返回地理对象的最大普通值。
ST_XMax( g )
gFLOAT
以下示例显示了 ST_XMax 的用法。
返回矩形范围内的最大 x 坐标：
=> SELECT ST_XMax(ST_GeomFromText('POLYGON((0 1,0 2,1 2,1 1,0 1))'));
ST_XMax
-----------
1
(1 row)
返回矩形范围内的最大经度值：
=> SELECT ST_XMax(ST_GeographyFromText(
'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
ST_XMax
---------
-71
(1 row)
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 x 坐标。
对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (MIN(longitude), ST_YMin(GEOGRAPHY)) 到 (MIN(longitude), ST_YMax(GEOGRAPHY)) 的大圆弧的最小经度来计算最小坐标。这种情况下，MIN(longitude) 表示地理对象的最小经度值。
如果纬度或经度超出范围，ST_XMin 将返回地理对象的最小普通值。
ST_XMin( g )
gFLOAT
以下示例显示了 ST_XMin 的用法。
返回矩形范围内的最小 x 坐标：
=> SELECT ST_XMin(ST_GeomFromText('POLYGON((0 1,0 2,1 2,1 1,0 1))'));
ST_XMin
----------
0
(1 row)
返回矩形范围内的最小经度值：
=> SELECT ST_XMin(ST_GeographyFromText(
'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
ST_XMin
----------
-71.5
(1 row)
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最大 y 坐标。
对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (ST_XMin(GEOGRAPHY), MAX(latitude)) 到 (ST_XMax(GEOGRAPHY), MAX(latitude)) 的大圆弧的最大纬度来计算最大坐标。这种情况下，MAX(latitude) 是地理对象的最大纬度值。
如果纬度或经度超出范围，ST_YMax 将返回地理对象的最大普通值。
ST_YMax( g )
gFLOAT
以下示例显示了 ST_YMax 的用法。
返回矩形范围内的最大 y 坐标：
=> SELECT ST_YMax(ST_GeomFromText('POLYGON((0 1,0 4,1 4,1 1,0 1))'));
ST_YMax
-----------
4
(1 row)
返回矩形范围内的最大纬度值：
=> SELECT ST_YMax(ST_GeographyFromText(
'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
ST_YMax
------------------
42.3802715689979
(1 row)
返回 GEOMETRY 或 GEOGRAPHY 对象的最小边界矩形的最小 y 坐标。
对于 GEOGRAPHY 类型，Vertica Place 将通过计算从 (ST_XMin(GEOGRAPHY), MIN(latitude)) 到 (ST_XMax(GEOGRAPHY), MIN(latitude)) 的大圆弧的最小纬度来计算最小坐标。这种情况下，MIN(latitude) 表示地理对象的最小纬度值。
如果纬度或经度超出范围，ST_YMin 将返回地理对象的最小普通值。
ST_YMin( g )
gFLOAT
以下示例显示了 ST_YMin 的用法。
返回矩形范围内的最小 y 坐标：
=> SELECT ST_YMin(ST_GeomFromText('POLYGON((0 1,0 4,1 4,1 1,0 1))'));
ST_YMin
-----------
1
(1 row)
返回矩形范围内的最小纬度值：
=> SELECT ST_YMin(ST_GeographyFromText(
'POLYGON((-71.50 42.35, -71.00 42.35, -71.00 42.38, -71.50 42.38, -71.50 42.35))'));
ST_YMin
------------------
42.35
(1 row)
确定 GEOMETRY 点的 y 坐标或 GEOGRAPHY 点的纬度值。
ST_Y( g )
gFLOAT
以下示例显示了 ST_Y 的用法。
返回 y 坐标：
=> SELECT ST_Y(ST_GeomFromText('POINT(3 5.25)'));
ST_Y
------
5.25
(1 row)
返回纬度值：
=> SELECT ST_Y(ST_GeographyFromText('POINT(35.44 51.04)'));
ST_Y
-------
51.04
(1 row)
返回 Javascript 几何对象表示法 (GeoJSON) 对象形式的几何或地理参数。
STV_AsGeoJSON( g, [USING PARAMETERS maxdecimals=[dec_value]])
gGEOMETRY 或 GEOGRAPHY 类型的空间对象
maxdecimals = dec_value有效值 ： 在 0 到 15 之间。
默认 值 **：**6
LONG VARCHAR
以下示例显示了 STV_AsGeoJSON 的用法。
将几何多边形转换为 GeoJSON：
=> SELECT STV_AsGeoJSON(ST_GeomFromText('POLYGON((3 2, 4 3, 5 1, 3 2), (3.5 2, 4 2.5, 4.5 1.5, 3.5 2))'));
STV_AsGeoJSON
--------------------------------------------------------------------------------------------------
{"type":"Polygon","coordinates":[[[3,2],[4,3],[5,1],[3,2]],[[3.5,2],[4,2.5],[4.5,1.5],[3.5,2]]]}
(1 row)
将地理点转换为 GeoJSON：
=> SELECT STV_AsGeoJSON(ST_GeographyFromText('POINT(42.36011 71.05899)') USING PARAMETERS maxdecimals=4);
STV_AsGeoJSON
-------------------------------------------------
{"type":"Point","coordinates":[42.3601,71.059]}
(1 row)
对一组多边形创建空间索引，以加快与一组点的空间相交计算速度。
利用一个输入多边形集（可以是查询的结果），可以创建空间索引。空间索引是在全局命名空间中创建的。每当跨群集的节点对输入表或投影分段时，Vertica 会采用分布式计划。
OVER() 子句必须为空。
STV_Create_Index( gid, g
USING PARAMETERS index='index_name'
[, overwrite={ true | false } ]
[, max_mem_mb=maxmem_value]
[, skip_nonindexable_polygons={true | false } ] )
OVER()
[ AS (polygons, srid, min_x, min_y, max_x, max_y, info) ]
gidg index = 'index_name'overwrite = [ true | false ]用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。
默认值： False
max_mem_mb = maxmem_valueSTV_Create_Index 在索引构建期间可分配的内存量指定限制（以 MB 为单位）的正整数。在多节点数据库上，它是每个节点的内存限制。默认值为 256。不要分配高于 GENERAL 资源池中的内存量的值。有关该池的详细信息，请参阅监控资源池。
如果为 max_mem_mb 设置的值等于或接近节点上的最大可用内存，则可能给系统性能造成不利影响。例如，它可能导致在索引构建期间，其他查询由于等待内存资源而发生超时。
skip_nonindexable_polygons = [ true | false ] （可选）BOOLEAN
在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。这些多边形被视为不可编制索引。当设置为 False 时，不可编制索引的多边形会导致创建索引失败。当设置为 True 时，可通过从索引中排除不可编制索引的多边形成功创建索引。
要审查无法编制索引的多边形，请配合参数 list_polygon 使用 STV_Describe_Index。
默认值：False
polygonsSRIDmin_x, min_y, max_x, max_ymin_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。info任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。
对跨多个节点的大型多边形表进行分段。通过表分段可以并行运行索引创建操作，从而充分利用 Vertica 中的大规模并行处理 (MPP) 架构。这会显著缩短大型表的执行时间。
对于需要构建索引的表，如果多边形总数较大，Vertica 建议对其进行分段。
STV_Create_Index 可能占用大量处理时间和内存。
首次为新数据编制索引时，Vertica 建议监视内存使用情况，以确保其保持在安全限制以内。内存使用情况取决于多边形数量、顶点数量以及多边形之间的重叠量。
STV_Create_Index 会在开始创建索引之前尝试分配内存。如果无法分配足够的内存，函数将会失败。如果没有足够的可用内存，请尝试以下解决方案：
在系统负载较小时创建索引。
避免并发创建索引。
尝试跨群集节点对输入表进行分段。
确保您计划索引的所有多边形都是有效的多边形。STV_Create_Index 和 STV_Refresh_Index 在构建索引时不检查多边形的有效性。
有关详细信息，请参阅创建或刷新索引之前确保多边形的有效性。
12.0.x 版之前创建的任何索引都需要重新创建。
如果 WGS84 多边形的顶点位于国际日期变更线 (IDL) 或北极和南极，则索引创建失败。
索引名称中不允许使用反斜杠或制表符。
索引名称不能超过 110 个字符。
以下几何图形不包含在索引中：
非多边形
具有 NULL 标识符的几何图形
NULL 多边形（集合）
EMPTY 多边形（集合）
无效多边形（集合）
以下地形不包含在索引中：
要取消运行 STV_Create_Index，请使用 Ctrl + C。
如果 Geometry 列没有有效的多边形，STV_Create_Index 将在 vertica.log 中报告错误并停止创建索引。
如果创建索引时使用了大量内存，请考虑对数据进行分段，以便并行创建索引。
以下示例显示了 STV_Create_Index 的用法。
使用单个字面参数创建索引：
=> SELECT STV_Create_Index(1, ST_GeomFromText('POLYGON((0 0,0 15.2,3.9 15.2,3.9 0,0 0))')
USING PARAMETERS index='my_polygon') OVER();
polygons | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
1 | 0 | 0 | 0 | 3.9 | 15.2 |
(1 row)
从表创建索引：
=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|POLYGON((10 20,15 60,20 45,46 15,10 20))
>> 4|POLYGON((5 20,9 30,20 45,36 35,5 20))
>> 5|POLYGON((12 23,9 30,20 45,36 35,37 67,45 80,50 20,12 23))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
max_mem_mb=256) OVER() FROM pols;
polygons | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
5 | 0 | -38 | 13 | 50 | 80 |
(1 row)
从已分区的表并行创建索引：
=> CREATE TABLE pols (p INT, gid INT, geom GEOMETRY(1000)) SEGMENTED BY HASH(p) ALL NODES;
CREATE TABLE
=> COPY pols (p, gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|10|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 1|11|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|12|POLYGON((-12 42,-12 42,27 48,14 26,-12 42))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true,
max_mem_mb=256) OVER() FROM pols;
polygons | SRID | min_x | min_y | max_x | max_y | info
----------+------+-------+-------+-------+-------+------
3 | 0 | -38 | 13 | 27 | 74 |
(1 row)
检索关于包含一组多边形的索引的信息。如果没有传递任何参数，STV_Describe_Index 将返回所有已定义的索引。
OVER() 子句必须为空。
STV_Describe_Index ( [ USING PARAMETERS [index='index_name']
[, list_polygons={true | false } ]] ) OVER ()
index = 'index_name'list_polygonpolygonsSRIDmin_x, min_y, max_x, max_ymin_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。namegidstateINDEXED - 空间对象已成功编制索引。
SELF_INTERSECT -（仅限 WGS84）空间对象未编制索引，因为其一个边与自身的另一个边相交。
EDGE_CROSS_IDL -（仅限 WGS84）空间对象未编制索引，因为其一个边与国际日期变更线交叉。
EDGE_HALF_CIRCLE -（仅限 WGS84）空间对象未编制索引，因为包含两个对跖的相邻顶点。
NON_INDEXABLE - 空间对象无法编制索引。
geography空间对象的熟知二进制 (WKB) 表示。
geometry空间对象的熟知二进制 (WKB) 表示。
任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。
如果索引是使用 12.0.x 或更早版本创建的，一些功能将会要求重建索引。
以下示例显示了 STV_Describe_Index 的用法。
检索关于索引的信息：
=> SELECT STV_Describe_Index (USING PARAMETERS index='my_polygons') OVER ();
type | polygons | SRID | min_x | min_y | max_x | max_y
----------+----------+------+-------+-------+-------+-------
GEOMETRY | 4 | 0 | -1 | -1 | 12 | 12
(1 row)
返回所有已定义的索引的名称：
=> SELECT STV_Describe_Index() OVER ();
name
------------------
MA_counties_index
my_polygons
NY_counties_index
US_States_Index
(4 rows)
返回索引中包含的多边形：
=> SELECT STV_Describe_Index(USING PARAMETERS index='my_polygons', list_polygons=TRUE) OVER ();
gid | state | geometry
-----+---------------+----------------------------------
12 | INDEXED | \260\000\000\000\000\000\000\ ...
14 | INDEXED | \200\000\000\000\000\000\000\ ...
10 | NON_INDEXABLE | \274\000\000\000\000\000\000\ ...
11 | INDEXED | \260\000\000\000\000\000\000\ ...
(4 rows)
删除空间索引。如果 STV_Drop_Index 找不到指定的空间索引，它将返回错误。
OVER 子句必须为空。
STV_Drop_Index( USING PARAMETERS index = 'index_name' ) OVER ()
index = 'index_name'以下示例显示了 STV_Drop_Index 的用法。
删除索引：
=> SELECT STV_Drop_Index(USING PARAMETERS index ='my_polygons') OVER ();
drop_index
------------
Index dropped
(1 row)
确定从一个空间对象的边界到另一个对象的边界的最短距离是否在指定的距离范围以内。
g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。
STV_DWithin( g1, g2, d )
g1GEOMETRY 或 GEOGRAPHY 类型的空间对象
g2GEOMETRY 或 GEOGRAPHY 类型的空间对象
dBOOLEAN
兼容的 GEOGRAPHY 对：
以下示例显示了 STV_DWithin 的用法。
两个几何图形彼此在最接近的点的距离为一个笛卡尔坐标单位：
=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
ST_GeomFromText('POLYGON((4 3,2 3,4 5,4 3))'),1);
STV_DWithin
-------------
t
(1 row)
如果将该距离缩小为 0.99 个单位：
=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
ST_GeomFromText('POLYGON((4 3,2 3,4 5,4 3))'),0.99);
STV_DWithin
-------------
f
(1 row)
第一个多边形将会接触到第二个多边形：
=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((-1 -1,2 2,0 1,-1 -1))'),
ST_GeomFromText('POLYGON((1 1,2 3,4 5,1 1))'),0.00001);
STV_DWithin
-------------
t
(1 row)
第一个多边形不在第二个多边形的 1000 米距离范围以内：
=> SELECT STV_DWithin(ST_GeomFromText('POLYGON((45.2 40,50.65 51.29,
55.67 47.6,50 47.6,45.2 40))'),ST_GeomFromText('POLYGON((25 25,25 30,
30 30,30 25,25 25))'), 1000);
STV_DWithin
--------------
t
(1 row)
将数据库表或子查询中的 GEOGRAPHY 或 GEOMETRY 数据导出到 shapefile 。输出被写入使用 STV_SetExportShapefileDirectory 指定的目录。
STV_Export2Shapefile( columns USING PARAMETERS shapefile = 'shapefile-name'
[, overwrite = boolean ]
[, shape = 'spatial-class'] )
OVER()
星号 (*) 值等同于列出 FROM 子句的所有列。
shapefile必须以文件扩展名 .shp 结尾。
长度限制为 128 个八位字节，例如 city-data.shp。
如果要将 shapefile 保存到子目录，可通过将子目录连接到 shapefile-name 来实现，例如， visualizations/city-data.shp。
您还可以将 shapefile 导出到您具有读写权限的挂载 S3 目录。使用语法
bucketname/path/filename。
overwrite用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。
默认值： False
shapePoint
Polygon
Linestring
Multipoint
Multipolygon
Multilinestring
多边形和多边形集合始终为顺时针方向。
默认值： Polygon
shapefile 导出目录中的三个文件，扩展名为 .shp、.shx 和 .dbf。
如果多边形集合、线串集合或点集合仅包含一个元素，则分别被写为多边形、线或点。
超过 10 个字符的列名称会被截短。
不能导出空的 POINTS。
会跳过所有包含 NULL 几何或地理数据的列。
不支持或无效的日期将被替换为 NULL。
数字值在导出时可能会损失精度。发生精度损失的原因是，.dbf 文件中的目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位。
shapefile 的大小不能超过 4GB。如果您的 shapefile 过大，请尝试拆分数据并导出到多个 shapefile。
以下示例显示了如何使用 STV_Export2Shapefile 将表 geo_data 的所有列导出到名为 city-data.shp 的 shapefile：
=> SELECT STV_Export2Shapefile(*
USING PARAMETERS shapefile = 'visualizations/city-data.shp',
overwrite = true, shape = 'Point')
OVER()
FROM geo_data
WHERE REVENUE > 25000;
Rows Exported | File Path
---------------+--------------------------------------------------------------
6442892 | v_geo-db_node0001: /home/geo/temp/visualizations/city-data.shp
(1 row)
返回一个包含所有输入数据的边界框。
在嵌套查询中使用 STV_Extent 以获得最佳结果。OVER 子句必须为空。
STV_Extent( g )
gGEOMETRY
以下示例显示了如何使用 STV_Extent。
返回线串的边界框，并验证它是否是有效的多边形：
=> SELECT ST_AsText(geom) AS bounding_box, ST_IsValid(geom)
FROM (SELECT STV_Extent(ST_GeomFromText('LineString(0 0, 1 1)')) OVER() AS geom) AS g;
bounding_box | ST_IsValid
-------------------------------------+------------
POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0)) | t
(1 row)
返回表中空间对象的边界框：
=> CREATE TABLE misc_geo_shapes (id IDENTITY, geom GEOMETRY);
CREATE TABLE
=> COPY misc_geo_shapes (gx FILLER LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> POINT(-71.03 42.37)
>> LINESTRING(-71.058849 42.367501, -71.062240 42.371276, -71.067938 42.371246)
>> POLYGON((-71.066030 42.380617, -71.055827 42.376734, -71.060811 42.376011, -71.066030 42.380617))
>> \\.
=> SELECT ST_AsText(geom_col) AS bounding_box
FROM (SELECT STV_Extent(geom) OVER() AS geom_col FROM misc_geo_shapes) AS g;
bounding_box
------------------------------------------------------------------------------------------------------------------
POLYGON ((-71.067938 42.367501, -71.03 42.367501, -71.03 42.380617, -71.067938 42.380617, -71.067938 42.367501))
(1 row)
更改空间对象的顶点顺序，使其遵循左手规则。
STV_ForceLHR( g, [USING PARAMETERS skip_nonreorientable_polygons={true | false} ])
gskip_nonreorientable_polygons = { true | false }（可选）Boolean
当设置为 False 时，不可定向的多边形将会生成错误。例如，如果将 STV_ForceLHR 或 STV_Reverse 与设置为 False 的 skip_nonorientable_polygons 配合使用，则包含孔的地理多边形将会生成错误。当设置为 True 时，返回的结果将是传递给 API 的未经更改的多边形。
此实参可帮助从包含无法重新定向的多边形的表创建索引。
Vertica Place 将以下多边形视为不可定向：
包含孔的多边形
多边形集合
包含孔的多边形集合
默认值：False
GEOGRAPHY
以下示例显示了 STV_ForceLHR 的用法。
将地理多边形的方向调整为左手方向：
=> SELECT ST_AsText(STV_ForceLHR(ST_GeographyFromText('Polygon((1 1, 3 1, 2 2, 1 1))')));
ST_AsText
--------------------------------
POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)
通过强制执行左手方向来反转地理多边形的方向：
=> SELECT ST_AsText(STV_ForceLHR(ST_GeographyFromText('Polygon((1 1, 2 2, 3 1, 1 1))')));
ST_AsText
--------------------------------
POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)
将 GEOMETRY 对象转换为 GEOGRAPHY 对象。SRID 值不影响 Vertica Place 查询的结果。
STV_Geography 在将 GEOMETRY 对象转换为 GEOGRAPHY 对象时，会将其 SRID 设为 4326。
STV_Geography( geom )
geomGEOGRAPHY
以下示例显示了 STV_Geography 的用法。
要计算 GEOGRAPHY 对象的质心，请将其转换为 GEOMETRY 对象，然后转换回 GEOGRAPHY 对象：
=> CREATE TABLE geogs(g GEOGRAPHY);
CREATE TABLE
=> COPY geogs(gx filler LONG VARCHAR, geog AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> MULTIPOINT(-108.619726 45.000284,-107.866813 45.00107,-106.363711 44.994223,-70.847746 41.205814)
>> \\.
=> SELECT ST_AsText(STV_Geography(ST_Centroid(STV_Geometry(g)))) FROM geogs;
ST_AsText
--------------------------------
POINT (-98.424499 44.05034775)
(1 row)
基于输入值，返回 GEOGRAPHY 点。
这是将原始坐标转换为 GEOGRAPHY 点的最佳方法。
STV_GeographyPoint( x, y )
xyGEOGRAPHY
以下示例显示了 STV_GeographyPoint 的用法。
返回 GEOGRAPHY 点：
=> SELECT ST_AsText(STV_GeographyPoint(-114.101588, 47.909677));
ST_AsText
-------------------------------
POINT (-114.101588 47.909677)
(1 row)
使用两列返回 GEOGRAPHY 点：
=> CREATE TABLE geog_data (id IDENTITY, x FLOAT, y FLOAT);
CREATE TABLE
=> COPY geog_data FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> -114.101588|47.909677
>> -111.532377|46.430753
>> \.
=> SELECT id, ST_AsText(STV_GeographyPoint(x, y)) FROM geog_data;
id | ST_AsText
----+-------------------------------
1 | POINT (-114.101588 47.909677)
2 | POINT (-111.532377 46.430753)
(2 rows)
在加载期间通过操纵数据源列来创建 GEOGRAPHY 点：
=> CREATE TABLE geog_data_load (id IDENTITY, geog GEOGRAPHY);
CREATE TABLE
=> COPY geog_data_load (lon FILLER FLOAT,
lat FILLER FLOAT,
geog AS STV_GeographyPoint(lon, lat))
FROM 'test_coords.csv' DELIMITER ',';
Rows Loaded
-------------
2
(1 row)
=> SELECT id, ST_AsText(geog) FROM geog_data_load;
id | ST_AsText
----+------------------------------------
1 | POINT (-75.101654451 43.363830536)
2 | POINT (-75.106444487 43.367093798)
(2 rows)
将 GEOGRAPHY 对象转换为 GEOMETRY 对象。
SRID 值不影响 Vertica Place 查询的结果。
STV_Geometry( geog )
geogGEOMETRY
以下示例显示了 STV_Geometry 的用法。
将 GEOGRAPHY 值转换为 GEOMETRY 值，然后将结果转换回 GEOGRAPHY 类型：
=> CREATE TABLE geogs(g GEOGRAPHY);
CREATE TABLE
=> COPY geogs(gx filler LONG VARCHAR, geog AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> MULTIPOINT(-108.619726 45.000284,-107.866813 45.00107,-106.363711 44.994223,-70.847746 41.205814)
>> \\.
=> SELECT ST_AsText(STV_Geography(ST_Centroid(STV_Geometry(g)))) FROM geogs;
ST_AsText
--------------------------------
POINT (-98.424499 44.05034775)
基于输入值，返回 GEOMETRY 点。
这是将原始坐标转换为 GEOMETRY 点的最佳方法。
STV_GeometryPoint( x, y [, srid] )
xysridGEOMETRY
以下示例显示了 STV_GeometryPoint 的用法。
返回包含 SRID 的 GEOMETRY 点：
=> SELECT ST_AsText(STV_GeometryPoint(71.148562, 42.989374, 4326));
ST_AsText
-----------------------------
POINT (-71.148562 42.989374)
(1 row)
使用两列返回 GEOMETRY 点：
=> CREATE TABLE geom_data (id IDENTITY, x FLOAT, y FLOAT, SRID int);
CREATE TABLE
=> COPY geom_data FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 42.36383053600048|-71.10165445099966|4326
>> 42.3670937980005|-71.10644448699964|4326
>> \\.
=> SELECT id, ST_AsText(STV_GeometryPoint(x, y, SRID)) FROM geom_data;
id | ST_AsText
----+------------------------------------
1 | POINT (-71.101654451 42.363830536)
2 | POINT (-71.106444487 42.367093798)
(2 rows)
在加载期间通过操纵数据源列来创建 GEOMETRY 点：
=> CREATE TABLE geom_data_load (id IDENTITY, geom GEOMETRY);
CREATE TABLE
=> COPY geom_data_load (lon FILLER FLOAT,
lat FILLER FLOAT,
geom AS STV_GeometryPoint(lon, lat))
FROM 'test_coords.csv' DELIMITER ',';
Rows Loaded
-------------
2
(1 row)
=> SELECT id, ST_AsText(geom) FROM geom_data_load;
id | ST_AsText
----+------------------------------------
1 | POINT (-75.101654451 43.363830536)
2 | POINT (-75.106444487 43.367093798)
(2 rows)
返回导出目录的路径。
STV_GetExportShapefileDirectory( )
图形文件导出目录的路径。
以下示例显示了如何使用 STV_GetExportShapefileDirectory 来查询 shapefile 导出目录的路径：
=> SELECT STV_GetExportShapefileDirectory();
STV_GetExportShapefileDirectory
-----------------------------------------------
Shapefile export directory: [/home/user/temp]
(1 row)
将一个点或多个点与一组多边形在空间上相交。STV_Intersect 标量函数将返回与相交多边形关联的标识符。
STV_Intersect( { g | x , y }
USING PARAMETERS index= 'index_name')
gxyindex = 'index_name'匹配多边形的标识符。如果点没有与索引中的任何多边形相交，则 STV_Intersect 标量函数将返回 NULL。
以下示例显示了如何使用 STV_Intersect 标量。
使用两个浮点数，返回匹配多边形的 gid 或 NULL：
=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((31 74,8 70,8 50,36 53,31 74))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
max_mem_mb=256) OVER() FROM pols;
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 1 | 0 | 8 | 50 | 36 | 74 |
(1 row)
=> SELECT STV_Intersect(12.5683, 55.6761 USING PARAMETERS index = 'my_polygons_1');
STV_Intersect
---------------
1
(1 row)
使用 GEOMETRY 列，返回匹配多边形的 gid 或 NULL：
=> CREATE TABLE polygons (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY polygons (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((-38 50,4 13,11 45,0 65,-38 50))
>> 3|POLYGON((-18 42,-10 65,27 48,14 26,-18 42))
>> \.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true,
max_mem_mb=256) OVER() FROM polygons;
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 3 | 0 | -38 | 13 | 27 | 74 |
(1 row)
=> CREATE TABLE points (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY points (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 100|POINT(-1 52)
>> 101|POINT(-20 0)
>> 102|POINT(-8 25)
>> 103|POINT(0 0)
>> 104|POINT(1 5)
>> 105|POINT(20 45)
>> 106|POINT(-20 5)
>> 107|POINT(-20 1)
>> \.
=> SELECT gid AS pt_gid, STV_Intersect(geom USING PARAMETERS index='my_polygons') AS pol_gid
FROM points ORDER BY pt_gid;
pt_gid | pol_gid
--------+---------
100 | 1
101 |
102 | 2
103 |
104 |
105 | 3
106 |
107 |
(8 rows)
将点与多边形在空间上相交。STV_Intersect 变换函数返回包含匹配的点/多边形对的元组。对于每个点，Vertica 返回一个或多个匹配的多边形。
在多个节点上并行计算 STV_Intersect 变换函数可以提高性能。要执行并行计算，请使用 OVER(PARTITION BEST) 子句。
STV_Intersect ( { gid | i }, { g | x , y }
USING PARAMETERS index='index_name')
OVER() AS (pt_gid, pol_gid)
gid | igxyindex = 'index_name'pt_gidpol_gid以下示例显示了如何使用 STV_Intersect 变换函数。
使用两个浮点数，返回匹配的点-多边形对。
=> CREATE TABLE pols (gid INT, geom GEOMETRY(1000));
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((31 74,8 70,8 50,36 53,31 74))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true,
max_mem_mb=256) OVER() FROM pols;
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 1 | 0 | 8 | 50 | 36 | 74 |
(1 row)
=> SELECT STV_Intersect(56, 12.5683, 55.6761 USING PARAMETERS index = 'my_polygons_1') OVER();
pt_gid | pol_gid
--------+---------
56 | 1
(1 row)
使用 GEOMETRY 列，返回匹配的点-多边形对。
=> CREATE TABLE polygons (gid int, geom GEOMETRY(700));
CREATE TABLE
=> COPY polygons (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 10|POLYGON((5 5, 5 10, 10 10, 10 5, 5 5))
>> 11|POLYGON((0 0, 0 2, 2 2, 2 0, 0 0))
>> 12|POLYGON((1 1, 1 3, 3 3, 3 1, 1 1))
>> 14|POLYGON((-1 -1, -1 12, 12 12, 12 -1, -1 -1))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons', overwrite=true, max_mem_mb=256)
OVER() FROM polygons;
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 4 | 0 | -1 | -1 | 12 | 12 |
(1 row)
=> CREATE TABLE points (gid INT, geom GEOMETRY(700));
CREATE TABLE
=> COPY points (gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POINT(9 9)
>> 2|POINT(0 1)
>> 3|POINT(2.5 2.5)
>> 4|POINT(0 0)
>> 5|POINT(1 5)
>> 6|POINT(1.5 1.5)
>> \\.
=> SELECT STV_Intersect(gid, geom USING PARAMETERS index='my_polygons') OVER (PARTITION BEST)
AS (point_id, polygon_gid)
FROM points;
point_id | polygon_gid
----------+-------------
5 | 14
1 | 14
1 | 10
4 | 14
4 | 11
6 | 12
6 | 14
6 | 11
2 | 14
2 | 11
3 | 12
3 | 14
(12 rows)
可通过在 WHERE 子句中使用 STV_Intersect 变换函数来提高查询性能。由于此语法会消除未与索引中的多边形相交的点，因此能够提高性能。
返回与 gid = 14 的多边形相交的点计数：
=> SELECT COUNT(pt_id) FROM
(SELECT STV_Intersect(gid, geom USING PARAMETERS index='my_polygons')
OVER (PARTITION BEST) AS (pt_id, pol_id) FROM points)
AS T WHERE pol_id = 14;
COUNT
-------
6
(1 row)
确定空间对象的格式是否正确或其是否有效。如果对象无效，STV_IsValidReason 将返回说明无效性原因的字符串。
如果以下所有项均成立，则多边形或多边形集合是有效的：
多边形是封闭的；其起点与终点相同。
其边界是一组线串。
边界不触及或穿越本身。
与外部多边形边界的接触点不超过一个的任何内部多边形。
如果将无效的对象传递给 Vertica Place 函数，函数将会失败或返回错误的结果。要确定多边形是否有效，请先运行 ST_IsValid。如果多边形有效，ST_IsValid 将返回 TRUE，否则将返回 FALSE。
STV_IsValidReason( g )
gLONG VARCHAR
以下示例显示了 STV_IsValidReason 的用法。
返回描述多边形无效位置的字符串：
=> SELECT STV_IsValidReason(ST_GeomFromText('POLYGON((1 3,3 2,1 1,
3 0,1 0,1 3))'));
STV_IsValidReason
-----------------------------------------------
Ring Self-intersection at or near POINT (1 1)
(1 row)
检索线串或线串集合的顶点。 根据输入对象的类型，返回的值为 GEOMETRY 或 GEOGRAPHY 类型的点。GEOMETRY 点将继承输入对象的 SRID。
STV_LineStringPoint 为分析函数。有关详细信息，请参阅分析函数。
STV_LineStringPoint( g )
OVER( [PARTITION NODES] ) AS
gGEOMETRY 或 GEOGRAPHY
以下示例显示了 STV_LineStringPoint 的用法。
返回几何线串的顶点及其 SRID：
=> SELECT ST_AsText(Point), ST_SRID(Point)
FROM (SELECT STV_LineStringPoint(
ST_GeomFromText('MULTILINESTRING((1 2, 2 3, 3 1, 4 2),
(10 20, 20 30, 30 10, 40 20))', 4269)) OVER () AS Point) AS foo;
ST_AsText | ST_SRID
---------------+---------
POINT (1 2) | 4269
POINT (2 3) | 4269
POINT (3 1) | 4269
POINT (4 2) | 4269
POINT (10 20) | 4269
POINT (20 30) | 4269
POINT (30 10) | 4269
POINT (40 20) | 4269
(8 rows)
返回地理线串的顶点：
=> SELECT ST_AsText(g)
FROM (SELECT STV_LineStringPoint(
ST_GeographyFromText('MULTILINESTRING ((42.1 71.0, 41.4 70.0, 41.3 72.9),
(42.99 71.46, 44.47 73.21)', 4269)) OVER () AS g) AS line_geog_points;
ST_AsText
---------------------
POINT (42.1 71.0)
POINT (41.4 70.0)
POINT (41.3 72.9)
POINT (42.99 71.46)
POINT (44.47 73.21)
(5 rows)
返回 INTEGER 类型的空间对象长度（以字节为单位）。
使用此函数确定空间数据的最优列宽。
STV_MemSize( g )
gINTEGER
以下示例显示了如何通过将 GEOMETRY 或 GEOGRAPHY 列大小调整为 STV_MemSize 所返回的最大值来对表进行优化：
=> CREATE TABLE mem_size_table (id int, geom geometry(800));
CREATE TABLE
=> COPY mem_size_table (id, gx filler LONG VARCHAR, geom as ST_GeomFromText(gx)) FROM STDIN DELIMITER '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>>1|POINT(3 5)
>>2|MULTILINESTRING((1 5, 2 4, 5 3, 6 6),(3 5, 3 7))
>>3|MULTIPOLYGON(((2 6, 2 9, 6 9, 7 7, 4 6, 2 6)),((0 0, 0 5, 1 0, 0 0)),((0 2, 2 5, 4 5, 0 2)))
>>\\.
=> SELECT max(STV_MemSize(geom)) FROM mem_size_table;
max
-----
336
(1 row)
=> CREATE TABLE production_table(id int, geom geometry(336));
CREATE TABLE
=> INSERT INTO production_table SELECT * FROM mem_size_table;
OUTPUT
--------
3
(1 row)
=> DROP mem_size_table;
DROP TABLE
计算空间对象与参考对象之间的距离，并按照与参考对象的距离，以升序方式返回（对象，距离）对。
g1 和 g2 参数必须都是 GEOMETRY 对象或都是 GEOGRAPHY 对象。
STV_NN 为分析函数。有关详细信息，请参阅分析函数。
STV_NN( g, ref_obj, k ) OVER()
gref_objk按距离以升序方式返回（对象，距离）对。如果某个参数为 EMPTY 或 NULL，则返回 0 行。
以下示例显示了 STV_NN 的用法。
创建表并插入 9 个 GEOGRAPHY 点：
=> CREATE TABLE points (g geography);
CREATE TABLE
=> COPY points (gx filler LONG VARCHAR, g AS ST_GeographyFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> POINT (21.5 18.4)
>> POINT (21.5 19.2)
>> POINT (21.5 20.7)
>> POINT (22.5 16.4)
>> POINT (22.5 17.15)
>> POINT (22.5 18.33)
>> POINT (23.5 13.68)
>> POINT (23.5 15.9)
>> POINT (23.5 18.4)
>> \\.
计算表 points 中的对象与 GEOGRAPHY 点 (23.5, 20) 的距离（以米为单位）。
返回与该点距离最近的 5 个对象：
=> SELECT ST_AsText(nn), dist FROM (SELECT STV_NN(g,
ST_GeographyFromText('POINT(23.5 20)'),5) OVER() AS (nn,dist) FROM points) AS example;
ST_AsText | dist
--------------------+------------------
POINT (23.5 18.4) | 177912.12757541
POINT (22.5 18.33) | 213339.210738322
POINT (21.5 20.7) | 222561.43679943
POINT (21.5 19.2) | 227604.371833335
POINT (21.5 18.4) | 275239.416790128
(5 rows)
将多边形的顶点作为个别点进行检索。 根据输入对象的类型，返回的值为 GEOMETRY 或 GEOGRAPHY 类型的点。GEOMETRY 点将继承输入对象的 SRID。
STV_PolygonPoint 为分析函数。有关详细信息，请参阅分析函数。
STV_PolygonPoint( g )
OVER( [PARTITION NODES] ) AS
gGEOMETRY 或 GEOGRAPHY
以下示例显示了 STV_PolygonPoint 的用法。
返回几何多边形的顶点：
=> SELECT ST_AsText(g) FROM (SELECT STV_PolygonPoint(ST_GeomFromText('POLYGON((1 2, 2 3, 3 1, 1 2))'))
OVER (PARTITION NODES) AS g) AS poly_points;
ST_AsText
-------------
POINT (1 2)
POINT (2 3)
POINT (3 1)
POINT (1 2)
(4 rows)
返回地理多边形的顶点：
=> SELECT ST_AsText(g) FROM (SELECT STV_PolygonPoint(ST_GeographyFromText('
POLYGON((25.5 28.76, 28.83 29.13, 27.2 30.99, 25.5 28.76))'))
OVER (PARTITION NODES) AS g) AS poly_points;
ST_AsText
---------------------
POINT (25.5 28.76)
POINT (28.83 29.13)
POINT (27.2 30.99)
POINT (25.5 28.76)
(4 rows)
反转空间对象顶点的顺序。
STV_Reverse( g, [USING PARAMETERS skip_nonreorientable_polygons={true | false} ])
gskip_nonreorientable_polygons = { true | false }（可选）Boolean
当设置为 False 时，不可定向的多边形将会生成错误。例如，如果将 STV_ForceLHR 或 STV_Reverse 与设置为 False 的 skip_nonorientable_polygons 配合使用，则包含孔的地理多边形将会生成错误。当设置为 True 时，返回的结果将是传递给 API 的未经更改的多边形。
此实参可帮助从包含无法重新定向的多边形的表创建索引。
Vertica Place 将以下多边形视为不可定向：
包含孔的多边形
多边形集合
包含孔的多边形集合
默认值：False
GEOGRAPHY
以下示例显示了 STV_Reverse 的用法。
反转地理多边形的顶点：
=> SELECT ST_AsText(STV_Reverse(ST_GeographyFromText('Polygon((1 1, 3 1, 2 2, 1 1))')));
ST_AsText
--------------------------------
POLYGON ((1 1, 2 2, 3 1, 1 1))
(1 row)
强制多边形反转方向：
=> SELECT ST_AsText(STV_Reverse(ST_GeographyFromText('Polygon((1 1, 2 2, 3 1, 1 1))')));
ST_AsText
--------------------------------
POLYGON ((1 1, 3 1, 2 2, 1 1))
(1 row)
为空间索引重命名。如果索引格式过期，则不能为索引重命名。
利用一个输入多边形集（可以是查询的结果），可以创建空间索引。空间索引是在全局命名空间中创建的。每当跨群集的节点对输入表或投影分段时，Vertica 会采用分布式计划。
OVER() 子句必须为空。
STV_Rename_Index( USING PARAMETERS
source = 'old_index_name',
dest = 'new_index_name',
overwrite = [ 'true' | 'false' ]
)
OVER ()
source = 'old_index_name'dest = 'new_index_name'overwrite = [ 'true' | 'false' ]用于指定是否覆盖索引的 BOOLEAN（如果存在索引）。此参数不能为 NULL。
默认值： False
任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。
索引名称不能超过 110 个字符。
索引名称中不允许使用反斜杠或制表符。
以下示例显示了 STV_Rename_Index 的用法。
为索引重命名：
=> SELECT STV_Rename_Index (
USING PARAMETERS
source = 'my_polygons',
dest = 'US_states',
overwrite = 'false'
)
OVER ();
rename_index
---------------
Index renamed
(1 Row)
将新添加或更新的多边形追加到现有的空间索引，以及从现有的空间索引中移除已删除的多边形。
OVER() 子句必须为空。
可变
STV_Refresh_Index( gid, g
USING PARAMETERS index='index_name'
[, skip_nonindexable_polygons={ true | false } ] )
OVER()
[ AS (type, polygons, srid, min_x, min_y, max_x, max_y, info,
indexed, appended, updated, deleted) ]
gidgindex = 'index_name' skip_nonindexable_polygons = { true | false }（可选）BOOLEAN
在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。这些多边形被视为不可编制索引。当设置为 False 时，不可编制索引的多边形会导致创建索引失败。当设置为 True 时，可通过从索引中排除不可编制索引的多边形成功创建索引。
要审查无法编制索引的多边形，请配合参数 list_polygon 使用 STV_Describe_Index。
默认值：False
typepolygonsSRIDmin_x, min_y, max_x, max_ymin_x, min_y) 是西南坐标，(max_x, max_y) 是东北坐标。infoindexedappendedupdateddeleted任何有权访问 STV_*_Index 函数的用户都可以描述、重命名或删除由其他任何用户创建的索引。
在极少的情况下，无法对复杂多边形（例如解析度过高或包含不规则尖峰）编制索引。请参见参数 skip_nonindexable_polygons。
如果将源表中的有效多边形替换为无效的多边形，STV_Refresh_Index 将会忽略无效的多边形。因此，原来已编制索引的多边形仍保留在索引中。
无法索引以下几何图形：
非多边形
NULL gid
NULL 多边形（集合）
EMPTY 多边形（集合）
无效多边形（集合）
以下地形不包含在索引中：
要取消运行 STV_Refresh_Index，请使用 Ctrl + C。
如果使用之前没有与索引关联的源数据，则会覆盖索引。
如果 STV_Refresh_Index 没有足够的内存处理该查询，则将使用 STV_Create_Index 重建索引。
如果 Geometry 列没有有效的多边形，STV_Refresh_Index 将在 vertica.log 中报告错误并停止刷新索引。
确保您计划索引的所有多边形都是有效的多边形。STV_Create_Index 和 STV_Refresh_Index 在构建索引时不检查多边形的有效性。
有关详细信息，请参阅创建或刷新索引之前确保多边形的有效性。
以下示例显示了 STV_Refresh_Index 的用法。
使用单个字面参数刷新索引：
=> SELECT STV_Create_Index(1, ST_GeomFromText('POLYGON((0 0,0 15.2,3.9 15.2,3.9 0,0 0))')
USING PARAMETERS index='my_polygon') OVER();
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 1 | 0 | 0 | 0 | 3.9 | 15.2 |
(1 row)
=> SELECT STV_Refresh_Index(2, ST_GeomFromText('POLYGON((0 0,0 13.2,3.9 18.2,3.9 0,0 0))')
USING PARAMETERS index='my_polygon') OVER();
type | polygons | SRID | min_x | min_y | max_x | max_y | info | indexed | appended | updated | deleted
----------+----------+------+-------+-------+-------+-------+------+---------+----------+---------+---------
GEOMETRY | 1 | 0 | 0 | 0 | 3.9 | 18.2 | | 1 | 1 | 0 | 1
(1 row)
刷新表索引：
=> CREATE TABLE pols (gid INT, geom GEOMETRY);
CREATE TABLE
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|POLYGON((-31 74,8 70,8 50,-36 53,-31 74))
>> 2|POLYGON((5 20,9 30,20 45,36 35,5 20))
>> 3|POLYGON((12 23,9 30,20 45,36 35,37 67,45 80,50 20,12 23))
>> \\.
=> SELECT STV_Create_Index(gid, geom USING PARAMETERS index='my_polygons_1', overwrite=true)
OVER() FROM pols;
type | polygons | SRID | min_x | min_y | max_x | max_y | info
----------+----------+------+-------+-------+-------+-------+------
GEOMETRY | 3 | 0 | -36 | 20 | 50 | 80 |
(1 row)
=> COPY pols(gid, gx filler LONG VARCHAR, geom AS ST_GeomFromText(gx)) FROM stdin delimiter '|';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 6|POLYGON((-32 74,8 70,8 50,-36 53,-32 74))
>> \\.
=> SELECT STV_Refresh_Index(gid, geom USING PARAMETERS index='my_polygons_1') OVER() FROM pols;
type | polygons | SRID | min_x | min_y | max_x | max_y | info | indexed | appended | updated | deleted
----------+----------+------+-------+-------+-------+-------+------+---------+----------+---------+---------
GEOMETRY | 4 | 0 | -36 | 20 | 50 | 80 | | 1 | 1 | 0 | 0
(1 row)
指定将 GEOMETRY 或 GEOGRAPHY 数据导出到 shapefile 的目录。不检查路径的有效性，并且路径不能为空。
STV_SetExportShapefileDirectory( USING PARAMETERS path='shapefile_path' )
path = ' shapefile_path ' 图形文件导出目录的路径。
只有 超级用户才能使用此函数。
以下示例显示了如何使用 STV_SetExportShapefileDirectory 将 shapefile 导出目录设为 /home/user/temp：
=> SELECT STV_SetExportShapefileDirectory(USING PARAMETERS path = '/home/user/temp');
STV_SetExportShapefileDirectory
------------------------------------------------------------
SUCCESS. Set shapefile export directory: [/home/user/temp]
(1 row)
这两个函数与 COPY 配合使用，解析 shapefile 中的几何图形和属性并将其加载到 Vertica 表，然后转换为适当的 GEOMETRY 数据类型。必须将这两个函数一起使用。
存在以下限制：
无法从 shapefile 加载空的点集合或无效的多边形集合。
如果 shapefile 的 .dbf 组件包含数字属性，则在 Vertica Place shapefile 加载程序将此字段加载到表中时，此字段的值可能会损失精度。因为目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位；而在 .dbf 文件中，数字字段最多可达 30 位。
被拒绝的记录保存在 Vertica 编录目录下的 CopyErrorLogs 子目录。
COPY table( columnslist )
WITH SOURCE STV_ShpSource
( file = 'filename'[[, SRID=spatial‑reference‑identifier] [, flatten_2d={true | false }] ] )
PARSER STV_ShpParser()
表columnslistfile = 'pathname' .dbf、.shp 或 .shx 文件的完全限定路径。
您还可以从存储在您具有读取和写入权限的挂载 S3 目录中的 shapefile 加载。在这种情况下，请使用以下语法：
bucketname/path/filename
SRID=spatial‑reference‑identifierflatten_2d true：在 COPY 命令之前排除具有 3D 或 4D 坐标的几何图形。
false：如果找到具有 3D 或 4D 坐标的几何图形，则会导致加载失败。
默认值： false
源 shapefile：读取
shapefile 目录：执行
COPY 命令在以下任一情况下会失败：
找不到或无法打开 shapefile。
STV_ShpParser 创建的列数或列数据类型与目标表中的列不匹配。使用 STV_ShpCreateTable 生成相应的 CREATE TABLE 命令。
缺失或无法打开其中一个必要文件。打开 shapefile 时，您必须拥有三个文件：.dbf、.shp 和 .shx。
如果 .shp 和 .shx 文件已损坏，STV_ShpSource 将返回错误。
如果 .shp 和 .shx 文件有效，但 .dbf 文件已损坏，STV_ShpSource 将忽略 .dbf 文件并且不创建该数据对应的列。
=> COPY tl_2010_us_state10 WITH SOURCE
STV_ShpSource(file='/shapefiles/tl_2010_us_state10.shp', SRID=4269) PARSER STV_ShpParser();
Rows loaded
-------------
52
返回包含在指定的 shapefile 中找到的属性列和类型的 CREATE TABLE 语句。
列类型将根据 shapefile 元数据调整大小。列大小基于在 shapefile 中找到的最大几何图形。表中的第一列是 gid，它是自动递增的 IDENTITY 主关键字列。缓存值默认设为 64。最后一列是用于存储实际几何数据的 GEOMETRY 数据类型。
STV_ShpCreateTable (USING PARAMETERS file='filename') OVER()
file = 'filename'.dbf、.shp 或 .shx 文件的完全限定路径（文件扩展名可选）。
您还可以使用存储在您具有读取和写入权限的挂载 S3 目录中的 shapefile 创建表。使用以下语法：
bucketname/path/filename
与指定的 shapefile 相匹配的 CREATE TABLE 语句
STV_ShpCreateTable 会返回 CREATE TABLE 语句；但它不会创建表。根据需要修改 CREATE TABLE 语句，在将 shapefile 加载到表中之前创建该表。
要使用字母数字和下划线 (_) 字符之外的其他字符创建表，必须指定双引号括起的表名称，例如"counties%NY"。
表名称与 shapefile 的名称相同（不包括目录名称或扩展名）。
必须可以从启动节点访问 shapefile。
如果 .shp 和 .shx 文件已损坏，STV_ShpCreateTable 将返回错误。如果 .shp 和 .shx 文件有效，但 .dbf 文件已损坏，STV_ShpCreateTable 将忽略 .dbf 文件并且不创建该数据对应的列。
所有必要文件（.dbf、.shp、.shx）必须在同一个目录中。否则，STV_ShpCreateTable 将会返回错误。
如果 shapefile 的 .dbf 组件包含数字属性，则在 Vertica shapefile 加载程序将此字段加载到表中时，此字段的值可能会损失精度。因为目标字段为 64 位 FLOAT 列，只能表示约 15 个有效位。而在 .dbf 文件中，数字字段最多可达 30 位。
Vertica 会在 vertica.log 文件中记录所有太长的 shapefile 值实例。
以下示例显示了 STV_ShpCreateTable 的用法。
返回 CREATE TABLE 语句：
=> SELECT STV_ShpCreateTable
(USING PARAMETERS file='/shapefiles/tl_2010_us_state10.shp')
OVER() as create_table_states;
create_table_states
----------------------------------
CREATE TABLE tl_2010_us_state10(
gid IDENTITY(64) PRIMARY KEY,
REGION10 VARCHAR(2),
DIVISION10 VARCHAR(2),
STATEFP10 VARCHAR(2),
STATENS10 VARCHAR(8),
GEOID10 VARCHAR(2),
STUSPS10 VARCHAR(2),
NAME10 VARCHAR(100),
LSAD10 VARCHAR(2),
MTFCC10 VARCHAR(5),
FUNCSTAT10 VARCHAR(1),
ALAND10 INT8,
AWATER10 INT8,
INTPTLAT10 VARCHAR(11),
INTPTLON10 VARCHAR(12),
geom GEOMETRY(940845)
);
(18 rows)
此部分包含用于管理与 Hadoop 交互的函数。
清除从 HDFS 复制的配置信息和任何缓存的连接。
此函数通过以下方式影响使用 hdfs 方案的读取：
此函数刷新从 Hadoop 复制的配置文件（例如 core-site.xml）加载的信息。这些文件位于 HadoopConfDir 配置参数设置的路径中。
此函数刷新有关在高可用性 (HA) Hadoop 群集中哪个 NameNode 处于活动状态的信息。因此，调用此函数后对 Hadoop 的第一次请求比预期的要慢。
Vertica 维护与 NameNode 的打开连接的缓存以减少延迟。此函数刷新该缓存。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_HDFS_CACHES ( )
超级用户
以下示例清除了 Hadoop 配置信息：
=> SELECT CLEAR_HDFS_CACHES();
CLEAR_HDFS_CACHES
--------------
Cleared
(1 row)
测试 Vertica 群集的 Hadoop 配置。该函数测试 HDFS 配置文件、HCatalog 连接器配置和 Kerberos 配置。
该函数调用以下函数：
如果使用一个实参调用此函数，它会将此实参传递给它调用的函数，这些函数也接受一个实参。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXTERNAL_CONFIG_CHECK( ['what_to_test' ] )
what_to_test此函数不需要权限。
以下示例仅测试名为“ns1”的名称服务的配置。由于长度原因，输出已被忽略。
=> SELECT EXTERNAL_CONFIG_CHECK('nameservice=ns1');
返回 Parquet 文件的元数据。元数据包括行组的数量和大小、列名以及有关块和压缩的信息。元数据以 JSON 形式返回。
此函数检查一个文件。Parquet 数据通常跨越单个目录中的多个文件；选择一个。该函数不接受目录名称作为实参。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_METADATA( 'filename' )
filename 在 USER 可访问的存储位置上具有 READ 权限的超级用户或非超级用户（请参阅 GRANT（存储位置））。
您必须使用单个文件而不是目录或 glob 调用此函数：
=> SELECT GET_METADATA('/data/emp-row.parquet');
GET_METADATA
----------------------------------------------------------------------------------------------------
schema:
required group field_id=-1 spark_schema {
optional int32 field_id=-1 employeeID;
optional group field_id=-1 personal {
optional binary field_id=-1 name (String);
optional group field_id=-1 address {
optional binary field_id=-1 street (String);
optional binary field_id=-1 city (String);
optional int32 field_id=-1 zipcode;
}
optional int32 field_id=-1 taxID;
}
optional binary field_id=-1 department (String);
}
data page version:
data page v1
metadata:
{
"FileName": "/data/emp-row.parquet",
"FileFormat": "Parquet",
"Version": "1.0",
"CreatedBy": "parquet-mr version 1.10.1 (build a89df8f9932b6ef6633d06069e50c9b7970bebd1)",
"TotalRows": "4",
"NumberOfRowGroups": "1",
"NumberOfRealColumns": "3",
"NumberOfColumns": "7",
"Columns": [
{ "Id": "0", "Name": "employeeID", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
{ "Id": "1", "Name": "personal.name", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
{ "Id": "2", "Name": "personal.address.street", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
{ "Id": "3", "Name": "personal.address.city", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} },
{ "Id": "4", "Name": "personal.address.zipcode", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
{ "Id": "5", "Name": "personal.taxID", "PhysicalType": "INT32", "ConvertedType": "NONE", "LogicalType": {"Type": "None"} },
{ "Id": "6", "Name": "department", "PhysicalType": "BYTE_ARRAY", "ConvertedType": "UTF8", "LogicalType": {"Type": "String"} }
],
"RowGroups": [
{
"Id": "0", "TotalBytes": "642", "TotalCompressedBytes": "0", "Rows": "4",
"ColumnChunks": [
{"Id": "0", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "51513", "Min": "17103" },
"Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "67", "CompressedSize": "69" },
{"Id": "1", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Sheldon Cooper", "Min": "Howard Wolowitz" },
"Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "142", "CompressedSize": "145" },
{"Id": "2", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "52 Broad St", "Min": "100 Main St Apt 4A" },
"Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "139", "CompressedSize": "123" },
{"Id": "3", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Pasadena", "Min": "Pasadena" },
"Compression": "SNAPPY", "Encodings": "RLE PLAIN_DICTIONARY BIT_PACKED ", "UncompressedSize": "95", "CompressedSize": "99" },
{"Id": "4", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "91021", "Min": "91001" },
"Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "68", "CompressedSize": "70" },
{"Id": "5", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "4", "DistinctValues": "0", "Max": "0", "Min": "0" },
"Compression": "SNAPPY", "Encodings": "PLAIN RLE BIT_PACKED ", "UncompressedSize": "28", "CompressedSize": "30" },
{"Id": "6", "Values": "4", "StatsSet": "True", "Stats": {"NumNulls": "0", "DistinctValues": "0", "Max": "Physics", "Min": "Astronomy" },
"Compression": "SNAPPY", "Encodings": "RLE PLAIN_DICTIONARY BIT_PACKED ", "UncompressedSize": "103", "CompressedSize": "107" }
]
}
]
}
(1 row)
报告 Vertica 在访问 HDFS 中的 Kerberized 数据时将使用的委派令牌。HadoopImpersonationConfig 配置参数指定一个或多个权限、名称服务和 HCatalog 架构及其关联的令牌。对于每个测试值，该函数会报告 Vertica 将使用什么 doAs 用户或委派令牌进行访问。使用此函数确认您已按预期定义了您的委派令牌。
您可以使用实参调用此函数来指定要测试的权限、名称服务或 HCatalog 架构，或者不使用实参来测试所有配置的值。
此函数不检查您是否可以使用这些委派令牌访问 HDFS。
有关模拟的详细信息，请参阅 代理用户和委托令牌。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HADOOP_IMPERSONATION_CONFIG_CHECK( ['what_to_test' ] )
what_to_test如果您不指定此实参，该函数将测试 HadoopImpersonationConfig 中定义的所有权限、名称服务和架构。
此函数不需要权限。
考虑 HadoopImpersonationConfig 的以下定义：
[{
"nameservice": "ns1",
"token": "RANDOM-TOKEN-STRING"
},
{
"nameservice": "*",
"doAs": "Paul"
},
{
"schema": "hcat1",
"doAs": "Fred"
}
]
以下查询仅测试“ns1”名称服务：
=> SELECT HADOOP_IMPERSONATION_CONFIG_CHECK('nameservice=ns1');
-- hadoop_impersonation_config_check --
Connections to nameservice [ns1] will use a delegation token with hash [b3dd9e71cd695d91]
出于安全原因，此函数返回令牌的哈希值。您可以使用预期值调用 HASH_EXTERNAL_TOKEN 并将该哈希值与此函数输出中的哈希值进行比较。
不带实参的查询会测试所有值：
=> SELECT HADOOP_IMPERSONATION_CONFIG_CHECK();
-- hadoop_impersonation_config_check --
Connections to nameservice [ns1] will use a delegation token with hash [b3dd9e71cd695d91]
JDBC connections for HCatalog schema [hcat1] will doAs [Fred]
[!] hadoop_impersonation_config_check : [PASS]
返回字符串令牌的哈希值，用于 HADOOP_IMPERSONATION_CONFIG_CHECK。使用您希望 Vertica 使用的委派令牌调用 HASH_EXTERNAL_TOKEN，并将其与 HADOOP_IMPERSONATION_CONFIG_CHECK 输出中的哈希值进行比较。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HASH_EXTERNAL_TOKEN( 'token' )
token此函数不需要权限。
以下查询测试 HADOOP_IMPERSONATION_CONFIG_CHECK 参考页面上示例中显示的预期值。
=> SELECT HASH_EXTERNAL_TOKEN('RANDOM-TOKEN-STRING');
hash_external_token
---------------------
b3dd9e71cd695d91
(1 row)
测试使用 HCatalog 连接器访问 Hive 数据的 Vertica 群集的配置。该函数首先验证 HCatalog 连接器是否已正确安装并报告几个相关配置参数的值。然后它使用 HiveServer2 测试连接。此函数不支持 WebHCat 服务器。
如果您指定 HCatalog 架构，并且您已为该架构定义了委派令牌，则此函数使用委派令牌。否则，该函数使用没有委派令牌的默认端点。
有关委派令牌的详细信息，请参阅代理用户和委托令牌。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HCATALOGCONNECTOR_CONFIG_CHECK( ['what_to_test' ] )
what_to_test此函数不需要权限。
以下查询使用默认端点和无委派令牌进行测试。
=> SELECT HCATALOGCONNECTOR_CONFIG_CHECK();
-- hcatalogconnector_config_check --
HCatalogConnectorUseHiveServer2 : [1]
EnableHCatImpersonation : [1]
HCatalogConnectorUseORCReader : [1]
HCatalogConnectorUseParquetReader : [1]
HCatalogConnectorUseTxtReader : [0]
[INFO] Vertica is not configured to use its internal parsers for delimited files.
[INFO] This is off by default, but will be changed in a future release.
HCatalogConnectorUseLibHDFSPP : [1]
[OK] HCatalog connector library is properly installed.
[INFO] Creating JDBC connection as session user.
[OK] Successful JDBC connection to HiveServer2 as user [USER].
[!] hcatalogconnector_config_check : [PASS]
要使用配置的委派令牌进行测试，请将架构作为实参传递：
=> SELECT HCATALOGCONNECTOR_CONFIG_CHECK('schema=hcat1');
测试使用 HDFS 的 Vertica 群集的配置。该函数扫描在 HadoopConfDir 中找到的 Hadoop 配置文件，并对它找到的每个群集执行配置检查。如果您配置了多个群集，您可以指定测试哪一个而不是测试所有群集。
对于每个 Hadoop 群集，它报告的属性包括：
名称服务名称和关联的 NameNode
高可用性状态
RPC 加密状态
Kerberos 身份验证状态
HTTP(S) 状态
然后，它使用 http(s)、hdfs 和 webhdfs URL 方案测试连接。它使用 Vertica 和会话用户测试后两者。
有关配置文件和 HadoopConfDir 的信息，请参阅配置 HDFS 访问。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HDFS_CLUSTER_CONFIG_CHECK( ['what_to_test' ] )
what_to_test如果您不指定此实参，该函数将测试在 HadoopConfDir 中找到的所有群集配置。
此函数不需要权限。
以下示例测试所有群集。
=> SELECT HDFS_CLUSTER_CONFIG_CHECK();
-- hdfs_cluster_config_check --
Hadoop Conf Path : [/conf/hadoop_conf]
[OK] HadoopConfDir verified on all nodes
Connection Timeout (seconds) : [60]
Token Refresh Frequency (seconds) : [0]
HadoopFSBlockSizeBytes (MiB) : [64]
[OK] Found [1] hadoop cluster configurations
------------- Cluster 1 -------------
Is DefaultFS : [true]
Nameservice : [vmns]
Namenodes : [node1.example.com:8020, node2.example.com:8020]
High Availability : [true]
RPC Encryption : [false]
Kerberos Authentication : [true]
HTTPS Only : [false]
[INFO] Checking connections to [hdfs:///]
vertica : [OK]
dbuser : [OK]
[INFO] Checking connections to [http://node1.example.com:50070]
[INFO] Node is in standby
[INFO] Checking connections to [http://node2.example.com:50070]
[OK] Can make authenticated external curl connection
[INFO] Checking webhdfs
vertica : [OK]
USER : [OK]
[!] hdfs_cluster_config_check : [PASS]
测试使用 HDFS 的 Vertica 群集的 Kerberos 配置。如果该函数可以同时使用 Vertica keytab 文件和会话用户访问 HDFS，则该函数成功，否则报告错误。该函数是 KERBEROS_CONFIG_CHECK 的一个更具体的版本。
如果当前会话没有 Kerberos 化，该函数将不能使用安全的 HDFS 连接并且会失败。
您可以使用实参调用此函数来指定要测试的 HDFS 配置，也可以不使用实参。如果你不使用实参调用此函数，该函数会读取 HDFS 配置文件，如果没有找到它们就会失败。请参阅配置 HDFS 访问。如果它找到配置文件，它会测试所有配置的名称服务。
该函数按顺序执行以下测试：
是否提供 Kerberos 服务？
是否存在 keytab 文件，是否在数据库中设置了 Kerberos 和 HDFS 配置参数？
Vertica 是否可以读取并使用密钥调用 kinit 以向 HDFS 进行身份验证并获取数据库 Kerberos 票证？
Vertica 能否同时使用数据库 Kerberos 票证和当前会话的用户可转发票证来执行 hdfs 和 webhdfs 操作？
Vertica 是否可以连接到 HiveServer2？（此函数不支持 WebHCat。）
如果任何测试失败，该函数将返回描述性错误消息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
KERBEROS_HDFS_CONFIG_CHECK( ['hdfsHost:hdfsPort',
'webhdfsHost:webhdfsPort', 'webhcatHost' ] )
hdfsHost, hdfsPorthdfs URL 指定的数据。如果值为 ' '，则函数跳过这部分检查。webhdfsHost, webhdfsPortwebhdfs URL 指定的数据。如果值为 ' '，则函数跳过这部分检查。此函数不需要权限。
将通过 HCatalog 连接器可用的 Hive 数据库架构的结构复制到 Vertica 架构。如果 HCatalog 架构和目标 Vertica 架构具有匹配的表名，SYNC_WITH_HCATALOG_SCHEMA 将覆盖 Vertica 表。
该函数可以直接同步 HCatalog 架构。在这种情况下，对 vertica_schema 和 hcatalog_schema 参数使用相同的架构名称调用该函数。该函数还可以将不同的架构同步到 HCatalog 架构。
如果更改 HCatalog 连接器配置参数的设置，必须再次调用该函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SYNC_WITH_HCATALOG_SCHEMA( vertica_schema, hcatalog_schema, [drop_non_existent] )
vertica_schemahcatalog_schematrue，请删除 vertica_schema 中与 hcatalog_schema 中的表不对应的任何表非超级用户：vertica_schema 上的 CREATE 权限。
用户还需要 Hive 数据的以下访问权限之一：
hcat_schema 的使用权限（如果 Hive 不使用授权服务来管理访问权限）。
通过授权服务（Sentry 或 Ranger）进行管理的权限，以及 HDFS 中的底层文件的访问权限。（Sentry 可以通过 ACL 同步提供该访问权限。）
dbadmin 用户权限（有/无授权服务）。
在 Vertica 中，Hive STRING 和 BINARY 数据类型与 VARCHAR(65000) 和 VARBINARY(65000) 类型相匹配。创建架构后，根据需要使用 ALTER TABLE调整数据类型。Vertica 中的 VARCHAR 或 VARBINARY 的最大大小为 65000，但您可以使用 LONG VARCHAR 和 LONG VARBINARY 指定更大的值。
Hive 和 Vertica 以不同的方式定义字符串长度。在 Hive 中，长度是指字符的数量；在 Vertica 中，长度是指字节的数量。因此，使用多个字节的字符编码（例如 Unicode）可能会导致两者之间不匹配。为避免数据截断，请根据字节而不是字符设置 Vertica 中的值。
如果数据大小超出列大小，Vertica 将在读取时间在 QUERY_EVENTS 系统表中记录一个事件。
以下示例使用 SYNC_WITH_HCATALOG_SCHEMA 同步名为 hcat 的 HCatalog 架构：
=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat', 'hcat');
sync_with_hcatalog_schema
----------------------------------------
Schema hcat synchronized with hcat
tables in hcat = 56
tables altered in hcat = 0
tables created in hcat = 56
stale tables in hcat = 0
table changes erred in hcat = 0
(1 row)
=> -- Use vsql's \d command to describe a table in the synced schema
=> \d hcat.messages
List of Fields by Tables
Schema | Table | Column | Type | Size | Default | Not Null | Primary Key | Foreign Key
-----------+----------+---------+----------------+-------+---------+----------+-------------+-------------
hcat | messages | id | int | 8 | | f | f |
hcat | messages | userid | varchar(65000) | 65000 | | f | f |
hcat | messages | "time" | varchar(65000) | 65000 | | f | f |
hcat | messages | message | varchar(65000) | 65000 | | f | f |
(4 rows)
以下示例使用 SYNC_WITH_HCATALOG_SCHEMA 后跟 ALTER TABLE 来调整列值：
=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
-> HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat', 'hcat');
...
=> ALTER TABLE hcat.t ALTER COLUMN a1 SET DATA TYPE long varchar(1000000);
=> ALTER TABLE hcat.t ALTER COLUMN a2 SET DATA TYPE long varbinary(1000000);
以下示例使用带本地（非 HCatalog）架构的 SYNC_WITH_HCATALOG_SCHEMA：
=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='default'
-> HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> CREATE SCHEMA hcat_local;
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema('hcat_local', 'hcat');
将通过 HCatalog 连接器可用的 Hive 数据库架构中的单个表结构复制到 Vertica 表。
该函数可以直接同步 HCatalog 架构。在这种情况下，对 vertica_schema 和 hcatalog_schema 参数使用相同的架构名称调用该函数。该函数还可以将不同的架构同步到 HCatalog 架构。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SYNC_WITH_HCATALOG_SCHEMA_TABLE( vertica_schema, hcatalog_schema, table_name )
vertica_schemahcatalog_schematable_name非超级用户：vertica_schema 上的 CREATE 权限。
用户还需要 Hive 数据的以下访问权限之一：
hcat_schema 的使用权限（如果 Hive 不使用授权服务来管理访问权限）。
通过授权服务（Sentry 或 Ranger）进行管理的权限，以及 HDFS 中的底层文件的访问权限。（Sentry 可以通过 ACL 同步提供该访问权限。）
dbadmin 用户权限（有/无授权服务）。
在 Vertica 中，Hive STRING 和 BINARY 数据类型与 VARCHAR(65000) 和 VARBINARY(65000) 类型相匹配。创建架构后，根据需要使用 ALTER TABLE调整数据类型。Vertica 中的 VARCHAR 或 VARBINARY 的最大大小为 65000，但您可以使用 LONG VARCHAR 和 LONG VARBINARY 指定更大的值。
Hive 和 Vertica 以不同的方式定义字符串长度。在 Hive 中，长度是指字符的数量；在 Vertica 中，长度是指字节的数量。因此，使用多个字节的字符编码（例如 Unicode）可能会导致两者之间不匹配。为避免数据截断，请根据字节而不是字符设置 Vertica 中的值。
如果数据大小超出列大小，Vertica 将在读取时间在 QUERY_EVENTS 系统表中记录一个事件。
以下示例使用 SYNC_WITH_HCATALOG_SCHEMA_TABLE 来同步 "nation" 表：
=> CREATE SCHEMA 'hcat_local';
CREATE SCHEMA
=> CREATE HCATALOG SCHEMA hcat WITH hostname='hcathost' HCATALOG_SCHEMA='hcat'
HCATALOG_USER='hcatuser';
CREATE SCHEMA
=> SELECT sync_with_hcatalog_schema_table('hcat_local', 'hcat', 'nation');
sync_with_hcatalog_schema_table
-----------------------------------------------------------------------------
Schema hcat_local synchronized with hcat for table nation
table nation is created in schema hcat_local
(1 row)
以下示例显示本地架构中已存在 "nation" 表时的行为：
=> SELECT sync_with_hcatalog_schema_table('hcat_local','hcat','nation');
sync_with_hcatalog_schema_table
-----------------------------------------------------------------------------
Schema hcat_local synchronized with hcat for table nation
table nation is altered in schema hcat_local
(1 row)
验证用于访问 HDFS 的 Hadoop 配置在所有 Vertica 节点上是否有效。配置在以下情况下有效：
所有必需的配置文件位于 HadoopConfDir 配置参数定义的路径中
Vertica 所需的所有属性都在这些文件中设置
此函数不会尝试验证这些属性的设置；它仅验证它们是否具有值。
Hadoop 配置可能在某些节点上有效而在其他节点上无效。如果值在任何节点上无效，该函数将报告验证失败；输出的其余部分报告详细信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
VERIFY_HADOOP_CONF_DIR( )
此函数没有参数。
此函数不需要权限。
以下示例显示了 Hadoop 配置有效时的结果。
=> SELECT VERIFY_HADOOP_CONF_DIR();
verify_hadoop_conf_dir
-------------------------------------------------------------------
Validation Success
v_vmart_node0001: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0002: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0003: HadoopConfDir [PG_TESTOUT/config] is valid
v_vmart_node0004: HadoopConfDir [PG_TESTOUT/config] is valid
(1 row)
在以下示例中，Hadoop 配置在一个节点上有效，但在其他节点上缺少所需的值。
=> SELECT VERIFY_HADOOP_CONF_DIR();
verify_hadoop_conf_dir
-------------------------------------------------------------------
Validation Failure
v_vmart_node0001: HadoopConfDir [PG_TESTOUT/test_configs/config] is valid
v_vmart_node0002: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
v_vmart_node0003: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
v_vmart_node0004: No fs.defaultFS parameter found in config files in [PG_TESTOUT/config]
(1 row)
利用机器学习函数可以处理数据分析过程不同阶段的数据集：
准备模型
训练模型
评估模型
应用模型
管理模型
一些 Vertica 机器学习函数作为 Vertica UDx 函数实施，另一些函数则作为元函数实施：
UDx 函数接受来自 FROM 子句的输入关系名称。调用函数的 SELECT 语句可组合 — 可用作其他 SELECT 语句的子查询。
元函数接受将输入关系名称作为单引号字符串传递，以作为实参或命名参数。SELECT 语句返回的数据不能用于子查询。机器学习元函数不支持临时表。
所有机器学习函数都会自动将 NUMERIC 实参转换为 FLOAT。
Vertica 支持机器学习函数，可在对数据进行分析之前根据需要准备数据。
根据 response_column 返回输入数据的平均分布视图。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BALANCE ( 'output‑view', 'input‑relation', 'response‑column', 'balance‑method'
[ USING PARAMETERS sampling_ratio=ratio ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。hybrid_sampling：对不同类执行过采样和欠采样，因此平等展现每个类。
over_sampling：对所有类过采样，多数类除外，适用于多数类的基数。
under_sampling：对所有类欠采样，少数类除外，适用于少数类的基数。
weighted_sampling：under_sampling 的别名。
ratiohybrid_sampling 配合使用时，此值无效。
默认值： 1.0
非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
=> CREATE TABLE backyard_bugs (id identity, bug_type int, finder varchar(20));
CREATE TABLE
=> COPY backyard_bugs FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1|Ants
>> 1|Beetles
>> 3|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 3|Caterpillars
>> 2|Ladybugs
>> 3|Ants
>> 3|Beetles
>> 1|Ladybugs
>> 3|Ladybugs
>> \.
=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs GROUP BY bug_type;
bug_type | COUNT
----------+-------
2 | 1
1 | 3
3 | 7
(3 rows)
=> SELECT BALANCE('backyard_bugs_balanced', 'backyard_bugs', 'bug_type', 'under_sampling');
BALANCE
--------------------------
Finished in 1 iteration
(1 row)
=> SELECT bug_type, COUNT(bug_type) FROM backyard_bugs_balanced GROUP BY bug_type;
----------+-------
2 | 1
1 | 2
3 | 1
(3 rows)
采用数字列的输入关系，计算其每对输入列之间的皮尔逊相关系数。函数作为多阶段转换函数实施。
CORR_MATRIX ( input-columns ) OVER()
input-columnsCORR_MATRIX 以三元组格式返回关联矩阵。也就是说，每个成对关联通过三个返回的列标识：第一个变量的名称、第二个变量的名称和每对输入列的关联值。函数还会返回两个额外的列： number_of_ignored_input_rows 和 number_of_processed_input_rows。第四/五列的值表示输入中忽略/用于计算相应关联值的行数。任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。
关联矩阵对称，所有对角元素的值均为 1；因此，只能返回对角线以上元素的值 — 即上三角。尽管如此，函数返回整个矩阵以简化任何后续操作。因此，输出行数为：
(#input‑columns)^2
前两个输出列为 VARCHAR(128) 类型，第三个输出列为 FLOAT 类型，最后两个输出列为 INT 类型。
OVER 子句的内容必须为空。
当输入表为空时，函数不会返回任何行。
当 X_i 和 Y_i 中的任何一个为 NULL、Inf 或 NaN 时，该对将不纳入 CORR(X, Y) 计算。也就是说，任何包含 NULL、Inf 或 NaN 的输入对都将被忽略。
对于 (X,X) 对，无论 X 的内容如何：CORR(X,X) = 1、number_of_ignored_input_rows = 0 且 number_of_processed_input_rows = #input_rows。
当 (NSUMX2 == SUMXSUMX) 或 (NSUMY2 == SUMYSUMY) 时，则 CORR(X, Y) 的值将为 NULL。理论上，可能发生在具有常数值的列的情况；然而，由于舍入误差，可能无法始终观察到。
在特殊情况下，即 (X_i,Y_i) 的所有对值均包含 NULL、inf 或 NaN 且 X != Y：CORR(X,Y)=NULL。
下面的示例使用 iris 数据集。*
根据异常值阈值返回数据集中的异常值。输出为包含异常值的表。 DETECT_OUTLIERS 使用检测方法 robust_szcore 使每个输入列实现标准化。然后，函数将包含大于默认或指定阈值的标准化值的所有行标识为异常值。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DETECT_OUTLIERS ( 'output‑table', 'input‑relation','input‑columns', 'detection‑method'
[ USING PARAMETERS
[outlier_threshold = threshold]
[, exclude_columns = 'excluded‑columns']
[, partition_columns = 'partition‑columns'] ] )
input_columns 的异常值行的表的名称。所有列均存在于此表中。SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。robust_zscore。outlier_threshold默认值： 3.0
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
partition_columnsDETECT_OUTLIERS 分别检测每个分区中的异常值。
默认值： 空列表
非超级用户：
对输入关系的 SELECT 权限
对输出表的 CREATE 权限
以下示例显示了 DETECT_OUTLIERS 的用法：
=> CREATE TABLE baseball_roster (id identity, last_name varchar(30), hr int, avg float);
CREATE TABLE
=> COPY baseball_roster FROM STDIN;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Polo|7|.233
>> Gloss|45|.170
>> Gus|12|.345
>> Gee|1|.125
>> Laus|3|.095
>> Hilltop|16|.222
>> Wicker|78|.333
>> Scooter|0|.121
>> Hank|999999|.8888
>> Popup|35|.378
>> \.
=> SELECT * FROM baseball_roster;
id | last_name | hr | avg
----+-----------+--------+--------
3 | Gus | 12 | 0.345
4 | Gee | 1 | 0.125
6 | Hilltop | 16 | 0.222
10 | Popup | 35 | 0.378
1 | Polo | 7 | 0.233
7 | Wicker | 78 | 0.333
9 | Hank | 999999 | 0.8888
2 | Gloss | 45 | 0.17
5 | Laus | 3 | 0.095
8 | Scooter | 0 | 0.121
(10 rows)
=> SELECT DETECT_OUTLIERS('baseball_outliers', 'baseball_roster', 'id, hr, avg', 'robust_zscore' USING PARAMETERS
outlier_threshold=3.0);
DETECT_OUTLIERS
--------------------------
Detected 2 outliers
(1 row)
=> SELECT * FROM baseball_outliers;
id | last_name | hr | avg
----+-----------+------------+-------------
7 | Wicker | 78 | 0.333
9 | Hank | 999999 | 0.8888
(2 rows)
训练并返回隔离森林 (iForest) 模型。训练模型后，可以使用 APPLY_IFOREST 函数预测输入关系中的异常值。
有关 iForest 算法工作原理的详细信息，请参阅隔离森林。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IFOREST( 'model‑name', 'input‑relation', 'input‑columns' [ USING PARAMETERS param=value[,...] ] )
CHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
exclude_columns默认值： 空字符串 ('')
ntree默认值： 100
sampling_size默认值： 0.632
col_sample_by_tree默认值： 1.0
max_depth默认值： 10
nbins默认值： 32
detailspredictor：预测变量的名称与训练模型时指定的顺序相同。
type：预测变量的类型的顺序与其名称在 predictor 中的顺序相同。
tree_countrejected_row_countaccepted_row_countrejected_row_count。call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
在以下示例中，函数的输入数据包含 INT、VARCHAR 和 FLOAT 类型的列：
=> SELECT IFOREST('baseball_anomalies','baseball','team, hr, hits, avg, salary' USING PARAMETERS ntree=75, sampling_size=0.7,
max_depth=15);
IFOREST
----------
Finished
(1 row)
您可以通过调用 GET_MODEL_SUMMARY 并检查详细信息部分来验证是否正确读取所有输入列：
=> SELECT GET_MODEL_SUMMARY(USING PARAMETERS model_name='baseball_anomalies');
GET_MODEL_SUMMARY
-------------------------------------------------------------------------------------------------------------------------------------
===========
call_string
===========
SELECT iforest('public.baseball_anomalies', 'baseball', 'team, hr, hits, avg, salary' USING PARAMETERS exclude_columns='', ntree=75,
sampling_size=0.7, col_sample_by_tree=1, max_depth=15, nbins=32);
=======
details
=======
predictor| type
---------+----------------
team |char or varchar
hr | int
hits | int
avg |float or numeric
salary |float or numeric
===============
Additional Info
===============
Name |Value
------------------+-----
tree_count | 75
rejected_row_count| 0
accepted_row_count|1000
(1 row)
根据每列中变量的观察值，使用平均值或众数估算数据集中的缺失值。此函数支持数字和分类数据类型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPUTE( 'output‑view', 'input‑relation', 'input‑columns', 'method'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, partition_columns = 'partition‑columns'] ] )
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。mean：每列中的缺失值将替换为该列的平均值。此方法仅适用于数字数据。
mode：每列中的缺失值将替换为该列中出现频率最高的值。此方法仅适用于分类数据。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
partition_columns非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
在 small_input_impute 表上执行 IMPUTE，指定平均值方法：
=> SELECT impute('output_view','small_input_impute', 'pid, x1,x2,x3,x4','mean'
USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)
执行IMPUTE，指定模式方法：
=> SELECT impute('output_view3','small_input_impute', 'pid, x5,x6','mode' USING PARAMETERS exclude_columns='pid');
impute
--------------------------
Finished in 1 iteration
(1 row)
对输入关系运行标准化算法。输出是具有标准化数据的视图。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NORMALIZE ( 'output‑view', 'input‑relation', 'input‑columns', 'normalization‑method'
[ USING PARAMETERS exclude_columns = 'excluded‑columns' ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。minmax
zscore
robust_zscore
如果表中出现无穷大值，该方法将自动忽略这些值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
非超级用户：
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
这些示例显示了如何在 mtcars 表的 wt 和 hp 列上使用 NORMALIZE 函数。
执行 NORMALIZE 函数，并指定 minmax 方法：
=> SELECT NORMALIZE('mtcars_norm', 'mtcars',
'wt, hp', 'minmax');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
执行 NORMALIZE 函数，并指定 zscore 方法：
=> SELECT NORMALIZE('mtcars_normz','mtcars',
'wt, hp', 'zscore');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
执行 NORMALIZE 函数，并指定 robust_zscore 方法：
=> SELECT NORMALIZE('mtcars_normz', 'mtcars',
'wt, hp', 'robust_zscore');
NORMALIZE
--------------------------
Finished in 1 iteration
(1 row)
NORMALIZE_FIT 计算输入关系中每个指定列的标准化参数。生成的模型将存储标准化参数。例如，对于 MinMax 标准化，每列的最小值和最大值都存储在模型中。生成的模型用作函数 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的输入。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NORMALIZE_FIT ( 'model‑name', 'input‑relation', 'input‑columns', 'normalization‑method'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, output_view = 'output‑view'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。minmax
zscore
robust_zscore
如果指定 robust_zscore，则 NORMALIZE_FIT 使用函数 APPROXIMATE_MEDIAN [聚合]。
所有标准化方法都将忽略输入关系中的无穷大、负无穷大或 NULL 值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
output_viewdataminmax：
colNames：模型列名称
mins：每列的最小值
maxes：每列的最大值
非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
以下示例使用表 mtcars 中的 wt 和 hp 列创建具有 NORMALIZE_FIT 的模型，然后在对 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的连续调用中使用此模型。
=> SELECT NORMALIZE_FIT('mtcars_normfit', 'mtcars', 'wt,hp', 'minmax');
NORMALIZE_FIT
---------------
Success
(1 row)
以下对 APPLY_NORMALIZE 的调用指定表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型中，而 cyl 不在标准化模型中：
=> CREATE TABLE mtcars_normalized AS SELECT APPLY_NORMALIZE (hp, cyl USING PARAMETERS model_name = 'mtcars_normfit') FROM mtcars;
CREATE TABLE
=> SELECT * FROM mtcars_normalized;
hp | cyl
--------------------+-----
0.434628975265018 | 8
0.681978798586572 | 8
0.434628975265018 | 6
1 | 8
0.540636042402827 | 8
0 | 4
0.681978798586572 | 8
0.0459363957597173 | 4
0.434628975265018 | 8
0.204946996466431 | 6
0.250883392226148 | 6
0.049469964664311 | 4
0.204946996466431 | 6
0.201413427561837 | 4
0.204946996466431 | 6
0.250883392226148 | 6
0.049469964664311 | 4
0.215547703180212 | 4
0.0353356890459364 | 4
0.187279151943463 | 6
0.452296819787986 | 8
0.628975265017668 | 8
0.346289752650177 | 8
0.137809187279152 | 4
0.749116607773852 | 8
0.144876325088339 | 4
0.151943462897526 | 4
0.452296819787986 | 8
0.452296819787986 | 8
0.575971731448763 | 8
0.159010600706714 | 4
0.346289752650177 | 8
(32 rows)
=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
hp | cyl
-----+-----
175 | 8
245 | 8
175 | 6
335 | 8
205 | 8
52 | 4
245 | 8
65 | 4
175 | 8
110 | 6
123 | 6
66 | 4
110 | 6
109 | 4
110 | 6
123 | 6
66 | 4
113 | 4
62 | 4
105 | 6
180 | 8
230 | 8
150 | 8
91 | 4
264 | 8
93 | 4
95 | 4
180 | 8
180 | 8
215 | 8
97 | 4
150 | 8
(32 rows)
以下对 REVERSE_NORMALIZE 的调用还指定了表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型 mtcars_normfit 中，而 cyl 不在标准化模型中。
=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
hp | cyl
-----------------+-----
205.000005722046 | 8
150.000000357628 | 8
150.000000357628 | 8
93.0000016987324 | 4
174.99999666214 | 8
94.9999992102385 | 4
214.999997496605 | 8
97.0000009387732 | 4
245.000006556511 | 8
174.99999666214 | 6
335 | 8
245.000006556511 | 8
62.0000002086163 | 4
174.99999666214 | 8
230.000002026558 | 8
52 | 4
263.999997675419 | 8
109.999999523163 | 6
123.000002324581 | 6
64.9999996386468 | 4
66.0000005029142 | 4
112.999997898936 | 4
109.999999523163 | 6
180.000000983477 | 8
180.000000983477 | 8
108.999998658895 | 4
109.999999523163 | 6
104.999999418855 | 6
123.000002324581 | 6
180.000000983477 | 8
66.0000005029142 | 4
90.9999999701977 | 4
(32 rows)
为要编码的每个功能生成每个类别级别的排序列表，并存储模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ONE_HOT_ENCODER_FIT ( 'model‑name', 'input‑relation','input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, output_view = 'output‑view']
[, extra_levels = 'category‑levels'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
output_viewextra_levelscall_stringvarchar_categories integer_categories boolean_categories date_categoriescategory_name：列名称
category_level：类别的级别，按类别排序
category_level_index：此分类级别在类别级别的排序列表中的索引。
非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
输出视图架构的 CREATE 权限
=> SELECT ONE_HOT_ENCODER_FIT ('one_hot_encoder_model','mtcars','*'
USING PARAMETERS exclude_columns='mpg,disp,drat,wt,qsec,vs,am');
ONE_HOT_ENCODER_FIT
--------------------
Success
(1 row)
通过输入表/视图计算主组件。结果保存在 PCA 模型中。在内部，PCA 使用基于输入日期构建的协方差矩阵的 SVD 来查找组件。该分解的奇异值也保存在 PCA 模型中，作为其一部分。可以在不同的运行中同时翻转一个主组件的所有元素符号。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PCA ( 'model‑name', 'input‑relation', 'input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, num_components = num‑components]
[, scale = is‑scaled]
[, method = 'method'] ] )
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
num_componentsscaleTrue：使用相关系数矩阵，而非协方差矩阵。
False （默认值）
methodLAPACK。columnsindex
name
singular_valuesindex
value
explain_variance：对应于该奇异值的数据方差的百分比
accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比
principal_componentsindex：各组件中元素的索引
PC1
PC2
...
counterscounter_name
Accepted_row_count：数据中有效行的数量
denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量
iteration_count：迭代次数，对于当前的 PCA 操作，始终为 1
counter_value
call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96 Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE
=> SELECT * FROM worldPCA;
HDI | country | col1
------+---------------------+-------------------
0.886 | Belgium | 79002.2946705704
0.699 | Belize | -25631.6670012556
0.427 | Benin | -40373.4104598122
0.805 | Chile | -16805.7940082156
0.687 | China | -37279.2893141103
0.744 | Costa Rica | -19505.5631231635
0.4 | Cote d'Ivoire | -38058.2060339272
0.776 | Cuba | -23724.5779612041
0.895 | Denmark | 117325.594028813
0.644 | Egypt | -34609.9941604549
...
(96 rows)
=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI | country | em1970 | em1971 | em1972 | em1973 |
em1974 | em1975 | em1976| em1977 | em1978 | em1979
| em1980 | em1981 | em1982 | em1983 | em1984 |em1985
| em1986 | em1987 | em1988 | em1989 | em1990 | em1991
| em1992 | em1993| em1994 | em1995 | em1996 | em1997
| em1998 | em1999 | em2000 | em2001 |em2002 |
em2003 | em2004 | em2005 | em2006 | em2007 | em2008
| em2009 | em2010 | gdp1970 | gdp1971 | gdp1972 | gdp1973
| gdp1974 | gdp1975 | gdp1976 | gdp1977 |gdp1978 | gdp1979
| gdp1980 | gdp1981 | gdp1982 | gdp1983 | gdp1984 | gdp1985
| gdp1986| gdp1987 | gdp1988 | gdp1989 | gdp1990 | gdp1991
| gdp1992 | gdp1993 | gdp1994 | gdp1995 | gdp1996 |
gdp1997 | gdp1998 | gdp1999 | gdp2000 | gdp2001 | gdp2002
| gdp2003 |gdp2004 | gdp2005 | gdp2006 | gdp2007 | gdp2008
| gdp2009 | gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium | 18585.6613572407 | -16145.6374560074 | 26938.956253415 | 8094.30475779595 |
12073.5461203817 | -11069.0567600181 | 19133.8584911727| 5500.312894949 | -4227.94863799987 | 6265.77925410752
| -10884.749295608 | 30929.4669575201 | -7831.49439429977 | 3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 | 1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 | 18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 | 1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
| 6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
| 5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 | 5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 | 8718.3731386891
...
(96 rows)
分三列返回分类数据输入的统计摘要：
CATEGORY：分类级别，与汇总列具有相同的 SQL 数据类型
COUNT：类别级别的数量，类型为 INTEGER
PERCENT：表示类别百分比，类型为 FLOAT
SUMMARIZE_CATCOL (target‑column
[ USING PARAMETERS TOPK = topk‑value [, WITH_TOTALCOUNT = show‑total] ] )
OVER()
BOOLEAN
FLOAT
INTEGER
DATE
CHAR/VARCHAR
TOPKWITH_TOTALCOUNT默认值： true
此示例显示了 salary_data 表中 current_salary 列的分类摘要。查询输出中显示列类别、计数和百分比。第一列列出分类级别，其与输入列具有相同的 SQL 数据类型，第二列列出该值的计数，第三列列出百分比。
=> SELECT SUMMARIZE_CATCOL (current_salary USING PARAMETERS TOPK = 5) OVER() FROM salary_data;
CATEGORY | COUNT | PERCENT
---------+-------+---------
| 1000 | 100
39004 | 2 | 0.2
35321 | 1 | 0.1
36313 | 1 | 0.1
36538 | 1 | 0.1
36562 | 1 | 0.1
(6 rows)
返回 Vertica 表中列的统计摘要：
Count
平均值
标准偏差
最小值/最大值
近似百分位
中间值
除了计数为 INTEGER 类型，所有汇总值均为 FLOAT 数据类型。
SUMMARIZE_NUMCOL (input‑columns [ USING PARAMETERS exclude_columns = 'excluded‑columns'] ) OVER()
SUMMARIZE_NUMCOL 将标准化模型中的所有列exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
显示 employee 表中 age 和 salary 列的统计摘要：
=> SELECT SUMMARIZE_NUMCOL(* USING PARAMETERS exclude_columns='id,name,gender,title') OVER() FROM employee;
COLUMN | COUNT | MEAN | STDDEV | MIN | PERC25 | MEDIAN | PERC75 | MAX
---------------+-------+------------+------------------+---------+---------+---------+-----------+--------
age | 5 | 63.4 | 19.3209730603818 | 44 | 45 | 67 | 71 | 90
salary | 5 | 3456.76 | 1756.78754300285 | 1234.56 | 2345.67 | 3456.78 | 4567.89 | 5678.9
(2 rows)
计算输入关系的 SVD 分解的奇异值（S 矩阵的对角线）和右奇异向量（V 矩阵）。结果将保存为 SVD 模型。可以在不同的运行中同时翻转 SVD 中奇异向量的所有元素符号。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVD ( 'model‑name', 'input‑relation', 'input‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, num_components = num‑components]
[, method = 'method'] ] )
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
num_componentsmethodLAPACK。columnsindex
name
singular_valuesindex
value
explain_variance：对应于该奇异值的数据方差的百分比
accumulated_explained_variance：删除当前奇异值之后的所有奇异值后，可以保留的数据方差的百分比
right_singular_vectorsindex：每个向量中元素的索引
vector1
vector2
...
counterscounter_name
Accepted_row_count：数据中有效行的数量
denied_row_count：数据中无效行（具有 NULL、INF 或 NaN）的数量
iteration_count：迭代次数，对于当前的 SVD 操作，始终为 1
counter_value
call_string非超级用户：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8 Rejected Rows: 0
(1 row)
=> CREATE TABLE transform_svd AS SELECT
APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
OVER () FROM small_svd;
CREATE TABLE
=> SELECT * FROM transform_svd;
id | col1 | col2 | col3 | col4
----+-------------------+---------------------+---------------------+--------------------
4 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
6 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
1 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
2 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
3 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
5 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
8 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
7 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
(8 rows)
=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id | x1 | x2 | x3 | x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)
Vertica 支持各种机器学习函数，这些函数使用一组数据训练模型，并返回可进行保存以用于稍后执行的模型。
这些函数要求非超级用户具有以下权限：
对创建模型的架构的 CREATE 权限
对输入关系的 SELECT 权限
通过具有一致时间步长的平稳时间序列创建自回归 (AR) 模型，此模型可用于通过 PREDICT_AUTOREGRESSOR 进行预测。
自动回归模型将根据先前的值来预测时间序列的未来值。更具体地说，用户指定的 lag 决定了该模型在计算过程中要考虑多少个先前的时间段，且预测值为每个 lag 的线性组合。
由于输入数据必须按时间戳排序，因此，此算法为单线程算法。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
AUTOREGRESSOR ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
[ USING PARAMETERS
[ p = lags ]
[, missing = "imputation‑method" ]
[, regularization = "regularization‑method" ]
[, lambda = regularization‑value ]
[, compute_mse = boolean ]
] )
model‑nameinput‑relation该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。
data‑columntimestamp‑columnpp 值会削弱相关性。
默认值： 3
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。
默认值： linear_interpolation
regularization无
L2：权重正则化项，即惩罚权重的平方值
默认值： 无
lambda默认值： 1.0
compute_mse默认值： False
请参阅自回归模型示例。
对输入关系运行二分 k-means 算法。结果将生成一个具有群集中心层次结构的已训练模型，其包含一系列 k 值，每个值都可用于预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BISECTING_KMEANS('model-name', 'input-relation', 'input-columns', 'num-clusters'
[ USING PARAMETERS
[exclude_columns = 'exclude-columns']
[, bisection_iterations = bisection-iterations]
[, split_method = 'split-method']
[, min_divisible_cluster_size = min-cluster-size]
[, kmeans_max_iterations = kmeans-max-iterations]
[, kmeans_epsilon = kmeans-epsilon]
[, kmeans_center_init_method = 'kmeans-init-method']
[, distance_method = 'distance-method']
[, output_view = 'output-view']
[, key_columns = 'key-columns'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
bisection_iterations如果设置为 >1，则允许算法运行并选择在每个二等分步骤中运行的最佳 k 均值。如果使用 kmeanspp，bisection_iterations 的值始终为 1，因为 kmeanspp 的运行成本更高（但也好过替代方案），因此它不需要多次运行。
默认值： 1
split_methodsize：选择最大群集进行二等分。
sum_squares：选择群集内平方和最大的群集进行二等分。
默认值： sum_squares
min_divisible_cluster_size默认值： 2
kmeans_max_iterations默认值： 10
kmeans_epsilon默认值： 1e-4
kmeans_center_init_methodkmeanspp （默认）：kmeans++ 算法
pseudo：使用 Spark 所用的“伪中心”方法，将给定中心二等分，但不迭代点
distance_method默认值： euclidean
output_viewkey_columnsexclude_columns 中。centershierarchyParentCluster：每个质心的父群集质心 — 即基于其通过二等分得到一个群集的群集质心。
LeftChildCluster：每个质心的左子群集质心 — 即将一个群集二等分后得到的第一个子群集的质心。
RightChildCluster：每个质心的右子群集质心 — 即将一个群集二等分得到的第二个子群集的质心。
BisectionLevel：指定通过其得到一个群集的二等分步骤。
WithinSS：当前群集的群集内平方和
TotalWithinSS：迄今为止获得的叶群集的群集内总平方和。
metrics总平方和
群集内总平方和
群集间总平方和
群集间平方和/总平方和
群集 x、center_id y[...] 的平方和
SELECT BISECTING_KMEANS('myModel', 'iris1', '*', '5'
USING PARAMETERS exclude_columns = 'Species,id', split_method ='sum_squares', output_view = 'myBKmeansView');
对输入关系执行 k-means 算法。结果是包含群集中心列表的模型。
您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的 k 均值模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练 k 均值模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
KMEANS ( 'model‑name', 'input‑relation', 'input‑columns', 'num‑clusters'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, max_iterations = max‑iterations]
[, epsilon = epsilon‑value]
[, { init_method = 'init‑method' } | { initial_centers_table = 'init‑table' } ]
[, output_view = 'output‑view']
[, key_columns = 'key‑columns'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。init_method 和 initial_centers_table 互斥。如果同时设置两者，此函数将返回错误。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_iterations默认值： 10
epsilon默认值： 1e-4
init_methodrandom
kmeanspp （默认）：kmeans++ 算法
如果 k 值过高，可能会占用大量内存。如果函数返回错误，提示可用内存不足，请减小 k 值或使用 random 方法。
initial_centers_tableoutput_viewkey_columnsoutput_view 的列。应选择这些列，以便其内容可以标识每个输入数据点。此参数仅在指定 output_view 时使用。input‑columns 中所列的仅用作 key_columns 而不用于训练的列应在 exclude_columns 中列出。centersmetrics以下示例创建 k-means 模型 myKmeansModel 并将其应用于输入表 iris1。APPLY_KMEANS 的调用混合了列名和常量。当传递一个常量代替列名称时，该常量将替换该列在所有行中的值：
=> SELECT KMEANS('myKmeansModel', 'iris1', '*', 5
USING PARAMETERS max_iterations=20, output_view='myKmeansView', key_columns='id', exclude_columns='Species, id');
KMEANS
----------------------------
Finished in 12 iterations
(1 row)
=> SELECT id, APPLY_KMEANS(Sepal_Length, 2.2, 1.3, Petal_Width
USING PARAMETERS model_name='myKmeansModel', match_by_pos='true') FROM iris2;
id | APPLY_KMEANS
-----+--------------
5 | 1
10 | 1
14 | 1
15 | 1
21 | 1
22 | 1
24 | 1
25 | 1
32 | 1
33 | 1
34 | 1
35 | 1
38 | 1
39 | 1
42 | 1
...
(60 rows)
对输入关系执行线性回归，并返回线性回归模型。
您可以采用 VERTICA_MODELS 或 PMML 格式导出生成的线性回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练线性回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
LINEAR_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, optimizer = 'optimizer‑method']
[, regularization = 'regularization‑method']
[, epsilon = epsilon‑value]
[, max_iterations = iterations]
[, lambda = lamda‑value]
[, alpha = alpha‑value]
[, fit_intercept = boolean‑value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsoptimizer默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。
regularizationNone （默认值）
L1
L2
ENet
epsilon在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。
默认值： 1e-6
max_iterations(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。
默认值： 100
lambdaregularization 参数的值。
默认值： 1
alpharegularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。
值范围： [0,1]
默认值： 0.5
fit_interceptfit_intercept 设置为 false 不适用于 BFGS 优化器。
默认值： True
=> SELECT LINEAR_REG('myLinearRegModel', 'faithful', 'eruptions', 'waiting'
USING PARAMETERS optimizer='BFGS', fit_intercept=true);
LINEAR_REG
----------------------------
Finished in 10 iterations
(1 row)
对输入关系执行逻辑回归。结果是一个逻辑回归模型。
您可以以 VERTICA_MODELS 或 PMML 格式导出生成的逻辑回归模型，以将其应用于 Vertica 外部的数据。您还可以在其他位置训练逻辑回归模型，然后以 PMML 格式将其导入 Vertica，以对 Vertica 中的数据进行预测。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
LOGISTIC_REG ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns']
[, optimizer = 'optimizer‑method']
[, regularization = 'regularization‑method']
[, epsilon = epsilon‑value]
[, max_iterations = iterations]
[, lambda = lamda‑value]
[, alpha = alpha‑value]
[, fit_intercept = boolean‑value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsoptimizer默认值： 如果 regularization-method 设置为 L1 或 ENet，则为 CGD，否则将为 Newton。
regularizationNone （默认值）
L1
L2
ENet
epsilon在范围 (0.0，1.0) 内浮动，停止定型时的错误值。如果实际值和预测值之差小于或等于 epsilon，或者迭代次数超过 max_iterations，则定型停止。
默认值： 1e-6
max_iterations(0，1000000) 范围内的整数，指最大定型迭代次数。如果迭代次数超过 max_iterations，或者实际值与预测值之差小于或等于 epsilon，则定型停止。
默认值： 100
lambdaregularization 参数的值。
默认值： 1
alpharegularization 参数的值，该参数用于定义要提供的 L1 与 L2 正则化量。值 1 相当于 L1，值 0 相当于 L2。
值范围： [0,1]
默认值： 0.5
fit_interceptfit_intercept 设置为 false 不适用于 BFGS 优化器。
默认值： True
超级用户，或对输入关系的 SELECT 权限
=> SELECT LOGISTIC_REG('myLogisticRegModel', 'mtcars', 'am',
'mpg, cyl, disp, hp, drat, wt, qsec, vs, gear, carb'
USING PARAMETERS exclude_columns='hp', optimizer='BFGS', fit_intercept=true);
LOGISTIC_REG
----------------------------
Finished in 20 iterations
(1 row)
通过具有一致时间步长的平稳时间序列创建移动平均 (MA) 模型，此模型随后可用于通过 PREDICT_MOVING_AVERAGE 进行预测。
移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的 lag 决定了它在计算过程中要考虑多少先前的预测和错误。
由于输入数据必须按时间戳排序，因此，此算法为单线程算法。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MOVING_AVERAGE ('model‑name', 'input‑relation', 'data‑column', 'timestamp‑column'
[ USING PARAMETERS
[ q = lags ]
[, missing = "imputation‑method" ]
[, regularization = "regularization‑method" ]
[, lambda = regularization‑value ]
[, compute_mse = boolean ]
] )
model‑nameinput‑relation该算法需要平稳的时间序列作为输入；使用平均值随着时间变化的时间序列可能会导致结果欠佳。
data‑columntimestamp‑columnq默认值： 1
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。这意味着如果数据集中第一个或最后一个值缺失，会将其直接删除。
默认值： linear_interpolation
regularization无
L2：权重正则化项，即惩罚权重的平方值
默认值： 无
lambda默认值： 1.0
compute_mse此参数仅接受“true”或“false”，不接受 BOOLEAN 的标准字面量等效项，如 1 或 0。
默认值： False
请参阅移动平均模型示例。
对输入关系执行朴素贝叶斯算法，并返回朴素贝叶斯模型。
根据数据类型处理列：
FLOAT：假定值遵循某种高斯分布。
INTEGER：假定值属于一个多项分布。
CHAR/VARCHAR：假定值遵循某种分类分布。这些列中存储的字符串值不得超过 128 个字符。
BOOLEAN：值被视为具有两个值的分类值。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NAIVE_BAYES ( 'model‑name', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS [exclude_columns = 'excluded‑columns'] [, alpha = alpha-value] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。响应列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。BOOLEAN 列值在训练前转换为 FLOAT 值：0 表示 false，1 表示 true。
exclude_columnsalpha默认值： 1.0
colsInfoindex：训练中提供的列的索引（从 0 开始）。索引 0 用于响应列。
name：列的名称。
type：用于响应的标签，其值为 Gaussian、Multinominal、Categorical 或 Bernoulli。
alphapriorlabel：类标签。
value：每个类的百分比。
nRowsTotalnRowsRejectedcallStrGaussianindex：预测变量列的索引。
mu：模型的平均值。
sigmaSq：模型的标准差平方。
Multinominalindex：预测变量列的索引。
prob：概率取决于由 class_name 指示的类。
Bernoulliindex：预测变量列的索引。
probTrue：此预测变量列中值为 TRUE 的概率。
Categoricalcategory：预测变量名称中的值。
<class_name>：具有该值的概率取决于由 class_name 指示的类。
超级用户或输入关系的 SELECT 权限。
=> SELECT NAIVE_BAYES('naive_house84_model', 'house84_train', 'party', '*'
USING PARAMETERS exclude_columns='party, id');
NAIVE_BAYES
--------------------------------------------------
Finished. Accepted Rows: 324 Rejected Rows: 0
(1 row)
训练随机森林模型，以对输入关系进行分类。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RF_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, ntree = num‑trees]
[, mtry = num‑features]
[, sampling_size = sampling‑size]
[, max_depth = depth]
[, max_breadth = breadth]
[, min_leaf_size = leaf-size]
[, min_info_gain = threshold]
[, nbins = num‑bins] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
ntree[1，1000] 范围内的整数，指森林中的树木数量。
默认值： 20
mtry默认值： 预测变量总数的平方根
sampling_size在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。
默认值： 0.632
max_depth[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。
默认值： 5
max_breadth[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。
默认值： 32
min_leaf_size[1, 1e6] 范围内的整数，拆分节点后每个分支必须具有的最小样本数。在其左分支或右分支中导致较少剩余样本的拆分将被丢弃，并且该节点被视为叶节点。
默认值： 1
min_info_gain在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。
默认值： 0.0
nbins[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。
默认值： 32
=> SELECT RF_CLASSIFIER ('myRFModel', 'iris', 'Species', 'Sepal_Length, Sepal_Width,
Petal_Length, Petal_Width' USING PARAMETERS ntree=100, sampling_size=0.3);
RF_CLASSIFIER
--------------------------------------------------
Finished training
(1 row)
训练随机森林模型，以对输入关系执行回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RF_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, ntree = num‑trees]
[, mtry = num‑features]
[, sampling_size = sampling‑size]
[, max_depth = depth]
[, max_breadth = breadth]
[, min_leaf_size = leaf-size]
[, min_info_gain = threshold]
[, nbins = num‑bins] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测变量列的类型必须为数字、CHAR/VARCHAR 或 BOOLEAN；否则模型无效。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsntree[1，1000] 范围内的整数，指森林中的树木数量。
默认值： 20
mtry默认值： 预测变量总数的三分之一
sampling_size在 (0.0，1.0] 范围内浮动，指为定型每棵树而随机挑选的输入数据部分。
默认值： 0.632
max_depth[1，100] 范围内的整数，指每个树的最大深度。例如，max_depth 为 0 时，表示树只有一个根节点；max_depth 为 2 时，表示树有四个叶节点。
默认值： 5
max_breadth[1，1e9] 范围内的整数，指树可以拥有的最大叶节点数。
默认值： 32
min_leaf_size此参数的默认值与 sklearn 等库中的类似参数不同，因此会产生一个预测值与原始响应值不同的模型。
默认值： 5
min_info_gain在 [0.0，1.0) 范围内浮动，指用于包括拆分的最小阈值。信息增益小于此阈值的拆分将被丢弃。
默认值： 0.0
nbins[2，1000] 范围内的整数，指用于离散连续特征的二进制文件数量。
默认值： 32
=> SELECT RF_REGRESSOR ('myRFRegressorModel', 'mtcars', 'carb', 'mpg, cyl, hp, drat, wt' USING PARAMETERS
ntree=100, sampling_size=0.3);
RF_REGRESSOR
--------------
Finished
(1 row)
针对输入关系训练 SVM 模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVM_CLASSIFIER ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, C = 'cost']
[, epsilon = 'epsilon‑value']
[, max_iterations = 'max‑iterations']
[, class_weights = 'weight']
[, intercept_mode = 'intercept‑mode']
[, intercept_scaling = 'scale'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columnsC默认值： 1.0
epsilon默认值： 1e-3
max_iterations默认值： 100
class_weightsNone （默认值）：不使用权重
value0、value1：两个逗号分隔的字符串，指定两个正 FLOAT 值，其中 value0 将权重分配给类 0，value1 将权重分配给类 1。
auto：根据样本数量对每个类别进行加权。
intercept_moderegularized （默认值）：适合截距并对其应用正则化。
unregularized：适合截距，但不包括在正则化中。
intercept_scaling以下示例在 mtcars 表上使用 SVM_CLASSIFIER：
=> SELECT SVM_CLASSIFIER(
'mySvmClassModel', 'mtcars', 'am', 'mpg,cyl,disp,hp,drat,wt,qsec,vs,gear,carb'
USING PARAMETERS exclude_columns = 'hp,drat');
SVM_CLASSIFIER
----------------------------------------------------------------
Finished in 15 iterations.
Accepted Rows: 32 Rejected Rows: 0
(1 row)
针对输入关系训练 SVM 模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SVM_REGRESSOR ( 'model‑name', input‑relation, 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, error_tolerance = error-tolerance]
[, C = cost]
[, epsilon = epsilon‑value]
[, max_iterations = max‑iterations]
[, intercept_mode = 'mode']
[, intercept_scaling = 'scale'] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
所有预测工具列的类型必须为 numeric 或 BOOLEAN；否则模型无效。
exclude_columns默认值： 0.1
C默认值： 1.0
epsilon默认值： 1e-3
max_iterations默认值： 100
intercept_moderegularized （默认值）：适合截距并对其应用正则化。
unregularized：适合截距，但不包括在正则化中。
intercept_scaling
=> SELECT SVM_REGRESSOR('mySvmRegModel', 'faithful', 'eruptions', 'waiting'
USING PARAMETERS error_tolerance=0.1, max_iterations=100);
SVM_REGRESSOR
----------------------------------------------------------------
Finished in 5 iterations.
Accepted Rows: 272 Rejected Rows: 0
(1 row)
训练 XGBoost 模型以对输入关系执行分类。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
XGB_CLASSIFIER ('model-name', 'input-relation', 'response-column', 'predictor-columns'
[ USING PARAMETERS
[ exclude_columns = 'excluded-columns' ]
[, max_ntree = max-trees ]
[, max_depth = max-depth ]
[, objective = 'optimization-strategy' ]
[, learning_rate = learning-rate ]
[, min_split_loss = minimum ]
[, weight_reg = regularization ]
[, nbins = num-bins ]
[, sampling_size = fraction-of-rows ]
[, col_sample_by_tree = sample-ratio-per-tree ]
[, col_sample_by_node = sample-ratio-per-node ]
] )
model-name模型的名称（不区分大小写）。
input-relationSYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。response-columnpredictor-columnsCHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_ntree默认值： 10
max_depth默认值： 6
objective默认值： 'crossentropy'
split_proposal_methodglobal：/*describe */
local: /describe/
默认值： global
learning_rate默认值： 0.3
min_split_loss如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。
默认值： 0.0（禁用）
weight_reg默认值： 1.0
nbins默认值： 32
sampling_size值 1 表示使用所有行。
默认值： 1.0
col_sample_by_tree值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
col_sample_by_node值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
请参阅XGBoost 用于分类。
训练 XGBoost 模型以对输入关系执行回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
XGB_REGRESSOR ('model-name', 'input-relation', 'response-column', 'predictor-columns'
[ USING PARAMETERS
[ exclude_columns = 'excluded-columns' ]
[, max_ntree = max-trees ]
[, max_depth = max-depth ]
[, objective = 'optimization-strategy' ]
[, learning_rate = learning-rate ]
[, min_split_loss = minimum ]
[, weight_reg = regularization ]
[, nbins = num-bins ]
[, sampling_size = fraction-of-rows ]
[, col_sample_by_tree = sample-ratio-per-tree ]
[, col_sample_by_node = sample-ratio-per-node ]
] )
model-name模型的名称（不区分大小写）。
input-relationSYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。response-columnpredictor-columnsCHAR、VARCHAR 和 BOOL 类型的列视为分类特征；所有其他类型的列则视为数字特征。
Vertica XGBoost 和随机森林算法为分类列 (BOOL/VARCHAR) 提供原生支持。仅需将分类列作为预测工具传递给模型，算法就会自动将这些列视为分类列，且不会尝试以与数值列相同的方式将它们拆分为多个二进制文件；Vertica 将这些列视为真正的分类值，而不是简单地将它们转换为底层的连续值。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
max_ntree默认值： 10
max_depth默认值： 6
objectivesquarederror' 是唯一的选项。
默认值： 'squarederror'
split_proposal_methodglobal：/*describe */
local: /describe/
默认值： global
learning_rate默认值： 0.3
min_split_loss如果设置为 0 或省略，则不设置最小值。在这种情况下，根据正或负目标函数值修剪树。
默认值： 0.0（禁用）
weight_reg默认值： 1.0
nbins默认值： 32
sampling_size值 1 表示使用所有行。
默认值： 1.0
col_sample_by_tree值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
col_sample_by_node值 1 表示使用所有列。
col_sample_by 如果指定多个参数，则参数彼此上下“堆叠”。即：假如有 24 列，对于 col_sample_by_tree=0.5 和 col_sample_by_node=0.5，col_sample_by_tree 将采样 12 列。这样将可用的未采样列池减少到 12。 col_sample_by_node 然后对剩余池的一半进行采样，因此每个节点采样 6 列。
此算法始终对至少一列进行采样。
默认值： 1
请参阅用于回归的 XGBoost。
机器学习 API 包括一组 UDx 函数，这些函数将每个输入行的列转换为一个或多个对应的输出列。这些转换遵循之前创建的模型中定义的规则。例如，
APPLY_SVD 使用 SVD 模型来转换输入数据。
除非另有说明，否则这些函数要求非超级用户具有以下权限：
模型上的 USAGE 权限
对输入关系的 SELECT 权限
通常，给定无效的输入行，这些函数的返回值为 NULL。
将已训练的二分 k-means 模型应用于输入关系，并将每个新数据点分配给已训练模型中最接近的匹配群集。
SELECT APPLY_BISECTING_KMEANS( 'input-columns'
USING PARAMETERS model_name = 'model-name'
[, num_clusters = 'num-clusters']
[, match_by_pos = match‑by‑position] ] )
model_name模型的名称（不区分大小写）。
num_clusters 默认值： 模型为 k 指定的值
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
非超级用户：模型所有者或模型的使用权限
将隔离森林 (iForest) 模型应用于输入关系。对于每个输入行，该函数返回包含两个字段的输出行：
anomaly_score：浮点值，表示模型中所有树的平均路径长度，按训练样本大小标准化。is_anomaly：布尔值，指示输入行是否异常。当 anomaly_score 等于或大于给定阈值时，此值为 true；否则，此值为 false。APPLY_IFOREST( input‑columns USING PARAMETERS param=value[,...] )
model_name 中的预测变量类型匹配。model_name模型的名称（不区分大小写）。
thresholdanomaly_score 等于或大于 threshold 的值，则该数据点被标记为异常值。
或者，您可以指定一个 contamination 值，该值设置一个阈值，其中标记为异常值的训练数据点的百分比约等于 contamination 的值。您不能在同一个函数调用中同时设置 contamination 和 threshold。
默认值： 0.7
match_by_posfalse：按名称匹配。
true：按输入列列表中列的位置匹配。
默认值：false
contaminationcontamination 值计算阈值。如果不设置此参数，该函数将使用指定或默认的 threshold 值标记异常值。
您不能在同一个函数调用中同时设置 contamination 和 threshold。
非超级用户：
模型上的 USAGE 权限
对输入关系的 SELECT 权限
以下示例演示了不同的 threshold 值如何影响对输入关系的异常值检测：
=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
threshold=0.75) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
first_name | last_name | predictions
------------+-----------+-------------------------------------------------------
Jacqueline | Richards | {"anomaly_score":0.777757463074347,"is_anomaly":true}
(1 row)
=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
threshold=0.55) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
first_name | last_name | predictions
------------+-----------+--------------------------------------------------------
Jacqueline | Richards | {"anomaly_score":0.777757463074347,"is_anomaly":true}
Debra | Hall | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
Gerald | Fuller | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)
您还可以使用不同的 contamination 值来更改异常值阈值：
=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
contamination = 0.1) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
first_name | last_name | predictions
------------+-----------+--------------------------------------------------------
Marie | Fields | {"anomaly_score":0.5307715717521868,"is_anomaly":true}
Jacqueline | Richards | {"anomaly_score":0.777757463074347,"is_anomaly":true}
Debra | Hall | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
Gerald | Fuller | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(4 rows)
=> SELECT * FROM (SELECT first_name, last_name, APPLY_IFOREST(team, hr, hits, avg, salary USING PARAMETERS model_name='baseball_anomalies',
contamination = 0.01) AS predictions FROM baseball) AS outliers WHERE predictions.is_anomaly IS true;
first_name | last_name | predictions
------------+-----------+--------------------------------------------------------
Jacqueline | Richards | {"anomaly_score":0.777757463074347,"is_anomaly":true}
Debra | Hall | {"anomaly_score":0.5714649698133808,"is_anomaly":true}
Gerald | Fuller | {"anomaly_score":0.5980549926114661,"is_anomaly":true}
(3 rows)
将 APPLY_PCA 生成的转换反转回原始坐标系。
APPLY_INVERSE_PCA ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, exclude_columns = 'excluded‑columns']
[, key_columns = 'key‑columns'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_columns以下示例显示了如何使用 APPLY_INVERSE_PCA 函数。它显示了第一条记录的输出。
=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96 Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE
=> SELECT * FROM worldPCA;
HDI | country | col1
------+---------------------+-------------------
0.886 | Belgium | 79002.2946705704
0.699 | Belize | -25631.6670012556
0.427 | Benin | -40373.4104598122
0.805 | Chile | -16805.7940082156
0.687 | China | -37279.2893141103
0.744 | Costa Rica | -19505.5631231635
0.4 | Cote d'Ivoire | -38058.2060339272
0.776 | Cuba | -23724.5779612041
0.895 | Denmark | 117325.594028813
0.644 | Egypt | -34609.9941604549
...
(96 rows)
=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI | country | em1970 | em1971 | em1972 | em1973 |
em1974 | em1975 | em1976| em1977 | em1978 | em1979
| em1980 | em1981 | em1982 | em1983 | em1984 |em1985
| em1986 | em1987 | em1988 | em1989 | em1990 | em1991
| em1992 | em1993| em1994 | em1995 | em1996 | em1997
| em1998 | em1999 | em2000 | em2001 |em2002 |
em2003 | em2004 | em2005 | em2006 | em2007 | em2008
| em2009 | em2010 | gdp1970 | gdp1971 | gdp1972 | gdp1973
| gdp1974 | gdp1975 | gdp1976 | gdp1977 |gdp1978 | gdp1979
| gdp1980 | gdp1981 | gdp1982 | gdp1983 | gdp1984 | gdp1985
| gdp1986| gdp1987 | gdp1988 | gdp1989 | gdp1990 | gdp1991
| gdp1992 | gdp1993 | gdp1994 | gdp1995 | gdp1996 |
gdp1997 | gdp1998 | gdp1999 | gdp2000 | gdp2001 | gdp2002
| gdp2003 |gdp2004 | gdp2005 | gdp2006 | gdp2007 | gdp2008
| gdp2009 | gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium | 18585.6613572407 | -16145.6374560074 | 26938.956253415 | 8094.30475779595 |
12073.5461203817 | -11069.0567600181 | 19133.8584911727| 5500.312894949 | -4227.94863799987 | 6265.77925410752
| -10884.749295608 | 30929.4669575201 | -7831.49439429977 | 3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 | 1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 | 18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 | 1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
| 6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
| 5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 | 5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 | 8718.3731386891
...
(96 rows)
将数据转换回原始域。这实质上是通过将三个矩阵相乘来计算原始数据的近似版本：矩阵 U（此函数的输入）、矩阵 S 和 V（存储在模型中）。
APPLY_INVERSE_SVD ( 'input‑columns'
USING PARAMETERS model_name = 'model‑name'
[, match_by_pos = match‑by‑position]
[, exclude_columns = 'excluded‑columns']
[, key_columns = 'key‑columns'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_columns=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8 Rejected Rows: 0
(1 row)
=> CREATE TABLE transform_svd AS SELECT
APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
OVER () FROM small_svd;
CREATE TABLE
=> SELECT * FROM transform_svd;
id | col1 | col2 | col3 | col4
----+-------------------+---------------------+---------------------+--------------------
4 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
6 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
1 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
2 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
3 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
5 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
8 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
7 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
(8 rows)
=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id | x1 | x2 | x3 | x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)
按照已知 k-means 模型将输入关系的每一行分配给一个群集中心。
APPLY_KMEANS ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
非超级用户：模型所有者或模型的使用权限
以下示例创建 k-means 模型 myKmeansModel 并将其应用于输入表 iris1。APPLY_KMEANS 的调用混合了列名和常量。当传递一个常量代替列名称时，该常量将替换该列在所有行中的值：
=> SELECT KMEANS('myKmeansModel', 'iris1', '*', 5
USING PARAMETERS max_iterations=20, output_view='myKmeansView', key_columns='id', exclude_columns='Species, id');
KMEANS
----------------------------
Finished in 12 iterations
(1 row)
=> SELECT id, APPLY_KMEANS(Sepal_Length, 2.2, 1.3, Petal_Width
USING PARAMETERS model_name='myKmeansModel', match_by_pos='true') FROM iris2;
id | APPLY_KMEANS
-----+--------------
5 | 1
10 | 1
14 | 1
15 | 1
21 | 1
22 | 1
24 | 1
25 | 1
32 | 1
33 | 1
34 | 1
35 | 1
38 | 1
39 | 1
42 | 1
...
(60 rows)
UDTF 函数，用于将保存在模型中的标准化参数应用于一组指定的输入列。如果函数中指定的任何列不在模型中，则其数据都会原封不动地传递到 APPLY_NORMALIZE。
APPLY_NORMALIZE 为该列中的值返回 NaN。
APPLY_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name');
APPLY_NORMALIZE 会规范化模型中的所有列。model_name模型的名称（不区分大小写）。
以下示例使用表 mtcars 中的 wt 和 hp 列创建具有 NORMALIZE_FIT 的模型，然后在对 APPLY_NORMALIZE 和 REVERSE_NORMALIZE 的连续调用中使用此模型。
=> SELECT NORMALIZE_FIT('mtcars_normfit', 'mtcars', 'wt,hp', 'minmax');
NORMALIZE_FIT
---------------
Success
(1 row)
以下对 APPLY_NORMALIZE 的调用指定表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型中，而 cyl 不在标准化模型中：
=> CREATE TABLE mtcars_normalized AS SELECT APPLY_NORMALIZE (hp, cyl USING PARAMETERS model_name = 'mtcars_normfit') FROM mtcars;
CREATE TABLE
=> SELECT * FROM mtcars_normalized;
hp | cyl
--------------------+-----
0.434628975265018 | 8
0.681978798586572 | 8
0.434628975265018 | 6
1 | 8
0.540636042402827 | 8
0 | 4
0.681978798586572 | 8
0.0459363957597173 | 4
0.434628975265018 | 8
0.204946996466431 | 6
0.250883392226148 | 6
0.049469964664311 | 4
0.204946996466431 | 6
0.201413427561837 | 4
0.204946996466431 | 6
0.250883392226148 | 6
0.049469964664311 | 4
0.215547703180212 | 4
0.0353356890459364 | 4
0.187279151943463 | 6
0.452296819787986 | 8
0.628975265017668 | 8
0.346289752650177 | 8
0.137809187279152 | 4
0.749116607773852 | 8
0.144876325088339 | 4
0.151943462897526 | 4
0.452296819787986 | 8
0.452296819787986 | 8
0.575971731448763 | 8
0.159010600706714 | 4
0.346289752650177 | 8
(32 rows)
=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
hp | cyl
-----+-----
175 | 8
245 | 8
175 | 6
335 | 8
205 | 8
52 | 4
245 | 8
65 | 4
175 | 8
110 | 6
123 | 6
66 | 4
110 | 6
109 | 4
110 | 6
123 | 6
66 | 4
113 | 4
62 | 4
105 | 6
180 | 8
230 | 8
150 | 8
91 | 4
264 | 8
93 | 4
95 | 4
180 | 8
180 | 8
215 | 8
97 | 4
150 | 8
(32 rows)
以下对 REVERSE_NORMALIZE 的调用还指定了表 mtcars 中的 hp 和 cyl 列，其中 hp 在标准化模型 mtcars_normfit 中，而 cyl 不在标准化模型中。
=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars_normalized;
hp | cyl
-----------------+-----
205.000005722046 | 8
150.000000357628 | 8
150.000000357628 | 8
93.0000016987324 | 4
174.99999666214 | 8
94.9999992102385 | 4
214.999997496605 | 8
97.0000009387732 | 4
245.000006556511 | 8
174.99999666214 | 6
335 | 8
245.000006556511 | 8
62.0000002086163 | 4
174.99999666214 | 8
230.000002026558 | 8
52 | 4
263.999997675419 | 8
109.999999523163 | 6
123.000002324581 | 6
64.9999996386468 | 4
66.0000005029142 | 4
112.999997898936 | 4
109.999999523163 | 6
180.000000983477 | 8
180.000000983477 | 8
108.999998658895 | 4
109.999999523163 | 6
104.999999418855 | 6
123.000002324581 | 6
180.000000983477 | 8
66.0000005029142 | 4
90.9999999701977 | 4
(32 rows)
用户定义的转换函数 (UDTF)，用于加载独热编码器模型并写出包含编码列的表。
APPLY_ONE_HOT_ENCODER( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, drop_first = 'is‑first']
[, ignore_null = 'ignore']
[, separator = 'separator‑character']
[, column_naming = 'name‑output']
[, null_column_name = 'null‑column‑name'] )
model_name模型的名称（不区分大小写）。
存储类别及其对应的级别。drop_firsttrue （默认值）：将分类变量的第一个级别视为引用级别。
false：分类变量的每个级别都在输出视图中具有对应的列
ignore_nulltrue （默认值）：Null 值将所有对应的 one-hot 二进制列设置为 null。
false：将 input-columns 中的 Null 值视为分类级别
separator默认值： 下划线 (_)
column_namingindices （默认值）：使用整数索引来表示分类级别。
values/values_relaxed：两种方法都使用分类级别名称。如果出现重复的列名称，该函数会尝试通过附加
_n 来消除其歧义，其中 n 是从零开始的整数索引（_0、_1、...）。
如果该函数无法生成唯一的列名称，它将根据所选的方法来处理：
values 返回错误。
values_relaxed 恢复使用索引。
如果 column_naming 设置为 values 或 values_relaxed，则以下列命名规则适用：
超过 128 个字符的输入列名称会被截断。
列名可以包含特殊字符。
如果参数 ignore_null 设置为 true，则 APPLY_ONE_HOT_ENCODER 根据参数 null_column_name 中设置的值构造列名。如果省略此参数，则使用字符串 null。
null_column_nameignore_null 设置为 false 且 column_naming 设置为 values 或 values_relaxed 时使用。
默认值： null
=> SELECT APPLY_ONE_HOT_ENCODER(cyl USING PARAMETERS model_name='one_hot_encoder_model',
drop_first='true', ignore_null='false') FROM mtcars;
cyl | cyl_1 | cyl_2
----+-------+-------
8 | 0 | 1
4 | 0 | 0
4 | 0 | 0
8 | 0 | 1
8 | 0 | 1
8 | 0 | 1
4 | 0 | 0
8 | 0 | 1
8 | 0 | 1
4 | 0 | 0
8 | 0 | 1
6 | 1 | 0
4 | 0 | 0
4 | 0 | 0
6 | 1 | 0
6 | 1 | 0
8 | 0 | 1
8 | 0 | 1
4 | 0 | 0
4 | 0 | 0
6 | 1 | 0
8 | 0 | 1
8 | 0 | 1
6 | 1 | 0
4 | 0 | 0
8 | 0 | 1
8 | 0 | 1
8 | 0 | 1
6 | 1 | 0
6 | 1 | 0
4 | 0 | 0
4 | 0 | 0
(32 rows)
使用 PCA 模型转换数据。该函数将返回每个数据点的新坐标。
APPLY_PCA ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, num_components = num‑components]
[, cutoff = cutoff‑value]
[, match_by_pos = match‑by‑position]
[, exclude_columns = 'excluded‑columns']
[, key_columns = 'key‑columns'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
num_componentscutoff 参数，则保留所有模型组件。cutoffmatch_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_columns
=> SELECT PCA ('pcamodel', 'world','country,HDI,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,
em1978,em1979,em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,
em1993,em1994,em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,
em2008,em2009,em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,
gdp1981,gdp1982,gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,
gdp1994,gdp1995,gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,
gdp2007,gdp2008,gdp2009,gdp2010' USING PARAMETERS exclude_columns='HDI,country');
PCA
---------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 96 Rejected Rows: 0
(1 row)
=> CREATE TABLE worldPCA AS SELECT
APPLY_PCA (HDI,country,em1970,em1971,em1972,em1973,em1974,em1975,em1976,em1977,em1978,em1979,
em1980,em1981,em1982,em1983,em1984 ,em1985,em1986,em1987,em1988,em1989,em1990,em1991,em1992,em1993,em1994,
em1995,em1996,em1997,em1998,em1999,em2000,em2001,em2002,em2003,em2004,em2005,em2006,em2007,em2008,em2009,
em2010,gdp1970,gdp1971,gdp1972,gdp1973,gdp1974,gdp1975,gdp1976,gdp1977,gdp1978,gdp1979,gdp1980,gdp1981,gdp1982,
gdp1983,gdp1984,gdp1985,gdp1986,gdp1987,gdp1988,gdp1989,gdp1990,gdp1991,gdp1992,gdp1993,gdp1994,gdp1995,
gdp1996,gdp1997,gdp1998,gdp1999,gdp2000,gdp2001,gdp2002,gdp2003,gdp2004,gdp2005,gdp2006,gdp2007,gdp2008,
gdp2009,gdp2010 USING PARAMETERS model_name='pcamodel', exclude_columns='HDI, country', key_columns='HDI,
country',cutoff=.3)OVER () FROM world;
CREATE TABLE
=> SELECT * FROM worldPCA;
HDI | country | col1
------+---------------------+-------------------
0.886 | Belgium | 79002.2946705704
0.699 | Belize | -25631.6670012556
0.427 | Benin | -40373.4104598122
0.805 | Chile | -16805.7940082156
0.687 | China | -37279.2893141103
0.744 | Costa Rica | -19505.5631231635
0.4 | Cote d'Ivoire | -38058.2060339272
0.776 | Cuba | -23724.5779612041
0.895 | Denmark | 117325.594028813
0.644 | Egypt | -34609.9941604549
...
(96 rows)
=> SELECT APPLY_INVERSE_PCA (HDI, country, col1
USING PARAMETERS model_name = 'pcamodel', exclude_columns='HDI,country',
key_columns = 'HDI, country') OVER () FROM worldPCA;
HDI | country | em1970 | em1971 | em1972 | em1973 |
em1974 | em1975 | em1976| em1977 | em1978 | em1979
| em1980 | em1981 | em1982 | em1983 | em1984 |em1985
| em1986 | em1987 | em1988 | em1989 | em1990 | em1991
| em1992 | em1993| em1994 | em1995 | em1996 | em1997
| em1998 | em1999 | em2000 | em2001 |em2002 |
em2003 | em2004 | em2005 | em2006 | em2007 | em2008
| em2009 | em2010 | gdp1970 | gdp1971 | gdp1972 | gdp1973
| gdp1974 | gdp1975 | gdp1976 | gdp1977 |gdp1978 | gdp1979
| gdp1980 | gdp1981 | gdp1982 | gdp1983 | gdp1984 | gdp1985
| gdp1986| gdp1987 | gdp1988 | gdp1989 | gdp1990 | gdp1991
| gdp1992 | gdp1993 | gdp1994 | gdp1995 | gdp1996 |
gdp1997 | gdp1998 | gdp1999 | gdp2000 | gdp2001 | gdp2002
| gdp2003 |gdp2004 | gdp2005 | gdp2006 | gdp2007 | gdp2008
| gdp2009 | gdp2010
-------+---------------------+-------------------+-------------------+------------------+------------------
+------------------+-------------------+------------------+------------------+-------------------+---------
----------+-------------------+------------------+-------------------+-------------------+-----------------
--+------------------+-------------------+-------------------+-------------------+------------------+-------
-----------+------------------+-------------------+-------------------+------------------+------------------
-+-------------------+------------------+-------------------+-------------------+-------------------+-------
------------+--------------------+------------------+-------------------+------------------+----------------
---+-------------------+-------------------+------------------+-------------------+------------------+------
------------+------------------+------------------+------------------+------------------+------------------+
------------------+------------------+------------------+------------------+------------------+-------------
-----+------------------+------------------+------------------+------------------+------------------+-------
-----------+------------------+------------------+------------------+------------------+------------------+-
-----------------+------------------+------------------+------------------+------------------+--------------
----+------------------+------------------+------------------+------------------+------------------+--------
----------+------------------+------------------+------------------+------------------+------------------
0.886 | Belgium | 18585.6613572407 | -16145.6374560074 | 26938.956253415 | 8094.30475779595 |
12073.5461203817 | -11069.0567600181 | 19133.8584911727| 5500.312894949 | -4227.94863799987 | 6265.77925410752
| -10884.749295608 | 30929.4669575201 | -7831.49439429977 | 3235.81760508742 | -22765.9285442662 | 27200
.6767714485 | -10554.9550160917 | 1169.4144482273 | -16783.7961289161 | 27932.2660829329 | 17227.9083196848
| 13956.0524012749 | -40175.6286481088 | -10889.4785920499 | 22703.6576872859 | -14635.5832197402 |
2857.12270512168 | 20473.5044214494 | -52199.4895696423 | -11038.7346460738 | 18466.7298633088 | -17410.4225137703 |
-3475.63826305462 | 29305.6753822341 | 1242.5724942049 | 17491.0096310849 | -12609.9984515902 | -17909.3603476248
| 6276.58431412381 | 21851.9475485178 | -2614.33738160397 | 3777.74134131349 | 4522.08854282736 | 4251.90446379366
| 4512.15101396876 | 4265.49424538129 | 5190.06845330997 | 4543.80444817989 | 5639.81122679089 | 4420.44705213467
| 5658.8820279283 | 5172.69025294376 | 5019.63640408663 | 5938.84979495903 | 4976.57073629812 | 4710.49525137591
| 6523.65700286465 | 5067.82520773578 | 6789.13070219317 | 5525.94643553563 | 6894.68336419297 | 5961.58442474331
| 5661.21093840818 | 7721.56088518218 | 5959.7301109143 | 6453.43604137202 | 6739.39384033096 | 7517.97645468455
| 6907.49136910647 | 7049.03921764209 | 7726.49091035527 | 8552.65909911844 | 7963.94487647115 | 7187.45827585515
| 7994.02955410523 | 9532.89844418041 | 7962.25713582666 | 7846.68238907624 | 10230.9878908643 | 8642.76044946519
| 8886.79860331866 | 8718.3731386891
...
(96 rows)
使用 SVD 模型转换数据。可计算 SVD 分解的矩阵 U。
APPLY_SVD ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, num_components = num-components]
[, cutoff = cutoff‑value]
[, match_by_pos = match‑by‑position]
[, exclude_columns = 'excluded‑columns']
[, key_columns = 'key‑columns'] )
所有列都必须为数字数据类型。
如果列名包含特殊字符，请用双引号将其括起来。
model_name模型的名称（不区分大小写）。
num_componentscutoff 参数，则保留模型中的所有组件。cutoffnum_components 参数，则保留所有模型组件。match_by_posfalse （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
exclude_columnsinput-columns 中要排除在处理范围之外的列名的逗号分隔列表。
key_columns=> SELECT SVD ('svdmodel', 'small_svd', 'x1,x2,x3,x4');
SVD
--------------------------------------------------------------
Finished in 1 iterations.
Accepted Rows: 8 Rejected Rows: 0
(1 row)
=> CREATE TABLE transform_svd AS SELECT
APPLY_SVD (id, x1, x2, x3, x4 USING PARAMETERS model_name='svdmodel', exclude_columns='id', key_columns='id')
OVER () FROM small_svd;
CREATE TABLE
=> SELECT * FROM transform_svd;
id | col1 | col2 | col3 | col4
----+-------------------+---------------------+---------------------+--------------------
4 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
6 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
1 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
2 | 0.17652411036246 | -0.0753183783382909 | -0.678196192333598 | 0.0567124770173372
3 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
5 | 0.494871802886819 | 0.161721379259287 | 0.0712816417153664 | -0.473145877877408
8 | 0.44849499240202 | -0.347260956311326 | 0.186958376368345 | 0.378561270493651
7 | 0.150974762654569 | 0.589561842046029 | 0.00392654610109522 | 0.360011163271921
(8 rows)
=> SELECT APPLY_INVERSE_SVD (* USING PARAMETERS model_name='svdmodel', exclude_columns='id',
key_columns='id') OVER () FROM transform_svd;
id | x1 | x2 | x3 | x4
----+------------------+------------------+------------------+------------------
4 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
6 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
7 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
1 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
2 | 20.6468626294368 | 9.30974906868751 | 8.71006863405534 | 6.5855928603967
3 | 31.2494347777156 | 20.6336519003026 | 27.5668287751507 | 5.84427645886865
5 | 107.93376580719 | 51.6980548011917 | 97.9665796560552 | 40.4918236881051
8 | 91.4056627665577 | 44.7629617207482 | 83.1704961993117 | 38.9274292265543
(8 rows)
对输入关系应用自回归 (AR) 模型。
自回归模型使用以前的值进行预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期时间步长数量，而预测值则是这些滞后的线性组合。
PREDICT_AUTOREGRESSOR ( 'timeseries‑column'
USING PARAMETERS
model‑name = 'model-name'
[, start = starting‑index]
[, npredictions = npredictions]
[, missing = "imputation‑method" ] )
OVER (ORDER BY 'timestamp‑column')
FROM input‑relation
如书面所示，以下实参为必需，既不能省略，也不能使用其他类型的子句代替。
OVER (ORDER BY '<span class="code-variable">timestamp‑column</span>')
p 值）。请注意，input‑relation 在 start 之前的任何 p（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。
model_name模型的名称（不区分大小写）。
start如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。
如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。
对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-p)，以其中较大者为准。
默认： input‑relation 的末尾
npredictions默认值： 10
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。
默认值： linear_interpolation
请参阅自回归模型示例。
对输入关系应用线性回归模型，并将预测值以 FLOAT 形式返回。
PREDICT_LINEAR_REG ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT PREDICT_LINEAR_REG(waiting USING PARAMETERS model_name='myLinearRegModel')FROM
faithful ORDER BY id;
PREDICT_LINEAR_REG
--------------------
4.15403481386324
2.18505296804024
3.76023844469864
2.8151271587036
4.62659045686076
2.26381224187316
4.86286827835952
4.62659045686076
1.94877514654148
4.62659045686076
2.18505296804024
...
(272 rows)
以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LINEAR_REG 函数。请注意，您可以将 column 实参替换为不同于输入列的常量：
=> SELECT PREDICT_LINEAR_REG(55 USING PARAMETERS model_name='linear_reg_faithful',
match_by_pos='true')FROM faithful ORDER BY id;
PREDICT_LINEAR_REG
--------------------
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
2.28552115094171
...
(272 rows)
对输入关系应用逻辑回归模型。
PREDICT_LOGISTIC_REG 以 FLOAT 形式返回预测类或预测类的概率，具体取决于 type 参数的设置方式。当返回值位于预测类的概率范围之内时，您可以将返回值转换为 INTEGER 或其他 numeric 类型。
PREDICT_LOGISTIC_REG ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, type = 'prediction‑type']
[, cutoff = probability‑cutoff]
[, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：预测值为 0 或 1。
probability：输出是预测类别为 1 的概率。
cutofftype 参数一起使用，FLOAT 介于 0 和 1 之间且专用。当 type 设置为 response 时，如果相应概率大于或等于 cutoff 的值，则预测返回值为 1；否则，返回值为 0。
默认值： 0.5
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT car_model,
PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel')
FROM mtcars;
car_model | PREDICT_LOGISTIC_REG
---------------------+----------------------
Camaro Z28 | 0
Fiat 128 | 1
Fiat X1-9 | 1
Ford Pantera L | 1
Merc 450SE | 0
Merc 450SL | 0
Toyota Corona | 0
AMC Javelin | 0
Cadillac Fleetwood | 0
Datsun 710 | 1
Dodge Challenger | 0
Hornet 4 Drive | 0
Lotus Europa | 1
Merc 230 | 0
Merc 280 | 0
Merc 280C | 0
Merc 450SLC | 0
Pontiac Firebird | 0
Porsche 914-2 | 1
Toyota Corolla | 1
Valiant | 0
Chrysler Imperial | 0
Duster 360 | 0
Ferrari Dino | 1
Honda Civic | 1
Hornet Sportabout | 0
Lincoln Continental | 0
Maserati Bora | 1
Mazda RX4 | 1
Mazda RX4 Wag | 1
Merc 240D | 0
Volvo 142E | 1
(32 rows)
以下示例显示了如何使用 match_by_pos 参数对输入表使用 PREDICT_LOGISTIC_REG。请注意，您可以将任何列输入替换为不同于输入列的常量。在此示例中，列 mpg 被替换为常量 20：
=> SELECT car_model,
PREDICT_LOGISTIC_REG(20, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel', match_by_pos='true')
FROM mtcars;
car_model | PREDICT_LOGISTIC_REG
--------------------+----------------------
AMC Javelin | 0
Cadillac Fleetwood | 0
Camaro Z28 | 0
Chrysler Imperial | 0
Datsun 710 | 1
Dodge Challenger | 0
Duster 360 | 0
Ferrari Dino | 1
Fiat 128 | 1
Fiat X1-9 | 1
Ford Pantera L | 1
Honda Civic | 1
Hornet 4 Drive | 0
Hornet Sportabout | 0
Lincoln Continental | 0
Lotus Europa | 1
Maserati Bora | 1
Mazda RX4 | 1
Mazda RX4 Wag | 1
Merc 230 | 0
Merc 240D | 0
Merc 280 | 0
Merc 280C | 0
Merc 450SE | 0
Merc 450SL | 0
Merc 450SLC | 0
Pontiac Firebird | 0
Porsche 914-2 | 1
Toyota Corolla | 1
Toyota Corona | 0
Valiant | 0
Volvo 142E | 1
(32 rows)
将由 MOVING_AVERAGE 创建的移动平均值 (MA) 模型应用于输入关系。
移动平均值模型使用早期预测误差进行未来预测。更具体地说，用户指定的“滞后”决定计算期间考虑的早期预测和错误数量。
PREDICT_MOVING_AVERAGE ( 'timeseries‑column'
USING PARAMETERS
model_name = 'model‑name'
[, start = starting‑index]
[, npredictions = npredictions]
[, missing = "imputation‑method" ] )
OVER (ORDER BY 'timestamp‑column')
FROM input‑relation
如书面所示，以下实参为必需，既不能省略，也不能使用其他类型的子句代替。
OVER (ORDER BY '<span class="code-variable">timestamp‑column</span>')
q 值）。请注意，input‑relation 在 start 之前的任何 q（训练期间设置）行中都不能包含缺失值。要处理缺失值，请参阅 IMPUTE 或 线性插值。
model_name模型的名称（不区分大小写）。
start如果 start 索引大于 timeseries-column 中的行数 N，则预测 N 到 start 之间的值并使用这些值进行预测。
如果为负，则从 input-relation 末尾倒数，对 start 索引进行标识。
对于 N 行的 input-relation，负值的下限为 -1000 或 -(N-q)，以其中较大者为准。
默认： input‑relation 的末尾
npredictions默认值： 10
missingdrop：忽略缺失值。
error：缺失值会引发错误。
zero：将缺失值替换为 0。
linear_interpolation：将缺失值替换为基于缺失值前后最近的有效条目的线性插值。如果预测范围内缺失值之前或之后的所有值缺失或无效，则无法指定插值且函数会出错。
默认值： linear_interpolation
请参阅移动平均模型示例。
对输入关系应用朴素贝叶斯模型。
PREDICT_NAIVE_BAYES 返回指定预测类或预测类概率的 VARCHAR，具体取决于 type 参数的设置方式。如果函数返回概率，您可以将返回值转换为 INTEGER 或其他 numeric 数据类型。
PREDICT_NAIVE_BAYES ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, type = ' return‑type ']
[, class = 'user‑input‑class']
[, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：返回概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回属于指定类实参的概率。
classtype 参数设置为 probability，则是必需的。如果省略此参数，“PREDICT_NAIVE_BAYES”返回经预测概率最高的类。match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT party, PREDICT_NAIVE_BAYES (vote1, vote2, vote3
USING PARAMETERS model_name='naive_house84_model',
type='response')
AS Predicted_Party
FROM house84_test;
party | Predicted_Party
------------+-----------------
democrat | democrat
democrat | democrat
democrat | democrat
republican | republican
democrat | democrat
democrat | democrat
democrat | democrat
democrat | democrat
democrat | democrat
republican | republican
democrat | democrat
democrat | democrat
democrat | democrat
democrat | republican
republican | republican
democrat | democrat
republican | republican
...
(99 rows)
对输入关系应用 Naive Bayes 模型并返回类的概率：
VARCHAR predicted 列包含概率最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中指定的类的概率。其他列包含属于 classes 参数中指定的每个类的概率。
PREDICT_NAIVE_BAYES_CLASSES ( predictor‑columns
USING PARAMETERS model_name = 'model‑name'
[, key_columns = 'key‑columns']
[, exclude_columns = 'excluded‑columns]
[, classes = 'classes']
[, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。
=> SELECT PREDICT_NAIVE_BAYES_CLASSES (id, vote1, vote2 USING PARAMETERS
model_name='naive_house84_model',key_columns='id',exclude_columns='id',
classes='democrat, republican', match_by_pos='false')
OVER() FROM house84_test;
id | Predicted | Probability | democrat | republican
-----+------------+-------------------+-------------------+-------------------
21 | democrat | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
28 | democrat | 0.775473383353576 | 0.775473383353576 | 0.224526616646424
83 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
102 | democrat | 0.779889432167111 | 0.779889432167111 | 0.220110567832889
107 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
125 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
132 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
136 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
155 | republican | 0.598662714551597 | 0.401337285448403 | 0.598662714551597
174 | republican | 0.592510497724379 | 0.407489502275621 | 0.592510497724379
...
(1 row)
对输入关系应用导入的 PMML 模型。函数返回采用 PMML 模型编码的模型类型预期的结果。
在以下情况下，PREDICT_PMML 返回 NULL：
预测指标为无效值或 NULL 值
分类预测指标属于未知类
PREDICT_PMML 针对使用 Output 标记的模型返回复杂类型 ROW 的值。Vertica 目前不支持直接将此数据插入表中。
您可以通过在将输出插入表之前使用 TO_JSON 将其更改为 JSON 来消除此限制：
=> CREATE TABLE predicted_output AS SELECT TO_JSON(PREDICT_PMML(X1,X2,X3
USING PARAMETERS model_name='pmml_imported_model'))
AS predicted_value
FROM input_table;
PREDICT_PMML ( input‑columns
USING PARAMETERS model_name = 'model-name' [, match_by_pos = match-by-position] )
model_nameK-means
线性回归
逻辑回归
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
在此示例中，函数调用使用表中的所有列作为预测指标，同时使用 PMML 格式的 "my_kmeans" 模型预测值：
SELECT PREDICT_PMML(* USING PARAMETERS model_name='my_kmeans') AS predicted_label FROM table;
在此示例中，函数调用仅将列 col1, col2 作为预测指标，使用架构 "my_schema" 中的模型 "my_kmeans" 预测每一行的值：
SELECT PREDICT_PMML(col1, col2 USING PARAMETERS model_name='my_schema.my_kmeans') AS predicted_label FROM table;
在此示例中，函数调用返回的错误既非 schema 也非 model-name，可以接受 * 作为值：
SELECT PREDICT_PMML(* USING PARAMETERS model_name='*.*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='*') AS predicted_label FROM table;
SELECT PREDICT_PMML(* USING PARAMETERS model_name='models.*') AS predicted_label FROM table;
对输入关系应用随机森林模型。PREDICT_RF_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：
预测类（基于公民投票）
每个输入实例的类概率。
PREDICT_RF_CLASSIFIER ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, type = 'prediction‑type']
[, class = 'user‑input‑class']
[, match_by_pos = match‑by‑position] )
input-columnsmodel_name模型的名称（不区分大小写）。
typeresponse （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，返回指定类的概率。
classtype 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 公民投票排名最高的类。因此，预测函数返回输入实例属于其预测类的概率。match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='myRFModel') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)
此示例显示了如何通过 match_by_pos 参数使用 PREDICT_RF_CLASSIFIER 函数：
=> SELECT PREDICT_RF_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='myRFModel', match_by_pos='true') FROM iris;
PREDICT_RF_CLASSIFIER
-----------------------
setosa
setosa
setosa
...
versicolor
versicolor
versicolor
...
virginica
virginica
virginica
...
(150 rows)
对输入关系应用随机森林模型并返回类的概率：
VARCHAR predicted 列包含投票（公民投票）排名最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。
与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。
PREDICT_RF_CLASSIFIER_CLASSES ( predictor‑columns
USING PARAMETERS model_name = 'model‑name'
[, key_columns = 'key‑columns']
[, exclude_columns = 'excluded‑columns']
[, classes = 'classes']
[, match_by_pos = match‑by‑position] )
OVER( [window-partition-clause] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。
=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='myRFModel') OVER () FROM iris;
predicted | probability
-----------+-------------------
setosa | 1
setosa | 0.99
setosa | 1
setosa | 1
setosa | 1
setosa | 0.97
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 0.99
...
(150 rows)
此示例显示了如何通过 match_by_pos 参数使用函数 PREDICT_RF_CLASSIFIER_CLASSES：
=> SELECT PREDICT_RF_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='myRFModel', match_by_pos='true') OVER () FROM iris;
predicted | probability
-----------+-------------------
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
setosa | 1
...
(150 rows)s
对输入关系应用随机森林模型，并返回 FLOAT 数据类型，该数据类型用于指定随机森林模型的预测值，即森林中树木的平均预测值。
PREDICT_RF_REGRESSOR ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT PREDICT_RF_REGRESSOR (mpg,cyl,hp,drat,wt
USING PARAMETERS model_name='myRFRegressorModel')FROM mtcars;
PREDICT_RF_REGRESSOR
----------------------
2.94774203574204
2.6954087024087
2.6954087024087
2.89906346431346
2.97688489288489
2.97688489288489
2.7086587024087
2.92078965478965
2.97688489288489
2.7086587024087
2.95621822621823
2.82255155955156
2.7086587024087
2.7086587024087
2.85650394050394
2.85650394050394
2.97688489288489
2.95621822621823
2.6954087024087
2.6954087024087
2.84493251193251
2.97688489288489
2.97688489288489
2.8856467976468
2.6954087024087
2.92078965478965
2.97688489288489
2.97688489288489
2.7934087024087
2.7934087024087
2.7086587024087
2.72469441669442
(32 rows)
使用 SVM 模型预测输入关系中样本的类标签，并将预测值以 FLOAT 数据类型返回。
PREDICT_SVM_CLASSIFIER (input‑columns
USING PARAMETERS model_name = 'model‑name'
[, match_by_pos = match‑by‑position]
[, type = 'return‑type']
[, cutoff = 'cutoff‑value'] ] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
typeresponse：输出 0 或 1 的预测类。
probability：输出位于 (0,1) 范围内的值，即使用逻辑函数转换的预测得分。
cutofftype 参数设置为 probability 的情况下才有效，这是一个 FLOAT 值，用于与转换的预测得分进行比较以确定预测类。
默认值： 0
=> SELECT PREDICT_SVM_CLASSIFIER (mpg,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
1
0
0
1
1
1
1
0
0
1
0
0
1
0
0
0
0
0
0
1
1
0
0
1
1
1
1
0
0
0
(32 rows)
此示例显示了如何通过 match_by_pos 参数对 mtcars 表使用 PREDICT_SVM_CLASSIFIER。在此示例中，列 mpg 被替换为常量 40：
=> SELECT PREDICT_SVM_CLASSIFIER (40,cyl,disp,wt,qsec,vs,gear,carb
USING PARAMETERS model_name='mySvmClassModel', match_by_pos ='true') FROM mtcars;
PREDICT_SVM_CLASSIFIER
------------------------
0
0
0
0
1
0
0
1
1
1
1
1
0
0
0
1
1
1
1
0
0
0
0
0
0
0
0
1
1
0
0
1
(32 rows)
使用 SVM 模型对输入关系中的样本执行回归，并将预测值以 FLOAT 数据类型返回。
PREDICT_SVM_REGRESSOR(input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
=> SELECT PREDICT_SVM_REGRESSOR(waiting USING PARAMETERS model_name='mySvmRegModel')
FROM faithful ORDER BY id;
PREDICT_SVM_REGRESSOR
--------------------
4.06488248694445
2.30392277646291
3.71269054484815
2.867429883817
4.48751281746003
2.37436116488217
4.69882798271781
4.48751281746003
2.09260761120512
...
(272 rows)
此示例显示了如何通过 match_by_pos 参数对有信心的表使用 PREDICT_SVM_REGRESSOR 函数。在此示例中，等待列被替换为常量 40：
=> SELECT PREDICT_SVM_REGRESSOR(40 USING PARAMETERS model_name='mySvmRegModel', match_by_pos='true')
FROM faithful ORDER BY id;
PREDICT_SVM_REGRESSOR
--------------------
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
1.31778533859324
...
(272 rows)
对输入关系应用 TensorFlow 模型，并返回编码模型类型的预期结果。
PREDICT_TENSORFLOW ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, num_passthru_cols = 'n-first-columns-to-ignore'] )
OVER( [window-partition-clause] )
model_name模型的名称（不区分大小写）。
num_passthru_cols使用 PREDICT_TENSORFLOW 和 num_passthru_cols 跳过前两个输入列：
SELECT PREDICT_TENSORFLOW ( pid,label,x1,x2
USING PARAMETERS model_name='spiral_demo', num_passthru_cols=2 )
OVER(PARTITION BEST) as predicted_class FROM points;
--example output, the skipped columns are displayed as the first columns of the output
pid | label | col0 | col1
-------+-------+----------------------+----------------------
0 | 0 | 0.990638732910156 | 0.00936129689216614
1 | 0 | 0.999036073684692 | 0.000963933940511197
2 | 1 | 0.0103802494704723 | 0.989619791507721
对输入关系应用 XGBoost 分类器模型。 PREDICT_XGB_CLASSIFIER 返回 VARCHAR 数据类型，指定以下几项之一，具体取决于 type 参数的设置方式：
预测类（基于概率得分）
每个输入实例的类概率。
PREDICT_XGB_CLASSIFIER ( input‑columns
USING PARAMETERS model_name = 'model‑name'
[, type = 'prediction-type' ]
[, class = 'user‑input‑class' ]
[, match_by_pos = 'match‑by‑position' ]
[, probability_normalization = 'prob-normalization' ] )
model_name模型的名称（不区分大小写）。
typeresponse （默认值）：所有可能的类中概率最高的类。
probability：仅当设置 class 参数的情况下才有效，针对每个输入实例返回指定类或预测类的概率。
classtype 参数设置为 probability 时使用的类。如果您省略此参数，函数将使用预测类 — 概率得分最高的类别。因此，预测函数返回输入实例属于指定类或预测类的概率。match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
probability_normalization分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。
使用
PREDICT_XGB_CLASSIFIER 将分类器应用于测试数据：
=> SELECT PREDICT_XGB_CLASSIFIER (Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='xgb_iris', probability_normalization='logit') FROM iris1;
PREDICT_XGB_CLASSIFIER
------------------------
setosa
setosa
setosa
.
.
.
versicolor
versicolor
versicolor
.
.
.
virginica
virginica
virginica
.
.
.
(90 rows)
有关更多示例，请参阅 XGBoost 用于分类。
对输入关系应用 XGBoost 分类器模型并返回类的概率：
VARCHAR predicted 列包含概率最高的类标签。
多个 FLOAT 列，其中第一个 probability 列包含预测列中报告的类的概率。其他列包含 classes 参数中指定的每个类的概率。
与参数 key_columns 中指定的匹配输入列具有相同值和数据类型的关键字列。
所有树都会影响每个响应类的预测概率，选择概率最高的类。
PREDICT_XGB_CLASSIFIER_CLASSES ( predictor‑columns)
USING PARAMETERS model_name = 'model‑name'
[, key_columns = 'key‑columns']
[, exclude_columns = 'excluded‑columns']
[, classes = 'classes']
[, match_by_pos = match‑by‑position]
[, probability_normalization = 'prob-normalization' ] )
OVER( [window-partition-clause] )
model_name模型的名称（不区分大小写）。
key_columns用于标识输出行的预测工具列名称的逗号分隔列表。要排除这些和其他预测工具列用于预测，请将其包含在参数 exclude_columns 的实参列表中。
exclude_columnsclassesmatch_by_posfalse （默认值）：按名称匹配。
true：按预测指标列列表中列的位置匹配。
probability_normalization分类器的标准化方法，它可以是 logit``softmax（多类分类器）或（二元分类器）。如果未指定，则使用默认的 logit 函数进行标准化。
使用
XGB_CLASSIFIER 创建 XGBoost 分类器模型后，您可以使用 PREDICT_XGB_CLASSIFIER_CLASSES 查看每个分类的概率。在此示例中，XGBoost 分类器模型 "xgb_iris" 用于预测给定花属于“鸢尾 (iris)”属的概率：
=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='xgb_iris') OVER (PARTITION BEST) FROM iris1;
predicted | probability
------------+-------------------
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.999911552783011
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
setosa | 0.9999650465368
versicolor | 0.99991871763563
.
.
.
(90 rows)
您还可以指定其他类。在此示例中，PREDICT_XGB_CLASSIFIER_CLASSES 与上一个示例进行相同的预测，但同样返回花属于指定的 classes“北美车前 (virginica)”和“花叶芦竹 (versicolor)”的概率：
=> SELECT PREDICT_XGB_CLASSIFIER_CLASSES(Sepal_Length, Sepal_Width, Petal_Length, Petal_Width
USING PARAMETERS model_name='xgb_iris', classes='virginica,versicolor', probability_normalization='logit') OVER (PARTITION BEST) FROM iris1;
predicted | probability | virginica | versicolor
------------+-------------------+----------------------+----------------------
setosa | 0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
setosa | 0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
setosa | 0.9999650465368 | 1.16160301545536e-05 | 2.33374330460065e-05
.
.
.
versicolor | 0.99991871763563 | 6.45697562080953e-05 | 0.99991871763563
versicolor | 0.999967282051702 | 1.60052775404199e-05 | 0.999967282051702
versicolor | 0.999648819964864 | 0.00028366342010669 | 0.999648819964864
.
.
.
virginica | 0.999977039257386 | 0.999977039257386 | 1.13305901169304e-05
virginica | 0.999977085131063 | 0.999977085131063 | 1.12847163501674e-05
virginica | 0.999977039257386 | 0.999977039257386 | 1.13305901169304e-05
(90 rows)
对输入关系应用 XGBoost 回归模型。 PREDICT_XGB_REGRESSOR 返回 FLOAT 数据类型，指定 XGBoost 模型的预测值：模型中每个树的贡献加权总和。
PREDICT_XGB_REGRESSOR ( input‑columns
USING PARAMETERS model_name = 'model‑name' [, match_by_pos = match‑by‑position] )
model_name模型的名称（不区分大小写）。
match_by_pos该布尔值指定输入列如何与模型特征匹配：
false （默认值）：按名称匹配。
true：按输入列列表中列的位置匹配。
请参阅用于回归的 XGBoost。
对标准化数据进行反向标准化转换，从而使标准化数据非标准化。如果您指定的列并非位于指定模型，则 REVERSE_NORMALIZE 会按原样返回该列。
REVERSE_NORMALIZE ( input‑columns USING PARAMETERS model_name = 'model‑name' );
model_name模型的名称（不区分大小写）。
对表 mtcars 中的 hp 和 cyl 列使用 REVERSE_NORMALIZE，其中 hp 位于标准化模型 mtcars_normfit，cyl 并非位于标准化模型。
=> SELECT REVERSE_NORMALIZE (hp, cyl USING PARAMETERS model_name='mtcars_normfit') FROM mtcars;
hp | cyl
------+-----
42502 | 8
58067 | 8
26371 | 4
42502 | 8
31182 | 6
32031 | 4
26937 | 4
34861 | 6
34861 | 6
50992 | 8
50992 | 8
49577 | 8
25805 | 4
18447 | 4
29767 | 6
65142 | 8
69387 | 8
14768 | 4
49577 | 8
60897 | 8
94857 | 8
31182 | 6
31182 | 6
30899 | 4
69387 | 8
49577 | 6
18730 | 4
18730 | 4
74764 | 8
17598 | 4
50992 | 8
27503 | 4
(32 rows)
一组 Vertica 机器学习函数评估训练模型生成的预测数据，或返回有关模型本身的信息。
使用响应变量的观察值和预测值计算表的混淆矩阵。 CONFUSION_MATRIX 生成具有以下尺寸的表格：
行：类的数量
列：类的数量 + 2
CONFUSION_MATRIX ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] OVER()
实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：
INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。
{0, 1, 3, 5, 6,} — Vertica 假设有七个类。
BOOLEAN：“是”或“否”
CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。
Vertica 将类数计算为两个输入列中值的并集。例如，假如 targets 和 predictions 中的值集输入列为如下所示，则 Vertica 将计为四个类：
{'milk', 'soy milk', 'cream'}
{'soy milk', 'almond milk'}
num_classes一个整数 > 1，指定要传递给该函数的类数。
如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：
INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。
BOOLEAN：默认设置为 2，不能设置为任何其他值。
此示例计算逻辑回归模型的混淆矩阵，该模型将 mtcars 数据集中的汽车分为自动档或手动档。观察值在输入列 obs 中，而预测值在输入列 pred 中。因为这是一个二元分类问题，所以所有值都是 0 或 1。
在返回的表中，列 am 中值为 0 的所有 19 辆汽车都被 PREDICT_LOGISTIC_REGRESSION 正确预测其值为 0。在 am 列中值为 1 的 13 辆汽车中，12 辆被正确预测其值为 1，而 1 辆汽车被错误地分类为值 0：
=> SELECT CONFUSION_MATRIX(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp,drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel')AS PRED
FROM mtcars) AS prediction_output;
actual_class | predicted_0 | predicted_1 | comment
-------------+-------------+-------------+------------------------------------------
0 | 19 | 0 |
1 | 0 | 13 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)
使用输入关系对学习算法执行 k-fold 交叉验证，并对超参数执行网格搜索。输出是所选算法的平均性能指标。该函数支持 SVM 分类、朴素贝叶斯和逻辑回归。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CROSS_VALIDATE ( 'algorithm', 'input‑relation', 'response‑column', 'predictor‑columns'
[ USING PARAMETERS
[exclude_columns = 'excluded‑columns']
[, cv_model_name = 'model']
[, cv_metrics = 'metrics']
[, cv_fold_count = num‑folds]
[, cv_hyperparams = 'hyperparams']
[, cv_prediction_cutoff = prediction‑cutoff] ] )
SYNC_WITH_HCATALOG_SCHEMA 以同步 hcatalog 架构，然后运行机器学习功能。输入关系中表示模型自变量的列的逗号分隔列表，或者使用星号 (*) 以选择所有列。如果选择所有列，则参数 exclude_columns 的实参列表必须包含 response‑column，以及任何无效的列作为预测工具列。
exclude_columnscv_model_nameGET_MODEL_ATTRIBUTE 和
GET_MODEL_SUMMARY 检索结果cv_metricsaccuracy （默认值）
error_rate
TP：真阳性，预测为 1 类的 1 类案例数
FP：假阳性，预测为 1 类的 0 类案例数
TN：真阴性，预测为 0 类的 0 类案例数
FN：假阴性，预测 0 类的 1 类案例数
TPR 或 recall：真阳性率，1 类中的正确预测
FPR：假阳性率，0 类中的错误预测
TNR：真阴性率，0 类中的正确预测
FNR：假阴性率，1 类中的错误预测
PPV 或 precision：阳性预测值，预测为 1 类案例中的正确预测
NPV：阴性预测值，预测为 0 类案例中的正确预测
MSE：均方误差
MAE：平均绝对误差
rsquared：决定系数
explained_variance
fscore
(1 + beta˄2) * precison * recall / (beta˄2 * precision + recall)
beta 默认等于 1
auc_roc：使用指定数量 bin 的 ROC 的 AUC，默认为 100
auc_prc：使用指定数量 bin 的 PRC 的 AUC，默认为 100
counts：解析为其他四个指标的快捷方式：TP、FP、TN 和 FN
count：仅在 JSON 语法中有效，计算由一个类 (case-class-label) 标记但预测为另一类 (predicted-class-label) 的案例数：
cv_metrics='[{"count":[case-class-label, predicted-class-label]}]'
cv_fold_count默认值： 5
cv_hyperparams{"param1":[value1,value2,...], "param2":{"first":first_value, "step":step_size, "count":number_of_values} }
应使用 JSON 标准引用超参数名称和字符串值。这些参数被传递给训练函数。
cv_prediction_cutoff默认值： 0.5
call_stringCROSS_VALIDATE 时指定的所有输入实参的值。run_averagecv_metrics 中指定的所有指标的所有折叠的平均值（如果指定）；否则为平均精度。fold_infofold_id：折叠的索引。
row_count：折叠中为测试而保留的行数。
countersaccepted_row_count：input_relation 中的总行数减去拒绝的行数。
rejected_row_count：因包含无效值而跳过的 input_relation 行数。
feature_count：输入到机器学习模型的特征数量。
run_detailsfold_id：保留用于测试的折叠的索引。
iteration_count：在非保留折叠的模型训练中使用的迭代数。
accuracy：参数 cv_metrics 中指定的所有指标，或精度（如果未提供 cv_metrics）。
error_rate：参数 cv_metrics 中指定的所有指标，或精度（如果忽略该参数）。
非超级用户：
对输入关系的 SELECT 权限
机器学习算法在其中生成模型的默认架构的 CREATE 和 USAGE 权限。如果提供了 cv_model_name，则交叉验证结果将作为模型保存在同一架构中。
参数 cv_metrics 可以将指标指定为 JSON 对象 的数组，其中每个对象指定一个指标名称。例如，以下表达式将 cv_metrics 设置为指定为 JSON 对象的两个指标，即 accuracy 和 error_rate：
cv_metrics='["accuracy", "error_rate"]'
在下一个示例中，cv_metrics 设置为两个指标，即 accuracy 和 TPR（真阳性率）。此处，TPR 指标被指定为一个 JSON 对象，它接受一个包含两个类标签实参（即 2 和 3）的数组：
cv_metrics='[ "accuracy", {"TPR":[2,3] } ]'
指定为 JSON 对象的指标可以接受参数。在以下示例中，fscore 指标指定参数 beta，该参数设置为 0.5：
cv_metrics='[ {"fscore":{"beta":0.5} } ]'
参数支持对于某些指标特别有用。例如，指标 auc_roc 和 auc_prc 构建一条曲线，然后计算该曲线下的面积。对于 ROC，曲线是通过绘制指标 TPR 与 FPR 而成的；对于 PRC，通过绘制指标 PPV (precision) 与 TPR (recall) 而成。通过将参数 num_bins 设置为大于默认值 100 的值，可以提高此类曲线的精度。例如，以下表达式计算使用 1000 个 bin 构建的 ROC 曲线的 AUC：
cv_metrics='[{"auc_roc":{"num_bins":1000}}]'
所有支持的指标均为二元分类器函数
LOGISTIC_REG 和
SVM_CLASSIFIER 而定义。对于
NAIVE_BAYES 等多类分类器函数，可以针对每个 one-versus-the-rest 二元分类器计算这些指标。使用实参请求每个分类器的指标。例如，如果训练数据具有整数类标签，您可以使用 precision (PPV) 指标设置 cv_metrics，如下所示：
cv_metrics='[{"precision":[0,4]}]'
此设置指定返回为两个分类器计算精度的两列：
第 1 列：对 0 与非 0 进行分类
第 2 列：对 4 与非 4 进行分类
如果忽略类标签实参，则使用索引为 1 的类。不是为单个 one-versus-the-rest 分类器计算指标，而是以下列方式之一计算平均值：macro、micro 或 weighted（默认）。例如，以下 cv_metrics 设置返回按类大小加权的平均值：
cv_metrics='[{"precision":{"avg":"weighted"}}]'
可以采用类似方式为多类分类器定义 AUC 类型的指标。例如，以下 cv_metrics 设置计算每个 one-versus-the-rest 分类器的 ROC 曲线下面积，然后返回按类大小加权的平均值。
cv_metrics='[{"auc_roc":{"avg":"weighted", "num_bins":1000}}]'
=> SELECT CROSS_VALIDATE('svm_classifier', 'mtcars', 'am', 'mpg'
USING PARAMETERS cv_fold_count= 6,
cv_hyperparams='{"C":[1,5]}',
cv_model_name='cv_svm',
cv_metrics='accuracy, error_rate');
CROSS_VALIDATE
----------------------------
Finished
===========
run_average
===========
C |accuracy |error_rate
---+--------------+----------
1 | 0.75556 | 0.24444
5 | 0.78333 | 0.21667
(1 row)
使用输入表返回一个计算错误分类率并将其显示为 FLOAT 值的表。 ERROR_RATE 返回具有以下维度的表：
行：类数加上包含跨类总错误率的一行
列：2
ERROR_RATE ( targets, predictions [ USING PARAMETERS num_classes = num‑classes ] ) OVER()
实参 targets 和 predictions 必须设置为数据类型相同的输入列，即以下之一：INTEGER、BOOLEAN 或 CHAR/VARCHAR。根据数据类型，这些列将按如所示标识类：
INTEGER：从零开始的连续整数（介于 0 和 (num-classes-1) 之间），其中 num-classes 为类数。例如，给定以下输入列值 — {0, 1, 2, 3, 4} — Vertica 假定有五个类。
{0, 1, 3, 5, 6,} — Vertica 假设有七个类。
BOOLEAN：“是”或“否”
CHAR/VARCHAR：类名。如果输入列的类型为 CHAR/VARCHAR 列，则还必须将参数 num_classes 设置为类数。
Vertica 将类数计算为两个输入列中值的并集。例如，假如 targets 和 predictions 中的值集输入列为如下所示，则 Vertica 将计为四个类：
{'milk', 'soy milk', 'cream'}
{'soy milk', 'almond milk'}
num_classes一个整数 > 1，指定要传递给该函数的类数。
如果指定的输入列为 CHAR/VARCHAR 类型，则必须设置此参数。否则，该函数将根据列数据类型处理此参数：
INTEGER：默认设置为 2，如果类数为任何其他值，则必须正确设置此参数。
BOOLEAN：默认设置为 2，不能设置为任何其他值。
非超级用户：模型所有者或模型的使用权限
此示例说明如何对名为 mtcars 的输入表执行 ERROR_RATE 函数。obs 列中显示响应变量，而 pred 列中显示预测值。由于该示例是一个分类问题，因此所有的响应变量值和预测变量值都是 0 或 1，表示二元分类。
在函数返回的表中，第一列显示类 ID 列。第二列显示该类 ID 的相应错误率。第三列表示该函数成功使用了多少行以及是否忽略了任何行。
=> SELECT ERROR_RATE(obs::int, pred::int USING PARAMETERS num_classes=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel', type='response') AS pred
FROM mtcars) AS prediction_output;
class | error_rate | comment
-------+--------------------+---------------------------------------------
0 | 0 |
1 | 0.0769230797886848 |
| 0.03125 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)
返回一个对比机器学习模型的可预测质量的表。此函数也被称为提升图。
LIFT_TABLE ( targets, probabilities
[ USING PARAMETERS [num_bins = num‑bins] [, main_class = class‑name ] ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对输入表 mtcars 执行 LIFT_TABLE。
=> SELECT LIFT_TABLE(obs::int, prob::float USING PARAMETERS num_bins=2) OVER()
FROM (SELECT am AS obs, PREDICT_LOGISTIC_REG(mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel',
type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | positive_prediction_ratio | lift | comment
-------------------+---------------------------+------------------+---------------------------------------------
1 | 0 | NaN |
0.5 | 0.40625 | 2.46153846153846 |
0 | 1 | 1 | Of 32 rows, 32 were used and 0 were ignored
(3 rows)
第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，对于每行，如果 prob 大于或等于 decision_boundary，将响应值分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。
第二列中，positive_prediction_ratio 表示分类 1 中使用相应 decision_boundary 值进行争取分类的样本比例。
第三列中，lift 函数用正确或错误分类为类 1 的行百分比来除 positive_prediction_ratio。
返回一个表，其中显示机器学习模型中预测和响应列的均方误差。
MSE ( targets, predictions ) OVER()
对输入表 faithful_testing 执行 MSE 函数。obs 列中显示响应变量，而 prediction 列中显示预测值。
=> SELECT MSE(obs, prediction) OVER()
FROM (SELECT eruptions AS obs,
PREDICT_LINEAR_REG (waiting USING PARAMETERS model_name='myLinearRegModel') AS prediction
FROM faithful_testing) AS prediction_output;
mse | Comments
-------------------+-----------------------------------------------
0.252925741352641 | Of 110 rows, 110 were used and 0 were ignored
(1 row)
返回一个表，其中显示了接收器 Precision Recall (PR) 曲线上的点。
PRC ( targets, probabilities
[ USING PARAMETERS
[num_bins = num‑bins]
[, f1_score = return‑score ]
[, main_class = class‑name ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
f1_score默认值：false
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对名为 mtcars 的输入表执行 PRC 函数。obs 列中显示响应变量，而 pred 列中显示预测变量。
=> SELECT PRC(obs::int, prob::float USING PARAMETERS num_bins=2, f1_score=true) OVER()
FROM (SELECT am AS obs,
PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS model_name='myLogisticRegModel',
type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | recall | precision | f1_score | comment
------------------+--------+-----------+-------------------+--------------------------------------------
0 | 1 | 0.40625 | 0.577777777777778 |
0.5 | 1 | 1 | 1 | Of 32 rows, 32 were used and 0 were ignored
(2 rows)
第一列 decision_boundary 指示将响应值分类为 0 还是 1 的分界点。例如，在每行中，如果概率等于或大于 decision_boundary，则将响应分类为 1。如果概率小于 decision_boundary，则将响应分类为 0。
读取随机森林或 XGBoost 模型中树的内容。
READ_TREE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] [, format = 'format'] )
model_nametree_idformattabular：返回包含 12 个输出列的表。
graphviz：返回可以传递给 graphviz 工具并呈现树的图形可视化的 DOT 语言源。
非超级用户：模型上的 USAGE 权限
从 READ_TREE 获取随机森林模型的表格格式输出：
=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'tabular') LIMIT 2;
-[ RECORD 1 ]-------------+-------------------
tree_id | 1
node_id | 1
node_depth | 0
is_leaf | f
is_categorical_split | f
split_predictor | petal_length
split_value | 1.921875
weighted_information_gain | 0.111242236024845
left_child_id | 2
right_child_id | 3
prediction |
probability/variance |
-[ RECORD 2 ]-------------+-------------------
tree_id | 1
node_id | 2
node_depth | 1
is_leaf | t
is_categorical_split |
split_predictor |
split_value |
weighted_information_gain |
left_child_id |
right_child_id |
prediction | setosa
probability/variance | 1
从 READ_TREE 获取 graphviz 格式的输出：
=> SELECT READ_TREE ( USING PARAMETERS model_name='myRFModel', tree_id=1 ,
format= 'graphviz')LIMIT 1;
-[ RECORD 1 ]+-------------------------------------------------------------------
---------------------------------------------------------------------------------
tree_id | 1
tree_digraph | digraph Tree{
1 [label="petal_length < 1.921875 ?", color="blue"];
1 -> 2 [label="yes", color="black"];
1 -> 3 [label="no", color="black"];
2 [label="prediction: setosa, probability: 1", color="red"];
3 [label="petal_length < 4.871875 ?", color="blue"];
3 -> 6 [label="yes", color="black"];
3 -> 7 [label="no", color="black"];
6 [label="prediction: versicolor, probability: 1", color="red"];
7 [label="prediction: virginica, probability: 1", color="red"];
}
此输入呈现如下：
使用平均减少杂质 (MDI) 方法衡量随机森林模型中预测工具的重要性。重要性向量被规范化为总和为 1。
RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'model‑name' [, tree_id = tree‑id] )
model_namerf_classifier 或 rf_regressor 类型。tree_id非超级用户：模型上的 USAGE 权限
此示例说明如何使用 RF_PREDICTOR_IMPORTANCE 函数。
=> SELECT RF_PREDICTOR_IMPORTANCE ( USING PARAMETERS model_name = 'myRFModel');
predictor_index | predictor_name | importance_value
-----------------+----------------+--------------------
0 | sepal.length | 0.106763318092655
1 | sepal.width | 0.0279536658041994
2 | petal.length | 0.499198722346586
3 | petal.width | 0.366084293756561
(4 rows)
返回表，其中显示了操作特征曲线的接收器上的点。在提高模型的鉴别阈值时，ROC 函数会告知分类模型的精度。
ROC ( targets, probabilities
[ USING PARAMETERS
[num_bins = num‑bins]
[, AUC = output]
[, main_class = class‑name ] ) ] )
OVER()
num_bins该整数值用于确定决策边界的数量。决策边界以 0 和 1（包含）之间的等距间隔设置。该函数在每个 num‑bin + 1 点处计算一次表。
默认值：100
更大的值会产生更精确的 AUC 近似值。
AUC默认值： True
main_class仅当 targets 是 CHAR/VARCHAR 类型时使用，请指定要与 probabilities 实参关联的类。
对输入表 mtcars 执行 ROC。观察到的类标签在 obs 列中，预测类标签在 prob 列中：
=> SELECT ROC(obs::int, prob::float USING PARAMETERS num_bins=5, AUC = True) OVER()
FROM (SELECT am AS obs,
PREDICT_LOGISTIC_REG (mpg, cyl, disp, drat, wt, qsec, vs, gear, carb
USING PARAMETERS
model_name='myLogisticRegModel', type='probability') AS prob
FROM mtcars) AS prediction_output;
decision_boundary | false_positive_rate | true_positive_rate | AUC |comment
-------------------+---------------------+--------------------+-----+-----------------------------------
0 | 1 | 1 | |
0.5 | 0 | 1 | |
1 | 0 | 0 | 1 | Of 32 rows,32 were used and 0 were ignoreded
(3 rows)
该函数会返回包含以下结果的表：
decision_boundary 指示是否将响应分类为 0 或 1 的分界点。在每行中，如果 prob 等于或大于 decision_boundary，则将响应分类为 1。如果 prob 小于 decision_boundary，将响应值分类为 0。
false_positive_rate 显示了相应 decision_boundary 中的误报（当 0 被分类为 1 时）百分比。
true_positive_rate 显示了分类为 1 并且还属于类 1 的行的百分比。
返回一个表，其中包含回归模型中预测的 R 平方值。
RSQUARED ( targets, predictions ) OVER()
OVER() 子句必须为空。
此示例演示了如何对名为 faithful_testing 的输入表执行 RSQUARED 函数。obs 列中显示响应变量的观测值，而 pred 列中显示响应变量的预测值。
=> SELECT RSQUARED(obs, prediction) OVER()
FROM (SELECT eruptions AS obs,
PREDICT_LINEAR_REG (waiting
USING PARAMETERS model_name='myLinearRegModel') AS prediction
FROM faithful_testing) AS prediction_output;
rsq | comment
-------------------+-----------------------------------------------
0.801392981147911 | Of 110 rows, 110 were used and 0 were ignored
(1 row)
Vertica 提供了管理模型的多种函数。
导出机器学习模型。Vertica 支持三种模型格式：
原生 Vertica (VERTICA_MODELS)
PMML
TensorFlow
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_MODELS ( 'output-dir', 'export-target' [ USING PARAMETERS category = 'model-category' ] )
output-direxport-target [schema.]{ model‑name | * }
其中 schema 指定从指定的架构导出模型（可选）。如果忽略，EXPORT_MODELS 使用默认架构。提供 *（星号）以从架构中导出所有模型。
categoryVERTICA_MODELS
PMML
TENSORFLOW
EXPORT_MODELS 根据导出操作的范围导出指定类别的模型，即应用于单个模型，还是应用于架构中的所有模型。请参阅下面的导出范围和类别处理。
下文导出的文件描述了 EXPORT_MODELS 为每个类别导出的文件。
如果忽略此参数，EXPORT_MODELS 将根据模型类型导出模型或指定架构中的模型。
超级用户
EXPORT_MODELS 根据以下参数设置执行：
导出操作的范围：单个模型，或给定架构中的所有模型
指定或忽略的类别
下表显示了这两个参数如何控制导出过程：
EXPORT_MODELS 为每个模型类别导出以下文件：
如果 EXPORT_MODELS 指定单个模型并且还设置了 category 参数，则如果模型类型和类别兼容，则函数成功；否则，它会返回错误：
如果 EXPORT_MODELS 指定从架构中导出所有模型并设置类别，它会针对与该类别不兼容的每个模型发出警告消息。该函数随后继续处理该架构中的剩余模型。
EXPORT_MODELS 在
output-dir/export_log.json 中记录所有错误和警告。
导出模型而不更改其类别：
导出模型 myschema.mykmeansmodel 而不更改其类别：
=> SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.mykmeansmodel');
EXPORT_MODELS
----------------
Success
(1 row)
导出架构 myschema 中的所有模型而不更改其类别：
=> SELECT EXPORT_MODELS ('/home/dbadmin', 'myschema.*');
EXPORT_MODELS
----------------
Success
(1 row)
导出与指定类别兼容的模型：
当您导入在不同版本的 Vertica 中训练的 VERTICA_MODELS 类别模型时，Vertica 会自动升级模型版本以匹配数据库的版本。如果失败，您必须运行 UPGRADE_MODEL。
如果两种方法都失败，则该模型不能用于数据库内评分，也不能导出为 PMML 模型。
类别设置为 PMML。PMML 和 VERTICA_MODELS 类型的模型与 PMML 类别兼容，因此如果 my_keans 属于任一类型，则导出操作成功：
=> SELECT EXPORT_MODELS ('/tmp/', 'my_kmeans' USING PARAMETERS category='PMML');
类别设置为 VERTICA_MODELS。只有 VERTICA_MODELS 类型的模型与 VERTICA_MODELS 类别兼容，因此只有当 my_keans 属于该类型时，导出操作才会成功：
=> SELECT EXPORT_MODELS ('/tmp/', 'public.my_kmeans' USING PARAMETERS category='VERTICA_MODELS');
类别设置为 TENSORFLOW。只有 TensorFlow 类型的模型与 TENSORFLOW 类别兼容，因此模型 tf_mnist_keras 必须为 TensorFlow 类型：
=> SELECT EXPORT_MODELS ('/tmp/', 'tf_mnist_keras', USING PARAMETERS category='TENSORFLOW');
export_models
---------------
Success
(1 row)
导出 TensorFlow 模型 tf_mnist_keras 后，列出导出的文件：
$ ls tf_mnist_keras/
crc.json metadata.json mnist_keras.pb model.json tf_model_desc.json
从模型中提取某个特定属性或从模型中提取所有属性。使用此函数可查看属性列表和行数，或查看有关单个属性的详细信息。GET_MODEL_ATTRIBUTE 的输出是一种表格格式，用户可以在其中选择特定的列或行。
GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name = 'model‑name' [, attr_name = 'attribute' ] )
model_name模型的名称（不区分大小写）。
attr_name非超级用户：模型所有者或模型的使用权限
此示例返回所有模型属性的摘要。
=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel');
attr_name | attr_fields | #_of_rows
-------------------+---------------------------------------------------+-----------
details | predictor, coefficient, std_err, t_value, p_value | 2
regularization | type, lambda | 1
iteration_count | iteration_count | 1
rejected_row_count | rejected_row_count | 1
accepted_row_count | accepted_row_count | 1
call_string | call_string | 1
(6 rows)
此示例从 myLinearRegModel 模型中提取 details 属性。
=> SELECT GET_MODEL_ATTRIBUTE ( USING PARAMETERS model_name='myLinearRegModel', attr_name='details');
coeffNames | coeff | stdErr | zValue | pValue
-----------+--------------------+---------------------+-------------------+-----------------------
Intercept | -1.87401598641074 | 0.160143331525544 | -11.7021169008952 | 7.3592939615234e-26
waiting | 0.0756279479518627 | 0.00221854185633525 | 34.0890336307608 | 8.13028381124448e-100
(2 rows)
返回模型的摘要信息。
GET_MODEL_SUMMARY ( USING PARAMETERS model_name = 'model‑name' )
模型的名称（不区分大小写）。
非超级用户：模型所有者或模型的使用权限
此示例说明如何查看线性回归模型的摘要。
=> SELECT GET_MODEL_SUMMARY( USING PARAMETERS model_name='myLinearRegModel');
--------------------------------------------------------------------------------
=======
details
=======
predictor|coefficient|std_err |t_value |p_value
---------+-----------+--------+--------+--------
Intercept| -2.06795 | 0.21063|-9.81782| 0.00000
waiting | 0.07876 | 0.00292|26.96925| 0.00000
==============
regularization
==============
type| lambda
----+--------
none| 1.00000
===========
call_string
===========
linear_reg('public.linear_reg_faithful', 'faithful_training', '"eruptions"', 'waiting'
USING PARAMETERS optimizer='bfgs', epsilon=1e-06, max_iterations=100,
regularization='none', lambda=1)
===============
Additional Info
===============
Name |Value
------------------+-----
iteration_count | 3
rejected_row_count| 0
accepted_row_count| 162
(1 row)
将以下模型导入 Vertica：通过 EXPORT_MODELS 导出的 Vertica 模型，或预测模型标记语言 (PMML) 或 TensorFlow 格式的模型。您可以使用此函数在 Vertica 群集之间移动模型，或导入在其他地方训练的 PMML 和 TensorFlow 模型。
GET_MODEL_SUMMARY 和 GET_MODEL_ATTRIBUTE 等其他 Vertica 模型管理操作支持导入的模型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPORT_MODELS ( 'source'
[ USING PARAMETERS [ new_schema = 'schema‑name' ] [, category = 'model-category' ] ] )
单个模型的目录：
path/model-directory
多个模型目录的父目录：
parent-dir-path/*
new_schemaIMPORT_MODELS 从其 metadata.json 文件中提取导入模型的名称（如果存在）。否则，该函数使用模型目录的名称。
categoryVERTICA_MODELS
PMML
TENSORFLOW
如果模型目录没有 metadata.json 文件，则需要此参数。如果以下情况之一为 true，则 IMPORT_MODELS 返回错误：
未指定类别且模型目录没有 metadata.json。
指定的类别与模型类型不匹配。
如果类别为 TENSORFLOW，则 IMPORT_MODELS 仅从模型目录中导入以下文件：
超级用户
以下要求和限制适用：
如果您导出模型，然后再次导入，则导出和导入模型目录名称必须匹配。如果发生命名冲突，请使用 new_schema 参数将模型导入不同的架构，然后重命名该模型。
机器学习配置参数 MaxModelSizeKB 设置可以导入 Vertica 的模型的最大大小。
目前不支持某些 PMML 功能和属性。有关详细信息，请参阅PMML 特征和属性。
如果您导入带有 metadata.json 和 crc.json 文件的 PMML 模型，则 CRC 文件必须包含元数据文件的 CRC 值。否则，导入操作会返回错误。
将模型导入指定的架构：
在这两个示例中，都没有指定模型类别，因此 IMPORT_MODEL 使用模型的 metadata.json 文件来确定其类别：
将单个模型 mykmeansmodel 导入到 newschema 架构中：
=> SELECT IMPORT_MODELS ('/home/dbadmin/myschema/mykmeansmodel' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)
将 myschema 目录中的所有模型导入到 newschema 架构中：
=> SELECT IMPORT_MODELS ('/home/dbadmin/myschema/*' USING PARAMETERS new_schema='newschema')
IMPORT_MODELS
----------------
Success
(1 row)
指定要导入的模型类别：
在前两个示例中，IMPORT_MODELS 只有在指定的模型和类别匹配时才返回成功；否则，它会返回错误：
导入 kmeans_pmml 作为 PMML 模型：
SELECT IMPORT_MODELS ('/root/user/kmeans_pmml' USING PARAMETERS category='PMML')
import_models
---------------
Success
(1 row)
导入 tf_mnist_estimator 作为 TensorFlow 模型：
=> SELECT IMPORT_MODELS ( '/path/tf_models/tf_mnist_estimator' USING PARAMETERS category='TENSORFLOW');
import_models
---------------
Success
(1 row)
从指定目录导入所有 TensorFlow 模型：
=> SELECT IMPORT_MODELS ( '/path/tf_models/*' USING PARAMETERS category='TENSORFLOW');
import_models
---------------
Success
(1 row)
升级之前的 Vertica 版本中的模型。如果您运行 IMPORT_MODELS 函数，Vertica 会在数据库升级期间自动运行此函数。备份或还原后手动调用该函数升级模型。
如果 UPGRADE_MODEL 未能升级模型并且模型属于 VERTICA_MODELS 类别，则它不能用于数据库内评分，也不能作为 PMML 模型导出。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
UPGRADE_MODEL ( [ USING PARAMETERS [model_name = 'model‑name'] ] )
model_name非超级用户：仅升级用户拥有的模型。
升级模型 myLogisticRegModel：
=> SELECT UPGRADE_MODEL( USING PARAMETERS model_name = 'myLogisticRegModel');
UPGRADE_MODEL
----------------------------
1 model(s) upgrade
(1 row)
升级用户拥有的所有模型：
=> SELECT UPGRADE_MODEL();
UPGRADE_MODEL
----------------------------
20 model(s) upgrade
(1 row)
Vertica 具有管理数据库操作各个方面的函数，例如会话、权限、投影和编录。
此部分包含特定于 Vertica 的编录管理函数。
从全局编录中删除许可证密钥。删除过期的密钥是可选的。如果安装了有效的备用许可证密钥，Vertica 会自动忽略过期的许可证密钥。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_LICENSE( 'license-name' )
LICENSES 的 NAME 列中的名称（或长许可证密钥）。超级用户
=> SELECT DROP_LICENSE('9b2d81e2-aab1-4cfb-bc07-fa9a696e8f5e');
返回 Vertica 编录的内部表示。此函数用于诊断目的。
DUMP_CATALOG 仅返回用户可见的对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DUMP_CATALOG()
无
以下查询获取 Vertica 编录的内部表示：
=> SELECT DUMP_CATALOG();
输出写入指定文件：
\o /tmp/catalog.txt
SELECT DUMP_CATALOG();
\o
生成 SQL 脚本，从而在其他群集上重新创建物理架构设计。
SQL 脚本符合以下要求：
仅包括用户有权访问的对象。
根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。
如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_CATALOG ( [ '[destination]' [, 'scope'] ] )
空字符串，将脚本写入标准输出。
SQL 输出文件的路径和名称，仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。
DESIGN：导出所有编录对象，包括架构、表、约束、视图、访问策略、投影、SQL 宏和存储过程。
DESIGN_ALL：已弃用。
TABLES：导出所有表及其访问策略。另请参阅 EXPORT_TABLES。
DIRECTED_QUERIES：导出所有存储在数据库中的定向查询。有关详细信息，请参阅管理定向查询。
默认值： DESIGN
无
请参阅导出编录。
生成一个 SQL 脚本，可用于在其他群集上重新创建非虚拟编录对象。
SQL 脚本符合以下要求：
仅包括用户有权访问的对象。
根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果表在非 PUBLIC 架构中，则所需的 CREATE SCHEMA 语句位于 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。
如果可能，使用其 KSAFE 子句（如果有）创建投影，否则使用其 OFFSET 子句。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_OBJECTS( ['[destination]' [, '[scope]'] [, 'mark-ksafe']] )
空字符串 ('') 将脚本写入标准输出。
SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。
{ [database.]schema[.object] | [[database.]schema]object }[,...]
如果设置为空字符串，Vertica 会导出用户有权访问的所有对象。
如果您仅指定一个架构，Vertica 会导出该架构中的所有对象。
如果指定一个数据库，它必须是当前数据库。
无
请参阅导出对象。
生成一个 SQL 脚本，可用于在其他群集上重新创建逻辑架构—架构、表、约束和视图。EXPORT_TABLES 仅导出用户有权访问的对象。
SQL 脚本符合以下要求：
仅包括用户有权访问的对象。
根据对象依赖关系对 CREATE 语句进行排序，以便可以按正确的顺序重新创建它们。例如，如果一个表引用了一个命名序列，则 CREATE SEQUENCE 语句在 CREATE TABLE 语句之前。同样，表的 CREATE ACCESS POLICY 语句跟在表的 CREATE TABLE 语句之后。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_TABLES( ['[destination]' [, '[scope]']] )
空字符串 ('') 将脚本写入标准输出。
SQL 输出文件的路径和名称。此选项仅对 超级用户有效。如果指定一个不存在的文件，函数会创建一个相应的文件。如果您仅指定一个文件名，Vertica 会在编录目录中创建它。如果文件已经存在，函数将静默覆盖其内容。
[database.]schema[.table][,...]
无
请参阅导出表。
在全局编录中安装许可证密钥。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
INSTALL_LICENSE( 'filename' )
超级用户
=> SELECT INSTALL_LICENSE('/tmp/vlicense.dat');
如果出现故障，在您的环境中启用或禁用高可用性。启用恢复以前， MARK_DESIGN_KSAFE 查询编录，确定群集物理模式设计是否满足下列要求：
在所有节点上复制小的、未分段的表。
大型表 超投影被分段，每个分段在不同的节点上。
对于 K-safety=1，每个大型表投影至少有一个 伙伴实例投影（或者对于 K-safety=2，具有两个伙伴实例投影）。
伙伴投影也在各数据库节点上进行分段，但对分配进行了修改，使包含相同数据的分段分配在不同节点上。请参阅使用投影的高可用性。
MARK_DESIGN_KSAFE 不改变物理架构。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MARK_DESIGN_KSAFE ( k )
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)
更新群集中每个 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)
此部分包含管理云集成的函数。对于 HDFS，另请参阅 Hadoop 函数。
清除 Azure 的缓存访问令牌。在更改 Azure 托管身份的配置后调用此函数。
Azure 对象存储可以支持和管理多个身份。如果正在使用多个身份，Vertica 会查找键为 VerticaManagedIdentityClientId 的 Azure 标记，其值必须是要使用的托管身份的 client_id 属性。如果 Azure 配置发生变化，请使用此函数清除缓存。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
AZURE_TOKEN_CACHE_CLEAR ( )
超级用户
此部分包含管理大型分布式数据库群集上的 spread 部署的函数以及控制群集如何组织数据以进行重新平衡的函数。
停止任何正在进行中或正在等待执行的重新平衡任务。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CANCEL_REBALANCE_CLUSTER()
超级用户
=> SELECT CANCEL_REBALANCE_CLUSTER();
CANCEL_REBALANCE_CLUSTER
--------------------------
CANCELED
(1 row)
禁用本地数据分段，本地数据分段会将节点上的投影分段拆分至可轻松移动到其他节点上的容器中。有关详细信息，请参阅局部数据分段。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DISABLE_LOCAL_SEGMENTS()
超级用户
=> SELECT DISABLE_LOCAL_SEGMENTS();
DISABLE_LOCAL_SEGMENTS
------------------------
DISABLED
(1 row)
启用本地存储分段，本地存储分段可以将节点上的投影分段拆分到可以轻松移动至其他节点的容器中。有关详细信息，请参阅局部数据分段。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ENABLE_LOCAL_SEGMENTS()
超级用户
=> SELECT ENABLE_LOCAL_SEGMENTS();
ENABLE_LOCAL_SEGMENTS
-----------------------
ENABLED
(1 row)
启用弹性群集调整，通过将一个节点的数据分段至可以轻松移动至其他主机的区块中，弹性群集调整可更为有效地扩大或缩小数据库群集的大小。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ENABLE_ELASTIC_CLUSTER()
超级用户
=> SELECT ENABLE_ELASTIC_CLUSTER();
ENABLE_ELASTIC_CLUSTER
------------------------
ENABLED
(1 row)
启用大型群集时，使得 Vertica 重新评估群集或子群集中的哪些节点为
控制节点，以及哪些节点被分配给它们作为从属节点。在更改企业模式数据库中的故障组或更改任一数据库模式中的控制节点数后调用此函数。调用此函数后，查询
V_CATALOG.CLUSTER_LAYOUT 系统表以查看建议的群集中节点的新布局。在新的控制节点分配生效之前，您还必须采取其他步骤。有关详细信息，请参阅更改控制节点的数量并重新对齐。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
在 ** Enterprise 模式 下：**
REALIGN_CONTROL_NODES()
在 ** Eon 模式 下：**
REALIGN_CONTROL_NODES('subcluster_name')
subcluster_name在 Enterprise 模式数据库中，从所有节点中选择控制节点，并将剩余节点分配给一个控制节点：
=> SELECT REALIGN_CONTROL_NODES();
在 Eon 模式数据库中，重新评估名为 analytics 的子群集中的控制节点分配：
=> SELECT REALIGN_CONTROL_NODES('analytics');
一个会话前台任务，将同步重新平衡数据库群集。REBALANCE_CLUSTER 仅在重新平衡操作完成后返回。如果当前会话结束，则操作立即中止。要将群集重新平衡为后台任务，请调用 START_REBALANCE_CLUSTER()。
在大型群集排列中，您通常在流中调用 REBALANCE_CLUSTER（请参阅更改控制节点的数量并重新对齐）。在更改控制节点（spread 主机）的数量和分布后，运行 REBALANCE_CLUSTER 以实现容错。
有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
REBALANCE_CLUSTER()
超级用户
=> SELECT REBALANCE_CLUSTER();
REBALANCE_CLUSTER
-------------------
REBALANCED
(1 row)
更新对编录的 Spread 配置文件的群集更改。这些更改包括：
新的或重新调整的控制节点
新的 Spread 主机或容错组
新的或删除的群集节点
此函数通常在多步进程中用于较大的弹性群集排列。调用此函数可能需要您重新启动数据库。然后，您必须重新平衡群集以实现容错。有关详细信息，请参阅定义和重新调整控制节点。
在 Eon 模式数据库中，使用此函数可能会导致数据库变为只读。调用此函数后，节点可能会断开连接。如果在没有这些节点的情况下，数据库不再有
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RELOAD_SPREAD( true )
使用更改来更新群集以控制消息传送：
=> SELECT reload_spread(true);
reload_spread
---------------
reloaded
(1 row)
REBALANCE_CLUSTER
设置启用大型群集时参与 spread 服务的 控制节点数。如果数据库在 Enterprise 模式下运行，该函数设置整个数据库群集的控制节点数。如果数据库在 Eon 模式下运行，则此函数设置您指定的子群集中的控制节点数。有关详细信息，请参阅大型群集。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
在 Enterprise 模式下：
SET_CONTROL_SET_SIZE( control_nodes )
在 Eon 模式下：
SET_CONTROL_SET_SIZE('subcluster_name', control_nodes )
subcluster_namecontrol_nodes正整数值：Vertica 将您指定的控制节点数分配给群集或子群集。该值可以大于当前节点数。该值不能大于 120（数据库的最大控制节点数）。在 Eon 模式下，该值加上为所有其他子群集设置的控制节点数的总和不能超过 120。
-1：使群集或子群集中的每个节点都成为控制节点。该值可有效禁用群集或子群集的大型群集。
在 Enterprise 模式数据库中，将整个群集的控制节点数设置为 5：
=> SELECT set_control_set_size(5);
SET_CONTROL_SET_SIZE
----------------------
Control size set
(1 row)
设置比例因子，比例因子决定在重新平衡数据库和启用了使用局部数据分段时，所使用的存储容器数量。有关详细信息，请参阅群集扩展。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_SCALING_FACTOR( factor )
超级用户
比例因子决定了在启用局部分段时，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)
一个后台任务，异步重新平衡数据库群集。此函数在重新平衡操作完成后立即返回。即使您关闭当前会话或数据库关闭，重新平衡也会持续到操作完成。在关闭的情况下，重新平衡会在群集重新启动后恢复。要停止重新平衡操作，请调用
CANCEL_REBALANCE_CLUSTER。
有关重新平衡任务的详细信息，请参阅在节点之间重新平衡数据。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
START_REBALANCE_CLUSTER()
超级用户
=> SELECT START_REBALANCE_CLUSTER();
START_REBALANCE_CLUSTER
-------------------------
REBALANCING
(1 row)
REBALANCE_CLUSTER
Vertica 数据收集器是一款实用程序，通过提供记录事件的框架来扩展系统表的功能。该实用程序收集并保留有关数据库群集的监控信息，同时在系统表中提供这些信息，需要的配置参数调整很少，对性能的影响微乎其微。
收集的数据存储在磁盘 Vertica/catalog 路径下的 DataCollector 目录中。可使用数据收集器所保留的信息查询系统表的过去状态并提取聚合信息，还可以执行以下操作：
查看用户已采取哪些操作
找出性能瓶颈
确定 Vertica 配置的潜在改进
数据收集器与名为工作负载分析器的顾问工具搭配使用，后者可以智能监控 SQL 查询和工作负载的性能，并通过观察实际工作负载的历史记录来建议优化操作。
默认情况下，数据收集器处于开启状态并保留所有会话的信息。如果出现性能问题，超级用户可以通过将设置配置参数 EnableDataCollector 设置为 0 来禁用数据收集器。
从数据收集器表和日志中清除所有内存及磁盘记录，并重置系统表 DATA_COLLECTOR 中的收集统计信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_DATA_COLLECTOR( [ '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)
返回有关数据收集器、
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>]);
等待内存日志移至磁盘后，刷新数据收集器，同时将日志与磁盘存储同步。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
FLUSH_DATA_COLLECTOR( [ '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)
检索与指定组件的保留政策有关的简短声明。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_DATA_COLLECTOR_POLICY( '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)
更新指定组件的以下保留策略属性：
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'] )
查询系统表 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 设置为过低的值，数据收集器可能无法以足够快的速度将缓冲数据刷新到磁盘以与活动级别保持一致，这可能会导致内存中的数据丢失。
非常大的数据收集器记录 — 例如，具有非常长的查询字符串的记录。数据收集器使用双缓冲，因此它无法在内存中保留比 memory‑buffer‑size 大 50% 以上的记录。
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 设置的那样。
超级用户
请参阅配置数据保留策略。
更新指定组件的保留策略属性 INTERVAL_TIME。调用此函数不会影响同一组件的其他属性。您可以使用此函数更新所有组件保留策略的 INTERVAL_TIME 属性。
要设置其他保留策略属性，请调用 SET_DATA_COLLECTOR_POLICY。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_DATA_COLLECTOR_TIME_POLICY( ['component',] 'interval‑time' )
查询系统表 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 一种数据类型，用于指定给定组件的数据在该组件的数据收集器表中保留的时间。保留策略属性 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 设置的那样。
超级用户
请参阅配置数据保留策略。
此部分包含特定于 Vertica 的数据库管理函数。
清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容。通常，只能在节点重新启动期间清除这些表。通过此函数，您可以在需要时随时清除这些表。例如，您可能想在解决导致磁盘资源拒绝的磁盘空间问题后清除系统表。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_RESOURCE_REJECTIONS();
超级用户
以下命令可以清除 RESOURCE_REJECTIONS 和 DISK_RESOURCE_REJECTIONS 系统表的内容：
=> SELECT clear_resource_rejections();
clear_resource_rejections
---------------------------
OK
(1 row)
将现有数据 (.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。如果指定一个数据库，它必须是当前数据库。
small：仅捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件
all：捆绑小于 min‑ros‑filesize‑kb 中所指定限值的文件，并捆绑大型存储容器的 .fdb 和 .pidx 文件。
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)
返回关于死锁的客户端及其等待的资源的信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DUMP_LOCKTABLE()
无
如果 Vertica 失去响应，请使用 DUMP_LOCKTABLE：
打开其他 vsql 连接。
执行查询：
=> SELECT DUMP_LOCKTABLE();
输出被写入到 vsql。请参阅监控日志文件。
您还可以使用以下命令查看连接方：
=> SELECT * FROM SESSIONS;
使用以下命令关闭所有会话：
=> SELECT CLOSE_ALL_SESSIONS();
使用以下命令关闭单个会话：
=> SELECT CLOSE_SESSION('session_id');
您可以从 V_MONITOR.SESSIONS 系统表中获取到 session_id 值。
转储系统中所有投影的分区键。
这是元函数。您必须在顶级 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
获取指定级别的配置参数的值。如果在该级别未设置任何值，此函数将返回一个空行。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_CONFIG_PARAMETER( 'parameter-name' [, 'level' | NULL] )
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)
测试 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)
调用 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)
在 Vertica 数据库上运行索引工具以执行以下任务之一：
对数据存储运行每块循环冗余检查 (CRC)，以验证数据完整性。
检查 ROS 容器中的排列顺序是否正确。
此函数会将有关其操作的摘要信息写入标准输出；将结果的详细信息记录在当前节点的 vertica.log 中。有关评估工具输出的详细信息，请参阅：
您还可以通过 Linux 命令行对已关闭的数据库运行索引工具。有关详细信息，请参阅CRC 和排序顺序检查。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RUN_INDEX_TOOL ( 'taskType', global, '[projFilter]' [, numThreads ] );
taskTypecheckcrc：对现有数据存储上的每个块运行循环冗余检查 (CRC)，以检查 ROS 数据块的数据完整性。
checksort：评估每个 ROS 行，以确定其排序是否正确。如果 ROS 数据未按投影的顺序正确排序，则依赖于已排序数据的查询结果就会不正确。
globalprojFilter空字符串 ('')：对所有投影运行检查。
一个字符串，指定一个或多个投影，如下所示：
projection‑name：对此投影运行检查
projection‑prefix*：对所有以字符串
projection‑prefix 开头的投影运行检查。
numThreadsn：线程数，≥1
-n：负整数，表示所有 CPU 内核的一部分，如下所示：
num‑cores / n
因此，-1 表示所有内核，-2 表示一半内核，-3 表示所有内核的三分之一，依此类推。
默认值： 1
超级用户
您可以通过设置以下两个参数来优化元函数性能：
projFilter：将操作范围缩小到一个或多个投影。
numThreads：指定用于执行函数的线程数。
从 ROS 存储容器中永久移除删除向量，以便可以重新使用磁盘空间。 PURGE 移除
Ancient History Mark 时期（含）之前的所有历史数据。
PURGE 不会删除临时表。
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)
返回各种安全相关参数的状态。使用此函数可验证您的 TLS 配置的完整性。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SECURITY_CONFIG_CHECK( 'db-component' )
db-componentNETWORK 是唯一受支持的组件。
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)
在指定级别设置或清除配置参数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_CONFIG_PARAMETER( 'param‑name', { param‑value | NULL}, ['level'| NULL])
要在指定级别清除 param‑name，请将其设置为 NULL。
user：当前用户。
session：当前会话，将覆盖数据库设置。
node-name：数据库节点的名称，将覆盖会话和数据库设置。
如果 level 被忽略或设置为 NULL，则会在数据库级别设置 param‑name。
在数据库级别将 AnalyzeRowCountInterval 参数设置为 3600：
=> SELECT SET_CONFIG_PARAMETER('AnalyzeRowCountInterval',3600);
SET_CONFIG_PARAMETER
----------------------------
Parameter set successfully
(1 row)
使用 ALTER DATABASE 可以获得相同的结果：
ALTER DATABASE DEFAULT SET PARAMETER AnalyzeRowCountInterval = 3600;
在会话级别将 MaxSessionUDParameterSize 参数设置为 2000。
=> SELECT SET_CONFIG_PARAMETER('MaxSessionUDParameterSize',2000,'SESSION');
SET_CONFIG_PARAMETER
----------------------------
Parameter set successfully
(1 row)
更改 spread 守护程序设置。此函数主要用于设置 spread 假设节点出现故障之前的超时。
SPREAD_STATE 中可见。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_SPREAD_OPTION( option‑name, option‑value )
目前，此函数仅支持一个选项： TokenTimeout. 此设置控制 spread 在假设消息丢失之前等待节点响应消息的时间。有关详细信息，请参阅调整虚拟环境的 Spread 守护程序超时。
=> 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);
关闭 Vertica 数据库。默认情况下，如果有任何用户连接，则关闭失败。您可以在
vertica.log 文件中查看关闭操作的状态。
在 Eon 模式下，您可以调用 SHUTDOWN_WITH_DRAIN 来执行优雅关闭，此操作会排空客户端连接，然后关闭数据库。
在调用 SHUTDOWN 之前，您可以关闭所有当前用户连接并阻止其他的连接尝试，如下所示：
暂时将配置参数 MaxClientSessions 设置为 0。
调用 CLOSE_ALL_SESSIONS 以关闭所有非 dbamin 连接。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SHUTDOWN ( [ 'false' | 'true' ] )
超级用户
以下命令尝试关闭数据库。由于用户已连接，命令失败：
=> SELECT SHUTDOWN('false');
NOTICE: Cannot shut down while users are connected
SHUTDOWN
-----------------------------
Shutdown: aborting shutdown
(1 row)
以下函数适用于 Eon 模式。
仅限 Eon 模式
调整子群集中一个节点或所有节点或者数据库中所有节点的 存储库大小。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ALTER_LOCATION_SIZE( 'location', '[target]', 'size')
locationdepot：调整节点当前存储库的大小。
存储库在 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 模式
强制正在预热其存储库的节点开始处理查询，同时继续在后台预热其存储库。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。此函数仅在以下情况下有效：
数据库在 Eon 模式下运行。
节点当前正在预热其存储库。
该节点正在从公共存储中预热其存储库。当 UseCommunalStorageForBatchDepotWarming 配置参数设置为默认值 1 时就是这种情况。有关此参数的详细信息，请参阅 Eon 模式参数。
调用此函数后，节点在参与查询时将在后台对其存储库进行预热。
此函数对未预热其存储库的节点没有影响。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
BACKGROUND_DEPOT_WARMING('node-name' [, 'subscription-name'])
node-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)
仅限 Eon 模式
取消节点上的存储库预热。仅当节点正在加入数据库并激活其订阅时，才会进行存储库预热。您可以选择取消节点上的所有预热，或者取消特定分片订阅的预热。节点将结束其当前执行的任何数据传输，以对其存储库进行预热，并从其队列中移除与预热相关的待执行传输。它将保留已加载到其存储库中的所有数据。当取消对特定订阅的预热时，如果所有其他订阅都已预热，则将停止预热存储库。如果其他订阅未预热，节点会继续预热其他订阅。
此函数仅在以下情况下有效：
数据库在 Eon 模式下运行。
节点当前正在预热其存储库。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CANCEL_DEPOT_WARMING('node-name' [, 'subscription-name'])
'node-name''subscription-name'返回一条消息，表明预热已被取消。
用户必须是 超级用户。
取消存储库预热会对查询的性能产生负面影响。具有冷存储库的节点可能需要从公共存储中检索其大部分数据，这比访问存储库要慢。
下面演示了如何取消节点 7 上的存储库预热：
=> SELECT CANCEL_DEPOT_WARMING('v_verticadb_node0007');
CANCEL_DEPOT_WARMING
--------------------------
Depot warming cancelled.
(1 row)
仅限 Eon 模式
取消一个或多个子群集的排空操作。此函数可以取消由 START_DRAIN_SUBCLUSTER 或 SHUTDOWN_WITH_DRAIN 函数的排空部分启动的排空操作。CANCEL_DRAIN_SUBCLUSTER 将指定子群集中的所有节点标记为未排空。先前排空的节点再次接受新的客户端连接以及从负载均衡重定向的连接。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CANCEL_DRAIN_SUBCLUSTER( '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)
仅限 Eon 模式
将公共存储中的无效数据标记为待删除，通常是由于 Vertica 清理机制失败而泄露的数据。需要调用此函数的事件包括：
节点故障
从 Enterprise 数据库到 Eon 数据库的迁移中断
从备份中恢复对象
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAN_COMMUNAL_STORAGE ( ['actually‑delete'] )
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)
仅限 Eon 模式
删除指定的存储库数据。您可以从一个子群集、单个节点或整个数据库群集中清除单个表或所有表的存储库数据。清除存储库数据不会影响公共存储。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_DATA_DEPOT( [ '[table‑name]' [, '[target-depots]'] ] )
table‑nametarget-depotssubcluster‑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)
仅限 Eon 模式
从指定的表或投影分区中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。.
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_DEPOT_PIN_POLICY_PARTITION( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, subcluster ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
object‑namemin‑range‑value max‑range‑valuesubcluster超级用户
仅限 Eon 模式
从指定的投影中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_DEPOT_PIN_POLICY_PROJECTION( '[[database.]schema.]projection' [, 'subcluster' ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
projectionsubcluster超级用户
仅限 Eon 模式
从指定的表中清除存储库固定策略。 对象取消固定后，可以被任何未固定或固定的对象从存储库中逐出。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_DEPOT_PIN_POLICY_TABLE( '[[database.]schema.]table' [, 'subcluster' ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表subcluster超级用户
仅限 Eon 模式
从公共存储中移除所有条目或数据获取请求队列中特定事务的条目。您可以通过查询 DEPOT_FETCH_QUEUE 系统表来查看提取队列。此函数会同步移除所有排队的请求。并会在所有提取都从队列中移除后返回。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_FETCH_QUEUE([transaction_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)
仅限 Eon 模式
如果以下任一情况为真，Vertica 将不允许对主子群集降级：
子群集包含一个 关键节点。
子群集是数据库中唯一的主子群集。您必须至少有一个主子群集。
启动程序节点是指您尝试降级的子群集的成员。您必须从另一个子群集调用 DEMOTE_SUBCLUSTER_TO_SECONDARY。
此函数调用可能需要很长时间才能完成，因为您要Set Snippet Variable Value in Topic的子群集中的所有节点都将采用全局编录锁定，编写检查点，然后提交。此全局编录锁可能会导致其他数据库任务失败并显示错误。
计划在其他数据库活动较少时调用此函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DEMOTE_SUBCLUSTER_TO_SECONDARY('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
仅限 Eon 模式
将排队等待从公共存储下载的所有文件提取到存储库。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
FINISH_FETCHING_FILES()
超级用户
获取所有排队下载的文件：
=> SELECT FINISH_FETCHING_FILES();
FINISH_FETCHING_FILES
---------------------------------
Finished fetching all the files
(1 row)
仅限 Eon 模式
删除数据库中所有标记为待删除的数据。使用此函数可在 reaper 服务删除磁盘文件之前移除所有标记为待删除的数据。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
FLUSH_REAPER_QUEUE( [sync‑catalog] )
true （默认值）：同步数据库编录
false：在未同步的情况下运行。
超级用户
移除所有标记为待删除的文件：
=> SELECT FLUSH_REAPER_QUEUE();
FLUSH_REAPER_QUEUE
-----------------------------------------------------
Sync'd catalog and deleted all files in the reaper queue.
(1 row)
仅限企业模式
将 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‑locationdepot‑location/vertica/depot
catalog‑locationVertica 编录位置的完整路径。默认设置为：
communal‑storage‑location/metadata/database‑name/nodes/node‑name/Catalog/
is‑dry‑runmigrate_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 模式
将辅助子群集转换为 主子群集。不能使用此函数来提升包含 启动程序节点的子群集。必须在连接到另一个子群集中的节点时调用此函数。
此函数调用可能需要很长时间才能完成，因为您要Set Snippet Variable Value in Topic的子群集中的所有节点都将采用全局编录锁定，编写检查点，然后提交。此全局编录锁可能会导致其他数据库任务失败并显示错误。
计划在其他数据库活动较少时调用此函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PROMOTE_SUBCLUSTER_TO_PRIMARY('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)
仅限 Eon 模式
在 Eon 模式下重新平衡子群集或整个群集中的分片分配。如果当前会话结束，则操作立即中止。根据数据库中对象的数量，重新平衡分片所需的时间以大致线性的方式增加。
在使用 ALTER NODE 修改群集或将节点添加到子群集后运行 REBALANCE_SHARDS。
在您执行以下操作后，Vertica 会自动重新平衡子群集中的分片：
从子群集中移除某个节点。
使用 admintools 命令 db_add_subcluster，结合 -s 选项（后跟主机列表）添加一个新的子群集。
重新平衡分片后，您将无法再从重新平衡之前的备份中还原对象。（始终可以执行完整备份。）重新平衡后，执行完整备份，以便将来能够从中还原对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
REBALANCE_SHARDS(['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)
仅限 Eon 模式
更改数据库中分片的数量。此函数在运行时需要使用全局编录锁 (GCLX)。运行时取决于编录的大小。
RESHARD_DATABASE 不会立即影响公共存储中的存储容器。重新分片后，新的分片仍然指向现有容器。如果增加数据库中分片的数量，多个分片将指向同一个存储容器。最终，Tuple Mover (TM) 合并任务会将存储容器与新的分片分段边界重新对齐。如果希望 TM 立即重新对齐存储容器，请调用 DO_TM_TASK 来运行“RESHARDMERGEOUT”任务。
此函数不会中断大多数查询。但是，全局编录锁可能会影响数据加载和 DDL 语句。
RESHARD_DATABASE(shard-count)
超级用户
请参阅更改数据库中的分片数。
仅限 Eon 模式
将表或投影的指定分区固定到子群集存储库或所有数据库存储库，以减少存储库逐出的风险。
仅当组内的所有分区都单独固定时，才能固定分区组。如果更改或移除表分区，Vertica 会删除该表的所有分区固定策略。表的固定策略（如有）不受影响。
有关固定策略和使用指南的详细信息，请参阅固定存储库对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_DEPOT_PIN_POLICY_PARTITION ( '[[database.]schema.]object‑name', 'min‑range‑value', 'max‑range‑value' [, 'subcluster' ] [, 'download' ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。默认值：false
超级用户
一般来说，涉及两个分区表的分区管理函数的优先级高于目标表的固定策略，如下所示：
例如，以下语句将分区从表 foo 复制到表 bar：
=> SELECT COPY_PARTITIONS_TO_TABLE('foo', '1', '5', 'bar');
在这种情况下，将应用以下逻辑：
如果两个表具有不同的分区固定策略，则应用目标表 bar 的分区键 1-5 的固定策略。
如果表 bar 不存在，Vertica 将基于表 foo 进行创建，并复制 foo 的分区键 1- 5 的策略。随后，如果从任一表中清除分区固定策略，该固定策略也会从另一个表中清除。
仅限 Eon 模式
将投影固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_DEPOT_PIN_POLICY_PROJECTION ( '[[database.]schema.]projection' [, 'subcluster' ] [, download ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。默认值：false
超级用户
仅限 Eon 模式
将表固定到子群集存储库或所有数据库存储库，以减少其面临的存储库逐出风险。有关固定策略和使用指南的详细信息，请参阅固定存储库对象。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_DEPOT_PIN_POLICY_TABLE ( '[[database.]schema.]table' [, 'subcluster' ] [, download ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
default_subcluster。如果省略此参数，系统将在所有数据库存储库上设置该策略。默认值：false
超级用户
仅限 Eon 模式
关闭子群集。此函数将同步关闭子群集，并在关闭完成后返回子群集已关闭消息。如果子群集已关闭，此函数将不返回错误。
如果有活动用户会话连接到子群集，则停止子群集不会发出警告。此行为与停止单个节点相同。在停止子群集之前，确认没有用户连接到它。
如果想在关闭子群集之前排空客户端连接，则可以使用 SHUTDOWN_WITH_DRAIN 优雅地关闭子群集。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SHUTDOWN_SUBCLUSTER('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)
仅限 Eon 模式
优雅地关闭一个或多个子群集。此函数会排空子群集节点上的客户端连接，然后关闭子群集。这是关闭消息发送到子群集后返回的同步函数。
现有用户会话中的工作继续在正在清空的节点上进行，但节点拒绝新的客户端连接，并被排除在负载均衡操作之外。dbadmin 仍然可以连接到正在清空的节点。
现有连接完成其工作并关闭，或达到用户指定的超时后，将开始排空节点。一旦满足这些条件之一，此函数会立即继续关闭子群集。
有关正常关闭过程的详细信息，请参阅正常关闭。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SHUTDOWN_WITH_DRAIN( 'subcluster-name', 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)
仅限 Eon 模式
排空一个或多个子群集。此函数将指定子群集中的所有节点标记为排空。现有用户会话继续在排空节点上运行，但这些节点拒绝新的客户端连接，且被排除在负载均衡操作之外。但 dbadmin 仍然可以连接到排空节点。
在优雅关闭的过程中，要排空子群集上的连接，可调用 SHUTDOWN_WITH_DRAIN。有关详细信息，请参阅优雅关闭。
要取消对子群集的排空操作，请调用 CANCEL_DRAIN_SUBCLUSTER。如果停止子群集中的所有节点排空操作，则会在重新启动时将这些节点标记为未排空。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
START_DRAIN_SUBCLUSTER( '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
仅限 Eon 模式
一个异步函数，在后台启动磁盘文件删除。默认情况下，此元函数会在开始删除之前同步编录。磁盘文件删除由 FLUSH_REAPER_QUEUE 在前台处理。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
START_REAPING_FILES( [sync‑catalog] )
true （默认值）：同步数据库编录
false：在未同步的情况下运行。
超级用户
启动 reaper 服务：
=> SELECT START_REAPING_FILES();
启动 reaper 服务并跳过初始编录同步：
=> SELECT START_REAPING_FILES(false);
仅限 Eon 模式
将编录同步到公共存储，以便在编录快要崩溃时恢复当前编录版本。Vertica 将所有待处理的检查点和事务日志同步到公共存储。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SYNC_CATALOG( [ 'node‑name' ] )
超级用户
同步所有节点上的编录：
=> SELECT SYNC_CATALOG();
同步一个节点上的编录：
=> SELECT SYNC_CATALOG( 'node001' );
此部分包含 Vertica 专用的时期管理函数。
手动关闭当前时期并开始新的时期。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ADVANCE_EPOCH ( [ integer ] )
integer超级用户
维护此函数主要是为了实现与 Vertica 较早版本的向后兼容性。
以下命令将以 1 为增量递增时期编号：
=> SELECT ADVANCE_EPOCH(1);
返回 Ancient History Mark 所在 时期的编号。可以从物理存储中清除截至 AHM 时期（包括该时期）删除的数据。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_AHM_EPOCH()
无
=> SELECT GET_AHM_EPOCH();
GET_AHM_EPOCH
----------------------
Current AHM epoch: 0
(1 row)
返回代表 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)
当前正在将数据（COPY、INSERT、UPDATE 和 DELETE 操作）写入到的时期。
返回当前时期的编号。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_CURRENT_EPOCH()
无
=> SELECT GET_CURRENT_EPOCH();
GET_CURRENT_EPOCH
-------------------
683
(1 row)
返回 上一个完好的时期的编号。如果数据库没有投影，此函数将返回错误。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_LAST_GOOD_EPOCH()
无
=> SELECT GET_LAST_GOOD_EPOCH();
GET_LAST_GOOD_EPOCH
---------------------
682
(1 row)
将 Ancient History Mark (AHM) 设置为允许的最大值。这使您可以清除所有已删除的数据。
MAKE_AHM_NOW 执行以下操作：
推进时间。
将 AHM 设置为
上一个完好的时期 (LGE)，至少设置为执行 MAKE_AHM_NOW 时的当前时期。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MAKE_AHM_NOW ( [ true ] )
一个或多个节点发生故障。
一个投影正在通过另一个投影进行刷新（保留刷新）。
在这两种情况下，必须将此实参提供给 MAKE_AHM_NOW，否则 Vertica 会返回错误。如果在保留刷新期间执行 MAKE_AHM_NOW(true)，Vertica 将回滚刷新操作并推进 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)
将 Ancient History Mark (AHM) 设置为指定的时期。此函数允许从物理存储中清除已删除数据，包括 AHM 时期。
SET_AHM_EPOCH 通常用于测试。相反，请考虑使用
SET_AHM_TIME，此函数更易于使用。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_AHM_EPOCH ( epoch, [ true ] )
设置 AHM 所在的时期数
零 (0)（默认值）表示禁用 PURGE
超级用户
如果群集中的任何节点发生故障，则必须使用 true 实参调用 SET_AHM_EPOCH；否则，函数将返回错误。
以下命令可将 AHM 设置为数量为 12 的指定时期：
=> SELECT SET_AHM_EPOCH(12);
以下命令可将 AHM 设置为数量为 2 的指定时期，并且允许在节点发生故障时推进：
=> SELECT SET_AHM_EPOCH(2, true);
将
Ancient History Mark (AHM) 设置为与启动程序节点上指定时间相对应的时期。此函数允许从物理存储中清除历史数据，包括 AHM 时期。 SET_AHM_TIME 返回一个表示 AHM 时期终点的 TIMESTAMPTZ。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_AHM_TIME ( time, [ true ] )
超级用户
如果群集中的任何节点发生故障，则必须使用 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 超过上一个完好的时期，则故障节点将不得不从头开始恢复。
此部分包含与 Vertica LDAP Link 服务相关的函数。
将一组 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 | -------------------- | ---------- | -----------
将一组 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
将一组 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
立即开始 LDAP 服务器和 Vertica 之间的同步，而不是等待在 LDAPLinkInterval 中设置的时间间隔。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ldap_link_sync_start()
必须是 dbaadmin 用户。
=> SELECT ldap_link_sync_start();
取消 LDAP 服务器和 Vertica 之间正在进行的 LDAP Link 同步（包括由 LDAP_LINK_DRYRUN_SYNC 启动的同步）。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ldap_link_sync_cancel()
必须是 dbaadmin 用户。
=> SELECT ldap_link_sync_cancel();
此部分包含用于监控 Vertica 许可证状态和合规性的函数。
返回在审核数据库大小时计算的数据库、架构或表的原始数据大小（以字节为单位）。除非指定容错为 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空字符串 ('') 将审核整个数据库。
要审核的架构或表的名称。
要审核的架构或表。要审核数据库，请将此参数设置为空字符串。
granularitydatabase
schema
table
粒度级别必须等于或小于 scope 的粒度。如果忽略此参数，粒度将设置为与 scope 相同的级别。因此，如果 online_sales 为架构，则以下语句相同：
AUDIT('online_sales', 'schema');
AUDIT('online_sales');
如果 AUDIT 将粒度设置为低于目标对象的级别，则会返回一条消息，推荐您使用系统表
USER_AUDITS。有关详细信息，请参阅下文的查询 V_CATALOG.USER_AUDITS。
error‑tolerance此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。
将此值设置为 0 将导致全面数据库审核，由于 AUDIT 会分析整个数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。
AUDIT 运行的周期比全面数据库审核更长。指定的此值越低，执行的数据采样越多，审核使用的资源也会越多。
confidence‑level此实参不会影响基于 ORC 或 Parquet 文件的外部表的审核。对这些表的审核始终返回底层数据文件的实际大小。
置信度值越高，执行的数据采样越多，函数使用的资源也会越多。将此值设置为 100 将导致全面数据库审核，由于该函数会分析所有数据库，因此会占用大量资源。Vertica 不建议对生产数据库执行全面的数据库审核，这会显著影响性能。
超级用户，或以下权限：
对目标表的 SELECT 权限
对目标架构的 USAGE 权限
如果 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)
请参阅审核数据库大小。
返回 __raw__ 列的估计 ROS 大小，等同于审核对象中 Flex 数据的导出大小。您可以审核数据库中的所有 Flex 数据，或将审核范围缩小到特定的 Flex 表、投影或架构。Vertica 将审核结果存储在系统表
USER_AUDITS 中。
审核不包括以下内容：
Flex 键
审核表中的其他列。
临时 Flex 表
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
AUDIT_FLEX ('[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 ]-------------------------+------------------------------
...
触发数据库大小的立即审核，以确定它是否符合 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)
触发立即审核，以确定 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)
返回 Vertica 许可证的期限。此函数显示的信息为：
许可证的有效期开始日期和结束日期（如果许可证没有到期日，则显示“永久”(Perpetual)）。
许可证期限到期后，可继续使用 Vertica 的天数（宽限期）
在许可证包含数据限额的情况下，数据库可以存储的数据量。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DISPLAY_LICENSE()
无
=> SELECT DISPLAY_LICENSE();
DISPLAY_LICENSE
---------------------------------------------------
Vertica Systems, Inc.
2007-08-03
Perpetual
500GB
(1 row)
报告自动审核数据库大小的时间。如果您的 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)
显示您的数据库是否符合 Vertica 许可证协议要求。此信息包括 Vertica 最近对数据库大小的审核结果（如果您的许可证条款中具有数据限额）、许可证期限（如果您的许可证具有结束日期）和节点数（如果您的许可证具有节点限制）。
GET_COMPLIANCE_STATUS 按 TB 衡量数据限额（其中 1 TB 等于 10244 字节）。
GET_COMPLIANCE_STATUS 显示的信息包括：
数据库的估计大小（有关大小估计的说明，请参阅审核数据库大小）。
Vertica 许可证所允许的原始数据大小。
您的数据库目前使用的限额百分比。
节点数和许可证限制。
上次审核的日期和时间。
您的数据库是否符合许可证协议的数据限额条款。
许可证的结束日期。
许可证到期之前的天数。
GET_COMPLIANCE_STATUS 的输出中。
如果审核显示您的许可证不符合数据限额要求，应该删除数据以使数据库大小低于许可的数量，或升级您的许可证。如果您的许可证已到期，应该立即联系 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)
设置 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)
此部分包含用于使用和管理通知程序的函数。
列出在 数据收集器组件上设置的所有通知策略。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
GET_DATA_COLLECTOR_NOTIFY_POLICY('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)
向 NOTIFIER 发送指定消息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
NOTIFY ( 'message', 'notifier', 'target‑topic' )
Kafka：消息的现有目标 Kafka 主题的名称。
Syslog：ProblemDescription 主题和 channel 值。
超级用户
发送消息以确认 ETL 作业已完成：
=> SELECT NOTIFY('ETL Done!', 'my_notifier', 'DB_activity_topic');
为 数据收集器组件创建/启用通知策略。当某些事件发生时，通知策略会自动向指定的 NOTIFIER 发送消息。
要查看数据收集器组件上的现有通知策略，请参阅 GET_DATA_COLLECTOR_NOTIFY_POLICY。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_DATA_COLLECTOR_NOTIFY_POLICY('component','notifier', 'topic', enabled)
查询系统表 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)
Kafka：将接收通知消息的 Kafka 主题的名称。
Syslog：字段 ProblemDescription 的主题。
要在登录尝试失败时收到通知，您可以创建一个通知程序，使其在 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)
以下示例创建了一个通知程序，当
数据收集器 (DC) 组件 LoginFailures 更新时，它会向 syslog 写入一条消息：
为当前数据库启用 syslog 通知程序：
=> ALTER DATABASE DEFAULT SET SyslogEnabled = 1;
创建并启用系统日志通知程序 v_syslog_notifier：
=> CREATE NOTIFIER v_syslog_notifier ACTION 'syslog'
ENABLE
MAXMEMORYSIZE '10M'
IDENTIFIED BY 'f8b0278a-3282-4e1a-9c86-e0f3f042a971'
PARAMETERS 'eventSeverity = 5';
配置 syslog 通知程序 v_syslog_notifier 以更新具有 SET_DATA_COLLECTOR_NOTIFY_POLICY 的 LoginFailures DC 组件：
=> SELECT SET_DATA_COLLECTOR_NOTIFY_POLICY('LoginFailures','v_syslog_notifier', 'Login failed!', true);
当用户未能以用户 Bob 身份进行身份验证时，此通知程序将以下消息写入 syslog（默认位置：/var/log/messages）：Apr 25 16:04:58 vertica_host_01 vertica： Event Posted: Event Code:21 Event Id:0 Event Severity: Notice [5] PostedTimestamp: 2022-04-25 16:04:58.083063 ExpirationTimestamp: 2022-04-25 16:04:58.083063 EventCodeDescription: Notifier ProblemDescription: (Login failed!) { "_db":"VMart", "_schema":"v_internal", "_table":"dc_login_failures", "_uuid":"f8b0278a-3282-4e1a-9c86-e0f3f042a971", "authentication_method":"Reject", "client_authentication_name":"default: Reject", "client_hostname":"::1", "client_label":"", "client_os_user_name":"dbadmin", "client_pid":523418, "client_version":"", "database_name":"dbadmin", "effective_protocol":"3.8", "node_name":"v_vmart_node0001", "reason":"REJECT", "requested_protocol":"3.8", "ssl_client_fingerprint":"", "ssl_client_subject":"", "time":"2022-04-25 16:04:58.082568-05", "user_name":"Bob" }#012 DatabaseName: VMart Hostname: vertica_host_01
此部分包含 Vertica 专用的分区管理函数。
指定将 DATE 分区键分成年、月和日的层次结构。Vertica
Tuple Mover 会定期根据当前日期评估分区键，并根据需要将分区合并到相应的年份和月份分区组中。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CALENDAR_HIERARCHY_DAY( partition‑expression[, active‑months[, active‑years] ] )
PARTITION BY 表达式相同。MONTH(CURRENT_DATE) 前多少个月的唯一分区键存储在单独的分区中。
如果指定为 1，则只将当月的分区键存储在单独的分区中。
如果指定为 0，则将当月的所有分区键合并到该月的分区组中。
有关详细信息，请参阅分层分区。
默认值： 2
YEAR(CURRENT_DATE) 前多少年的分区键按月份分组到单独的分区中。
如果指定为 1，则只将当年的分区键存储在月份分区组中。
如果指定为 0，则将当前和以前年份的所有分区键合并到年份分区组中。
有关详细信息，请参阅分层分区。
默认值： 2
CALENDAR_HIERARCHY_DAY算法假设大多数表活动都集中在最近的日期。通过将 active‑years 和 active‑months 设置为 ≥ 2 的小数字，可将合并活动隔离到特定日期的容器中，并将开销降至最低。Vertica 建议您对 active‑years 和 active‑months 使用默认设置 2。对于大多数用户来说，这些设置在 ROS 存储和性能之间实现了最佳平衡。
在表分区子句中指定此函数，作为其 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;
有关用法的详细信息，请参阅分层分区。
将分区从一个表复制到另一个表中。这种轻型分区复制可通过在两个表之间初始共享同一个存储来提高性能。完成复制操作后，各表彼此独立。用户对每个表执行操作时不会影响另一个表。这些操作可增加两个表所需的存储总量。
这是元函数。您必须在顶级 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‑tablemin‑range‑value max‑range‑value目标表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)
删除指定的表分区键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_PARTITIONS (
'[[database.]schema.]table‑name',
'min‑range‑value',
'max‑range‑value'
[, 'force‑split']
)
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table‑namemin‑range‑value max‑range‑valueforce‑split可选的布尔实参，指定如果分区键的范围跨越多个容器或单个容器的某些部分，是否拆分 ROS 容器：
true：根据需要拆分 ROS 容器。
false （默认值）：如果必须拆分 ROS 容器以实施此操作，则返回错误。
以下几项之一：
DBADMIN
表所有者
对表架构的 USAGE 权限和对表的 TRUNCATE 权限
请参阅删除分区。
转储指定投影的分区键。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DUMP_PROJECTION_PARTITION_KEYS( '[[database.]schema.]projection-name')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
非超级用户：对锚表的 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)
转储指定表的所有投影的分区键。
这是元函数。您必须在顶级 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)
将分区从一个表移至另一个表。
这是元函数。您必须在顶级 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‑tablemin‑range‑value max‑range‑value目标表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 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。
目标表不能是不可变的。
不能将以下表用作源表或目标表：
临时表
虚拟表
系统表
外部表
请参阅存档分区。
拆分指定投影的
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)
调用 Tuple Mover，以根据需要重新组织 ROS 存储容器以符合当前分区策略。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PARTITION_TABLE ( '[schema.]table‑name')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table‑name 表所有者
对架构的 USAGE 权限
不能在实时聚合投影或 Top-K 投影的锚表中运行 PARTITION_TABLE。
要重新组织存储以符合新策略，请在更改分区 GROUP BY 表达式后运行 PARTITION_TABLE。
清除已删除行的表分区。类似 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)
在两个表之间切换分区。
这是元函数。您必须在顶级 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目标表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 将返回一个警告，但操作继续进行。分区仍然位于它们的现有存储层中。
目标表不能是不可变的。
不能将以下表用作源表或目标表：
临时表
虚拟表
系统表
外部表
请参阅交换分区。
此部分包含用于管理用户和角色权限以及访问策略的函数。
检查是否启用了 Vertica 用户角色，并返回 true 或 false。当为数据库角色创建访问策略时，通常会使用此函数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ENABLED_ROLE ( 'role' )
无
请参阅：
返回当前用户对对象具有的有效权限，包括显式权限、隐式权限、继承的权限以及基于用户的权限。
因为此元函数仅返回有效权限，因此 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.]schemapublic。无
在以下示例中，用户 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)
检查是否已将 Vertica 用户角色授予指定的用户或角色，并返回 true 或 false。
您还可以查询系统表 ROLES、GRANTS 和 USERS，以获取有关用户及其角色分配的信息。有关详细信息，请参阅查看用户角色。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HAS_ROLE( [ 'grantee' ,] 'verify‑role' );
granteeCURRENT_USER)。如果指定了角色，Vertica 会检查是否向此角色授予在 verify‑role 中指定的角色。
verify‑role无
在以下示例中，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)
启用非超级用户对所有系统表的访问权限。调用此函数后，Vertica 将忽略表 SYSTEM_TABLES 中的 IS_ACCESSIBLE_DURING_LOCKDOWN 设置。要继续对非超级用户强制执行对系统表的访问限制，请调用 RESTRICT_SYSTEM_TABLES_ACCESS。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RELEASE_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()
超级用户
此部分包含 Vertica 专用的投影管理函数。
从系统表 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)
针对潜在的 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)
返回投影的 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)
返回与 projection 的状态相关的信息：
使用
[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]
返回指定锚表的投影的上下文和投影信息。
数据库 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]
从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。
PURGE_PROJECTION 在清除数据时可能会占用大量磁盘空间。
有关清除操作的详细信息，请参阅
PURGE。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PURGE_PROJECTION ( '[[database.]schema.]projection' )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表所有者
对架构的 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)
在前台同步刷新一个或多个表投影，并更新 PROJECTION_REFRESHES 系统表。如果在不使用实参的情况下运行 REFRESH，则它会刷新所有包含过时数据的投影。
有关投影刷新的详细信息，请参阅刷新投影。
如果刷新会违反表或架构磁盘配额，操作将失败。有关详细信息，请参阅磁盘配额。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
REFRESH ( [ '[[database.]schema.]table[,...]' ] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
Projection NameAnchor TableStatusqueued：排队等待刷新。
refreshing：正在刷新。
refreshed：已成功完成刷新。
failed：未成功完成刷新。
Refresh MethodError CountDuration (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]
刷新使用约束 SET USING 或 DEFAULT USING 定义的表列。与 REFRESH_COLUMNS 调用关联的所有刷新操作属于同一个事务。因此，必须刷新 REFRESH_COLUMNS 指定的所有表和列；否则，整个操作将回退。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
REFRESH_COLUMNS ( 'table‑list', '[column‑list]'
[, '[refresh‑mode ]' [, min‑partition‑key, max‑partition‑key] ]
)
[[database.]schema.]table[,...]
[[[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');
如果指定一个数据库，它必须是当前数据库。
UPDATE ：将原始行标记为已删除并用新行替换它们。为了保存这些更新，您必须发出 COMMIT 语句。
REBUILD: 替换指定列中的所有数据。重建操作是自动提交的。
如果设置为空字符串或被忽略，则在 UPDATE 模式下执行 REFRESH_COLUMNS。如果指定多个表，则必须显式指定 REBUILD 模式。
在这两种情况下，如果任何 SET USING 列定义为 强制执行约束的表中的主键或唯一键，则 REFRESH_COLUMNS 将返回错误。
有关使用 REBUILD 选项的限制，请参阅 REBUILD 模式限制。
需要满足以下要求：
函数只能指定一个表进行刷新。
表必须在指定的键上进行分区。
您可以使用这些实参通过最近加载的数据（即最新分区中的数据）刷新列。定期使用此选项可以显著降低因重建大型表中的整个列而产生的开销。
有关详细信息，请参阅下文中的基于分区的 REBUILD。
查询表和平展表的架构：USAGE
查询表：SELECT
平展表：SELECT、UPDATE
通常，当对 SET USING 列数据的更改仅限于相对较少的行数时，选择 UPDATE 模式较为妥当。如果大量 SET USING 列数据过时且必须更新，请使用 REBUILD 模式。无论在任何新 SET USING 列上使用 REBUILD 调用 REFRESH_COLUMNS 都是一种很好的做法 — 例如，在使用 ALTER TABLE...ADD COLUMN 添加 SET USING 列之后对其进行填充。
如果在 SET USING 列上调用 REFRESH_COLUMNS 并将刷新模式指定为 REBUILD，则 Vertica 会在以下任何一项中指定该列时返回错误：
表的分区键
未分段的投影
任何投影的排序顺序或分段
忽略列的 SET USING 表达式中引用的锚表列的任何投影
任何投影的 GROUPED 子句
如果对平展表进行分区，则可通过指定一个或多个分区键来降低在 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（或 DEFAULT USING）列中调用 REFRESH_COLUMNS 时，它将通过联接目标表和源表来执行 SET USING 查询。默认情况下，源表始终为联接的内表。大多数情况下，源表的基数小于目标表，因此 REFRESH_COLUMNS 有效地执行联接。
有时，特别是当您在分区表上调用 REFRESH_COLUMNS 时，源表有可能比目标表更大。在这种情况下，联接操作的性能可能欠佳。
您可以通过启用配置参数 RewriteQueryForLargeDim 来解决此问题。启用 (1) 后，Vertica 将反转目标表和源表之间的内部和外部联接，以此重写查询。
请参阅 修整表示例 和 DEFAULT 与 SET USING。
使用各自 锚表的最新数据刷新 当前架构中的投影。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)
取消 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)
关闭所有外部会话（除发布此函数的外部会话以外）。关闭 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
中断指定的外部会话，回退当前事务（如果有），并关闭套接字。您只能关闭自己的会话。
关闭会话可能需要花费一些时间。要查看所有打开会话的状态，请查询系统表
SESSIONS。
有关会话管理选项的详细信息，请参阅 管理会话。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLOSE_SESSION ( '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
停止用户会话，回退当前正在运行的任何事务，并关闭连接。要确定要关闭的会话的状态，请查询
SESSIONS 表。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLOSE_USER_SESSIONS ( 'user‑name' )
此示例将关闭用户 u1 的所有活动会话：
=> SELECT close_user_sessions('u1');
返回在当前会话的上一个已完成加载中加载到数据库的行数。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)
返回在当前会话的上一个已完成加载期间拒绝的行数。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)
中断用户会话中的指定语句，回滚当前事务，把成功/失败消息写入日志文件。
执行语句过程中可以中断会话。中断只可针对用户会话运行的语句。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
INTERRUPT_STATEMENT( 'session‑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
强制所有会话释放其 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)
终止 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)
保留 General 资源池中的内存资源，以仅供 Vertica 备份和还原进程使用。其他任何 Vertica 进程都不能访问保留的资源。如果可用的资源量不足，Vertica 会将保留请求排入队列。
此元函数是会话级别的保留。当会话结束时，Vertica 会自动释放该会话中保留的任何资源。由于该元函数在会话级别运行，因此多个会话之间的资源名称无需唯一确定。
可通过查询 SESSIONS 表来查看保留的资源。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESERVE_SESSION_RESOURCE ( 'name', memory)
无
将 1024 KB 的内存保留用于备份和还原进程：
=> SELECT reserve_session_resource('VBR_RESERVE',1024);
-[ RECORD 1 ]------------+----------------
reserve_session_resource | Grant succeed
将默认的连接字符串配置设置应用于当前会话。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESET_SESSION()
以下示例显示了如何使用 RESET_SESSION。
将当前客户端连接字符串重置为默认的连接字符串设置：
=> SELECT RESET_SESSION();
RESET_SESSION
----------------------
Reset session: done.
(1 row)
此部分包含 Vertica 专用的存储管理函数。
将标签添加到存储位置，或者更改或移除现有标签。如果任何存储策略未指定位置标签，则可进行更改。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ALTER_LOCATION_LABEL ( 'path' , '[node]' , '[location‑label]' )
超级用户
只有当这两个条件都为真时，您才能移除位置标签：
未在数据库对象的存储策略中指定标签。
标记的位置不是其关联对象的最后一个可用存储。
以下 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)
更改存储位置保存的数据类型。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ALTER_LOCATION_USE ( 'path' , '[node]' , 'usage' )
'')。如果 usage 为 SHARED TEMP 或 SHARED USER，则必须在所有节点上进行更改。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');
清除 Vertica 内部缓存文件。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_CACHES ( )
超级用户
如果要为查询运行基准测试，除清除内部 Vertica 缓存文件之外，还要清除 Linux 文件系统缓存。内核使用未分配的内存作为缓存以保持磁盘块纯净。如果运行的是 Linux 2.6.16 或更高版本且具有 root 访问权限，则可清除内核文件系统缓存，如下所示：
确保缓存中的所有数据均已写入磁盘：
# sync
写入 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)
从指定的数据库、架构或表中移除用户定义的存储策略。先前策略标记位置的存储容器将移动到默认位置。默认情况下，此移动发生在所有挂起的合并任务返回之后。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] [, 'enforce‑storage‑move' ] )
database：清除存储策略的 database。
[database.]schema: 清除存储策略的 schema。
[[database.]schema.]table: 清除存储策略的 table。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。
在所有情况下，database 必须为当前数据库的名称。
false （默认值）：仅在所有待定合并任务返回后移动存储容器。
true：立即将所有存储容器移动到新位置。
ENFORCE_OBJECT_STORAGE_POLICY 立即强制执行所有存储策略。
超级用户
以下语句可清除表 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)
运行 Tuple Mover (TM) 操作并提交当前事务。您可以将此操作限定于特定表或投影。开始使用此函数时，TM 会使用 GENERAL 资源池而不是 TM 资源池。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DO_TM_TASK('task'[, '[[database.]schema.]{ table | projection}]' )
taskreshardmergeout：重新调整存储容器，使其符合通过 RESHARD_DATABASE 调用创建的分片定义。指定表或投影以及分区值范围，限制 reshardmergeout 操作的范围。
analyze_row_count：收集一组最少的统计信息并聚合指定投影的行计数，然后将其保存在数据库编录中。收集指定投影中的行数。如果指定一个表名，DO_TM_TASK 会返回该表所有投影的行计数。有关详细信息，请参阅分析行计数。
update_storage_catalog （仅推荐用于 Eon 模式）：使用捆绑表数据的元数据更新编录。有关详细信息，请参阅将捆绑包元数据写入编录。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table | projection如果未指定表或投影，则会将该任务应用于所有数据库表及其投影。
架构：USAGE
表：INSERT、UPDATE 或 DELETE 之一
以下示例对表中的所有投影执行合并：
=> SELECT DO_TM_TASK('mergeout', 't1');
您可以对表的一系列分区执行重新分片合并任务：
=> SELECT DO_TM_TASK('reshardmergeout', 'store_orders', '2001', '2005');
永久移除已停用的存储位置。此操作无法撤消。必须先使用 RETIRE_LOCATION 停用存储位置，然后再将其删除；不能删除正在使用的存储位置。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_LOCATION ( 'path', 'node' )
'')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。超级用户
如果使用某存储位置来存储数据，之后将其更改为仅存储临时文件，则该位置仍会包含数据文件。Vertica 不允许删除含数据文件的存储位置。您可以使用 MOVE_RETIRED_LOCATION_DATA 函数手动合并存储位置中的数据文件，或者您也可以删除分区。删除数据文件操作无效。
下列示例展示如何删除 v_vmart_node0003 上之前停用的存储位置：
=> SELECT DROP_LOCATION('/data', 'v_vmart_node0003');
仅限企业模式
立即应用指定对象的存储策略。默认情况下，Tuple Mover 在所有挂起的合并操作完成后强制执行对象存储策略。调用此函数相当于在使用 RETIRE_LOCATION 时设置 enforce 实参。此函数通常用作删除存储位置前的最后一步。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ENFORCE_OBJECT_STORAGE_POLICY ( 'object‑name' [,'key‑min', 'key‑max'] )
database：应用 database 存储策略。
[database.]schema: 应用 schema 存储策略。
[[database.]schema.]table: 应用 table存储策略。如果 table 位于除 public 以外的任何架构中，则必须提供架构名称。
在所有情况下，database 必须为当前数据库的名称。
以下几项之一：
超级用户
对象所有者及对其存储位置的访问权限。
将存储策略更新应用于 test 表：
=> SELECT ENFORCE_OBJECT_STORAGE_POLICY ('test');
测量存储位置的磁盘性能。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MEASURE_LOCATION_PERFORMANCE ( 'path', 'node' )
超级用户
如果您试图基于预测或测量访问模式，创建将投影、列和分区存储在不同磁盘的磁盘分层结构，您需要对每一个存放数据的存储位置的性能进行测量。您无需测量临时数据存储位置的性能，因为临时文件基于可用空间进行存储。
测量存储位置性能的方法仅适用于已配置的群集。如果您想在配置群集以前测量磁盘，请参阅 测量存储性能。
存储位置性能等同于从磁盘读取写入 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
从数据库中指定的停用存储位置或从全部停用存储位置移出全部数据。 MOVE_RETIRED_LOCATION_DATA 根据存储数据对象的存储策略，将数据移动至非停用存储位置。此函数仅在完成所有受影响的存储位置数据的迁移后才返回。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MOVE_RETIRED_LOCATION_DATA( ['location‑path'] [, 'node'] )
STORAGE_LOCATIONS 的 LOCATION_PATH 列所指定的存储位置的路径。此存储位置必须标记为已停用。
如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有停用的存储位置移出数据。
如果忽略此参数，MOVE_RETIRED_LOCATION_DATA 将从所有节点的 location-path 移出数据。
超级用户
查询系统表 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)
查询系统表 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)
调用 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)
重复前述查询，验证消息表的存储位置：
=> 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)
恢复之前使用 RETIRE_LOCATION 停用的存储位置。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RESTORE_LOCATION ( 'path', 'node' )
'')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。
如果删除任何位置，该操作将会失败。
超级用户
在还原存储位置之后，Vertica 会对所有群集存储位置重新排名。它将使用新恢复的位置来处理根据其排名确定的查询。
有关每个节点使用的磁盘存储信息，请查询
DISK_STORAGE 系统表。
在 node4 上还原停用的存储位置：
=> SELECT RESTORE_LOCATION ('/thirdSL/' , 'v_vmartdb_node0004');
停用指定的存储位置。要获取所有现有存储位置的列表，请查询 STORAGE_LOCATIONS 系统表。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
RETIRE_LOCATION ( 'path', 'node' [, enforce ] )
'')。如果存储位置为 SHARED，则必须在所有节点上执行此操作。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);
设置存储位置的磁盘性能。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SET_LOCATION_PERFORMANCE ( 'path', 'node' , 'throughput', 'average‑latency')
超级用户
以下示例将 node2 上的存储位置性能设置为每秒吞吐 122 MB 和每秒延迟 140 次寻道。
=> SELECT SET_LOCATION_PERFORMANCE('/secondVerticaStorageLocation/','node2','122','140');
通过为数据库对象分配一个标记存储位置来创建或更改其存储策略。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。如果指定一个数据库，它必须是当前数据库。
false （默认值）：仅在所有待定合并任务返回后移动存储容器。
true：立即将所有存储容器移动到新位置。
ENFORCE_OBJECT_STORAGE_POLICY 立即强制执行所有存储策略
以下几项之一：
超级用户
对象所有者及对其存储位置的访问权限。
请参阅 清除存储策略
在指定范围内分析和报告约束违规
您可以在执行 INSERT、UPDATE、MERGE 或 COPY 语句时启用自动强制执行主键约束、唯一键约束和检查约束。另外，您可以在发出这些语句后使用 ANALYZE_CONSTRAINTS 验证约束。参考约束强制执行了解更多信息。
ANALYZE_CONSTRAINTS 以 SELECT * FROM t1 持有表 t1 的锁定的相同方式执行锁定。有关其他信息，请参阅
LOCKS。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_CONSTRAINTS ('[[[database.]schema.]table ]' [, 'column[,...]'] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表架构：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)
结果集列在下表中详细描述：
请参阅检测约束违规。
分析紧密相关的列对的指定表。ANALYZE_CORRELATIONS 存储相关性最强的 20 对。ANALYZE_CORRELATIONS 还分析统计信息。
ANALYZE_CORRELATIONS 只能分析成对的单列相关。
例如，州名与国家/地区名称列紧密相关，因为通过市名通常（但并非始终）可以确认州名。康舍霍肯市与宾夕法尼亚州唯一相关，相比较而言，佐治亚州、印地安那州、肯塔基州、纽约州、弗吉尼亚州和马萨诸塞州则都有波士顿市。在本例中，市名与州名紧密相关。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_CORRELATIONS ('[[[database.]schema.]table ]' [, 'recalculate'] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
table-namerecalculate默认值： false
以下几项之一：
拥有设计架构 USAGE 权限的用户。
在下例中，ANALYZE_CORRELATIONS 分析 public 架构中所有表的列相关，即使当前不存在相关性：
=> SELECT ANALYZE_CORRELATIONS ('public.*', 'true');
ANALYZE_CORRELATIONS
----------------------
0
(1 row)
将一个表复制到另一个表。此轻量级内存函数从源表复制 DDL 及所有用户创建的投影。同时，还会复制源表的投影统计信息。因此，源表和目标表最初具有相同的定义并共享同一个存储。
完成复制操作后，源表与复制表相互独立，因此可以对一个表执行 DML 操作而不会影响另一个表。这些操作可增加两个表所需的存储总量。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
COPY_TABLE (
'[[database.]schema.]source-table',
'[[database.]schema.]target-table'
)
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
source‑table目标表如果该表不存在，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
禁止 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
检查 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[,...] )
formattable_name不要将架构名称作为表名的一部分；使用 table_schema 参数。
table_schemavertica_type_for_complex_type非超级用户：对于用户可访问的存储位置的读取权限。
在下例中，输入文件包含具有两个整数列的表的数据。可以完全推断表定义，也可以按原样使用返回的 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
检查 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[,...] )
formattable_name不要将架构名称作为表名的一部分；使用 table_schema 参数。
table_schematable_type默认值： “native”
with_copy_statement默认值：false
one_line_result默认值： false（整齐打印）
max_files默认值： 1
max_candidatesmax_candidates，还会增加 max_files。有关详细信息，请参阅 JSON。
默认值： 1
非超级用户：对于用户可访问的存储位置的读取权限。
与其他受支持的格式不同，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)
返回 AUTO_INCREMENT/IDENTITY 列的最后一个值。如果多个会话并行加载同一个包含 AUTO_INCREMENT/IDENTITY 列的表，则函数返回为该列生成的最后一个值。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
LAST_INSERT_ID()
表所有者
对表架构的 USAGE 权限
从物理存储空间中永久移除已删除的数据，以便可以重新使用磁盘空间。您可以清除包含 Ancient History Mark 时期之前的历史数据。
清除指定表的所有投影。不能使用此函数清除临时表。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
PURGE_TABLE ( '[[database.]schema.]table' )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表所有者
对架构的 USAGE 权限
以下示例清理了 Vmart 架构中的商店销售事实表的所有投影：
=> SELECT PURGE_TABLE('store.store_sales_fact');
同步重新平衡指定表中的数据。
再平衡操作执行以下任务：
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
REBALANCE_TABLE('[[database.]schema.]table‑name')
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
超级用户
执行以下任务后，重新平衡很有用，甚至十分必要：
在准备从群集移除一个或多个节点时，将其标记为临时节点。
向群集添加一个或多个节点，以便 Vertica 可以使用数据填充空节点。
更改弹性群集的比例因子，该比例因子可确定用于跨数据库存储投影的存储容器的数目。
设置控制节点大小或重新调整大型群集布局上的控制节点
向容错组添加节点或从中移除节点。
以下命令显示如何重新平衡指定表上的数据。
=> SELECT REBALANCE_TABLE('online_sales.online_sales_fact');
REBALANCE_TABLE
-------------------
REBALANCED
(1 row)
通过逆转
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
此部分包含文本搜索和正则表达式函数，以及 MATCH 子句中使用的函数。
与 MATCH 子句 一起使用，此部分的函数返回关于查找或返回的模式的附加数据。例如，可以使用这些函数返回表示与输入行匹配的事件或模式名的值、匹配的序列名或匹配模式实例的全分区唯一标识符。
如果您想在点击流分析中根据用户的 Web 浏览行为（页面点击）确定用户的操作，那么模式匹配就尤其有用。典型的在线点击流漏斗是：
公司主页 -> 产品主页 -> 搜索 -> 结果 -> 在线购买
您可以使用以上点击流漏斗，在用户的 Web 点击序列中搜索匹配并标识该用户：
登录了公司主页。
导航至产品页面。
运行查询。
单击搜索结果中的链接。
购买。
有关使用此点击流模型的示例，请参阅 事件系列模式匹配。
返回一个 VARCHAR 值，表示与行匹配事件的名称。
EVENT_NAME()
模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 EVENT_NAME()，Vertica 将返回以下错误消息：
=> SELECT event_name();
ERROR: query with pattern matching function event_name must include a MATCH clause
以下语句分析了用户在 "website2.com" 的浏览历史并标识了用户从另一网站（进入）登录 website2.com 以及在做出购买之前（购买）浏览任意数量的其他页面（站内）的模式。该查询还将输出 EVENT_NAME() 的结果值，即与行匹配的事件的名称。
SELECT uid,
sid,
ts,
refurl,
pageurl,
action,
event_name()
FROM clickstream_log
MATCH
(PARTITION BY uid, sid ORDER BY ts
DEFINE
Entry AS RefURL NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
Onsite AS PageURL ILIKE '%website2.com%' AND Action='V',
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN
P AS (Entry Onsite* Purchase)
ROWS MATCH FIRST EVENT);
uid | sid | ts | refurl | pageurl | action | event_name
-----+-----+----------+----------------------+----------------------+--------+------------
1 | 100 | 12:00:00 | website1.com | website2.com/home | V | Entry
1 | 100 | 12:01:00 | website2.com/home | website2.com/floby | V | Onsite
1 | 100 | 12:02:00 | website2.com/floby | website2.com/shamwow | V | Onsite
1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy | P | Purchase
2 | 100 | 12:10:00 | website1.com | website2.com/home | V | Entry
2 | 100 | 12:11:00 | website2.com/home | website2.com/forks | V | Onsite
2 | 100 | 12:13:00 | website2.com/forks | website2.com/buy | P | Purchase
(7 rows)
将成功模式匹配作为 INTEGER 值返回。返回值是分区中匹配所在的序号位置。
MATCH_ID()
模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 MATCH_ID()，Vertica 将返回以下错误消息：
=> SELECT match_id();
ERROR: query with pattern matching function match_id must include a MATCH clause
下面的语句在 website2.com 网站上分析用户的浏览历史，并确定用户从另一个网站（ website2.com 子句中的Entry ）到达 MATCH ，以及订购（购买）之前浏览的其他页面（Onsite）数的模式。查询同时也输出表示匹配序号的 MATCH_ID() 的值。
SELECT uid,
sid,
ts,
refurl,
pageurl,
action,
match_id()
FROM clickstream_log
MATCH
(PARTITION BY uid, sid ORDER BY ts
DEFINE
Entry AS RefURL NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
Onsite AS PageURL ILIKE '%website2.com%' AND Action='V',
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN
P AS (Entry Onsite* Purchase)
ROWS MATCH FIRST EVENT);
uid | sid | ts | refurl | pageurl | action | match_id
----+-----+----------+----------------------+----------------------+--------+------------
1 | 100 | 12:00:00 | website1.com | website2.com/home | V | 1
1 | 100 | 12:01:00 | website2.com/home | website2.com/floby | V | 2
1 | 100 | 12:02:00 | website2.com/floby | website2.com/shamwow | V | 3
1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy | P | 4
2 | 100 | 12:10:00 | website1.com | website2.com/home | V | 1
2 | 100 | 12:11:00 | website2.com/home | website2.com/forks | V | 2
2 | 100 | 12:13:00 | website2.com/forks | website2.com/buy | P | 3
(7 rows)
返回匹配模式实例的全分区唯一标识符整数值。
PATTERN_ID()
模式匹配函数必须用在 MATCH 子句 语法中；例如，如果单独调用 PATTERN_ID()，Vertica 将返回以下错误消息：
=> SELECT pattern_id();
ERROR: query with pattern matching function pattern_id must include a MATCH clause
以下语句分析了用户在 website2.com 的浏览历史并标识了用户从另一网站（进入）登录 website2.com 以及在做出购买之前（购买）浏览任意数量的其他页面（站内）的模式。查询也输出了 PATTERN_ID() 的值，表示匹配模式实例的全分区标识符。
SELECT uid,
sid,
ts,
refurl,
pageurl,
action,
pattern_id()
FROM clickstream_log
MATCH
(PARTITION BY uid, sid ORDER BY ts
DEFINE
Entry AS RefURL NOT ILIKE '%website2.com%' AND PageURL ILIKE '%website2.com%',
Onsite AS PageURL ILIKE '%website2.com%' AND Action='V',
Purchase AS PageURL ILIKE '%website2.com%' AND Action = 'P'
PATTERN
P AS (Entry Onsite* Purchase)
ROWS MATCH FIRST EVENT);
uid | sid | ts | refurl | pageurl | action | pattern_id
----+-----+----------+----------------------+----------------------+--------+------------
1 | 100 | 12:00:00 | website1.com | website2.com/home | V | 1
1 | 100 | 12:01:00 | website2.com/home | website2.com/floby | V | 1
1 | 100 | 12:02:00 | website2.com/floby | website2.com/shamwow | V | 1
1 | 100 | 12:03:00 | website2.com/shamwow | website2.com/buy | P | 1
2 | 100 | 12:10:00 | website1.com | website2.com/home | V | 1
2 | 100 | 12:11:00 | website2.com/home | website2.com/forks | V | 1
2 | 100 | 12:13:00 | website2.com/forks | website2.com/buy | P | 1
(7 rows)
利用正则表达式可以对字符串执行模式匹配。利用正则表达式语法，可以精确地定义用于匹配字符串的模式，从而为您提供比 LIKE 谓词中所用的通配符匹配更多的控制。利用 Vertica 正则表达式函数可以执行多种任务，例如确定字符串值是否与某个模式匹配，提取字符串中与某个模式匹配的部分，或对字符串中某个模式出现的次数进行计数。
Vertica 使用兼容 Perl 的正则表达式 (PCRE) 库来为正则表达式求值。顾名思义，PCRE 的正则表达式语法可兼容 Perl 5 编程语言所用的语法。您可以阅读 PCRE 文档中关于其库的内容。但如果您不熟悉正则表达式的使用，Perl 正则表达式文档提供了很好的入门材料。
指定为 SELECT 列表中的元素，返回查询表中与指定模式匹配的所有列。例如：
=> SELECT MATCH_COLUMNS ('%order%') FROM store.store_orders_fact LIMIT 3;
order_number | date_ordered | quantity_ordered | total_order_cost | reorder_level
--------------+--------------+------------------+------------------+---------------
191119 | 2003-03-09 | 15 | 4021 | 23
89985 | 2003-05-04 | 19 | 2692 | 23
246962 | 2007-06-01 | 77 | 4419 | 42
(3 rows)
MATCH_COLUMNS ('pattern')
_ （下划线）：匹配任意单个字符。
% （百分号）：匹配 0 或多个字符的字符串。
模式还可以包含反斜杠 (\\) 字符，转义嵌入列名中的保留字符：_（下划线）、%（百分号）和反斜杠 (\\) 本身。
无
您可以使用 MATCH_COLUMNS 定义数据库对象 — 例如，在 CREATE PROJECTION 中指定来标识投影列，或者在 CREATE TABLE...AS 中标识新表中的列。在所有情况下，Vertica 都会在存储对象 DDL 之前扩展 MATCH_COLUMNS 输出。对原始源表的后续更改不会影响派生的对象定义。
通常，将 MATCH_COLUMNS 指定为 SELECT 列表中的一个元素。例如，CREATE PROJECTION 可调用 MATCH_COLUMNS 来指定要包含在投影中的列。但是，尝试在投影的分段子句中指定列会返回错误：
=> CREATE PROJECTION p_store_orders AS SELECT
MATCH_COLUMNS('%product%'),
MATCH_COLUMNS('%store%'),
order_number FROM store.store_orders_fact SEGMENTED BY MATCH_COLUMNS('products%') ALL NODES;
ERROR 0: MATCH_COLUMNS() function can only be specified as an element in a SELECT list
=> CREATE PROJECTION p_store_orders AS SELECT
MATCH_COLUMNS('%product%'),
MATCH_COLUMNS('%store%'),
order_number FROM store.store_orders_fact;
WARNING 4468: Projection <store.p_store_orders_b0> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
WARNING 4468: Projection <store.p_store_orders_b1> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION
如果从支持固定数量实参的函数调用 MATCH_COLUMNS，则 Vertica 将返回错误。例如，UPPER 函数仅支持一个实参；因此，按照以下方式从 UPPER 调用 MATCH_COLUMNS 将返回错误：
=> SELECT MATCH_COLUMNS('emp%') FROM employee_dimension LIMIT 1;
-[ RECORD 1 ]-----------+---------------------------------
employee_key | 1
employee_gender | Male
employee_first_name | Craig
employee_middle_initial | F
employee_last_name | Robinson
employee_age | 22
employee_street_address | 5 Bakers St
employee_city | Thousand Oaks
employee_state | CA
employee_region | West
=> SELECT UPPER (MATCH_COLUMNS('emp%')) FROM employee_dimension;
ERROR 10465: MATCH_COLUMNS() function can only be specified as an element in a SELECT list
相反，HASH 函数接受无限数量的实参，因此可以成功将 MATCH_COLUMNS 作为实参调用：
=> select HASH(MATCH_COLUMNS('emp%')) FROM employee_dimension LIMIT 10;
HASH
---------------------
2047284364908178817
1421997332260827278
7981613309330877388
792898558199431621
5275639269069980417
7892790768178152349
184601038712735208
3020263228621856381
7056305566297085916
3328422577712931057
(10 rows)
MATCH_COLUMNS 的以下用法无效并返回错误：
在 RECURSIVE WITH 子句的非递归（基础）术语查询中包含 MATCH_COLUMNS
连接 MATCH_COLUMNS 调用的结果：
=> SELECT MATCH_COLUMNS ('%store%')||MATCH_COLUMNS('%store%') FROM store.store_orders_fact;
ERROR 0: MATCH_COLUMNS() function can only be specified as an element in a SELECT list
在 MATCH_COLUMNS 上设置别名
以下 CREATE PROJECTION 语句使用 MATCH_COLUMNS 指定新投影中的表列：
=> CREATE PROJECTION p_store_orders AS SELECT
MATCH_COLUMNS('%product%'),
MATCH_COLUMNS('%store%'),
order_number FROM store.store_orders_fact;
WARNING 4468: Projection <store.p_store_orders_b0> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
WARNING 4468: Projection <store.p_store_orders_b1> is not available for query processing. Execute the select start_refresh() function to copy data into this projection.
The projection must have a sufficient number of buddy projections and all nodes must be up before starting a refresh
CREATE PROJECTION
=> SELECT export_objects('', 'store.p_store_orders_b0');
...
CREATE PROJECTION store.p_store_orders_b0 /*+basename(p_store_orders)*/
(
product_key,
product_version,
store_key,
order_number
)
AS
SELECT store_orders_fact.product_key,
store_orders_fact.product_version,
store_orders_fact.store_key,
store_orders_fact.order_number
FROM store.store_orders_fact
ORDER BY store_orders_fact.product_key,
store_orders_fact.product_version,
store_orders_fact.store_key,
store_orders_fact.order_number
SEGMENTED BY hash(store_orders_fact.product_key, store_orders_fact.product_version, store_orders_fact.store_key, store_orders_fact.order_number) ALL NODES OFFSET 0;
SELECT MARK_DESIGN_KSAFE(1);
(1 row)
如 EXPORT_OBJECTS 输出所示，Vertica 将两个 MATCH_COLUMNS 调用的结果集存储到新投影的 DDL 中。锚表 DDL 中的后续更改不会影响此投影。
返回正则表达式与字符串匹配的次数。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_COUNT ( string-expession, pattern [, position [, regexp‑modifier ]... ] )
string-expressionVARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。
与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。
position默认值： 1
regexp‑modifier[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：
b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。
c （默认值）： 强制匹配区分大小写。
i： 强制匹配不区分大小写。
m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。
n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。
x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。
计算指定字符串 (a man, a plan, a canal: Panama) 中子字符串 an 的出现次数：
=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', 'an');
REGEXP_COUNT
--------------
4
(1 row)
自第五个字符开始，查找子字符串 an 的出现次数。
=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', 'an',5);
REGEXP_COUNT
--------------
3
(1 row)
查找包含小写字符且后跟 an 的子字符串的出现次数：
=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', '[a-z]an');
REGEXP_COUNT
--------------
3
(1 row
REGEXP_COUNT 指定 i 修饰符，因此忽略大小写：
=> SELECT REGEXP_COUNT('a man, a plan, a canal: Panama', '[a-z]an', 1, 'i');
REGEXP_COUNT
--------------
4
如果字符串包含正则表达式的匹配项，则返回 True。REGEXP_ILIKE 与 LIKE 谓词 相似，不同的是它使用不区分大小写的正则表达式，而不是简单的通配符匹配。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_ILIKE ( string-expression, pattern )
此示例将创建一个包含多个字符串的表来演示正则表达式。
使用单个 LONG VARCHAR 列 longvc 创建表 (body)，并插入具有不同字符的数据：
=> CREATE table longvc(body long varchar (1048576));
CREATE TABLE
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');
=> insert into longvc values ('Out of the frying pan, he landed immediately in the fire');
=> SELECT * FROM longvc;
body
------------------------------------------------
На берегу пустынных волн
Voin syödä lasia, se ei vahingoita minua
私はガラスを食べられます。それは私を傷つけません。
Je peux manger du verre, ça ne me fait pas mal.
zésbaésbaa
Out of the frying pan, he landed immediately in the fire
(6 rows)
包含字符 ç 的模式匹配表行：
=> SELECT * FROM longvc where regexp_ilike(body, 'ç');
body
-------------------------------------------------
Je peux manger du verre, ça ne me fait pas mal.
(1 row)
选择所有包含字符 A/a 的行：
=> SELECT * FROM longvc where regexp_ilike(body, 'A');
body
-------------------------------------------------
Je peux manger du verre, ça ne me fait pas mal.
Voin syödä lasia, se ei vahingoita minua
zésbaésbaa
(3 rows)
选择所有包含字符 O/o 的行：
=> SELECT * FROM longvc where regexp_ilike(body, 'O');
body
----------------------------------------------------------
Voin syödä lasia, se ei vahingoita minua
Out of the frying pan, he landed immediately in the fire
(2 rows)
返回字符串中正则表达式所匹配的开始或结束位置。如果正则表达式在字符串中没有找到匹配项，REGEXP_INSTR 将返回 0。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_INSTR ( string-expression, pattern
[, position [, occurrence [, return‑position [, regexp‑modifier ]... [, captured‑subexp ]]]] )
string-expressionVARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。
模式与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。
position默认值： 1
occurrence默认值： 1
return‑position默认值： 0
regexp‑modifier[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：
b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。
c （默认值）： 强制匹配区分大小写。
i： 强制匹配不区分大小写。
m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。
n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。
x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。
默认值： 0
\s*(\w+\s+(\w+)) 中，子表达式 1 包括了除前导空格之外的所有文本。
在指定字符串 (easy come, easy go) 中查找以字母 e 开头并以字母 y 结尾的字母序列的第一个实例。
=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y');
REGEXP_INSTR
--------------
1
(1 row)
自第二个字符 (2) 开始，查找以字母 e 开头并以字母 y 结尾的第一个字母序列：
=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y',2);
REGEXP_INSTR
--------------
12
(1 row)
自第一个字符 (1) 开始，查找以字母 e 开头并以字母 y 结尾的第二个字母序列：
=> SELECT REGEXP_INSTR('easy come, easy go','e\w*y',1,2);
REGEXP_INSTR
--------------
12
(1 row)
查找第一个空格之后的第一个字符的位置：
=> SELECT REGEXP_INSTR('easy come, easy go','\s',1,1,1);
REGEXP_INSTR
--------------
6
(1 row)
通过将每个单词捕获为一个子表达式并返回第三个子表达式的开始位置，查找字符串中第三个单词的开始位置。
=> SELECT REGEXP_INSTR('one two three','(\w+)\s+(\w+)\s+(\w+)', 1,1,0,'',3);
REGEXP_INSTR
--------------
9
(1 row)
如果字符串与正则表达式匹配，则返回 True。REGEXP_LIKE 与 LIKE 谓词 相似，不同的是它使用正则表达式而不是简单的通配符匹配。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_LIKE ( string-expression, pattern [, regexp‑modifier ]... )
string-expressionVARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。
与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。
[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：
b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。
c （默认值）： 强制匹配区分大小写。
i： 强制匹配不区分大小写。
m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。
n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。
x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。
创建一个包含多个字符串的表：
=> CREATE TABLE t (v VARCHAR);
CREATE TABLE
=> CREATE PROJECTION t1 AS SELECT * FROM t;
CREATE PROJECTION
=> COPY t FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> aaa
>> Aaa
>> abc
>> abc1
>> 123
>> \.
=> SELECT * FROM t;
v
-------
aaa
Aaa
abc
abc1
123
(5 rows)
选择表 t 中所有包含字母 a 的记录：
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a');
v
------
Aaa
aaa
abc
abc1
(4 rows)
选择表 t 中所有以字母 a 开头的行：
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'^a');
v
------
aaa
abc
abc1
(3 rows)
选择所有包含子字符串 aa 的行：
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aa');
v
-----
Aaa
aaa
(2 rows)
选择所有包含一个数字的行。
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'\d');
v
------
123
abc1
(2 rows)
选择所有包含子字符串 aaa 的行：
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aaa');
v
-----
aaa
(1 row)
选择所有包含子字符串 aaa 且使用不区分大小写的匹配的行。
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'aaa', 'i');
v
-----
Aaa
aaa
(2 rows)
选择包含子字符串 a b c 的行：
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a b c');
v
---
(0 rows)
选择包含子字符串 a b c 且忽略正则表达式内的空格的行。
=> SELECT v FROM t WHERE REGEXP_LIKE(v,'a b c','x');
v
------
abc
abc1
(2 rows)
向表 t 中添加多行行：
=> COPY t FROM stdin RECORD TERMINATOR '!';
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Record 1 line 1
>> Record 1 line 2
>> Record 1 line 3!
>> Record 2 line 1
>> Record 2 line 2
>> Record 2 line 3!
>> \.
选择表 t 中以子字符串 Record 开头并以子字符串 line 2 结尾的行。
=> SELECT v from t WHERE REGEXP_LIKE(v,'^Record.*line 2$');
v
---
(0 rows)
选择以子字符串 Record 开头并以子字符串 line 2 结尾，并且将多个行作为单独字符串处理的行。
=> SELECT v from t WHERE REGEXP_LIKE(v,'^Record.*line 2$','m');
v
--------------------------------------------------
Record 2 line 1
Record 2 line 2
Record 2 line 3
Record 1 line 1
Record 1 line 2
Record 1 line 3
(2 rows)
如果字符串与不区分大小写的正则表达式不匹配，则返回 True。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_NOT_ILIKE ( string-expression, pattern )
创建一个包含单个 long varchar 列 (longvc) 的表 (body)。然后，插入包含一些不同字符的数据，并查询表内容：
=> CREATE table longvc(body long varchar (1048576));
CREATE TABLE
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');
=> SELECT * FROM longvc;
body
------------------------------------------------
На берегу пустынных волн
Voin syödä lasia, se ei vahingoita minua
私はガラスを食べられます。それは私を傷つけません。
Je peux manger du verre, ça ne me fait pas mal.
zésbaésbaa
(5 rows)
查找所有不包含字符 ç 的行：
=> SELECT * FROM longvc where regexp_not_ilike(body, 'ç');
body
----------------------------------------------------
Voin syödä lasia, se ei vahingoita minua
zésbaésbaa
На берегу пустынных волн
私はガラスを食べられます。それは私を傷つけません。
(4 rows)
查找所有不包含子字符串 a 的行：
=> SELECT * FROM longvc where regexp_not_ilike(body, 'a');
body
----------------------------------------------------
На берегу пустынных волн
私はガラスを食べられます。それは私を傷つけません。
(2 rows)
如果字符串不包含正则表达式的匹配项，则返回 True。REGEXP_NOT_LIKE 是区分大小写的正则表达式。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_NOT_LIKE ( string-expression, pattern )
创建一个包含 LONG VARCHAR 列 body 的表 (longvc)。然后，插入包含一些不同字符的数据，并查询表内容：
=> CREATE table longvc(body long varchar (1048576));
CREATE TABLE
=> insert into longvc values ('На берегу пустынных волн');
=> insert into longvc values ('Voin syödä lasia, se ei vahingoita minua');
=> insert into longvc values ('私はガラスを食べられます。それは私を傷つけません。');
=> insert into longvc values ('Je peux manger du verre, ça ne me fait pas mal.');
=> insert into longvc values ('zésbaésbaa');
=> SELECT * FROM longvc;
body
------------------------------------------------
На берегу пустынных волн
Voin syödä lasia, se ei vahingoita minua
私はガラスを食べられます。それは私を傷つけません。
Je peux manger du verre, ça ne me fait pas mal.
zésbaésbaa
(5 rows)
使用 REGEXP_NOT_LIKE 可以返回不包含字符 ç 的行：
=> SELECT * FROM longvc where regexp_not_like(body, 'ç');
body
----------------------------------------------------
Voin syödä lasia, se ei vahingoita minua
zésbaésbaa
На берегу пустынных волн
私はガラスを食べられます。それは私を傷つけません。
(4 rows)
返回不包含字符 *ö 和 *ä 的所有行：
=> SELECT * FROM longvc where regexp_not_like(body, '.*ö.*ä');
body
----------------------------------------------------
Je peux manger du verre, ça ne me fait pas mal.
zésbaésbaa
На берегу пустынных волн
私はガラスを食べられます。それは私を傷つけません。
(4 rows)
对不包含子字符 z 和 *ésbaa 的所有行进行模式匹配：
=> SELECT * FROM longvc where regexp_not_like(body, 'z.*ésbaa');
body
----------------------------------------------------
Je peux manger du verre, ça ne me fait pas mal.
Voin syödä lasia, se ei vahingoita minua
zésbaésbaa
На берегу пустынных волн
私はガラスを食べられます。それは私を傷つけません。
(5 rows)
将所有与正则表达式匹配的子字符串实例替换为另一个子字符串。REGEXP_REPLACE 与 REPLACE 函数相似，不同的是，它使用正则表达式来选择要替换的子字符串。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_REPLACE ( string-expression, target
[, replacement [, position [, occurrence[...] [, regexp‑modifier]]]] )
string-expressionVARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。
与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。
\1 插入到替换字符串，第二个则会使用 \2 插入到替换字符串，依此类推。默认值： 1
默认值： 1
[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：
b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。
c （默认值）： 强制匹配区分大小写。
i： 强制匹配不区分大小写。
m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。
n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。
x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。
与 Oracle 不同，Vertica 可以处理捕获到的无限数量的子表达式，而 Oracle 则限制为 9 个。
在 Vertica 中，可以在替换模式中使用 \10 来访问正则表达式中第 10 对圆括号所捕获的子字符串。在 Oracle 中，\10 将作为第一对圆括号所捕获的子字符串进行处理，后面紧跟 0。要在 Vertica 强制使用此 Oracle 行为，请使用 \g 反向引用，并将捕获的子表达式编号括在花括号内。例如，\g{1}0 表示第一对圆括号所捕获的子字符串，后面紧跟 0。
也可以对捕获的子表达式进行命名，以增强正则表达式的明确性。有关详细信息，请参阅 PCRE 文档。
在字符串 healthy, wealthy, and wise 中查找以 thy 结尾的“字符元”组（字母、数字和下划线），并将其替换为空字符串。
=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy');
REGEXP_REPLACE
----------------
, , and wise
(1 row)
查找以 thy 结尾的字符元组，并替换为字符串 something。
=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something');
REGEXP_REPLACE
--------------------------------
something, something, and wise
(1 row)
查找以 thy 结尾的字符元组，并从字符串中的第三个字符开始替换为字符串 something。
=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something', 3);
REGEXP_REPLACE
----------------------------------
hesomething, something, and wise
(1 row)
将以 thy 结尾的第二个字符元组替换为字符串 something。
=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','\w+thy', 'something', 1, 2);
REGEXP_REPLACE
------------------------------
healthy, something, and wise
(1 row)
查找以 thy 结尾的字符元组（捕获 thy 前面的字母），并替换为捕获到的字母加上字母 ish。
=> SELECT REGEXP_REPLACE('healthy, wealthy, and wise','(\w+)thy', '\1ish');
REGEXP_REPLACE
----------------------------
healish, wealish, and wise
(1 row)
创建表以演示替换查询中的字符串。
=> CREATE TABLE customers (name varchar(50), phone varchar(11));
CREATE TABLE
=> CREATE PROJECTION customers1 AS SELECT * FROM customers;
CREATE PROJECTION
=> COPY customers FROM stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> Able, Adam|17815551234
>> Baker,Bob|18005551111
>> Chu,Cindy|16175559876
>> Dodd,Dinara|15083452121
>> \.
查询客户，使用 REGEXP_REPLACE 设置电话号码格式。
=> SELECT name, REGEXP_REPLACE(phone, '(\d)(\d{3})(\d{3})(\d{4})',
'\1-(\2) \3-\4') as phone FROM customers;
name | phone
-------------+------------------
Able, Adam | 1-(781) 555-1234
Baker,Bob | 1-(800) 555-1111
Chu,Cindy | 1-(617) 555-9876
Dodd,Dinara | 1-(508) 345-2121
(4 rows)
返回字符串内与正则表达式匹配的子字符串。如果没有找到匹配项，REGEXP_SUBSTR 将返回 NULL。这与空字符串不同，如果正则表达式匹配零长度的字符串，则会返回空字符串。
此函数使用默认区域设置对 UTF-8 字符串进行操作，即使区域设置设置为其他方式。
REGEXP_SUBSTR ( string-expression, pattern
[, position [, occurrence [, regexp‑modifier [, captured‑subexp ]]... ]] )
string-expressionVARCHAR 或 LONG VARCHAR 表达式，用于评估在模式中指定的正则表达式是否匹配。如果字符串表达式位于在 Flex 表或列式表的 __raw__ 列中，则在搜索模式之前将字符串转换为 LONG VARCHAR。
与字符串表达式匹配的正则表达式。正则表达式必须符合 Perl 正则表达式语法。
默认值： 1
默认值： 1
[可选] 一个或多个单字符标志，可修改正则表达式模式与字符串表达式匹配的方式：
b： 将字符串视为二进制八位字节数，而不是 UTF-8 字符。
c （默认值）： 强制匹配区分大小写。
i： 强制匹配不区分大小写。
m： 将要匹配的字符串视为多行。使用此修饰符，可使行头 (^) 和行尾 ($) 的正则表达式运算符与字符串内的换行符 (\n) 相匹配。如果没有 m 修饰符，行头和行尾运算符仅与字符串的开头和结尾相匹配。
n： 将正则表达式运算符 (.) 与换行符 (\n) 相匹配。默认情况下，. 运算符可与除换行符以外的任何字符相匹配。
x： 将注释添加到正则表达式。x 修饰符可导致函数忽略正则表达式中所有未经转义的空格字符和注释。注释以哈希 (#) 字符开始，以换行符 (\n) 结束。在字符串中匹配的正则表达式中的所有空格都必须使用反斜杠 (\\) 字符进行转义。
默认值： 0
\s*(\w+\s+(\w+)) 中，子表达式 1 包括了除前导空格之外的所有文本。
选择以 thy 结尾的第一个字母子字符串。
=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy');
REGEXP_SUBSTR
---------------
healthy
(1 row)
选择从字符串中的第二个字符开头并以 thy 结尾的第一个字母子字符串。
=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy',2);
REGEXP_SUBSTR
---------------
ealthy
(1 row)
选择以 thy 结尾的第二个字母子字符串。
=> SELECT REGEXP_SUBSTR('healthy, wealthy, and wise','\w+thy',1,2);
REGEXP_SUBSTR
---------------
wealthy
(1 row)
返回捕获的第三个子表达式的内容，该子表达式将捕获字符串中的第三个词。
=> SELECT REGEXP_SUBSTR('one two three', '(\w+)\s+(\w+)\s+(\w+)', 1, 1, '', 3);
REGEXP_SUBSTR
---------------
three
(1 row)
此部分包含 Vertica 专用的文本搜索函数。
删除分词器配置文件。
SELECT v_txtindex.DELETE_TOKENIZER_CONFIG_FILE (USING PARAMETERS proc_oid='proc_oid', confirm={true | false });
confirm = [true | false]True — 当使用的参数值为 True 时，强制删除分词器。
False — 当使用的参数值为 False 时，删除分词器。
默认值： False
proc_oid以下示例说明如何使用 DELETE_TOKENIZER_CONFIG_FILE 删除分词器配置文件：
=> SELECT v_txtindex.DELETE_TOKENIZER_CONFIG_FILE (USING PARAMETERS proc_oid='45035996274126984');
DELETE_TOKENIZER_CONFIG_FILE
------------------------------
t
(1 row)
返回给定分词器的配置参数。
SELECT v_txtindex.GET_TOKENIZER_PARAMETER(parameter_name USING PARAMETERS proc_oid='proc_oid');
parameter_name以下几项之一：
stopWordsCaseInsensitive
minorSeparators
majorSeparators
minLength
maxLength
ngramsSize
used
proc_oid以下示例显示了如何使用 GET_TOKENIZER_PARAMETER。
返回分词器中使用的停止词：
=> SELECT v_txtindex.GET_TOKENIZER_PARAMETER('stopwordscaseinsensitive' USING PARAMETERS proc_oid='45035996274126984');
getTokenizerParameter
-----------------------
devil,TODAY,the,fox
(1 row)
返回分词器中使用的主要分隔符：
=> SELECT v_txtindex.GET_TOKENIZER_PARAMETER('majorseparators' USING PARAMETERS proc_oid='45035996274126984');
getTokenizerParameter
-----------------------
{}()&[]
(1 row)
读取并返回给定分词器的所有参数的键值对。
您必须将 OVER() 子句与此函数一起使用。
SELECT v_txtindex.READ_CONFIG_FILE(USING PARAMETERS proc_oid='proc_oid') OVER ()
proc_oid以下示例显示了如何使用 READ_CONFIG_FILE 来返回与分词器关联的参数：
=> SELECT v_txtindex.READ_CONFIG_FILE(USING PARAMETERS proc_oid='45035996274126984') OVER();
config_key | config_value
--------------------------+---------------------
majorseparators | {}()&[]
stopwordscaseinsensitive | devil,TODAY,the,fox
(2 rows)
配置分词器参数。
\n, \t,\r 必须通过 Vertica 表示法 U&’\000D’ 或通过 Vertica 转义表示法 E’\r’ 以 Unicode 形式输入。否则，它们将被直接视为两个分隔符。例如 "\\" & "r"。
SELECT v_txtindex.SET_TOKENIZER_PARAMETER (parameter_name, parameter_value USING PARAMETERS proc_oid='proc_oid')
parameter_name使用下列内容之一：
stopwordsCaseInsensitive：非索引字列表。属于此列表的所有标记都会被忽略。Vertica 支持最多包含前 256 个 Unicode 字符的分隔符和非索引字。
如果您要定义包含逗号或反斜杠的非索引字，则需要对其转义。
例如： "Dear Jack\," "Dear Jack\\"
默认值： '' （空列表）
majorSeparators：主要分隔符列表。用引号引起来且之间没有空格。
默认值： E' []<>(){}|!;,''"*&?+\r\n\t'
minorSeparators：二级分隔符列表。用引号引起来且之间没有空格。
默认值： E'/:=@.-$#%\\_'
minLength — 标记拥有的最小长度，Integer 类型。必须大于 0。
默认值： '2'
maxLength：标记拥有的最大长度。Integer 类型。不得大于 1024 字节。有关增加标记大小的信息，请参阅 文本搜索参数。
默认值： '128'
ngramsSize：大于 0 的整数值。仅与 ngram 分词器结合使用。
默认值： '3'
used：指示无法更改分词器配置。Boolean 类型。将 used 设置为 True 后，对 setTokenizerParameter 的任何调用将失败。
在使用已配置的分词器之前，您必须将参数 used 设置为 True。这样做可防止配置在用于创建文本索引后被修改。
默认值： False
parameter_value如果您要禁用 minorSeperators 或 stopWordsCaseInsensitive，则将其值设置为 ''。
proc_oid以下示例显示了如何使用 SET_TOKENIZER_PARAMETER 配置非索引字和分隔符。
配置分词器的非索引字：
=> SELECT v_txtindex.SET_TOKENIZER_PARAMETER('stopwordsCaseInsensitive', 'devil,TODAY,the,fox' USING PARAMETERS proc_oid='45035996274126984');
SET_TOKENIZER_PARAMETER
-------------------------
t
(1 row)
配置分词器的主要分隔符：
=> SELECT v_txtindex.SET_TOKENIZER_PARAMETER('majorSeparators',E'{}()&[]' USING PARAMETERS proc_oid='45035996274126984');
SET_TOKENIZER_PARAMETER
-------------------------
t
(1 row)
其中一些函数通过具有不同自变量类型的多种形式提供。除非另有注明，否则函数的给定形式返回与它的自变量相同的数据类型。在边界情况下，函数与 DOUBLE PRECISION 数据配合使用的准确性和行为可能会有所不同，具体取决于主机系统。
返回实参的绝对值。返回值与实参的数据类型相同。
ABS ( expression )
expression SELECT ABS(-28.7);
abs
------
28.7
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示实参的反三角余弦。
ACOS ( expression )
expressionSELECT ACOS (1);
acos
------
0
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正弦。
ASIN ( expression )
expressionSELECT ASIN(1);
asin
-----------------
1.5707963267949
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示实参的三角反正切。
ATAN ( expression )
SELECT ATAN(1);
atan
-------------------
0.785398163397448
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示实参的算术被除数的三角反正切。
ATAN2 ( quotient, divisor )
quotientdivisorSELECT ATAN2(2,1);
ATAN2
------------------
1.10714871779409
(1 row)
返回实参的立方根。返回值的类型为 DOUBLE PRECISION。
CBRT ( expression )
expressionSELECT CBRT(27.0);
cbrt
------
3
(1 row)
将返回值向上舍入到下一个整数。例如，给定实参 5.01 和 5.99，CEILING 返回 6。CEILING 与 FLOOR 相对，它向下舍入返回值。
CEIL[ING] ( expression )
=> SELECT CEIL(-42.8);
CEIL
------
-42
(1 row)
SELECT CEIL(48.01);
CEIL
------
49
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角余弦。
COS ( expression )
expressionSELECT COS(-1);
COS
------------------
0.54030230586814
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的双曲余弦。
COSH ( expression )
expression=> SELECT COSH(-1);
COSH
------------------
1.54308063481524
返回一个 DOUBLE PRECISION 值，该值表示实参的三角余切。
COT ( expression )
expressionSELECT COT(1);
cot
-------------------
0.642092615934331
(1 row)
将表达式从弧度转换为小数度，或从度、分钟和秒转换为小数度。返回值的类型为 DOUBLE PRECISION。
DEGREES ( { radians | degrees, minutes, seconds } )
角度测量单位。2π 弧度等于全角度。
角度测量单位，等于全角度的 1/360。
角度测量单位，表示 1/60 度。
角度测量单位，表示 1/60 分钟。
SELECT DEGREES(0.5);
DEGREES
------------------
28.6478897565412
(1 row)
SELECT DEGREES(1,2,3);
DEGREES
------------------
1.03416666666667
(1 row)
返回两点之间的距离（以千米为单位）。指定起点和终点的纬度和经度。使用椭球体模型时，还可以指定曲率半径以实现更高的精度。
DISTANCE ( lat0, lon0, lat1, lon1 [, radius‑of‑curvature ] )
此示例查找纬度 45 度、经度 1 度的距离（以千米为单位），假设地球为球形。
SELECT DISTANCE(45,0,45,1);
DISTANCE
----------------------
78.6262959272162
(1 row)
使用 Vincenty 公式返回两点之间的距离（以千米为单位）。由于 Vincenty 公式包含 WGS-84 椭球体模型的参数，因此无需指定曲率半径。指定起点和终点的纬度和经度。此函数的精度高于 DISTANCE 函数，但速度较慢。
DISTANCEV (lat0, lon0, lat1, lon1);
此示例查找纬度 45 度、经度 1 度的距离（以千米为单位），假设地球为椭球形。
SELECT DISTANCEV(45,0, 45,1);
distanceV
------------------
78.8463347095916
(1 row)
返回指数函数，即某个数字的 e 次幂。返回值与实参的数据类型相同。
EXP ( exponent )
exponentSELECT EXP(1.0);
exp
------------------
2.71828182845905
(1 row)
将返回值向下舍入为前一个整数。例如，给定实参 5.01 和 5.99，FLOOR 返回 5。FLOOR 与 CEILING 相对，它向上舍入返回值。
FLOOR ( expression )
=> SELECT FLOOR((TIMESTAMP '2005-01-17 10:00' - TIMESTAMP '2005-01-01') / INTERVAL '7');
FLOOR
-------
2
(1 row)
=> SELECT FLOOR(-42.8);
FLOOR
-------
-43
(1 row)
=> SELECT FLOOR(42.8);
FLOOR
-------
42
(1 row)
虽然以下示例看似 INTEGER，但左侧的数字为 INTEGER (2^49)，而右侧的数字为 FLOAT：
=> SELECT 1<<49, FLOOR(1 << 49);
?column? | floor
-----------------+-----------------
562949953421312 | 562949953421312
(1 row)
将前一示例与以下示例进行比较：
=> SELECT 1<<50, FLOOR(1 << 50);
?column? | floor
------------------+----------------------
1125899906842624 | 1.12589990684262e+15
(1 row)
通过函数实参计算哈希值，从而产生位于范围
0 <= x < 263 内的值。
HASH 函数通常用于对一组群集节点中的投射进行分段。此函数基于行在列中的值选择每个行的特定节点。HASH 函数在群集中均匀分布数据，有利于优化查询执行。
HASH ( { * | expression[,...] } )
* | expression[,...]=> SELECT HASH(product_price, product_cost) FROM product_dimension
WHERE product_price = '11';
hash
---------------------
4157497907121511878
1799398249227328285
3250220637492749639
(3 rows)
返回实参的自然对数。返回数据类型与实参相同。
LN ( expression )
expressionSELECT LN(2);
ln
-------------------
0.693147180559945
(1 row)
返回实参的指定底的对数。返回值的数据类型与传递参数的数据类型相同。
LOG ( [ base, ] expression )
baseexpression => SELECT LOG(2.0, 64);
LOG
-----
6
(1 row)
SELECT LOG(100);
LOG
-----
2
(1 row)
返回 10 个基本实参对数，也被称为常用对数。返回值的数据类型与通过参数的数据类型相同。
LOG10 ( expression )
expression => SELECT LOG10(30);
LOG10
------------------
1.47712125471966
(1 row)
返回除法运算的余数。
MOD( expression1, expression2 )
计算
MOD(expression1, expression2) 是采用下列规则：
如果 expression1 或 expression2 是 NULL 值，则结果是 NULL 值。
如果 expression2 是零，则出现例外情况：数据异常 — 除数为 0。
否则，结果是唯一的确切数字值 R，标度为 0 (zero)，则下列各项为 true：
R 与 expression2 具有相同的符号。
R 的绝对值小于 expression1 的绝对值。
对于标度为 0 (零) 的一些精确数字值 K，expression2 = expression1 * K + R。
SELECT MOD(9,4);
mod
-----
1
(1 row)
SELECT MOD(10,3);
mod
-----
1
(1 row)
SELECT MOD(-10,3);
mod
-----
-1
(1 row)
SELECT MOD(-10,-3);
mod
-----
-1
(1 row)
SELECT MOD(10,-3);
mod
-----
1
(1 row)
=> SELECT MOD(6.2,0);
ERROR 3117: Division by zero
返回常数 pi (P)，即欧式几何中任何圆的周长与其直径的比值。返回类型为 DOUBLE PRECISION。
PI()
SELECT PI();
pi
------------------
3.14159265358979
(1 row)
返回 DOUBLE PRECISION 值，表示一个数字的另一个数字的幂。
POW[ER] ( expression1, expression2 )
SELECT POWER(9.0, 3.0);
power
-------
729
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示以弧度表示的角度。您可以在 DEGREES 中表达输入角度，并且可以选择包括分钟数和秒数。
RADIANS (degrees [, minutes, seconds])
degreesminutessecondsSELECT RADIANS(45);
RADIANS
-------------------
0.785398163397448
(1 row)
SELECT RADIANS (1,2,3);
RADIANS
-------------------
0.018049613347708
(1 row)
返回均匀分布的随机 DOUBLE PRECISION 值 x，其中
0 <= x < 1。
典型的伪随机发生器接受一个种子，该种子被设置为生成可重现的伪随机序列。但是，Vertica 会在节点群集中分布 SQL 处理，其中每个节点都产生其自己的独立随机序列。
基于 RANDOM 的结果是不可重现的，因为该工作可能在各个节点之间以不同方式划分。因此，Vertica 会在每次执行请求时为每个节点自动生成真正的随机种子，并且不会提供一种机制来强制生成特定种子。
RANDOM()
在下例中，RANDOM 返回 ≥ 0 且 < 1.0 的浮点数：
SELECT RANDOM();
random
-------------------
0.211625560652465
(1 row)
接受并返回 INTEGER 值。
RANDOMINT(n) 返回从 0 到 n – 1 的 n 个整数之一。
典型的伪随机发生器接受一个种子，该种子被设置为生成可重现的伪随机序列。但是，Vertica 会在节点群集中分布 SQL 处理，其中每个节点都产生其自己的独立随机序列。
基于 RANDOM 的结果是不可重现的，因为该工作可能在各个节点之间以不同方式划分。因此，Vertica 会在每次执行请求时为每个节点自动生成真正的随机种子，并且不会提供一种机制来强制生成特定种子。
RANDOMINT ( n )
接受的值为介于 1 到 9,223,372,036,854,775,807 之间的任何正整数 (n)。
有关整数数据类型的常规信息，请参阅 INTEGER 部分。
如果提供负值或超出最大值，Vertica 将返回错误。
在下例中，结果为 INTEGER，即 >= 0 且 < n，从集合 {0,1,2,3,4} 中随机选择。
=> SELECT RANDOMINT(5);
RANDOMINT
----------
3
(1 row)
接受并返回从 0 到指定函数实参 -1 之间的一组值中的一个 INTEGER 值。对于此加密随机数生成器，Vertica 使用 RAND_bytes 提供随机值。
RANDOMINT_CRYPTO ( integer‑expression )
在下例中，RANDOMINT_CRYPTO 返回 >= 0 且小于指定实参 5 的 INTEGER，从集合 {0,1,2,3,4} 中随机选择。
=> SELECT RANDOMINT_crypto(5);
RANDOMINT_crypto
----------------
3
(1 row)
将值四舍五入到指定的小数位数，保留原始精度和小数位数。大于或等于 0.5 的小数部分将四舍五入。小于 0.5 的分数向下舍入（截断）。
ROUND ( expression [ , places ] )
expressionNUMERIC 或 DOUBLE PRECISION (FLOAT) 类型的表达式。placesplaces 为正整数时，Vertica 使用指定位数对小数点右侧的值进行四舍五入。当
places 为负整数时，Vertica 使用指定位数对小数点左侧的值进行四舍五入。将 ROUND 与 NUMERIC 数据类型配合使用，则返回 NUMERIC 并保留原始精度和标度。
=> SELECT ROUND(3.5);
ROUND
-------
4.0
(1 row)
=> SELECT ROUND(2.0, 1.0) FROM dual;
ROUND
-------
2.0
(1 row)
=> SELECT ROUND(12.345, 2.0);
ROUND
--------
12.350
(1 row)
=> SELECT ROUND(3.444444444444444);
ROUND
-------------------
3.000000000000000
(1 row)
=> SELECT ROUND(3.14159, 3);
ROUND
---------
3.14200
(1 row)
=> SELECT ROUND(1234567, -3);
ROUND
---------
1235000
(1 row)
=> SELECT ROUND(3.4999, -1);
ROUND
--------
0.0000
(1 row)
以下示例创建了一个包含两列的表，添加了一行值，显示小数点左侧和右侧的舍入示例。
=> CREATE TABLE sampleround (roundcol1 NUMERIC, roundcol2 NUMERIC);
CREATE TABLE
=> INSERT INTO sampleround VALUES (1234567, .1234567);
OUTPUT
--------
1
(1 row)
=> SELECT ROUND(roundcol1,-3) AS pn3, ROUND(roundcol1,-4) AS pn4, ROUND(roundcol1,-5) AS pn5 FROM sampleround;
pn3 | pn4 | pn5
-------------------------+-------------------------+-------------------------
1235000.000000000000000 | 1230000.000000000000000 | 1200000.000000000000000
(1 row)
=> SELECT ROUND(roundcol2,3) AS p3, ROUND(roundcol2,4) AS p4, ROUND(roundcol2,5) AS p5 FROM sampleround;
p3 | p4 | p5
-------------------+-------------------+-------------------
0.123000000000000 | 0.123500000000000 | 0.123460000000000
(1 row)
返回 DOUBLE PRECISION 值 -1、0 或 1，该值表示实参的算术符号。
SIGN ( expression )
expressionSELECT SIGN(-8.4);
sign
------
-1
(1 row)
返回 DOUBLE PRECISION 值，表示已传递参数的三角正弦。
SIN ( expression )
expressionSELECT SIN(30 * 2 * 3.14159 / 360);
SIN
-------------------
0.499999616987256
(1 row)
返回 DOUBLE PRECISION 值，表示已传递参数的双曲正弦。
SINH ( expression )
expression=> SELECT SINH(30 * 2 * 3.14159 / 360);
SINH
-------------------
0.547852969600632
返回一个 DOUBLE PRECISION 值，该值表示实参的算术平方根。
SQRT ( expression )
expressionSELECT SQRT(2);
sqrt
-----------------
1.4142135623731
(1 row)
返回一个 DOUBLE PRECISION 值，该值表示所传递参数的三角正切。
TAN ( expression )
expression=> SELECT TAN(30);
TAN
-------------------
-6.40533119664628
(1 row)
返回 DOUBLE PRECISION 值表示传递参数的双曲正切。
TANH ( expression )
expression=> SELECT TANH(-1);
TANH
-------------------
-0.761594155955765
返回完全截断的 expression 值（接近零）。提供 places 实参可将表达式截断为您指定的小数位数。
TRUNC ( expression [ , places ] )
expression NUMERIC 或 DOUBLE PRECISION (FLOAT) 类型的表达式。places将 TRUNC 与 NUMERIC 数据类型配合使用，则返回 NUMERIC 并保留原始精度和标度。
=> SELECT TRUNC(3.5);
TRUNC
-------
3.0
(1 row)
=> SELECT TRUNC(42.8);
TRUNC
-------
42.0
(1 row)
=> SELECT TRUNC(42.4382, 2);
TRUNC
---------
42.4300
(1 row)
以下示例创建了一个包含两列的表，添加了一行值，显示小数点左侧和右侧的截断示例。
=> CREATE TABLE sampletrunc (truncol1 NUMERIC, truncol2 NUMERIC);
CREATE TABLE
=> INSERT INTO sampletrunc VALUES (1234567, .1234567);
OUTPUT
--------
1
(1 row)
=> SELECT TRUNC(truncol1,-3) AS p3, TRUNC(truncol1,-4) AS p4, TRUNC(truncol1,-5) AS p5 FROM sampletrunc;
p3 | p4 | p5
-------------------------+-------------------------+-------------------------
1234000.000000000000000 | 1230000.000000000000000 | 1200000.000000000000000
(1 row)
=> SELECT TRUNC(truncol2,3) AS p3, TRUNC(truncol2,4) AS p4, TRUNC(truncol2,5) AS p5 FROM sampletrunc;
p3 | p4 | p5
-------------------+-------------------+-------------------
0.123000000000000 | 0.123400000000000 | 0.123450000000000
(1 row)
构建等宽直方图，其中直方图的范围被分为相同大小的区间（存储桶）。此外，低存储桶以下的值返回 0，高存储桶以上的值返回 bucket_count +1。返回整数值。
WIDTH_BUCKET ( expression, hist_min, hist_max, bucket_count )
expressionhist_minhist_maxbucket_countWIDTH_BUCKET 将数据集分成多个等宽的存储桶。例如，Age = 0–20, 20–40, 40–60, 60–80。这称为等宽直方图。
使用 WIDTH_BUCKET 时，请注意最小和最大边界值。每个存储桶包含等于或大于该存储桶基准数的值，所以年龄范围 0–20、20–40 等等实际上是 0–19.99 和 20–39.999。
WIDTH_BUCKET 接受以下数据类型：（FLOAT 和/或 INTEGER）、（TIMESTAMP 和/或 DATE 和/或 TIMESTAMPTZ）或 （INTERVAL和/或 TIME）。
下述示例返回五个可能值，有三个存储桶：0 [100以下)、1 [100–300)、2 [300–500)、3 [500–700) 和 4 [700 及以上)：
SELECT product_description, product_cost, WIDTH_BUCKET(product_cost, 100, 700, 3);
下述示例针对康涅狄格州的女医生顾客，在 annual_income 列上创建包含九个存储桶的直方图。结果将存储桶编号返回到“Income”列，共分为 11 个存储桶，其中包括下溢桶和溢出桶。请注意，如果顾客的年收入高于最大值，则分配到溢出桶 10：
SELECT customer_name, annual_income, WIDTH_BUCKET (annual_income, 100000, 1000000, 9) AS "Income"
FROM public.customer_dimension WHERE customer_state='CT'
AND title='Dr.' AND customer_gender='Female' AND household_id < '1000'
ORDER BY "Income";
在下述结果集中，之所以有存储桶 0，是因为存储桶从 1 到 bucket_count 进行编号。任何低于 hist_min 给定值的，都进入存储桶 0；任何高于 hist_max 给定值的，都进入存储桶 bucket_count+1。在这个示例中，存储桶 9 是空的，没有溢出。值 12,283 小于 100,000，因此进入下溢桶。
customer_name | annual_income | Income
--------------------+---------------+--------
Joanna A. Nguyen | 12283 | 0
Amy I. Nguyen | 109806 | 1
Juanita L. Taylor | 219002 | 2
Carla E. Brown | 240872 | 2
Kim U. Overstreet | 284011 | 2
Tiffany N. Reyes | 323213 | 3
Rebecca V. Martin | 324493 | 3
Betty . Roy | 476055 | 4
Midori B. Young | 462587 | 4
Martha T. Brown | 687810 | 6
Julie D. Miller | 616509 | 6
Julie Y. Nielson | 894910 | 8
Sarah B. Weaver | 896260 | 8
Jessica C. Nielson | 861066 | 8
(14 rows)
NULL 处理函数可接受任何类型的自变量，返回类型基于其自变量类型。
返回列表中第一个非空表达式的值。如果所有表达式的求值均为 NULL，则 COALESCE 返回 NULL。
COALESCE 符合 ANSI SQL-92 标准。
COALESCE ( { * | expression[,...] } )
* | expression[,...]* （星号）
对查询表中的所有列进行求值。
表达式
任何数据类型的表达式。expression 中包含的函数必须具有确定性。
COALESCE 返回从表 lead_vocalists 查询的每一行中的第一个非空值。请注意，在第一行中，COALESCE 返回空字符串。
=> SELECT quote_nullable(fname)fname, quote_nullable(lname)lname,
quote_nullable(coalesce (fname, lname)) "1st non-null value" FROM lead_vocalists ORDER BY fname;
fname | lname | 1st non-null value
---------+-----------+--------------------
'' | 'Sting' | ''
'Diana' | 'Ross' | 'Diana'
'Grace' | 'Slick' | 'Grace'
'Mick' | 'Jagger' | 'Mick'
'Steve' | 'Winwood' | 'Steve'
NULL | 'Cher' | 'Cher'
(6 rows)
返回列表中第一个非空表达式的值。
IFNULL 为 NVL 的别名。
IFNULL ( expression1 , expression2 );
如果 expression1 为 NULL，则 IFNULL 返回 expression2。
如果 expression1 不为 NULL，则 IFNULL 返回 expression1。
COALESCE 为更标准、更通用的函数。
IFNULL 等同于 ISNULL。
IFNULL 等同于 COALESCE，但 IFNULL 仅通过两个实参调用。
ISNULL(a,b) 与 x IS NULL 不同。
实参可以包含 Vertica 支持的所有数据类型。
实施等同于 CASE 表达式。例如：
CASE WHEN expression1 IS NULL THEN expression2
ELSE expression1 END;
以下语句返回值 140：
SELECT IFNULL(NULL, 140) FROM employee_dimension;
以下语句返回值 60：
SELECT IFNULL(60, 90) FROM employee_dimension;
=> SELECT IFNULL (SCORE, 0.0) FROM TESTING;
IFNULL
--------
100.0
87.0
.0
.0
.0
(5 rows)
返回列表中第一个非空表达式的值。
ISNULL 为 NVL 的别名。
ISNULL ( expression1 , expression2 );
如果 expression1 为 NULL，则 ISNULL 返回 expression2。
如果 expression1 不为 NULL，则 ISNULL 返回 expression1。
COALESCE 为更标准、更通用的函数。
ISNULL 等同于 COALESCE，但 ISNULL 仅通过两个实参调用。
ISNULL(a,b) 与 x IS NULL 不同。
实参可以包含 Vertica 支持的所有数据类型。
实施等同于 CASE 表达式。例如：
CASE WHEN expression1 IS NULL THEN expression2
ELSE expression1 END;
以下语句返回值 140：
SELECT ISNULL(NULL, 140) FROM employee_dimension;
以下语句返回值 60：
SELECT ISNULL(60, 90) FROM employee_dimension;
SELECT product_description, product_price,
ISNULL(product_cost, 0.0) AS cost
FROM product_dimension;
product_description | product_price | cost
--------------------------------+---------------+------
Brand #59957 wheat bread | 405 | 207
Brand #59052 blueberry muffins | 211 | 140
Brand #59004 english muffins | 399 | 240
Brand #53222 wheat bread | 323 | 94
Brand #52951 croissants | 367 | 121
Brand #50658 croissants | 100 | 94
Brand #49398 white bread | 318 | 25
Brand #46099 wheat bread | 242 | 3
Brand #45283 wheat bread | 111 | 105
Brand #43503 jelly donuts | 259 | 19
(10 rows)
比较两个表达式。如果两个表达式不相等，则该函数返回第一个表达式 (expression1)。如果两个表达式相等，则该函数返回 null。
NULLIF( expression1, expression2 )
expression1expression2下面的一系列语句说明了 NULLIF 函数的一个简单用法。
创建包含单列的表 t and insert some values：
CREATE TABLE t (x TIMESTAMPTZ);
INSERT INTO t VALUES('2009-09-04 09:14:00-04');
INSERT INTO t VALUES('2010-09-04 09:14:00-04');
发出 select 语句：
SELECT x, NULLIF(x, '2009-09-04 09:14:00 EDT') FROM t;
x | nullif
------------------------+------------------------
2009-09-04 09:14:00-04 |
2010-09-04 09:14:00-04 | 2010-09-04 09:14:00-04
SELECT NULLIF(1, 2);
NULLIF
--------
1
(1 row)
SELECT NULLIF(1, 1);
NULLIF
--------
(1 row)
SELECT NULLIF(20.45, 50.80);
NULLIF
--------
20.45
(1 row)
如果列中的值为 0，则计算结果为 NULL。
NULLIFZERO(expression)
expression下表 TESTING 显示了 5 名学生的测试得分。请注意，缺少 S. Robinson 和 K. Johnson 的测试得分（NULL 值显示在“分数 (Score)”列中。）
=> SELECT * FROM TESTING;
Name | Score
-------------+-------
J. Doe | 100
R. Smith | 87
L. White | 0
S. Robinson |
K. Johnson |
(5 rows)
下面的 SELECT 语句指定 Vertica 应将“分数 (Score)”列中的任何 0 值返回为 Null。在结果中，您可以看到 Vertica 将 L. White 的 0 分返回为 Null。
=> SELECT Name, NULLIFZERO(Score) FROM TESTING;
Name | NULLIFZERO
-------------+------------
J. Doe | 100
R. Smith | 87
L. White |
S. Robinson |
K. Johnson |
(5 rows)
返回列表中第一个非空表达式的值。
NVL ( expression1 , expression2 );
如果 expression1 为 NULL，则 NVL 返回 expression2。
如果 expression1 不为 NULL，则 NVL 返回 expression1。
COALESCE 为更标准、更通用的函数。
NVL 等同于 COALESCE，但 NVL 仅通过两个实参调用。
实参可以包含 Vertica 支持的所有数据类型。
实施等同于 CASE 表达式：
CASE WHEN expression1 IS NULL THEN expression2
ELSE expression1 END;
expression1 不为 NULL，因此 NVL 返回 expression1：
SELECT NVL('fast', 'database');
nvl
------
fast
(1 row)
expression1 为 NULL，因此 NVL 返回 expression2：
SELECT NVL(null, 'database');
nvl
----------
database
(1 row)
expression2 为 NULL，因此 NVL 返回 expression1：
SELECT NVL('fast', null);
nvl
------
fast
(1 row)
在以下示例中，expression1 (title) 包含 NULL，因此 NVL 返回 expression2 并将 "Withheld" 替换为未知值：
SELECT customer_name, NVL(title, 'Withheld') as title
FROM customer_dimension
ORDER BY title;
customer_name | title
------------------------+-------
Alexander I. Lang | Dr.
Steve S. Harris | Dr.
Daniel R. King | Dr.
Luigi I. Sanchez | Dr.
Duncan U. Carcetti | Dr.
Meghan K. Li | Dr.
Laura B. Perkins | Dr.
Samantha V. Robinson | Dr.
Joseph P. Wilson | Mr.
Kevin R. Miller | Mr.
Lauren D. Nguyen | Mrs.
Emily E. Goldberg | Mrs.
Darlene K. Harris | Ms.
Meghan J. Farmer | Ms.
Bettercare | Withheld
Ameristar | Withheld
Initech | Withheld
(17 rows)
接受三个实参。如果第一个实参不为 NULL，则返回第二个实参，否则返回第三个实参。如果第二个实参与第三个实参的数据类型不一致，则隐式转换为通用类型，类似于 COALESCE。
NVL2 ( expression1 , expression2 , expression3 );
如果 expression1 不为 NULL，则 NVL2 返回 expression2。
如果 expression1 为 NULL，则 NVL2 返回 expression3。
实参 2 和 3 可为 Vertica 支持的任何数据类型。
实施等同于 CASE 表达式：
CASE WHENexpression1IS NOT NULL THENexpression2ELSEexpression3 END;
在此示例中，expression1 不为 NULL，因此 NVL2 返回 expression2：
SELECT NVL2('very', 'fast', 'database');
nvl2
------
fast
(1 row)
在此示例中，expression1 为 NULL，因此 NVL2 返回 expression3：
SELECT NVL2(null, 'fast', 'database');
nvl2
----------
database
(1 row)
在以下示例中，expression1 (title) 包含 NULL，因此 NVL2 返回 expression3 ("Withheld")，同时将非空值替换为表达式 "Known"：
SELECT customer_name, NVL2(title, 'Known', 'Withheld')
as title
FROM customer_dimension
ORDER BY title;
customer_name | title
------------------------+-------
Alexander I. Lang | Known
Steve S. Harris | Known
Daniel R. King | Known
Luigi I. Sanchez | Known
Duncan U. Carcetti | Known
Meghan K. Li | Known
Laura B. Perkins | Known
Samantha V. Robinson | Known
Joseph P. Wilson | Known
Kevin R. Miller | Known
Lauren D. Nguyen | Known
Emily E. Goldberg | Known
Darlene K. Harris | Known
Meghan J. Farmer | Known
Bettercare | Withheld
Ameristar | Withheld
Initech | Withheld
(17 rows)
如果列为 NULL，则计算为 0。
ZEROIFNULL(expression)
INTEGER
DOUBLE PRECISION
INTERVAL
NUMERIC
以下查询从表 test_results 返回 5 名学生的得分，其中 L. White 的 Score 设置为 0，S. Robinson 和 K. Johnson 设置为 NULL：
=> SELECT Name, Score FROM test_results;
Name | Score
-------------+-------
J. Doe | 100
R. Smith | 87
L. White | 0
S. Robinson |
K. Johnson |
(5 rows)
下一项查询对列 Score 调用 ZEROIFNULL，因此 Vertica 为 S. Robinson 和 K. Johnson 返回 0：
=> SELECT Name, ZEROIFNULL (Score) FROM test_results;
Name | ZEROIFNULL
-------------+------------
J. Doe | 100
R. Smith | 87
L. White | 0
S. Robinson | 0
K. Johnson | 0
(5 rows)
您还可以在 PARTITION BY expressions 中使用 ZEROIFNULL，必须始终解析为非空值。例如：
CREATE TABLE t1 (a int, b int) PARTITION BY (ZEROIFNULL(a));
CREATE TABLE
Vertica 在对表t1 进行分区时调用此函数，通常是在加载操作期间执行。加载期间，函数会检查 PARTITION BY 表达式（在本例中为列 a）的数据是否存在 NULL 值。如果在给定行中遇到 NULL 值，则将分区键设置为 0，而不是返回错误。
此部分中的函数支持配置和分析数据库和查询性能。
此部分包含特定于 Vertica 的配置函数。
从指定分析类型的内存数据中清除。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CLEAR_PROFILING( 'profiling-type' [, 'scope'] )
profiling-typesession：清除对基本会话参数的配置，并锁定超时数据。
query：清除对已运行的查询的常规信息的配置，例如使用的查询字符串和查询持续时间。
ee：清除对关于每个查询的执行运行的信息的配置。
scopelocal：清除当前会话的分析数据。
global：清除所有数据库会话的配置数据。
以下语句清除了对查询所做分析的数据：
=> SELECT CLEAR_PROFILING('query');
禁止当前会话收集指定类型的分析数据。有关详细信息，请参阅 启用分析。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DISABLE_PROFILING( 'profiling-type' )
profiling-typesession：禁用针对基本会话参数和锁定超时数据的分析。
query：禁用针对运行的查询相关常规信息（如，使用的查询字符串和查询持续时间）的分析。
ee：禁用针对各查询的执行运行相关信息的分析。
以下语句可禁用对查询执行运行的分析：
=> SELECT DISABLE_PROFILING('ee');
DISABLE_PROFILING
-----------------------
EE Profiling Disabled
(1 row)
允许当前会话收集指定类型的分析数据。有关详细信息，请参阅 启用分析。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ENABLE_PROFILING( 'profiling-type' )
profiling-typesession：启用针对基本会话参数和锁定超时数据的配置。
query：启用针对运行的查询的常规信息（如查询字符串和查询持续时间）的配置。
ee：启用针对各查询的执行运行信息的配置。
下列语句将启用对查询执行运行的分析：
=> SELECT ENABLE_PROFILING('ee');
ENABLE_PROFILING
----------------------
EE Profiling Enabled
(1 row)
显示是否启用分析。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SHOW_PROFILING_CONFIG ()
以下语句显示为所有分析类型（会话、执行引擎和查询）启用了全局分析：
=> SELECT SHOW_PROFILING_CONFIG();
SHOW_PROFILING_CONFIG
------------------------------------------
Session Profiling: Session off, Global on
EE Profiling: Session off, Global on
Query Profiling: Session off, Global on
(1 row)
此部分包含用于收集和管理表数据统计信息的 Vertica 函数。
计算外部表中的确切行数。 ANALYZE_EXTERNAL_ROW_COUNT 在后台运行。
DO_TM_TASK 无法计算外部表的行数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_EXTERNAL_ROW_COUNT ('[[[database.]schema.]table‑name ]')
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
外部表上的任何 INSERT/UPDATE/DELETE 权限
计算所有外部表的精确行计数：
=> SELECT ANALYZE_EXTERNAL_ROW_COUNT('');
计算表 loader_rejects 的精确行计数：
=> SELECT ANALYZE_EXTERNAL_ROW_COUNT('loader_rejects');
从存储与指定表相关联的投影的所有节点上收集并聚合数据示例和存储信息。函数跳过复杂数据类型列。默认情况下，Vertica 会根据资源限制分析单个查询执行计划中的多个列。此类多列分析有助于实现以下目标：
减少计划执行延迟。
加快对相对较小且包含多列的表进行分析。
Vertica 将统计信息写入数据库编录。查询优化器将使用这些收集的数据来创建查询计划。没有这些数据，查询优化器会假设数据值均匀分布，所有投影的存储使用量相等。
您可以使用 CTRL+C 或调用 INTERRUPT_STATEMENT 取消统计信息收集。
ANALYZE_STATISTICS 为函数 ANALYZE_HISTOGRAM 的别名，不再进行记录。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_STATISTICS ('[[[database.]schema.]table]' [, 'column‑list' [, percent ]] )
0 - 成功
如果发生错误，请参阅
vertica.log 以了解详细信息。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表column‑list如果通过添加列并以默认值或其他值填充其内容等方式对表进行更改，则在此列上调用 ANALYZE_STATISTICS 以获取最新统计信息。
percent如果分析超过 10% 的磁盘空间，处理时间会成比例地增加，但是得到的采样精确度较高。
非超级用户：
架构：USAGE
表：INSERT、DELETE 或 UPDATE 之一
请参阅收集表统计信息。
收集并聚合指定表中一系列分区的数据示例和存储信息。Vertica 将收集的统计信息写入数据库编录。
您可以使用 CTRL+C 或元函数 INTERRUPT_STATEMENT 取消统计信息收集。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_STATISTICS_PARTITION ('[[database.]schema.]table', 'min‑range‑value','max‑range‑value' [, 'column‑list' [, percent ]] )
0：成功
如果发生错误，请参阅
vertica.log 以了解详细信息。
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
如果分析超过 10% 的磁盘空间，处理时间会成比例地增加，但是得到的采样精确度较高。
非超级用户：
架构：USAGE
表：INSERT、DELETE 或 UPDATE 之一
ANALYZE_STATISTICS_PARTITION 具有以下要求和限制：
该表必须进行分区，并且不能包含未分区的数据。
表分区表达式必须指定单个列。支持以下表达式：
仅指定列的表达式，即对所有列值进行分区。例如：
PARTITION BY ship_date GROUP BY CALENDAR_HIERARCHY_DAY(ship_date, 2, 2)
如果列是 DATE 或 TIMESTAMP/TIMESTAMPTZ，则分区表达式可以指定支持的日期/时间函数，该函数会返回该列或其任何部分，例如月份或年份。例如，以下分区表达式指定对列 order_date 的年份部分进行分区：
PARTITION BY YEAR(order_date)
该表达式对列执行加法或减法。例如：
PARTITION BY YEAR(order_date) -1
表分区表达式不能将指定列强制转换为另一种数据类型。
Vertica 不从以下投影中收集任何统计数据：
实时聚合投影和 Top-K 投影
定义这些投影可以在表达式中包含 SQL 函数
请参阅收集分区统计信息。
移除使用
ANALYZE_EXTERNAL_ROW_COUNT 编译的外部表行计数统计信息。 DROP_EXTERNAL_ROW_COUNT 在后台运行。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_EXTERNAL_ROW_COUNT ('[[[database.]schema.]table‑name ]');
数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
对表的 INSERT/UPDATE/DELETE 权限
包含表的架构上的 USAGE 权限
删除外部表 loader_rejects 的行计数统计信息：
=> SELECT DROP_EXTERNAL_ROW_COUNT('loader_rejects');
移除先前由
ANALYZE_STATISTICS 生成的数据库预测的统计数据。删除此数据后，Vertica 优化器会使用默认统计信息创建查询计划。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_STATISTICS ('[[[database.]schema.]table]' [, 'category' [, '[column‑list]'] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表类别ALL （默认值）：删除所有统计信息，包括直方图和行计数。
HISTOGRAMS：仅删除直方图。保留行计数统计信息。
column‑list 非超级用户：
架构：USAGE
表：INSERT、DELETE 或 UPDATE 之一
删除表 store.store_sales_fact 的所有基础统计信息：
=> SELECT DROP_STATISTICS('store.store_sales_fact');
DROP_STATISTICS
-----------------
0
(1 row)
删除所有表投影的统计信息：
=> SELECT DROP_STATISTICS ('');
DROP_STATISTICS
-----------------
0
(1 row)
DROP_STATISTICS_PARTITION
移除先前由
ANALYZE_STATISTICS_PARTITION 生成的数据库预测的统计数据。删除此数据后，Vertica 优化器会使用表级统计信息（如果可用）或默认统计信息创建查询计划。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
DROP_STATISTICS_PARTITION ('[[database.]schema.]table', '[min‑range‑value]', '[max‑range‑value]' [, category [, '[column‑list]'] )
[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表min‑range‑value max‑range‑valueANALYZE_STATISTICS_PARTITION 分析的完整分区范围或其超集。如果范围省略任何分析分区，则 DROP_STATISTICS_PARTITION 不会删除任何统计信息。
类别 BASE （默认值）：删除直方图和行计数（最小/最大列值、直方图）。
HISTOGRAMS：仅删除直方图。保留行计数统计信息。
ALL：删除所有统计信息。
column‑list 非超级用户：
架构：USAGE
表：INSERT、DELETE 或 UPDATE 之一
DROP_STATISTICS
从先前通过 ANALYZE_STATISTICS 收集的数据生成 XML 格式的统计信息。导出统计信息之前，请调用 ANALYZE_STATISTICS 以收集最新数据。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_STATISTICS ('[ filename ]' [,'table‑spec' [,'column[,...]']])
filename
[[database.]schema.]table
默认架构为 public。如果指定一个数据库，它必须是当前数据库。
如果省略 table‑spec 或将其设置为空字符串，Vertica 会导出数据库的所有统计信息。
列 超级用户
EXPORT_STATISTICS 不导出 LONG 数据类型列的统计信息。
以下语句将 VMart 示例数据库的统计信息导出到文件：
=> SELECT EXPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/vmart_stats.xml');
EXPORT_STATISTICS
-----------------------------------
Statistics exported successfully
(1 row)
下一个语句从名为 food 的表中导出单列（“价格 (price)”）的统计信息：
=> SELECT EXPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/price.xml', 'food.price');
EXPORT_STATISTICS
-----------------------------------
Statistics exported successfully
(1 row)
从先前通过 ANALYZE_STATISTICS_PARTITION 收集的数据生成 XML 格式的分区级统计信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
EXPORT_STATISTICS_PARTITION ('[ filename ]', 'table‑spec', 'min‑range‑value','max‑range‑value' [, 'column[,...]' )
filename
[[database.]schema.]table
默认架构为 public。如果指定一个数据库，它必须是当前数据库。
列 超级用户
EXPORT_STATISTICS_PARTITION 不导出 LONG 数据类型列的统计信息。
从
EXPORT_STATISTICS 生成的 XML 文件导入统计信息。导入的统计信息将覆盖 XML 文件中引用的投影的现有统计信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
IMPORT_STATISTICS ( 'filename' )
EXPORT_STATISTICS 生成的 XML 输入文件的路径和名称。超级用户
IMPORT_STATISTICS 仅导入有效的统计信息。如果源 XML 文件包含特定列的无效统计信息，则不导入这些统计信息，并且 Vertica 将发出警告。如果统计信息文件具有无效的结构，导入操作会失败。若要检查统计信息文件是否有效，请运行
VALIDATE_STATISTICS。
IMPORT_STATISTICS 返回 LONG 数据类型列的警告，因为 EXPORT_STATISTICS 生成的源 XML 文件中不包含该类型列的统计信息。
从先前由 EXPORT_STATISTICS 创建的 XML 文件导入 VMart 数据库的统计信息：
=> SELECT IMPORT_STATISTICS('/opt/vertica/examples/VMart_Schema/vmart_stats.xml');
IMPORT_STATISTICS
----------------------------------------------------------------------------
Importing statistics for projection date_dimension_super column date_key failure (stats did not contain row counts)
Importing statistics for projection date_dimension_super column date failure (stats did not contain row counts)
Importing statistics for projection date_dimension_super column full_date_description failure (stats did not contain row counts)
...
(1 row)
验证由
EXPORT_STATISTICS 生成的 XML 文件中的统计信息。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
VALIDATE_STATISTICS ( 'XML‑file' )
超级用户
以下示例显示了统计信息有效时的结果：
=> SELECT EXPORT_STATISTICS('cust_dim_stats.xml','customer_dimension');
EXPORT_STATISTICS
-----------------------------------
Statistics exported successfully
(1 row)
=> SELECT VALIDATE_STATISTICS('cust_dim_stats.xml');
VALIDATE_STATISTICS
---------------------
(1 row)
如果 VALIDATE_STATISTICS 无法读取文档的 XML，则会引发以下错误：
=> SELECT VALIDATE_STATISTICS('/home/dbadmin/stats.xml');
VALIDATE_STATISTICS
----------------------------------------------------------------------------
Error validating statistics file: At line 1:1. Invalid document structure
(1 row)
如果某些表统计信息无效，VALIDATE_STATISTICS 会返回标识相关信息的报告。在以下示例中，函数报告属性 distinct、buckets、rows、count、并且 distinctCount 不能是负数。
=> SELECT VALIDATE_STATISTICS('/stats.xml');
WARNING 0: Invalid value '-1' for attribute 'distinct' under column 'public.t.x'.
Please use a positive value.
WARNING 0: Invalid value '-1' for attribute 'buckets' under column 'public.t.x'.
Please use a positive value.
WARNING 0: Invalid value '-1' for attribute 'rows' under column 'public.t.x'.
Please use a positive value.
WARNING 0: Invalid value '-1' for attribute 'count' under bound '1', column 'public.t.x'.
Please use a positive value.
WARNING 0: Invalid value '-1' for attribute 'distinctCount' under bound '1', column 'public.t.x'.
Please use a positive value.
VALIDATE_STATISTICS
---------------------
(1 row)
在这种情况下，再次对表运行
ANALYZE_STATISTICS 以创建有效统计信息。
此部分包含 Vertica 专用的工作负载管理函数。
运行工作负载分析器，这是一款用于分析系统表中包含的系统信息的实用程序。
工作负载分析器可智能监控 SQL 查询的性能和工作负载历史记录、资源和配置，以确定查询性能低下的根本原因。 ANALYZE_WORKLOAD 从系统表
TUNING_RECOMMENDATIONS 返回您指定的范围和时间内的所有事件的优化建议。
优化建议基于统计信息、系统、 数据收集器事件和数据库-表-投影组合设计。工作负载分析器建议有助于快速轻松地优化查询性能。
有关常见的触发条件和建议，请参阅 工作负载分析器建议。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
ANALYZE_WORKLOAD ( '[ scope ]' [, 'since‑time' | save‑data ] );
[[database.]schema.]table
如果设置为空字符串，Vertica 将返回所有数据库对象的建议。
如果指定一个数据库，它必须是当前数据库。
必须将字符串显式转换为 TIMESTAMP 或 TIMESTAMPTZ。例如：
SELECT ANALYZE_WORKLOAD('T1', '2010-10-04 11:18:15'::TIMESTAMPTZ);
SELECT ANALYZE_WORKLOAD('T1', TIMESTAMPTZ '2010-10-04 11:18:15');
ANALYZE_WORKLOAD 的返回值：
false （默认值）：将丢弃结果。
true：保存 ANALYZE_WORKLOAD 返回的结果。对 ANALYZE_WORKLOAD 的后续调用返回从保存结果时最后一次调用开始的结果。该调用之前的对象事件将被忽略。
从
TUNING_RECOMMENDATIONS 返回聚合优化建议。
超级用户
请参阅获取优化建议。
更改活动查询的运行时优先级。
CHANGE_RUNTIME_PRIORITY。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY(transaction-id, 'value')
SESSIONS 获取的事务。valueRUNTIMEPRIORITY 值：HIGH、MEDIUM 或 LOW。超级用户：无
非超级用户只能更改自身查询的运行时优先级，不能提高查询的运行时优先级使其高于资源池级别。
请参阅更改正在运行的查询的运行时优先级。
更改主动运行查询的运行时优先级。请注意，虽然此函数仍然有效，但您应使用 CHANGE_CURRENT_STATEMENT_RUNTIME_PRIORITY 来更改运行时优先级。 CHANGE_RUNTIME_PRIORITY 将在未来版本的 Vertica 中弃用。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CHANGE_RUNTIME_PRIORITY(TRANSACTION_ID,STATEMENT_ID, 'value')
TRANSACTION_IDTRANSACTION_ID 不能为 NULL。
您可以在“会话”表中找到事务 ID。
STATEMENT_ID您可以在“会话”表中找到语句 ID。
您可以指定 NULL，以更改事务中当前正在运行的查询的运行时优先级。
'value'RUNTIMEPRIORITY 值。可以为 HIGH、MEDIUM 或 LOW。不需要特殊权限。但是，非超级用户只能改他们自己查询的运行时优先级。另外，非超级用户不能将查询的运行时优先级提高至高于资源池的优先级。
=> SELECT CHANGE_RUNTIME_PRIORITY(45035996273705748, NULL, 'low');
尝试将指定查询移动至指定目标池。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
MOVE_STATEMENT_TO_RESOURCE_POOL (session_id , transaction_id, statement_id, target_resource_pool_name)
session_idtransaction_idstatement_idtarget_resource_pool_name函数可能返回下列结果：
超级用户
下面的例子显示如何将指定语句移动至调用 my_target_pool的资源池：
=> SELECT MOVE_STATEMENT_TO_RESOURCE_POOL ('v_vmart_node0001.example.-31427:0x82fbm', 45035996273711993, 1, 'my_target_pool');
在执行另一个语句或命令之前等待指定的秒数。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
SLEEP( seconds )
secondsSLEEP(3) 与 SLEEP('3') 相同。如果成功执行此函数，返回值 0；否则，因语法错误返回错误消息。
不能取消休眠操作。
在包含共享资源的环境中使用 SLEEP() 时应当慎重，如结合使用独占锁的事务。
以下命令将暂停执行 100 秒：
=> SELECT SLEEP(100);
sleep
-------
0
(1 row)
这些函数提供有关当前系统状态的信息。超级用户对所有系统信息有不受限制的访问权限，但是用户只能查看有关自身当前会话的信息。
返回当前数据库的名称，等同于
DBNAME。
CURRENT_DATABASE()
=> SELECT CURRENT_DATABASE;
CURRENT_DATABASE
------------------
VMart
(1 row)
在 COPY 语句的范围内调用时，返回加载所使用的文件名。存在以下例外：
如果在 COPY 语句的上下文之外调用函数，则返回 NULL。
如果通过未设置源的 UDL 调用函数，则返回字符串 <unknown>。
COPY LOCAL 不支持此函数。
CURRENT_LOAD_SOURCE()
创建表并在加载时使用两个单独文件的名称填充以下其中一列：
=> CREATE TABLE t (c1 integer, c2 varchar(50), c3 varchar(200));
CREATE TABLE
=> COPY t (c1, c2, c3 AS CURRENT_LOAD_SOURCE())
FROM '/home/load_file_1' ON exampledb_node02,
'/home/load_file_2' ON exampledb_node03 DELIMITER ',';
Rows Loaded
-------------
5
(1 row)
=> SELECT * FROM t;
c1 | c2 | c3
----+--------------+-----------------------
2 | dogs | /home/load_file_1
1 | cats | /home/load_file_1
4 | superheroes | /home/load_file_2
3 | birds | /home/load_file_1
5 | whales | /home/load_file_2
(5 rows)
返回当前架构的名称。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
CURRENT_SCHEMA()
无
以下命令返回当前架构的名称。
=> SELECT CURRENT_SCHEMA();
current_schema
----------------
public
(1 row)
以下命令将返回不带圆括号的相同结果：
=> SELECT CURRENT_SCHEMA;
current_schema
----------------
public
(1 row)
以下命令显示搜索路径中列于当前用户之后的当前架构：
=> SHOW SEARCH_PATH;
name | setting
-------------+---------------------------------------------------
search_path | "$user", public, v_catalog, v_monitor, v_internal
(1 row)
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
CURRENT_USER()
CURRENT_USER 函数不需要括号。
此函数对于权限检查很有用。
CURRENT_USER 等同于 SESSION_USER、用户 和 USERNAME。
=> SELECT CURRENT_USER();
CURRENT_USER
--------------
dbadmin
(1 row)
以下命令将返回不带圆括号的相同结果：
=> SELECT CURRENT_USER;
CURRENT_USER
--------------
dbadmin
(1 row)
返回当前数据库的名称，等同于
CURRENT_DATABASE。
DBNAME()
=> SELECT DBNAME();
dbname
------------------
VMart
(1 row)
返回 true 或 false，以验证用户是否具有表的指定权限。
这是元函数。您必须在顶级 SELECT 语句中调用元函数。
HAS_TABLE_PRIVILEGE ( [ user, ] '[[database.]schema.]table', 'privilege' )
用户[database.]schema数据库和架构。默认架构为 public。如果指定一个数据库，它必须是当前数据库。
表privilege非超级用户，为以下之一：
表所有者
对表架构具有 USAGE 权限，对表具有一项或多项权限
=> SELECT HAS_TABLE_PRIVILEGE('store.store_dimension', 'SELECT');
HAS_TABLE_PRIVILEGE
---------------------
t
(1 row)
=> SELECT HAS_TABLE_PRIVILEGE('release', 'store.store_dimension', 'INSERT');
HAS_TABLE_PRIVILEGE
---------------------
t
(1 row)
=> SELECT HAS_TABLE_PRIVILEGE(45035996273711159, 45035996273711160, 'select');
HAS_TABLE_PRIVILEGE
---------------------
t
(1 row)
返回启用的密码套件列表，这些套件是用于保护 TLS/SSL 连接的算法集。
默认情况下，Vertica 使用 OpenSSL 的默认密码套件。有关详细信息，请参阅 OpenSSL 手册页。
LIST_ENABLED_CIPHERS()
=> SELECT LIST_ENABLED_CIPHERS();
SSL_RSA_WITH_RC4_128_MD5
SSL_RSA_WITH_RC4_128_SHA
TLS_RSA_WITH_AES_128_CBC_SHA
返回 VARCHAR，其中包含发起当前数据库会话的用户的名称。
SESSION_USER()
SESSION_USER 函数不要求圆括号。
SESSION_USER 等同于 CURRENT_USER、用户 和 USERNAME。
=> SELECT SESSION_USER();
session_user
--------------
dbadmin
(1 row)
以下命令将返回不带圆括号的相同结果：
=> SELECT SESSION_USER;
session_user
--------------
dbadmin
(1 row)
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
USER()
USER 函数不需要括号。
USER 等同于 CURRENT_USER、SESSION_USER 和 USERNAME。
=> SELECT USER();
current_user
--------------
dbadmin
(1 row)
以下命令将返回不带圆括号的相同结果：
=> SELECT USER;
current_user
--------------
dbadmin
(1 row)
返回包含启动当前数据库连接的用户的名称的 VARCHAR。
USERNAME()
此函数对于权限检查很有用。
USERNAME 等同于 CURRENT_USER、SESSION_USER 和 用户。
=> SELECT USERNAME();
username
--------------
dbadmin
(1 row)
返回包含 Vertica 节点的版本信息的 VARCHAR。
VERSION()
=> SELECT VERSION();
VERSION
-------------------------------------------
Vertica Analytic Database v10.0.0-0
(1 row)