聚合函数通过行组汇总查询结果集的数据。这些组使用 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)