InfluxDB之InfluxQL函数

3、InfluxQL函数

3.1 聚合函数

本文档主要介绍了聚合函数（Aggregations）的语法结构、语法说明以及使用示例。

COUNT()

返回非空的field value的个数。

语法

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

嵌套语法

SELECT COUNT(DISTINCT([*||//]))[…]

语法说明

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()函数里。

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

SELECT COUNT("water_level") FROM "h2o_feet"

name: h2o_feet
time                   count
---------
1970-01-01T00:00:00Z15258

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

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

SELECT COUNT(*) FROM "h2o_feet"

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

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

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

SELECT COUNT(/water/) FROM "h2o_feet"

name: h2o_feet
time                   count_water_level
---------------------
1970-01-01T00:00:00Z15258

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

示例4：计算指定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:00Z200
2015-08-18T00:00:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:24:00Z2
2015-08-18T00:36:00Z2
2015-08-18T00:48:00Z2

该查询返回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:00Z4

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

COUNT()的常见问题

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

示例

> 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:00Z2
2015-09-18T21:36:00Z2
2015-09-18T21:48:00Z0

> 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:00Z2
2015-09-18T21:36:00Z2
2015-09-18T21:48:00Z800000

上述代码块中的第一个查询没有使用fill()，最后一个时间间隔中没有数据，因此该时间间隔返回的值是0。第二个查询使用了fill(800000)，它将最后一个时间间隔的返回值0替换成800000。

DISTINCT()

返回不同的field value。

语法

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

嵌套语法

SELECT COUNT(DISTINCT([*||//]))[…]

语法说明

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()函数里。

示例1：列出指定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。

示例2：列出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。

示例3：列出与正则表达式匹配的每个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。

示例4：列出指定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。

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

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

name: h2o_feet
time                   count
---------
1970-01-01T00:00:00Z4

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

DISTINCT()的常见问题

在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:00Z4

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([*||//][,])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

语法说明

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

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。

示例1：计算指定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:00Z3732.66

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

示例2：计算指定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:00Z62.211

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

示例3：计算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:00Z62.211

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

示例4：计算与正则表达式匹配的每个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:00Z62.211

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

示例5：计算指定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:00Z24.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([*||//])[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。

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

SELECT MEAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                   mean
--------
1970-01-01T00:00:00Z4.442107025822522

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

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

SELECT MEAN(*) FROM "h2o_feet"

name: h2o_feet
time                   mean_water_level
--------------------
1970-01-01T00:00:00Z4.442107025822522

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

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

SELECT MEAN(/water/) FROM "h2o_feet"

name: h2o_feet
time                   mean_water_level
--------------------
1970-01-01T00:00:00Z4.442107025822523

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

示例4：计算指定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:00Z9.01
2015-08-18T00:00:00Z8.0625
2015-08-18T00:12:00Z7.8245
2015-08-18T00:24:00Z7.5675
2015-08-18T00:36:00Z7.303
2015-08-18T00:48:00Z7.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([*||//])[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()将返回两个中间值的平均数。

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

SELECT MEDIAN("water_level") FROM "h2o_feet"

name: h2o_feet
time                   median
----------
1970-01-01T00:00:00Z4.124

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

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

SELECT MEDIAN(*) FROM "h2o_feet"

name: h2o_feet
time                   median_water_level
----------------------
1970-01-01T00:00:00Z4.124

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

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

SELECT MEDIAN(/water/) FROM "h2o_feet"

name: h2o_feet
time                   median_water_level
----------------------
1970-01-01T00:00:00Z4.124

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

示例4：计算指定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:00Z700
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003
2015-08-18T00:36:00Z2.0620000000000003
2015-08-18T00:48:00Z700

该查询返回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([*||//])[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。

示例1：计算指定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中出现频率最高的值。

示例2：计算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。

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

SELECT MODE(/water/) FROM "h2o_feet"

name: h2o_feet
time                   mode_water_level
--------------------
1970-01-01T00:00:00Z2.69

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

示例4：计算指定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([*||//])[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。

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

SELECT SPREAD("water_level") FROM "h2o_feet"

name: h2o_feet
time                   spread
----------
1970-01-01T00:00:00Z10.574

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

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

SELECT SPREAD(*) FROM "h2o_feet"

name: h2o_feet
time                   spread_water_level
----------------------
1970-01-01T00:00:00Z10.574

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

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

SELECT SPREAD(/water/) FROM "h2o_feet"

name: h2o_feet
time                   spread_water_level
----------------------
1970-01-01T00:00:00Z10.574

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

示例4：计算指定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:00Z18
2015-08-18T00:00:00Z0.052000000000000046
2015-08-18T00:12:00Z0.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([*||//])[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。

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

SELECT STDDEV("water_level") FROM "h2o_feet"

name: h2o_feet
time                   stddev
----------
1970-01-01T00:00:00Z2.279144584196141

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

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

SELECT STDDEV(*) FROM "h2o_feet"

name: h2o_feet
time                   stddev_water_level
----------------------
1970-01-01T00:00:00Z2.279144584196141

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

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

SELECT STDDEV(/water/) FROM "h2o_feet"

name: h2o_feet
time                   stddev_water_level
----------------------
1970-01-01T00:00:00Z2.279144584196141

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

示例4：计算指定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:00Z18000
2015-08-18T00:00:00Z0.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([*||//])[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。

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

SELECT SUM("water_level") FROM "h2o_feet"

name: h2o_feet
time                   sum
-------
1970-01-01T00:00:00Z67777.66900000004

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

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

SELECT SUM(*) FROM "h2o_feet"

name: h2o_feet
time                   sum_water_level
-------------------
1970-01-01T00:00:00Z67777.66900000004

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

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

SELECT SUM(/water/) FROM "h2o_feet"

name: h2o_feet
time                   sum_water_level
-------------------
1970-01-01T00:00:00Z67777.66900000004

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

示例4：计算指定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:00Z18000
2015-08-18T00:00:00Z16.125
2015-08-18T00:12:00Z15.649
2015-08-18T00:24:00Z15.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。

3.2 选择函数

本文档主要介绍了选择函数（Selectors）的语法结构、语法说明以及使用示例。

BOTTOM()

返回最小的N个field value。

语法

SELECT BOTTOM([,],)[,|][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函数不同。
示例1：选择指定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对应的最小的三个值。

示例2：选择两个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的最小值。

示例3：选择指定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的值。

示例4：选择指定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:00Z1.991   santa_monica
2015-08-18T00:54:00Z2.054   santa_monica
2015-08-18T00:54:00Z6.982   coyote_creek
2015-08-18T00:24:00Z2.041   santa_monica
2015-08-18T00:30:00Z2.051   santa_monica
2015-08-18T00:42:00Z2.057   santa_monica
2015-08-18T00:00:00Z2.064   santa_monica
2015-08-18T00:06:00Z2.116   santa_monica
2015-08-18T00:12:00Z2.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:00Z2.064|
2015-08-18T00:12:00Z2.028|<-------Smallest points for the first time interval
--
                           __
2015-08-18T00:24:00Z2.041|
2015-08-18T00:30:00Z2.051|<-------Smallest points for the second time interval
--

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

使用语法SELECT BOTTOM(,,)的查询可以返回比预期少的数据点。如果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中。第二个查询展示了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:00Z2

> SHOW TAG KEYS FROM "bottom_water_levels"

name: bottom_water_levels
tagKey
------
location

FIRST()

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

语法

SELECT FIRST()[,|][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。

示例1：选择指定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。

示例2：选择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。

示例3：选择与正则表达式匹配的每个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。

示例4：选择指定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的值。

示例5：选择指定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:00Z9.01
2015-08-18T00:00:00Z8.12
2015-08-18T00:12:00Z7.887
2015-08-18T00:24:00Z7.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()[,|][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。

示例1：选择指定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。

示例2：选择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。

示例3：选择与正则表达式匹配的每个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。

示例4：选择指定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的值。

示例5：选择指定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:00Z9.01
2015-08-18T00:00:00Z8.005
2015-08-18T00:12:00Z7.762
2015-08-18T00:24:00Z7.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。

说明 GROUP BY time()子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间，其中，第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z和2015-08-18T00:00:00Z之间，最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z和2015-08-18T00:36:00Z之间。

MAX()

返回field value的最大值。

语法

SELECT MAX()[,|][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。

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

SELECT MAX("water_level") FROM "h2o_feet"

name: h2o_feet
time                   max
-------
2015-08-29T07:24:00Z9.964

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

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

SELECT MAX(*) FROM "h2o_feet"

name: h2o_feet
time                   max_water_level
-------------------
2015-08-29T07:24:00Z9.964

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

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

SELECT MAX(/water/) FROM "h2o_feet"

name: h2o_feet
time                   max_water_level
-------------------
2015-08-29T07:24:00Z9.964

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

示例4：选择指定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:00Z9.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的值。

示例5：选择指定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:00Z9.01
2015-08-18T00:00:00Z8.12
2015-08-18T00:12:00Z7.887
2015-08-18T00:24:00Z7.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之间。

MIN()

返回field value的最小值。

语法

SELECT MIN()[,|][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。

示例1：选择指定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的最小值。

示例2：选择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。

示例3：选择与正则表达式匹配的每个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的最小值。

示例4：选择指定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的值。

示例5：选择指定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:00Z9.01
2015-08-18T00:00:00Z8.005
2015-08-18T00:12:00Z7.762
2015-08-18T00:24:00Z7.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。

说明 GROUP BY time()子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间，其中，第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z和2015-08-18T00:00:00Z之间，最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z和2015-08-18T00:36:00Z之间。

PERCENTILE()

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

语法

SELECT PERCENTILE(,)[,|][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。

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

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

name: h2o_feet
time                   percentile
--------------
2015-08-31T03:42:00Z1.122

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

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

SELECT PERCENTILE(*,5) FROM "h2o_feet"

name: h2o_feet
time                   percentile_water_level
--------------------------
2015-08-31T03:42:00Z1.122

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

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

SELECT PERCENTILE(/water/,5) FROM "h2o_feet"

name: h2o_feet
time                   percentile_water_level
--------------------------
2015-08-31T03:42:00Z1.122

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

示例4：选择指定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:00Z1.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:00Z15
2015-08-18T00:00:00Z2.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()与其它InfluxQL函数进行对比

• PERCENTILE(,100)相当于MAX()。

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

• PERCENTILE(,0)不等于MIN()，PERCENTILE(,0)会返回null。

SAMPLE()

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

语法

SELECT SAMPLE(,)[,|][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。

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

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

name: h2o_feet
time                   sample
----------
2015-09-09T21:48:00Z5.659
2015-09-18T10:00:00Z6.939

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

示例2：选择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:00Z3.284
2015-09-03T04:30:00Z   below 3 feet
2015-09-03T20:06:00Z   between 3 and 6 feet
2015-09-08T21:54:00Z3.412

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

示例3：选择与正则表达式匹配的每个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:00Z7.854
2015-09-09T20:30:00Z7.32
2015-09-13T19:18:00Z   between 3 and 6 feet

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

示例4：选择指定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:00Z5.689   coyote_creek  between 3 and 6 feet
2015-09-08T15:48:00Z6.391   coyote_creek  between 6 and 9 feet

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

示例5：选择指定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:00Z2.028
2015-08-18T00:30:00Z2.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:00Z2.116|
2015-08-18T00:12:00Z2.028|<-------Randomly-selected points for the first time interval
--
                           __
2015-08-18T00:18:00Z2.126|
2015-08-18T00:30:00Z2.051|<-------Randomly-selected points for the second time interval
--

TOP()

返回最大的N个field value。

语法

SELECT TOP([,],)[,|][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函数不同。

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

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

name: h2o_feet
time                   top
-------
2015-08-29T07:18:00Z9.957
2015-08-29T07:24:00Z9.964
2015-08-29T07:30:00Z9.954

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

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

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

name: h2o_feet
time                   top     location
---------------
2015-08-29T03:54:00Z7.205   santa_monica
2015-08-29T07:24:00Z9.964   coyote_creek

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

示例3：选择指定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:00Z9.957  coyote_creek  at or greater than 9 feet
2015-08-29T07:24:00Z9.964  coyote_creek  at or greater than 9 feet
2015-08-29T07:30:00Z9.954  coyote_creek  at or greater than 9 feet
2015-08-29T07:36:00Z9.941  coyote_creek  at or greater than 9 feet

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

示例4：选择指定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:00Z7.11   coyote_creek
2015-08-18T00:54:00Z6.982  coyote_creek
2015-08-18T00:54:00Z2.054  santa_monica
2015-08-18T00:24:00Z7.635  coyote_creek
2015-08-18T00:30:00Z7.5    coyote_creek
2015-08-18T00:36:00Z7.372  coyote_creek
2015-08-18T00:00:00Z8.12   coyote_creek
2015-08-18T00:06:00Z8.005  coyote_creek
2015-08-18T00:12:00Z7.887  coyote_creek

该查询返回在2015-08-18T00:00:00Z和2015-08-18T00:54:00Z之间的每个24分钟间隔内，field key water_level对应的最大的三个值，并且以递减的时间戳顺序返回结果。

说明 GROUP BY time()子句不会覆盖数据点的原始时间戳。

TOP()的常见问题

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

对于同时带有TOP()和GROUP BY time()子句的查询，将返回每个GROUP BY time()时间间隔的指定个数的数据点。对于大多数GROUP BY time()查询，返回的时间戳表示GROUP BY time()时间间隔的开始时间，但是，带有TOP()函数的GROUP BY time()查询则不一样，它们保留原始数据点的时间戳。

示例：以下查询返回每18分钟GROUP BY time()间隔对应的两个数据点。请注意，返回的时间戳是数据点的原始时间戳；它们不会被强制要求必须匹配GROUP BY time()间隔的开始时间。

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

name: h2o_feet
time                   top
----------
                           __
2015-08-18T00:00:00Z2.064|
2015-08-18T00:06:00Z2.116|<-------Greatest points for the first time interval
--
                           __
2015-08-18T00:18:00Z2.126|
2015-08-18T00:30:00Z2.051|<-------Greatest points for the second time interval
--

问题2：TOP()和具有少于N个tag value的tag key

使用语法SELECT TOP(,,)的查询可以返回比预期少的数据点。如果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:00Z7.205  santa_monica
2015-08-29T07:24:00Z9.964  coyote_creek

问题3：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:00Z2

> SHOW TAG KEYS FROM "top_water_levels"

name: top_water_levels
tagKey
------
location

3.3 转换函数

本文档主要介绍了转换函数（Transformations）的语法结构、语法说明以及使用示例。

ABS()

返回field value的绝对值。

基本语法

SELECT ABS([*|])[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。

基本语法示例1：计算指定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
-------
15298416000000000001.33909108671076
15298416600000000000.774984088561186
15298417200000000000.921037167720451
15298417800000000001.73880754843378
15298418400000000000.905980032168252
15298419000000000000.891164752631417

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

基本语法示例2：计算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
--------------
15298416000000000001.339091086710760.163643058925645
15298416600000000000.7749840885611860.137034364053949
15298417200000000000.9210371677204510.482943221384294
15298417800000000001.738807548433780.0729732928756677
15298418400000000000.9059800321682521.77857552719844
15298419000000000000.8911647526314170.741147445214238

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

基本语法示例3：计算指定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
-------
15298417800000000001.73880754843378
15298417200000000000.921037167720451
15298416600000000000.774984088561186
15298416000000000001.33909108671076

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

高级语法

SELECT ABS(([*|]))[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
-------
15298416000000000000.3960977256302787
15298423200000000000.0010541018316373302
15298430400000000000.04494733240283668
15298437600000000000.2553594777104415
15298444800000000000.20382988543108413
15298452000000000000.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
15298423200000000000.0010541018316373302
15298430400000000000.04494733240283668
15298437600000000000.2553594777104415
15298444800000000000.20382988543108413
1529845200000000000-0.790836070736962

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

ACOS()

返回field value的反余弦（以弧度表示）。field value必须在-1和1之间。

基本语法

SELECT ACOS([*|])[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:00Z0.83
2017-05-02T00:00:00Z0.3
2017-05-03T00:00:00Z0.84
2017-05-04T00:00:00Z0.22
2017-05-05T00:00:00Z0.17
2017-05-06T00:00:00Z0.77
2017-05-07T00:00:00Z0.64
2017-05-08T00:00:00Z0.72
2017-05-09T00:00:00Z0.16

示例1：计算指定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:00Z0.591688642426544
2017-05-02T00:00:00Z1.266103672779499
2017-05-03T00:00:00Z0.5735131044230969
2017-05-04T00:00:00Z1.3489818562981022
2017-05-05T00:00:00Z1.399966657665792
2017-05-06T00:00:00Z0.6919551751263169
2017-05-07T00:00:00Z0.8762980611683406
2017-05-08T00:00:00Z0.7669940078618667
2017-05-09T00:00:00Z1.410105673842986

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

示例2：计算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:00Z0.591688642426544
2017-05-02T00:00:00Z1.266103672779499
2017-05-03T00:00:00Z0.5735131044230969
2017-05-04T00:00:00Z1.3489818562981022
2017-05-05T00:00:00Z1.399966657665792
2017-05-06T00:00:00Z0.6919551751263169
2017-05-07T00:00:00Z0.8762980611683406
2017-05-08T00:00:00Z0.7669940078618667
2017-05-09T00:00:00Z1.410105673842986

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

示例3：计算指定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:00Z0.8762980611683406
2017-05-06T00:00:00Z0.6919551751263169
2017-05-05T00:00:00Z1.399966657665792
2017-05-04T00:00:00Z1.3489818562981022

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

高级语法

SELECT ACOS(([*|]))[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:00Z0.9703630732143733
2017-05-03T00:00:00Z1.1483422646081407
2017-05-06T00:00:00Z0.7812981174487247
2017-05-09T00:00:00Z1.410105673842986

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

为了得到这些结果，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:00Z0.565
2017-05-03T00:00:00Z0.41
2017-05-06T00:00:00Z0.71
2017-05-09T00:00:00Z0.16

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

ASIN()

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

基本语法

SELECT ASIN([*|])[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:00Z0.83
2017-05-02T00:00:00Z0.3
2017-05-03T00:00:00Z0.84
2017-05-04T00:00:00Z0.22
2017-05-05T00:00:00Z0.17
2017-05-06T00:00:00Z0.77
2017-05-07T00:00:00Z0.64
2017-05-08T00:00:00Z0.72
2017-05-09T00:00:00Z0.16

示例1：计算指定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:00Z0.9791076843683526
2017-05-02T00:00:00Z0.3046926540153975
2017-05-03T00:00:00Z0.9972832223717997
2017-05-04T00:00:00Z0.22181447049679442
2017-05-05T00:00:00Z0.1708296691291045
2017-05-06T00:00:00Z0.8788411516685797
2017-05-07T00:00:00Z0.6944982656265559
2017-05-08T00:00:00Z0.8038023189330299
2017-05-09T00:00:00Z0.1606906529519106

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

示例2：计算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:00Z0.9791076843683526
2017-05-02T00:00:00Z0.3046926540153975
2017-05-03T00:00:00Z0.9972832223717997
2017-05-04T00:00:00Z0.22181447049679442
2017-05-05T00:00:00Z0.1708296691291045
2017-05-06T00:00:00Z0.8788411516685797
2017-05-07T00:00:00Z0.6944982656265559
2017-05-08T00:00:00Z0.8038023189330299
2017-05-09T00:00:00Z0.1606906529519106

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

示例3：计算指定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:00Z0.6944982656265559
2017-05-06T00:00:00Z0.8788411516685797
2017-05-05T00:00:00Z0.1708296691291045
2017-05-04T00:00:00Z0.22181447049679442

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

高级语法

SELECT ASIN(([*|]))[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:00Z0.6004332535805232
2017-05-03T00:00:00Z0.42245406218675574
2017-05-06T00:00:00Z0.7894982093461719
2017-05-09T00:00:00Z0.1606906529519106

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

为了得到这些结果，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:00Z0.565
2017-05-03T00:00:00Z0.41
2017-05-06T00:00:00Z0.71
2017-05-09T00:00:00Z0.16

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

ATAN()

返回field value的反正切（以弧度表示）。field value必须在-1和1之间。

基本语法

SELECT ATAN([*|])[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:00Z0.83
2017-05-02T00:00:00Z0.3
2017-05-03T00:00:00Z0.84
2017-05-04T00:00:00Z0.22
2017-05-05T00:00:00Z0.17
2017-05-06T00:00:00Z0.77
2017-05-07T00:00:00Z0.64
2017-05-08T00:00:00Z0.72
2017-05-09T00:00:00Z0.16

示例1：计算指定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:00Z0.6927678353971222
2017-05-02T00:00:00Z0.2914567944778671
2017-05-03T00:00:00Z0.6986598247214632
2017-05-04T00:00:00Z0.2165503049760893
2017-05-05T00:00:00Z0.16839015714752992
2017-05-06T00:00:00Z0.6561787179913948
2017-05-07T00:00:00Z0.5693131911006619
2017-05-08T00:00:00Z0.6240230529767568
2017-05-09T00:00:00Z0.1586552621864014

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

示例2：计算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:00Z0.6927678353971222
2017-05-02T00:00:00Z0.2914567944778671
2017-05-03T00:00:00Z0.6986598247214632
2017-05-04T00:00:00Z0.2165503049760893
2017-05-05T00:00:00Z0.16839015714752992
2017-05-06T00:00:00Z0.6561787179913948
2017-05-07T00:00:00Z0.5693131911006619
2017-05-08T00:00:00Z0.6240230529767568
2017-05-09T00:00:00Z0.1586552621864014

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

示例3：计算指定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:00Z0.5693131911006619
2017-05-06T00:00:00Z0.6561787179913948
2017-05-05T00:00:00Z0.16839015714752992
2017-05-04T00:00:00Z0.2165503049760893

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

高级语法

SELECT ATAN(([*|]))[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:00Z0.5142865412694495
2017-05-03T00:00:00Z0.3890972310552784
2017-05-06T00:00:00Z0.6174058917515726
2017-05-09T00:00:00Z0.1586552621864014

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

为了得到这些结果，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:00Z0.565
2017-05-03T00:00:00Z0.41
2017-05-06T00:00:00Z0.71
2017-05-09T00:00:00Z0.16

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

ATAN2()

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

基本语法

SELECT ATAN2([*|| num ],[| 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)
  返回在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:00Z102650094
2018-05-16T12:02:00Z254953576
2018-05-16T12:03:00Z403355208
2018-05-16T12:04:00Z557958579
2018-05-16T12:05:00Z706561213
2018-05-16T12:06:00Z858964807
2018-05-16T12:07:00Z1018067707
2018-05-16T12:08:00Z1177769819
2018-05-16T12:09:00Z1332172452
2018-05-16T12:10:00Z1488575881

示例一：计算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:00Z0.020478631571881498
2018-05-16T12:02:00Z0.04754142349303296
2018-05-16T12:03:00Z0.07292147724575364
2018-05-16T12:04:00Z0.09495251193874832
2018-05-16T12:05:00Z0.11490822875441563
2018-05-16T12:06:00Z0.13176409347584003
2018-05-16T12:07:00Z0.14923587589682233
2018-05-16T12:08:00Z0.1671059946640312
2018-05-16T12:09:00Z0.18182893717409565
2018-05-16T12:10:00Z0.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:00Z0.0204786315718814980.7853981633974483
2018-05-16T12:02:00Z0.047541423493032960.7853981633974483
2018-05-16T12:03:00Z0.072921477245753640.7853981633974483
2018-05-16T12:04:00Z0.094952511938748320.7853981633974483
2018-05-16T12:05:00Z0.114908228754415630.7853981633974483
2018-05-16T12:06:00Z0.131764093475840030.7853981633974483
2018-05-16T12:07:00Z0.149235875896822330.7853981633974483
2018-05-16T12:08:00Z0.16710599466403120.7853981633974483
2018-05-16T12:09:00Z0.181828937174095650.7853981633974483
2018-05-16T12:10:00Z0.193702863149522340.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:00Z0.1671059946640312
2018-05-16T12:07:00Z0.14923587589682233
2018-05-16T12:06:00Z0.13176409347584003
2018-05-16T12:05:00Z0.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(,)[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:00Z0.133815587896842
2018-05-16T12:12:00Z0.2662716308351908
2018-05-16T12:24:00Z0.2958845306108965
2018-05-16T12:36:00Z0.23783439588429497
2018-05-16T12:48:00Z0.1906803720242831
2018-05-16T13:00:00Z0.17291511946158172

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

为了得到这些结果，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:00Z867464433.181818181816
2018-05-16T12:12:00Z26419.83333333333296865.25
2018-05-16T12:24:00Z40337.416666666664132326.41666666666
2018-05-16T12:36:00Z41149.583333333336169743.16666666666
2018-05-16T12:48:00Z41230.416666666664213600.91666666666
2018-05-16T13:00:00Z41184.5235799

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

CEIL()

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

基本语法

SELECT CEIL([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z3
2015-08-18T00:06:00Z3
2015-08-18T00:12:00Z3
2015-08-18T00:18:00Z3
2015-08-18T00:24:00Z3
2015-08-18T00:30:00Z3

该查询返回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:00Z3
2015-08-18T00:06:00Z3
2015-08-18T00:12:00Z3
2015-08-18T00:18:00Z3
2015-08-18T00:24:00Z3
2015-08-18T00:30:00Z3

该查询返回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:00Z3
2015-08-18T00:12:00Z3
2015-08-18T00:06:00Z3
2015-08-18T00:00:00Z3

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

高级语法

SELECT CEIL(([*||//]))[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:00Z3
2015-08-18T00:12:00Z3
2015-08-18T00:24:00Z3

该查询返回每12分钟的时间间隔对应的大于water_level平均值的最小整数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

COS()

返回field value的余弦值。

基本语法

SELECT COS([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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。

COS()

返回field value的余弦值。

基本语法

SELECT COS([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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。

高级语法

SELECT COS(([*|]))[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的平均值的余弦值。

为了得到这些结果，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:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

CUMULATIVE_SUM()

返回field value的累积总和。

基本语法

SELECT CUMULATIVE_SUM([*||//])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z2.064
2015-08-18T00:06:00Z4.18
2015-08-18T00:12:00Z6.208
2015-08-18T00:18:00Z8.334
2015-08-18T00:24:00Z10.375
2015-08-18T00:30:00Z12.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:00Z2.064
2015-08-18T00:06:00Z4.18
2015-08-18T00:12:00Z6.208
2015-08-18T00:18:00Z8.334
2015-08-18T00:24:00Z10.375
2015-08-18T00:30:00Z12.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:00Z2.064
2015-08-18T00:06:00Z4.18
2015-08-18T00:12:00Z6.208
2015-08-18T00:18:00Z8.334
2015-08-18T00:24:00Z10.375
2015-08-18T00:30:00Z12.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:00Z6.218
2015-08-18T00:12:00Z8.246
2015-08-18T00:06:00Z10.362
2015-08-18T00:00:00Z12.426

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

高级语法

SELECT CUMULATIVE_SUM(([*||//]))[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:00Z2.09
2015-08-18T00:12:00Z4.167
2015-08-18T00:24:00Z6.213

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

为了得到这些结果，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:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

DERIVATIVE()

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

基本语法

SELECT DERIVATIVE([*||//][,])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

基本语法描述

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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z0.00014444444444444457
2015-08-18T00:12:00Z-0.00024444444444444465
2015-08-18T00:18:00Z0.0002722222222222218
2015-08-18T00:24:00Z-0.000236111111111111
2015-08-18T00:30:00Z2.777777777777842e-05

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

第一个结果(0.00014444444444444457)是原始数据中前两个field value在一秒内的变化率。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:00Z0.052000000000000046
2015-08-18T00:12:00Z-0.08800000000000008
2015-08-18T00:18:00Z0.09799999999999986
2015-08-18T00:24:00Z-0.08499999999999996
2015-08-18T00:30:00Z0.010000000000000231

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

第一个结果(0.052000000000000046)是原始数据中前两个field value在六分钟内的变化率。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:00Z0.026000000000000023
2015-08-18T00:12:00Z-0.04400000000000004
2015-08-18T00:18:00Z0.04899999999999993
2015-08-18T00:24:00Z-0.04249999999999998
2015-08-18T00:30:00Z0.0050000000000001155

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

第一个结果(0.026000000000000023)是原始数据中前两个field value在三分钟内的变化率。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:00Z0.01733333333333335
2015-08-18T00:12:00Z-0.02933333333333336
2015-08-18T00:18:00Z0.03266666666666662
2015-08-18T00:24:00Z-0.02833333333333332
2015-08-18T00:30:00Z0.0033333333333334103

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

第一个结果(0.01733333333333335)是原始数据中前两个field value在两分钟内的变化率。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在一秒内的变化率。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(([*||//])[,])[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分钟变化率。

为了得到这些结果，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:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

然后，InfluxDB®计算这些平均值的每12分钟的变化率。第一个结果(-0.0129999999999999)是原始数据中前两个field value在12分钟内的变化率。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的平均值的每六分钟变化率。

为了得到这些结果，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:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

然后，InfluxDB®计算这些平均值的每六分钟的变化率。第一个结果(-0.00649999999999995)是原始数据中前两个field value在六分钟内的变化率。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([*||//])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z0.052000000000000046
2015-08-18T00:12:00Z-0.08800000000000008
2015-08-18T00:18:00Z0.09799999999999986
2015-08-18T00:24:00Z-0.08499999999999996
2015-08-18T00:30:00Z0.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:00Z0.052000000000000046
2015-08-18T00:12:00Z-0.08800000000000008
2015-08-18T00:18:00Z0.09799999999999986
2015-08-18T00:24:00Z-0.08499999999999996
2015-08-18T00:30:00Z0.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:00Z0.052000000000000046
2015-08-18T00:12:00Z-0.08800000000000008
2015-08-18T00:18:00Z0.09799999999999986
2015-08-18T00:24:00Z-0.08499999999999996
2015-08-18T00:30:00Z0.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:00Z0.08800000000000008

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

高级语法

SELECT DIFFERENCE(([*||//]))[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:00Z0.009999999999999787
2015-08-18T00:24:00Z-0.07499999999999973

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

为了得到这些结果，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:00Z2.116
2015-08-18T00:12:00Z2.126
2015-08-18T00:24:00Z2.051

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

ELAPSED()

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

语法

SELECT ELAPSED([*||//][,])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

语法描述

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

• ELAPSED(field_key)返回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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.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:00Z360000000000
2015-08-18T00:12:00Z360000000000

该查询返回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:00Z6
2015-08-18T00:12:00Z6

该查询返回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:00Z66
2015-08-18T00:12:00Z66

该查询返回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:00Z360360
2015-08-18T00:12:00Z36036

该查询返回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的值大于时间戳之间的差值，那么InfluxDB®将会返回0。

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

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

name: h2o_feet
time                   elapsed
-----------
2015-08-18T00:06:00Z0
2015-08-18T00:12:00Z0

问题二：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分钟。

为了得到这些结果，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:00Z12
2015-08-18T00:48:00Z12

> 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:00Z2.057<---Actually occurs at 2015-08-18T00:42:00Z
2015-08-18T00:48:00Z1.991

EXP()

返回field value的指数。

基本语法

SELECT EXP([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z7.877416541092307
2015-08-18T00:06:00Z8.297879498060171
2015-08-18T00:12:00Z7.598873404088091
2015-08-18T00:18:00Z8.381274573459967
2015-08-18T00:24:00Z7.6983036546645645
2015-08-18T00:30:00Z7.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:00Z7.877416541092307
2015-08-18T00:06:00Z8.297879498060171
2015-08-18T00:12:00Z7.598873404088091
2015-08-18T00:18:00Z8.381274573459967
2015-08-18T00:24:00Z7.6983036546645645
2015-08-18T00:30:00Z7.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:00Z8.381274573459967
2015-08-18T00:12:00Z7.598873404088091
2015-08-18T00:06:00Z8.297879498060171
2015-08-18T00:00:00Z7.877416541092307

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

高级语法

SELECT EXP(([*|]))[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:00Z8.084915164305059
2015-08-18T00:12:00Z7.980491491670466
2015-08-18T00:24:00Z7.736891562315577

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

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

FLOOR()

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

基本语法

SELECT FLOOR([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:18:00Z2
2015-08-18T00:24:00Z2
2015-08-18T00:30:00Z2

该查询返回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:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:18:00Z2
2015-08-18T00:24:00Z2
2015-08-18T00:30:00Z2

该查询返回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:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:00:00Z2

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

高级语法

SELECT FLOOR(([*|]))[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:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:24:00Z2

该查询返回每12分钟的时间间隔对应的小于water_level平均值的最大整数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

LN()

返回field value的自然对数。

基本语法

SELECT LN([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z0.7246458476193163
2015-08-18T00:06:00Z0.749527513996053
2015-08-18T00:12:00Z0.7070500857289368
2015-08-18T00:18:00Z0.7542422799197561
2015-08-18T00:24:00Z0.7134398838277077
2015-08-18T00:30:00Z0.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:00Z0.7246458476193163
2015-08-18T00:06:00Z0.749527513996053
2015-08-18T00:12:00Z0.7070500857289368
2015-08-18T00:18:00Z0.7542422799197561
2015-08-18T00:24:00Z0.7134398838277077
2015-08-18T00:30:00Z0.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:00Z8.381274573459967
2015-08-18T00:12:00Z7.598873404088091
2015-08-18T00:06:00Z8.297879498060171
2015-08-18T00:00:00Z7.877416541092307

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

高级语法

SELECT LN(([*|]))[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:00Z0.7371640659767196
2015-08-18T00:12:00Z0.7309245448939752
2015-08-18T00:24:00Z0.7158866675294349

该查询返回每12分钟的时间间隔对应的water_level的平均值的自然对数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

LOG()

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

基本语法

SELECT LOG([*|],)[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z0.5227214853805835
2015-08-18T00:06:00Z0.5406698137259695
2015-08-18T00:12:00Z0.5100288261706268
2015-08-18T00:18:00Z0.5440707984345088
2015-08-18T00:24:00Z0.5146380911853161
2015-08-18T00:30:00Z0.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:00Z0.5227214853805835
2015-08-18T00:06:00Z0.5406698137259695
2015-08-18T00:12:00Z0.5100288261706268
2015-08-18T00:18:00Z0.5440707984345088
2015-08-18T00:24:00Z0.5146380911853161
2015-08-18T00:30:00Z0.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:00Z0.5440707984345088
2015-08-18T00:12:00Z0.5100288261706268
2015-08-18T00:06:00Z0.5406698137259695
2015-08-18T00:00:00Z0.5227214853805835

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

高级语法

SELECT LOG(([*|]),)[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:00Z0.531751471153079
2015-08-18T00:12:00Z0.5272506080912802
2015-08-18T00:24:00Z0.5164030725416209

该查询返回每12分钟的时间间隔对应的water_level的平均值的以4为底数的对数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

LOG2()

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

基本语法

SELECT LOG2([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z1.045442970761167
2015-08-18T00:06:00Z1.081339627451939
2015-08-18T00:12:00Z1.0200576523412537
2015-08-18T00:18:00Z1.0881415968690176
2015-08-18T00:24:00Z1.0292761823706322
2015-08-18T00:30:00Z1.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:00Z1.045442970761167
2015-08-18T00:06:00Z1.081339627451939
2015-08-18T00:12:00Z1.0200576523412537
2015-08-18T00:18:00Z1.0881415968690176
2015-08-18T00:24:00Z1.0292761823706322
2015-08-18T00:30:00Z1.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:00Z1.0881415968690176
2015-08-18T00:12:00Z1.0200576523412537
2015-08-18T00:06:00Z1.081339627451939
2015-08-18T00:00:00Z1.045442970761167

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

高级语法

SELECT LOG2(([*|]))[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:00Z1.063502942306158
2015-08-18T00:12:00Z1.0545012161825604
2015-08-18T00:24:00Z1.0328061450832418

该查询返回每12分钟的时间间隔对应的water_level的平均值的以2为底数的对数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

LOG10()

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

基本语法

SELECT LOG10([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z0.3147096929551737
2015-08-18T00:06:00Z0.32551566336314813
2015-08-18T00:12:00Z0.3070679506612984
2015-08-18T00:18:00Z0.32756326018727794
2015-08-18T00:24:00Z0.3098430047160705
2015-08-18T00:30:00Z0.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:00Z0.3147096929551737
2015-08-18T00:06:00Z0.32551566336314813
2015-08-18T00:12:00Z0.3070679506612984
2015-08-18T00:18:00Z0.32756326018727794
2015-08-18T00:24:00Z0.3098430047160705
2015-08-18T00:30:00Z0.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:00Z0.32756326018727794
2015-08-18T00:12:00Z0.3070679506612984
2015-08-18T00:06:00Z0.32551566336314813
2015-08-18T00:00:00Z0.3147096929551737

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

高级语法

SELECT LOG10(([*|]))[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:00Z0.32014628611105395
2015-08-18T00:12:00Z0.3174364965350991
2015-08-18T00:24:00Z0.3109056293761414

该查询返回每12分钟的时间间隔对应的water_level的平均值的以10为底数的对数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

MOVING_AVERAGE()

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

基本语法

SELECT MOVING_AVERAGE([*||//],)[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z2.09
2015-08-18T00:12:00Z2.072
2015-08-18T00:18:00Z2.077
2015-08-18T00:24:00Z2.0835
2015-08-18T00:30:00Z2.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:00Z2.0693333333333332
2015-08-18T00:18:00Z2.09
2015-08-18T00:24:00Z2.065
2015-08-18T00:30:00Z2.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:00Z2.0835
2015-08-18T00:24:00Z2.07775
2015-08-18T00:30:00Z2.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:00Z2.072
2015-08-18T00:00:00Z2.09

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

高级语法

SELECT MOVING_AVERAGE(([*||//]), 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:00Z2.121
2015-08-18T00:24:00Z2.0885

该查询返回每12分钟的时间间隔对应的water_level的最大值的窗口大小为两个值的滚动平均值。

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

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

name: h2o_feet
time                   max
-------
2015-08-18T00:00:00Z2.116
2015-08-18T00:12:00Z2.126
2015-08-18T00:24:00Z2.051

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

NON_NEGATIVE_DERIVATIVE()

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

基本语法

SELECT NON_NEGATIVE_DERIVATIVE([*||//][,])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

基本语法描述

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(([*||//])[,])[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()

高级语法示例

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

NON_NEGATIVE_DIFFERENCE()

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

基本语法

SELECT NON_NEGATIVE_DIFFERENCE([*||//])[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(([*||//]))[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()

高级语法示例

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

POW()

返回field value的x次方。

基本语法

SELECT POW([*|],)[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z18.148417929216
2015-08-18T00:06:00Z20.047612231936
2015-08-18T00:12:00Z16.914992230656004
2015-08-18T00:18:00Z20.429279055375993
2015-08-18T00:24:00Z17.352898193760993
2015-08-18T00:30:00Z17.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:00Z18.148417929216
2015-08-18T00:06:00Z20.047612231936
2015-08-18T00:12:00Z16.914992230656004
2015-08-18T00:18:00Z20.429279055375993
2015-08-18T00:24:00Z17.352898193760993
2015-08-18T00:30:00Z17.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:00Z20.429279055375993
2015-08-18T00:12:00Z16.914992230656004
2015-08-18T00:06:00Z20.047612231936
2015-08-18T00:00:00Z18.148417929216

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

高级语法

SELECT POW(([*|]),)[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:00Z19.08029760999999
2015-08-18T00:12:00Z18.609983417041
2015-08-18T00:24:00Z17.523567165456008

该查询返回每12分钟的时间间隔对应的water_level的平均值的4次方。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

然后，InfluxDB®计算这些平均值的4次方。

ROUND()

返回指定值的四舍五入后的整数。

基本语法

SELECT ROUND([*|])[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:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.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:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:18:00Z2
2015-08-18T00:24:00Z2
2015-08-18T00:30:00Z2

该查询返回measurement h2o_feet中field key water_level对应的field value四舍五入后的整数。

示例二：计算measurement中每个field key对应的field value四舍五入后的整数

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

name: h2o_feet
time                  round_water_level
---------------------
2015-08-18T00:00:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:18:00Z2
2015-08-18T00:24:00Z2
2015-08-18T00:30:00Z2

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

示例三：计算指定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' ORDER BY time DESC LIMIT 4 OFFSET 2

name: h2o_feet
time                  round
---------
2015-08-18T00:18:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:06:00Z2
2015-08-18T00:00:00Z2

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

高级语法

SELECT ROUND(([*|]))[INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

高级语法描述

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

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

COUNT()

MEAN()

MEDIAN()

MODE()

SUM()

FIRST()

LAST()

MIN()

MAX()

PERCENTILE()

高级语法示例：计算平均值四舍五入后的整数

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

name: h2o_feet
time                  round
---------
2015-08-18T00:00:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:24:00Z2

该查询返回每12分钟的时间间隔对应的water_level的平均值四舍五入后的整数。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

然后，InfluxDB®计算这些平均值四舍五入后的整数。

SIN()

返回field value的正弦值。

基本语法

SELECT SIN([*|])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

基本语法描述

SIN(field_key)返回field key对应的field value的正弦值。

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

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

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

基本语法示例

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

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

name: h2o_feet
time                  water_level
---------------
2015-08-18T00:00:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.051

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

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

name: h2o_feet
time                  sin
-------
2015-08-18T00:00:00Z0.8808206017241819
2015-08-18T00:06:00Z0.8550216851706579
2015-08-18T00:12:00Z0.8972904165810275
2015-08-18T00:18:00Z0.8497930984115993
2015-08-18T00:24:00Z0.8914760289023131
2015-08-18T00:30:00Z0.8869008523376968

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

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

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

name: h2o_feet
time                  sin_water_level
-------------------
2015-08-18T00:00:00Z0.8808206017241819
2015-08-18T00:06:00Z0.8550216851706579
2015-08-18T00:12:00Z0.8972904165810275
2015-08-18T00:18:00Z0.8497930984115993
2015-08-18T00:24:00Z0.8914760289023131
2015-08-18T00:30:00Z0.8869008523376968

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

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

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

name: h2o_feet
time                  sin
-------
2015-08-18T00:18:00Z0.8497930984115993
2015-08-18T00:12:00Z0.8972904165810275
2015-08-18T00:06:00Z0.8550216851706579
2015-08-18T00:00:00Z0.8808206017241819

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

高级语法

SELECT SIN(([*|]))[INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

高级语法描述

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

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

COUNT()

MEAN()

MEDIAN()

MODE()

SUM()

FIRST()

LAST()

MIN()

MAX()

PERCENTILE()

高级语法示例：计算平均值的正弦值

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

name: h2o_feet
time                  sin
-------
2015-08-18T00:00:00Z0.8682145834456126
2015-08-18T00:12:00Z0.8745914945253902
2015-08-18T00:24:00Z0.8891995555912935

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

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

SQRT()

返回field value的平方根。

基本语法

SELECT SQRT([*|])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

基本语法描述

SQRT(field_key)返回field key对应的field value的平方根。

SQRT(*)返回在measurement中每个field key对应的field value的平方根。

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

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

基本语法示例

下面的示例将使用”NOAA_water_database”数据集的如下数据：

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

name: h2o_feet
time                  water_level
---------------
2015-08-18T00:00:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.051

示例一：计算指定field key对应的field value的平方根

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

name: h2o_feet
time                  sqrt
--------
2015-08-18T00:00:00Z1.4366627996854378
2015-08-18T00:06:00Z1.4546477236774544
2015-08-18T00:12:00Z1.4240786495134319
2015-08-18T00:18:00Z1.4580809305384939
2015-08-18T00:24:00Z1.4286357128393508
2015-08-18T00:30:00Z1.4321312788986909

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

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

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

name: h2o_feet
time                  sqrt_water_level
--------------------
2015-08-18T00:00:00Z1.4366627996854378
2015-08-18T00:06:00Z1.4546477236774544
2015-08-18T00:12:00Z1.4240786495134319
2015-08-18T00:18:00Z1.4580809305384939
2015-08-18T00:24:00Z1.4286357128393508
2015-08-18T00:30:00Z1.4321312788986909

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

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

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

name: h2o_feet
time                  sqrt
--------
2015-08-18T00:18:00Z1.4580809305384939
2015-08-18T00:12:00Z1.4240786495134319
2015-08-18T00:06:00Z1.4546477236774544
2015-08-18T00:00:00Z1.4366627996854378

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

高级语法

SELECT SQRT(([*|]))[INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

高级语法描述

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

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

COUNT()

MEAN()

MEDIAN()

MODE()

SUM()

FIRST()

LAST()

MIN()

MAX()

PERCENTILE()

高级语法示例：计算平均值的平方根

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

name: h2o_feet
time                  sqrt
--------
2015-08-18T00:00:00Z1.445683229480096
2015-08-18T00:12:00Z1.4411800720243115
2015-08-18T00:24:00Z1.430384563675098

该查询返回每12分钟的时间间隔对应的water_level的平均值的平方根。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

然后，InfluxDB®计算这些平均值的平方根。

TAN()

返回field value的正切值。

基本语法

SELECT TAN([*|])[INTO_clause] FROM_clause [WHERE_clause][GROUP_BY_clause][ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

基本语法描述

TAN(field_key)返回field key对应的field value的正切值。

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

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

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

基本语法示例

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

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

name: h2o_feet
time                  water_level
---------------
2015-08-18T00:00:00Z2.064
2015-08-18T00:06:00Z2.116
2015-08-18T00:12:00Z2.028
2015-08-18T00:18:00Z2.126
2015-08-18T00:24:00Z2.041
2015-08-18T00:30:00Z2.051

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

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

name: h2o_feet
time                  tan
-------
2015-08-18T00:00:00Z-1.8604293534384375
2015-08-18T00:06:00Z-1.6487359603347427
2015-08-18T00:12:00Z-2.0326408012302273
2015-08-18T00:18:00Z-1.6121545688343464
2015-08-18T00:24:00Z-1.9676434782626282
2015-08-18T00:30:00Z-1.9198657720074992

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

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

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

name: h2o_feet
time                  tan_water_level
-------------------
2015-08-18T00:00:00Z-1.8604293534384375
2015-08-18T00:06:00Z-1.6487359603347427
2015-08-18T00:12:00Z-2.0326408012302273
2015-08-18T00:18:00Z-1.6121545688343464
2015-08-18T00:24:00Z-1.9676434782626282
2015-08-18T00:30:00Z-1.9198657720074992

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

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

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

name: h2o_feet
time                  tan
-------
2015-08-18T00:18:00Z-1.6121545688343464
2015-08-18T00:12:00Z-2.0326408012302273
2015-08-18T00:06:00Z-1.6487359603347427
2015-08-18T00:00:00Z-1.8604293534384375

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

高级语法

SELECT TAN(([*|]))[INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause][LIMIT_clause][OFFSET_clause][SLIMIT_clause][SOFFSET_clause]

高级语法描述

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

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

COUNT()

MEAN()

MEDIAN()

MODE()

SUM()

FIRST()

LAST()

MIN()

MAX()

PERCENTILE()

高级语法示例：计算平均值的正弦值

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

name: h2o_feet
time                  tan
-------
2015-08-18T00:00:00Z-1.7497661902817365
2015-08-18T00:12:00Z-1.8038002062256624
2015-08-18T00:24:00Z-1.9435224805850773

该查询返回每12分钟的时间间隔对应的water_level的平均值的正切值。

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

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z2.09
2015-08-18T00:12:00Z2.077
2015-08-18T00:24:00Z2.0460000000000003

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

https://www.alibabacloud.com/help/zh/time-series-database/latest/introduction-to-tsdb-for-influxdb