InfluxQL 函数
此页面记录了早期版本的 InfluxDB OSS。InfluxDB OSS v2 是最新的稳定版本。请参阅 InfluxDB v2 文档。
使用 InfluxQL 函数聚合、选择、转换和预测数据。
内容
聚合函数
COUNT()
返回非空字段值的数量。
语法
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(*)
返回与指标中每个字段键关联的字段值数量。
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
该查询返回 h2o_feet 指标中每个包含单词 water 的字段键的非空字段值数量。
统计与字段键关联的字段值数量并包含多个子句
> 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 值替换为 fill_option。 COUNT() 报告没有数据的时间间隔的 0，而 fill(<fill_option>) 将任何 0 值替换为 fill_option。
示例
以下代码块中的第一个查询不包含 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
DISTINCT()
返回唯一字段值的列表。
语法
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)
返回与字段键关联的唯一字段值。
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 假设具有相同序列和时间戳的 数据点 是重复数据点，并且仅使用目标指标中最新的数据点覆盖任何重复数据点。
示例
以下代码块中的第一个查询使用 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
INTEGRAL()
返回后续字段值的曲线下面积。
语法
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 参数是一个整数，后跟一个 持续时间文字，它是可选的。如果查询未指定 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
该查询返回与 h2o_feet 指标中 water_level 字段键关联的字段值的曲线下面积（以秒为单位）。
计算与字段键关联的字段值的积分并指定 unit 选项
> 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
该查询返回与 h2o_feet 指标中 water_level 字段键关联的字段值的曲线下面积（以分钟为单位）。
计算与指标中每个字段键关联的字段值的积分并指定 unit 选项
> 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 指标中每个存储数值的字段键关联的字段值的曲线下面积（以分钟为单位）。 h2o_feet 指标有一个数值字段：water_level。
计算与匹配正则表达式的每个字段键关联的字段值的积分并指定 unit 选项
> 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
该查询返回 h2o_feet 指标中 water_level 字段键关联的字段值的曲线下面积（以分钟为单位）。它涵盖了 2015-08-18T00:00:00Z 和 2015-08-18T00:30:00Z 之间的时间范围，将结果分组为 12 分钟的时间间隔，并将返回的结果数限制为一个。
MEAN()
返回字段值的算术平均值（平均值）。
语法
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(*)
返回与指标中每个字段键关联的平均字段值。
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 填充空时间间隔，并将返回的点数和序列数限制为七个和一个。
MEDIAN()
返回排序后的字段值列表的中间值。
语法
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
该查询返回 h2o_feet 指标中 water_level 字段键的中间字段值。
计算与指标中每个字段键关联的中位数
> 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 填充空时间间隔，限制返回的点数和序列数分别为七个和一个，并偏移返回的序列数一个。
MODE()
返回字段值列表中最频繁的值。
语法
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
该查询返回 h2o_feet 指标中 level description 字段键中最频繁的字段值。
计算与指标中每个字段键关联的众数
> 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
该查询返回 h2o_feet 指标中每个包含单词 /water/ 的字段键的最频繁字段值。
计算与字段键关联的众数并包含多个子句
> 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()
返回最小和最大字段值之间的差值。
语法
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
该查询返回 h2o_feet 指标中 water_level 字段键中最小和最大字段值之间的差值。
计算与指标中每个字段键关联的范围
> 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 填充空时间间隔，限制返回的点数和序列数分别为三个和一个，并偏移返回的序列数一个。
STDDEV()
返回字段值的标准差。
语法
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(*)
返回与指标中每个字段键关联的字段值的标准差。
STDDEV() 支持 int64 和 float64 字段值 数据类型。
示例
计算与字段键关联的标准差
> SELECT STDDEV("water_level") FROM "h2o_feet"
name: h2o_feet
time stddev
---- ------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回 h2o_feet 指标中 water_level 字段键中字段值的标准差。
计算与指标中每个字段键关联的标准差
> 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 填充空时间间隔，限制返回的点数和序列数分别为两个和一个，并偏移返回的序列数一个。
SUM()
返回字段值的总和。
语法
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(*)
返回与指标中每个字段键关联的字段值的总和。
SUM() 支持 int64 和 float64 字段值 数据类型。
示例
计算与字段键关联的字段值的总和
> SELECT SUM("water_level") FROM "h2o_feet"
name: h2o_feet
time sum
---- ---
1970-01-01T00:00:00Z 67777.66900000004
该查询返回 h2o_feet 指标中 water_level 字段键中字段值的总和。
计算与指标中每个字段键关联的字段值的总和
> 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 填充空时间间隔，并将返回的点数和序列数限制为四个和一个。
选择器函数
BOTTOM()
返回最小的 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)
返回标签键的 N 个标签值的最小字段值。
BOTTOM(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键以及相关的标签和/或字段关联的最小 N 个字段值。
BOTTOM() 支持 int64 和 float64 字段值数据类型。
注意
- 如果多个最小值具有相同的字段值，
BOTTOM()将返回时间戳最早的字段值。 - 当与
INTO子句 结合使用时，BOTTOM()与其他 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 measurement 中的最小的三个字段值。
选择与两个标签的字段键关联的最小字段值
> 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
该查询返回 water_level 字段键中，2015-08-18T00:00:00Z 和 2015-08-18T00:54:00Z 之间每 24 分钟 间隔 的最小的三个值。它还以 降序时间戳 顺序返回结果。
请注意，GROUP BY time() 子句 不会覆盖点的原始时间戳。有关该行为的更详细说明，请参阅下面部分中的 问题 1。
BOTTOM() 的常见问题
带有 GROUP BY time() 子句的 BOTTOM()
带有 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(<field_key>,<tag_key>,<N>) 的查询可能返回的点数少于预期。如果标签键有 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 measurement。
第二个查询 显示 InfluxDB 在 bottom_water_levels measurement 中将 location 标签保留为标签。
> 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
FIRST()
语法
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)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的（由时间戳确定的）最旧的字段值。
FIRST() 支持所有字段值数据类型。
示例
选择与字段键关联的第一个字段值
> SELECT FIRST("level description") FROM "h2o_feet"
name: h2o_feet
time first
---- -----
2015-08-18T00:00:00Z between 6 and 9 feet
该查询返回 h2o_feet measurement 中与 level description 字段键关联的（由时间戳确定的）最旧的字段值。
选择与 measurement 中每个字段键关联的第一个字段值
> 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 measurement 中每个字段键的（由时间戳确定的）最旧的字段值。h2o_feet measurement 有两个字段键：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
该查询返回 h2o_feet measurement 中每个包含单词 level 的字段键的最旧字段值。
选择与字段键以及相关标签和字段关联的第一个值
> 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 之前的时间间隔。
LAST()
语法
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)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的（由时间戳确定的）最新的字段值。
LAST() 支持所有字段值数据类型。
示例
选择与字段键关联的最后一个字段值
> SELECT LAST("level description") FROM "h2o_feet"
name: h2o_feet
time last
---- ----
2015-09-18T21:42:00Z between 3 and 6 feet
该查询返回 h2o_feet measurement 中与 level description 字段键关联的（由时间戳确定的）最新的字段值。
选择与 measurement 中每个字段键关联的最后一个字段值
> 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 measurement 中每个字段键的（由时间戳确定的）最新的字段值。h2o_feet measurement 有两个字段键：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
该查询返回 h2o_feet measurement 中每个包含单词 level 的字段键的最新字段值。
选择与字段键以及相关标签和字段关联的最后一个字段值
> 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 填充空时间间隔，并将返回的点和序列的数量限制为四个和一个。
请注意，GROUP BY time() 子句 覆盖了点的原始时间戳。结果中的时间戳指示每个 12 分钟时间间隔的开始时间；结果中的第一个点涵盖 2015-08-17T23:48:00Z 到 2015-08-18T00:00:00Z 之前的时间间隔，结果中的最后一个点涵盖 2015-08-18T00:24:00Z 到 2015-08-18T00:36:00Z 之前的时间间隔。
MAX()
返回最大的字段值。
语法
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)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的最大的字段值。
MAX() 支持 int64 和 float64 字段值数据类型。
示例
选择与字段键关联的最大字段值
> SELECT MAX("water_level") FROM "h2o_feet"
name: h2o_feet
time max
---- ---
2015-08-29T07:24:00Z 9.964
该查询返回 h2o_feet measurement 中 water_level 字段键中的最大字段值。
选择与 measurement 中每个字段键关联的最大字段值
> SELECT MAX(*) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回 h2o_feet measurement 中每个存储数值的字段键的最大字段值。h2o_feet measurement 有一个数值字段：water_level。
选择与每个匹配正则表达式的字段键关联的最大字段值
> SELECT MAX(/level/) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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 填充空时间间隔，并将返回的点和序列的数量限制为四个和一个。
请注意，GROUP BY time() 子句 覆盖了点的原始时间戳。结果中的时间戳指示每个 12 分钟时间间隔的开始时间；结果中的第一个点涵盖 2015-08-17T23:48:00Z 到 2015-08-18T00:00:00Z 之前的时间间隔，结果中的最后一个点涵盖 2015-08-18T00:24:00Z 到 2015-08-18T00:36:00Z 之前的时间间隔。
MIN()
返回最小的字段值。
语法
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)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的最小的字段值。
MIN() 支持 int64 和 float64 字段值数据类型。
示例
选择与字段键关联的最小字段值
> SELECT MIN("water_level") FROM "h2o_feet"
name: h2o_feet
time min
---- ---
2015-08-29T14:30:00Z -0.61
该查询返回 h2o_feet measurement 中 water_level 字段键中的最小字段值。
选择与 measurement 中每个字段键关联的最小字段值
> SELECT MIN(*) FROM "h2o_feet"
name: h2o_feet
time min_water_level
---- ---------------
2015-08-29T14:30:00Z -0.61
该查询返回 h2o_feet measurement 中每个存储数值的字段键的最小字段值。h2o_feet measurement 有一个数值字段：water_level。
选择与每个匹配正则表达式的字段键关联的最小字段值
> SELECT MIN(/level/) FROM "h2o_feet"
name: h2o_feet
time min_water_level
---- ---------------
2015-08-29T14:30:00Z -0.61
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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 填充空时间间隔，并将返回的点和序列的数量限制为四个和一个。
请注意，GROUP BY time() 子句 覆盖了点的原始时间戳。结果中的时间戳指示每个 12 分钟时间间隔的开始时间；结果中的第一个点涵盖 2015-08-17T23:48:00Z 到 2015-08-18T00:00:00Z 之前的时间间隔，结果中的最后一个点涵盖 2015-08-18T00:24:00Z 到 2015-08-18T00:36:00Z 之前的时间间隔。
PERCENTILE()
返回第 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)
返回与 measurement 中每个字段键关联的第 N 个百分位数字段值。
PERCENTILE(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的第 N 个百分位数字段值。
N 必须是介于 0 和 100 之间（包括 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
该查询返回大于 h2o_feet measurement 中 water_level 字段键中百分之五的字段值的字段值。
选择与 measurement 中每个字段键关联的第五个百分位数字段值
> SELECT PERCENTILE(*,5) FROM "h2o_feet"
name: h2o_feet
time percentile_water_level
---- ----------------------
2015-08-31T03:42:00Z 1.122
该查询返回大于 h2o_feet measurement 中每个存储数值的字段键中百分之五的字段值的字段值。h2o_feet measurement 有一个数值字段：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 measurement 中每个存储数值并包含单词 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
该查询返回大于 water_level 字段键以及 location 标签键和 level description 字段键的相关值中百分之五的字段值的字段值。
选择与字段键关联的第二十个百分位数字段值，并包含多个子句
> 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 字段键中百分之二十的值的字段值。它涵盖了 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(<field_key>,100)等效于MAX(<field_key>)。PERCENTILE(<field_key>, 50)几乎等效于MEDIAN(<field_key>)，只是如果字段键包含偶数个字段值，则MEDIAN()函数返回两个中间值的平均值。PERCENTILE(<field_key>,0)不等效于MIN(<field_key>)。这是一个已知问题。
SAMPLE()
返回 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)
返回与 measurement 中每个字段键关联的 N 个随机选择的字段值。
SAMPLE(field_key,N),tag_key(s),field_key(s)
返回与括号中的字段键以及相关的 标签 和/或 字段 关联的 N 个随机选择的字段值。
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
该查询返回 h2o_feet measurement 中 water_level 字段键中的两个随机选择的点。
选择与 measurement 中每个字段键关联的字段值的样本
> 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 measurement 中每个字段键的两个随机选择的点。h2o_feet measurement 有两个字段键：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
该查询返回 h2o_feet measurement 中每个包含单词 level 的字段键的两个随机选择的点。
选择与字段键以及相关标签和字段关联的字段值的样本
> 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() 的常见问题
带有 GROUP BY time() 子句的 SAMPLE()
带有 SAMPLE() 和 GROUP BY time() 子句的查询返回每个 GROUP BY time() 间隔中指定数量的点 (N)。对于大多数 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
--
TOP()
返回最大的 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 个字段值。
TOP() 支持 int64 和 float64 字段值数据类型。
注意
示例
选择与字段键关联的最大的三个字段值
> 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
该查询返回 h2o_feet measurement 中 water_level 字段键中的最大的三个字段值。
选择与两个标签的字段键关联的最大字段值
> 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
该查询返回 water_level 字段键中，2015-08-18T00:00:00Z 和 2015-08-18T00:54:00Z 之间每 24 分钟 间隔 的最大的三个值。它还以 降序时间戳 顺序返回结果。
请注意，GROUP BY time() 子句 不会覆盖点的原始时间戳。有关该行为的更详细说明，请参阅下面部分中的 问题 1。
TOP() 的常见问题
带有 GROUP BY time() 子句的 TOP()
带有 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(<field_key>,<tag_key>,<N>) 的查询可能返回的点数少于预期。如果标签键有 X 个标签值，查询指定 N 个值，并且 X 小于 N，则查询返回 X 个点。
示例
以下查询请求 location 标签键的三个标签值的 water_level 的最大字段值。由于 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()、标签和 INTO 子句
当与 INTO 子句 结合使用且没有 GROUP BY tag 子句 时，大多数 InfluxQL 函数会将初始数据中的任何标签 转换 为新写入数据中的字段。此行为也适用于 TOP() 函数，除非 TOP() 将标签键作为参数包含在内：TOP(field_key,tag_key(s),N)。在这些情况下，系统会将指定的标签保留为新写入数据中的标签。
示例
以下代码块中的第一个查询返回与 location 标签键关联的两个标签值的 water_level 字段键中的最大字段值。它还将这些结果写入 top_water_levels measurement。
第二个查询 显示 InfluxDB 在 top_water_levels measurement 中将 location 标签保留为标签。
> 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(字段键)
返回与 字段键 关联的字段值的绝对值。
ABS(*)
返回与 指标 中每个字段键关联的字段值的绝对值。
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 分钟间隔计算的 a 的平均值的绝对值。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的 a 的平均值。 此步骤与使用带有 GROUP BY time() 子句且不带 ABS() 的 MEAN() 函数相同
> 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(字段键)
返回与 字段键 关联的字段值的反余弦值。
ACOS(*)
返回与 指标 中每个字段键关联的字段值的反余弦值。
ACOS() 支持值介于 -1 和 1 之间的 int64 和 float64 字段值 数据类型。
基本语法支持 GROUP BY 子句，该子句按标签分组，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 ACOS() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
示例
以下示例使用模拟公园占用率相对于总容量的数据样本。 需要注意的重要事项是，所有字段值都落在 ACOS() 函数的可计算范围（-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 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 指标中每个存储数值的字段键的字段值的反余弦值。 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 的平均值。 此步骤与使用带有 GROUP BY time() 子句且不带 ACOS() 的 MEAN() 函数相同
> 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(字段键)
返回与 字段键 关联的字段值的反正弦值。
ASIN(*)
返回与 指标 中每个字段键关联的字段值的反正弦值。
ASIN() 支持值介于 -1 和 1 之间的 int64 和 float64 字段值 数据类型。
基本语法支持 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 的平均值。 此步骤与使用带有 GROUP BY time() 子句且不带 ASIN() 的 MEAN() 函数相同
> 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(字段键)
返回与 字段键 关联的字段值的反正切值。
ATAN(*)
返回与 指标 中每个字段键关联的字段值的反正切值。
ATAN() 支持值介于 -1 和 1 之间的 int64 和 float64 字段值 数据类型。
基本语法支持 GROUP BY 子句，该子句按标签分组，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 ATAN() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
示例
以下示例使用模拟公园占用率相对于总容量的数据样本。 需要注意的重要事项是，所有字段值都落在 ATAN() 函数的可计算范围（-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 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 指标中每个存储数值的字段键的字段值的反正切值。 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 的平均值。 此步骤与使用带有 GROUP BY time() 子句且不带 ATAN() 的 MEAN() 函数相同
> 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(字段键_y, 字段键_x)
返回与 字段键 字段键_y 关联的字段值除以与 字段键_x 关联的字段值的反正切值。
ATAN2(*, 字段键_x)
返回 指标 中每个字段键关联的字段值除以与 字段键_x 关联的字段值。
ATAN2() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 GROUP BY 子句，该子句按标签分组，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 ATAN2() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
示例
以下示例使用模拟飞行数据样本
> 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
计算字段键_y 除以字段键_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 指标的一部分。
计算指标中每个字段键关联的值除以字段键_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
该查询返回 平均 altitude_ft 除以平均 distance_ft 的反正切值。 平均值以 12 分钟间隔计算。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的平均 altitude_ft 和 distance_ft。 此步骤与使用带有 GROUP BY time() 子句且不带 ATAN2() 的 MEAN() 函数相同：^
> 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 计算这些平均值的反正切值。
CEIL()
返回后续值向上舍入到最接近的整数。
基本语法
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(字段键)
返回与 字段键 关联的字段值向上舍入到最接近的整数。
CEIL(*)
返回 指标 中每个字段键关联的字段值向上舍入到最接近的整数。
CEIL() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 GROUP BY 子句，该子句按标签分组，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 CEIL() 与 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 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。 此步骤与使用带有 GROUP BY time() 子句且不带 CEIL() 的 MEAN() 函数相同
> 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(字段键)
返回与 字段键 关联的字段值的余弦值。
COS(*)
返回与 指标 中每个字段键关联的字段值的余弦值。
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。 此步骤与使用带有 GROUP BY time() 子句且不带 COS() 的 MEAN() 函数相同
> 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 计算这些平均值的余弦值。
CUMULATIVE_SUM()
返回后续字段值的运行总计。
基本语法
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(字段键)
返回与 字段键 关联的后续字段值的运行总计。
CUMULATIVE_SUM(/正则表达式/)
返回与每个匹配正则表达式的字段键关联的后续字段值的运行总计。
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
该查询返回 h2o_feet 指标中 water_level 字段键中字段值的运行总计。
计算与指标中每个字段键关联的字段值的累积总和
> 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 分钟间隔计算的 平均 water_level 的运行总计。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的平均 water_level。 此步骤与使用带有 GROUP BY time() 子句且不带 CUMULATIVE_SUM() 的 MEAN() 函数相同
> 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 的总和。
DERIVATIVE()
返回后续字段值之间变化率。
基本语法
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 参数是一个整数，后跟一个持续时间文字，它是可选的。 如果查询未指定 unit，则单位默认为一秒 (1s)。
DERIVATIVE(字段键)
返回与 字段键 关联的后续字段值之间的变化率。
DERIVATIVE(/正则表达式/)
返回与每个匹配正则表达式的字段键关联的后续字段值之间的变化率。
DERIVATIVE(*)
返回 指标 中每个字段键关联的后续字段值之间的变化率。
DERIVATIVE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 GROUP BY 子句，该子句按标签分组，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 DERIVATIVE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
示例
示例 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
该查询返回与 h2o_feet 指标中 water_level 字段键关联的字段值之间的一秒变化率。
第一个结果 (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
该查询返回与 h2o_feet 指标中 water_level 字段键关联的字段值之间的六分钟变化率。
第一个结果 (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 分钟间隔内计算的 平均 water_level 之间 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 之间 6 分钟的变化率。
为了获得这些结果，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 计算这些平均值之间 6 分钟的变化率。第一个结果 (-0.00649999999999995) 是前两个平均值之间 6 分钟的变化率。 InfluxDB 计算字段值之间的差值，并将该值归一化为 6 分钟的变化率。
(2.077 - 2.09) / (12m / 6m)
------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
DIFFERENCE()
返回后续 字段值 之间相减的结果。
基本语法
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 分钟间隔内计算的 最大 water_level 之间的差值。
为了获得这些结果，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 之间的差值。
ELAPSED()
返回后续 字段值 的时间戳之间的差值。
语法
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 选项是一个整数，后跟一个 持续时间字面量，它确定返回差值的单位。如果查询未指定 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
查询返回 h2o_feet 测量值中每个包含单词 level 的字段键的后续时间戳之间的差值（以秒为单位）。
计算与字段键相关的字段值之间经过的时间并包含多个子句
> 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
ELAPSED() 与 GROUP BY time() 子句
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() 子句一起使用，以查找 最小 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 子句。有关如何将 EXP() 与 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 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 计算这些平均值的指数。
FLOOR()
返回向下舍入到最接近整数的后续值。
基本语法
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 将这些平均值向下舍入到最接近的整数。
HISTOGRAM()
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)
返回与 字段键 相关的字段值的自然对数。
LN(*)
返回与 measurement 中每个字段键相关的字段值的自然对数。
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 分钟间隔内计算的 平均 water_level 的自然对数。
为了获得这些结果，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 计算这些平均值的自然对数。
LOG()
返回以 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)
返回以 b 为底的与 measurement 中每个字段键相关的字段值的对数。
LOG() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不 按时间间隔分组 的 GROUP BY 子句。有关如何将 LOG() 与 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
计算以 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
查询返回 h2o_feet 测量值中存储数值的每个字段键的以 4 为底的字段值的对数。 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
查询返回在 12 分钟间隔内计算的 平均 water_level 的以 4 为底的对数。
为了获得这些结果，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 为底的对数。
LOG2()
返回以 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 子句。有关如何将 LOG2() 与 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
计算以 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
查询返回在 12 分钟间隔内计算的 平均 water_level 的以 2 为底的对数。
为了获得这些结果，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 为底的与 measurement 中每个字段键相关的字段值的对数。
LOG10() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不 按时间间隔分组 的 GROUP BY 子句。有关如何将 LOG10() 与 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
计算以 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 分钟间隔内计算的 平均 water_level 值的以 10 为底的对数。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的平均 water_level 值。此步骤与使用带有 GROUP BY time() 子句但不带 LOG10() 的 MEAN() 函数相同
> 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 为底的对数。
MOVING_AVERAGE()
返回后续 字段值 窗口上的滚动平均值。
基本语法
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 个字段值的滚动平均值。
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
该查询返回在 12 分钟间隔内计算的 最大 water_level 值的两个值窗口上的滚动平均值。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的最大 water_level 值。此步骤与使用带有 GROUP BY time() 子句但不带 MOVING_AVERAGE() 的 MAX() 函数相同
> 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)。
NON_NEGATIVE_DERIVATIVE()
返回后续 字段值 之间非负的变化率。非负变化率包括正变化率和等于零的变化率。
基本语法
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 参数是一个整数，后跟一个 持续时间文字，它是可选的。如果查询未指定 unit，则单位默认为一秒 (1s)。NON_NEGATIVE_DERIVATIVE() 仅返回正变化率或等于零的变化率。
NON_NEGATIVE_DERIVATIVE(field_key)
返回与 字段键 关联的后续字段值之间非负的变化率。
NON_NEGATIVE_DERIVATIVE(/regular_expression/)
返回与每个与正则表达式匹配的字段键关联的后续字段值之间非负的变化率。
NON_NEGATIVE_DERIVATIVE(*)
返回与 测量 中每个字段键关联的后续字段值之间非负的变化率。
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() 仅返回正变化率或等于零的变化率。
NON_NEGATIVE_DIFFERENCE()
返回后续 字段值 之间非负的减法结果。非负的减法结果包括正差值和等于零的差值。
基本语法
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)
返回与 测量 中每个字段键关联的字段值的 x 次幂。
POW() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 POW() 与 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
计算与字段键关联的字段值的 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'
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 次幂。
计算与测量中每个字段键关联的字段值的 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 字段键关联的字段值，并将其乘以 4 次幂。它涵盖了 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 值。此步骤与使用带有 GROUP BY time() 子句但不带 POW() 的 MEAN() 函数相同
> 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 次幂。
ROUND()
返回后续值四舍五入到最接近的整数。
基本语法
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(*)
返回 测量 中每个字段键关联的字段值，四舍五入到最接近的整数。
ROUND() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 ROUND() 与 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 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 值。此步骤与使用带有 GROUP BY time() 子句但不带 ROUND() 的 MEAN() 函数相同
> 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(*)
返回 测量 中每个字段键关联的字段值的正弦值。
SIN() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不按时间间隔分组 的 GROUP BY 子句。 有关如何将 SIN() 与 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 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 值。此步骤与使用带有 GROUP BY time() 子句但不带 SIN() 的 MEAN() 函数相同
> 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(*)
返回 测量 中每个字段键关联的字段值的平方根。
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 分钟间隔内计算的 平均 water_level 值的平方根。
为了获得这些结果，InfluxDB 首先计算 12 分钟间隔的平均 water_level 值。此步骤与使用带有 GROUP BY time() 子句但不带 SQRT() 的 MEAN() 函数相同
> 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(*)
返回 测量 中每个字段键关联的字段值的正切值。
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 测量中每个存储数值的字段键的字段值的正切值。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 值。此步骤与使用带有 GROUP BY time() 子句但不带 TAN() 的 MEAN() 函数相同
> 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()
使用 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 个季节性调整的预测字段值。
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'
步骤 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() 边界以匹配原始数据的时间范围。
蓝线显示查询的结果
步骤 2：确定季节性模式
使用步骤 1 中查询的信息，识别数据中的季节性模式。
关注下图中的蓝线，water_level 数据中的模式大约每 25 小时 15 分钟重复一次。每个季节有四个数据点，因此 4 是季节性模式参数。
步骤 3：应用 HOLT_WINTERS() 函数
将 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) 是我们在上一步中确定的季节性模式。
蓝线显示查询的结果
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()
参数
除了 字段键 之外，技术分析函数还接受以下参数
PERIOD
必需，整数，最小值 = 1
算法的样本大小。这本质上是会对算法输出产生任何显著影响的历史样本的数量。例如，2 表示当前点和前一个点。该算法使用指数衰减率来确定历史点的权重，通常称为 alpha (α)。PERIOD 控制衰减率。
注意：较旧的点仍然可能产生影响。
HOLD_PERIOD
整数，最小值=-1
算法开始发出结果之前需要的样本数量。默认值 -1 表示该值基于算法、PERIOD 和 WARMUP_TYPE，但该值是算法可以发出有意义结果的值。
默认保持周期
对于大多数可用的技术分析，默认的 HOLD_PERIOD 由您使用的技术分析算法和 WARMUP_TYPE 决定
| 算法 \ 预热类型 | 简单 | 指数 | 无 |
|---|---|---|---|
| EXPONENTIAL_MOVING_AVERAGE（指数移动平均线） | PERIOD - 1 | PERIOD - 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（相对强弱指数） | PERIOD | PERIOD | 不适用 |
| CHANDE_MOMENTUM_OSCILLATOR（钱德动量摆荡指标） | PERIOD | PERIOD | PERIOD - 1 |
Kaufman 算法默认保持周期
| 算法 | 默认保持周期 |
|---|---|
| KAUFMANS_EFFICIENCY_RATIO() | PERIOD |
| KAUFMANS_ADAPTIVE_MOVING_AVERAGE() | PERIOD |
WARMUP_TYPE（预热类型）
default=‘exponential’
这控制算法在前 PERIOD 个样本中如何初始化自身。它本质上是算法具有不完整样本集的持续时间。
简单
前 PERIOD 个样本的简单移动平均线 (SMA)。这是 ta-lib 使用的方法。
指数
具有缩放 alpha (α) 的指数移动平均线 (EMA)。这基本上对第一个点使用 PERIOD=1 的 EMA，对第二个点使用 PERIOD=2，依此类推，直到算法消耗了 PERIOD 个点。由于算法立即开始使用 EMA，因此当使用此方法且 HOLD_PERIOD 未指定或为 -1 时，算法可能会在比使用 simple 方法更小的样本量后开始发出点。
无
算法根本不执行任何平滑处理。这是 ta-lib 使用的方法。当使用此方法且 HOLD_PERIOD 未指定时，HOLD_PERIOD 默认为 PERIOD - 1。
none预热类型仅适用于CHANDE_MOMENTUM_OSCILLATOR()函数。
CHANDE_MOMENTUM_OSCILLATOR()
钱德动量摆荡指标 (CMO) 是由 Tushar Chande 开发的技术动量指标。CMO 指标的创建方法是：计算最近所有较高数据点之和与最近所有较低数据点之和之间的差值，然后将结果除以给定时间段内所有数据移动的总和。结果乘以 100，得到 -100 到 +100 的范围。来源
基本语法
CHANDE_MOMENTUM_OSCILLATOR([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>, [warmup_type]])
可用参数
period（周期）
hold_period（保持周期） (可选)
warmup_type（预热类型） (可选)
CHANDE_MOMENTUM_OSCILLATOR(field_key, 2)
返回与 字段键 关联的字段值，这些字段值使用周期为 2 值的钱德动量摆荡指标算法以及默认的保持周期和预热类型进行处理。
CHANDE_MOMENTUM_OSCILLATOR(field_key, 10, 9, 'none')
返回与 字段键 关联的字段值，这些字段值使用周期为 10 值、保持周期为 9 值以及 none 预热类型的钱德动量摆荡指标算法进行处理。
CHANDE_MOMENTUM_OSCILLATOR(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的钱德动量摆荡指标算法以及默认的保持周期和预热类型进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对CHANDE_MOMENTUM_OSCILLATOR()函数的调用中包含一个 聚合函数。
CHANDE_MOMENTUM_OSCILLATOR(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的钱德动量摆荡指标算法以及默认的保持周期和预热类型进行处理。
CHANDE_MOMENTUM_OSCILLATOR(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的钱德动量摆荡指标算法以及默认的保持周期和预热类型进行处理。
CHANDE_MOMENTUM_OSCILLATOR() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 CHANDE_MOMENTUM_OSCILLATOR() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
EXPONENTIAL_MOVING_AVERAGE()
指数移动平均线 (EMA) 是一种移动平均线，它类似于 简单移动平均线，但更侧重于最新数据。它也称为“指数加权移动平均线”。与简单移动平均线相比，这种类型的移动平均线对近期数据变化的反应更快。
基本语法
EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用参数
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(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的指数移动平均线算法以及默认的保持周期和预热类型进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对EXPONENTIAL_MOVING_AVERAGE()函数的调用中包含一个 聚合函数。
EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的指数移动平均线算法以及默认的保持周期和预热类型进行处理。
EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的指数移动平均线算法以及默认的保持周期和预热类型进行处理。
EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE()
双指数移动平均线 (DEMA) 试图通过更侧重于近期值来消除与移动平均线相关的固有滞后。名称表明这是通过应用双指数平滑来实现的，但事实并非如此。“双”这个名称源于 EMA 的值被加倍。为了使其与实际数据保持一致并消除滞后，从先前加倍的 EMA 中减去了“EMA 的 EMA”的值。
基本语法
DOUBLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用参数
period（周期）
hold_period（保持周期） (可选)
warmup_type（预热类型） (可选)
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回与 字段键 关联的字段值，这些字段值使用周期为 2 值的双指数移动平均线算法以及默认的保持周期和预热类型进行处理。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回与 字段键 关联的字段值，这些字段值使用周期为 10 值、保持周期为 9 值以及 exponential 预热类型的双指数移动平均线算法进行处理。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(MEAN(<field_key>), 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)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的双指数移动平均线算法以及默认的保持周期和预热类型进行处理。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 DOUBLE_EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
KAUFMANS_EFFICIENCY_RATIO()
Kaufman 效率比率，或简称“效率比率” (ER)，是通过将一段时间内的数据变化除以实现该变化的数据移动的绝对总和来计算的。由此产生的比率范围在 0 到 1 之间，值越高表示市场效率越高或趋势性越强。
ER 与 钱德动量摆荡指标 (CMO) 非常相似。不同之处在于，CMO 考虑了市场方向，但如果您取 CMO 的绝对值并除以 100，您将得到效率比率。
基本语法
KAUFMANS_EFFICIENCY_RATIO([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>])
可用参数
period（周期）
hold_period（保持周期） (可选)
KAUFMANS_EFFICIENCY_RATIO(field_key, 2)
返回与 字段键 关联的字段值，这些字段值使用周期为 2 值的效率指数算法以及默认的保持周期和预热类型进行处理。
KAUFMANS_EFFICIENCY_RATIO(field_key, 10, 10)
返回与 字段键 关联的字段值，这些字段值使用周期为 10 值和保持周期为 10 值的效率指数算法进行处理。
KAUFMANS_EFFICIENCY_RATIO(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的效率指数算法以及默认的保持周期进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对KAUFMANS_EFFICIENCY_RATIO()函数的调用中包含一个 聚合函数。
KAUFMANS_EFFICIENCY_RATIO(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的效率指数算法以及默认的保持周期和预热类型进行处理。
KAUFMANS_EFFICIENCY_RATIO(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 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)
返回与 字段键 关联的字段值，这些字段值使用周期为 10 值和保持周期为 10 值的 Kaufman 自适应移动平均线算法进行处理。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的 Kaufman 自适应移动平均线算法以及默认的保持周期进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对KAUFMANS_ADAPTIVE_MOVING_AVERAGE()函数的调用中包含一个 聚合函数。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的 Kaufman 自适应移动平均线算法以及默认的保持周期和预热类型进行处理。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的 Kaufman 自适应移动平均线算法以及默认的保持周期和预热类型进行处理。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 KAUFMANS_ADAPTIVE_MOVING_AVERAGE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE()
三重指数移动平均线 (TEMA) 的开发目的是滤除传统移动平均线的波动率。虽然名称暗示它是三重指数平滑，但实际上它是 单指数移动平均线、双指数移动平均线 和三重指数移动平均线的组合。
基本语法
TRIPLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用参数
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(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的三重指数移动平均线算法以及默认的保持周期和预热类型进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对TRIPLE_EXPONENTIAL_MOVING_AVERAGE()函数的调用中包含一个 聚合函数。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的三重指数移动平均线算法以及默认的保持周期和预热类型进行处理。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的三重指数移动平均线算法以及默认的保持周期和预热类型进行处理。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 TRIPLE_EXPONENTIAL_MOVING_AVERAGE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
TRIPLE_EXPONENTIAL_DERIVATIVE()
三重指数导数指标，通常称为“TRIX”，是一种用于识别超卖和超买市场的震荡指标，也可用作动量指标。TRIX 计算 三重指数移动平均线，该平均线基于数据输入在时间段内的 对数。从前一个值中减去前一个值。这可以防止周期短于定义周期的循环被指标考虑在内。
与许多震荡指标一样，TRIX 在零线附近震荡。当用作震荡指标时，正值表示超买市场，而负值表示超卖市场。当用作动量指标时，正值表示动量正在增加，而负值表示动量正在减少。许多分析师认为，当 TRIX 向上穿过零线时，会发出买入信号；当它向下穿过零线时，会发出卖出信号。
基本语法
TRIPLE_EXPONENTIAL_DERIVATIVE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用参数
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(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的三重指数导数算法以及默认的保持周期和预热类型进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对TRIPLE_EXPONENTIAL_DERIVATIVE()函数的调用中包含一个 聚合函数。
TRIPLE_EXPONENTIAL_DERIVATIVE(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的三重指数导数算法以及默认的保持周期和预热类型进行处理。
TRIPLE_EXPONENTIAL_DERIVATIVE(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的三重指数导数算法以及默认的保持周期和预热类型进行处理。
TRIPLE_EXPONENTIAL_DERIVATIVE() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 TRIPLE_EXPONENTIAL_DERIVATIVE() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
RELATIVE_STRENGTH_INDEX()
相对强弱指数 (RSI) 是一种动量指标，它比较指定时间段内近期上涨和下跌的幅度，以衡量数据移动的速度和变化。
基本语法
RELATIVE_STRENGTH_INDEX([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用参数
period（周期）
hold_period（保持周期） (可选)
warmup_type（预热类型） (可选)
RELATIVE_STRENGTH_INDEX(field_key, 2)
返回与 字段键 关联的字段值，这些字段值使用周期为 2 值的相对强弱指数算法以及默认的保持周期和预热类型进行处理。
RELATIVE_STRENGTH_INDEX(field_key, 10, 10, 'exponential')
返回与 字段键 关联的字段值，这些字段值使用周期为 10 值、保持周期为 10 值以及 exponential 预热类型的相对强弱指数算法进行处理。
RELATIVE_STRENGTH_INDEX(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回与 字段键 关联的字段值的平均值，这些字段值使用周期为 2 值的相对强弱指数算法以及默认的保持周期和预热类型进行处理。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对RELATIVE_STRENGTH_INDEX()函数的调用中包含一个 聚合函数。
RELATIVE_STRENGTH_INDEX(/regular_expression/, 2)
返回与每个字段键关联的字段值，这些字段键与 正则表达式 匹配，并使用周期为 2 值的相对强弱指数算法以及默认的保持周期和预热类型进行处理。
RELATIVE_STRENGTH_INDEX(*, 2)
返回与 指标 中每个字段键关联的字段值，这些字段值使用周期为 2 值的相对强弱指数算法以及默认的保持周期和预热类型进行处理。
RELATIVE_STRENGTH_INDEX() 支持 int64 和 float64 字段值 数据类型。
基本语法支持 按标签分组 的 GROUP BY 子句，但不支持 按时间间隔分组 的 GROUP BY 子句。有关如何将 RELATIVE_STRENGTH_INDEX() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法 部分。
其他
示例数据
本文档中使用的数据可在 示例数据 页面上下载。
函数的通用语法
在 SELECT 子句中指定多个函数
语法
SELECT <function>(),<function>() FROM_clause [...]
在一个 SELECT 语句中使用逗号 (,) 分隔多个函数。此语法适用于除 TOP() 和 BOTTOM() 之外的所有 InfluxQL 函数。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
该查询返回 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() 的完整讨论，请参阅 数据探索。
函数常见问题
以下部分描述了所有函数、聚合函数和选择器函数常见的混淆来源。有关各个函数的常见问题，请参阅特定于函数的文档
所有函数
嵌套函数
某些 InfluxQL 函数支持在 SELECT 子句 中进行嵌套
COUNT()与DISTINCT()CUMULATIVE_SUM()DERIVATIVE()DIFFERENCE()ELAPSED()MOVING_AVERAGE()NON_NEGATIVE_DERIVATIVE()HOLT_WINTERS()和HOLT_WINTERS_WITH_FIT()
对于其他函数，请使用 InfluxQL 的 子查询 在 FROM 子句 中嵌套函数。有关使用子查询的更多信息，请参阅 数据探索 页面。
查询 now() 之后的时间范围
大多数 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 子句 中没有时间范围的查询返回 epoch 0 (1970-01-01T00:00:00Z) 作为时间戳。InfluxDB 使用 epoch 0 作为空时间戳等效值。带有聚合函数的查询，如果在 WHERE 子句中包含时间范围，则返回较低的时间界限作为时间戳。
示例
使用没有指定时间范围的聚合函数
> SELECT SUM("water_level") FROM "h2o_feet"
name: h2o_feet
time sum
---- ---
1970-01-01T00:00:00Z 67777.66900000004
该查询返回 InfluxDB 等效的空时间戳（epoch 0：1970-01-01T00:00:00Z）作为时间戳。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 等效的空时间戳（epoch 0：1970-01-01T00:00:00Z）。
带有多个函数且 WHERE 子句 中没有时间范围的查询返回 InfluxDB 等效的空时间戳（epoch 0：1970-01-01T00:00:00Z）。带有多个函数且 WHERE 子句中包含时间范围的查询返回较低的时间界限作为时间戳。
带有选择器函数和 GROUP BY time() 子句的查询返回每个 GROUP BY time() 时间间隔的较低时间界限。请注意，当与 GROUP BY time() 子句配对使用时，SAMPLE() 函数的行为与其他选择器函数不同。有关更多信息，请参阅 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
第一个查询返回 InfluxDB 等效的空时间戳（epoch 0: 1970-01-01T00:00:00Z）作为时间戳。FIRST(*) 返回两个时间戳（h2o_feet measurement 中的每个字段键一个），因此系统使用等效的空时间戳覆盖这些时间戳。
第二个查询返回原始数据中出现的最大数据点的时间戳。MAX(*) 返回一个时间戳（h2o-feet measurement 只有一个数值字段），因此系统不会覆盖原始时间戳。
使用选择器函数和另一个函数，且不指定时间范围
> 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
该查询返回 InfluxDB 等效的空时间戳（epoch 0: 1970-01-01T00:00:00Z）作为时间戳。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() 时间间隔的较低时间边界作为时间戳。
此页是否对您有帮助？
感谢您的反馈！