本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 聚合函数
聚合函数返回的不是根据单个行计算得出的结果，而是根据有限行集中包含的聚合数据或有限行集的相关信息计算得出的结果。聚合函数可能出现在以下任何一项中：
+ [SELECT 子句](sql-reference-select-clause.md)的 部分
+ [ORDER BY 子句](sql-reference-order-by-clause.md)
+ [HAVING 子句](sql-reference-having-clause.md)
聚合函数不同于[分析函数](sql-reference-analytic-functions.md)，后者始终相对于必须指定的窗口进行计算，因此不能出现在 HAVING 子句中。本主题后面的表格中列出了其他区别。
使用聚合函数对表执行聚合查询和对流执行聚合查询的操作略有不同，如下所示。如果对表执行的聚合查询包含 GROUP BY 子句，则聚合函数会为输入行集中的每个组返回一个结果。缺少显式 GROUP BY 子句等同于 GROUP BY ()，只会为整个输入行集返回一个结果。
对于流，聚合查询必须在基于行时间的单调表达式上包含一个显式 GROUP BY 子句。否则，唯一的组就是整个流，永远不会结束，因此无法报告任何结果。基于单调表达式添加 GROUP BY 子句会将流分成在时间上连续的有限行集，然后可以聚合每个此类行集并生成相应报告。
每当一个会更改单调分组表达式值的行到达时，就会启动一个新组，而前一组被视为已完成。然后，Amazon Kinesis Data Analytics 应用程序会输出聚合函数的值。请注意，GROUP BY 子句还可能包括其他非单调表达式，在这种情况下可能会为每个行集生成多个结果。
对流执行聚合查询通常称为流式聚合，这与在[分析函数](sql-reference-analytic-functions.md)和[流的窗口式聚合](sql-reference-windowed-aggregation-stream.md)中讨论的窗口式聚合不同。有关 stream-to-stream联接的更多信息，请参阅[JOIN 子句](sql-reference-join-clause.md)。
如果输入行在用作数据分析函数输入的列中包含 `null`，则数据分析函数将忽略该行（COUNT 除外）。
**聚合函数和分析函数之间的区别**
| 函数类型 | 输出 | 使用的行或窗口 | 注意 |
| --- | --- | --- | --- |
| 聚合函数 | 每组输入行对应一个输出行。 | 所有输出列都是根据同一窗口或同一组行计算的。 | 流式聚合中不允许使用 COUNT DISTINCT。不允许使用以下类型的语句： SELECT COUNT(DISTINCT x) ... FROM ... GROUP BY ... |
| [分析函数](sql-reference-analytic-functions.md) | 每个输入行对应一个输出行。 | 可以使用不同窗口或分区计算每个输出列。 | COUNT DISTINCT 不能用作[分析函数](sql-reference-analytic-functions.md)或用在窗口式聚合中。 |
## 流式聚合和行时间边界
通常，当一个会更改 GROUP BY 中单调表达式值的行到达时，聚合查询就会生成一个结果。例如，如果查询按 FLOOR(rowtime TO MINUTE) 进行分组，而且当前行的行时间为 9:59.30，则行时间为 10:00.00 的新行将触发结果。
或者，可以使用行时间边限来推进单调表达式，使查询能够返回结果。例如，如果查询按 FLOOR(rowtime TO MINUTE) 进行分组，而且当前行的行时间为 9:59.30，则在传入的行时间边界为 10:00.00 时，查询会返回结果。
## 聚合函数列表
Amazon Kinesis Data Analytics 支持以下聚合函数：
+ [AVG](sql-reference-avg.md)
+ [COUNT](sql-reference-count.md)
+ [COUNT\$1DISTINCT\$1ITEMS\$1TUMBLING 函数](count-distinct-items.md)
+ [EXP\$1AVG](sql-reference-exp-avg.md)
+ [FIRST\$1VALUE](sql-reference-first-value.md)
+ [LAST\$1VALUE](sql-reference-last-value.md)
+ [MAX](sql-reference-max.md)
+ [MIN](sql-reference-min.md)
+ [SUM](sql-reference-sum.md)
+ [TOP\$1K\$1ITEMS\$1TUMBLING 函数](top-k.md)
以下 SQL 使用 AVG 聚合函数作为查询的一部分来查找所有员工的平均年龄：
```
SELECT
AVG(AGE) AS AVERAGE_AGE
FROM SALES.EMPS;
```
结果：
| AVERAGE\$1AGE |
| --- |
| 38 |
要查找每个部门员工的平均年龄，我们可以在查询中添加一个显式 GROUP BY 子句：
```
SELECT
DEPTNO,
AVG(AGE) AS AVERAGE_AGE
FROM SALES.EMPS
GROUP BY DEPTNO;
```
返回值:
| DEPTNO | AVERAGE\$1AGE |
| --- | --- |
| 10 | 30 |
| 20 | 25 |
| 30 | 40 |
| 40 | 57 |
## 对流执行的聚合查询的示例（流式聚合）
在此示例中，假设下表中的数据流经名为 WEATHERSTREAM 的流。
| ROWTIME | CITY | TEMP |
| --- | --- | --- |
| 2018-11-01 01:00:00.0 | 丹佛 | 29 |
| 2018-11-01 01:00:00.0 | 安克雷奇 | 2 |
| 2018-11-01 06:00:00.0 | 迈阿密 | 65 |
| 2018-11-01 07:00:00.0 | 丹佛 | 32 |
| 2018-11-01 09:00:00.0 | 安克雷奇 | 9 |
| 2018-11-01 13:00:00.0 | 丹佛 | 50 |
| 2018-11-01 17:00:00.0 | 安克雷奇 | 10 |
| 2018-11-01 18:00:00.0 | 迈阿密 | 71 |
| 2018-11-01 19:00:00.0 | 丹佛 | 43 |
| 2018-11-02 01:00:00.0 | 安克雷奇 | 4 |
| 2018-11-02 01:00:00.0 | 丹佛 | 39 |
| 2018-11-02 07:00:00.0 | 丹佛 | 46 |
| 2018-11-02 09:00:00.0 | 安克雷奇 | 3 |
| 2018-11-02 13:00:00.0 | 丹佛 | 56 |
| 2018-11-02 17:00:00.0 | 安克雷奇 | 2 |
| 2018-11-02 19:00:00.0 | 丹佛 | 50 |
| 2018-11-03 01:00:00.0 | 丹佛 | 36 |
| 2018-11-03 01:00:00.0 | 安克雷奇 | 1 |
如果要查找每天任意地方（全球范围内，不分城市）记录的最低和最高温度，则可以分别使用聚合函数 MIN 和 MAX 来计算最低和最高温度。要表示我们每天需要此类信息（以及要提供单调表达式作为 GROUP BY 子句的参数），我们使用 FLOOR 函数将每个行的行时间向下取整为最近一天：
```
SELECT STREAM
FLOOR(WEATHERSTREAM.ROWTIME to DAY) AS FLOOR_DAY,
MIN(TEMP) AS MIN_TEMP,
MAX(TEMP) AS MAX_TEMP
FROM WEATHERSTREAM
GROUP BY FLOOR(WEATHERSTREAM.ROWTIME TO DAY);
```
聚合查询的结果见下表。
| FLOOR\$1DAY | MIN\$1TEMP | MAX\$1TEMP |
| --- | --- | --- |
| 2018-11-01 00:00:00.0 | 2 | 71 |
| 2018-11-02 00:00:00.0 | 2 | 56 |
尽管示例数据确实包括 2018-11-03 的温度测量值，但没有这一天对应的行。这是因为在知道 2018-11-03 对应的所有行都到达之前，无法聚合这一天对应的行，而且只有在行时间为 2018-11-04 00:00:00.0（或更晚）或行时间边界为 2018-11-04 00:00:00.0（或更晚）的行到达时，才会进行聚合。如果其中任何一个到达，则下一个结果将如下表所示。
| FLOOR\$1DAY | MIN\$1TEMP | MAX\$1TEMP |
| --- | --- | --- |
| 2018-11-03 00:00:00.0 | 1 | 36 |
假设我们不是要查找每天的全球最低和最高气温，而是要查找每天每个城市的最低、最高和平均温度。为此，我们使用 SUM 和 COUNT 聚合函数来计算平均值，然后将 CITY 添加到 GROUP BY 子句中，如下所示：
```
SELECT STREAM
FLOOR(WEATHERSTREAM.ROWTIME TO DAY) AS FLOOR_DAY,
CITY,
MIN(TEMP) AS MIN_TEMP,
MAX(TEMP) AS MAX_TEMP,
SUM(TEMP)/COUNT(TEMP) AS AVG_TEMP
FROM WEATHERSTREAM
GROUP BY FLOOR(WEATHERSTREAM.ROWTIME TO DAY), CITY;
```
聚合查询的结果见下表。
| FLOOR\$1DAY | CITY | MIN\$1TEMP | MAX\$1TEMP | AVG\$1TEMP |
| --- | --- | --- | --- | --- |
| 2018-11-01 00:00:00.0 | 安克雷奇 | 2 | 10 | 7 |
| 2018-11-01 00:00:00.0 | 丹佛 | 29 | 50 | 38 |
| 2018-11-01 00:00:00.0 | 迈阿密 | 65 | 71 | 68 |
| 2018-11-02 00:00:00.0 | 安克雷奇 | 2 | 4 | 3 |
| 2018-11-02 00:00:00.0 | 丹佛 | 39 | 56 | 47 |
在本例中，当新一天的温度测量值对应的行到达时，会触发聚合前一天的数据，按 CITY 进行分组，然后为这一天的测量值中包含的每个城市生成一行。
同样，在 2018-11-04 的任何实际测量值出来之前，可以使用行时间边界 2018-11-04 00:00:00.0 来生成 2018-11-03 的结果，如下表所示。
| FLOOR\$1DAY | CITY | MIN\$1TEMP | MAX\$1TEMP | AVG\$1TEMP |
| --- | --- | --- | --- | --- |
| 2018-11-03 00:00:00.0 | 安克雷奇 | 1 | 1 | 1 |
| 2018-11-03 00:00:00.0 | 丹佛 | 36 | 36 | 36 |
# 流的窗口式聚合
为了说明窗口式聚合在 Amazon Kinesis Data Streams 中的工作原理，假定下表中的数据将流经一个名为 WEATHERSTREAM 的流。
| ROWTIME | CITY | TEMP |
| --- | --- | --- |
| 2018-11-01 01:00:00.0 | 丹佛 | 29 |
| 2018-11-01 01:00:00.0 | 安克雷奇 | 2 |
| 2018-11-01 06:00:00.0 | 迈阿密 | 65 |
| 2018-11-01 07:00:00.0 | 丹佛 | 32 |
| 2018-11-01 09:00:00.0 | 安克雷奇 | 9 |
| 2018-11-01 13:00:00.0 | 丹佛 | 50 |
| 2018-11-01 17:00:00.0 | 安克雷奇 | 10 |
| 2018-11-01 18:00:00.0 | 迈阿密 | 71 |
| 2018-11-01 19:00:00.0 | 丹佛 | 43 |
| 2018-11-02 01:00:00.0 | 安克雷奇 | 4 |
| 2018-11-02 01:00:00.0 | 丹佛 | 39 |
| 2018-11-02 07:00:00.0 | 丹佛 | 46 |
| 2018-11-02 09:00:00.0 | 安克雷奇 | 3 |
| 2018-11-02 13:00:00.0 | 丹佛 | 56 |
| 2018-11-02 17:00:00.0 | 安克雷奇 | 2 |
| 2018-11-02 19:00:00.0 | 丹佛 | 50 |
| 2018-11-03 01:00:00.0 | 丹佛 | 36 |
| 2018-11-03 01:00:00.0 | 安克雷奇 | 1 |
假设您要查找 24 小时期间内记录的全球（无论是哪个城市）的最低和最高温度（在任意给定读数之前）。为此，您需要定义 `RANGE INTERVAL '1' DAY PRECEDING` 的一个窗口，并在 `MIN` 和 `MAX` 分析函数的 `OVER` 子句中使用它：
```
SELECT STREAM
ROWTIME,
MIN(TEMP) OVER W1 AS WMIN_TEMP,
MAX(TEMP) OVER W1 AS WMAX_TEMP
FROM WEATHERSTREAM
WINDOW W1 AS (
RANGE INTERVAL '1' DAY PRECEDING
);
```
## 结果
| ROWTIME | WMIN\$1TEMP | WMAX\$1TEMP |
| --- | --- | --- |
| 2018-11-01 01:00:00.0 | 29 | 29 |
| 2018-11-01 01:00:00.0 | 2 | 29 |
| 2018-11-01 06:00:00.0 | 2 | 65 |
| 2018-11-01 07:00:00.0 | 2 | 65 |
| 2018-11-01 09:00:00.0 | 2 | 65 |
| 2018-11-01 13:00:00.0 | 2 | 65 |
| 2018-11-01 17:00:00.0 | 2 | 65 |
| 2018-11-01 18:00:00.0 | 2 | 71 |
| 2018-11-01 19:00:00.0 | 2 | 71 |
| 2018-11-02 01:00:00.0 | 2 | 71 |
| 2018-11-02 01:00:00.0 | 2 | 71 |
| 2018-11-02 07:00:00.0 | 4 | 71 |
| 2018-11-02 09:00:00.0 | 3 | 71 |
| 2018-11-02 13:00:00.0 | 3 | 71 |
| 2018-11-02 17:00:00.0 | 2 | 71 |
| 2018-11-02 19:00:00.0 | 2 | 56 |
| 2018-11-03 01:00:00.0 | 2 | 56 |
| 2018-11-03 01:00:00.0 | 1 | 56 |
现在，假定您要查找在 24 小时期间内记录的在任意给定读数之前的最低、最高和平均温度（按城市划分）。为此，您可以向窗口规范添加针对 `CITY` 的 `PARTITION BY` 子句，并向选择列表添加针对同一个窗口的 `AVG` 分析函数：
```
SELECT STREAM
ROWTIME,
CITY,
MIN(TEMP) over W1 AS WMIN_TEMP,
MAX(TEMP) over W1 AS WMAX_TEMP,
AVG(TEMP) over W1 AS WAVG_TEMP
FROM AGGTEST.WEATHERSTREAM
WINDOW W1 AS (
PARTITION BY CITY
RANGE INTERVAL '1' DAY PRECEDING
);
```
### 结果
| ROWTIME | CITY | WMIN\$1TEMP | WMAX\$1TEMP | WAVG\$1TEMP |
| --- | --- | --- | --- | --- |
| 2018-11-01 01:00:00.0 | 丹佛 | 29 | 29 | 29 |
| 2018-11-01 01:00:00.0 | 安克雷奇 | 2 | 2 | 2 |
| 2018-11-01 06:00:00.0 | 迈阿密 | 65 | 65 | 65 |
| 2018-11-01 07:00:00.0 | 丹佛 | 29 | 32 | 30 |
| 2018-11-01 09:00:00.0 | 安克雷奇 | 2 | 9 | 5 |
| 2018-11-01 13:00:00.0 | 丹佛 | 29 | 50 | 37 |
| 2018-11-01 17:00:00.0 | 安克雷奇 | 2 | 10 | 7 |
| 2018-11-01 18:00:00.0 | 迈阿密 | 65 | 71 | 68 |
| 2018-11-01 19:00:00.0 | 丹佛 | 29 | 50 | 38 |
| 2018-11-02 01:00:00.0 | 安克雷奇 | 2 | 10 | 6 |
| 2018-11-02 01:00:00.0 | 丹佛 | 29 | 50 | 38 |
| 2018-11-02 07:00:00.0 | 丹佛 | 32 | 50 | 42 |
| 2018-11-02 09:00:00.0 | 安克雷奇 | 3 | 10 | 6 |
| 2018-11-02 13:00:00.0 | 丹佛 | 39 | 56 | 46 |
| 2018-11-02 17:00:00.0 | 安克雷奇 | 2 | 10 | 4 |
| 2018-11-02 19:00:00.0 | 丹佛 | 39 | 56 | 46 |
| 2018-11-03 01:00:00.0 | 丹佛 | 36 | 56 | 45 |
| 2018-11-03 01:00:00.0 | 安克雷奇 | 1 | 4 | 2 |
## 行时间边界和窗口式聚合示例
以下是窗口式聚合查询的一个示例：
```
SELECT STREAM ROWTIME, ticker, amount, SUM(amount)
OVER (
PARTITION BY ticker
RANGE INTERVAL '1' HOUR PRECEDING)
AS hourlyVolume
FROM Trades
```
因为这是对流的查询，所以行一进入就会弹出此查询。例如，给定以下输入：
```
Trades: IBM 10 10 10:00:00
Trades: ORCL 20 10:10:00
Trades.bound: 10:15:00
Trades: ORCL 15 10:25:00
Trades: IBM 30 11:05:00
Trades.bound: 11:10:00
```
在此示例中，输出如下：
```
Trades: IBM 10 10 10:00:00
Trades: ORCL 20 20 10:10:00
Trades.bound: 10:15:00
Trades: ORCL 15 35 10:25:00
Trades: IBM 30 30 11:05:00
Trades.bound: 11:10:00
```
这些行仍然在后台逗留一个小时，因此第二个 ORCL 行输出的总计为 35；但原始 IBM 交易落在“上一个小时”窗口外，因此它未包含在 IBM 总计中。
## 示例
有些业务问题似乎需要对流的整个历史进行总计，但这通常无法计算。但是，此类业务问题通常可以通过查看最后一天、最后一小时或最近 N 条记录来解决。此类记录的集合称为*窗口化聚合*。
它们在流数据库中易于计算，可以用 ANSI (SQL:2008) 标准 SQL 表示，如下所示：
```
SELECT STREAM ticker,
avg(price) OVER lastHour AS avgPrice,
max(price) OVER lastHour AS maxPrice
FROM Bids
WINDOW lastHour AS (
PARTITION BY ticker
RANGE INTERVAL '1' HOUR PRECEDING)
```
##
**注意**
`Interval_clause` 必须属于以下合适的类型之一：
包含 ROWS 的整数文字
数字列上的 RANGE 的数字值
范围超过 a 的间隔 date/time/timestamp
# AVG
从窗口式查询返回一组值的平均值。根据时间或行定义窗口式查询。有关窗口式查询的信息，请参阅[窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)。要返回在指定时间窗口内选择的值表达式的流的指数加权平均值，请参阅 [EXP\$1AVG](sql-reference-exp-avg.md)。
在使用 AVG 时，请注意以下事项：
+ 如果您未使用 `OVER` 子句，则 `AVG` 将作为聚合函数进行计算。在这种情况下，聚合查询必须根据将流分组到有限行中的 `ROWTIME` 在单调表达式中包含 [GROUP BY 子句](sql-reference-group-by-clause.md)。否则，组将是无限流，并且查询永远无法完成，也不会输出任何行。有关更多信息，请参阅 [聚合函数](sql-reference-aggregate-functions.md)。
+ 使用 GROUP BY 子句的窗口式查询在滚动窗口中处理行。有关更多信息，请参阅[滚动窗口（使用 GROUP BY 的聚合）](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
+ 如果您使用 `OVER` 子句，则 `AVG` 将作为分析函数进行计算。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
+ 使用 OVER 子句的窗口式查询在滑动窗口中处理行。有关更多信息，请参阅[滑动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/sliding-window-concepts.html)
## 语法
### 滚动窗口式查询
```
AVG(number-expression) ... GROUP BY monotonic-expression | time-based-expression
```
### 滑动窗口式查询
```
AVG([DISTINCT | ALL] number-expression) OVER window-specification
```
## 参数
DISTINCT
仅对值的每个唯一实例执行聚合函数。
ALL
对所有值执行聚合函数。`ALL` 为默认值。
*number-expression*
指定针对聚合中的每一行计算的值表达式。
OVER *window-specification*
划分流中按时间范围间隔或行数分区的记录。窗口规范定义流中记录的划分方式 (按时间范围间隔或行数)。
按*单调*表达式分组 \$1 *time-based-expression*
基于分组表达式的值为记录分组，从而针对在所有列中具有相同值的每组行返回一个摘要行。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：使用 GROUP BY 子句返回平均值
在此示例中，聚合查询在 `ROWTIME` 上有一个 `GROUP BY` 子句，可将流分组到有限行中。随后，从 `AVG` 子句返回的行计算 `GROUP BY` 函数。
#### 使用 STEP（推荐）
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
avg_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
AVG(price) AS avg_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol,
STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND);
```
#### 使用 FLOOR
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
avg_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
AVG(price) AS avg_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol,
FLOOR("SOURCE_SQL_STREAM_001".ROWTIME TO MINUTE);
```
#### 结果
上一示例输出的流与以下内容类似。
![\[Table showing stock ticker symbols NFS, WAS, PPL, ALY with corresponding dates and average prices.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-avg-example-1.png)
### 示例 2：使用 OVER 子句返回平均值
在此示例中，`OVER` 子句划分流中按之前“1”小时的时间范围间隔分区的记录。随后，从 `AVG` 子句返回的行计算 `OVER` 函数。
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
avg_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM ticker_symbol,
AVG(price) OVER (
PARTITION BY ticker_symbol
RANGE INTERVAL '1' HOUR PRECEDING) AS avg_price
FROM "SOURCE_SQL_STREAM_001"
```
上一示例输出的流与以下内容类似。
![\[Table showing stock data with columns for timestamp, ticker symbol, and average price.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-avg-example-2.png)
## 使用说明
Amazon Kinesis Analytics 不支持应用于间隔类型的 `AVG`。此功能偏离了 SQL:2008 标准。
当用作分析函数时，如果所计算的窗口不包含任何行，或者所有行均包含 null 值，则 `AVG` 将返回 null。有关更多信息，请参阅[分析函数](sql-reference-analytic-functions.md)。AVG 还为 `PARTITION BY` 子句返回 null，在这种情况下，窗口中匹配输入行的分区不包含任何行或所有行均为 null。有关 `PARTITION BY`的更多信息，请参阅[WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)。
`AVG` 会忽略来自值集或数字表达式的 null 值。例如，以下各项返回值 2：
+ AVG(1, 2, 3) = 2
+ AVG(1,null, 2, null, 3, null) = 2
## 相关主题
+ [窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)
+ [EXP\$1AVG](sql-reference-exp-avg.md)
+ [聚合函数](sql-reference-aggregate-functions.md)
+ [GROUP BY 子句](sql-reference-group-by-clause.md)
+ [分析函数](sql-reference-analytic-functions.md)
+ [入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)
+ [WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)
# COUNT
从窗口式查询返回一组值的限定行的数目。根据时间或行定义窗口式查询。有关窗口式查询的信息，请参阅[窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)。
在使用 COUNT 时，请注意以下事项：
+ 如果您未使用 `OVER` 子句，则 `COUNT` 将作为聚合函数进行计算。在这种情况下，聚合查询必须根据将流分组到有限行中的 `ROWTIME` 在单调表达式中包含 [GROUP BY 子句](sql-reference-group-by-clause.md)。否则，组将是无限流，并且查询永远无法完成，也不会输出任何行。有关更多信息，请参阅 [聚合函数](sql-reference-aggregate-functions.md)。
+ 使用 GROUP BY 子句的窗口式查询在滚动窗口中处理行。有关更多信息，请参阅[滚动窗口（使用 GROUP BY 的聚合）](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
+ 如果您使用 `OVER` 子句，则 `COUNT` 将作为分析函数进行计算。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
+ 使用 OVER 子句的窗口式查询在滑动窗口中处理行。有关更多信息，请参阅[滑动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/sliding-window-concepts.html)
## 语法
### 滚动窗口式查询
```
COUNT(number-expression) ... GROUP BY monotonic-expression | time-based-expression
```
### 滑动窗口式查询
```
COUNT(* | ALL number-expression) OVER window-specification
```
## 参数
\$1
对所有行进行计数。
ALL
计算所有行。`ALL` 是默认值。
*number-expression*
指定针对聚合中的每一行计算的值表达式。
OVER *window-specification*
划分流中按时间范围间隔或行数分区的记录。窗口规范定义流中记录的划分方式 (按时间范围间隔或行数)。
按*单调*表达式分组 \$1 *time-based-expression*
基于分组表达式的值为记录分组，从而针对在所有列中具有相同值的每组行返回一个摘要行。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：使用 GROUP BY 子句返回值的数目
在此示例中，聚合查询在 `ROWTIME` 上有一个 `GROUP BY` 子句，可将流分组到有限行中。随后，从 `COUNT` 子句返回的行计算 `GROUP BY` 函数。
#### 使用 STEP（推荐）
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
count_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
COUNT(Price) AS count_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND);
```
#### 使用 FLOOR
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
count_price DOUBLE);
-- CREATE OR REPLACE PUMP to insert into output
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
COUNT(Price) AS count_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, FLOOR("SOURCE_SQL_STREAM_001".ROWTIME TO MINUTE);
```
#### 结果
上一示例输出的流与以下内容类似。
![\[Table showing stock ticker symbols and prices for AAPL, WSB, and UHN at specific times.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-count-example-1.png)
### 示例 2：使用 OVER 子句返回值的数目
在此示例中，`OVER` 子句划分流中按之前“1”小时的时间范围间隔分区的记录。随后，从 `COUNT` 子句返回的行计算 `OVER` 函数。
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
count_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM ticker_symbol,
COUNT(price) OVER (
PARTITION BY ticker_symbol
RANGE INTERVAL '1' HOUR PRECEDING) AS count_price
FROM "SOURCE_SQL_STREAM_001"
```
上一示例输出的流与以下内容类似。
![\[Table showing timestamp, stock ticker symbols, and prices for four different stocks.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-count-example-2.png)
## 使用说明
Amazon Kinesis Analytics 不支持 `COUNT` 函数的 `FILTER` 子句，也不支持在聚合函数或分析函数中使用 `COUNT DISTINCT`。有关聚合函数和分析函数的更多信息，请参阅[聚合函数](sql-reference-aggregate-functions.md)和[分析函数](sql-reference-analytic-functions.md)。此功能偏离了 SQL:2008 标准。
在用作分析函数时，`COUNT` 将在所计算的窗口不包含任何行时返回零。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。COUNT 还为 `PARTITION BY` 子句返回零，在这种情况下，窗口中匹配输入行的分区不包含任何行。有关 `PARTITION BY`的更多信息，请参阅[WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)。
`COUNT` 会忽略来自值集或数字表达式的 null 值。例如，以下各项返回值 3：
+ COUNT(1, 2, 3) = 3
+ COUNT(1,null, 2, null, 3, null) = 3
## 相关主题
+ [窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)
+ [聚合函数](sql-reference-aggregate-functions.md)
+ [GROUP BY 子句](sql-reference-group-by-clause.md)
+ [分析函数](sql-reference-analytic-functions.md)
+ [入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)
+ [WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)
# COUNT\$1DISTINCT\$1ITEMS\$1TUMBLING 函数
返回滚动窗口上指定的应用程序内流列中不同项目数量的计数。结果计数为近似值；该函数使用 HyperLogLog 算法。
有关更多信息，请参阅 [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog)。
在使用 `COUNT_DISTINCT_ITEMS_TUMBLING` 时，请注意以下事项：
+ 当窗口中的项目数小于或等于 10000 时，此函数将返回准确计数。
+ 准确计数不同项目可能效率低下且成本高昂。因此，此函数估算计数。例如，如果有 100000 个不同的项目，则该算法可能会返回 99700 个。如果不考虑成本和效率，您可以自行编写 SELECT 语句以获取准确计数。
以下示例演示了如何在一个五秒的滚动窗口中获取每个股票代码的不同行的准确计数。SELECT 语句使用所有列（ROWTIME 除外）来确定唯一性。
```
CREATE OR REPLACE STREAM output_stream (ticker_symbol VARCHAR(4), unique_count BIGINT);
CREATE OR REPLACE PUMP stream_pump AS
INSERT INTO output_stream
SELECT STREAM TICKER_SYMBOL, COUNT(distinct_stream.price) AS unique_count
FROM (
SELECT STREAM DISTINCT rowtime as window_time,
TICKER_SYMBOL,
CHANGE,
PRICE,
STEP((SOURCE_SQL_STREAM_001.rowtime) BY INTERVAL '5' SECOND)
FROM SOURCE_SQL_STREAM_001) as distinct_stream
GROUP BY TICKER_SYMBOL,
STEP((distinct_stream.window_time) BY INTERVAL '5' SECOND);
```
此函数在一个[滚动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)内运行。将滚动窗口的大小指定为参数。
## 语法
```
COUNT_DISTINCT_ITEMS_TUMBLING (
in-application-streamPointer,
'columnName',
windowSize
)
```
## 参数
以下各节介绍了这些参数。
### in-application-stream指针
使用此参数，您可以提供指向应用程序内流的指针。您可以使用 `CURSOR` 函数设置指针。例如，以下语句将设置指向 `InputStream` 的指针。
```
CURSOR(SELECT STREAM * FROM InputStream)
```
### columnName
应用程序内流中您希望函数用来计数不同值的列名称。请注意有关列名称的以下内容：
+ 必须用单引号 (') 括起来。例如 `'column1'`。
### windowSize
滚动窗口的大小，以秒为单位。大小应至少为 1 秒，且不应超过 1 小时 = 3600 秒。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：粗略估计列中的唯一值的数量
以下示例演示了如何使用 `COUNT_DISTINCT_ITEMS_TUMBLING` 函数估算应用程序内流的当前滚动窗口中的不同 `TICKER_SYMBOL` 值的数目。有关滚动窗口的更多信息，请参阅[滚动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
```
CREATE OR REPLACE STREAM DESTINATION_SQL_STREAM (
NUMBER_OF_DISTINCT_ITEMS BIGINT);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM *
FROM TABLE(COUNT_DISTINCT_ITEMS_TUMBLING(
CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001"), -- pointer to the data stream
'TICKER_SYMBOL', -- name of column in single quotes
60 -- tumbling window size in seconds
)
);
```
上一示例输出的流与以下内容类似：
![\[Table showing ROWTIME and NUMBER_OF_DISTINCT_ITEMS columns with four identical entries.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-count-distinct-example-1.png)
# EXP\$1AVG
```
EXP_AVG ( expression, )
```
EXP\$1AVG 返回在指定时间窗口内选择的值表达式的流的指数加权的平均值（[指数移动平均值](https://en.wikipedia.org/wiki/Moving_average)）。EXP\$1AVG 基于 的值将指定窗口分成若干个时间间隔。对于最近的时间间隔，指定表达式的值的权重最大，而对于较早的间隔，权重则呈指数级降低。
## 示例
此示例创建了 30 秒窗口内每个股票代码价格的指数加权平均值，因此最近 10 秒子窗口中（该股票代码对应的）价格的权重是中间 10 秒子窗口中价格权重的两倍，是最早的 10 秒子窗口中价格权重的四倍。
```
select stream t.rowtime, ticker, price,
exp_avg(price, INTERVAL '10' SECOND) over w as avgPrice
from t
window w as (partition by ticker range interval '30' second preceding);
```
在此示例中，10 秒是衰减函数的半衰期，也就是说，应用于平均价格的权重下降两倍的时间段。换句话说，较早的权重是较近的权重的一半。在调用 EXP\$1AVG 时，time\$1interval 被指定为 interval '10' second。
# FIRST\$1VALUE
```
FIRST_VALUE( ) OVER
```
FIRST\$1VALUE 从有资格聚合的第一行中返回 的评估。FIRST\$1VALUE 需要使用 OVER 子句，因此被视为[分析函数](sql-reference-analytic-functions.md)。FIRST\$1VALUE 有一个 null 处理选项，定义在下表中。
| Null 处理选项 | 效果 |
| --- | --- |
| FIRST\$1VALUE(x) IGNORE NULLS OVER | 返回 中 x 的首个非 null 值 |
| FIRST\$1VALUE(x) RESPECT NULLS OVER | 返回第一个值，包括 中 x 的 null 值 |
| FIRST\$1VALUE(x) OVER | 返回第一个值，包括 中 x 的 null 值 |
# LAST\$1VALUE
```
LAST_VALUE ( ) OVER
```
LAST\$1VALUE 从有资格聚合的最后一行中返回 的计算。
| Null 处理选项 | 效果 |
| --- | --- |
| LAST\$1VALUE(x) IGNORE NULLS OVER | 返回 中 x 的最后一个非 null 值 |
| LAST\$1VALUE(x) RESPECT NULLS OVER | 返回最后一个值，包括 中 x 的 null 值 |
| LAST\$1VALUE(x) OVER | 返回最后一个值，包括 中 x 的 null 值 |
# MAX
从窗口式查询返回一组值的最大值。根据时间或行定义窗口式查询。有关窗口查询的信息，请参阅[窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)。
在使用 MAX 时，请注意以下事项：
+ 如果您未使用 `OVER` 子句，则 `MAX` 将作为聚合函数进行计算。在这种情况下，聚合查询必须根据将流分组到有限行中的 `ROWTIME` 在单调表达式中包含 [GROUP BY 子句](sql-reference-group-by-clause.md)。否则，组将是无限流，并且查询永远无法完成，也不会输出任何行。有关更多信息，请参阅 [聚合函数](sql-reference-aggregate-functions.md)。
+ 使用 GROUP BY 子句的窗口式查询在滚动窗口中处理行。有关更多信息，请参阅[滚动窗口（使用 GROUP BY 的聚合）](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
+ 如果您使用 `OVER` 子句，则 `MAX` 将作为分析函数进行计算。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
+ 使用 OVER 子句的窗口式查询在滑动窗口中处理行。有关更多信息，请参阅[滑动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/sliding-window-concepts.html)
## 语法
### 滚动窗口式查询
```
MAX(number-expression) ... GROUP BY monotonic-expression | time-based-expression
```
### 滑动窗口式查询
```
MAX(number-expression) OVER window-specification
```
## 参数
*number-expression*
指定针对聚合中的每一行计算的值表达式。
OVER *window-specification*
划分流中按时间范围间隔或行数分区的记录。窗口规范定义流中记录的划分方式 (按时间范围间隔或行数)。
按*单调*表达式分组 \$1 *time-based-expression*
基于分组表达式的值为记录分组，从而针对在所有列中具有相同值的每组行返回一个摘要行。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：使用 GROUP BY 子句返回最大值
在此示例中，聚合查询在 `ROWTIME` 上有一个 `GROUP BY` 子句，可将流分组到有限行中。随后，从 `MAX` 子句返回的行计算 `GROUP BY` 函数。
#### 使用 STEP（推荐）
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
max_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
MAX(Price) AS max_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND);
```
#### 使用 FLOOR
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
max_price DOUBLE);
-- CREATE OR REPLACE PUMP to insert into output
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
MAX(Price) AS max_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, FLOOR("SOURCE_SQL_STREAM_001".ROWTIME TO MINUTE);
```
#### 结果
上一示例输出的流与以下内容类似。
![\[Table showing ROWTIME, TICKER_SYMBOL, and MAX_PRICE columns with sample data entries.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-max-example-1.png)
### 示例 2：使用 OVER 子句返回最大值
在此示例中，`OVER` 子句划分流中按之前“1”小时的时间范围间隔分区的记录。随后，从 `MAX` 子句返回的行计算 `OVER` 函数。
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
max_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM ticker_symbol,
MAX(price) OVER (
PARTITION BY ticker_symbol
RANGE INTERVAL '1' HOUR PRECEDING) AS max_price
FROM "SOURCE_SQL_STREAM_001"
```
上一示例输出的流与以下内容类似。
![\[Table showing stock ticker symbols QAZ, QXZ, MJN, WSB with corresponding timestamps and maximum prices.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-max-example-2.png)
## 使用说明
对于字符串值，MAX 通过排序序列中的最后一个字符串来确定。
如果将 MAX 用作分析函数，并且所计算的窗口不包含任何行，则 MAX 将返回 null。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
## 相关主题
+ [窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)
+ [聚合函数](sql-reference-aggregate-functions.md)
+ [GROUP BY 子句](sql-reference-group-by-clause.md)
+ [分析函数](sql-reference-analytic-functions.md)
+ [入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)
+ [WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)
# MIN
从窗口式查询返回一组值的最小值。根据时间或行定义窗口式查询。有关窗口式查询的信息，请参阅[窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)。
在使用 MIN 时，请注意以下事项：
+ 如果您未使用 `OVER` 子句，则 `MIN` 将作为聚合函数进行计算。在这种情况下，聚合查询必须根据将流分组到有限行中的 `ROWTIME` 在单调表达式中包含 [GROUP BY 子句](sql-reference-group-by-clause.md)。否则，组将是无限流，并且查询永远无法完成，也不会输出任何行。有关更多信息，请参阅 [聚合函数](sql-reference-aggregate-functions.md)。
+ 使用 GROUP BY 子句的窗口式查询在滚动窗口中处理行。有关更多信息，请参阅[滚动窗口（使用 GROUP BY 的聚合）](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
+ 如果您使用 `OVER` 子句，则 `MIN` 将作为分析函数进行计算。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
+ 使用 OVER 子句的窗口式查询在滑动窗口中处理行。有关更多信息，请参阅[滑动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/sliding-window-concepts.html)
## 语法
### 滚动窗口式查询
```
MIN(number-expression) ... GROUP BY monotonic-expression | time-based-expression
```
### 滑动窗口式查询
```
MIN(number-expression) OVER window-specification
```
## 参数
*number-expression*
指定针对聚合中的每一行计算的值表达式。
OVER *window-specification*
划分流中按时间范围间隔或行数分区的记录。窗口规范定义流中记录的划分方式 (按时间范围间隔或行数)。
按*单调*表达式分组 \$1 *time-based-expression*
基于分组表达式的值为记录分组，从而针对在所有列中具有相同值的每组行返回一个摘要行。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：使用 GROUP BY 子句返回最小值
在此示例中，聚合查询在 `ROWTIME` 上有一个 `GROUP BY` 子句，可将流分组到有限行中。随后，从 `MIN` 子句返回的行计算 `GROUP BY` 函数。
#### 使用 STEP（推荐）
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
min_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
MIN(Price) AS min_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND);
```
#### 使用 FLOOR
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
min_price DOUBLE);
-- CREATE OR REPLACE PUMP to insert into output
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
MIN(Price) AS min_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, FLOOR("SOURCE_SQL_STREAM_001".ROWTIME TO MINUTE);
```
#### 结果
上一示例输出的流与以下内容类似。
![\[Table showing stock ticker symbols, timestamps, and minimum prices for four different stocks.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-min-example-1.png)
### 示例 2：使用 OVER 子句返回最小值
在此示例中，`OVER` 子句划分流中按之前“1”小时的时间范围间隔分区的记录。随后，从 `MIN` 子句返回的行计算 `OVER` 函数。
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
min_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM ticker_symbol,
MIN(price) OVER (
PARTITION BY ticker_symbol
RANGE INTERVAL '1' HOUR PRECEDING) AS min_price
FROM "SOURCE_SQL_STREAM_001"
```
上一示例输出的流与以下内容类似。
![\[Table showing stock ticker symbols and minimum prices for NFS, NFLX, ASD, and DFG on 2017-02-17.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-min-example-2.png)
## 使用说明
对于字符串值，MIN 通过排序序列中的最后一个字符串来确定。
如果将 MIN 用作分析函数，并且所计算的窗口不包含任何行，则 MIN 将返回 null。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
## 相关主题
+ [窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)
+ [聚合函数](sql-reference-aggregate-functions.md)
+ [GROUP BY 子句](sql-reference-group-by-clause.md)
+ [分析函数](sql-reference-analytic-functions.md)
+ [入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)
+ [WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)
# SUM
从窗口式查询返回一组值的和。根据时间或行定义窗口式查询。有关窗口式查询的信息，请参阅[窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)。
在使用 SUM 时，请注意以下事项：
+ 如果您未使用 `OVER` 子句，则 `SUM` 将作为聚合函数进行计算。在这种情况下，聚合查询必须根据将流分组到有限行中的 `ROWTIME` 在单调表达式中包含 [GROUP BY 子句](sql-reference-group-by-clause.md)。否则，组将是无限流，并且查询永远无法完成，也不会输出任何行。有关更多信息，请参阅 [聚合函数](sql-reference-aggregate-functions.md)。
+ 使用 GROUP BY 子句的窗口式查询在滚动窗口中处理行。有关更多信息，请参阅[滚动窗口（使用 GROUP BY 的聚合）](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)。
+ 如果您使用 `OVER` 子句，则 `SUM` 将作为分析函数进行计算。有关更多信息，请参阅 [分析函数](sql-reference-analytic-functions.md)。
+ 使用 OVER 子句的窗口式查询在滑动窗口中处理行。有关更多信息，请参阅[滑动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/sliding-window-concepts.html)
## 语法
### 滚动窗口式查询
```
SUM(number-expression) ... GROUP BY monotonic-expression | time-based-expression
```
### 滑动窗口式查询
```
SUM([DISTINCT | ALL] number-expression) OVER window-specification
```
## 参数
DISTINCT
仅对唯一值进行计数。
ALL
计算所有行。`ALL` 是默认值。
*number-expression*
指定针对聚合中的每一行计算的值表达式。
OVER *window-specification*
划分流中按时间范围间隔或行数分区的记录。窗口规范定义流中记录的划分方式 (按时间范围间隔或行数)。
按*单调*表达式分组 \$1 *time-based-expression*
基于分组表达式的值为记录分组，从而针对在所有列中具有相同值的每组行返回一个摘要行。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：使用 GROUP BY 子句返回值的和
在此示例中，聚合查询在 `ROWTIME` 上有一个 `GROUP BY` 子句，可将流分组到有限行中。随后，从 `SUM` 子句返回的行计算 `GROUP BY` 函数。
#### 使用 STEP（推荐）
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
sum_price DOUBLE);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
SUM(price) AS sum_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, STEP("SOURCE_SQL_STREAM_001".ROWTIME BY INTERVAL '60' SECOND);
```
#### 使用 FLOOR
```
CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (
ticker_symbol VARCHAR(4),
sum_price DOUBLE);
-- CREATE OR REPLACE PUMP to insert into output
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM
ticker_symbol,
SUM(price) AS sum_price
FROM "SOURCE_SQL_STREAM_001"
GROUP BY ticker_symbol, FLOOR("SOURCE_SQL_STREAM_001".ROWTIME TO MINUTE);
```
#### 结果
上一示例输出的流与以下内容类似。
![\[Table showing data stream with timestamp, ticker symbol, and sum price columns.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-sum-example-1.png)
## 使用说明
Amazon Kinesis Analytics 不支持应用于间隔类型的 `SUM`。此功能偏离了 SQL:2008 标准。
`SUM` 会忽略来自值集或数字表达式的 null 值。例如，以下各项返回值 6：
+ AVG(1, 2, 3) = 6
+ SUM(1,null, 2, null, 3, null) = 6
## 相关主题
+ [窗口式查询](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/windowed-sql.html)
+ [聚合函数](sql-reference-aggregate-functions.md)
+ [GROUP BY 子句](sql-reference-group-by-clause.md)
+ [分析函数](sql-reference-analytic-functions.md)
+ [入门练习](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)
+ [WINDOW 子句 (滑动窗口)](sql-reference-window-clause.md)
# TOP\$1K\$1ITEMS\$1TUMBLING 函数
在滚动窗口中返回指定的应用程序内流列中最常出现的值。这可用于在指定列中查找趋势（最热门）值。
例如，入门练习使用演示流来提供持续的股价更新（股票代码、价格、变动和其他列）。假设您想在每个 1 分钟的滚动窗口中找到交易最频繁的三只股票。您可以使用此函数来查找这些股票代码。
在使用 `TOP_K_ITEMS_TUMBLING` 时，请注意以下事项：
+ 计数流式来源上的每条传入记录效率不高，因此该函数将估算最常出现的值。例如，在寻找交易量最大的三只股票时，该函数可能会返回交易量最大的五只股票中的三只。
此函数在一个[滚动窗口](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/tumbling-window-concepts.html)内运行。您需要将窗口大小指定为参数。
有关包含 step-by-step说明的示例应用程序，请参阅[最常出现的值](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/top-k-example.html)。
## 语法
```
TOP_K_ITEMS_TUMBLING (
in-application-streamPointer,
'columnName',
K,
windowSize,
)
```
## 参数
以下各节介绍了这些参数。
### in-application-stream指针
指向应用程序内流的指针。您可以使用 CURSOR 函数设置指针。例如，以下语句将指针设置为 InputStream。
```
CURSOR(SELECT STREAM * FROM InputStream)
```
### columnName
应用程序内流中您希望用来计算 topK 值的列名称。请注意有关列名称的以下内容：
**注意**
列名称必须用单引号 (') 括起来。例如 `'column1'`。
### K
使用此参数，您可以指定希望从特定列中返回多少个最常出现的值。值 K 必须大于或等于 1 且不能超过 100000。
### windowSize
滚动窗口的大小，以秒为单位。大小必须大于或等于 1 秒，且不得超过 3600 秒 (1 小时)。
## 示例
### 示例数据集
以下示例基于样本股票数据集，后者是 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)的一部分。要运行每个示例，您需要一个具有样本股票代码输入流的 Amazon Kinesis Analytics 应用程序。要了解如何创建 Analytics 应用程序和配置样本股票代码输入流，请参阅 *Amazon Kinesis Analytics 开发人员指南*中的[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/get-started-exercise.html)。
具有以下架构的示例股票数据集。
```
(ticker_symbol VARCHAR(4),
sector VARCHAR(16),
change REAL,
price REAL)
```
### 示例 1：返回最常出现的值
以下示例在[入门](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/getting-started.html)教程中创建的示例流中检索最常出现的值。
```
CREATE OR REPLACE STREAM DESTINATION_SQL_STREAM (
"TICKER_SYMBOL" VARCHAR(4),
"MOST_FREQUENT_VALUES" BIGINT
);
CREATE OR REPLACE PUMP "STREAM_PUMP" AS
INSERT INTO "DESTINATION_SQL_STREAM"
SELECT STREAM *
FROM TABLE (TOP_K_ITEMS_TUMBLING(
CURSOR(SELECT STREAM * FROM "SOURCE_SQL_STREAM_001"),
'TICKER_SYMBOL', -- name of column in single quotes
5, -- number of the most frequently occurring values
60 -- tumbling window size in seconds
)
);
```
上一示例输出的流与以下内容类似。
![\[Table showing data stream with columns for timestamp, ticker symbol, and frequency values.\]](http://docs.aws.amazon.com/zh_cn/kinesisanalytics/latest/sqlref/images/sql-reference-topk-example-1.png)