InfluxQL函数可以用来聚合(aggregate)、选择(select)、转换(transform)和预测(predict)数据。

内容

Aggregations

COUNT()

返回非空的field value的个数。

语法

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)
返回field key对应的field value的个数。

COUNT(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的个数。

COUNT(*)
返回在measurement中每个field key对应的field value的个数。

COUNT()支持所有数据类型的field value。InfluxQL支持将DISTINCT()函数嵌套在COUNT()函数里。

示例

示例一：计算指定field key对应的field value的个数

> SELECT COUNT("water_level") FROM "h2o_feet"
name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   15258

该查询返回measurement h2o_feet中field key water_level对应的非空field value的个数。

示例二：计算measurement中每个field key对应的field value的个数

> SELECT COUNT(*) FROM "h2o_feet"
name: h2o_feet
time                   count_level description   count_water_level
----                   -----------------------   -----------------
1970-01-01T00:00:00Z   15258                     15258

该查询返回measurement h2o_feet中每个field key对应的非空field value的个数。measurement h2o_feet中有两个field key：level description和water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的个数

> SELECT COUNT(/water/) FROM "h2o_feet"
name: h2o_feet
time                   count_water_level
----                   -----------------
1970-01-01T00:00:00Z   15258

该查询返回measurement h2o_feet中每个包含单词water的field key对应的非空field value的个数。

示例四：计算指定field key对应的field value的个数并包含多个子句

> 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

该查询返回field key water_level对应的非空field value的个数，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用200填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为7和1。

示例五：计算指定field key对应的不同field value的个数

> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"
name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   4

该查询返回measurement h2o_feet中field key level description对应的不同field value的个数。

COUNT()的常见问题

问题一：COUNT()和fill()

大多数InfluxQL函数对于没有数据的时间间隔返回null值，如果不想返回null，可以使用fill()函数，fill(<fill_option>)将null值替换成fill_option。对于没有数据的时间间隔，COUNT()返回0，而fill(<fill_option>)可以将0替换成fill_option。

示例
下面代码块中的第一个查询没有使用fill()，最后一个时间间隔中没有数据，因此该时间间隔返回的值是0。第二个查询使用了fill(800000)，它将最后一个时间间隔的返回值0替换成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()

返回不同的field value。

语法

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

嵌套语法

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

语法描述

DISTINCT(field_key)
返回field key对应的不同的field value。

DISTINCT(/regular_expression/)
返回与正则表达式匹配的每个field key对应的不同的field value。

DISTINCT(*)
返回在measurement中每个field key对应的不同的field value。

DISTINCT()支持所有数据类型的field value。InfluxQL支持将DISTINCT()函数嵌套在COUNT()函数里。

示例

示例一：列出指定field key对应的不同的field value

> 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

该查询返回measurement h2o_feet中field key level description对应的不同field value。

示例二：列出measurement中每个field key对应的不同的field value

> 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
[...]

该查询返回measurement h2o_feet中每个field key对应的不同的field value。measurement h2o_feet中有两个field key：level description和water_level。

示例三：列出与正则表达式匹配的每个field key对应的不同的field value

> SELECT DISTINCT(/description/) FROM "h2o_feet"
name: h2o_feet
time                   distinct_level description
----                   --------------------------
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

该查询返回measurement h2o_feet中每个包含单词description的field key对应的不同的field value。

示例四：列出指定field key对应的不同的field value并包含多个子句

>  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

该查询返回field key level description对应的不同的field value，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询将返回的序列个数限制为1。

示例五：计算指定field key对应的不同field value的个数

> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"
name: h2o_feet
time                   count
----                   -----
1970-01-01T00:00:00Z   4

该查询返回measurement h2o_feet中field key level description对应的不同field value的个数。

DISTINCT()的常见问题

问题一：DISTINCT()和INTO子句

在INTO子句中使用DISTINCT()可能会导致TSDB For InfluxDB®覆盖目标measurement中的数据点。DISTINCT()通常返回多个具有相同时间戳的结果；TSDB For InfluxDB®假设在相同序列中并具有相同时间戳的数据点是重复数据点，并简单地用目标measurement中最新的数据点覆盖重复数据点。

示例
下面代码块中的第一个查询使用了DISTINCT()，并返回四个结果。请注意，每个结果都有相同的时间戳。第二个查询将INTO子句添加到查询中，并将查询结果写入measurement distincts。最后一个查询选择measurement distincts中所有数据。
因为原来的四个结果是重复的(它们在相同的序列，有相同的时间戳)，所以最后一个查询只返回一个数据点。当系统遇到重复数据点时，它会用最近的数据点覆盖之前的数据点。

>  SELECT DISTINCT("level description") FROM "h2o_feet"
name: h2o_feet
time                   distinct
----                   --------
1970-01-01T00:00:00Z   below 3 feet
1970-01-01T00:00:00Z   between 6 and 9 feet
1970-01-01T00:00:00Z   between 3 and 6 feet
1970-01-01T00:00:00Z   at or greater than 9 feet
>  SELECT DISTINCT("level description") INTO "distincts" FROM "h2o_feet"
name: result
time                   written
----                   -------
1970-01-01T00:00:00Z   4
> SELECT * FROM "distincts"
name: distincts
time                   distinct
----                   --------
1970-01-01T00:00:00Z   at or greater than 9 feet

INTEGRAL()

返回field value曲线下的面积，即关于field value的积分。

语法

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]

语法描述

TSDB For InfluxDB®计算field value曲线下的面积，并将这些结果转换为每个unit的总面积。参数unit的值是一个整数，后跟一个时间单位。这个参数是可选的，不是必须要有的。如果查询没有指定unit的值，那么unit默认为一秒(1s)。

INTEGRAL(field_key)
返回field key对应的field value曲线下的面积。

INTEGRAL(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value曲线下的面积。

INTEGRAL(*)
返回在measurement中每个field key对应的field value曲线下的面积。

INTEGRAL()不支持fill()。INTEGRAL()支持数据类型为int64和float64的field value。

示例

示例一～示例五使用了数据库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

示例一：计算指定field key对应的field value的积分

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value曲线下的面积（以秒为单位)。

示例二：计算指定field key对应的field value的积分并指定`unit`

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

该查询返回measurement h2o_feet中field key water_level对应的field value曲线下的面积(以分钟为单位)。

示例三：计算measurement中每个field key对应的field value的积分并指定`unit`

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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value曲线下的面积(以分钟为单位)。measurement h2o_feet中只有一个数值类型的field：water_level。

示例四：计算与正则表达式匹配的每个field key对应的field value的积分并指定`unit`

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

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value曲线下的面积(以分钟为单位)。

示例五：计算指定field key对应的field value的积分并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value曲线下的面积(以分钟为单位)，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并将查询结果按12分钟的时间间隔进行分组，同时，该查询将返回的数据点个数限制为1。

MEAN()

返回field value的平均值。

语法

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)
返回field key对应的field value的平均值。

MEAN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的平均值。

MEAN(*)
返回在measurement中每个field key对应的field value的平均值。

MEAN()支持数据类型为int64和float64的field value。

示例

示例一：计算指定field key对应的field value的平均值

> SELECT MEAN("water_level") FROM "h2o_feet"
name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.442107025822522

该查询返回measurement h2o_feet中field key water_level对应的field value的平均值。

示例二：计算measurement中每个field key对应的field value的平均值

> SELECT MEAN(*) FROM "h2o_feet"
name: h2o_feet
time                   mean_water_level
----                   ----------------
1970-01-01T00:00:00Z   4.442107025822522

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的平均值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的平均值

> SELECT MEAN(/water/) FROM "h2o_feet"
name: h2o_feet
time                   mean_water_level
----                   ----------------
1970-01-01T00:00:00Z   4.442107025822523

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的平均值。

示例四：计算指定field key对应的field value的平均值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的平均值，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:30:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用9.01填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为7和1。

MEDIAN()

返回排好序的field value的中位数。

语法

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)
返回field key对应的field value的中位数。

MEDIAN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的中位数。

MEDIAN(*)
返回在measurement中每个field key对应的field value的中位数。

MEDIAN()支持数据类型为int64和float64的field value。

注释：MEDIAN()近似于PERCENTILE(field_key, 50)，除非field key包含的field value有偶数个，那么这时候MEDIAN()将返回两个中间值的平均数。

示例

示例一：计算指定field key对应的field value的中位数

> SELECT MEDIAN("water_level") FROM "h2o_feet"
name: h2o_feet
time                   median
----                   ------
1970-01-01T00:00:00Z   4.124

该查询返回measurement h2o_feet中field key water_level对应的field value的中位数。

示例二：计算measurement中每个field key对应的field value的中位数

> SELECT MEDIAN(*) FROM "h2o_feet"
name: h2o_feet
time                   median_water_level
----                   ------------------
1970-01-01T00:00:00Z   4.124

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的中位数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的中位数

> SELECT MEDIAN(/water/) FROM "h2o_feet"
name: h2o_feet
time                   median_water_level
----                   ------------------
1970-01-01T00:00:00Z   4.124

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的中位数。

示例四：计算指定field key对应的field value的中位数并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的中位数，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用700填充没有数据的时间间隔，将返回的数据点个数和序列个数分别限制为7和1，并将返回的序列偏移一个（即第一个序列的数据不返回）。

MODE()

返回field value中出现频率最高的值。

语法

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)
返回field key对应的field value中出现频率最高的值。

MODE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value中出现频率最高的值。

MODE(*)
返回在measurement中每个field key对应的field value中出现频率最高的值。

MODE()支持所有数据类型的field value。

注释：如果出现频率最高的值有两个或多个并且它们之间有关联，那么MODE()返回具有最早时间戳的field value。

示例

示例一：计算指定field key对应的field value中出现频率最高的值

> SELECT MODE("level description") FROM "h2o_feet"
name: h2o_feet
time                   mode
----                   ----
1970-01-01T00:00:00Z   between 3 and 6 feet

该查询返回measurement h2o_feet中field key level description对应的field value中出现频率最高的值。

示例二：计算measurement中每个field key对应的field value中出现频率最高的值

> 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

该查询返回measurement h2o_feet中每个field key对应的field value中出现频率最高的值。measurement h2o_feet中有两个field key：level description和water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value中出现频率最高的值

> SELECT MODE(/water/) FROM "h2o_feet"
name: h2o_feet
time                   mode_water_level
----                   ----------------
1970-01-01T00:00:00Z   2.69

该查询返回measurement h2o_feet中每个包含单词water的field key对应的field value中出现频率最高的值。

示例四：计算指定field key对应的field value中出现频率最高的值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value中出现频率最高的值，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询将返回的数据点个数和序列个数分别限制为3和1，并将返回的序列偏移一个（即第一个序列的数据不返回）。

SPREAD()

返回field value中最大值和最小值之差。

语法

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)
返回field key对应的field value中最大值和最小值之差。

SPREAD(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value中最大值和最小值之差。

SPREAD(*)
返回在measurement中每个field key对应的field value中最大值和最小值之差。

SPREAD()支持数据类型为int64和float64的field value。

示例

示例一：计算指定field key对应的field value中最大值和最小值之差

> SELECT SPREAD("water_level") FROM "h2o_feet"
name: h2o_feet
time                   spread
----                   ------
1970-01-01T00:00:00Z   10.574

该查询返回measurement h2o_feet中field key water_level对应的field value中最大值和最小值之差。

示例二：计算measurement中每个field key对应的field value中最大值和最小值之差

> SELECT SPREAD(*) FROM "h2o_feet"
name: h2o_feet
time                   spread_water_level
----                   ------------------
1970-01-01T00:00:00Z   10.574

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value中最大值和最小值之差。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value中最大值和最小值之差

> SELECT SPREAD(/water/) FROM "h2o_feet"
name: h2o_feet
time                   spread_water_level
----                   ------------------
1970-01-01T00:00:00Z   10.574

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value中最大值和最小值之差。

示例四：计算指定field key对应的field value中最大值和最小值之差并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value中最大值和最小值之差，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用18填充没有数据的时间间隔，将返回的数据点个数和序列个数分别限制为3和1，并将返回的序列偏移一个（即第一个序列的数据不返回）。

STDDEV()

返回field value的标准差。

语法

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)
返回field key对应的field value的标准差。

STDDEV(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的标准差。

STDDEV(*)
返回在measurement中每个field key对应的field value的标准差。

STDDEV()支持数据类型为int64和float64的field value。

示例

示例一：计算指定field key对应的field value的标准差

> SELECT STDDEV("water_level") FROM "h2o_feet"
name: h2o_feet
time                   stddev
----                   ------
1970-01-01T00:00:00Z   2.279144584196141

该查询返回measurement h2o_feet中field key water_level对应的field value的标准差。

示例二：计算measurement中每个field key对应的field value的标准差

> SELECT STDDEV(*) FROM "h2o_feet"
name: h2o_feet
time                   stddev_water_level
----                   ------------------
1970-01-01T00:00:00Z   2.279144584196141

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的标准差。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的标准差

> SELECT STDDEV(/water/) FROM "h2o_feet"
name: h2o_feet
time                   stddev_water_level
----                   ------------------
1970-01-01T00:00:00Z   2.279144584196141

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的标准差。

示例四：计算指定field key对应的field value的标准差并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的标准差，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用18000填充没有数据的时间间隔，将返回的数据点个数和序列个数分别限制为2和1，并将返回的序列偏移一个（即第一个序列的数据不返回）。

SUM()

返回field value的总和。

语法

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)
返回field key对应的field value的总和。

SUM(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的总和。

SUM(*)
返回在measurement中每个field key对应的field value的总和。

SUM()支持数据类型为int64和float64的field value。

示例

示例一：计算指定field key对应的field value的总和

> SELECT SUM("water_level") FROM "h2o_feet"
name: h2o_feet
time                   sum
----                   ---
1970-01-01T00:00:00Z   67777.66900000004

该查询返回measurement h2o_feet中field key water_level对应的field value的总和。

示例二：计算measurement中每个field key对应的field value的总和

> SELECT SUM(*) FROM "h2o_feet"
name: h2o_feet
time                   sum_water_level
----                   ---------------
1970-01-01T00:00:00Z   67777.66900000004

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的总和。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的总和

> SELECT SUM(/water/) FROM "h2o_feet"
name: h2o_feet
time                   sum_water_level
----                   ---------------
1970-01-01T00:00:00Z   67777.66900000004

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的总和。

示例四：计算指定field key对应的field value的总和并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的总和，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用18000填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为4和1。

Selectors

BOTTOM()

返回最小的N个field value。

语法

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)
返回field key对应的最小的N个值。

BOTTOM(field_key,tag_key(s),N)
返回tag key的N个tag value对应的field key的最小值。

BOTTOM(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的最小的N个值，以及相关的tag和/或field。

BOTTOM()支持数据类型为int64和float64的field value。

注释：

如果最小值有两个或多个相等的值，BOTTOM()返回具有最早时间戳的field value。
当BOTTOM()函数与INTO子句一起使用时，BOTTOM()与其它InfluxQL函数不同。请查看BOTTOM()的常见问题章节获得更多信息。

示例

示例一：选择指定field key对应的最小的三个值

> 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

该查询返回measurement h2o_feet中field key water_level对应的最小的三个值。

示例二：选择两个tag对应的field key的最小值

> 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

该查询返回tag key location的两个tag value对应的field key water_level的最小值。

示例三：选择指定field key对应的最小的四个值以及相关的tag和field

> 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

该查询返回field key water_level对应的最小的四个值，以及相关的tag key location和field key level description的值。

示例四：选择指定field key对应的最小的三个值并包含多个子句

> 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分钟间隔内，field key water_level对应的最小的三个值，并且以递减的时间戳顺序返回结果。

请注意，GROUP BY time()子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。

`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个tag value的tag key

使用语法SELECT BOTTOM(<field_key>,<tag_key>,<N>)的查询可以返回比预期少的数据点。如果tag key有X个tag value，但是查询指定的是N个tag value，如果X小于N，那么查询将返回X个数据点。

示例
以下查询请求的是tag key location的三个tag value对于的water_level的最小值。因为tag key location只有两个tag value(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()`、tag和`INTO`子句

当使用INTO子句但没有使用GROUP BY tag子句时，大多数InfluxQL函数将原始数据中的tag转换为新写入数据中的field。这种行为同样适用于BOTTOM()函数除非BOTTOM()中包含tag key作为参数：BOTTOM(field_key,tag_key(s),N)。在这些情况下，系统会将指定的tag保留为新写入数据中的tag。

示例
下面代码块中的第一个查询返回tag key location的两个tag value对应的field key water_level的最小值，并且，它这些结果写入measurement bottom_water_levels中。第二个查询展示了TSDB For InfluxDB®将tag location保留为measurement bottom_water_levels中的tag。

> 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()

返回具有最早时间戳的field value。

语法

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)
返回field key对应的具有最早时间戳的field value。

FIRST(/regular_expression/)
返回与正则表达式匹配的每个field key对应的具有最早时间戳的field value。

FIRST(*)
返回在measurement中每个field key对应的具有最早时间戳的field value。

FIRST(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的具有最早时间戳的field value，以及相关的tag和/或field。

FIRST()支持所有数据类型的field value。

示例

示例一：选择指定field key对应的具有最早时间戳的field value

> SELECT FIRST("level description") FROM "h2o_feet"
name: h2o_feet
time                   first
----                   -----
2015-08-18T00:00:00Z   between 6 and 9 feet

该查询返回measurement h2o_feet中field key level description对应的具有最早时间戳的field value。

示例二：选择measurement中每个field key对应的具有最早时间戳的field value

> 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

该查询返回measurement h2o_feet中每个field key对应的具有最早时间戳的field value。measurement h2o_feet中有两个field key：level description和water_level。

示例三：选择与正则表达式匹配的每个field key对应的具有最早时间戳的field value

> 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

该查询返回measurement h2o_feet中每个包含单词level的field key对应的具有最早时间戳的field value。

示例四：选择指定field key对应的具有最早时间戳的field value以及相关的tag和field

> 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

该查询返回measurement h2o_feet中field key level description对应的具有最早时间戳的field value，以及相关的tag key location和field key water_level的值。

示例五：选择指定field key对应的具有最早时间戳的field value并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的具有最早时间戳的field value，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用9.01填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为4和1。

请注意，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()

返回具有最新时间戳的field value。

语法

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)
返回field key对应的具有最新时间戳的field value。

LAST(/regular_expression/)
返回与正则表达式匹配的每个field key对应的具有最新时间戳的field value。

LAST(*)
返回在measurement中每个field key对应的具有最新时间戳的field value。

LAST(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的具有最新时间戳的field value，以及相关的tag和/或field。

LAST()支持所有数据类型的field value。

示例

示例一：选择指定field key对应的具有最新时间戳的field value

> SELECT LAST("level description") FROM "h2o_feet"
name: h2o_feet
time                   last
----                   ----
2015-09-18T21:42:00Z   between 3 and 6 feet

该查询返回measurement h2o_feet中field key level description对应的具有最新时间戳的field value。

示例二：选择measurement中每个field key对应的具有最新时间戳的field value

> SELECT LAST(*) FROM "h2o_feet"
name: h2o_feet
time                   last_level description   last_water_level
----                   -----------------------   -----------------
2015-09-18T21:42:00Z   between 3 and 6 feet      4.938

该查询返回measurement h2o_feet中每个field key对应的具有最新时间戳的field value。measurement h2o_feet中有两个field key：level description和water_level。

示例三：选择与正则表达式匹配的每个field key对应的具有最新时间戳的field value

> SELECT LAST(/level/) FROM "h2o_feet"
name: h2o_feet
time                   last_level description   last_water_level
----                   -----------------------   -----------------
2015-09-18T21:42:00Z   between 3 and 6 feet      4.938

该查询返回measurement h2o_feet中每个包含单词level的field key对应的具有最新时间戳的field value。

示例四：选择指定field key对应的具有最新时间戳的field value以及相关的tag和field

> 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

该查询返回measurement h2o_feet中field key level description对应的具有最新时间戳的field value，以及相关的tag key location和field key water_level的值。

示例五：选择指定field key对应的具有最新时间戳的field value并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的具有最新时间戳的field value，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用9.01填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为4和1。

MAX()

返回field value的最大值。

语法

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)
返回field key对应的field value的最大值。

MAX(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的最大值。

MAX(*)
返回在measurement中每个field key对应的field value的最大值。

MAX(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的field value的最大值，以及相关的tag和/或field。

MAX()支持数据类型为int64和float64的field value。

示例

示例一：选择指定field key对应的field value的最大值

> SELECT MAX("water_level") FROM "h2o_feet"
name: h2o_feet
time                   max
----                   ---
2015-08-29T07:24:00Z   9.964

该查询返回measurement h2o_feet中field key water_level对应的field value的最大值。

示例二：选择measurement中每个field key对应的field value的最大值

> SELECT MAX(*) FROM "h2o_feet"
name: h2o_feet
time                   max_water_level
----                   ---------------
2015-08-29T07:24:00Z   9.964

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的最大值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：选择与正则表达式匹配的每个field key对应的field value的最大值

> SELECT MAX(/water/) FROM "h2o_feet"
name: h2o_feet
time                   max_water_level
----                   ---------------
2015-08-29T07:24:00Z   9.964

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的最大值。

示例四：选择指定field key对应的field value的最大值以及相关的tag和field

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的最大值，以及相关的tag key location和field key level description的值。

示例五：选择指定field key对应的field value的最大值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的最大值，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用9.01填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为4和1。

MIN()

返回field value的最小值。

语法

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)
返回field key对应的field value的最小值。

MIN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的最小值。

MIN(*)
返回在measurement中每个field key对应的field value的最小值。

MIN(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的field value的最小值，以及相关的tag和/或field。

MIN()支持数据类型为int64和float64的field value。

示例

示例一：选择指定field key对应的field value的最小值

> SELECT MIN("water_level") FROM "h2o_feet"
name: h2o_feet
time                   min
----                   ---
2015-08-29T14:30:00Z   -0.61

该查询返回measurement h2o_feet中field key water_level对应的field value的最小值。

示例二：选择measurement中每个field key对应的field value的最小值

> SELECT MIN(*) FROM "h2o_feet"
name: h2o_feet
time                   min_water_level
----                   ---------------
2015-08-29T14:30:00Z   -0.61

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的最小值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：选择与正则表达式匹配的每个field key对应的field value的最小值

> SELECT MIN(/water/) FROM "h2o_feet"
name: h2o_feet
time                   min_water_level
----                   ---------------
2015-08-29T14:30:00Z   -0.61

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的最小值。

示例四：选择指定field key对应的field value的最小值以及相关的tag和field

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的最小值，以及相关的tag key location和field key level description的值。

示例五：选择指定field key对应的field value的最小值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的最小值，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按12分钟的时间间隔和每个tag进行分组，同时，该查询用9.01填充没有数据的时间间隔，并将返回的数据点个数和序列个数分别限制为4和1。

PERCENTILE()

返回第N个百分位数的field value。

语法

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)
返回指定field key对应的第N个百分位数的field value。

PERCENTILE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的第N个百分位数的field value。

PERCENTILE(*,N)
返回在measurement中每个field key对应的第N个百分位数的field value。

PERCENTILE(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的第N个百分位数的field value，以及相关的tag和/或field。

N必须是0到100之间的整数或浮点数。PERCENTILE()支持数据类型为int64和float64的field value。

示例

示例一：选择指定field key对应的第五个百分位数的field value

> SELECT PERCENTILE("water_level",5) FROM "h2o_feet"
name: h2o_feet
time                   percentile
----                   ----------
2015-08-31T03:42:00Z   1.122

该查询返回的field value大于measurement h2o_feet中field key water_level对应的所有field value中的百分之五。

示例二：选择measurement中每个field key对应的第五个百分位数的field value

> SELECT PERCENTILE(*,5) FROM "h2o_feet"
name: h2o_feet
time                   percentile_water_level
----                   ----------------------
2015-08-31T03:42:00Z   1.122

该查询返回的field value大于measurement h2o_feet中每个存储数值的field key对应的所有field value中的百分之五。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：选择与正则表达式匹配的每个field key对应的第五个百分位数的field value

> SELECT PERCENTILE(/water/,5) FROM "h2o_feet"
name: h2o_feet
time                   percentile_water_level
----                   ----------------------
2015-08-31T03:42:00Z   1.122

该查询返回的field value大于measurement h2o_feet中每个存储数值并包含单词water的field key对应的所有field value中的百分之五。

示例四：选择指定field key对应的第五个百分位数的field value以及相关的tag和field

> 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

该查询返回的field value大于measurement h2o_feet中field key water_level对应的所有field value中的百分之五，以及相关的tag key location和field key level description的值。

示例五：选择指定field key对应的第20个百分位数的field value并包含多个子句

> 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

该查询返回的field value大于measurement h2o_feet中field key water_level对应的所有field value中的百分之二十，它涵盖的时间范围在2015-08-17T23:48:00Z和2015-08-18T00:54:00Z之间，并将查询结果按24分钟的时间间隔进行分组，同时，该查询用15填充没有数据的时间间隔，并将返回的数据点个数限制为2。

请注意，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()` vs 其它InfluxQL函数

PERCENTILE(<field_key>,100)相当于MAX(<field_key>)。
PERCENTILE(<field_key>, 50)近似于MEDIAN(<field_key>)，除非field key包含的field value有偶数个，那么这时候MEDIAN()将返回两个中间值的平均数。
PERCENTILE(<field_key>,0)不等于MIN(<field_key>)，PERCENTILE(<field_key>,0)会返回null。

SAMPLE()

返回包含N个field value的随机样本。SAMPLE()使用reservoir sampling来生成随机数据点。

语法

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)
返回指定field key对应的N个随机选择的field value。

SAMPLE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的N个随机选择的field value。

SAMPLE(*,N)
返回在measurement中每个field key对应的N个随机选择的field value。

SAMPLE(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的N个随机选择的field value，以及相关的tag和/或field。

N必须是整数。SAMPLE()支持所有数据类型的field value。

示例

示例一：选择指定field key对应的field value的随机样本

> 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

该查询返回measurement h2o_feet中field key water_level对应的两个随机选择的数据点。

示例二：选择measurement中每个field key对应的field value的随机样本

> 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

该查询返回measurement h2o_feet中每个field key对应的两个随机选择的数据点。measurement h2o_feet中有两个field key：level description和water_level。

示例三：选择与正则表达式匹配的每个field key对应的field value的随机样本

> 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

该查询返回measurement h2o_feet中每个包含单词level的field key对应的两个随机选择的数据点。

示例四：选择指定field key对应的field value的随机样本以及相关的tag和field

> 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

该查询返回measurement h2o_feet中field key water_level对应的两个随机选择的数据点，以及相关的tag key location和field key level description的值。

示例五：选择指定field key对应field value的随机样本并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的一个随机选择的数据点，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并将查询结果按18分钟的时间间隔进行分组。

请注意，GROUP BY time()子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。

`SAMPLE()`的常见问题

问题一：`SAMPLE()`和`GROUP BY time()`子句同时使用

对于同时带有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个field value。

语法

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)
返回field key对应的最大的N个值。

TOP(field_key,tag_key(s),N)
返回tag key的N个tag value对应的field key的最大值。

TOP(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的最大的N个值，以及相关的tag和/或field。

TOP()支持数据类型为int64和float64的field value。

注释：

如果最大值有两个或多个并且它们之间有关联，TOP()返回具有最早时间戳的field value。
当TOP()函数与INTO子句一起使用时，TOP()与其它InfluxQL函数不同。请查看TOP()的常见问题章节获得更多信息。

示例

示例一：选择指定field key对应的最大的三个值

> 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

该查询返回measurement h2o_feet中field key water_level对应的最大的三个值。

示例二：选择两个tag对应的field key的最大值

> 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

该查询返回tag key location的两个tag value对应的field key water_level的最大值。

示例三：选择指定field key对应的最大的四个值以及相关的tag和field

> 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

该查询返回field key water_level对应的最大的四个值，以及相关的tag key location和field key level description的值。

示例四：选择指定field key对应的最大的三个值并包含多个子句

> 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分钟间隔内，field key water_level对应的最大的三个值，并且以递减的时间戳顺序返回结果。

请注意，GROUP BY time()子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。

`TOP()`的常见问题

问题一：`TOP()`和`GROUP BY time()`子句同时使用

对于同时带有TOP()和GROUP BY time()子句的查询，将返回每个GROUP BY time()时间间隔的指定个数的数据点。对于大多数GROUP BY time()查询，返回的时间戳表示GROUP BY time()时间间隔的开始时间，但是，带有TOP()函数的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个tag value的tag key

使用语法SELECT TOP(<field_key>,<tag_key>,<N>)的查询可以返回比预期少的数据点。如果tag key有X个tag value，但是查询指定的是N个tag value，如果X小于N，那么查询将返回X个数据点。

示例
以下查询请求的是tag key location的三个tag value对于的water_level的最大值。因为tag key location只有两个tag value(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()`、tag和`INTO`子句

当使用INTO子句但没有使用GROUP BY tag子句时，大多数InfluxQL函数将原始数据中的tag转换为新写入数据中的field。这种行为同样适用于TOP()函数，除非TOP()中包含tag key作为参数：TOP(field_key,tag_key(s),N)。在这些情况下，系统会将指定的tag保留为新写入数据中的tag。

示例
下面代码块中的第一个查询返回tag key location的两个tag value对应的field key water_level的最大值，并且，它这些结果写入measurement top_water_levels中。第二个查询展示了TSDB For InfluxDB®将tag location保留为measurement top_water_levels中的tag。

> 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

Transformations

ABS()

返回field value的绝对值。

基本语法

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)
返回field key对应的field value的绝对值。

ABS(*)
返回在measurement中每个field key对应的field value的绝对值。

ABS()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的field value的绝对值

> 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

该查询返回measurement data中field key a对应的field value的绝对值。

示例二：计算measurement中每个field key对应的field value的绝对值

> 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

该查询返回measurement data中每个存储数值的field key对应的field value的绝对值。measurement data中有两个数值类型的field：a和b。

示例三：计算指定field key对应的field value的绝对值并包含多个子句

> 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

该查询返回measurement data中field key a对应的field value的绝对值，它涵盖的时间范围在2018-06-24T12:00:00Z和2018-06-24T12:05:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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)
time                 abs
----                 ---
1529841600000000000  0.3960977256302787
1529842320000000000  0.0010541018316373302
1529843040000000000  0.04494733240283668
1529843760000000000  0.2553594777104415
1529844480000000000  0.20382988543108413
1529845200000000000  0.790836070736962

该查询返回field key a对应的每12分钟的时间间隔的field value的平均值的绝对值。

为了得到这些结果，TSDB For InfluxDB®首先计算field key a对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用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

然后，TSDB For InfluxDB®计算这些平均值的绝对值。

ACOS()

返回field value的反余弦(以弧度表示)。field value必须在-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)
返回field key对应的field value的反余弦。

ACOS(*)
返回在measurement中每个field key对应的field value的反余弦。

ACOS()支持数据类型为int64和float64的field value，并且field value必须在-1和1之间。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用ACOS()和GROUP BY time()子句。

基本语法示例

下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是，所有的field value都在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

示例一：计算指定field key对应的field value的反余弦

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反余弦。

示例二：计算measurement中每个field key对应的field value的反余弦

> 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

该查询返回measurement park_occupancy中每个存储数值的field key对应的field value的反余弦。measurement park_occupancy中只有一个数值类型的field：of_capacity。

示例三：计算指定field key对应的field value的反余弦并包含多个子句

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反余弦，它涵盖的时间范围在2017-05-01T00:00:00Z和2017-05-09T00:00:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key of_capacity对应的每三天的时间间隔的field value的平均值的反余弦。

为了得到这些结果，TSDB For InfluxDB®首先计算field key of_capacity对应的每三天的时间间隔的field value的平均值。这一步跟同时使用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

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

ASIN()

返回field value的反正弦(以弧度表示)。field value必须在-1和1之间。

基本语法

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

基本语法描述

ASIN(field_key)
返回field key对应的field value的反正弦。

ASIN(*)
返回在measurement中每个field key对应的field value的反正弦。

ASIN()支持数据类型为int64和float64的field value，并且field value必须在-1和1之间。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用ASIN()和GROUP BY time()子句。

基本语法示例

下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是，所有的field value都在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

示例一：计算指定field key对应的field value的反正弦

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反正弦。

示例二：计算measurement中每个field key对应的field value的反正弦

> 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

该查询返回measurement park_occupancy中每个存储数值的field key对应的field value的反正弦。measurement park_occupancy中只有一个数值类型的field：of_capacity。

示例三：计算指定field key对应的field value的反正弦并包含多个子句

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反正弦，它涵盖的时间范围在2017-05-01T00:00:00Z和2017-05-09T00:00:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key of_capacity对应的每三天的时间间隔的field value的平均值的反正弦。

为了得到这些结果，TSDB For InfluxDB®首先计算field key of_capacity对应的每三天的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用ASIN()的情形一样：

> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time                  mean
----                  ----
2017-04-30T00:00:00Z  0.565
2017-05-03T00:00:00Z  0.41
2017-05-06T00:00:00Z  0.71
2017-05-09T00:00:00Z  0.16

然后，TSDB For InfluxDB®计算这些平均值的反正弦。

ATAN()

返回field value的反正切（以弧度表示)。field value必须在-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)
返回field key对应的field value的反正切。

ATAN(*)
返回在measurement中每个field key对应的field value的反正切。

ATAN()支持数据类型为int64和float64的field value，并且field value必须在-1和1之间。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用ATAN()和GROUP BY time()子句。

基本语法示例

下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是，所有的field value都在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

示例一：计算指定field key对应的field value的反正切

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反正切。

示例二：计算measurement中每个field key对应的field value的反正切

> 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

该查询返回measurement park_occupancy中每个存储数值的field key对应的field value的反正切。measurement park_occupancy中只有一个数值类型的field：of_capacity。

示例三：计算指定field key对应的field value的反正切并包含多个子句

> 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

该查询返回measurement park_occupancy中field key of_capacity对应的field value的反正切，它涵盖的时间范围在2017-05-01T00:00:00Z和2017-05-09T00:00:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key of_capacity对应的每三天的时间间隔的field value的平均值的反正切。

为了得到这些结果，TSDB For InfluxDB®首先计算field key of_capacity对应的每三天的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用ATAN()的情形一样：

> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time                  mean
----                  ----
2017-04-30T00:00:00Z  0.565
2017-05-03T00:00:00Z  0.41
2017-05-06T00:00:00Z  0.71
2017-05-09T00:00:00Z  0.16

然后，TSDB For 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 “field_key_y”对应的field value除以field key “field_key_x”对应的field value的反正切。

ATAN2(*, field_key_x)<br />返回在measurement中每个field key对应的field value除以field key “field_key_x”对应的field value的反正切。

ATAN2()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

该查询返回field key altitude_ft对应的field value除以field key distance_ft对应的field value的反正切。这两个field key都在measurement flight_data中。

示例二：计算measurement中每个field key除以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

该查询返回measurement flight_data中每个存储数值的field key对应的field value除以field key distance_ft对应的field value的反正切。measurement flight_data中有两个数值类型的field：altitude_ft和distance_ft。

示例三：计算field value的反正切并包含多个子句

> 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

该查询返回field key altitude_ft对应的field value除以field key distance_ft对应的field value的反正切，它涵盖的时间范围在2018-05-16T12:10:00Z和2018-05-16T12:10:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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

该查询返回field key altitude_ft对应的field value的平均值除以field key distance_ft对应的field value的平均值的反正切。平均值是按每12分钟的时间间隔计算的。

为了得到这些结果，TSDB For InfluxDB®首先计算field key altitude_ft和distance_ft对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用ATAN2()的情形一样：

> SELECT MEAN("altitude_ft"), MEAN("distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T13:01:00Z' GROUP BY time(12m)
name: flight_data
time                  mean                mean_1
----                  ----                ------
2018-05-16T12:00:00Z  8674                64433.181818181816
2018-05-16T12:12:00Z  26419.833333333332  96865.25
2018-05-16T12:24:00Z  40337.416666666664  132326.41666666666
2018-05-16T12:36:00Z  41149.583333333336  169743.16666666666
2018-05-16T12:48:00Z  41230.416666666664  213600.91666666666
2018-05-16T13:00:00Z  41184.5             235799

然后，TSDB For 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)
返回field key对应的大于field value的最小整数。

CEIL(*)
返回在measurement中每个field key对应的大于field value的最小整数。

CEIL()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的大于field value的最小整数

> 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

该查询返回measurement h2o_feet中field key water_level对应的大于field value的最小整数。

示例二：计算measurement中每个field key对应的大于field value的最小整数

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的大于field value的最小整数。measurement h2o_feet只有一个数值类型的field：water_level。

示例三：计算指定field key对应的大于field value的最小整数并包含多个子句

> 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

该查询返回field key water_level对应的大于field value的最小整数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回)。

高级语法

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平均值的最小整数。

为了得到这些结果，TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的大于water_level的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用CEIL()的情形一样：

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

然后，TSDB For InfluxDB®计算大于这些平均值的最小整数。

COS()

返回field value的余弦值。

基本语法

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)
返回field key对应的field value的余弦值。

COS(*)
返回在measurement中每个field key对应的field value的余弦值。

COS()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的field value的余弦值

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的余弦值。

示例二：计算measurement中每个field key对应的field value的余弦值

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的余弦值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的余弦值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的余弦值，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key water_level对应的每12分钟的时间间隔的field value的平均值的余弦值。

为了得到这些结果，TSDB For InfluxDB®首先计算field key water_level对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用COS()的情形一样：

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

然后，TSDB For InfluxDB®计算这些平均值的余弦值。

CUMULATIVE_SUM()

返回field value的累积总和。

基本语法

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)
返回field key对应的field value的累积总和。

CUMULATIVE_SUM(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的累积总和。

CUMULATIVE_SUM(*)
返回在measurement中每个field key对应的field value的累积总和。

CUMULATIVE_SUM()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的field value的累积总和

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的累积总和。

示例二：计算measurement中每个field key对应的field value的累积总和

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的累积总和。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的累积总和

> 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

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的累积总和。

示例四：计算指定field key对应的field value的累积总和并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的累积总和，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key water_level对应的每12分钟的时间间隔的field value的平均值的累积总和。

为了得到这些结果，TSDB For InfluxDB®首先计算field key water_level对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用CUMULATIVE_SUM()的情形一样：

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

然后，TSDB For InfluxDB®计算这些平均值的累积总和。最终查询结果中的第二个数据点(4.167)是2.09和2.077的总和，第三个数据点(6.213)是2.09、2.077和2.0460000000000003的总和。

DERIVATIVE()

返回field value之间的变化率，即导数。

基本语法

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]

基本语法描述

TSDB For InfluxDB®计算field value之间的差值，并将这些结果转换为每个unit的变化率。参数unit的值是一个整数，后跟一个时间单位。这个参数是可选的，不是必须要有的。如果查询没有指定unit的值，那么unit默认为一秒(1s)。

DERIVATIVE(field_key)
返回field key对应的field value的变化率。

DERIVATIVE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的变化率。

DERIVATIVE(*)
返回在measurement中每个field key对应的field value的变化率。

DERIVATIVE()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用DERIVATIVE()和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

示例一：计算指定field key对应的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'
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

该查询返回measurement h2o_feet中field key water_level对应的field value的每秒变化率。

第一个结果(0.00014444444444444457)是原始数据中前两个field value在一秒内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为一秒的变化率：

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

示例二：计算指定field key对应的field value的导数并指定`unit`

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的每六分钟的变化率。

第一个结果(0.052000000000000046)是原始数据中前两个field value在六分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为六分钟的变化率：

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

示例三：计算measurement中每个field key对应的field value的导数并指定`unit`

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的每三分钟的变化率。measurement h2o_feet中只有一个数值类型的field：water_level。

第一个结果(0.026000000000000023)是原始数据中前两个field value在三分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为三分钟的变化率：

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

示例四：计算与正则表达式匹配的每个field key对应的field value的导数并指定`unit`

> 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

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value的每两分钟的变化率。measurement h2o_feet中只有一个数值类型的field：water_level。

第一个结果(0.01733333333333335)是原始数据中前两个field value在两分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为两分钟的变化率：

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

示例五：计算指定field key对应的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

该查询返回measurement h2o_feet中field key water_level对应的field value的每秒变化率，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为1，并将返回的数据点偏移两个(即前两个数据点不返回）。

唯一的结果(-0.0002722222222222218)是原始数据中前两个field value在一秒内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为一秒的变化率：

(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()间隔内嵌套函数的结果，然后计算这些结果的导数。

参数unit的值是一个整数，后跟一个时间单位。这个参数是可选的，不是必须要有的。如果查询没有指定unit的值，那么unit默认为GROUP BY time()的时间间隔。请注意，这里unit的默认值跟基本语法中unit的默认值不一样。

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

该查询返回field key water_level对应的每12分钟的时间间隔的field value的平均值的每12分钟变化率。

为了得到这些结果，TSDB For InfluxDB®首先计算field key water_level对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()函数和GROUP BY time()子句、但不使用DERIVATIVE()的情形一样：

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

然后，TSDB For InfluxDB®计算这些平均值的每12分钟的变化率。第一个结果(-0.0129999999999999)是原始数据中前两个field value在12分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为12分钟的变化率：

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

示例二：计算平均值的导数并指定`unit`

> 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

该查询返回field key water_level对应的每12分钟的时间间隔的field value的平均值的每六分钟变化率。

> 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

然后，TSDB For InfluxDB®计算这些平均值的每六分钟的变化率。第一个结果(-0.00649999999999995)是原始数据中前两个field value在六分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值，并将该值标准化为六分钟的变化率：

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

DIFFERENCE()

返回field value之间的差值。

基本语法

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

基本语法描述

DIFFERENCE(field_key)
返回field key对应的field value的差值。

DIFFERENCE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的差值。

DIFFERENCE(*)
返回在measurement中每个field key对应的field value的差值。

DIFFERENCE()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的field value的差值

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value之间的差值。

示例二：计算measurement中每个field key对应的field value的差值

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value之间的差值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的差值

> 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

该查询返回measurement h2o_feet中每个存储数值并包含单词water的field key对应的field value之间的差值。

示例四：计算指定field key对应的field value的差值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value之间的差值，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为2，并将返回的数据点偏移两个（即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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

该查询返回field key water_level对应的每12分钟的时间间隔的field value的最大值之间的差值。

为了得到这些结果，TSDB For InfluxDB®首先计算field key water_level对应的每12分钟的时间间隔的field value的最大值。这一步跟同时使用MAX()函数和GROUP BY time()子句、但不使用DIFFERENCE()的情形一样：

> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time                   max
----                   ---
2015-08-18T00:00:00Z   2.116
2015-08-18T00:12:00Z   2.126
2015-08-18T00:24:00Z   2.051

然后，TSDB For InfluxDB®计算这些最大值之间的差值。最终查询结果中的第一个数据点(0.009999999999999787)是2.126和2.116的差，第二个数据点(-0.07499999999999973)是2.051和2.126的差。

ELAPSED()

返回field value的时间戳之间的差值。

语法

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]

语法描述

TSDB For InfluxDB®计算时间戳之间的差值。参数unit的值是一个整数，后跟一个时间单位，它决定了返回的差值的单位。这个参数是可选的，不是必须要有的。如果没有指定unit的值，那么查询将返回以纳秒为单位的两个时间戳之间的差值。

ELAPSED(field_key)
返回field key对应的时间戳之间的差值。

ELAPSED(/regular_expression/)
返回与正则表达式匹配的每个field key对应的时间戳之间的差值。

ELAPSED(*)
返回在measurement中每个field key对应的时间戳之间的差值。

ELAPSED()支持所有数据类型的field value。

基本语法示例

下面的示例将使用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

示例一：计算指定field key对应的field value之间的时间间隔

> 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

该查询返回measurement h2o_feet中field key water_level对应的时间戳之间的差值(以纳秒为单位)。

示例二：计算指定field key对应的field value之间的时间间隔并指定`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

该查询返回measurement h2o_feet中field key water_level对应的时间戳之间的差值(以分钟为单位)。

示例三：计算measurement中每个field key对应的field value之间的时间间隔并指定`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

该查询返回measurement h2o_feet中每个field key对应的时间戳之间的差值(以分钟为单位)。measurement h2o_feet中有两个field key：level description和water_level。

示例四：计算与正则表达式匹配的每个field key对应的field value之间的时间间隔并指定`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

该查询返回measurement h2o_feet中每个包含单词level的field key对应的时间戳之间的差值(以秒为单位)。

示例五：计算指定field key对应的field value之间的时间间隔并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的时间戳之间的差值(以毫秒为单位)，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:12:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为1，并将返回的数据点偏移一个（即前一个数据点不返回）。

请注意，查询结果是负数；因为ORDER BY time DESC子句按递减的顺序对时间戳进行排序，所以ELAPSED()以相反的顺序计算时间戳的差值。

`ELAPSED()`的常见问题

问题一：`ELAPSED()`和大于经过时间的单位

如果unit的值大于时间戳之间的差值，那么TSDB For InfluxDB®将会返回0。

示例
measurement h2o_feet中每六分钟有一个数据点。如果查询将unit设置为一小时，TSDB For InfluxDB®将会返回0：

> SELECT ELAPSED("water_level",1h) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time                   elapsed
----                   -------
2015-08-18T00:06:00Z   0
2015-08-18T00:12:00Z   0

问题二：`ELAPSED()`和`GROUP BY time()`子句同时使用

ELAPSED()函数支持GROUP BY time()子句，但是查询结果不是特别有用。目前，如果ELAPSED()查询包含一个嵌套的InfluxQL函数和一个GROUP BY time()子句，那么只会返回指定GROUP BY time()子句中的时间间隔。

GROUP BY time()子句决定了查询结果中的时间戳：每个时间戳表示时间间隔的开始时间。该行为也适用于嵌套的selector函数(例如FIRST()或MAX())，而在其它的所有情况下，这些函数返回的是原始数据的特定时间戳。因为GROUP BY time()子句会覆盖原始时间戳，所以ELAPSED()始终返回与GROUP BY time()的时间间隔相同的时间戳。

示例
下面代码块中的第一个查询尝试使用ELAPSED()和GROUP BY time()子句来查找最小的water_level的值之间经过的时间(以分钟为单位)。查询的两个时间间隔都返回了12分钟。

为了得到这些结果，TSDB For 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()

返回field value的指数。

基本语法

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

基本语法描述

EXP(field_key)
返回field key对应的field value的指数。

EXP(*)
返回在measurement中每个field key对应的field value的指数。

EXP()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用EXP()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的指数

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的指数。

示例二：计算measurement中每个field key对应的field value的指数

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的指数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的指数并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的指数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回)。

高级语法

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()支持以下嵌套函数：

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的平均值的绝对值。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些平均值的指数。

FLOOR()

返回小于指定值的最大整数。

基本语法

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

基本语法描述

FLOOR(field_key)
返回field key对应的小于field value的最大整数。

FLOOR(*)
返回在measurement中每个field key对应的小于field value的最大整数。

FLOOR()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的小于field value的最大整数

> 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

该查询返回measurement h2o_feet中field key water_level对应的小于field value的最大整数。

示例二：计算measurement中每个field key对应的小于field value的最大整数

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的小于field value的最大整数。measurement h2o_feet只有一个数值类型的field：water_level。

示例三：计算指定field key对应的小于field value的最大整数并包含多个子句

> 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

该查询返回field key water_level对应的小于field value的最大整数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回)。

高级语法

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平均值的最大整数。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算小于这些平均值的最大整数。

LN()

返回field value的自然对数。

基本语法

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

基本语法描述

LN(field_key)
返回field key对应的field value的自然对数。

LN(*)
返回在measurement中每个field key对应的field value的自然对数。

LN()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用LN()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的自然对数

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的自然对数。

示例二：计算measurement中每个field key对应的field value的自然对数

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的自然对数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的自然对数并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的field value的自然对数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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的平均值的自然对数。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些平均值的自然对数。

LOG()

返回field value的以b为底数的对数。

基本语法

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

基本语法描述

LOG(field_key, b)
返回field key对应的field value的以b为底数的对数。

LOG(*, b)
返回在measurement中每个field key对应的field value的以b为底数的对数。

LOG()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用LOG()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以4为底数的对数。

示例二：计算measurement中每个field key对应的field value的以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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的以4为底数的对数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以4为底数的对数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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为底数的对数。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些平均值的以4为底数的对数。

LOG2()

返回field value的以2为底数的对数。

基本语法

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

基本语法描述

LOG2(field_key)
返回field key对应的field value的以2为底数的对数。

LOG2(*)
返回在measurement中每个field key对应的field value的以2为底数的对数。

LOG2()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用LOG2()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以2为底数的对数。

示例二：计算measurement中每个field key对应的field value的以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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的以2为底数的对数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以2为底数的对数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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()间隔内嵌套函数的结果，然后计算这些结果的以2为底数的对数。

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为底数的对数。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些平均值的以2为底数的对数。

LOG10()

返回field value的以10为底数的对数。

基本语法

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

基本语法描述

LOG10(field_key)
返回field key对应的field value的以10为底数的对数。

LOG10(*)
返回在measurement中每个field key对应的field value的以10为底数的对数。

LOG10()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用LOG10()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以10为底数的对数。

示例二：计算measurement中每个field key对应的field value的以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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的以10为底数的对数。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的以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

该查询返回measurement h2o_feet中field key water_level对应的field value的以10为底数的对数，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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()间隔内嵌套函数的结果，然后计算这些结果的以10为底数的对数。

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为底数的对数。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些平均值的以10为底数的对数。

MOVING_AVERAGE()

返回field value窗口的滚动平均值。

基本语法

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个连续field value的窗口的滚动平均值。参数N是一个整数，并且它是必须的。

MOVING_AVERAGE(field_key,N)
返回field key对应的N个field value的滚动平均值。

MOVING_AVERAGE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的N个field value的滚动平均值。

MOVING_AVERAGE(*,N)
返回在measurement中每个field key对应的N个field value的滚动平均值。

MOVING_AVERAGE()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用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

示例一：计算指定field key对应的field value的滚动平均值

> 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

该查询返回measurement h2o_feet中field key water_level对应的窗口大小为两个field value的滚动平均值。第一个结果(2.09)是原始数据中前两个field value的平均值：(2.064 + 2.116) / 2。第二个结果(2.072)是原始数据中第二和第三个field value的平均值：(2.116 + 2.028) / 2。

示例二：计算measurement中每个field key对应的field value的滚动平均值

> 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

该查询返回measurement h2o_feet中每个存储数值的field key对应的窗口大小为三个field value的滚动平均值。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算与正则表达式匹配的每个field key对应的field value的滚动平均值

> 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

该查询返回measurement h2o_feet中每个存储数值并包含单词level的field key对应的窗口大小为四个field value的滚动平均值。

示例四：计算指定field key对应的field value的滚动平均值并包含多个子句

> 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

该查询返回measurement h2o_feet中field key water_level对应的窗口大小为两个field value的滚动平均值，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为2，并将返回的数据点偏移三个(即前三个数据点不返回）。

高级语法

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()支持以下嵌套函数：

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的最大值的窗口大小为两个值的滚动平均值。

为了得到这些结果，TSDB For 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

然后，TSDB For InfluxDB®计算这些最大值的窗口大小为两个值的滚动平均值。最终查询结果中的第一个数据点(2.121)是前两个最大值的平均值((2.116 + 2.126) / 2)。

NON_NEGATIVE_DERIVATIVE()

返回field value之间的非负变化率。非负变化率包括正的变化率和等于0的变化率。

基本语法

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]

基本语法描述

TSDB For InfluxDB®计算field value之间的差值，并将这些结果转换为每个unit的变化率。参数unit的值是一个整数，后跟一个时间单位。这个参数是可选的，不是必须要有的。如果查询没有指定unit的值，那么unit默认为一秒(1s)。NON_NEGATIVE_DERIVATIVE()只返回正的变化率和等于0的变化率。

NON_NEGATIVE_DERIVATIVE(field_key)
返回field key对应的field value的非负变化率。

NON_NEGATIVE_DERIVATIVE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的非负变化率。

NON_NEGATIVE_DERIVATIVE(*)
返回在measurement中每个field key对应的field value的非负变化率。

NON_NEGATIVE_DERIVATIVE()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用NON_NEGATIVE_DERIVATIVE()和GROUP BY time()子句。

基本语法示例

请查看DERIVATIVE()文档中的示例，NON_NEGATIVE_DERIVATIVE()跟DERIVATIVE()的运行方式相同，但是NON_NEGATIVE_DERIVATIVE()只返回查询结果中正的变化率和等于0的变化率。

高级语法

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()间隔内嵌套函数的结果，然后计算这些结果的非负导数。

参数unit的值是一个整数，后跟一个时间单位。这个参数是可选的，不是必须要有的。如果查询没有指定unit的值，那么unit默认为GROUP BY time()的时间间隔。请注意，这里unit的默认值跟基本语法中unit的默认值不一样。NON_NEGATIVE_DERIVATIVE()只返回正的变化率和等于0的变化率。

NON_NEGATIVE_DERIVATIVE()支持以下嵌套函数：

COUNT()
MEAN()
MEDIAN()
MODE()
SUM()
FIRST()
LAST()
MIN()
MAX()
PERCENTILE()

高级语法示例

NON_NEGATIVE_DIFFERENCE()

返回field value之间的非负差值。非负差值包括正的差值和等于0的差值。

基本语法

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)
返回field key对应的field value的非负差值。

NON_NEGATIVE_DIFFERENCE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的非负差值。

NON_NEGATIVE_DIFFERENCE(*)
返回在measurement中每个field key对应的field value的非负差值。

NON_NEGATIVE_DIFFERENCE()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用NON_NEGATIVE_DIFFERENCE()和GROUP BY time()子句。

基本语法示例

请查看DIFFERENCE()文档中的示例，NON_NEGATIVE_DIFFERENCE()跟DIFFERENCE()的运行方式相同，但是NON_NEGATIVE_DIFFERENCE()只返回查询结果中正的差值和等于0的差值。

高级语法

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()支持以下嵌套函数：

COUNT()
MEAN()
MEDIAN()
MODE()
SUM()
FIRST()
LAST()
MIN()
MAX()
PERCENTILE()

高级语法示例

POW()

返回field value的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)
返回field key对应的field value的x次方。

POW(*, x)
返回在measurement中每个field key对应的field value的x次方。

POW()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用POW()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value的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

该查询返回measurement h2o_feet中field key water_level对应的field value的4次方。

示例二：计算measurement中每个field key对应的field value的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

该查询返回measurement h2o_feet中每个存储数值的field key对应的field value的4次方。measurement h2o_feet中只有一个数值类型的field：water_level。

示例三：计算指定field key对应的field value的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

该查询返回measurement h2o_feet中field key water_level对应的field value的4次方，它涵盖的时间范围在2015-08-18T00:00:00Z和2015-08-18T00:30:00Z之间，并且以递减的时间戳顺序返回结果，同时，该查询将返回的数据点个数限制为4，并将返回的数据点偏移两个(即前两个数据点不返回）。

高级语法

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()间隔内嵌套函数的结果，然后计算这些结果的x次方。

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次方。

为了得到这些结果，TSDB For 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

然后，TSDB For 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)
返回field key对应的field value四舍五入后的整数。

ROUND(*)
返回在measurement中每个field key对应的field value四舍五入后的整数。

ROUND()支持数据类型为int64和float64的field value。

基本语法支持group by tags的GROUP BY子句，但是不支持group by time。请查看高级语法章节了解如何使用ROUND()和GROUP BY time()子句。

基本语法示例

下面的示例将使用示例数据中的如下数据：

> 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

示例一：计算指定field key对应的field value四舍五入后的整数

> 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-

InfluxQL函数

Aggregations

COUNT()

语法

嵌套语法

语法描述

示例

示例一：计算指定field key对应的field value的个数

示例二：计算measurement中每个field key对应的field value的个数

示例三：计算与正则表达式匹配的每个field key对应的field value的个数

示例四：计算指定field key对应的field value的个数并包含多个子句

示例五：计算指定field key对应的不同field value的个数

COUNT()的常见问题

问题一：COUNT()和fill()

DISTINCT()

语法

嵌套语法

语法描述

示例

示例一：列出指定field key对应的不同的field value

示例二：列出measurement中每个field key对应的不同的field value

示例三：列出与正则表达式匹配的每个field key对应的不同的field value

示例四：列出指定field key对应的不同的field value并包含多个子句

示例五：计算指定field key对应的不同field value的个数

DISTINCT()的常见问题

问题一：DISTINCT()和INTO子句

INTEGRAL()

语法

语法描述

示例

示例一：计算指定field key对应的field value的积分

示例二：计算指定field key对应的field value的积分并指定unit

示例三：计算measurement中每个field key对应的field value的积分并指定unit

示例四：计算与正则表达式匹配的每个field key对应的field value的积分并指定unit

示例五：计算指定field key对应的field value的积分并包含多个子句

MEAN()

语法

语法描述

示例

示例一：计算指定field key对应的field value的平均值

示例二：计算measurement中每个field key对应的field value的平均值

示例三：计算与正则表达式匹配的每个field key对应的field value的平均值

示例四：计算指定field key对应的field value的平均值并包含多个子句

MEDIAN()

语法

语法描述

示例

示例一：计算指定field key对应的field value的中位数

示例二：计算measurement中每个field key对应的field value的中位数

示例三：计算与正则表达式匹配的每个field key对应的field value的中位数

示例四：计算指定field key对应的field value的中位数并包含多个子句

MODE()

语法

语法描述

示例

示例一：计算指定field key对应的field value中出现频率最高的值

示例二：计算measurement中每个field key对应的field value中出现频率最高的值

示例三：计算与正则表达式匹配的每个field key对应的field value中出现频率最高的值

示例四：计算指定field key对应的field value中出现频率最高的值并包含多个子句

SPREAD()

语法

语法描述

示例

示例一：计算指定field key对应的field value中最大值和最小值之差

示例二：计算measurement中每个field key对应的field value中最大值和最小值之差

示例三：计算与正则表达式匹配的每个field key对应的field value中最大值和最小值之差

示例四：计算指定field key对应的field value中最大值和最小值之差并包含多个子句

STDDEV()

语法

语法描述

示例

示例一：计算指定field key对应的field value的标准差

示例二：计算measurement中每个field key对应的field value的标准差

示例三：计算与正则表达式匹配的每个field key对应的field value的标准差

示例四：计算指定field key对应的field value的标准差并包含多个子句

SUM()

语法

语法描述

示例

示例一：计算指定field key对应的field value的总和

示例二：计算指定field key对应的field value的积分并指定`unit`

示例三：计算measurement中每个field key对应的field value的积分并指定`unit`

示例四：计算与正则表达式匹配的每个field key对应的field value的积分并指定`unit`

`BOTTOM()`的常见问题

问题一：`BOTTOM()`和`GROUP BY time()`子句同时使用

问题二：`BOTTOM()`和具有少于N个tag value的tag key

问题三：`BOTTOM()`、tag和`INTO`子句

`PERCENTILE()`的常见问题

问题一：`PERCENTILE()` vs 其它InfluxQL函数