InfluxQL 函数

此页面记录了 InfluxDB OSS 的早期版本。InfluxDB OSS v2 是最新的稳定版本。请参阅 InfluxDB v2 文档。

使用InfluxQL函数聚合、选择、转换和预测数据。

内容

聚合函数
选择器
变换
预测因素
- HOLT_WINTERS()
技术分析
其他

聚合

计数()

返回非空的字段值的数量。

语法

SELECT COUNT( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

嵌套语法

SELECT COUNT(DISTINCT( [ * | <field_key> | /<regular_expression>/ ] )) [...]

COUNT(field_key)
返回与字段键相关联的字段值的数量。

COUNT(/regular_expression/)
返回与每个字段键匹配的<а>正则表达式相关的字段值的数量。

COUNT(*)
返回与measurement中每个字段键相关联的字段值的数量。

COUNT() 支持所有字段值数据类型。 InfluxQL 支持将 DISTINCT() 嵌套在 COUNT() 中。

示例

计算与字段键关联的字段值

> SELECT COUNT("water_level") FROM "h2o_feet"

name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   15258

查询返回h2o_feet测量中water_level字段键的非空字段值的数量。

计算测量中每个字段键相关联的字段值

> SELECT COUNT(*) FROM "h2o_feet"

name: h2o_feet
time                   count_level description   count_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   15258                     15258

查询返回与h2o_feet测量相关的每个字段键的非空字段值的数量。h2o_feet测量有两个字段键：level description和water_level。

统计与每个字段键匹配正则表达式的字段值数量

> SELECT COUNT(/water/) FROM "h2o_feet"

name: h2o_feet
time                   count_water_level
----                   -----------------
1970-01-01T00:00:00Z   15258

查询返回每个字段键的非空字段值的数量，字段键中包含单词 water 在 h2o_feet 测量中。

计算与字段键相关的字段值并包含多个条件

> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(200) LIMIT 7 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   count
----                   -----
2015-08-17T23:48:00Z   200
2015-08-18T00:00:00Z   2
2015-08-18T00:12:00Z   2
2015-08-18T00:24:00Z   2
2015-08-18T00:36:00Z   2
2015-08-18T00:48:00Z   2

该查询返回 water_level 字段键中非空字段值的数量。它覆盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并且将结果分组到 12 分钟的时间间隔和每个标签。该查询填充空的时间间隔为 200 并且限制返回的点和序列的数量为七和一个。

统计与字段键相关联的不同字段值

> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"

name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   4

查询返回 level description 字段键和 h2o_feet 测量的唯一字段值的数量。

COUNT() 的常见问题

COUNT() 和 fill()

大多数 InfluxQL 函数报告 null 值表示没有数据的时间间隔，和 fill() 用 fill_option 替换该 null 值。 COUNT() 在没有数据的时间间隔报告 0，而 fill() 用 fill_option 替换任何 0 值。

示例

下面代码块中的第一个查询不包含 fill()。最后一个时间间隔没有数据，因此该时间间隔报告的值为零。第二个查询包含 fill(800000)；它用 800000 替换了最后一个时间间隔中的零。

> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m)

name: h2o_feet
time                   count
----                   -----
2015-09-18T21:24:00Z   2
2015-09-18T21:36:00Z   2
2015-09-18T21:48:00Z   0

> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m) fill(800000)

name: h2o_feet
time                   count
----                   -----
2015-09-18T21:24:00Z   2
2015-09-18T21:36:00Z   2
2015-09-18T21:48:00Z   800000

不重复()

返回唯一的字段值列表。

语法

SELECT DISTINCT( [ <field_key> | /<regular_expression>/ ] ) FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

嵌套语法

SELECT COUNT(DISTINCT( [ <field_key> | /<regular_expression>/ ] )) [...]

DISTINCT(field_key)
返回与 field key 相关联的唯一字段值。

DISTINCT() 支持所有字段值数据类型。 InfluxQL 支持将 DISTINCT() 嵌套在 COUNT() 中。

示例

列出与字段键相关的不同字段值

> SELECT DISTINCT("level description") FROM "h2o_feet"

name: h2o_feet
time                   distinct
----                   --------
1970-01-01T00:00:00Z   between 6 and 9 feet
1970-01-01T00:00:00Z   below 3 feet
1970-01-01T00:00:00Z   between 3 and 6 feet
1970-01-01T00:00:00Z   at or greater than 9 feet

查询返回在 h2o_feet 测量的 level description 字段键中的唯一字段值的表格列表。

列出与测量中每个字段键关联的不同字段值

> SELECT DISTINCT(*) FROM "h2o_feet"

name: h2o_feet
time                   distinct_level description   distinct_water_level
----                   --------------------------   --------------------
1970-01-01T00:00:00Z   between 6 and 9 feet         8.12
1970-01-01T00:00:00Z   between 3 and 6 feet         8.005
1970-01-01T00:00:00Z   at or greater than 9 feet    7.887
1970-01-01T00:00:00Z   below 3 feet                 7.762
[...]

查询返回每个字段键的唯一字段值的表格列表，来自于h2o_feet测量。 h2o_feet测量有两个字段键：level description和water_level。

列出与字段键相关的不同字段值并包含几个子句

>  SELECT DISTINCT("level description") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   distinct
----                   --------
2015-08-18T00:00:00Z   between 6 and 9 feet
2015-08-18T00:12:00Z   between 6 and 9 feet
2015-08-18T00:24:00Z   between 6 and 9 feet
2015-08-18T00:36:00Z   between 6 and 9 feet
2015-08-18T00:48:00Z   between 6 and 9 feet

查询返回level description字段键中唯一字段值的表格列表。它涵盖了时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将结果分组为每个标签的12分钟时间间隔。查询还限制返回的系列数量为一个。

统计与字段键相关联的不同字段值

> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"

name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   4

该查询返回 level description 字段键和 h2o_feet 测量中的唯一字段值的数量。

DISTINCT() 常见问题

DISTINCT() 和 INTO 子句

使用 DISTINCT() 和 INTO 子句可能会导致 InfluxDB 覆盖目标测量中的点。DISTINCT() 通常返回几个具有相同时间戳的结果；InfluxDB 假设具有相同 series 和时间戳的 points 是重复点，并简单地用目标测量中的最新点覆盖任何重复点。

示例

下面代码块中的第一个查询使用了 DISTINCT() 函数，并返回四个结果。注意每个结果都有相同的时间戳。第二个查询在初始查询中添加了 INTO 子句，并将查询结果写入 distincts 测量值。代码块中的最后一个查询选择了 distincts 测量值中的所有数据。

最后的查询返回一个点，因为前四个初始结果是重复的点；它们属于同一系列并具有相同的时间戳。当系统遇到重复的点时，它只会用最新的点覆盖先前的点。

>  SELECT DISTINCT("level description") FROM "h2o_feet"

name: h2o_feet
time                   distinct
----                   --------
1970-01-01T00:00:00Z   below 3 feet
1970-01-01T00:00:00Z   between 6 and 9 feet
1970-01-01T00:00:00Z   between 3 and 6 feet
1970-01-01T00:00:00Z   at or greater than 9 feet

>  SELECT DISTINCT("level description") INTO "distincts" FROM "h2o_feet"

name: result
time                   written
----                   -------
1970-01-01T00:00:00Z   4

> SELECT * FROM "distincts"

name: distincts
time                   distinct
----                   --------
1970-01-01T00:00:00Z   at or greater than 9 feet

积分()

返回后续字段值下的曲线面积。

语法

SELECT INTEGRAL( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ]  ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

InfluxDB 计算后续字段值的曲线下面积，并将这些结果转换为每个 unit 的总面积。 unit 参数是一个整数，后跟一个 duration literal，是可选的。如果查询没有指定 unit，则单位默认为一秒 (1s)。

INTEGRAL(field_key)
返回与字段键相关联的后续字段值下的曲线下的面积。

INTEGRAL(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的后续字段值下的曲线面积。

INTEGRAL(*)
返回与测量中每个字段键相关联的平均字段值。

INTEGRAL() 不支持 fill()。INTEGRAL() 支持 int64 和 float64 字段值数据类型。

示例

示例 1-5 使用以下的 NOAA_water_database 数据子样本：

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028
2015-08-18T00:18:00Z   2.126
2015-08-18T00:24:00Z   2.041
2015-08-18T00:30:00Z   2.051

计算与字段键相关的字段值的积分

> SELECT INTEGRAL("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                 integral
----                 --------
1970-01-01T00:00:00Z 3732.66

查询返回与water_level字段键相关的字段值在h2o_feet测量中的曲线下面积（以秒为单位）。

计算与字段键相关的字段值的积分，并指定单位选项

> SELECT INTEGRAL("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                 integral
----                 --------
1970-01-01T00:00:00Z 62.211

该查询返回与 water_level 字段键相关的字段值在 h2o_feet 测量中的曲线下的面积（以分钟为单位）。

计算与测量中每个字段键相关联的字段值的积分并指定单位选项

> SELECT INTEGRAL(*,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                 integral_water_level
----                 --------------------
1970-01-01T00:00:00Z 62.211

该查询返回与每个存储数值的字段键相关联的字段值下的曲线面积（以分钟为单位）。 h2o_feet 测量具有一个数值字段：water_level。

计算与每个字段键匹配的正则表达式相关的字段值的积分，并指定单位选项

> SELECT INTEGRAL(/water/,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                 integral_water_level
----                 --------------------
1970-01-01T00:00:00Z 62.211

查询返回与存储数值的每个字段键相关的字段值下的曲线面积（以分钟为单位），该字段值包含在h2o_feet测量中的单词water。

计算与字段键相关的字段值的积分，并包含多个子句

> SELECT INTEGRAL("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m) LIMIT 1

name: h2o_feet
time                 integral
----                 --------
2015-08-18T00:00:00Z 24.972

查询返回与water_level字段关键字和h2o_feet测量相关的曲线下方的面积（以分钟为单位）。它覆盖了时间范围从2015-08-18T00:00:00Z到2015-08-18T00:30:00Z，将结果分组为12分钟的间隔，并且限制返回的结果数量为一个。

均值()

返回字段值的算术平均值（平均数）。

语法

SELECT MEAN( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MEAN(field_key)
返回与字段键相关联的平均字段值。

MEAN(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的平均字段值。

MEAN(*)
返回与measurement中每个字段键相关联的平均字段值。

MEAN() 支持 int64 和 float64 字段值数据类型。

示例

计算与字段键相关的均值字段值

> SELECT MEAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.442107025822522

查询返回在 h2o_feet 测量中 water_level 字段键的平均字段值。

计算与测量中每个字段键相关的均值字段值

> SELECT MEAN(*) FROM "h2o_feet"

name: h2o_feet
time                   mean_water_level
----                   ----------------
1970-01-01T00:00:00Z   4.442107025822522

该查询返回 h2o_feet 测量中每个存储数值的字段键的平均字段值。h2o_feet 测量有一个数值字段： water_level。

计算与每个字段键关联的平均场值，该字段键与正则表达式匹配

> SELECT MEAN(/water/) FROM "h2o_feet"

name: h2o_feet
time                   mean_water_level
----                   ----------------
1970-01-01T00:00:00Z   4.442107025822523

查询返回每个存储数值的字段键的平均字段值，这些字段键在h2o_feet测量中包含单词water。

计算与字段键相关的均值场值并包括多个子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 7 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-17T23:48:00Z   9.01
2015-08-18T00:00:00Z   8.0625
2015-08-18T00:12:00Z   7.8245
2015-08-18T00:24:00Z   7.5675
2015-08-18T00:36:00Z   7.303
2015-08-18T00:48:00Z   7.046

查询返回 water_level 字段键值的平均值。它覆盖了时间范围在 2015-08-17T23:48:00Z 和 2015-08-18T00:54:00Z 之间，并且将结果分组为每12分钟的时间间隔和每个标签。查询填充空的时间间隔为 9.01 并且限制返回的点和序列的数量为七个和一个。

中位数()

从排序后的字段值列表中返回中间值。

语法

SELECT MEDIAN( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MEDIAN(field_key)
返回与字段键相关联的中间字段值。

MEDIAN(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的中间字段值。

MEDIAN(*)
返回与每个字段键关联的中间字段值，在测量中。

MEDIAN() 支持 int64 和 float64 字段值数据类型。

注意： MEDIAN() 几乎等同于 PERCENTILE(field_key, 50)，除了 MEDIAN() 如果字段包含偶数个值，则返回中间两个字段值的平均值。

示例

计算与字段键相关联的中位数字段值

> SELECT MEDIAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                   median
----                   ------
1970-01-01T00:00:00Z   4.124

查询返回 water_level 字段键中的中间字段值，以及 h2o_feet 测量值。

计算与测量中每个字段键相关的中位数字段值

> SELECT MEDIAN(*) FROM "h2o_feet"

name: h2o_feet
time                   median_water_level
----                   ------------------
1970-01-01T00:00:00Z   4.124

该查询返回在 h2o_feet 测量中存储数值的每个字段键的中间字段值。 h2o_feet 测量有一个数值字段： water_level。

计算与每个字段键匹配正则表达式的中位数字段值

> SELECT MEDIAN(/water/) FROM "h2o_feet"

name: h2o_feet
time                   median_water_level
----                   ------------------
1970-01-01T00:00:00Z   4.124

该查询返回每个存储数值的字段键的中间字段值，并且在h2o_feet测量中包含单词water。

计算与字段键相关联的中位数字段值并包含多个子句

> SELECT MEDIAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(700) LIMIT 7 SLIMIT 1 SOFFSET 1

name: h2o_feet
tags: location=santa_monica
time                   median
----                   ------
2015-08-17T23:48:00Z   700
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003
2015-08-18T00:36:00Z   2.0620000000000003
2015-08-18T00:48:00Z   700

该查询返回water_level字段键的中间字段值。它覆盖了时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并且将结果分组为每标签的12分钟时间间隔。该查询填充空的时间间隔为700 ，限制返回的点和序列的数量为七和一个，偏移返回的序列为一个。

模式()

返回列表中最常见的字段值。

语法

SELECT MODE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MODE(field_key)
返回与字段键相关联的最频繁字段值。

MODE(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的最常见字段值。

MODE(*)
返回与每个字段键关联的最频繁字段值，位于测量中。

MODE() 支持所有字段值数据类型。

注意： MODE() 如果存在两个或更多值的最大出现次数相同，则返回具有最早时间戳的字段值。

示例

计算与字段键关联的众数字段值

> SELECT MODE("level description") FROM "h2o_feet"

name: h2o_feet
time                   mode
----                   ----
1970-01-01T00:00:00Z   between 3 and 6 feet

查询返回level description字段键和h2o_feet测量中最常见的字段值。

计算与测量中每个字段键相关联的众数字段值

> SELECT MODE(*) FROM "h2o_feet"

name: h2o_feet
time                   mode_level description   mode_water_level
----                   ----------------------   ----------------
1970-01-01T00:00:00Z   between 3 and 6 feet     2.69

查询返回每个字段键的最常见字段值在 h2o_feet 测量中。 h2o_feet 测量有两个字段键： level description 和 water_level。

计算与匹配正则表达式的每个字段键相关联的众数字段值

> SELECT MODE(/water/) FROM "h2o_feet"

name: h2o_feet
time                   mode_water_level
----                   ----------------
1970-01-01T00:00:00Z   2.69

查询返回每个字段键中包含单词 /water/ 的 h2o_feet 测量的最常见字段值。

计算与字段键相关的众数字段值并包含多个条件

> SELECT MODE("level description") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* LIMIT 3 SLIMIT 1 SOFFSET 1

name: h2o_feet
tags: location=santa_monica
time                   mode
----                   ----
2015-08-17T23:48:00Z
2015-08-18T00:00:00Z   below 3 feet
2015-08-18T00:12:00Z   below 3 feet

查询返回与 water_level 字段键相关的值的众数。它涵盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并将结果分组为 12 分钟的时间间隔和每个标签。查询限制返回的点和序列的数量为三个和一个，并且它偏移返回的序列为一个。

SPREAD()

返回最小值和最大值之间的差异 field values。

语法

SELECT SPREAD( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

SPREAD(field_key)
返回与字段键关联的最小和最大字段值之间的差异。

SPREAD(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的最小和最大字段值之间的差异。

SPREAD(*)
返回与每个字段键相关联的最小和最大字段值之间的差异，位于测量中。

SPREAD() 支持 int64 和 float64 字段值数据类型。

示例

计算与字段键相关的字段值的差异

> SELECT SPREAD("water_level") FROM "h2o_feet"

name: h2o_feet
time                   spread
----                   ------
1970-01-01T00:00:00Z   10.574

查询返回water_level字段键和h2o_feet测量中最小值和最大值之间的差异。

计算与测量中每个字段键关联的字段值的差异

> SELECT SPREAD(*) FROM "h2o_feet"

name: h2o_feet
time                   spread_water_level
----                   ------------------
1970-01-01T00:00:00Z   10.574

查询返回每个存储数值的字段键的最小值和最大值之间的差异，针对h2o_feet测量。 h2o_feet测量具有一个数值字段：water_level。

计算与每个字段键匹配正则表达式的字段值的差异

> SELECT SPREAD(/water/) FROM "h2o_feet"

name: h2o_feet
time                   spread_water_level
----                   ------------------
1970-01-01T00:00:00Z   10.574

查询返回每个存储数值并在h2o_feet测量中包含单词water的字段键的最小值和最大值之间的差异。

计算与字段键相关的字段值的差异并包括多个子句

> SELECT SPREAD("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18) LIMIT 3 SLIMIT 1 SOFFSET 1

name: h2o_feet
tags: location=santa_monica
time                   spread
----                   ------
2015-08-17T23:48:00Z   18
2015-08-18T00:00:00Z   0.052000000000000046
2015-08-18T00:12:00Z   0.09799999999999986

该查询返回 water_level 字段键中最小值和最大值之间的差异。它涵盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z ，并将结果分组为每个标签每12分钟的时间间隔。该查询填充空的时间间隔为 18，限制返回的点和系列的数量为三和一，并偏移返回的系列为一。

标准差()

返回字段值的标准差。

语法

SELECT STDDEV( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

STDDEV(field_key)
返回与字段键相关的字段值的标准差。

STDDEV(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的字段值的标准差。

STDDEV(*)
返回与measurement中每个字段键相关的字段值的标准差。

STDDEV() 支持 int64 和 float64 字段值数据类型。

示例

计算与字段键相关的字段值的标准偏差

> SELECT STDDEV("water_level") FROM "h2o_feet"

name: h2o_feet
time                   stddev
----                   ------
1970-01-01T00:00:00Z   2.279144584196141

查询返回 water_level 字段键和 h2o_feet 测量中字段值的标准差。

计算测量中与每个字段键关联的字段值的标准差

> SELECT STDDEV(*) FROM "h2o_feet"

name: h2o_feet
time                   stddev_water_level
----                   ------------------
1970-01-01T00:00:00Z   2.279144584196141

查询返回每个字段键存储在h2o_feet测量中的数值字段值的标准差。 h2o_feet测量有一个数值字段：water_level。

计算与每个字段键匹配正则表达式的字段值的标准差

> SELECT STDDEV(/water/) FROM "h2o_feet"

name: h2o_feet
time                   stddev_water_level
----                   ------------------
1970-01-01T00:00:00Z   2.279144584196141

该查询返回每个存储数值并在h2o_feet度量中包含单词water的字段键的字段值的标准偏差。

计算与字段键关联的字段值的标准偏差并包含多个子句

> SELECT STDDEV("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18000) LIMIT 2 SLIMIT 1 SOFFSET 1

name: h2o_feet
tags: location=santa_monica
time                   stddev
----                   ------
2015-08-17T23:48:00Z   18000
2015-08-18T00:00:00Z   0.03676955262170051

查询返回water_level字段值的标准差。它涵盖了时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将结果分组为12分钟的时间间隔和每个标签。查询填充了空的时间间隔，以18000填充，限制返回的点和系列的数量为两个和一个，并且偏移返回的系列为一个。

求和()

返回字段值的总和。

语法

SELECT SUM( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

SUM(field_key)
返回与字段键相关的字段值的总和。

SUM(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的字段值的总和。

SUM(*)
返回与measurement中每个字段键相关联的字段值的总和。

SUM() 支持 int64 和 float64 字段值数据类型。

示例

计算与字段键相关联的字段值的总和

> SELECT SUM("water_level") FROM "h2o_feet"

name: h2o_feet
time                   sum
----                   ---
1970-01-01T00:00:00Z   67777.66900000004

该查询返回water_level字段键和h2o_feet测量中的字段值的总和。

计算测量中与每个字段键相关联的字段值的总和

> SELECT SUM(*) FROM "h2o_feet"

name: h2o_feet
time                   sum_water_level
----                   ---------------
1970-01-01T00:00:00Z   67777.66900000004

查询返回每个存储数值的字段键的字段值总和，计算在h2o_feet测量中。 h2o_feet测量有一个数值字段：water_level。

计算与每个字段键匹配的正则表达式相关联的字段值的总和

> SELECT SUM(/water/) FROM "h2o_feet"

name: h2o_feet
time                   sum_water_level
----                   ---------------
1970-01-01T00:00:00Z   67777.66900000004

查询返回存储数字值并在h2o_feet测量中包含单词water的每个字段键的字段值的总和。

计算与字段键关联的字段值的总和并包括几个子句

> SELECT SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18000) LIMIT 4 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   sum
----                   ---
2015-08-17T23:48:00Z   18000
2015-08-18T00:00:00Z   16.125
2015-08-18T00:12:00Z   15.649
2015-08-18T00:24:00Z   15.135

该查询返回water_level字段键中字段值的总和。它涵盖了时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并且将结果分组为12分钟的时间间隔和每个标签。该查询用18000填充空的时间间隔，并且限制返回的点和系列数量为四和一个。

选择器

底部()

返回最小的 N 字段值。

语法

SELECT BOTTOM(<field_key>[,<tag_key(s)>],<N> )[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

BOTTOM(field_key,N)
返回与字段键相关联的最小的N个字段值。

BOTTOM(field_key,tag_key(s),N)
返回tag key的N个标签值中的最小字段值。

BOTTOM(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键相关的最小的N个字段值以及相关的tag和/或field。

BOTTOM() 支持 int64 和 float64 字段值数据类型。

注意：

BOTTOM() 如果在多个值中存在最小值的平局，则返回时间戳最早的字段值。
BOTTOM() 在与一个 INTO 子句相结合时，与其他 InfluxQL 函数不同。有关更多信息，请参见常见问题部分。

示例

选择与字段键相关的底部三个字段值

> SELECT BOTTOM("water_level",3) FROM "h2o_feet"

name: h2o_feet
time                   bottom
----                   ------
2015-08-29T14:30:00Z   -0.61
2015-08-29T14:36:00Z   -0.591
2015-08-30T15:18:00Z   -0.594

查询返回 water_level 字段键中和 h2o_feet 测量中最小的三个字段值。

选择与两个标签相关的字段键的底部字段值

> SELECT BOTTOM("water_level","location",2) FROM "h2o_feet"

name: h2o_feet
time                   bottom   location
----                   ------   --------
2015-08-29T10:36:00Z   -0.243   santa_monica
2015-08-29T14:30:00Z   -0.61    coyote_creek

查询返回与location标签键相关的两个标签值中water_level字段键的最小字段值。

选择与字段键相关的底部四个字段值以及相关的标签和字段

> SELECT BOTTOM("water_level",4),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  bottom  location      level description
----                  ------  --------      -----------------
2015-08-29T14:24:00Z  -0.587  coyote_creek  below 3 feet
2015-08-29T14:30:00Z  -0.61   coyote_creek  below 3 feet
2015-08-29T14:36:00Z  -0.591  coyote_creek  below 3 feet
2015-08-30T15:18:00Z  -0.594  coyote_creek  below 3 feet

查询返回water_level字段键中的最小四个字段值，以及location标签键和level description字段键的相关值。

选择与字段键关联的三个最低字段值并包括多个子句

> SELECT BOTTOM("water_level",3),"location" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) ORDER BY time DESC

name: h2o_feet
time                  bottom  location
----                  ------  --------
2015-08-18T00:48:00Z  1.991   santa_monica
2015-08-18T00:54:00Z  2.054   santa_monica
2015-08-18T00:54:00Z  6.982   coyote_creek
2015-08-18T00:24:00Z  2.041   santa_monica
2015-08-18T00:30:00Z  2.051   santa_monica
2015-08-18T00:42:00Z  2.057   santa_monica
2015-08-18T00:00:00Z  2.064   santa_monica
2015-08-18T00:06:00Z  2.116   santa_monica
2015-08-18T00:12:00Z  2.028   santa_monica

查询返回每个24分钟间隔内water_level字段键的最小三个值，时间范围是2015-08-18T00:00:00Z到2015-08-18T00:54:00Z。它还按降序时间戳顺序返回结果。

注意GROUP BY time() 子句并不会覆盖点的原始时间戳。有关该行为的更详细解释，请参见下面的问题 1部分。

与 `BOTTOM()` 相关的常见问题

`BOTTOM()` 与 `GROUP BY time()` 子句

使用 BOTTOM() 和 GROUP BY time() 子句的查询返回指定数量的点，每个 GROUP BY time() 间隔。对于大多数 GROUP BY time() 查询，返回的时间戳标记 GROUP BY time() 间隔的开始。带有 BOTTOM() 函数的 GROUP BY time() 查询表现得不同；它们保持原始数据点的时间戳。

示例

下面的查询每18分钟返回两个点 GROUP BY time() 间隔。请注意，返回的时间戳是点的原始时间戳；它们并不强制与 GROUP BY time() 间隔的开始匹配。

> SELECT BOTTOM("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)

name: h2o_feet
time                   bottom
----                   ------
                           __
2015-08-18T00:00:00Z  2.064 |
2015-08-18T00:12:00Z  2.028 | <------- Smallest points for the first time interval
                           --
                           __
2015-08-18T00:24:00Z  2.041 |
2015-08-18T00:30:00Z  2.051 | <------- Smallest points for the second time interval                      --

BOTTOM() 和一个标签键，其标签值少于 N 个

使用语法 SELECT BOTTOM(,,) 的查询可能返回少于预期的点。如果标签键有 X 个标签值，查询指定了 N 个值，而 X 小于 N，那么查询返回 X 个点。

示例

下面的查询请求 location 标签键的三个标签值的 water_level 的最小字段值。因为 location 标签键有两个标签值 (santa_monica 和 coyote_creek)，所以查询返回两个点而不是三个。

> SELECT BOTTOM("water_level","location",3) FROM "h2o_feet"

name: h2o_feet
time                   bottom   location
----                   ------   --------
2015-08-29T10:36:00Z   -0.243   santa_monica
2015-08-29T14:30:00Z   -0.61    coyote_creek

BOTTOM()、标签和INTO子句

当与一个 INTO 子句结合并且没有 GROUP BY tag 子句时，大多数 InfluxQL 函数将初始数据中的任何标签转换为新写入数据中的字段。这个行为同样适用于 BOTTOM() 函数，除非 BOTTOM() 包含一个标签键作为参数：BOTTOM(field_key,tag_key(s),N)。在这些情况下，系统将指定的标签保留为新写入数据中的标签。

示例

下面代码块中的第一个查询返回与location标签键相关的两个标签值中water_level字段键的最小字段值。它还将这些结果写入bottom_water_levels测量。

第二个查询显示 InfluxDB 将 location 标签作为标签保存在 bottom_water_levels 度量中。

> SELECT BOTTOM("water_level","location",2) INTO "bottom_water_levels" FROM "h2o_feet"

name: result
time                 written
----                 -------
1970-01-01T00:00:00Z 2

> SHOW TAG KEYS FROM "bottom_water_levels"

name: bottom_water_levels
tagKey
------
location

第一次()

返回具有最早时间戳的字段值。

语法

SELECT FIRST(<field_key>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

FIRST(field_key)
返回与字段键关联的最旧字段值（由时间戳确定）。

FIRST(/regular_expression/)
返回与每个匹配正则表达式的字段键关联的最旧字段值（由时间戳确定）。

FIRST(*)
返回与measurement中每个字段键关联的最旧字段值（由时间戳确定）。

FIRST(field_key),tag_key(s),field_key(s)
返回与括号中的字段键及相关的tag和/或field关联的最旧字段值（由时间戳确定）。

FIRST() 支持所有字段值数据类型。

示例

选择与字段键相关的第一个字段值

> SELECT FIRST("level description") FROM "h2o_feet"

name: h2o_feet
time                   first
----                   -----
2015-08-18T00:00:00Z   between 6 and 9 feet

查询返回与level description字段键关联的最旧字段值（由时间戳决定），以及在h2o_feet测量中。

选择与测量中每个字段键关联的第一个字段值

> SELECT FIRST(*) FROM "h2o_feet"

name: h2o_feet
time                   first_level description   first_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   between 6 and 9 feet      8.12

查询返回每个字段键的最旧字段值（由时间戳确定），在h2o_feet测量中。 h2o_feet测量有两个字段键：level description和water_level。

选择与每个字段键匹配正则表达式的第一个字段值

> SELECT FIRST(/level/) FROM "h2o_feet"

name: h2o_feet
time                   first_level description   first_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   between 6 and 9 feet      8.12

查询返回每个字段键中包含词语 level 的最旧字段值，属于 h2o_feet 测量。

选择与字段键及相关标签和字段关联的第一个值

> SELECT FIRST("level description"),"location","water_level" FROM "h2o_feet"

name: h2o_feet
time                  first                 location      water_level
----                  -----                 --------      -----------
2015-08-18T00:00:00Z  between 6 and 9 feet  coyote_creek  8.12

该查询返回level description字段键中最旧的字段值（由时间戳确定）及其相关的location标签键和water_level字段键的值。

选择与字段键关联的第一个字段值并包含几个子句

> SELECT FIRST("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   first
----                   -----
2015-08-17T23:48:00Z   9.01
2015-08-18T00:00:00Z   8.12
2015-08-18T00:12:00Z   7.887
2015-08-18T00:24:00Z   7.635

该查询返回 water_level 字段键中最旧的字段值（由时间戳确定）。它涵盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并将结果分组成 12 分钟的时间间隔和每个标签。该查询填充空的时间间隔为 9.01，并且限制返回的点和序列的数量为四和一。

请注意，GROUP BY time() 子句会覆盖点的原始时间戳。结果中的时间戳表示每个12分钟时间间隔的开始；结果中的第一个点涵盖了 2015-08-17T23:48:00Z 和 2015-08-18T00:00:00Z 之间的时间间隔，结果中的最后一个点涵盖了 2015-08-18T00:24:00Z 和 2015-08-18T00:36:00Z 之间的时间间隔。

最后()

返回具有最新时间戳的字段值。

语法

SELECT LAST(<field_key>)[,<tag_key(s)>|<field_keys(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

LAST(field_key)
返回与字段键关联的最新字段值（由时间戳确定）。

LAST(/regular_expression/)
返回与匹配正则表达式的每个字段键关联的最新字段值（由时间戳决定）。

LAST(*)
返回与measurement中每个字段键相关联的最新字段值（由时间戳确定）。

LAST(field_key),tag_key(s),field_key(s)
返回与括号中的字段键相关的最新字段值（由时间戳确定）以及相关的 tag 和/或 field。

LAST() 支持所有字段值数据类型。

示例

选择与字段键相关的最后字段值

> SELECT LAST("level description") FROM "h2o_feet"

name: h2o_feet
time                   last
----                   ----
2015-09-18T21:42:00Z   between 3 and 6 feet

查询返回与level description字段键相关联的最新字段值（由时间戳决定），并在h2o_feet测量中。

选择与测量中每个字段键关联的最后字段值

> SELECT LAST(*) FROM "h2o_feet"

name: h2o_feet
time                   last_level description   last_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   between 3 and 6 feet      4.938

查询返回每个字段键的最新字段值（由时间戳确定），在h2o_feet测量中。 h2o_feet测量有两个字段键：level description和water_level。

选择与每个字段关键字匹配的正则表达式相关联的最后一个字段值

> SELECT LAST(/level/) FROM "h2o_feet"

name: h2o_feet
time                   last_level description   last_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   between 3 and 6 feet      4.938

查询返回每个字段键中包含单词 level 的 h2o_feet 测量的最新字段值。

选择与字段键关联的最后一个字段值以及相关的标签和字段

> SELECT LAST("level description"),"location","water_level" FROM "h2o_feet"

name: h2o_feet
time                  last                  location      water_level
----                  ----                  --------      -----------
2015-09-18T21:42:00Z  between 3 and 6 feet  santa_monica  4.938

查询返回最新的字段值（由时间戳确定）在 level description 字段关键字中，以及 location 标签关键字和 water_level 字段关键字的相关值。

选择与字段键关联的最后一个字段值并包含几个子句

> SELECT LAST("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   last
----                   ----
2015-08-17T23:48:00Z   9.01
2015-08-18T00:00:00Z   8.005
2015-08-18T00:12:00Z   7.762
2015-08-18T00:24:00Z   7.5

查询返回在 water_level 字段键中最新的字段值（由时间戳确定）。它覆盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并将结果分组为每个标签的12分钟时间间隔。查询填充空时间间隔为 9.01，并且它限制返回的点和系列的数量为四个和一个。

最大值()

返回最大的字段值。

语法

SELECT MAX(<field_key>)[,<tag_key(s)>|<field__key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MAX(field_key)
返回与字段键相关联的最大字段值。

MAX(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的最大字段值。

MAX(*)
返回与每个字段键相关联的最大字段值，位于measurement中。

MAX(field_key),tag_key(s),field_key(s)
返回与括号中的字段键相关联的最大字段值，以及相关的 tag 和/或 field。

MAX() 支持 int64 和 float64 字段值数据类型。

示例

选择与字段键相关的最大字段值

> SELECT MAX("water_level") FROM "h2o_feet"

name: h2o_feet
time                   max
----                   ---
2015-08-29T07:24:00Z   9.964

查询返回water_level字段键中和h2o_feet测量中的最大字段值。

选择与测量中每个字段键相关联的最大字段值

> SELECT MAX(*) FROM "h2o_feet"

name: h2o_feet
time                   max_water_level
----                   ---------------
2015-08-29T07:24:00Z   9.964

查询返回每个存储数值的字段键的最大字段值，在h2o_feet度量中。h2o_feet度量有一个数值字段：water_level。

选择与匹配正则表达式的每个字段键相关联的最大字段值

> SELECT MAX(/level/) FROM "h2o_feet"

name: h2o_feet
time                   max_water_level
----                   ---------------
2015-08-29T07:24:00Z   9.964

该查询返回每个存储数值的字段键的最大字段值，并且在h2o_feet测量中包含单词water。

选择与字段键及相关标签和字段关联的最大字段值

> SELECT MAX("water_level"),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  max    location      level description
----                  ---    --------      -----------------
2015-08-29T07:24:00Z  9.964  coyote_creek  at or greater than 9 feet

查询返回water_level字段键中的最大字段值以及location标签键和level description字段键的相关值。

选择与字段键相关联的最大字段值，并包含几个子句

> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   max
----                   ---
2015-08-17T23:48:00Z   9.01
2015-08-18T00:00:00Z   8.12
2015-08-18T00:12:00Z   7.887
2015-08-18T00:24:00Z   7.635

查询返回 water_level 字段键中最大的字段值。它涵盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并且将结果分组为12分钟的时间间隔和每个标签。查询填充空的时间间隔为 9.01，并且限制返回的点数和序列数为四个和一个。

最小值()

返回最低的字段值。

语法

SELECT MIN(<field_key>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MIN(field_key)
返回与字段键相关联的最低字段值。

MIN(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的最低字段值。

MIN(*)
返回与measurement中每个字段键相关联的最低字段值。

MIN(field_key),tag_key(s),field_key(s)
返回与括号中的字段键相关联的最低字段值以及相关的 tag 和/或 field。

MIN() 支持 int64 和 float64 字段值数据类型。

示例

选择与字段键相关的最小字段值

> SELECT MIN("water_level") FROM "h2o_feet"

name: h2o_feet
time                   min
----                   ---
2015-08-29T14:30:00Z   -0.61

查询返回water_level字段键和h2o_feet测量中的最低字段值。

选择与测量中每个字段键相关联的最小字段值

> SELECT MIN(*) FROM "h2o_feet"

name: h2o_feet
time                   min_water_level
----                   ---------------
2015-08-29T14:30:00Z   -0.61

查询返回每个存储数值的字段键的最低字段值，位于 h2o_feet 测量中。 h2o_feet 测量有一个数值字段： water_level。

选择与每个字段键匹配的正则表达式的最小字段值

> SELECT MIN(/level/) FROM "h2o_feet"

name: h2o_feet
time                   min_water_level
----                   ---------------
2015-08-29T14:30:00Z   -0.61

查询返回存储数值的每个字段键的最低字段值，并且在h2o_feet测量中包含单词water。

选择与字段关键字及相关标签和字段关联的最小字段值

> SELECT MIN("water_level"),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  min    location      level description
----                  ---    --------      -----------------
2015-08-29T14:30:00Z  -0.61  coyote_creek  below 3 feet

查询返回 water_level 字段键的最低字段值以及 location 标签键和 level description 字段键的相关值。

选择与字段键关联的最小字段值并包含几个条件

> SELECT MIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   min
----                   ---
2015-08-17T23:48:00Z   9.01
2015-08-18T00:00:00Z   8.005
2015-08-18T00:12:00Z   7.762
2015-08-18T00:24:00Z   7.5

查询返回 water_level 字段键中的最低字段值。它涵盖了时间范围从 2015-08-17T23:48:00Z 到 2015-08-18T00:54:00Z，并将结果分组为12分钟的时间间隔和每个标签。查询填充空的时间间隔为 9.01，并且它限制返回的点和系列数量为四个和一个。

百分位数()

返回第 N 个百分位数字段值。

语法

SELECT PERCENTILE(<field_key>, <N>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

PERCENTILE(field_key,N)
返回与字段键相关联的第N个百分位字段值。

PERCENTILE(/regular_expression/,N)
返回与每个匹配正则表达式的字段键相关联的第N百分位字段值。

PERCENTILE(*,N)
返回与每个字段键相关联的第 N 个百分位字段值，来自 measurement。

PERCENTILE(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键相关联的第N个百分位字段值以及相关的 tag 和/或 field。

N 必须是一个在 0 和 100 之间（包括两者）的整数或浮点数。 PERCENTILE() 支持 int64 和 float64 字段值数据类型。

示例

选择与字段键相关的第五百分位字段值

> SELECT PERCENTILE("water_level",5) FROM "h2o_feet"

name: h2o_feet
time                   percentile
----                   ----------
2015-08-31T03:42:00Z   1.122

查询返回的字段值大于water_level字段键和h2o_feet测量中字段值的百分之五。

选择与测量中每个字段键相关的第五百分位字段值

> SELECT PERCENTILE(*,5) FROM "h2o_feet"

name: h2o_feet
time                   percentile_water_level
----                   ----------------------
2015-08-31T03:42:00Z   1.122

查询返回每个存储数值的字段键中，字段值大于百分之五的字段值。 h2o_feet 测量包含一个数值字段：water_level。

选择与每个字段键匹配正则表达式的第五百分位字段值

> SELECT PERCENTILE(/level/,5) FROM "h2o_feet"

name: h2o_feet
time                   percentile_water_level
----                   ----------------------
2015-08-31T03:42:00Z   1.122

查询返回每个存储数值的字段键中大于该字段值五个百分点的字段值，并且在h2o_feet测量中包含单词water。

选择与字段键相关的第五百分位字段值以及相关标签和字段

> SELECT PERCENTILE("water_level",5),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  percentile  location      level description
----                  ----------  --------      -----------------
2015-08-31T03:42:00Z  1.122       coyote_creek  below 3 feet

查询返回水位字段键中大于字段值五百分之一的字段值，以及位置标签键和级别描述字段键的相关值。

选择与字段键相关联的第 twenty 个百分位字段值，并包括若干条款

> SELECT PERCENTILE("water_level",20) FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) fill(15) LIMIT 2

name: h2o_feet
time                   percentile
----                   ----------
2015-08-17T23:36:00Z   15
2015-08-18T00:00:00Z   2.064

查询返回大于water_level字段值20%的字段值。它覆盖了时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并且将结果分组为24分钟的时间间隔。它用15填充空的时间间隔，并且它限制返回的点的数量为两个。

请注意，GROUP BY time() 子句会覆盖点的原始时间戳。结果中的时间戳表示每个 24 分钟时间间隔的开始；结果中的第一个点涵盖了 2015-08-17T23:36:00Z 和 2015-08-18T00:00:00Z 之前的时间间隔，结果中的最后一个点涵盖了 2015-08-18T00:00:00Z 和 2015-08-18T00:24:00Z 之前的时间间隔。

PERCENTILE() 的常见问题

PERCENTILE() 与其他 InfluxQL 函数的比较

PERCENTILE(,100) 等价于 MAX()。
PERCENTILE(, 50) 几乎等同于 MEDIAN()，不同的是 MEDIAN() 函数在字段键包含偶数个字段值时返回两个中间值的平均值。
PERCENTILE(,0) 并不等同于 MIN()。这是一个已知的问题。

样本()

返回 N 个字段值的随机样本。SAMPLE() 使用水库抽样来生成随机点。

语法

SELECT SAMPLE(<field_key>, <N>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

SAMPLE(field_key,N)
返回与字段键相关联的N个随机选择的字段值。

SAMPLE(/regular_expression/,N)
返回与匹配正则表达式的每个字段键相关联的N个随机选择的字段值。

SAMPLE(*,N)
返回与每个字段键相关联的 N 个随机选择的字段值，来自 measurement。

SAMPLE(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键相关联的 N 个随机选择的字段值以及相关的 tag 和/或 field。

N 必须是一个整数。 SAMPLE() 支持所有字段值数据类型。

示例

选择与字段键关联的字段值样本

> SELECT SAMPLE("water_level",2) FROM "h2o_feet"

name: h2o_feet
time                   sample
----                   ------
2015-09-09T21:48:00Z   5.659
2015-09-18T10:00:00Z   6.939

查询返回从 water_level 字段键和 h2o_feet 测量中随机选择的两个点。

选择与测量中每个字段键相关联的字段值样本

> SELECT SAMPLE(*,2) FROM "h2o_feet"

name: h2o_feet
time                   sample_level description   sample_water_level
----                   ------------------------   ------------------
2015-08-25T17:06:00Z                              3.284
2015-09-03T04:30:00Z   below 3 feet
2015-09-03T20:06:00Z   between 3 and 6 feet
2015-09-08T21:54:00Z                              3.412

该查询返回每个字段键在 h2o_feet 测量中随机选择的两个点。 h2o_feet 测量有两个字段键： level description 和 water_level。

选择与每个字段键匹配正则表达式的字段值样本

> SELECT SAMPLE(/level/,2) FROM "h2o_feet"

name: h2o_feet
time                   sample_level description   sample_water_level
----                   ------------------------   ------------------
2015-08-30T05:54:00Z   between 6 and 9 feet
2015-09-07T01:18:00Z                              7.854
2015-09-09T20:30:00Z                              7.32
2015-09-13T19:18:00Z   between 3 and 6 feet

查询返回每个包含单词 level 的字段键的两个随机选择的点，来自 h2o_feet 测量。

选择与字段键及相关标签和字段相关的字段值样本

> SELECT SAMPLE("water_level",2),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  sample  location      level description
----                  ------  --------      -----------------
2015-08-29T10:54:00Z  5.689   coyote_creek  between 3 and 6 feet
2015-09-08T15:48:00Z  6.391   coyote_creek  between 6 and 9 feet

查询返回从 water_level 字段键中随机选择的两个点，以及 location 标签和 level description 字段的相关值。

选择与字段键相关联的字段值的样本并包含几个条件

> SELECT SAMPLE("water_level",1) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)

name: h2o_feet
time                   sample
----                   ------
2015-08-18T00:12:00Z   2.028
2015-08-18T00:30:00Z   2.051

查询从 water_level 字段键中随机选择一个点。它涵盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z 的内容，并将结果分组为18分钟的间隔。

请注意，GROUP BY time() 子句不会覆盖点的原始时间戳。请参阅下面部分的问题 1，以获取该行为的更详细解释。

关于 `SAMPLE()` 的常见问题

`SAMPLE()` 与 `GROUP BY time()` 子句

使用 SAMPLE() 和 GROUP BY time() 子句的查询返回指定数量的点 (N) 每个 GROUP BY time() 时间间隔。对于大多数 GROUP BY time() 查询，返回的时间戳标记 GROUP BY time() 时间间隔的开始。带有 SAMPLE() 函数的 GROUP BY time() 查询表现得不同；它们保留原始数据点的时间戳。

示例

下面的查询每18分钟返回两个随机选择的点 GROUP BY time() 间隔。请注意，返回的时间戳是点的原始时间戳；它们不会被强制匹配 GROUP BY time() 间隔的开始。

> SELECT SAMPLE("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)

name: h2o_feet
time                   sample
----                   ------
                           __
2015-08-18T00:06:00Z   2.116 |
2015-08-18T00:12:00Z   2.028 | <------- Randomly-selected points for the first time interval
                           --
                           __
2015-08-18T00:18:00Z   2.126 |
2015-08-18T00:30:00Z   2.051 | <------- Randomly-selected points for the second time interval
                           --

顶部函数()

返回最大的 N 字段值。

语法

SELECT TOP( <field_key>[,<tag_key(s)>],<N> )[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

TOP(field_key,N)
返回与字段键相关联的最大的N个字段值。

TOP(field_key,tag_key(s),N)
返回标签键的N个标签值的最大字段值。

TOP(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键关联的最大的N个字段值，以及相关的 tag 和/或 field。

TOP() 支持 int64 和 float64 字段值数据类型。

注意：

TOP() 返回具有最早时间戳的字段值，如果两个或更多值在最大值上存在平局。
TOP() 在与 INTO 子句结合时与其他 InfluxQL 函数不同。请参阅常见问题部分以获取更多信息。

示例

选择与字段键相关的前三个字段值

> SELECT TOP("water_level",3) FROM "h2o_feet"

name: h2o_feet
time                   top
----                   ---
2015-08-29T07:18:00Z   9.957
2015-08-29T07:24:00Z   9.964
2015-08-29T07:30:00Z   9.954

查询返回在 water_level 字段键和 h2o_feet 测量中的三个最大字段值。

选择与两个标签相关的字段键的最高字段值

> SELECT TOP("water_level","location",2) FROM "h2o_feet"

name: h2o_feet
time                   top     location
----                   ---     --------
2015-08-29T03:54:00Z   7.205   santa_monica
2015-08-29T07:24:00Z   9.964   coyote_creek

查询返回与location标签键关联的两个标签值中的water_level字段键的最大字段值。

选择与字段键关联的前四个字段值以及相关标签和字段

> SELECT TOP("water_level",4),"location","level description" FROM "h2o_feet"

name: h2o_feet
time                  top    location      level description
----                  ---    --------      -----------------
2015-08-29T07:18:00Z  9.957  coyote_creek  at or greater than 9 feet
2015-08-29T07:24:00Z  9.964  coyote_creek  at or greater than 9 feet
2015-08-29T07:30:00Z  9.954  coyote_creek  at or greater than 9 feet
2015-08-29T07:36:00Z  9.941  coyote_creek  at or greater than 9 feet

查询返回 water_level 字段键中的最大四个值，以及 location 标签键和 level description 字段键的相关值。

选择与字段键相关的前三个字段值并包含多个条件

> SELECT TOP("water_level",3),"location" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) ORDER BY time DESC

name: h2o_feet
time                  top    location
----                  ---    --------
2015-08-18T00:48:00Z  7.11   coyote_creek
2015-08-18T00:54:00Z  6.982  coyote_creek
2015-08-18T00:54:00Z  2.054  santa_monica
2015-08-18T00:24:00Z  7.635  coyote_creek
2015-08-18T00:30:00Z  7.5    coyote_creek
2015-08-18T00:36:00Z  7.372  coyote_creek
2015-08-18T00:00:00Z  8.12   coyote_creek
2015-08-18T00:06:00Z  8.005  coyote_creek
2015-08-18T00:12:00Z  7.887  coyote_creek

该查询返回每个 24 分钟时间间隔内 water_level 字段键的最大三个值，时间范围为 2015-08-18T00:00:00Z 和 2015-08-18T00:54:00Z。它还按降序时间戳顺序返回结果。

请注意，GROUP BY time() 子句不会覆盖数据点的原始时间戳。有关该行为的更详细解释，请参阅下面部分的问题 1。

关于 `TOP()` 的常见问题

`TOP()` 与 `GROUP BY time()` 子句

带有 TOP() 和 GROUP BY time() 子句的查询将返回每个 GROUP BY time() 区间的指定点数。对于大多数 GROUP BY time() 查询，返回的时间戳标记 GROUP BY time() 区间的开始。带有 TOP() 函数的 GROUP BY time() 查询表现得不同；它们保持原始数据点的时间戳。

示例

下面的查询每18分钟返回两个点 GROUP BY time() 间隔。请注意，返回的时间戳是点的原始时间戳；它们并不强制与 GROUP BY time() 间隔的开始匹配。

> SELECT TOP("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)

name: h2o_feet
time                   top
----                   ------
                           __
2015-08-18T00:00:00Z  2.064 |
2015-08-18T00:06:00Z  2.116 | <------- Greatest points for the first time interval
                           --
                           __
2015-08-18T00:18:00Z  2.126 |
2015-08-18T00:30:00Z  2.051 | <------- Greatest points for the second time interval
                           --

TOP() 和一个标签键，具有少于 N 个标签值

具有语法 SELECT TOP(,,) 的查询可能返回比预期更少的点数。如果标签键有 X 个标签值，查询指定 N 个值，并且 X 小于 N，则查询返回 X 个点。

示例

下面的查询请求三个标签值的water_level的最大字段值，标签键为location。因为location标签键有两个标签值（santa_monica和coyote_creek），所以查询返回两个点而不是三个。

> SELECT TOP("water_level","location",3) FROM "h2o_feet"

name: h2o_feet
time                  top    location
----                  ---    --------
2015-08-29T03:54:00Z  7.205  santa_monica
2015-08-29T07:24:00Z  9.964  coyote_creek

TOP()、tags 和 INTO 子句

当与一个 INTO 子句结合并且没有 GROUP BY tag 子句时，大多数 InfluxQL 函数将初始数据中的任何标签转换为新写入数据中的字段。这种行为也适用于 TOP() 函数，除非 TOP() 将标签键作为参数：TOP(field_key,tag_key(s),N)。在这些情况下，系统将指定的标签保留为新写入数据中的标签。

示例

下面代码块中的第一个查询返回与location标签键相关的两个标签值在water_level字段键中的最大字段值。它还将这些结果写入top_water_levels测量中。

第二个查询显示 InfluxDB 保留了 location 标签作为 top_water_levels 测量中的一个标签。

> SELECT TOP("water_level","location",2) INTO "top_water_levels" FROM "h2o_feet"

name: result
time                 written
----                 -------
1970-01-01T00:00:00Z 2

> SHOW TAG KEYS FROM "top_water_levels"

name: top_water_levels
tagKey
------
location

变换

绝对值函数（ABS）()

返回字段值的绝对值。

基本语法

SELECT ABS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ABS(field_key)
返回与字段键相关联的字段值的绝对值。

ABS(*)
返回与measurement中每个字段键相关联的字段值的绝对值。

ABS() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，允许按标签分组，但不支持 GROUP BY 子句，允许按时间分组。有关如何使用 ABS() 与 GROUP BY time() 子句，请参见高级语法部分。

示例

下面的示例使用了这个样本数据的以下子样本：

> SELECT * FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'

name: data
time                 a                   b
----                 -                   -
1529841600000000000  1.33909108671076    -0.163643058925645
1529841660000000000  -0.774984088561186  0.137034364053949
1529841720000000000  -0.921037167720451  -0.482943221384294
1529841780000000000  -1.73880754843378   -0.0729732928756677
1529841840000000000  -0.905980032168252  1.77857552719844
1529841900000000000  -0.891164752631417  0.741147445214238

计算与字段键相关的字段值的绝对值

> SELECT ABS("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'

name: data
time                 abs
----                 ---
1529841600000000000  1.33909108671076
1529841660000000000  0.774984088561186
1529841720000000000  0.921037167720451
1529841780000000000  1.73880754843378
1529841840000000000  0.905980032168252
1529841900000000000  0.891164752631417

查询返回data测量中a字段键的字段值的绝对值。

计算测量中与每个字段键关联的字段值的绝对值

> SELECT ABS(*) FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'

name: data
time                 abs_a              abs_b
----                 -----              -----
1529841600000000000  1.33909108671076   0.163643058925645
1529841660000000000  0.774984088561186  0.137034364053949
1529841720000000000  0.921037167720451  0.482943221384294
1529841780000000000  1.73880754843378   0.0729732928756677
1529841840000000000  0.905980032168252  1.77857552719844
1529841900000000000  0.891164752631417  0.741147445214238

查询返回存储数值的每个字段键的字段值的绝对值，位于data测量中。data测量有两个数值字段：a和b。

计算与字段键关联的字段值的绝对值并包括多个条件

> SELECT ABS("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2

name: data
time                 abs
----                 ---
1529841780000000000  1.73880754843378
1529841720000000000  0.921037167720451
1529841660000000000  0.774984088561186
1529841600000000000  1.33909108671076

查询返回与a字段键相关联的字段值的绝对值。它涵盖了时间范围在2018-06-24T12:00:00Z和2018-06-24T12:05:00Z之间，并按降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT ABS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后对这些结果应用 ABS() 函数。

ABS() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算均值的绝对值

> SELECT ABS(MEAN("a")) FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T13:00:00Z' GROUP BY time(12m)

name: data
time                 abs
----                 ---
1529841600000000000  0.3960977256302787
1529842320000000000  0.0010541018316373302
1529843040000000000  0.04494733240283668
1529843760000000000  0.2553594777104415
1529844480000000000  0.20382988543108413
1529845200000000000  0.790836070736962

查询返回在12分钟间隔内计算的average a的绝对值。

为了获取这些结果，InfluxDB 首先在 12 分钟的间隔内计算平均 a。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句并且没有 ABS() 是相同的：

> SELECT MEAN("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T13:00:00Z' GROUP BY time(12m)

name: data
time                 mean
----                 ----
1529841600000000000  -0.3960977256302787
1529842320000000000  0.0010541018316373302
1529843040000000000  0.04494733240283668
1529843760000000000  0.2553594777104415
1529844480000000000  0.20382988543108413
1529845200000000000  -0.790836070736962

InfluxDB 然后计算这些平均值的绝对值。

反余弦函数（ACOS）

返回字段值的反余弦（以弧度为单位）。字段值必须在 -1 和 1 之间。

基本语法

SELECT ACOS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ACOS(field_key)
返回与字段键相关联的字段值的反余弦。

ACOS(*)
返回与measurement中每个字段键相关联的字段值的反余弦。

ACOS() 支持值在 -1 和 1 之间的 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，用于按标签分组，但不支持 GROUP BY 子句用于按时间分组。请参阅高级语法部分了解如何使用 ACOS() 与 GROUP BY time() 子句。

示例

以下示例使用了相对于总容量的模拟公园入住率的数据样本。需要注意的重要事项是，所有字段值都落在可计算范围内（-1到1）ACOS()函数：

> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  capacity
----                  --------
2017-05-01T00:00:00Z  0.83
2017-05-02T00:00:00Z  0.3
2017-05-03T00:00:00Z  0.84
2017-05-04T00:00:00Z  0.22
2017-05-05T00:00:00Z  0.17
2017-05-06T00:00:00Z  0.77
2017-05-07T00:00:00Z  0.64
2017-05-08T00:00:00Z  0.72
2017-05-09T00:00:00Z  0.16

计算与字段键相关的字段值的反余弦

> SELECT ACOS("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  acos
----                  ----
2017-05-01T00:00:00Z  0.591688642426544
2017-05-02T00:00:00Z  1.266103672779499
2017-05-03T00:00:00Z  0.5735131044230969
2017-05-04T00:00:00Z  1.3489818562981022
2017-05-05T00:00:00Z  1.399966657665792
2017-05-06T00:00:00Z  0.6919551751263169
2017-05-07T00:00:00Z  0.8762980611683406
2017-05-08T00:00:00Z  0.7669940078618667
2017-05-09T00:00:00Z  1.410105673842986

查询返回park_occupancy测量中of_capacity字段键的反余弦值。

计算与测量中每个字段键关联的字段值的反余弦

> SELECT ACOS(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  acos_of_capacity
----                  -------------
2017-05-01T00:00:00Z  0.591688642426544
2017-05-02T00:00:00Z  1.266103672779499
2017-05-03T00:00:00Z  0.5735131044230969
2017-05-04T00:00:00Z  1.3489818562981022
2017-05-05T00:00:00Z  1.399966657665792
2017-05-06T00:00:00Z  0.6919551751263169
2017-05-07T00:00:00Z  0.8762980611683406
2017-05-08T00:00:00Z  0.7669940078618667
2017-05-09T00:00:00Z  1.410105673842986

查询返回存储数值的每个字段键的字段值的反余弦。park_occupancy测量具有一个数值字段：of_capacity。

计算与字段键相关的字段值的反余弦，并包含多个子句

> SELECT ACOS("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2

name: park_occupancy
time                  acos
----                  ----
2017-05-07T00:00:00Z  0.8762980611683406
2017-05-06T00:00:00Z  0.6919551751263169
2017-05-05T00:00:00Z  1.399966657665792
2017-05-04T00:00:00Z  1.3489818562981022

该查询返回与 of_capacity 字段键相关的字段值的反余弦值。它覆盖了时间范围从 2017-05-01T00:00:00Z 到 2017-05-09T00:00:00Z，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT ACOS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 ACOS() 函数应用于这些结果。

ACOS() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算平均值的反余弦

> SELECT ACOS(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                  acos
----                  ----
2017-04-30T00:00:00Z  0.9703630732143733
2017-05-03T00:00:00Z  1.1483422646081407
2017-05-06T00:00:00Z  0.7812981174487247
2017-05-09T00:00:00Z  1.410105673842986

查询返回在3天间隔内计算的平均值的反余弦of_capacity。

为了得到这些结果，InfluxDB 首先以 3 天为间隔计算平均 of_capacity。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 ACOS() 是相同的：

> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                  mean
----                  ----
2017-04-30T00:00:00Z  0.565
2017-05-03T00:00:00Z  0.41
2017-05-06T00:00:00Z  0.71
2017-05-09T00:00:00Z  0.16

然后，InfluxDB 计算这些平均值的反余弦。

ASIN()

返回字段值的反正弦（以弧度为单位）。字段值必须在-1和1之间。

基本语法

SELECT ASIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ASIN(field_key)
返回与 field key 相关的字段值的反正弦值。

ASIN(*)
返回与measurement中每个字段键关联的字段值的反正弦。

ASIN() 支持 int64 和 float64 字段值数据类型，其值在 -1 和 1 之间。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。请参见高级语法部分，以了解如何使用 ASIN() 结合 GROUP BY time() 子句。

示例

以下示例使用与总容量相关的模拟公园占用数据样本。需要注意的重要事项是，所有字段值均在ASIN()函数的可计算范围内（-1 到 1）：

> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  capacity
----                  --------
2017-05-01T00:00:00Z  0.83
2017-05-02T00:00:00Z  0.3
2017-05-03T00:00:00Z  0.84
2017-05-04T00:00:00Z  0.22
2017-05-05T00:00:00Z  0.17
2017-05-06T00:00:00Z  0.77
2017-05-07T00:00:00Z  0.64
2017-05-08T00:00:00Z  0.72
2017-05-09T00:00:00Z  0.16

计算与字段键相关的字段值的反正弦

> SELECT ASIN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  asin
----                  ----
2017-05-01T00:00:00Z  0.9791076843683526
2017-05-02T00:00:00Z  0.3046926540153975
2017-05-03T00:00:00Z  0.9972832223717997
2017-05-04T00:00:00Z  0.22181447049679442
2017-05-05T00:00:00Z  0.1708296691291045
2017-05-06T00:00:00Z  0.8788411516685797
2017-05-07T00:00:00Z  0.6944982656265559
2017-05-08T00:00:00Z  0.8038023189330299
2017-05-09T00:00:00Z  0.1606906529519106

查询返回park_capacity测量中of_capacity字段键的反正弦值。

计算与测量中每个字段键关联的字段值的反正弦

> SELECT ASIN(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  asin_of_capacity
----                  -------------
2017-05-01T00:00:00Z  0.9791076843683526
2017-05-02T00:00:00Z  0.3046926540153975
2017-05-03T00:00:00Z  0.9972832223717997
2017-05-04T00:00:00Z  0.22181447049679442
2017-05-05T00:00:00Z  0.1708296691291045
2017-05-06T00:00:00Z  0.8788411516685797
2017-05-07T00:00:00Z  0.6944982656265559
2017-05-08T00:00:00Z  0.8038023189330299
2017-05-09T00:00:00Z  0.1606906529519106

查询返回每个存储数值的字段键的反正弦值，字段来自于park_capacity度量。 h2o_feet度量有一个数值字段：of_capacity。

计算与字段键相关的字段值的反正弦，并包含多个条件

> SELECT ASIN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2

name: park_occupancy
time                  asin
----                  ----
2017-05-07T00:00:00Z  0.6944982656265559
2017-05-06T00:00:00Z  0.8788411516685797
2017-05-05T00:00:00Z  0.1708296691291045
2017-05-04T00:00:00Z  0.22181447049679442

查询返回与 of_capacity 字段键相关联的字段值的反正弦。它覆盖了时间范围从 2017-05-01T00:00:00Z 到 2017-05-09T00:00:00Z，并以降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移两个点的结果。

高级语法

SELECT ASIN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 ASIN() 函数应用于这些结果。

ASIN() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，以及 PERCENTILE()。

示例

计算平均值的反正弦。

> SELECT ASIN(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                  asin
----                  ----
2017-04-30T00:00:00Z  0.6004332535805232
2017-05-03T00:00:00Z  0.42245406218675574
2017-05-06T00:00:00Z  0.7894982093461719
2017-05-09T00:00:00Z  0.1606906529519106

查询返回在3天间隔计算的平均值 of_capacity 的反正弦值。

为了获得这些结果，InfluxDB 首先计算 3 天间隔的平均 of_capacity。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 ASIN() 是相同的：

> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                  mean
----                  ----
2017-04-30T00:00:00Z  0.565
2017-05-03T00:00:00Z  0.41
2017-05-06T00:00:00Z  0.71
2017-05-09T00:00:00Z  0.16

InfluxDB 然后计算这些平均值的反正弦。

反正切函数 ATAN()

返回字段值的反正切（以弧度为单位）。字段值必须在-1和1之间。

基本语法

SELECT ATAN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ATAN(field_key)
返回与字段键关联的字段值的反正切。

ATAN(*)
返回与measurement中每个字段键相关联的字段值的反正切。

ATAN() 支持 int64 和 float64 字段值数据类型，值的范围在 -1 和 1 之间。

基本语法支持 GROUP BY 子句，可以按标签分组，但不支持 GROUP BY 子句，可以按时间分组。请参见高级语法部分，了解如何在 GROUP BY time() 子句中使用 ATAN()。

示例

以下示例使用了模拟公园占用率相对于总容量的数据样本。重要的是要注意，所有字段值都在可计算范围内（-1 到 1）ATAN() 函数：

> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  capacity
----                  --------
2017-05-01T00:00:00Z  0.83
2017-05-02T00:00:00Z  0.3
2017-05-03T00:00:00Z  0.84
2017-05-04T00:00:00Z  0.22
2017-05-05T00:00:00Z  0.17
2017-05-06T00:00:00Z  0.77
2017-05-07T00:00:00Z  0.64
2017-05-08T00:00:00Z  0.72
2017-05-09T00:00:00Z  0.16

计算与字段键相关的字段值的反正切

> SELECT ATAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  atan
----                  ----
2017-05-01T00:00:00Z  0.6927678353971222
2017-05-02T00:00:00Z  0.2914567944778671
2017-05-03T00:00:00Z  0.6986598247214632
2017-05-04T00:00:00Z  0.2165503049760893
2017-05-05T00:00:00Z  0.16839015714752992
2017-05-06T00:00:00Z  0.6561787179913948
2017-05-07T00:00:00Z  0.5693131911006619
2017-05-08T00:00:00Z  0.6240230529767568
2017-05-09T00:00:00Z  0.1586552621864014

查询返回park_occupancy 测量中 of_capacity 字段键的字段值的反正切。

计算与测量中每个字段键相关的字段值的反正切

> SELECT ATAN(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'

name: park_occupancy
time                  atan_of_capacity
----                  -------------
2017-05-01T00:00:00Z  0.6927678353971222
2017-05-02T00:00:00Z  0.2914567944778671
2017-05-03T00:00:00Z  0.6986598247214632
2017-05-04T00:00:00Z  0.2165503049760893
2017-05-05T00:00:00Z  0.16839015714752992
2017-05-06T00:00:00Z  0.6561787179913948
2017-05-07T00:00:00Z  0.5693131911006619
2017-05-08T00:00:00Z  0.6240230529767568
2017-05-09T00:00:00Z  0.1586552621864014

该查询返回每个存储数值的字段键的字段值的反正切。 park_occupancy 测量有一个数值字段: of_capacity。

计算与字段键相关的字段值的反正切并包含多个子句

> SELECT ATAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2

name: park_occupancy
time                  atan
----                  ----
2017-05-07T00:00:00Z  0.5693131911006619
2017-05-06T00:00:00Z  0.6561787179913948
2017-05-05T00:00:00Z  0.16839015714752992
2017-05-04T00:00:00Z  0.2165503049760893

该查询返回与of_capacity字段键相关的字段值的反正切。它覆盖了时间范围在2017-05-01T00:00:00Z和2017-05-09T00:00:00Z之间，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT ATAN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 ATAN() 函数应用于这些结果。

ATAN() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，以及 PERCENTILE()。

高级语法示例

计算均值的反正切。

> SELECT ATAN(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                 atan
----                 ----
2017-04-30T00:00:00Z 0.5142865412694495
2017-05-03T00:00:00Z 0.3890972310552784
2017-05-06T00:00:00Z 0.6174058917515726
2017-05-09T00:00:00Z 0.1586552621864014

查询返回每3天间隔计算的of_capacity的反正切值。

为了获得这些结果，InfluxDB 首先以 3 天为间隔计算平均 of_capacity。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 ATAN() 是相同的：

> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)

name: park_occupancy
time                  mean
----                  ----
2017-04-30T00:00:00Z  0.565
2017-05-03T00:00:00Z  0.41
2017-05-06T00:00:00Z  0.71
2017-05-09T00:00:00Z  0.16

InfluxDB 然后计算这些平均值的反正切。

ATAN2()

返回 y/x 的反正切值（以弧度表示）。

基本语法

SELECT ATAN2( [ * | <field_key> | num ], [ <field_key> | num ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ATAN2(field_key_y, field_key_x)
返回与字段键相关的字段值 field_key_y 除以与 field_key_x 相关的字段值的反正切。

ATAN2(*, field_key_x)
返回与每个字段键相关联的字段值在测量中除以与field_key_x相关联的字段值。

ATAN2() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组但不支持 GROUP BY 子句，这些子句按时间分组。请参见高级语法部分，了解如何在 GROUP BY time() 子句中使用 ATAN2()。

示例

下面的示例使用以下模拟航班数据：

> SELECT "altitude_ft", "distance_ft" FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'

name: flight_data
time                  altitude_ft  distance_ft
----                  -----------  -----------
2018-05-16T12:01:00Z  1026         50094
2018-05-16T12:02:00Z  2549         53576
2018-05-16T12:03:00Z  4033         55208
2018-05-16T12:04:00Z  5579         58579
2018-05-16T12:05:00Z  7065         61213
2018-05-16T12:06:00Z  8589         64807
2018-05-16T12:07:00Z  10180        67707
2018-05-16T12:08:00Z  11777        69819
2018-05-16T12:09:00Z  13321        72452
2018-05-16T12:10:00Z  14885        75881

计算 field_key_y 相对于 field_key_x 的反正切

> SELECT ATAN2("altitude_ft", "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'

name: flight_data
time                  atan2
----                  -----
2018-05-16T12:01:00Z  0.020478631571881498
2018-05-16T12:02:00Z  0.04754142349303296
2018-05-16T12:03:00Z  0.07292147724575364
2018-05-16T12:04:00Z  0.09495251193874832
2018-05-16T12:05:00Z  0.11490822875441563
2018-05-16T12:06:00Z  0.13176409347584003
2018-05-16T12:07:00Z  0.14923587589682233
2018-05-16T12:08:00Z  0.1671059946640312
2018-05-16T12:09:00Z  0.18182893717409565
2018-05-16T12:10:00Z  0.1937028631495223

查询返回的值是altitude_ft字段键的值与distance_ft字段键的值的反正切。两者都是flight_data测量的一部分。

计算与测量中每个字段键相关的值与 field_key_x 的比值的反正切

> SELECT ATAN2(*, "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'

name: flight_data
time                  atan2_altitude_ft     atan2_distance_ft
----                  -----------------     -----------------
2018-05-16T12:01:00Z  0.020478631571881498  0.7853981633974483
2018-05-16T12:02:00Z  0.04754142349303296   0.7853981633974483
2018-05-16T12:03:00Z  0.07292147724575364   0.7853981633974483
2018-05-16T12:04:00Z  0.09495251193874832   0.7853981633974483
2018-05-16T12:05:00Z  0.11490822875441563   0.7853981633974483
2018-05-16T12:06:00Z  0.13176409347584003   0.7853981633974483
2018-05-16T12:07:00Z  0.14923587589682233   0.7853981633974483
2018-05-16T12:08:00Z  0.1671059946640312    0.7853981633974483
2018-05-16T12:09:00Z  0.18182893717409565   0.7853981633974483
2018-05-16T12:10:00Z  0.19370286314952234   0.7853981633974483

查询返回所有数值字段值在 flight_data 测量中被 distance_ft 字段键的值除的反正切值。flight_data 测量有两个数值字段： altitude_ft 和 distance_ft。

计算字段值的反正切并包括多个条件

> SELECT ATAN2("altitude_ft", "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2

name: flight_data
time                  atan2
----                  -----
2018-05-16T12:08:00Z  0.1671059946640312
2018-05-16T12:07:00Z  0.14923587589682233
2018-05-16T12:06:00Z  0.13176409347584003
2018-05-16T12:05:00Z  0.11490822875441563

该查询返回与 altitude_ft 字段键关联的字段值的反正切，除以 distance_ft 字段键。它涵盖了时间范围在 2018-05-16T12:10:00Z 和 2018-05-16T12:10:00Z 之间，并按降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT ATAN2(<function()>, <function()>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 ATAN2() 函数应用于这些结果。

ATAN2() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，以及 PERCENTILE()。

示例

计算均值的反正切

> SELECT ATAN2(MEAN("altitude_ft"), MEAN("distance_ft")) FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T13:01:00Z' GROUP BY time(12m)

name: flight_data
time                  atan2
----                  -----
2018-05-16T12:00:00Z  0.133815587896842
2018-05-16T12:12:00Z  0.2662716308351908
2018-05-16T12:24:00Z  0.2958845306108965
2018-05-16T12:36:00Z  0.23783439588429497
2018-05-16T12:48:00Z  0.1906803720242831
2018-05-16T13:00:00Z  0.17291511946158172

查询返回的结果是 average altitude_ft 的 argtangents 除以平均 distance_ft。平均值按 12 分钟的间隔计算。

为了得到这些结果，InfluxDB 首先计算12分钟间隔的平均 altitude_ft 和 distance_ft。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 ATAN2() 是一样的：

> SELECT MEAN("altitude_ft"), MEAN("distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T13:01:00Z' GROUP BY time(12m)

name: flight_data
time                  mean                mean_1
----                  ----                ------
2018-05-16T12:00:00Z  8674                64433.181818181816
2018-05-16T12:12:00Z  26419.833333333332  96865.25
2018-05-16T12:24:00Z  40337.416666666664  132326.41666666666
2018-05-16T12:36:00Z  41149.583333333336  169743.16666666666
2018-05-16T12:48:00Z  41230.416666666664  213600.91666666666
2018-05-16T13:00:00Z  41184.5             235799

InfluxDB 然后计算这些平均值的反正切。

向上取整()

返回向上舍入到最近整数的后续值。

基本语法

SELECT CEIL( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

CEIL(field_key)
返回与字段键相关联的字段值，并向上舍入到最近的整数。

CEIL(*)
返回与每个字段键相关联的字段值，在measurement中向上取整至最接近的整数。

CEIL() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，该子句按标签分组，但不支持 GROUP BY 子句，该子句按时间分组。有关如何在 GROUP BY time() 子句中使用 CEIL() 的信息，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关联的字段值的上限

> SELECT CEIL("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  ceil
----                  ----
2015-08-18T00:00:00Z  3
2015-08-18T00:06:00Z  3
2015-08-18T00:12:00Z  3
2015-08-18T00:18:00Z  3
2015-08-18T00:24:00Z  3
2015-08-18T00:30:00Z  3

查询返回 h2o_feet 测量中 water_level 字段键的字段值，四舍五入到最接近的整数。

计算与测量中每个字段键相关联的字段值的上限

> SELECT CEIL(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  ceil_water_level
----                  ----------------
2015-08-18T00:00:00Z  3
2015-08-18T00:06:00Z  3
2015-08-18T00:12:00Z  3
2015-08-18T00:18:00Z  3
2015-08-18T00:24:00Z  3
2015-08-18T00:30:00Z  3

查询返回存储在h2o_feet度量中的每个字段键的字段值，这些字段值为数值类型，并向上舍入到最接近的整数。h2o_feet度量有一个数值字段：water_level。

计算与字段键关联的字段值的上限，并包含多个条件

> SELECT CEIL("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  ceil
----                  ----
2015-08-18T00:18:00Z  3
2015-08-18T00:12:00Z  3
2015-08-18T00:06:00Z  3
2015-08-18T00:00:00Z  3

查询返回与water_level字段键相关的字段值，向上取整为最接近的整数。它涵盖了时间范围从2015-08-18T00:00:00Z到2015-08-18T00:30:00Z，并按照时间戳降序排列返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT CEIL(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 CEIL() 函数应用于这些结果。

CEIL() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE().

示例

计算向上舍入到最近整数的均值

> SELECT CEIL(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  ceil
----                  ----
2015-08-18T00:00:00Z  3
2015-08-18T00:12:00Z  3
2015-08-18T00:24:00Z  3

查询返回在12分钟间隔计算的平均water_level并将其四舍五入到最接近的整数。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步骤与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 CEIL() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后将这些平均值四舍五入到最近的整数。

COS()

返回字段值的余弦。

基本语法

SELECT COS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

COS(field_key)
返回与字段键相关联的字段值的余弦值。

COS(*)
返回与每个字段键相关联的字段值的余弦，在measurement中。

COS() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句按标签分组，但不支持 GROUP BY 子句按时间分组。请参阅高级语法部分了解如何使用 COS() 与 GROUP BY time() 子句。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的余弦值

> SELECT COS("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  cos
----                  ---
2015-08-18T00:00:00Z  -0.47345017433543124
2015-08-18T00:06:00Z  -0.5185922462666872
2015-08-18T00:12:00Z  -0.4414407189100776
2015-08-18T00:18:00Z  -0.5271163912192579
2015-08-18T00:24:00Z  -0.45306786455514825
2015-08-18T00:30:00Z  -0.4619598230611262

查询返回h2o_feet测量中water_level字段键的值的余弦。

计算与测量中每个字段键相关的字段值的余弦

> SELECT COS(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  cos_water_level
----                  ---------------
2015-08-18T00:00:00Z  -0.47345017433543124
2015-08-18T00:06:00Z  -0.5185922462666872
2015-08-18T00:12:00Z  -0.4414407189100776
2015-08-18T00:18:00Z  -0.5271163912192579
2015-08-18T00:24:00Z  -0.45306786455514825
2015-08-18T00:30:00Z  -0.4619598230611262

查询返回每个存储数值的字段键的字段值的余弦值，在h2o_feet测量中。 h2o_feet测量有一个数值字段：water_level。

计算与字段键相关的字段值的余弦，并包含多个子句

> SELECT COS("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  cos
----                  ---
2015-08-18T00:18:00Z  -0.5271163912192579
2015-08-18T00:12:00Z  -0.4414407189100776
2015-08-18T00:06:00Z  -0.5185922462666872
2015-08-18T00:00:00Z  -0.47345017433543124

该查询返回与 water_level 字段键相关的字段值的余弦。它涵盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z，并以降序时间戳顺序返回结果。该查询还限制返回的点的数量为四个，并且偏移结果两个点。

高级语法

SELECT COS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 COS() 函数应用于这些结果。

COS() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算平均值的余弦

> SELECT COS(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  cos
----                  ---
2015-08-18T00:00:00Z  -0.49618891270599885
2015-08-18T00:12:00Z  -0.4848605136571181
2015-08-18T00:24:00Z  -0.4575195627907578

查询返回在12分钟间隔内计算的平均值 water_level的余弦。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 COS() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的余弦。

累积和()

返回后续字段值的累计总和。

基本语法

SELECT CUMULATIVE_SUM( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

CUMULATIVE_SUM(field_key)
返回与字段键相关联的后续字段值的运行总和。

CUMULATIVE_SUM(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的后续字段值的累计总和。

CUMULATIVE_SUM(*)
返回与每个字段键相关联的后续字段值的运行总和。

CUMULATIVE_SUM() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句用于按标签分组，但不支持 GROUP BY 子句用于按时间分组。有关如何使用 CUMULATIVE_SUM() 与 GROUP BY time() 子句的说明，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028
2015-08-18T00:18:00Z   2.126
2015-08-18T00:24:00Z   2.041
2015-08-18T00:30:00Z   2.051

计算与字段键相关的字段值的累积和

> SELECT CUMULATIVE_SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   cumulative_sum
----                   --------------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   4.18
2015-08-18T00:12:00Z   6.208
2015-08-18T00:18:00Z   8.334
2015-08-18T00:24:00Z   10.375
2015-08-18T00:30:00Z   12.426

查询返回water_level字段键和h2o_feet测量中字段值的累计总和。

计算与测量中每个字段键相关联的字段值的累积和

> SELECT CUMULATIVE_SUM(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   cumulative_sum_water_level
----                   --------------------------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   4.18
2015-08-18T00:12:00Z   6.208
2015-08-18T00:18:00Z   8.334
2015-08-18T00:24:00Z   10.375
2015-08-18T00:30:00Z   12.426

查询返回每个存储数值的字段键的字段值的累计总和，在h2o_feet测量中。 h2o_feet测量有一个数值字段：water_level。

计算与匹配正则表达式的每个字段键相关联的字段值的累积和

> SELECT CUMULATIVE_SUM(/water/) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   cumulative_sum_water_level
----                   --------------------------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   4.18
2015-08-18T00:12:00Z   6.208
2015-08-18T00:18:00Z   8.334
2015-08-18T00:24:00Z   10.375
2015-08-18T00:30:00Z   12.426

查询返回每个存储数值的字段键的字段值的累计总和，并且在h2o_feet测量中包含单词water。

计算与字段键关联的字段值的累积和并包括几个子句

> SELECT CUMULATIVE_SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  cumulative_sum
----                  --------------
2015-08-18T00:18:00Z  6.218
2015-08-18T00:12:00Z  8.246
2015-08-18T00:06:00Z  10.362
2015-08-18T00:00:00Z  12.426

查询返回与water_level字段键相关联的字段值的累计总和。它涵盖了时间范围从2015-08-18T00:00:00Z到2015-08-18T00:30:00Z，并以降序时间戳顺序返回结果。查询还限制返回的点的数量为四个，并偏移结果两点。

高级语法

SELECT CUMULATIVE_SUM(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个GROUP BY time() 子句和一个嵌套的InfluxQL函数。查询首先计算指定GROUP BY time()间隔内嵌套函数的结果，然后将CUMULATIVE_SUM()函数应用于这些结果。

CUMULATIVE_SUM() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算平均值的累积和

> SELECT CUMULATIVE_SUM(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   cumulative_sum
----                   --------------
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   4.167
2015-08-18T00:24:00Z   6.213

查询返回每12分钟计算的平均 水位的累计总和。

为了获得这些结果，InfluxDB 首先在 12 分钟的间隔内计算平均 water_level。这个步骤与使用 MEAN() 函数和 GROUP BY time() 子句而不使用 CUMULATIVE_SUM() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

接下来，InfluxDB 计算这些平均值的累积总和。最终结果中的第二个点 (4.167) 是 2.09 和 2.077 的总和，第三个点 (6.213) 是 2.09、2.077 和 2.0460000000000003 的总和。

导数()

返回后续字段值之间的变化率。

基本语法

SELECT DERIVATIVE( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

InfluxDB计算后续字段值之间的差异，并将这些结果转换为每unit的变化率。 unit参数是一个后面跟有duration literal的整数，它是可选的。如果查询未指定unit，则单位默认为一秒(1s)。

DERIVATIVE(field_key)
返回与字段键相关的后续字段值之间的变化率。

DERIVATIVE(/regular_expression/)
返回与每个匹配正则表达式的字段键相关联的后续字段值之间的变化率。

DERIVATIVE(*)
返回与每个字段键相关联的measurement中后续字段值之间的变化率。

DERIVATIVE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句来按标签分组，但不支持 GROUP BY 子句来按时间分组。请参阅高级语法部分，了解如何在 GROUP BY time() 子句中使用 DERIVATIVE()。

示例

示例 1-5 使用以下的 NOAA_water_database 数据子样本：

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028
2015-08-18T00:18:00Z   2.126
2015-08-18T00:24:00Z   2.041
2015-08-18T00:30:00Z   2.051

计算与字段键相关的字段值之间的导数

> SELECT DERIVATIVE("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   derivative
----                   ----------
2015-08-18T00:06:00Z   0.00014444444444444457
2015-08-18T00:12:00Z   -0.00024444444444444465
2015-08-18T00:18:00Z   0.0002722222222222218
2015-08-18T00:24:00Z   -0.000236111111111111
2015-08-18T00:30:00Z   2.777777777777842e-05

查询返回与water_level字段键关联的字段值与h2o_feet测量之间的一秒变化率。

第一个结果 (0.00014444444444444457) 是原始数据中前两个连续字段值之间的一秒钟变化率。 InfluxDB 计算字段值之间的差异，并将该值标准化为一秒钟的变化率：

(2.116 - 2.064) / (360s / 1s)
--------------    ----------
       |               |
       |          the difference between the field values' timestamps / the default unit
second field value - first field value

计算与字段键相关联的字段值之间的导数并指定单位选项

> SELECT DERIVATIVE("water_level",6m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time			derivative
----			----------
2015-08-18T00:06:00Z	0.052000000000000046
2015-08-18T00:12:00Z	-0.08800000000000008
2015-08-18T00:18:00Z	0.09799999999999986
2015-08-18T00:24:00Z	-0.08499999999999996
2015-08-18T00:30:00Z	0.010000000000000231

查询返回与 water_level 字段键相关联的现场值之间的六分钟变化率，以及在 h2o_feet 测量中的变化率。

第一个结果 (0.052000000000000046) 是原始数据中前两个连续字段值之间的六分钟变化率。 InfluxDB 计算字段值之间的差异，并将该值标准化为六分钟变化率：

(2.116 - 2.064) / (6m / 6m)
--------------    ----------
       |              |
       |          the difference between the field values' timestamps / the specified unit
second field value - first field value

计算与测量中每个字段键相关联的字段值之间的导数，并指定单位选项

> SELECT DERIVATIVE(*,3m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'


name: h2o_feet
time                   derivative_water_level
----                   ----------------------
2015-08-18T00:06:00Z   0.026000000000000023
2015-08-18T00:12:00Z   -0.04400000000000004
2015-08-18T00:18:00Z   0.04899999999999993
2015-08-18T00:24:00Z   -0.04249999999999998
2015-08-18T00:30:00Z   0.0050000000000001155

该查询返回与每个存储数值的字段键相关的字段值之间的三分钟变化率，在h2o_feet测量中。 h2o_feet测量有一个数值字段：water_level。

第一个结果 (0.026000000000000023) 是原始数据中前两个连续字段值之间的三分钟变化率。 InfluxDB 计算字段值之间的差异，并将该值归一化为三分钟变化率：

(2.116 - 2.064) / (6m / 3m)
--------------    ----------
       |              |
       |          the difference between the field values' timestamps / the specified unit
second field value - first field value

计算与每个符合正则表达式的字段键相关的字段值之间的导数，并指定单位选项

> SELECT DERIVATIVE(/water/,2m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   derivative_water_level
----                   ----------------------
2015-08-18T00:06:00Z   0.01733333333333335
2015-08-18T00:12:00Z   -0.02933333333333336
2015-08-18T00:18:00Z   0.03266666666666662
2015-08-18T00:24:00Z   -0.02833333333333332
2015-08-18T00:30:00Z   0.0033333333333334103

查询返回与每个存储数值的字段键相关联的字段值之间的两分钟变化率，并且在h2o_feet测量中包含单词water。

第一个结果 (0.01733333333333335) 是原始数据中前两个值之间的两分钟变化率。 InfluxDB计算字段值之间的差异，并将该值标准化为两分钟变化率：

(2.116 - 2.064) / (6m / 2m)
--------------    ----------
       |              |
       |          the difference between the field values' timestamps / the specified unit
second field value - first field value

计算与字段键相关联的字段值之间的导数并包含多个子句

> SELECT DERIVATIVE("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' ORDER BY time DESC LIMIT 1 OFFSET 2

name: h2o_feet
time                   derivative
----                   ----------
2015-08-18T00:12:00Z   -0.0002722222222222218

该查询返回与 water_level 字段键有关的字段值之间的每秒变化率，并在 h2o_feet 测量中进行计算。它涵盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z，并以时间戳降序返回结果。该查询还限制返回的点数为一个，并偏移结果两个点。

唯一的结果 (-0.0002722222222222218) 是原始数据中相关后续字段值之间的一秒变化率。 InfluxDB 计算字段值之间的差异，并将该值标准化为一秒的变化率：

(2.126 - 2.028) / (360s / 1s)
--------------    ----------
       |              |
       |          the difference between the field values' timestamps / the default unit
second field value - first field value

高级语法

SELECT DERIVATIVE(<function> ([ * | <field_key> | /<regular_expression>/ ]) [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后对这些结果应用 DERIVATIVE() 函数。

参数 unit 是一个整数，后面跟着一个持续时间字面量，这是可选的。
如果查询没有指定 unit，则 unit 默认为 GROUP BY time() 的时间间隔。
请注意，这种行为与基本语法的默认行为不同。

DERIVATIVE()支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，以及 PERCENTILE()。

示例

计算平均值的导数

> SELECT DERIVATIVE(MEAN("water_level")) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   derivative
----                   ----------
2015-08-18T00:12:00Z   -0.0129999999999999
2015-08-18T00:24:00Z   -0.030999999999999694

查询返回的是在12分钟间隔内计算的平均水位的12分钟变化率。

要获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 DERIVATIVE() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

接下来，InfluxDB 计算这些平均值之间的 12 分钟变化率。第一个结果 (-0.0129999999999999) 是前两个平均值之间的 12 分钟变化率。 InfluxDB 计算字段值之间的差异，并将该值标准化为 12 分钟变化率。

(2.077 - 2.09) / (12m / 12m)
-------------    ----------
       |               |
       |          the difference between the field values' timestamps / the default unit
second field value - first field value

计算平均值的导数并指定单位选项

> SELECT DERIVATIVE(MEAN("water_level"),6m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   derivative
----                   ----------
2015-08-18T00:12:00Z   -0.00649999999999995
2015-08-18T00:24:00Z   -0.015499999999999847

查询返回在12分钟间隔内计算的平均water_level之间的六分钟变化率。

为了获得这些结果，InfluxDB 首先在 12 分钟的间隔内计算平均 water_level。这一步和使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 DERIVATIVE() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

接下来，InfluxDB 计算这两个平均值之间的六分钟变化率。第一个结果 (-0.00649999999999995) 是前两个平均值之间的六分钟变化率。 InfluxDB 计算字段值之间的差异，并将该值归一化为六分钟变化率。

(2.077 - 2.09) / (12m / 6m)
-------------    ----------
       |               |
       |          the difference between the field values' timestamps / the specified unit
second field value - first field value

差异()

返回后续字段值之间的减法结果。

基本语法

SELECT DIFFERENCE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

DIFFERENCE(field_key)
返回与字段键相关的后续字段值之间的差异。

DIFFERENCE(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的后续字段值之间的差异。

DIFFERENCE(*)
返回与每个字段键相关联的后续字段值之间的差异，位于measurement中。

DIFFERENCE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句（通过标签分组），但不支持 GROUP BY 子句（通过时间分组）。请参阅高级语法部分了解如何使用 DIFFERENCE() 与 GROUP BY time() 子句。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028
2015-08-18T00:18:00Z   2.126
2015-08-18T00:24:00Z   2.041
2015-08-18T00:30:00Z   2.051

计算与字段键相关的字段值之间的差异

> SELECT DIFFERENCE("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   difference
----                   ----------
2015-08-18T00:06:00Z   0.052000000000000046
2015-08-18T00:12:00Z   -0.08800000000000008
2015-08-18T00:18:00Z   0.09799999999999986
2015-08-18T00:24:00Z   -0.08499999999999996
2015-08-18T00:30:00Z   0.010000000000000231

查询返回water_level字段键和h2o_feet测量中后续字段值之间的差异。

计算测量中每个字段键关联的字段值之间的差异

> SELECT DIFFERENCE(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   difference_water_level
----                   ----------------------
2015-08-18T00:06:00Z   0.052000000000000046
2015-08-18T00:12:00Z   -0.08800000000000008
2015-08-18T00:18:00Z   0.09799999999999986
2015-08-18T00:24:00Z   -0.08499999999999996
2015-08-18T00:30:00Z   0.010000000000000231

查询返回每个存储数值的字段键的后续字段值之间的差异，在h2o_feet测量中。 h2o_feet测量中有一个数值字段：water_level。

计算与每个字段键匹配正则表达式相关联的字段值之间的差异

> SELECT DIFFERENCE(/water/) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                   difference_water_level
----                   ----------------------
2015-08-18T00:06:00Z   0.052000000000000046
2015-08-18T00:12:00Z   -0.08800000000000008
2015-08-18T00:18:00Z   0.09799999999999986
2015-08-18T00:24:00Z   -0.08499999999999996
2015-08-18T00:30:00Z   0.010000000000000231

查询返回每个存储数值的字段键的后续字段值之间的差异，并且在h2o_feet测量中包含单词water。

计算与字段键关联的字段值之间的差异并包括多个子句

> SELECT DIFFERENCE("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 2 OFFSET 2

name: h2o_feet
time                   difference
----                   ----------
2015-08-18T00:12:00Z   -0.09799999999999986
2015-08-18T00:06:00Z   0.08800000000000008

查询返回water_level字段键中后续字段值之间的差异。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。查询还限制返回的点数为两个，并偏移结果两个点。

高级语法

SELECT DIFFERENCE(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 区间计算嵌套函数的结果，然后对这些结果应用 DIFFERENCE() 函数。

DIFFERENCE() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算最大值之间的差异

> SELECT DIFFERENCE(MAX("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   difference
----                   ----------
2015-08-18T00:12:00Z   0.009999999999999787
2015-08-18T00:24:00Z   -0.07499999999999973

查询返回在12分钟间隔内计算的最大值 水位之间的差异。

要获得这些结果，InfluxDB 首先在 12 分钟的时间间隔内计算最大 water_level。这一步与使用 MAX() 函数结合 GROUP BY time() 子句而不使用 DIFFERENCE() 是相同的：

> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   max
----                   ---
2015-08-18T00:00:00Z   2.116
2015-08-18T00:12:00Z   2.126
2015-08-18T00:24:00Z   2.051

接下来，InfluxDB 计算这些最大值之间的差异。最终结果中的第一个点 (0.009999999999999787) 是 2.126 和 2.116 之间的差异，最终结果中的第二个点 (-0.07499999999999973) 是 2.051 和 2.126 之间的差异。

已过去时间()

返回后续字段值的时间戳之间的差值。

语法

SELECT ELAPSED( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

InfluxDB 计算后续时间戳之间的差值。 unit 选项是一个整数，后面跟着一个 duration literal，它决定了返回差值的单位。如果查询没有指定 unit 选项，则查询返回以纳秒为单位的时间戳差值。

ELAPSED(field_key)
返回与字段键相关的后续时间戳之间的差异。

ELAPSED(/regular_expression/)
返回与每个字段键相关联的后续时间戳之间的差异，这些字段键符合正则表达式。

ELAPSED(*)
返回与每个字段键关联的随时间戳之间的差异，单位为measurement。

ELAPSED() 支持所有字段值数据类型。

示例

这些示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028

计算与字段键相关的字段值之间的经过时间

> SELECT ELAPSED("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:06:00Z   360000000000
2015-08-18T00:12:00Z   360000000000

查询返回water_level字段键和h2o_feet测量中后续时间戳之间的差异（以纳秒为单位）。

计算与字段键关联的字段值之间的经过时间，并指定单位选项

> SELECT ELAPSED("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:06:00Z   6
2015-08-18T00:12:00Z   6

查询返回在 water_level 字段键中和 h2o_feet 测量中的后续时间戳之间的差异（以分钟为单位）。

计算测量中与每个字段键关联的字段值之间的经过时间，并指定单位选项

> SELECT ELAPSED(*,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   elapsed_level description   elapsed_water_level
----                   -------------------------   -------------------
2015-08-18T00:06:00Z   6                           6
2015-08-18T00:12:00Z   6                           6

查询返回与每个字段键相关联的后续时间戳之间的差异（以分钟为单位），在h2o_feet测量中。 h2o_feet测量有两个字段键：level description和water_level。

计算与每个字段键匹配正则表达式的字段值之间的经过时间，并指定单位选项

> SELECT ELAPSED(/level/,1s) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   elapsed_level description   elapsed_water_level
----                   -------------------------   -------------------
2015-08-18T00:06:00Z   360                         360
2015-08-18T00:12:00Z   360                         360

查询返回与每个字段键相关的后续时间戳之间的差异（以秒为单位），该字段键包含单词 level 在 h2o_feet 测量中。

计算与字段键相关的字段值之间的经过时间，并包含几个条件

> SELECT ELAPSED("water_level",1ms) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z' ORDER BY time DESC LIMIT 1 OFFSET 1

name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:00:00Z   -360000

查询返回water_level字段键和h2o_feet测量中后续时间戳之间的差值（以毫秒为单位）。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:12:00Z之间，并按降序对时间戳进行排序。查询还限制返回的点数为一个，并且偏移结果一个点。

注意结果是负数；ORDER BY time DESC 子句按时间戳降序排序，因此 ELAPSED() 计算时间戳之间的差异时是反向的。

ELAPSED() 的常见问题

ELAPSED() 和大于经过时间的单位

如果unit选项大于时间戳之间的差值，InfluxDB将返回0。

示例

在h2o_feet测量中的时间戳以六分钟为间隔发生。如果查询将unit选项设置为一个小时，InfluxDB返回0：

> SELECT ELAPSED("water_level",1h) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:06:00Z   0
2015-08-18T00:12:00Z   0

带有 GROUP BY time() 子句的 ELAPSED()

该 ELAPSED() 函数支持 GROUP BY time() 子句，但查询结果并不是特别有用。目前，带有嵌套函数和 GROUP BY time() 子句的 ELAPSED() 查询只是返回 GROUP BY time() 子句中指定的时间间隔。

此 GROUP BY time() 子句决定结果中的时间戳；每个时间戳标记时间间隔的开始。这个行为同样适用于嵌套选择器函数（比如 FIRST() 或 MAX()），在其他情况下会返回原始数据中的特定时间戳。因为 GROUP BY time() 子句覆盖了原始时间戳，所以 ELAPSED() 计算始终返回与 GROUP BY time() 间隔相同的值。

示例

在下面的代码块中，第一个查询尝试使用 ELAPSED() 函数与 GROUP BY time() 子句来查找 minimum water_level 之间的经过时间（以分钟为单位）。该查询返回两个时间间隔均为 12分钟。

为了获得这些结果，InfluxDB 首先在 12 分钟的间隔内计算最低 water_level。代码块中的第二个查询显示了该步骤的结果。该步骤与使用 MIN() 函数结合 GROUP BY time() 子句并没有 ELAPSED() 函数是相同的。注意第二个查询返回的时间戳相隔 12 分钟。在原始数据中，第一个结果 (2.057) 出现在 2015-08-18T00:42:00Z 但 GROUP BY time() 子句覆盖了原始时间戳。因为时间戳是由 GROUP BY time() 间隔决定的，而不是由原始数据决定的，所以 ELAPSED() 计算总是返回与 GROUP BY time() 间隔相同的值。

> SELECT ELAPSED(MIN("water_level"),1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:36:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m)

name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:36:00Z   12
2015-08-18T00:48:00Z   12

> SELECT MIN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:36:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m)

name: h2o_feet
time                   min
----                   ---
2015-08-18T00:36:00Z   2.057    <--- Actually occurs at 2015-08-18T00:42:00Z
2015-08-18T00:48:00Z   1.991

EXP()

返回字段值的指数。

基本语法

SELECT EXP( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

EXP(field_key)
返回与字段键相关的字段值的指数。

EXP(*)
返回与measurement中每个字段键关联的字段值的指数。

EXP() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句来按标签分组，但不支持 GROUP BY 子句来按时间分组。有关如何在 GROUP BY time() 子句中使用 EXP() 的信息，请参阅高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的指数

> SELECT EXP("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  exp
----                  ---
2015-08-18T00:00:00Z  7.877416541092307
2015-08-18T00:06:00Z  8.297879498060171
2015-08-18T00:12:00Z  7.598873404088091
2015-08-18T00:18:00Z  8.381274573459967
2015-08-18T00:24:00Z  7.6983036546645645
2015-08-18T00:30:00Z  7.775672892658607

查询返回在 h2o_feet 测量中 water_level 字段键的字段值的指数。

计算与测量中每个字段键相关联的字段值的指数

> SELECT EXP(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  exp_water_level
----                  ---------------
2015-08-18T00:00:00Z  7.877416541092307
2015-08-18T00:06:00Z  8.297879498060171
2015-08-18T00:12:00Z  7.598873404088091
2015-08-18T00:18:00Z  8.381274573459967
2015-08-18T00:24:00Z  7.6983036546645645
2015-08-18T00:30:00Z  7.775672892658607

查询返回每个字段键的字段值的指数，这些字段键在h2o_feet测量中存储数值。 h2o_feet测量有一个数值字段：water_level。

计算与字段键关联的字段值的指数并包含多个条件

> SELECT EXP("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  exp
----                  ---
2015-08-18T00:18:00Z  8.381274573459967
2015-08-18T00:12:00Z  7.598873404088091
2015-08-18T00:06:00Z  8.297879498060171
2015-08-18T00:00:00Z  7.877416541092307

查询返回与water_level字段键相关的字段值的指数。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并按降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT EXP(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的InfluxQL函数。查询首先在指定的GROUP BY time()区间内计算嵌套函数的结果，然后对这些结果应用EXP()函数。

EXP() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算均值的指数。

> SELECT EXP(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  exp
----                  ---
2015-08-18T00:00:00Z  8.084915164305059
2015-08-18T00:12:00Z  7.980491491670466
2015-08-18T00:24:00Z  7.736891562315577

查询返回在12分钟间隔内计算的平均 water_level的指数。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 EXP() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的指数。

向下取整()

返回向下舍入到最接近的整数的后续值。

基本语法

SELECT FLOOR( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

FLOOR(field_key)
返回与字段键关联的字段值，并向下舍入到最接近的整数。

FLOOR(*)
返回与每个字段键相关联的字段值，在measurement中向下舍入到最接近的整数。

FLOOR() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，按标签分组，但不支持 GROUP BY 子句，按时间分组。请参阅高级语法一节，了解如何使用 FLOOR() 与 GROUP BY time() 子句。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的下限

> SELECT FLOOR("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  floor
----                  -----
2015-08-18T00:00:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:18:00Z  2
2015-08-18T00:24:00Z  2
2015-08-18T00:30:00Z  2

查询返回在 h2o_feet 测量中 water_level 字段键的字段值，向下取整到最接近的整数。

计算与测量中每个字段键相关联的字段值的下限

> SELECT FLOOR(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  floor_water_level
----                  -----------------
2015-08-18T00:00:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:18:00Z  2
2015-08-18T00:24:00Z  2
2015-08-18T00:30:00Z  2

查询返回每个存储数值的字段键的字段值，h2o_feet 测量结果向下舍入到最近的整数。 h2o_feet 测量包含一个数值字段：water_level。

计算与字段键相关联的字段值的向下取整并包含多个子句

> SELECT FLOOR("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  floor
----                  -----
2015-08-18T00:18:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:00:00Z  2

该查询返回与 water_level 字段键相关的字段值，并向下取整到最近的整数。它涵盖了时间范围在 2015-08-18T00:00:00Z 和 2015-08-18T00:30:00Z 之间，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT FLOOR(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 FLOOR() 函数应用于这些结果。

FLOOR() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算向下舍入到最近整数的平均值。

> SELECT FLOOR(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  floor
----                  -----
2015-08-18T00:00:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:24:00Z  2

查询返回在12分钟间隔计算的平均water_level并将其四舍五入到最接近的整数。

要获得这些结果，InfluxDB 首先计算每 12 分钟的平均 water_level。这个步骤与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 FLOOR() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后将这些平均值向下舍入到最接近的整数。

直方图()

InfluxQL当前不支持生成直方图。有关使用存储在InfluxDB中的数据创建直方图的信息，请参见 Flux的 histogram() 函数.

自然对数函数 (LN)

返回字段值的自然对数。

基本语法

SELECT LN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

LN(field_key)
返回与 field key 相关联的字段值的自然对数。

LN(*)
返回与测量中每个字段键关联的字段值的自然对数。

LN() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这会按标签分组，但不支持 GROUP BY 子句，这会按时间分组。有关如何使用 LN() 与 GROUP BY time() 子句，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键关联的字段值的自然对数

> SELECT LN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  ln
----                  --
2015-08-18T00:00:00Z  0.7246458476193163
2015-08-18T00:06:00Z  0.749527513996053
2015-08-18T00:12:00Z  0.7070500857289368
2015-08-18T00:18:00Z  0.7542422799197561
2015-08-18T00:24:00Z  0.7134398838277077
2015-08-18T00:30:00Z  0.7183274790902436

查询返回h2o_feet度量中water_level字段键的字段值的自然对数。

计算与测量中每个字段键相关的字段值的自然对数

> SELECT LN(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  ln_water_level
----                  --------------
2015-08-18T00:00:00Z  0.7246458476193163
2015-08-18T00:06:00Z  0.749527513996053
2015-08-18T00:12:00Z  0.7070500857289368
2015-08-18T00:18:00Z  0.7542422799197561
2015-08-18T00:24:00Z  0.7134398838277077
2015-08-18T00:30:00Z  0.7183274790902436

查询返回h2o_feet测量中每个存储数值的字段键的字段值的自然对数。 h2o_feet测量有一个数值字段：water_level。

计算与字段键相关的字段值的自然对数，并包括多个子句

> SELECT LN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  ln
----                  --
2015-08-18T00:18:00Z  0.7542422799197561
2015-08-18T00:12:00Z  0.7070500857289368
2015-08-18T00:06:00Z  0.749527513996053
2015-08-18T00:00:00Z  0.7246458476193163

查询返回与water_level字段键相关的字段值的自然对数。它覆盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT LN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后对这些结果应用 LN() 函数。

LN() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，和 PERCENTILE()。

示例

计算均值的自然对数。

> SELECT LN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  ln
----                  --
2015-08-18T00:00:00Z  0.7371640659767196
2015-08-18T00:12:00Z  0.7309245448939752
2015-08-18T00:24:00Z  0.7158866675294349

查询返回在12分钟间隔内计算的平均水位的自然对数。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 LN() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的自然对数。

日志()

返回以b为底的字段值的对数。

基本语法

SELECT LOG( [ * | <field_key> ], <b> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

LOG(field_key, b)
返回与字段键相关联的字段值的对数，底数为b。

LOG(*, b)
返回与measurement中每个字段键相关联的字段值的以b为底的对数。

LOG() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句按标签分组，但不支持 GROUP BY 子句按时间分组。请参阅高级语法部分，以了解如何在 GROUP BY time() 子句中使用 LOG()。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键关联的字段值的以4为底的对数

> SELECT LOG("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log
----                  ---
2015-08-18T00:00:00Z  0.5227214853805835
2015-08-18T00:06:00Z  0.5406698137259695
2015-08-18T00:12:00Z  0.5100288261706268
2015-08-18T00:18:00Z  0.5440707984345088
2015-08-18T00:24:00Z  0.5146380911853161
2015-08-18T00:30:00Z  0.5181637459088826

查询返回 h2o_feet 测量中 water_level 字段键的值以4为底的对数。

计算与测量中每个字段键相关联的字段值的以4为底的对数

> SELECT LOG(*, 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log_water_level
----                  ---------------
2015-08-18T00:00:00Z  0.5227214853805835
2015-08-18T00:06:00Z  0.5406698137259695
2015-08-18T00:12:00Z  0.5100288261706268
2015-08-18T00:18:00Z  0.5440707984345088
2015-08-18T00:24:00Z  0.5146380911853161
2015-08-18T00:30:00Z  0.5181637459088826

查询返回每个存储数值的字段键的字段值的以4为底的对数，位于h2o_feet测量中。 h2o_feet测量有一个数字字段：water_level。

计算与字段键关联的字段值的以4为底的对数，并包含多个子句

> SELECT LOG("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  log
----                  ---
2015-08-18T00:18:00Z  0.5440707984345088
2015-08-18T00:12:00Z  0.5100288261706268
2015-08-18T00:06:00Z  0.5406698137259695
2015-08-18T00:00:00Z  0.5227214853805835

该查询返回与water_level字段键相关的字段值的以4为底的对数。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT LOG(<function>( [ * | <field_key> ] ), <b>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 区间计算嵌套函数的结果，然后将 LOG() 函数应用于这些结果。

LOG() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算均值的以4为底的对数

> SELECT LOG(MEAN("water_level"), 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  log
----                  ---
2015-08-18T00:00:00Z  0.531751471153079
2015-08-18T00:12:00Z  0.5272506080912802
2015-08-18T00:24:00Z  0.5164030725416209

查询返回以4为底的average water_level的对数，这些对数是在12分钟间隔内计算的。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句，且不使用 LOG() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的以4为底的对数。

对数2()

返回字段值以2为底的对数。

基本语法

SELECT LOG2( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

LOG2(field_key)
返回与字段键相关的字段值的以2为底的对数。

LOG2(*)
返回与每个字段键相关联的字段值的以2为底的对数，位于measurement中。

LOG2() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，可以按标签分组，但不支持 GROUP BY 子句，可以按时间分组。请参见高级语法部分，了解如何在 GROUP BY time() 子句中使用 LOG2()。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的以2为底的对数

> SELECT LOG2("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log2
----                  ----
2015-08-18T00:00:00Z  1.045442970761167
2015-08-18T00:06:00Z  1.081339627451939
2015-08-18T00:12:00Z  1.0200576523412537
2015-08-18T00:18:00Z  1.0881415968690176
2015-08-18T00:24:00Z  1.0292761823706322
2015-08-18T00:30:00Z  1.0363274918177652

该查询返回h2o_feet测量中water_level字段键的值的以2为底的对数。

计算与测量中每个字段键相关的字段值的以2为底的对数

> SELECT LOG2(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log2_water_level
----                  ----------------
2015-08-18T00:00:00Z  1.045442970761167
2015-08-18T00:06:00Z  1.081339627451939
2015-08-18T00:12:00Z  1.0200576523412537
2015-08-18T00:18:00Z  1.0881415968690176
2015-08-18T00:24:00Z  1.0292761823706322
2015-08-18T00:30:00Z  1.0363274918177652

查询返回存储在h2o_feet测量中的每个字段键的字段值的以2为底的对数。 h2o_feet测量包含一个数值字段：water_level。

计算与字段键相关的字段值的以2为底的对数并包含多个子句

> SELECT LOG2("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  log2
----                  ----
2015-08-18T00:18:00Z  1.0881415968690176
2015-08-18T00:12:00Z  1.0200576523412537
2015-08-18T00:06:00Z  1.081339627451939
2015-08-18T00:00:00Z  1.045442970761167

查询返回与water_level字段键相关的字段值的以2为底的对数。它涵盖了在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间的时间范围，并按降序时间戳顺序返回结果。查询还限制返回点的数量为四个，并偏移结果两个点。

高级语法

SELECT LOG2(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 LOG2() 函数应用于这些结果。

LOG2() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，和 PERCENTILE()。

示例

计算均值的以2为底的对数

> SELECT LOG2(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  log2
----                  ----
2015-08-18T00:00:00Z  1.063502942306158
2015-08-18T00:12:00Z  1.0545012161825604
2015-08-18T00:24:00Z  1.0328061450832418

查询返回以2为底的average water_level在12分钟间隔计算的对数。

为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的平均 water_level。这个步骤与使用 MEAN() 函数结合 GROUP BY time() 子句并且不使用 LOG2() 的效果是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的以 2 为底的对数。

LOG10()

返回字段值以10为底的对数。

基本语法

SELECT LOG10( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

LOG10(field_key)
返回与字段键相关的字段值的以10为底的对数。

LOG10(*)
返回与每个字段键相关联的字段值的以10为底的对数。

LOG10() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。请参阅高级语法部分，以了解如何在 GROUP BY time() 子句中使用 LOG10()。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的以10为底的对数

> SELECT LOG10("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log10
----                  -----
2015-08-18T00:00:00Z  0.3147096929551737
2015-08-18T00:06:00Z  0.32551566336314813
2015-08-18T00:12:00Z  0.3070679506612984
2015-08-18T00:18:00Z  0.32756326018727794
2015-08-18T00:24:00Z  0.3098430047160705
2015-08-18T00:30:00Z  0.3119656603683663

查询返回h2o_feet测量中water_level字段键的值的以10为底的对数。

计算与测量中每个字段键相关的字段值的以10为底的对数

> SELECT LOG10(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  log10_water_level
----                  -----------------
2015-08-18T00:00:00Z  0.3147096929551737
2015-08-18T00:06:00Z  0.32551566336314813
2015-08-18T00:12:00Z  0.3070679506612984
2015-08-18T00:18:00Z  0.32756326018727794
2015-08-18T00:24:00Z  0.3098430047160705
2015-08-18T00:30:00Z  0.3119656603683663

查询返回 h2o_feet 测量中每个存储数值的字段键的字段值的以10为底的对数。 h2o_feet 测量有一个数值字段：water_level。

计算与字段键相关的字段值的以10为底的对数，并包含多个子句

> SELECT LOG10("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  log10
----                  -----
2015-08-18T00:18:00Z  0.32756326018727794
2015-08-18T00:12:00Z  0.3070679506612984
2015-08-18T00:06:00Z  0.32551566336314813
2015-08-18T00:00:00Z  0.3147096929551737

查询返回与water_level字段键相关的字段值的以10为底的对数。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT LOG10(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 LOG10() 函数应用于这些结果。

LOG10() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE().

示例

计算均值的以10为底的对数

> SELECT LOG10(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  log10
----                  -----
2015-08-18T00:00:00Z  0.32014628611105395
2015-08-18T00:12:00Z  0.3174364965350991
2015-08-18T00:24:00Z  0.3109056293761414

查询返回在12分钟间隔内计算的平均 水位的以10为底的对数。

为了获得这些结果，InfluxDB 首先计算每 12 分钟的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 LOG10() 相同：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的以 10 为底的对数。

移动平均值()

返回随后的字段值的滚动平均值。

基本语法

SELECT MOVING_AVERAGE( [ * | <field_key> | /<regular_expression>/ ] , <N> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

MOVING_AVERAGE() 计算一组 N 个后续字段值的滚动平均值。 N 参数是一个整数，并且是必需的。

MOVING_AVERAGE(field_key,N)
返回与 N 字段值相关联的字段键的滚动平均值。

MOVING_AVERAGE(/regular_expression/,N)
返回与每个匹配正则表达式的字段键相关的N个字段值的滚动平均值。

MOVING_AVERAGE(*,N)
返回与每个字段键相关联的N个字段值的滚动平均值，来自于measurement。

MOVING_AVERAGE() int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句以标签分组，但不支持 GROUP BY 子句以时间分组。有关如何使用 MOVING_AVERAGE() 与 GROUP BY time() 子句，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028
2015-08-18T00:18:00Z   2.126
2015-08-18T00:24:00Z   2.041
2015-08-18T00:30:00Z   2.051

计算与字段键相关的字段值的移动平均值

> SELECT MOVING_AVERAGE("water_level",2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   moving_average
----                   --------------
2015-08-18T00:06:00Z   2.09
2015-08-18T00:12:00Z   2.072
2015-08-18T00:18:00Z   2.077
2015-08-18T00:24:00Z   2.0835
2015-08-18T00:30:00Z   2.0460000000000003

查询返回了 water_level 字段键和 h2o_feet 测量的两个字段值窗口的滚动平均值。第一个结果 (2.09) 是原始数据中前两个点的平均值：(2.064 + 2.116) / 2)。第二个结果 (2.072) 是原始数据中后两个点的平均值：(2.116 + 2.028) / 2)。

计算与测量中每个字段键关联的字段值的移动平均值

> SELECT MOVING_AVERAGE(*,3) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                   moving_average_water_level
----                   --------------------------
2015-08-18T00:12:00Z   2.0693333333333332
2015-08-18T00:18:00Z   2.09
2015-08-18T00:24:00Z   2.065
2015-08-18T00:30:00Z   2.0726666666666667

查询返回每个存储数值的字段键在三个字段值窗口中的滚动平均值，针对h2o_feet测量。h2o_feet测量包含一个数值字段：water_level。

计算与每个字段键匹配正则表达式的字段值的移动平均值

> SELECT MOVING_AVERAGE(/level/,4) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'

name: h2o_feet
time                    moving_average_water_level
----                    --------------------------
2015-08-18T00:18:00Z    2.0835
2015-08-18T00:24:00Z    2.07775
2015-08-18T00:30:00Z    2.0615

查询返回每个字段键的四个字段值窗口的滚动平均值，该字段键存储数值并且在h2o_feet测量中包含单词level。

计算与字段键相关的字段值的移动平均，并包含多个子句

> SELECT MOVING_AVERAGE("water_level",2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' ORDER BY time DESC LIMIT 2 OFFSET 3

name: h2o_feet
time                   moving_average
----                   --------------
2015-08-18T00:06:00Z   2.072
2015-08-18T00:00:00Z   2.09

查询返回了在 h2o_feet 测量中 water_level 字段键的两个字段值窗口的滚动平均值。它涵盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z 并以降序时间戳顺序返回结果。查询还限制返回的点数为两个，并偏移结果三个点。

高级语法

SELECT MOVING_AVERAGE(<function> ([ * | <field_key> | /<regular_expression>/ ]) , N ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 MOVING_AVERAGE() 函数应用于这些结果。

MOVING_AVERAGE() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算最大值的移动平均

> SELECT MOVING_AVERAGE(MAX("water_level"),2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   moving_average
----                   --------------
2015-08-18T00:12:00Z   2.121
2015-08-18T00:24:00Z   2.0885

该查询返回2个值窗口的滚动平均值，maximum water_level在12分钟间隔计算。

为了获得这些结果，InfluxDB 首先在 12 分钟间隔计算最大 water_level。这一步与使用 MAX() 函数结合 GROUP BY time() 子句并且不使用 MOVING_AVERAGE() 是相同的：

> SELECT MAX("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)

name: h2o_feet
time                   max
----                   ---
2015-08-18T00:00:00Z   2.116
2015-08-18T00:12:00Z   2.126
2015-08-18T00:24:00Z   2.051

接下来，InfluxDB 在这两个最大值的窗口上计算滚动平均值。第一次最终结果 (2.121) 是前两个最大值的平均值 ((2.116 + 2.126) / 2)。

非负导数()

返回后续字段值之间的非负变化率。非负变化率包括正变化率和等于零的变化率。

基本语法

SELECT NON_NEGATIVE_DERIVATIVE( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

InfluxDB计算连续字段值之间的差异，并将这些结果转换为每个 unit 的变化率。 unit 参数是一个整数，后面跟着一个 duration literal，是可选的。如果查询没有指定 unit，单位默认是1秒 (1s)。 NON_NEGATIVE_DERIVATIVE() 只返回正的变化率或等于零的变化率。

NON_NEGATIVE_DERIVATIVE(field_key)
返回与字段键相关的后续字段值之间的非负变化率。

NON_NEGATIVE_DERIVATIVE(/regular_expression/)
返回与每个匹配正则表达式的字段键相关的后续字段值之间的非负变化率。

NON_NEGATIVE_DERIVATIVE(*)
返回与每个字段键相关联的后续字段值之间的非负变化率，关联的字段在measurement中。

NON_NEGATIVE_DERIVATIVE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，以标签分组，但不支持 GROUP BY 子句，以时间分组。请参阅高级语法部分了解如何使用 NON_NEGATIVE_DERIVATIVE() 与 GROUP BY time() 子句。

示例

请参阅DERIVATIVE()文档中的示例。NON_NEGATIVE_DERIVATIVE()的行为与DERIVATIVE()函数相同，但NON_NEGATIVE_DERIVATIVE()仅返回正的变化率或等于零的变化率。

高级语法

SELECT NON_NEGATIVE_DERIVATIVE(<function> ([ * | <field_key> | /<regular_expression>/ ]) [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 区间计算嵌套函数的结果，然后将 NON_NEGATIVE_DERIVATIVE() 函数应用于这些结果。

参数 unit 是一个整数，后面跟着一个持续时间字面量，它是可选的。如果查询没有指定 unit，则 unit 默认为 GROUP BY time() 的时间间隔。请注意，这种行为与基本语法的默认行为不同。 NON_NEGATIVE_DERIVATIVE() 仅返回正的变化率或等于零的变化率。

NON_NEGATIVE_DERIVATIVE() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

请查看DERIVATIVE() 文档中的示例。NON_NEGATIVE_DERIVATIVE() 的行为与 DERIVATIVE() 函数相同，但 NON_NEGATIVE_DERIVATIVE() 仅返回正的变化率或等于零的变化率。

非负差异()

返回后续字段值之间减法的非负结果。减法的非负结果包括正差和等于零的差。

基本语法

SELECT NON_NEGATIVE_DIFFERENCE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

NON_NEGATIVE_DIFFERENCE(field_key)
返回与字段键相关的后续字段值之间的非负差。

NON_NEGATIVE_DIFFERENCE(/regular_expression/)
返回与匹配正则表达式的每个字段键相关联的后续字段值之间的非负差值。

NON_NEGATIVE_DIFFERENCE(*)
返回与每个字段键关联的后续字段值之间的非负差。

NON_NEGATIVE_DIFFERENCE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。有关如何使用 NON_NEGATIVE_DIFFERENCE() 与 GROUP BY time() 子句，请参见高级语法部分。

示例

请查看DIFFERENCE()文档中的例子。NON_NEGATIVE_DIFFERENCE()的行为与DIFFERENCE()函数相同，但NON_NEGATIVE_DIFFERENCE()仅返回正差异或等于零的差异。

高级语法

SELECT NON_NEGATIVE_DIFFERENCE(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔计算嵌套函数的结果，然后将 NON_NEGATIVE_DIFFERENCE() 函数应用于这些结果。

NON_NEGATIVE_DIFFERENCE() 支持以下嵌套函数: COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

请参阅DIFFERENCE() 文档中的示例。NON_NEGATIVE_DIFFERENCE() 的行为与DIFFERENCE() 函数相同，但NON_NEGATIVE_DIFFERENCE() 仅返回正差异或等于零的差异。

POW()

返回字段值的x次方。

基本语法

SELECT POW( [ * | <field_key> ], <x> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

POW(field_key, x)
返回与字段关键字相关联的字段值的x次方。

POW(*, x)
返回与measurement中每个字段键相关联的字段值的x次方。

POW() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句来按标签分组，但不支持 GROUP BY 子句来按时间分组。请参阅高级语法部分以了解如何在 GROUP BY time() 子句中使用 POW()。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键的四次方相关的字段值

> SELECT POW("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  pow
----                  ---
2015-08-18T00:00:00Z  18.148417929216
2015-08-18T00:06:00Z  20.047612231936
2015-08-18T00:12:00Z  16.914992230656004
2015-08-18T00:18:00Z  20.429279055375993
2015-08-18T00:24:00Z  17.352898193760993
2015-08-18T00:30:00Z  17.69549197320101

查询返回h2o_feet测量中water_level字段键的字段值，乘以4的幂。

计算与测量中每个字段键关联的字段值的四次方

> SELECT POW(*, 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  pow_water_level
----                  ---------------
2015-08-18T00:00:00Z  18.148417929216
2015-08-18T00:06:00Z  20.047612231936
2015-08-18T00:12:00Z  16.914992230656004
2015-08-18T00:18:00Z  20.429279055375993
2015-08-18T00:24:00Z  17.352898193760993
2015-08-18T00:30:00Z  17.69549197320101

查询返回每个存储数值的字段键的字段值，这些值是在h2o_feet度量中乘以4的结果。 h2o_feet度量有一个数值字段：water_level。

计算与字段键相关的字段值，升至4次方，并包括多个子句

> SELECT POW("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  pow
----                  ---
2015-08-18T00:18:00Z  20.429279055375993
2015-08-18T00:12:00Z  16.914992230656004
2015-08-18T00:06:00Z  20.047612231936
2015-08-18T00:00:00Z  18.148417929216

查询返回与water_level字段键相关的字段值的四次方。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。查询还限制返回的点数为四个，并且偏移结果两个点。

高级语法

SELECT POW(<function>( [ * | <field_key> ] ), <x>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 时间间隔内计算嵌套函数的结果，然后将 POW() 函数应用于这些结果。

POW() 支持以下嵌套函数： COUNT()， MEAN()， MEDIAN()， MODE()， SUM()， FIRST()， LAST()， MIN()， MAX()，和 PERCENTILE()。

示例

计算4次方的平均值

> SELECT POW(MEAN("water_level"), 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  pow
----                  ---
2015-08-18T00:00:00Z  19.08029760999999
2015-08-18T00:12:00Z  18.609983417041
2015-08-18T00:24:00Z  17.523567165456008

查询返回在每12分钟间隔计算的平均值water_level，乘以4的幂。

要获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 POW() 是相同的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

然后，InfluxDB 计算这些平均值的四次方。

舍入()

返回四舍五入到最接近的整数的后续值。

基本语法

SELECT ROUND( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

ROUND(field_key)
返回与字段键相关的字段值，四舍五入到最接近的整数。

ROUND(*)
返回与每个字段键相关联的字段值, 在measurement中四舍五入到最接近的整数。

ROUND() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，即按标签分组，但不支持 GROUP BY 子句，即按时间分组。有关如何在 GROUP BY time() 子句中使用 ROUND() 的信息，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

与字段键相关的字段值取整

> SELECT ROUND("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  round
----                  -----
2015-08-18T00:00:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:18:00Z  2
2015-08-18T00:24:00Z  2
2015-08-18T00:30:00Z  2

该查询返回在 h2o_feet 测量中 water_level 字段键的字段值，四舍五入到最接近的整数。

将与测量中的每个字段键相关联的字段值四舍五入

> SELECT ROUND(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  round_water_level
----                  -----------------
2015-08-18T00:00:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:18:00Z  2
2015-08-18T00:24:00Z  2
2015-08-18T00:30:00Z  2

查询返回每个存储数值的字段键的字段值，h2o_feet 测量值四舍五入为最接近的整数。h2o_feet 测量值有一个数值字段：water_level。

四舍五入与字段键相关的字段值，并包含几个子句

> SELECT ROUND("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  round
----                  -----
2015-08-18T00:18:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:06:00Z  2
2015-08-18T00:00:00Z  2

该查询返回与water_level字段键关联的字段值，四舍五入到最接近的整数。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT ROUND(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先计算指定 GROUP BY time() 时间间隔内嵌套函数的结果，然后对这些结果应用 ROUND() 函数。

ROUND() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，和 PERCENTILE()。

示例

计算均值并四舍五入到最接近的整数

> SELECT ROUND(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  round
----                  -----
2015-08-18T00:00:00Z  2
2015-08-18T00:12:00Z  2
2015-08-18T00:24:00Z  2

查询返回在12分钟间隔内计算的平均water_level，并四舍五入到最接近的整数。

为了获得这些结果，InfluxDB 首先在 12 分钟的间隔内计算平均 water_level。这一步与使用 MEAN() 函数和 GROUP BY time() 子句而不使用 ROUND() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后将这些平均值四舍五入到最近的整数。

SIN()

返回字段值的正弦。

基本语法

SELECT SIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

SIN(field_key)
返回与字段键相关联的字段值的正弦值。

SIN(*)
返回与measurement中每个字段键相关的字段值的正弦。

SIN() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，以标签分组，但不支持 GROUP BY 子句，以时间分组。有关如何在 GROUP BY time() 子句中使用 SIN() 的信息，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键关联的字段值的正弦

> SELECT SIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  sin
----                  ---
2015-08-18T00:00:00Z  0.8808206017241819
2015-08-18T00:06:00Z  0.8550216851706579
2015-08-18T00:12:00Z  0.8972904165810275
2015-08-18T00:18:00Z  0.8497930984115993
2015-08-18T00:24:00Z  0.8914760289023131
2015-08-18T00:30:00Z  0.8869008523376968

查询返回h2o_feet测量中water_level字段键的值的正弦。

计算与测量中每个字段键相关的字段值的正弦

> SELECT SIN(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  sin_water_level
----                  ---------------
2015-08-18T00:00:00Z  0.8808206017241819
2015-08-18T00:06:00Z  0.8550216851706579
2015-08-18T00:12:00Z  0.8972904165810275
2015-08-18T00:18:00Z  0.8497930984115993
2015-08-18T00:24:00Z  0.8914760289023131
2015-08-18T00:30:00Z  0.8869008523376968

查询返回每个存储数字值的字段键的字段值的正弦值，属于h2o_feet测量。 h2o_feet测量有一个数值字段：water_level。

计算与字段键相关的字段值的正弦并包含几个子句

> SELECT SIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  sin
----                  ---
2015-08-18T00:18:00Z  0.8497930984115993
2015-08-18T00:12:00Z  0.8972904165810275
2015-08-18T00:06:00Z  0.8550216851706579
2015-08-18T00:00:00Z  0.8808206017241819

该查询返回与 water_level 字段键相关的字段值的正弦值。它涵盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z 并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT SIN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 区间计算嵌套函数的结果，然后对这些结果应用 SIN() 函数。

SIN() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算平均值的正弦

> SELECT SIN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  sin
----                  ---
2015-08-18T00:00:00Z  0.8682145834456126
2015-08-18T00:12:00Z  0.8745914945253902
2015-08-18T00:24:00Z  0.8891995555912935

查询返回在12分钟间隔内计算的平均 water_level的正弦值。

为了获得这些结果，InfluxDB 首先计算每 12 分钟间隔的平均 water_level。这一步与使用 MEAN() 函数配合 GROUP BY time() 子句且不使用 SIN() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

然后，InfluxDB 计算这些平均值的正弦。

SQRT()

返回字段值的平方根。

基本语法

SELECT SQRT( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

SQRT(field_key)
返回与字段键相关联的字段值的平方根。

SQRT(*)
返回与measurement中每个字段键相关联的平方根字段值。

SQRT() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。请参阅高级语法部分，了解如何将 SQRT() 与 GROUP BY time() 子句结合使用。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的平方根

> SELECT SQRT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  sqrt
----                  ----
2015-08-18T00:00:00Z  1.4366627996854378
2015-08-18T00:06:00Z  1.4546477236774544
2015-08-18T00:12:00Z  1.4240786495134319
2015-08-18T00:18:00Z  1.4580809305384939
2015-08-18T00:24:00Z  1.4286357128393508
2015-08-18T00:30:00Z  1.4321312788986909

查询返回 h2o_feet 测量中 water_level 字段键的字段值的平方根。

计算与测量中每个字段键相关的字段值的平方根

> SELECT SQRT(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  sqrt_water_level
----                  ----------------
2015-08-18T00:00:00Z  1.4366627996854378
2015-08-18T00:06:00Z  1.4546477236774544
2015-08-18T00:12:00Z  1.4240786495134319
2015-08-18T00:18:00Z  1.4580809305384939
2015-08-18T00:24:00Z  1.4286357128393508
2015-08-18T00:30:00Z  1.4321312788986909

查询返回每个存储数值的字段键的字段值的平方根，位于h2o_feet测量中。 h2o_feet测量有一个数值字段：water_level。

计算与字段键关联的字段值的平方根并包含多个子句

> SELECT SQRT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  sqrt
----                  ----
2015-08-18T00:18:00Z  1.4580809305384939
2015-08-18T00:12:00Z  1.4240786495134319
2015-08-18T00:06:00Z  1.4546477236774544
2015-08-18T00:00:00Z  1.4366627996854378

该查询返回与 water_level 字段键相关联的字段值的平方根。它覆盖了时间范围从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z 并按降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT SQRT(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 间隔内计算嵌套函数的结果，然后将 SQRT() 函数应用于这些结果。

SQRT() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX()，以及 PERCENTILE()。

示例

计算均值的平方根

> SELECT SQRT(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  sqrt
----                  ----
2015-08-18T00:00:00Z  1.445683229480096
2015-08-18T00:12:00Z  1.4411800720243115
2015-08-18T00:24:00Z  1.430384563675098

查询返回每12分钟计算的平均 水位的平方根。

为了获得这些结果，InfluxDB 首先以 12 分钟的间隔计算平均 water_level。此步骤与使用 MEAN() 函数结合 GROUP BY time() 子句且不使用 SQRT() 相同：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的平方根。

TAN()

返回字段值的正切。

基本语法

SELECT TAN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

TAN(field_key)
返回与字段键相关联的字段值的正切。

TAN(*)
返回与measurement中每个字段键相关联的字段值的切线。

TAN() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，按标签分组，但不支持 GROUP BY 子句，按时间分组。有关如何使用 TAN() 与 GROUP BY time() 子句，请参见高级语法部分。

示例

下面的示例使用以下子样本的 NOAA_water_database 数据：

> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  water_level
----                  -----------
2015-08-18T00:00:00Z  2.064
2015-08-18T00:06:00Z  2.116
2015-08-18T00:12:00Z  2.028
2015-08-18T00:18:00Z  2.126
2015-08-18T00:24:00Z  2.041
2015-08-18T00:30:00Z  2.051

计算与字段键相关的字段值的切线

> SELECT TAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  tan
----                  ---
2015-08-18T00:00:00Z  -1.8604293534384375
2015-08-18T00:06:00Z  -1.6487359603347427
2015-08-18T00:12:00Z  -2.0326408012302273
2015-08-18T00:18:00Z  -1.6121545688343464
2015-08-18T00:24:00Z  -1.9676434782626282
2015-08-18T00:30:00Z  -1.9198657720074992

查询返回在 h2o_feet 测量中 water_level 字段键的值的正切。

计算与测量中每个字段键相关联的字段值的切线

> SELECT TAN(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'

name: h2o_feet
time                  tan_water_level
----                  ---------------
2015-08-18T00:00:00Z  -1.8604293534384375
2015-08-18T00:06:00Z  -1.6487359603347427
2015-08-18T00:12:00Z  -2.0326408012302273
2015-08-18T00:18:00Z  -1.6121545688343464
2015-08-18T00:24:00Z  -1.9676434782626282
2015-08-18T00:30:00Z  -1.9198657720074992

查询返回每个存储数值的字段键的值的正切。h2o_feet 测量包含一个数值字段: water_level。

计算与字段键相关联的字段值的正切，并包含多个子句

> SELECT TAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  tan
----                  ---
2015-08-18T00:18:00Z  -1.6121545688343464
2015-08-18T00:12:00Z  -2.0326408012302273
2015-08-18T00:06:00Z  -1.6487359603347427
2015-08-18T00:00:00Z  -1.8604293534384375

查询返回与water_level字段键关联的值的切线。它涵盖了时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并按降序时间戳顺序返回结果。查询还限制返回的点数为四个，并偏移结果两个点。

高级语法

SELECT TAN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

高级语法需要一个 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先在指定的 GROUP BY time() 区间内计算嵌套函数的结果，然后对这些结果应用 TAN() 函数。

TAN() 支持以下嵌套函数： COUNT(), MEAN(), MEDIAN(), MODE(), SUM(), FIRST(), LAST(), MIN(), MAX(), 和 PERCENTILE()。

示例

计算平均值的正切

> SELECT TAN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                  tan
----                  ---
2015-08-18T00:00:00Z  -1.7497661902817365
2015-08-18T00:12:00Z  -1.8038002062256624
2015-08-18T00:24:00Z  -1.9435224805850773

该查询返回在12分钟间隔内计算的平均 water_level的正切值。

为了获得这些结果，InfluxDB 首先以 12 分钟的间隔计算平均 water_level。这个步骤与使用 MEAN() 函数结合 GROUP BY time() 子句而不使用 TAN() 是一样的：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077
2015-08-18T00:24:00Z   2.0460000000000003

InfluxDB 然后计算这些平均值的正切。

预测因素

HOLT_WINTERS()

返回N个预测的字段值，使用霍尔特-温特斯季节性方法。

使用 HOLT_WINTERS() 来:

预测数据值何时会超过给定阈值
将预测值与实际值进行比较，以检测数据中的异常

语法

SELECT HOLT_WINTERS[_WITH-FIT](<function>(<field_key>),<N>,<S>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]

HOLT_WINTERS(function(field_key),N,S) 返回 N 个季节性调整的预测字段值，针对指定的 field key。

预测的 N 值与 GROUP BY time() 的时间间隔相同。如果你的 GROUP BY time() 间隔是 6m 且 N 是 3，你将会收到三个每个间隔六分钟的预测值。

S 是季节模式参数，并根据 GROUP BY time() 时间间隔限定季节模式的长度。如果您的 GROUP BY time() 时间间隔为 2m，并且 S 为 3，那么季节模式每六分钟出现一次，也就是每三个数据点出现一次。如果您不想对预测值进行季节性调整，请将 S 设置为 0 或 1.

HOLT_WINTERS_WITH_FIT(function(field_key),N,S) 返回拟合值以及为指定字段键调整的 N 个季节性预测字段值。

HOLT_WINTERS() 和 HOLT_WINTERS_WITH_FIT() 处理在一致时间间隔内发生的数据；嵌套的 InfluxQL 函数和 GROUP BY time() 子句确保 Holt-Winters 函数在规则数据上操作。

HOLT_WINTERS() 和 HOLT_WINTERS_WITH_FIT() 支持 int64 和 float64 字段值数据类型。

示例

预测与字段键相关的字段值

原始数据

该示例使用 Chronograf 来可视化数据。该示例重点关注 NOAA_water_database 数据的以下子样本：

SELECT "water_level" FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-08-22 22:12:00' AND time <= '2015-08-28 03:00:00'

Raw Data

步骤 1：匹配原始数据的趋势

编写一个 GROUP BY time() 查询，以匹配原始 water_level 数据的总体趋势。在这里，我们使用 FIRST() 函数：

SELECT FIRST("water_level") FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' and time >= '2015-08-22 22:12:00' and time <= '2015-08-28 03:00:00' GROUP BY time(379m,348m)

在GROUP BY time()子句中，第一个参数(379m)匹配 water_level数据中每个峰值和谷值之间的时间长度。第二个参数(348m)是偏移间隔。偏移间隔改变默认的GROUP BY time()边界以匹配原始数据的时间范围。

蓝色线条显示了查询的结果：

First step

步骤 2：确定季节模式

使用步骤1中查询的信息识别数据中的季节性模式。

注意图表下方的蓝线，water_level 数据的模式大约每25小时15分钟重复一次。每个季节有四个数据点，所以4是季节性模式参数。

Second step

步骤 3：应用 HOLT_WINTERS() 函数

将霍尔特-温特斯函数添加到查询中。在这里，我们使用 HOLT_WINTERS_WITH_FIT() 查看拟合值和预测值：

SELECT HOLT_WINTERS_WITH_FIT(FIRST("water_level"),10,4) FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-08-22 22:12:00' AND time <= '2015-08-28 03:00:00' GROUP BY time(379m,348m)

在 HOLT_WINTERS_WITH_FIT() 函数中，第一个参数 (10) 请求 10 个预测字段值。每个预测点相隔 379m，与 GROUP BY time() 子句中的第一个参数相同。在 HOLT_WINTERS_WITH_FIT() 函数中的第二个参数 (4) 是我们在前一步确定的季节模式。

蓝色线条显示了查询的结果：

Third step

与 `HOLT_WINTERS()` 相关的常见问题

`HOLT_WINTERS()` 并且接收少于 `N` 个点

在某些情况下，用户可能会收到比N参数请求的预测点少的结果。这种行为发生在数学变得不稳定，无法预测更多的点时。这意味着HOLT_WINTERS()要么不适合该数据集，要么季节调整参数无效并使算法困惑。

技术分析

以下技术分析函数应用广泛使用的算法到您的数据。虽然它们主要用于金融和投资领域，但它们在其他行业和使用案例中也有应用。

CHANDE_MOMENTUM_OSCILLATOR()
EXPONENTIAL_MOVING_AVERAGE()
DOUBLE_EXPONENTIAL_MOVING_AVERAGE()
KAUFMANS_EFFICIENCY_RATIO()
KAUFMANS_ADAPTIVE_MOVING_AVERAGE()
TRIPLE_EXPONENTIAL_MOVING_AVERAGE()
TRIPLE_EXPONENTIAL_DERIVATIVE()
RELATIVE_STRENGTH_INDEX()

参数

除了一个 field key，技术分析函数接受以下参数：

`PERIOD`

必需，整数，最小值=1

算法的样本大小。这基本上是对算法输出有任何重要影响的历史样本数量。例如，2意味着当前点和其之前的点。算法使用指数衰减率来确定历史点的权重，通常称为α（alpha）。PERIOD控制衰减率。

注意：较旧的积分仍然可能产生影响。

`HOLD_PERIOD`

整数，最小值=-1

算法在开始输出结果之前需要多少个样本。 -1的默认值意味着该值基于算法、PERIOD，和WARMUP_TYPE，但这是一个算法可以输出有意义结果的值。

默认持有期:

对于大多数可用的技术分析，默认的 HOLD_PERIOD 是由您使用的技术分析算法和WARMUP_TYPE来决定的

算法 \ 热身类型	简单	指数	无
EXPONENTIAL_MOVING_AVERAGE	周期 - 1	周期 - 1	不适用
DOUBLE_EXPONENTIAL_MOVING_AVERAGE	( PERIOD - 1 ) * 2	PERIOD - 1	不适用
TRIPLE_EXPONENTIAL_MOVING_AVERAGE	( PERIOD - 1 ) * 3	PERIOD - 1	不适用
TRIPLE_EXPONENTIAL_DERIVATIVE	( PERIOD - 1 ) * 3 + 1	PERIOD	不适用
RELATIVE_STRENGTH_INDEX	周期	周期	不适用
CHANDE_MOMENTUM_OSCILLATOR	周期	周期	周期 - 1

考夫曼算法默认持有期:

算法	默认持有期限
KAUFMANS_EFFICIENCY_RATIO()	周期
KAUFMANS_ADAPTIVE_MOVING_AVERAGE()	周期

`WARMUP_TYPE`

默认=‘exponential’

这控制着算法如何为前 PERIOD 样本初始化自身。它本质上是具有不完整样本集的持续时间。

simple
首个PERIOD样本的简单移动平均（SMA）。这是ta-lib使用的方法。

exponential
带有缩放系数alpha (α) 的指数移动平均（EMA）。这基本上使用PERIOD=1作为第一个点，PERIOD=2作为第二个点，等等，直到算法消耗了PERIOD个点。当使用此方法且HOLD_PERIOD未指定或为-1时，算法可能会在样本量远小于simple的情况下开始发出点。

none
该算法根本不进行任何平滑处理。这是ta-lib使用的方法。当使用此方法并且未指定HOLD_PERIOD时，HOLD_PERIOD 默认为PERIOD - 1。

没有温暖类型仅在CHANDE_MOMENTUM_OSCILLATOR()函数中可用。

CHANDE_MOMENTUM_OSCILLATOR()

钱德动量振荡器（CMO）是由图沙尔·钱德开发的技术动量指标。 CMO指标通过计算最近所有较高数据点的总和与最近所有较低数据点的总和之间的差异来创建，然后将结果除以给定时间段内所有数据变动的总和。结果乘以100，以给出-100到+100的范围。 ^Source

基本语法

CHANDE_MOMENTUM_OSCILLATOR([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>, [warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

CHANDE_MOMENTUM_OSCILLATOR(field_key, 2)
返回与字段键相关的字段值，这些值使用Chande动量振荡器算法处理，周期为2，默认的保持期和预热类型。

CHANDE_MOMENTUM_OSCILLATOR(field_key, 10, 9, 'none')
返回与field key相关的字段值，该值使用Chande动量振荡器算法处理，周期为10，保持期为9，预热类型为none。

CHANDE_MOMENTUM_OSCILLATOR(MEAN(), 2) ... GROUP BY time(1d)
返回与字段键相关联的字段值的平均值，使用Chande动量振荡器算法处理，周期为2值，默认保持周期和预热类型。

注意： 当使用 GROUP BY 子句聚合数据时，您必须在对 CHANDE_MOMENTUM_OSCILLATOR() 函数的调用中包含一个聚合函数。

CHANDE_MOMENTUM_OSCILLATOR(/regular_expression/, 2)
返回与匹配的每个字段键相关联的字段值，该匹配是使用Chande动量振荡器算法处理的，周期为2，默认保持周期和预热类型。

CHANDE_MOMENTUM_OSCILLATOR(*, 2)
返回与每个字段键关联的字段值，在measurement中处理，使用Chande动量振荡器算法，周期为2值，使用默认的保持周期和预热类型。

CHANDE_MOMENTUM_OSCILLATOR() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句来按标签分组，但不支持 GROUP BY 子句来按时间分组。请参阅高级语法部分了解如何使用 CHANDE_MOMENTUM_OSCILLATOR() 与 GROUP BY time() 子句。

指数移动平均值()

指数移动平均（EMA）是一种移动平均，类似于简单移动平均，但对最新数据赋予更大的权重。它也被称为“指数加权移动平均”。这种移动平均对最近数据变化的反应比简单移动平均更快。

^来源

基本语法

EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回与字段键关联的字段值，这些值使用具有2值周期的指数移动平均算法处理，并采用默认的保持周期和预热类型。

EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回与字段键相关联的字段值，这些值使用指数移动平均算法进行处理，周期为10个值，保持期为9个值，且采用exponential预热类型。

EXPONENTIAL_MOVING_AVERAGE(MEAN(), 2) ... GROUP BY time(1d)
返回与字段键相关联的字段值的均值，使用带有2值周期的指数移动平均算法处理，以及默认的保持周期和预热类型。

注意： 当使用 GROUP BY 子句聚合数据时，您必须在调用 EXPONENTIAL_MOVING_AVERAGE() 函数时包含一个聚合函数。

EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键相关联的字段值，这些键与正则表达式匹配使用具有2值周期的指数移动平均算法处理，并使用默认的保持周期和预热类型。

EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回与每个字段键相关联的字段值，这些值在measurement中使用2值周期的指数移动平均算法处理，使用默认的保持周期和预热类型。

EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。请参阅高级语法部分，了解如何使用 EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句。

双指数移动平均（DOUBLE_EXPONENTIAL_MOVING_AVERAGE）

双重指数移动平均（DEMA）试图消除与移动平均相关的固有滞后，通过对最近值施加更多权重来实现。名称暗示这是通过应用双重指数平滑实现的，但事实并非如此。名称中的“双重”源于EMA的值被加倍这一事实。为了保持与实际数据的一致性并消除滞后，正从之前加倍的EMA中减去“EMA of EMA”的值。

^来源

基本语法

DOUBLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回与field key相关的字段值，使用双指数移动平均算法处理，周期为2的值，默认的保持周期和预热类型。

DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回与字段键相关的字段值，这些值是使用双重指数移动平均算法进行处理的，周期为10个值，保持期为9个值，以及exponential热身类型。

DOUBLE_EXPONENTIAL_MOVING_AVERAGE(MEAN(), 2) ... GROUP BY time(1d)
返回与字段键相关联的字段值的平均值，使用具有2值周期的双指数移动平均算法处理，并使用默认的保持周期和预热类型。

注意： 当使用 GROUP BY 子句聚合数据时，您必须在调用 DOUBLE_EXPONENTIAL_MOVING_AVERAGE() 函数时包含一个聚合函数。

DOUBLE_EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些键匹配正则表达式，并使用具有2值周期的双指数移动平均算法处理，采用默认的保持周期和预热类型。

DOUBLE_EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回与每个字段键相关联的字段值，来自measurement，使用双指数移动平均算法处理，周期为2的值，默认保持周期和预热类型。

DOUBLE_EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。请参阅高级语法部分，了解如何使用 DOUBLE_EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句。

卡夫曼效率比率()

考夫曼效率比率，简称“效率比率”（ER），通过将一定时期内的数据变化除以实现该变化所发生的数据移动的绝对总和来计算。结果比率介于0和1之间，值越高表示市场越有效率或趋势明显。

效率比率与Chande Momentum Oscillator (CMO) 非常相似。不同之处在于CMO考虑了市场方向，但如果你取绝对CMO并除以100，你就得到了效率比率。

^来源

基本语法

KAUFMANS_EFFICIENCY_RATIO([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>])

可用参数：

期间
 持有期间 (可选)

KAUFMANS_EFFICIENCY_RATIO(field_key, 2)
返回与字段键相关联的字段值，这些值使用效率指数算法处理，周期为2值，默认保持周期和预热类型。

KAUFMANS_EFFICIENCY_RATIO(field_key, 10, 10)
返回与字段键相关联的字段值，使用效率指数算法处理，具有10个值的周期和10个值的保持期。

KAUFMANS_EFFICIENCY_RATIO(MEAN(), 2) ... GROUP BY time(1d)
返回与field key相关的字段值的平均值，使用效率指数算法处理，周期为2值，默认持有周期。

注意： 在使用 GROUP BY 子句聚合数据时，您必须在对 KAUFMANS_EFFICIENCY_RATIO() 函数的调用中包含一个聚合函数。

KAUFMANS_EFFICIENCY_RATIO(/regular_expression/, 2)
返回与每个字段键相关联的字段值，这些键匹配正则表达式，使用效率指数算法处理，周期为2，使用默认的保持周期和预热类型。

KAUFMANS_EFFICIENCY_RATIO(*, 2)
返回与每个字段键相关联的字段值，该字段值在measurement中使用效率指数算法处理，周期为2值，并且默认持有周期和预热类型。

KAUFMANS_EFFICIENCY_RATIO() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句按标签分组，但不支持 GROUP BY 子句按时间分组。有关如何使用 KAUFMANS_EFFICIENCY_RATIO() 与 GROUP BY time() 子句的详细信息，请参见高级语法部分。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE()

Kaufman的自适应移动平均线（KAMA）是一种旨在考虑样本噪声或波动性的移动平均线。当数据波动相对较小且噪声较低时，KAMA将紧密跟随数据点。当数据波动加大时，KAMA将调整并从更远的距离跟随数据。这个趋势跟随指标可以用来识别整体趋势、把握转折点和过滤数据波动。

^来源

基本语法

KAUFMANS_ADAPTIVE_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>])

可用参数：
period
hold_period (可选)

KAUFMANS_ADAPTIVE_MOVING_AVERAGE(field_key, 2)
返回与字段关键相关联的字段值，通过使用具有2值周期的Kaufman自适应移动平均算法进行处理，以及默认的持有周期和预热类型。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE(field_key, 10, 10)
返回与字段键相关联的字段值，使用Kaufman自适应移动平均算法处理，具有10值周期和10值保持周期。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE(MEAN(), 2) ... GROUP BY time(1d)
返回与field key相关联的字段值的平均值，这些值使用Kaufman自适应移动平均算法处理，周期为2，默认保持周期。

注意： 当使用 GROUP BY 子句聚合数据时，您必须在调用 KAUFMANS_ADAPTIVE_MOVING_AVERAGE() 函数时包含一个聚合函数。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键相关联的字段值，这些字段键符合正则表达式，使用Kaufman自适应移动平均算法处理，周期为2值，并使用默认的保持周期和预热类型。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE(*, 2)
返回与每个字段键关联的字段值，在measurement中使用Kaufman自适应移动平均算法处理，周期为2，使用默认的保持期和热身类型。

KAUFMANS_ADAPTIVE_MOVING_AVERAGE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，进行按标签分组，但不支持 GROUP BY 子句，进行按时间分组。有关如何使用 KAUFMANS_ADAPTIVE_MOVING_AVERAGE() 与 GROUP BY time() 子句的内容，请参见高级语法部分。

三重指数移动平均()

三重指数移动平均（TEMA）旨在从传统移动平均中过滤掉波动性。虽然名字暗示它是三重指数平滑，但实际上它是一个单重指数移动平均、一个双重指数移动平均和一个三重指数移动平均的组合。

^来源

基本语法

TRIPLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

TRIPLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回与字段键相关联的字段值，这些值是使用具有2值周期的三重指数移动平均算法处理的，采用默认的保持周期和预热类型。

TRIPLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回与字段 ключ关联的字段值，使用三重指数移动平均算法处理，周期为10值，保持期为9值，采用exponential预热类型。

TRIPLE_EXPONENTIAL_MOVING_AVERAGE(MEAN(), 2) ... GROUP BY time(1d)
返回与field key相关联的字段值的平均值，使用周期为2的三重指数移动平均算法处理，并使用默认的保持周期和热身类型。

注意： 当使用 GROUP BY 子句聚合数据时，您必须在调用 TRIPLE_EXPONENTIAL_MOVING_AVERAGE() 函数时包含一个聚合函数。

TRIPLE_EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键匹配正则表达式，使用带有2个值周期的三重指数移动平均算法处理，并使用默认的保持周期和预热类型。

TRIPLE_EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回与每个字段键相关联的字段值，在measurement中，使用具有2值周期的三重指数移动平均算法处理，并使用默认的保持周期和预热类型。

TRIPLE_EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，这些子句按标签分组，但不支持 GROUP BY 子句，这些子句按时间分组。有关如何使用 TRIPLE_EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句的信息，请参见高级语法部分。

三重指数导数()

三重指数衍生指标，通常称为“TRIX”，是一种用于识别超卖和超买市场的振荡器，同时也可以作为动量指标。 TRIX计算数据输入在一定时间周期内的三重指数移动平均的对数。从上一个值中减去上一个值。这防止了短于定义周期的周期被指标考虑。

像许多振荡器一样，TRIX 在零线周围振荡。当用作振荡器时，正值表示市场超买，而负值表示市场超卖。当用作动量指标时，正值表明动量在增加，而负值表明动量在减少。许多分析师认为，当 TRIX 线上穿零线时，它给出买入信号；而当它收在零线以下时，它给出卖出信号。

^来源

基本语法

TRIPLE_EXPONENTIAL_DERIVATIVE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

TRIPLE_EXPONENTIAL_DERIVATIVE(field_key, 2)
返回与字段键相关联的字段值，这些值是使用具有2个值周期的三重指数导数算法处理的，并且采用默认的保持期和预热类型。

TRIPLE_EXPONENTIAL_DERIVATIVE(field_key, 10, 10, 'exponential')
返回与字段键关联的字段值，这些值使用三重指数导数算法处理，周期为10值，保持期为10值，预热类型为exponential。

TRIPLE_EXPONENTIAL_DERIVATIVE(MEAN(), 2) ... GROUP BY time(1d)
返回与field key相关联的字段值的均值，使用带有2个值周期的三重指数导数算法处理，采用默认的保持周期和预热类型。

注意： 在使用 GROUP BY 子句聚合数据时，您必须在调用 TRIPLE_EXPONENTIAL_DERIVATIVE() 函数时包含一个聚合函数。

TRIPLE_EXPONENTIAL_DERIVATIVE(/regular_expression/, 2)
返回与每个匹配正则表达式的字段键关联的字段值，这些字段值是使用具有2值周期的三重指数导数算法处理的，以及默认的保持周期和预热类型。

TRIPLE_EXPONENTIAL_DERIVATIVE(*, 2)
返回与每个字段键关联的字段值，在measurement中处理，使用2值周期的三重指数导数算法以及默认的保持周期和预热类型。

TRIPLE_EXPONENTIAL_DERIVATIVE() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句来按标签分组，但不支持 GROUP BY 子句来按时间分组。请参见高级语法部分，了解如何使用 TRIPLE_EXPONENTIAL_DERIVATIVE() 与 GROUP BY time() 子句。

相对强弱指数()

相对强弱指数（RSI）是一个动量指标，它比较指定时间段内最近上涨和下跌的幅度，以衡量数据变动的速度和变化。

^来源

基本语法

RELATIVE_STRENGTH_INDEX([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])

可用参数：

周期
 持有周期 (可选)
热身类型 (可选)

RELATIVE_STRENGTH_INDEX(field_key, 2)
返回与field key相关联的字段值，使用相对强弱指数算法处理，周期为2的值，默认保持周期和热身类型。

RELATIVE_STRENGTH_INDEX(field_key, 10, 10, 'exponential')
返回与字段键相关联的字段值，这些值使用相对强度指数算法处理，周期为10值，持有期为10值，以及exponential热身类型。

RELATIVE_STRENGTH_INDEX(MEAN(), 2) ... GROUP BY time(1d)
返回与field key相关联的字段值的均值，使用相对强弱指数算法处理，周期为2个值，默认保持周期和预热类型。

注意： 在使用 GROUP BY 子句聚合数据时，您必须在对 RELATIVE_STRENGTH_INDEX() 函数的调用中包含一个聚合函数。

RELATIVE_STRENGTH_INDEX(/regular_expression/, 2)
返回与每个字段键相关联的字段值，该字段键与正则表达式匹配，使用相对强弱指数算法处理，周期为2，采用默认的保持周期和热身类型。

RELATIVE_STRENGTH_INDEX(*, 2)
返回与每个字段键相关联的字段值，在measurement中使用相对强弱指数算法处理，周期为2的值，以及默认的持有时间和预热类型。

RELATIVE_STRENGTH_INDEX() 支持 int64 和 float64 字段值数据类型。

基本语法支持 GROUP BY 子句，可以按标签分组，但不支持 GROUP BY 子句，可以按时间分组。请参阅高级语法部分以了解如何使用 RELATIVE_STRENGTH_INDEX() 与 GROUP BY time() 子句。

其他

示例数据

本文档中使用的数据可以在示例数据页面下载。

函数的一般语法

在 SELECT 子句中指定多个函数

语法

SELECT <function>(),<function>() FROM_clause [...]

在一个 SELECT 语句中，用逗号 (,) 分隔多个函数。该语法适用于所有 InfluxQL 函数，除了 TOP() 和 BOTTOM()。SELECT 子句不支持与其他函数一起指定 TOP() 或 BOTTOM()。

示例

在一个查询中计算平均值和中位数字段值

> SELECT MEAN("water_level"),MEDIAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                  mean               median
----                  ----               ------
1970-01-01T00:00:00Z  4.442107025822522  4.124

查询返回平均值和中位数字段值在water_level字段键中。

在一个查询中计算两个字段的众数

> SELECT MODE("water_level"),MODE("level description") FROM "h2o_feet"

name: h2o_feet
time                  mode  mode_1
----                  ----  ------
1970-01-01T00:00:00Z  2.69  between 3 and 6 feet

查询返回mode字段值，针对water_level字段键和level description字段键。water_level的模式在mode列中，而level description的模式在mode_1列中。系统不能返回多个同名列，因此将第二个mode列重命名为mode_1。

请参见重命名输出字段键以了解如何配置输出列标题。

在一个查询中计算最小值和最大值字段

> SELECT MIN("water_level"), MAX("water_level") [...]

name: h2o_feet
time                  min    max
----                  ---    ---
1970-01-01T00:00:00Z  -0.61  9.964

查询返回最小和最大字段值在water_level字段键中。

请注意，查询返回 1970-01-01T00:00:00Z，这是InfluxDB等效的空时间戳，作为时间戳值。MIN() 和 MAX() 是选择器函数；当选择器函数是在 SELECT 子句中的唯一函数时，它返回一个特定的时间戳。由于 MIN() 和 MAX() 返回两个不同的时间戳（见下文），系统用空时间戳等效值覆盖这些时间戳。

>  SELECT MIN("water_level") FROM "h2o_feet"

name: h2o_feet
time                  min
----                  ---
2015-08-29T14:30:00Z  -0.61    <--- Timestamp 1

>  SELECT MAX("water_level") FROM "h2o_feet"

name: h2o_feet
time                  max
----                  ---
2015-08-29T07:24:00Z  9.964    <--- Timestamp 2

重命名输出字段键

语法

SELECT <function>() AS <field_key> [...]

默认情况下，函数返回的结果字段键与函数名称匹配。
包含一个 AS 子句来指定输出字段键的名称。

示例

指定输出字段键

> SELECT MEAN("water_level") AS "dream_name" FROM "h2o_feet"

name: h2o_feet
time                  dream_name
----                  ----------
1970-01-01T00:00:00Z  4.442107025822522

查询返回平均值字段的water_level字段键的值，并将输出字段键重命名为dream_name。没有AS子句，查询返回mean作为输出字段键：

> SELECT MEAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                  mean
----                  ----
1970-01-01T00:00:00Z  4.442107025822522

为多个函数指定输出字段键

> SELECT MEDIAN("water_level") AS "med_wat",MODE("water_level") AS "mode_wat" FROM "h2o_feet"

name: h2o_feet
time                  med_wat  mode_wat
----                  -------  --------
1970-01-01T00:00:00Z  4.124    2.69

该查询返回中位数和众数字段值，对于water_level字段键，并将输出字段键重命名为med_wat和mode_wat。没有AS子句时，查询将返回median和mode作为输出字段键：

> SELECT MEDIAN("water_level"),MODE("water_level") FROM "h2o_feet"

name: h2o_feet
time                  median  mode
----                  ------  ----
1970-01-01T00:00:00Z  4.124   2.69

更改未提供数据的区间报告的值

默认情况下，带有 InfluxQL 函数和GROUP BY time() 子句的查询在没有数据的时间段中报告空值。在GROUP BY子句的末尾包含fill()以更改该值。有关fill()的完整讨论，请参见数据探索。

函数的常见问题

以下部分描述了与所有函数、聚合函数和选择器函数的常见混淆来源。有关特定函数的常见问题，请参阅函数特定的文档：

去重()
BOTTOM()
PERCENTILE()
SAMPLE()
顶部()
ELAPSED()
HOLT_WINTERS()

所有函数

嵌套函数

一些 InfluxQL 函数支持在 SELECT 子句中嵌套：

COUNT() 与 DISTINCT()
CUMULATIVE_SUM()
DERIVATIVE()
DIFFERENCE()
ELAPSED()
MOVING_AVERAGE()
NON_NEGATIVE_DERIVATIVE()
HOLT_WINTERS() 和 HOLT_WINTERS_WITH_FIT()

对于其他函数，请使用 InfluxQL 的子查询在 FROM 子句中嵌套函数。有关使用子查询的更多信息，请参见数据探索页面。

查询现在之后的时间范围

大多数 SELECT 语句的默认时间范围在 1677-09-21 00:12:43.145224194 和 2262-04-11T23:47:16.854775806Z UTC 之间。对于带有 InfluxQL 函数和 GROUP BY time() 子句的 SELECT 语句，默认时间范围在 1677-09-21 00:12:43.145224194 UTC 和 now() 之间。

要查询在 now() 之后发生的时间戳数据，带有 InfluxQL 函数和 GROUP BY time() 子句的 SELECT 语句必须在 WHERE 子句提供一个替代的上限。请查看常见问题解答页面以获取示例。

聚合函数

理解返回的时间戳

一个带有聚合函数且在WHERE子句中没有时间范围的查询返回纪元0 (1970-01-01T00:00:00Z) 作为时间戳。 InfluxDB将纪元0视为空时间戳的等价物。一个包含时间范围的聚合函数查询在WHERE子句中返回下限时间作为时间戳。

示例

使用没有指定时间范围的聚合函数

> SELECT SUM("water_level") FROM "h2o_feet"

name: h2o_feet
time                   sum
----                   ---
1970-01-01T00:00:00Z   67777.66900000004

查询返回null时间戳（纪元0：1970-01-01T00:00:00Z）的InfluxDB等价物作为时间戳。SUM()在多个时间戳中聚合点，并且没有单个时间戳可以返回。

在指定时间范围内使用聚合函数

> SELECT SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z'

name: h2o_feet
time                  sum
----                  ---
2015-08-18T00:00:00Z  67777.66900000004

查询返回下限时间边界 (WHERE time >= '2015-08-18T00:00:00Z') 作为时间戳。

使用具有指定时间范围和GROUP BY time()子句的聚合函数

> SELECT SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:18:00Z' GROUP BY time(12m)

name: h2o_feet
time                  sum
----                  ---
2015-08-18T00:00:00Z  20.305
2015-08-18T00:12:00Z  19.802999999999997

查询返回每个 GROUP BY time() 时间间隔的下限时间界限作为时间戳。

将聚合函数与非聚合函数混合

聚合函数不支持在SELECT子句中指定独立的字段键或标签键。聚合函数返回一个单一的计算值，对于任何未聚合的字段或标签没有明显的单一值可返回。在SELECT子句中将独立的字段键或标签键与聚合函数一起包含将返回一个错误：

> SELECT SUM("water_level"),"location" FROM "h2o_feet"

ERR: error parsing query: mixing aggregate and non-aggregate queries is not supported

得到稍微不同的结果

对于某些聚合函数，在同一组 float64 点上执行相同的函数可能会产生略微不同的结果。 InfluxDB 在应用聚合函数之前不会对点进行排序；这种行为可能导致查询结果的细微差异。

选择器函数

理解返回的时间戳

由选择器函数返回的时间戳依赖于查询中的函数数量和查询中的其他子句：

使用单个选择器函数、单个字段键参数且没有 GROUP BY time() 子句的查询将返回在原始数据中出现的时间戳。使用单个选择器函数、多个字段键参数且没有 GROUP BY time() 子句的查询将返回在原始数据中出现的时间戳或 InfluxDB 相当于 null 时间戳（纪元 0： 1970-01-01T00:00:00Z）。

在WHERE子句中包含多个函数且没有时间范围的查询返回InfluxDB的空时间戳等效值（时间纪元 0: 1970-01-01T00:00:00Z）。在WHERE子句中包含多个函数且有时间范围的查询返回下限时间作为时间戳。

带有选择器函数和 GROUP BY time() 子句的查询返回每个 GROUP BY time() 时间间隔的下限。注意，SAMPLE() 函数与 GROUP BY time() 子句配对时表现出不同于其他选择器函数的行为。有关更多信息，请参见与 SAMPLE() 相关的常见问题。

示例

使用单个选择器函数，具有单个字段键且没有指定时间范围

> SELECT MAX("water_level") FROM "h2o_feet"

name: h2o_feet
time                  max
----                  ---
2015-08-29T07:24:00Z  9.964

> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z'

name: h2o_feet
time                  max
----                  ---
2015-08-29T07:24:00Z  9.964

查询返回出现在原始数据中的最大点的时间戳。

使用单个选择器函数，结合多个字段键且不指定时间范围

> SELECT FIRST(*) FROM "h2o_feet"

name: h2o_feet
time                  first_level description  first_water_level
----                  -----------------------  -----------------
1970-01-01T00:00:00Z  between 6 and 9 feet     8.12

> SELECT MAX(*) FROM "h2o_feet"

name: h2o_feet
time                  max_water_level
----                  ---------------
2015-08-29T07:24:00Z  9.964

第一个查询返回了null时间戳（纪元0：1970-01-01T00:00:00Z）在InfluxDB中的对应值作为时间戳。FIRST(*)返回两个时间戳（每个字段键对应一个在h2o_feet 测量值中），因此系统用null时间戳的对应值覆盖这些时间戳。

第二个查询返回原始数据中出现的最大点的时间戳。MAX(*)返回一个时间戳（h2o-feet度量只有一个数值字段），所以系统不会覆盖原始时间戳。

将选择器函数与其他函数结合使用，且不指定时间范围

> SELECT MAX("water_level"),MIN("water_level") FROM "h2o_feet"

name: h2o_feet
time                  max    min
----                  ---    ---
1970-01-01T00:00:00Z  9.964  -0.61

查询返回一个空时间戳（纪元0：1970-01-01T00:00:00Z）的InfluxDB等效值作为时间戳。MAX()和MIN()函数返回不同的时间戳，因此系统没有单一的时间戳可以返回。

在指定时间范围内使用选择器函数与另一个函数

> SELECT MAX("water_level"),MIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z'

name: h2o_feet
time                  max    min
----                  ---    ---
2015-08-18T00:00:00Z  9.964  -0.61

查询返回下限时间边界 (WHERE time >= '2015-08-18T00:00:00Z') 作为时间戳。

使用带有 GROUP BY time() 子句的选择器函数

> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:18:00Z' GROUP BY time(12m)

name: h2o_feet
time                  max
----                  ---
2015-08-18T00:00:00Z  8.12
2015-08-18T00:12:00Z  7.887

查询返回每个 GROUP BY time() 区间的下限时间作为时间戳。