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(*)
返回与 measurement 中每个字段键关联的字段值的数量。
COUNT() 支持所有字段值数据类型。InfluxQL 支持与 DISTINCT() 嵌套使用。
示例
计算与字段键关联的字段值的数量
> SELECT COUNT("water_level") FROM "h2o_feet"
name: h2o_feet
time count
---- -----
1970-01-01T00:00:00Z 15258
该查询返回 h2o_feet measurement 中 water_level 字段键的非空字段值的数量。
计算与 measurement 中每个字段键关联的字段值的数量
> SELECT COUNT(*) FROM "h2o_feet"
name: h2o_feet
time count_level description count_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z 15258 15258
该查询返回与 h2o_feet measurement 关联的每个字段键的非空字段值的数量。该 h2o_feet measurement 有两个字段键：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 measurement 中每个包含单词 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 measurement 的唯一字段值的数量。
COUNT() 的常见问题
COUNT() 和 fill()
大多数 InfluxQL 函数对于没有数据的时间间隔报告 null 值，并且 fill(<fill_option>) 用 fill_option 替换该 null 值。COUNT() 对于没有数据的时间间隔报告 0，并且 fill(<fill_option>) 用 fill_option 替换任何 0 值。
示例
以下代码块中的第一个查询不包含 fill()。最后一个时间间隔没有数据，因此该时间间隔的报告值为零。第二个查询包含 fill(800000)；它用 800000 替换了最后一个间隔中的零。
> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m)
name: h2o_feet
time count
---- -----
2015-09-18T21:24:00Z 2
2015-09-18T21:36:00Z 2
2015-09-18T21:48:00Z 0
> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m) fill(800000)
name: h2o_feet
time count
---- -----
2015-09-18T21:24:00Z 2
2015-09-18T21:36:00Z 2
2015-09-18T21:48:00Z 800000
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 支持与 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 measurement 中 level description 字段键的唯一字段值的表格列表。
列出与 measurement 中每个字段键关联的不同字段值
> 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 measurement 中每个字段键的唯一字段值的表格列表。该 h2o_feet measurement 有两个字段键：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 measurement 的唯一字段值的数量。
DISTINCT() 的常见问题
DISTINCT() 和 INTO 子句
将 DISTINCT() 与 INTO 子句一起使用可能会导致 InfluxDB 覆盖目标 measurement 中的点。DISTINCT() 通常返回多个具有相同时间戳的结果；InfluxDB 假设具有相同 series 和时间戳的点是重复点，并简单地用目标 measurement 中最近的点覆盖任何重复点。
示例
以下代码块中的第一个查询使用 DISTINCT() 函数并返回四个结果。请注意，每个结果都具有相同的时间戳。第二个查询在初始查询中添加了一个 INTO 子句，并将查询结果写入 distincts measurement。代码块中的最后一个查询选择 distincts measurement 中的所有数据。
最后一个查询返回一个点，因为最初的四个结果是重复点；它们属于同一个 series 并且具有相同的时间戳。当系统遇到重复点时，它会简单地用最近的点覆盖之前的点。
> 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(*)
返回 measurement 中每个字段键的平均字段值。
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 measurement 中 water_level 字段键关联的字段值的曲线下面积（以秒为单位）。
计算与字段键关联的字段值的积分并指定单位选项
> 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 measurement 中 water_level 字段键关联的字段值的曲线下面积（以分钟为单位）。
计算与 measurement 中每个字段键关联的字段值的积分并指定单位选项
> 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 measurement 中每个存储数值的字段键关联的字段值的曲线下面积（以分钟为单位）。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的字段值的积分并指定单位选项
> SELECT INTEGRAL(/water/,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time integral_water_level
---- --------------------
1970-01-01T00:00:00Z 62.211
该查询返回与 h2o_feet measurement 中每个存储数值并包含单词 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 measurement 中 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(*)
返回 measurement 中每个字段键的平均字段值。
MEAN() 支持 int64 和 float64 字段值数据类型。
示例
计算与字段键关联的平均字段值
> SELECT MEAN("water_level") FROM "h2o_feet"
name: h2o_feet
time mean
---- ----
1970-01-01T00:00:00Z 4.442107025822522
该查询返回 h2o_feet measurement 中 water_level 字段键的平均字段值。
计算与 measurement 中每个字段键关联的平均字段值
> SELECT MEAN(*) FROM "h2o_feet"
name: h2o_feet
time mean_water_level
---- ----------------
1970-01-01T00:00:00Z 4.442107025822522
该查询返回 h2o_feet measurement 中每个存储数值的字段键的平均字段值。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的平均字段值
> SELECT MEAN(/water/) FROM "h2o_feet"
name: h2o_feet
time mean_water_level
---- ----------------
1970-01-01T00:00:00Z 4.442107025822523
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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(*)
返回与 measurement 中每个字段键关联的中间字段值。
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 measurement 中 water_level 字段键的中间字段值。
计算与 measurement 中每个字段键关联的中位数
> SELECT MEDIAN(*) FROM "h2o_feet"
name: h2o_feet
time median_water_level
---- ------------------
1970-01-01T00:00:00Z 4.124
该查询返回 h2o_feet measurement 中每个存储数值的字段键的中间字段值。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的中位数
> SELECT MEDIAN(/water/) FROM "h2o_feet"
name: h2o_feet
time median_water_level
---- ------------------
1970-01-01T00:00:00Z 4.124
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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(*)
返回与 measurement 中每个字段键关联的最频繁的字段值。
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 measurement 中 level description 字段键的最频繁的字段值。
计算与 measurement 中每个字段键关联的众数
> 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 measurement 中每个字段键的最频繁的字段值。该 h2o_feet measurement 有两个字段键：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 measurement 中每个包含单词 /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(*)
返回与 measurement 中每个字段键关联的最小和最大字段值之间的差值。
SPREAD() 支持 int64 和 float64 字段值数据类型。
示例
计算与字段键关联的字段值的范围
> SELECT SPREAD("water_level") FROM "h2o_feet"
name: h2o_feet
time spread
---- ------
1970-01-01T00:00:00Z 10.574
该查询返回 h2o_feet measurement 中 water_level 字段键的最小和最大字段值之间的差值。
计算与 measurement 中每个字段键关联的字段值的范围
> SELECT SPREAD(*) FROM "h2o_feet"
name: h2o_feet
time spread_water_level
---- ------------------
1970-01-01T00:00:00Z 10.574
该查询返回 h2o_feet measurement 中每个存储数值的字段键的最小和最大字段值之间的差值。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的字段值的范围
> SELECT SPREAD(/water/) FROM "h2o_feet"
name: h2o_feet
time spread_water_level
---- ------------------
1970-01-01T00:00:00Z 10.574
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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(*)
返回与 measurement 中每个字段键关联的字段值的标准差。
STDDEV() 支持 int64 和 float64 字段值数据类型。
示例
计算与字段键关联的字段值的标准差
> SELECT STDDEV("water_level") FROM "h2o_feet"
name: h2o_feet
time stddev
---- ------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回 h2o_feet measurement 中 water_level 字段键的字段值的标准差。
计算与 measurement 中每个字段键关联的字段值的标准差
> SELECT STDDEV(*) FROM "h2o_feet"
name: h2o_feet
time stddev_water_level
---- ------------------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回 h2o_feet measurement 中每个存储数值的字段键的字段值的标准差。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的字段值的标准差
> SELECT STDDEV(/water/) FROM "h2o_feet"
name: h2o_feet
time stddev_water_level
---- ------------------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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(*)
返回与 measurement 中每个字段键关联的字段值的总和。
SUM() 支持 int64 和 float64 字段值数据类型。
示例
计算与字段键关联的字段值的总和
> SELECT SUM("water_level") FROM "h2o_feet"
name: h2o_feet
time sum
---- ---
1970-01-01T00:00:00Z 67777.66900000004
该查询返回 h2o_feet measurement 中 water_level 字段键的字段值的总和。
计算与 measurement 中每个字段键关联的字段值的总和
> SELECT SUM(*) FROM "h2o_feet"
name: h2o_feet
time sum_water_level
---- ---------------
1970-01-01T00:00:00Z 67777.66900000004
该查询返回 h2o_feet measurement 中每个存储数值的字段键的字段值的总和。h2o_feet measurement 有一个数值字段：water_level。
计算与每个匹配正则表达式的字段键关联的字段值的总和
> SELECT SUM(/water/) FROM "h2o_feet"
name: h2o_feet
time sum_water_level
---- ---------------
1970-01-01T00:00:00Z 67777.66900000004
该查询返回 h2o_feet measurement 中每个存储数值并包含单词 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
该查询返回 h2o_feet measurement 中 water_level 字段键的最小的三个字段值。
为两个标签选择与字段键关联的最小字段值
> 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
该查询返回 2015-08-18T00:00:00Z 和 2015-08-18T00:54:00Z 之间每个 24 分钟间隔的 water_level 字段键中的最小的三个值。它还以时间戳降序返回结果。
请注意， GROUP BY time() 子句不会覆盖点的原始时间戳。有关该行为的更详细说明，请参阅下面部分中的问题 1。
BOTTOM() 的常见问题
BOTTOM() 和 GROUP BY time() 子句
带有 BOTTOM() 和 GROUP BY time() 子句的查询为每个 GROUP BY time() 间隔返回指定数量的点。对于大多数 GROUP BY time() 查询，返回的时间戳标记 GROUP BY time() 间隔的开始。带有 BOTTOM() 函数的 GROUP BY time() 查询的行为有所不同；它们保留原始数据点的时间戳。
示例
以下查询为每个 18 分钟 GROUP BY time() 间隔返回两个点。请注意，返回的时间戳是点的原始时间戳；它们不会强制匹配 GROUP BY time() 间隔的开始。
> SELECT BOTTOM("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)
name: h2o_feet
time bottom
---- ------
__
2015-08-18T00:00:00Z 2.064 |
2015-08-18T00:12:00Z 2.028 | <------- Smallest points for the first time interval
--
__
2015-08-18T00:24:00Z 2.041 |
2015-08-18T00:30:00Z 2.051 | <------- Smallest points for the second time interval --
BOTTOM() 和标签键的标签值少于 N 个
语法为 SELECT BOTTOM(<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(field_key,tag_key(s),N)，否则此行为也适用于 BOTTOM() 函数。在这些情况下，系统会将指定的标签保留为新写入数据中的标签。
示例
以下代码块中的第一个查询返回与 location 标签键关联的两个标签值的 water_level 字段键中的最小字段值。它还将这些结果写入 bottom_water_levels measurement。
第二个查询 显示 InfluxDB 将 location 标签保留为 bottom_water_levels measurement 中的标签。
> 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(*)
返回与指标中每个字段键关联的最旧的字段值（由时间戳确定）。
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
该查询返回与 level description 字段键和 h2o_feet 指标关联的最旧的字段值（由时间戳确定）。
选择与指标中每个字段键关联的第一个字段值
> SELECT FIRST(*) FROM "h2o_feet"
name: h2o_feet
time first_level description first_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z between 6 and 9 feet 8.12
该查询返回 h2o_feet 指标中每个字段键的最旧字段值（由时间戳确定）。h2o_feet 指标有两个字段键：level description 和 water_level。
选择与匹配正则表达式的每个字段键关联的第一个字段值
> SELECT FIRST(/level/) FROM "h2o_feet"
name: h2o_feet
time first_level description first_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z between 6 and 9 feet 8.12
该查询返回 h2o_feet 指标中每个包含单词 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(*)
返回与指标中每个字段键关联的最新字段值（由时间戳确定）。
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
该查询返回与 level description 字段键和 h2o_feet 指标关联的最新字段值（由时间戳确定）。
选择与指标中每个字段键关联的最后一个字段值
> SELECT LAST(*) FROM "h2o_feet"
name: h2o_feet
time last_level description last_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z between 3 and 6 feet 4.938
该查询返回 h2o_feet 指标中每个字段键的最新字段值（由时间戳确定）。h2o_feet 指标有两个字段键：level description 和 water_level。
选择与匹配正则表达式的每个字段键关联的最后一个字段值
> SELECT LAST(/level/) FROM "h2o_feet"
name: h2o_feet
time last_level description last_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z between 3 and 6 feet 4.938
该查询返回 h2o_feet 指标中每个包含单词 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(*)
返回与指标中每个字段键关联的最大字段值。
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 指标中 water_level 字段键的最大字段值。
选择与指标中每个字段键关联的最大字段值
> SELECT MAX(*) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回 h2o_feet 指标中每个存储数值的字段键的最大字段值。h2o_feet 指标有一个数值字段：water_level。
选择与匹配正则表达式的每个字段键关联的最大字段值
> SELECT MAX(/level/) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回 h2o_feet 指标中每个存储数值并包含单词 water 的字段键的最大字段值。
选择与字段键以及相关标签和字段关联的最大字段值
> SELECT MAX("water_level"),"location","level description" FROM "h2o_feet"
name: h2o_feet
time max location level description
---- --- -------- -----------------
2015-08-29T07:24:00Z 9.964 coyote_creek at or greater than 9 feet
该查询返回 water_level 字段键中的最大字段值，以及 location 标签键和 level description 字段键的相关值。
选择与字段键关联的最大字段值并包含多个子句
> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time max
---- ---
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.12
2015-08-18T00:12:00Z 7.887
2015-08-18T00:24:00Z 7.635
该查询返回 water_level 字段键中的最大字段值。它涵盖了 2015-08-17T23:48:00Z 和 2015-08-18T00:54:00Z 之间的时间范围，并将结果分组为 12 分钟的时间间隔并按标签分组。该查询使用 9.01 填充空时间间隔，并限制返回的点和序列的数量分别为四个和一个。
请注意，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(*)
返回与指标中每个字段键关联的最小字段值。
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 指标中 water_level 字段键的最小字段值。
选择与指标中每个字段键关联的最小字段值
> SELECT MIN(*) FROM "h2o_feet"
name: h2o_feet
time min_water_level
---- ---------------
2015-08-29T14:30:00Z -0.61
该查询返回 h2o_feet 指标中每个存储数值的字段键的最小字段值。h2o_feet 指标有一个数值字段：water_level。
选择与匹配正则表达式的每个字段键关联的最小字段值
> SELECT MIN(/level/) FROM "h2o_feet"
name: h2o_feet
time min_water_level
---- ---------------
2015-08-29T14:30:00Z -0.61
该查询返回 h2o_feet 指标中每个存储数值并包含单词 water 的字段键的最小字段值。
选择与字段键以及相关标签和字段关联的最小字段值
> SELECT MIN("water_level"),"location","level description" FROM "h2o_feet"
name: h2o_feet
time min location level description
---- --- -------- -----------------
2015-08-29T14:30:00Z -0.61 coyote_creek below 3 feet
该查询返回 water_level 字段键中的最小字段值，以及 location 标签键和 level description 字段键的相关值。
选择与字段键关联的最小字段值并包含多个子句
> SELECT MIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time min
---- ---
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.005
2015-08-18T00:12:00Z 7.762
2015-08-18T00:24:00Z 7.5
该查询返回 water_level 字段键中的最小字段值。它涵盖了 2015-08-17T23:48:00Z 和 2015-08-18T00:54:00Z 之间的时间范围，并将结果分组为 12 分钟的时间间隔并按标签分组。该查询使用 9.01 填充空时间间隔，并限制返回的点和序列的数量分别为四个和一个。
请注意，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)
返回与指标中每个字段键关联的第 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 指标中 water_level 字段键中百分之五的字段值的字段值。
选择与指标中每个字段键关联的第五个百分位数字段值
> SELECT PERCENTILE(*,5) FROM "h2o_feet"
name: h2o_feet
time percentile_water_level
---- ----------------------
2015-08-31T03:42:00Z 1.122
该查询返回大于 h2o_feet 指标中每个存储数值的字段键中百分之五的字段值的字段值。h2o_feet 指标有一个数值字段：water_level。
选择与匹配正则表达式的每个字段键关联的第五个百分位数字段值
> SELECT PERCENTILE(/level/,5) FROM "h2o_feet"
name: h2o_feet
time percentile_water_level
---- ----------------------
2015-08-31T03:42:00Z 1.122
该查询返回大于 h2o_feet 指标中每个存储数值并包含单词 water 的字段键中百分之五的字段值的字段值。
选择与字段键以及相关标签和字段关联的第五个百分位数字段值
> SELECT PERCENTILE("water_level",5),"location","level description" FROM "h2o_feet"
name: h2o_feet
time percentile location level description
---- ---------- -------- -----------------
2015-08-31T03:42:00Z 1.122 coyote_creek below 3 feet
该查询返回大于 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)
返回与指标中每个字段键关联的 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 指标中 water_level 字段键中随机选择的两个点。
选择与指标中每个字段键关联的字段值的样本
> SELECT SAMPLE(*,2) FROM "h2o_feet"
name: h2o_feet
time sample_level description sample_water_level
---- ------------------------ ------------------
2015-08-25T17:06:00Z 3.284
2015-09-03T04:30:00Z below 3 feet
2015-09-03T20:06:00Z between 3 and 6 feet
2015-09-08T21:54:00Z 3.412
该查询返回 h2o_feet 指标中每个字段键随机选择的两个点。h2o_feet 指标有两个字段键：level description 和 water_level。
选择与匹配正则表达式的每个字段键关联的字段值的样本
> SELECT SAMPLE(/level/,2) FROM "h2o_feet"
name: h2o_feet
time sample_level description sample_water_level
---- ------------------------ ------------------
2015-08-30T05:54:00Z between 6 and 9 feet
2015-09-07T01:18:00Z 7.854
2015-09-09T20:30:00Z 7.32
2015-09-13T19:18:00Z between 3 and 6 feet
该查询返回 h2o_feet 指标中每个包含单词 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 字段值数据类型。
注意
- 如果两个或多个值的最大值存在并列，则
TOP()返回具有最早时间戳的字段值。 - 当与 <代码>INTO 子句 结合使用时，
TOP()与其他 InfluxQL 函数不同。有关更多信息，请参阅 常见问题 部分。
示例
选择与字段键关联的前三个字段值
> SELECT TOP("water_level",3) FROM "h2o_feet"
name: h2o_feet
time top
---- ---
2015-08-29T07:18:00Z 9.957
2015-08-29T07:24:00Z 9.964
2015-08-29T07:30:00Z 9.954
该查询返回 h2o_feet 指标中 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
该查询返回 2015-08-18T00:00:00Z 和 2015-08-18T00:54:00Z 之间每个 24 分钟间隔的 water_level 字段键中最大的三个值。它还以降序时间戳顺序返回结果。
请注意，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 指标。
第二个查询 显示 InfluxDB 将 location 标签保留为 top_water_levels 指标中的标签。
> SELECT TOP("water_level","location",2) INTO "top_water_levels" FROM "h2o_feet"
name: result
time written
---- -------
1970-01-01T00:00:00Z 2
> SHOW TAG KEYS FROM "top_water_levels"
name: top_water_levels
tagKey
------
location
转换函数
ABS()
返回字段值的绝对值。
基本语法
SELECT ABS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ABS(field_key)
返回与字段键关联的字段值的绝对值。
ABS(*)
返回与指标中每个字段键关联的字段值的绝对值。
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。此步骤与将 MEAN() 函数与 GROUP BY time() 子句一起使用且不带 ABS() 相同
> SELECT MEAN("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T13:00:00Z' GROUP BY time(12m)
name: data
time mean
---- ----
1529841600000000000 -0.3960977256302787
1529842320000000000 0.0010541018316373302
1529843040000000000 0.04494733240283668
1529843760000000000 0.2553594777104415
1529844480000000000 0.20382988543108413
1529845200000000000 -0.790836070736962
然后，InfluxDB 计算这些平均值的绝对值。
ACOS()
返回字段值的反余弦值（以弧度为单位）。字段值必须介于 -1 和 1 之间。
基本语法
SELECT ACOS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ACOS(field_key)
返回与字段键关联的字段值的反余弦值。
ACOS(*)
返回与指标中每个字段键关联的字段值的反余弦值。
ACOS() 支持 int64 和 float64 字段值数据类型，值介于 -1 和 1 之间。
基本语法支持按标签分组的 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。此步骤与将 MEAN() 函数与 GROUP BY time() 子句一起使用且不带 ACOS() 相同
> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time mean
---- ----
2017-04-30T00:00:00Z 0.565
2017-05-03T00:00:00Z 0.41
2017-05-06T00:00:00Z 0.71
2017-05-09T00:00:00Z 0.16
然后，InfluxDB 计算这些平均值的反余弦值。
ASIN()
返回字段值的反正弦值（以弧度为单位）。字段值必须介于 -1 和 1 之间。
基本语法
SELECT ASIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ASIN(field_key)
返回与字段键关联的字段值的反正弦值。
ASIN(*)
返回与指标中每个字段键关联的字段值的反正弦值。
ASIN() 支持 int64 和 float64 字段值数据类型，值介于 -1 和 1 之间。
基本语法支持按标签分组的 GROUP BY 子句，但不按时间间隔分组的 GROUP BY 子句。有关如何将 ASIN() 与 GROUP BY time() 子句一起使用的信息，请参阅高级语法部分。
示例
以下示例使用模拟公园占用率相对于总容量的数据样本。需要注意的重要事项是，所有字段值都落在 ASIN() 函数的可计算范围 (-1 到 1) 内
> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time capacity
---- --------
2017-05-01T00:00:00Z 0.83
2017-05-02T00:00:00Z 0.3
2017-05-03T00:00:00Z 0.84
2017-05-04T00:00:00Z 0.22
2017-05-05T00:00:00Z 0.17
2017-05-06T00:00:00Z 0.77
2017-05-07T00:00:00Z 0.64
2017-05-08T00:00:00Z 0.72
2017-05-09T00:00:00Z 0.16
计算与字段键关联的字段值的反正弦值
> SELECT ASIN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time asin
---- ----
2017-05-01T00:00:00Z 0.9791076843683526
2017-05-02T00:00:00Z 0.3046926540153975
2017-05-03T00:00:00Z 0.9972832223717997
2017-05-04T00:00:00Z 0.22181447049679442
2017-05-05T00:00:00Z 0.1708296691291045
2017-05-06T00:00:00Z 0.8788411516685797
2017-05-07T00:00:00Z 0.6944982656265559
2017-05-08T00:00:00Z 0.8038023189330299
2017-05-09T00:00:00Z 0.1606906529519106
该查询返回 park_capacity measurement 中 of_capacity 字段键的反正弦值。
计算 measurement 中与每个字段键关联的字段值的反正弦值
> 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 measurement 中存储数值的每个字段键的字段值的反正弦值。h2o_feet measurement 有一个数值字段：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(field_key)
返回与 字段键 关联的字段值的反正切值。
ATAN(*)
返回 measurement 中与每个字段键关联的字段值的反正切值。
ATAN() 支持 int64 和 float64 字段值 数据类型，其值必须介于 -1 和 1 之间。
基本语法支持按 标签分组 的 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 measurement 中 of_capacity 字段键的反正切值。
计算 measurement 中与每个字段键关联的字段值的反正切值
> 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 measurement 中存储数值的每个字段键的字段值的反正切值。park_occupancy measurement 有一个数值字段：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(field_key_y, field_key_x)
返回与 字段键 field_key_y 关联的字段值除以与 field_key_x 关联的字段值的反正切值。
ATAN2(*, field_key_x)
返回 measurement 中与每个字段键关联的字段值除以与 field_key_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
计算 field_key_y 除以 field_key_x 的反正切值
> SELECT ATAN2("altitude_ft", "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'
name: flight_data
time atan2
---- -----
2018-05-16T12:01:00Z 0.020478631571881498
2018-05-16T12:02:00Z 0.04754142349303296
2018-05-16T12:03:00Z 0.07292147724575364
2018-05-16T12:04:00Z 0.09495251193874832
2018-05-16T12:05:00Z 0.11490822875441563
2018-05-16T12:06:00Z 0.13176409347584003
2018-05-16T12:07:00Z 0.14923587589682233
2018-05-16T12:08:00Z 0.1671059946640312
2018-05-16T12:09:00Z 0.18182893717409565
2018-05-16T12:10:00Z 0.1937028631495223
该查询返回 flight_data measurement 中 altitude_ft 字段键的字段值除以 distance_ft 字段键的值的反正切值。
计算 measurement 中与每个字段键关联的值除以 field_key_x 的反正切值
> SELECT ATAN2(*, "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'
name: flight_data
time atan2_altitude_ft atan2_distance_ft
---- ----------------- -----------------
2018-05-16T12:01:00Z 0.020478631571881498 0.7853981633974483
2018-05-16T12:02:00Z 0.04754142349303296 0.7853981633974483
2018-05-16T12:03:00Z 0.07292147724575364 0.7853981633974483
2018-05-16T12:04:00Z 0.09495251193874832 0.7853981633974483
2018-05-16T12:05:00Z 0.11490822875441563 0.7853981633974483
2018-05-16T12:06:00Z 0.13176409347584003 0.7853981633974483
2018-05-16T12:07:00Z 0.14923587589682233 0.7853981633974483
2018-05-16T12:08:00Z 0.1671059946640312 0.7853981633974483
2018-05-16T12:09:00Z 0.18182893717409565 0.7853981633974483
2018-05-16T12:10:00Z 0.19370286314952234 0.7853981633974483
该查询返回 flight_data measurement 中所有数值字段值除以 distance_ft 字段键的值的反正切值。flight_data measurement 有两个数值字段：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(field_key)
返回与 字段键 关联的字段值，向上舍入到最接近的整数。
CEIL(*)
返回 measurement 中与每个字段键关联的字段值，向上舍入到最接近的整数。
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 measurement 中 water_level 字段键的字段值，向上舍入到最接近的整数。
计算 measurement 中与每个字段键关联的字段值的上限值
> 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 measurement 中存储数值的每个字段键的字段值，向上舍入到最接近的整数。h2o_feet measurement 有一个数值字段：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(field_key)
返回与 字段键 关联的字段值的余弦值。
COS(*)
返回 measurement 中与每个字段键关联的字段值的余弦值。
COS() 支持 int64 和 float64 字段值 数据类型。
基本语法支持按 标签分组 的 GROUP BY 子句，但不支持按 时间分组 的 GROUP BY 子句。有关如何将 COS() 与 GROUP BY time() 子句一起使用的信息，请参阅 高级语法 部分。
示例
以下示例使用 NOAA_water_database 数据 的以下子样本：^
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
计算与字段键关联的字段值的余弦值
> SELECT COS("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time cos
---- ---
2015-08-18T00:00:00Z -0.47345017433543124
2015-08-18T00:06:00Z -0.5185922462666872
2015-08-18T00:12:00Z -0.4414407189100776
2015-08-18T00:18:00Z -0.5271163912192579
2015-08-18T00:24:00Z -0.45306786455514825
2015-08-18T00:30:00Z -0.4619598230611262
该查询返回 h2o_feet measurement 中 water_level 字段键的字段值的余弦值。
计算 measurement 中与每个字段键关联的字段值的余弦值
> 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 measurement 中存储数值的每个字段键的字段值的余弦值。h2o_feet measurement 有一个数值字段：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(field_key)
返回与 字段键 关联的后续字段值的运行总和。
CUMULATIVE_SUM(/regular_expression/)
返回与每个匹配 正则表达式 的字段键关联的后续字段值的运行总和。
CUMULATIVE_SUM(*)
返回 measurement 中与每个字段键关联的后续字段值的运行总和。
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 measurement 中 water_level 字段键的字段值的运行总和。
计算 measurement 中与每个字段键关联的字段值的累积总和
> 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 measurement 中存储数值的每个字段键的字段值的运行总和。h2o_feet measurement 有一个数值字段：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 measurement 中每个存储数值且包含单词 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(field_key)
返回与 字段键 关联的后续字段值之间的变化率。
DERIVATIVE(/regular_expression/)
返回与每个匹配 正则表达式 的字段键关联的后续字段值之间的变化率。
DERIVATIVE(*)
返回 measurement 中与每个字段键关联的后续字段值之间的变化率。
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 measurement 中与 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 measurement 中与 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
计算 measurement 中与每个字段键关联的字段值之间的导数，并指定单位选项
> 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 measurement 中每个存储数值的字段键的字段值之间的三分钟变化率。h2o_feet measurement 有一个数值字段：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 measurement 中每个存储数值且包含单词 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
该查询返回 h2o_feet measurement 中与 water_level 字段键关联的字段值之间的一秒变化率。它涵盖了 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 值。此步骤与使用带有 GROUP BY time() 子句且不带 DERIVATIVE() 的 MEAN() 函数相同
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
接下来，InfluxDB 计算这些平均值之间的 12 分钟变化率。第一个结果 (-0.0129999999999999) 是前两个平均值之间的 12 分钟变化率。InfluxDB 计算字段值之间的差异，并将该值归一化为 12 分钟变化率。
(2.077 - 2.09) / (12m / 12m)
------------- ----------
| |
| the difference between the field values' timestamps / the default unit
second field value - first field value
计算平均值的导数并指定单位选项
> SELECT DERIVATIVE(MEAN("water_level"),6m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:12:00Z -0.00649999999999995
2015-08-18T00:24:00Z -0.015499999999999847
该查询返回以 12 分钟为间隔计算的平均 water_level 值之间的六分钟变化率。
为了获得这些结果，InfluxDB 首先以 12 分钟为间隔计算平均 water_level 值。此步骤与使用带有 GROUP BY time() 子句且不带 DERIVATIVE() 的 MEAN() 函数相同
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
接下来，InfluxDB 计算这些平均值之间的六分钟变化率。第一个结果 (-0.00649999999999995) 是前两个平均值之间的六分钟变化率。InfluxDB 计算字段值之间的差异，并将该值归一化为六分钟变化率。
(2.077 - 2.09) / (12m / 6m)
------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
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
该查询返回 h2o_feet measurement 中 water_level 字段键的后续字段值之间的差值。
计算 measurement 中与每个字段键关联的字段值之间的差值
> 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 measurement 中每个存储数值的字段键的后续字段值之间的差值。h2o_feet measurement 有一个数值字段：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 measurement 中每个存储数值且包含单词 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 值。此步骤与使用带有 GROUP BY time() 子句且不带 DIFFERENCE() 的 MAX() 函数相同
> 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(字段键)
返回与字段键关联的后续时间戳之间的差异。
ELAPSED(/正则表达式/)
返回与每个匹配正则表达式的字段键关联的后续时间戳之间的差异。
ELAPSED(*)
返回与度量中每个字段键关联的后续时间戳之间的差异。
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 度量中后续时间戳之间的差异（以纳秒为单位）。
计算与字段键关联的字段值之间经过的时间，并指定 unit 选项
> 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 度量中后续时间戳之间的差异（以分钟为单位）。
计算与度量中每个字段键关联的字段值之间经过的时间，并指定 unit 选项
> 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。
计算与每个匹配正则表达式的字段键关联的字段值之间经过的时间，并指定 unit 选项
> 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
带有 GROUP BY time() 子句的 ELAPSED()
ELAPSED() 函数支持 GROUP BY time() 子句，但查询结果不是特别有用。目前，带有嵌套函数和 GROUP BY time() 子句的 ELAPSED() 查询仅返回 GROUP BY time() 子句中指定的间隔。
GROUP BY time() 子句确定结果中的时间戳；每个时间戳标记一个时间间隔的开始。这种行为也适用于嵌套的选择器函数（如 FIRST() 或 MAX()），在所有其他情况下，这些函数将从原始数据返回特定的时间戳。由于 GROUP BY time() 子句覆盖了原始时间戳，因此 ELAPSED() 计算始终返回与 GROUP BY time() 间隔相同的值。
示例
在下面的代码块中，第一个查询尝试将 ELAPSED() 函数与 GROUP BY time() 子句一起使用，以查找 最小 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(字段键)
返回与字段键关联的字段值的指数。
EXP(*)
返回与度量中每个字段键关联的字段值的指数。
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(字段键)
返回与字段键关联的字段值，向下舍入到最接近的整数。
FLOOR(*)
返回与度量中每个字段键关联的字段值，向下舍入到最接近的整数。
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(字段键)
返回与字段键关联的字段值的自然对数。
LN(*)
返回与度量中每个字段键关联的字段值的自然对数。
LN() 支持 int64 和 float64 字段值数据类型。
基本语法支持 按标签分组的 GROUP BY 子句，但不按时间分组的 GROUP BY 子句。有关如何将 LN() 与 GROUP BY time() 子句一起使用，请参阅高级语法部分。
示例
以下示例使用 NOAA_water_database 数据 的以下子样本
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
计算与字段键关联的字段值的自然对数
> SELECT LN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ln
---- --
2015-08-18T00:00:00Z 0.7246458476193163
2015-08-18T00:06:00Z 0.749527513996053
2015-08-18T00:12:00Z 0.7070500857289368
2015-08-18T00:18:00Z 0.7542422799197561
2015-08-18T00:24:00Z 0.7134398838277077
2015-08-18T00:30:00Z 0.7183274790902436
该查询返回 h2o_feet 度量中 water_level 字段键中字段值的自然对数。
计算与度量中每个字段键关联的字段值的自然对数
> SELECT LN(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ln_water_level
---- --------------
2015-08-18T00:00:00Z 0.7246458476193163
2015-08-18T00:06:00Z 0.749527513996053
2015-08-18T00:12:00Z 0.7070500857289368
2015-08-18T00:18:00Z 0.7542422799197561
2015-08-18T00:24:00Z 0.7134398838277077
2015-08-18T00:30:00Z 0.7183274790902436
该查询返回 h2o_feet 度量中每个存储数值的字段键的字段值的自然对数。h2o_feet 度量有一个数值字段：water_level。
计算与字段键关联的字段值的自然对数，并包含多个子句
> SELECT LN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time ln
---- --
2015-08-18T00:18:00Z 0.7542422799197561
2015-08-18T00:12:00Z 0.7070500857289368
2015-08-18T00:06:00Z 0.749527513996053
2015-08-18T00:00:00Z 0.7246458476193163
该查询返回与 water_level 字段键关联的字段值的自然对数。它涵盖了 2015-08-18T00:00:00Z 和 2015-08-18T00:30:00Z 之间的时间范围，并以降序时间戳顺序返回结果。该查询还限制返回的点数为四个，并偏移结果两个点。
高级语法
SELECT LN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要 GROUP BY time() 子句和一个嵌套的 InfluxQL 函数。查询首先计算指定 GROUP BY time() 间隔的嵌套函数的结果，然后将 LN() 函数应用于这些结果。
LN() 支持以下嵌套函数：COUNT()、MEAN()、MEDIAN()、MODE()、SUM()、FIRST()、LAST()、MIN()、MAX() 和 PERCENTILE()。
示例
计算平均值的自然对数。
> SELECT LN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time ln
---- --
2015-08-18T00:00:00Z 0.7371640659767196
2015-08-18T00:12:00Z 0.7309245448939752
2015-08-18T00:24:00Z 0.7158866675294349
该查询返回以 12 分钟间隔计算的平均 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(字段键, b)
返回以 b 为底的与字段键关联的字段值的对数。
LOG(*, b)
返回以 b 为底的与度量中每个字段键关联的字段值的对数。
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(字段键)
返回以 2 为底的与字段键关联的字段值的对数。
LOG2(*)
返回以 2 为底的与度量中每个字段键关联的字段值的对数。
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(字段键)
返回以 10 为底的与字段键关联的字段值的对数。
LOG10(*)
返回以 10 为底的与度量中每个字段键关联的字段值的对数。
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。此步骤与将 MEAN() 函数与 GROUP BY time() 子句一起使用且不使用 LOG10() 相同
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 计算这些平均值的以 10 为底的对数。
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(字段键,N)
返回与字段键关联的 N 个字段值的滚动平均值。
MOVING_AVERAGE(/正则表达式/,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 值。此步骤与使用 MAX() 函数以及 GROUP BY time() 子句且不使用 MOVING_AVERAGE() 相同。
> SELECT MAX("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time max
---- ---
2015-08-18T00:00:00Z 2.116
2015-08-18T00:12:00Z 2.126
2015-08-18T00:24:00Z 2.051
接下来，InfluxDB 使用这些最大值计算跨越两个值的窗口的滚动平均值。第一个最终结果 (2.121) 是前两个最大值的平均值 ((2.116 + 2.126) / 2)。
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 值。此步骤与使用 MEAN() 函数以及 GROUP BY time() 子句且不使用 POW() 相同。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 计算这些平均值并乘以 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 值。此步骤与使用 MEAN() 函数以及 GROUP BY time() 子句且不使用 ROUND() 相同。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 将这些平均值四舍五入到最接近的整数。
SIN()
返回字段值的正弦值。
基本语法
SELECT SIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SIN(field_key)
返回与字段键关联的字段值的正弦值。
SIN(*)
返回测量中与每个字段键关联的字段值的正弦值。
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 值。此步骤与使用 MEAN() 函数以及 GROUP BY time() 子句且不使用 SIN() 相同。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 计算这些平均值的正弦值。
SQRT()
返回字段值的平方根。
基本语法
SELECT SQRT( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SQRT(field_key)
返回与字段键关联的字段值的平方根。
SQRT(*)
返回测量中与每个字段键关联的字段值的平方根。
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 值。此步骤与使用 MEAN() 函数以及 GROUP BY time() 子句且不使用 SQRT() 相同。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 计算这些平均值的平方根。
TAN()
返回字段值的正切值。
基本语法
SELECT TAN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TAN(field_key)
返回与字段键关联的字段值的正切值。
TAN(*)
返回测量中与每个字段键关联的字段值的正切值。
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 值。此步骤与使用 MEAN() 函数以及 GROUP BY time() 子句且不使用 TAN() 相同。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后，InfluxDB 计算这些平均值的正切值。
预测函数
HOLT_WINTERS()
使用 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 |
考夫曼算法默认保持周期
| 算法 | 默认保持周期 |
|---|---|
| KAUFMANS_EFFICIENCY_RATIO() | PERIOD |
| KAUFMANS_ADAPTIVE_MOVING_AVERAGE() | PERIOD |
WARMUP_TYPE
默认值='exponential'
这控制算法如何为前 PERIOD 个样本初始化自身。它本质上是算法具有不完整样本集的持续时间。
简单
前 PERIOD 个样本的简单移动平均线 (SMA)。这是 ta-lib 使用的方法。
指数
具有缩放 alpha (α) 的指数移动平均线 (EMA)。这基本上对第一个点使用 PERIOD=1 的 EMA，对第二个点使用 PERIOD=2 的 EMA，依此类推，直到算法消耗了 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')
返回使用 Chande 动量震荡指标算法处理的字段键关联的字段值，该算法的周期为 10 个值，持有周期为 9 个值，预热类型为 none。
CHANDE_MOMENTUM_OSCILLATOR(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用 Chande 动量震荡指标算法处理的字段键关联的字段值的平均值，该算法的周期为 2 个值，并使用默认的持有周期和预热类型。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对CHANDE_MOMENTUM_OSCILLATOR()函数的调用中包含聚合函数。
CHANDE_MOMENTUM_OSCILLATOR(/regular_expression/, 2)
返回与每个匹配正则表达式的字段键关联的字段值，这些字段值使用 Chande 动量震荡指标算法处理，该算法的周期为 2 个值，并使用默认的持有周期和预热类型。
CHANDE_MOMENTUM_OSCILLATOR(*, 2)
返回与 指标中每个字段键关联的字段值，这些字段值使用 Chande 动量震荡指标算法处理，该算法的周期为 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()
考夫曼效率比率，或简称为“效率比率” (ER)，是通过将一个周期内的数据变化除以为实现该变化而发生的数据移动的绝对总和来计算的。 结果比率介于 0 和 1 之间，值越高表示市场效率越高或趋势性越强。
ER 与 Chande 动量震荡指标 (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()
考夫曼自适应移动平均线 (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 个值，并使用默认的持有周期和预热类型。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(field_key, 10, 10)
返回使用考夫曼自适应移动平均线算法处理的字段键关联的字段值，该算法的周期为 10 个值，持有周期为 10 个值。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用考夫曼自适应移动平均线算法处理的字段键关联的字段值的平均值，该算法的周期为 2 个值，并使用默认的持有周期。
注意： 当使用
GROUP BY子句聚合数据时，您必须在对KAUFMANS_ADAPTIVE_MOVING_AVERAGE()函数的调用中包含聚合函数。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(/regular_expression/, 2)
返回与每个匹配正则表达式的字段键关联的字段值，这些字段值使用考夫曼自适应移动平均线算法处理，该算法的周期为 2 个值，并使用默认的持有周期和预热类型。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(*, 2)
返回与 指标中每个字段键关联的字段值，这些字段值使用考夫曼自适应移动平均线算法处理，该算法的周期为 2 个值，并使用默认的持有周期和预热类型。
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() 时间间隔的较低时间边界作为时间戳。
此页对您有帮助吗？
感谢您的反馈！