更新时间:2020-09-11 23:39
InfluxQL函数可以用来聚合(aggregate)、选择(select)、转换(transform)和预测(predict)数据。
内容
SELECT COUNT( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SELECT COUNT(DISTINCT( [ * | <field_key> | /<regular_expression>/ ] )) [...]
COUNT(field_key)
返回field key对应的field value的个数。
COUNT(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的个数。
COUNT(*)
返回在measurement中每个field key对应的field value的个数。
COUNT()
支持所有数据类型的field value。InfluxQL支持将DISTINCT()
函数嵌套在COUNT()
函数里。
> SELECT COUNT("water_level") FROM "h2o_feet"
name: h2o_feet
time count
---- -----
1970-01-01T00:00:00Z 15258
该查询返回measurement h2o_feet
中field key water_level
对应的非空field value的个数。
> SELECT COUNT(*) FROM "h2o_feet"
name: h2o_feet
time count_level description count_water_level
---- ----------------------- -----------------
1970-01-01T00:00:00Z 15258 15258
该查询返回measurement h2o_feet
中每个field key对应的非空field value的个数。measurement h2o_feet
中有两个field key:level description
和water_level
。
> SELECT COUNT(/water/) FROM "h2o_feet"
name: h2o_feet
time count_water_level
---- -----------------
1970-01-01T00:00:00Z 15258
该查询返回measurement h2o_feet
中每个包含单词water
的field key对应的非空field value的个数。
> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(200) LIMIT 7 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time count
---- -----
2015-08-17T23:48:00Z 200
2015-08-18T00:00:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:24:00Z 2
2015-08-18T00:36:00Z 2
2015-08-18T00:48:00Z 2
该查询返回field key water_level
对应的非空field value的个数,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用200
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为7和1。
> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"
name: h2o_feet
time count
---- -----
1970-01-01T00:00:00Z 4
该查询返回measurement h2o_feet
中field key level description
对应的不同field value的个数。
大多数InfluxQL函数对于没有数据的时间间隔返回null
值,如果不想返回null
,可以使用fill()
函数,fill(<fill_option>)
将null
值替换成fill_option
。对于没有数据的时间间隔,COUNT()
返回0
,而fill(<fill_option>)
可以将0
替换成fill_option
。
示例
下面代码块中的第一个查询没有使用fill()
,最后一个时间间隔中没有数据,因此该时间间隔返回的值是0
。第二个查询使用了fill(800000)
,它将最后一个时间间隔的返回值0
替换成800000
。
> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m)
name: h2o_feet
time count
---- -----
2015-09-18T21:24:00Z 2
2015-09-18T21:36:00Z 2
2015-09-18T21:48:00Z 0
> SELECT COUNT("water_level") FROM "h2o_feet" WHERE time >= '2015-09-18T21:24:00Z' AND time <= '2015-09-18T21:54:00Z' GROUP BY time(12m) fill(800000)
name: h2o_feet
time count
---- -----
2015-09-18T21:24:00Z 2
2015-09-18T21:36:00Z 2
2015-09-18T21:48:00Z 800000
SELECT DISTINCT( [ * | <field_key> | /<regular_expression>/ ] ) FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SELECT COUNT(DISTINCT( [ * | <field_key> | /<regular_expression>/ ] )) [...]
DISTINCT(field_key)
返回field key对应的不同的field value。
DISTINCT(/regular_expression/)
返回与正则表达式匹配的每个field key对应的不同的field value。
DISTINCT(*)
返回在measurement中每个field key对应的不同的field value。
DISTINCT()
支持所有数据类型的field value。InfluxQL支持将DISTINCT()
函数嵌套在COUNT()
函数里。
> 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。
> 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
。
> 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。
> 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。
> SELECT COUNT(DISTINCT("level description")) FROM "h2o_feet"
name: h2o_feet
time count
---- -----
1970-01-01T00:00:00Z 4
该查询返回measurement h2o_feet
中field key level description
对应的不同field value的个数。
在INTO
子句中使用DISTINCT()
可能会导致TSDB For InfluxDB®覆盖目标measurement中的数据点。DISTINCT()
通常返回多个具有相同时间戳的结果;TSDB For InfluxDB®假设在相同序列中并具有相同时间戳的数据点是重复数据点,并简单地用目标measurement中最新的数据点覆盖重复数据点。
示例
下面代码块中的第一个查询使用了DISTINCT()
,并返回四个结果。请注意,每个结果都有相同的时间戳。第二个查询将INTO
子句添加到查询中,并将查询结果写入measurement distincts
。最后一个查询选择measurement distincts
中所有数据。
因为原来的四个结果是重复的(它们在相同的序列,有相同的时间戳),所以最后一个查询只返回一个数据点。当系统遇到重复数据点时,它会用最近的数据点覆盖之前的数据点。
> SELECT DISTINCT("level description") FROM "h2o_feet"
name: h2o_feet
time distinct
---- --------
1970-01-01T00:00:00Z below 3 feet
1970-01-01T00:00:00Z between 6 and 9 feet
1970-01-01T00:00:00Z between 3 and 6 feet
1970-01-01T00:00:00Z at or greater than 9 feet
> SELECT DISTINCT("level description") INTO "distincts" FROM "h2o_feet"
name: result
time written
---- -------
1970-01-01T00:00:00Z 4
> SELECT * FROM "distincts"
name: distincts
time distinct
---- --------
1970-01-01T00:00:00Z at or greater than 9 feet
SELECT INTEGRAL( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TSDB For InfluxDB®计算field value曲线下的面积,并将这些结果转换为每个unit
的总面积。参数unit
的值是一个整数,后跟一个时间单位。这个参数是可选的,不是必须要有的。如果查询没有指定unit
的值,那么unit
默认为一秒(1s
)。
INTEGRAL(field_key)
返回field key对应的field value曲线下的面积。
INTEGRAL(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value曲线下的面积。
INTEGRAL(*)
返回在measurement中每个field key对应的field value曲线下的面积。
INTEGRAL()
不支持fill()
。INTEGRAL()
支持数据类型为int64和float64的field value。
示例一~示例五使用了数据库NOAA_water_database
中的一部分示例数据:
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT INTEGRAL("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time integral
---- --------
1970-01-01T00:00:00Z 3732.66
该查询返回measurement h2o_feet
中field key water_level
对应的field value曲线下的面积(以秒为单位)。
unit
> SELECT INTEGRAL("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time integral
---- --------
1970-01-01T00:00:00Z 62.211
该查询返回measurement h2o_feet
中field key water_level
对应的field value曲线下的面积(以分钟为单位)。
unit
> SELECT INTEGRAL(*,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time integral_water_level
---- --------------------
1970-01-01T00:00:00Z 62.211
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value曲线下的面积(以分钟为单位)。measurement h2o_feet
中只有一个数值类型的field:water_level
。
unit
> SELECT INTEGRAL(/water/,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time integral_water_level
---- --------------------
1970-01-01T00:00:00Z 62.211
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value曲线下的面积(以分钟为单位)。
> SELECT INTEGRAL("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m) LIMIT 1
name: h2o_feet
time integral
---- --------
2015-08-18T00:00:00Z 24.972
该查询返回measurement h2o_feet
中field key water_level
对应的field value曲线下的面积(以分钟为单位),它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并将查询结果按12分钟的时间间隔进行分组,同时,该查询将返回的数据点个数限制为1。
SELECT MEAN( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MEAN(field_key)
返回field key对应的field value的平均值。
MEAN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的平均值。
MEAN(*)
返回在measurement中每个field key对应的field value的平均值。
MEAN()
支持数据类型为int64和float64的field value。
> SELECT MEAN("water_level") FROM "h2o_feet"
name: h2o_feet
time mean
---- ----
1970-01-01T00:00:00Z 4.442107025822522
该查询返回measurement h2o_feet
中field key water_level
对应的field value的平均值。
> SELECT MEAN(*) FROM "h2o_feet"
name: h2o_feet
time mean_water_level
---- ----------------
1970-01-01T00:00:00Z 4.442107025822522
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的平均值。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT MEAN(/water/) FROM "h2o_feet"
name: h2o_feet
time mean_water_level
---- ----------------
1970-01-01T00:00:00Z 4.442107025822523
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的平均值。
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 7 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time mean
---- ----
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.0625
2015-08-18T00:12:00Z 7.8245
2015-08-18T00:24:00Z 7.5675
2015-08-18T00:36:00Z 7.303
2015-08-18T00:48:00Z 7.046
该查询返回measurement h2o_feet
中field key water_level
对应的field value的平均值,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:30:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用9.01
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为7和1。
SELECT MEDIAN( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MEDIAN(field_key)
返回field key对应的field value的中位数。
MEDIAN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的中位数。
MEDIAN(*)
返回在measurement中每个field key对应的field value的中位数。
MEDIAN()
支持数据类型为int64和float64的field value。
注释:
MEDIAN()
近似于PERCENTILE(field_key, 50)
,除非field key包含的field value有偶数个,那么这时候MEDIAN()
将返回两个中间值的平均数。
> SELECT MEDIAN("water_level") FROM "h2o_feet"
name: h2o_feet
time median
---- ------
1970-01-01T00:00:00Z 4.124
该查询返回measurement h2o_feet
中field key water_level
对应的field value的中位数。
> SELECT MEDIAN(*) FROM "h2o_feet"
name: h2o_feet
time median_water_level
---- ------------------
1970-01-01T00:00:00Z 4.124
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的中位数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT MEDIAN(/water/) FROM "h2o_feet"
name: h2o_feet
time median_water_level
---- ------------------
1970-01-01T00:00:00Z 4.124
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的中位数。
> SELECT MEDIAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(700) LIMIT 7 SLIMIT 1 SOFFSET 1
name: h2o_feet
tags: location=santa_monica
time median
---- ------
2015-08-17T23:48:00Z 700
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
2015-08-18T00:36:00Z 2.0620000000000003
2015-08-18T00:48:00Z 700
该查询返回measurement h2o_feet
中field key water_level
对应的field value的中位数,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用700
填充没有数据的时间间隔,将返回的数据点个数和序列个数分别限制为7和1,并将返回的序列偏移一个(即第一个序列的数据不返回)。
SELECT MODE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MODE(field_key)
返回field key对应的field value中出现频率最高的值。
MODE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value中出现频率最高的值。
MODE(*)
返回在measurement中每个field key对应的field value中出现频率最高的值。
MODE()
支持所有数据类型的field value。
注释:如果出现频率最高的值有两个或多个并且它们之间有关联,那么
MODE()
返回具有最早时间戳的field value。
> 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中出现频率最高的值。
> 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
。
> SELECT MODE(/water/) FROM "h2o_feet"
name: h2o_feet
time mode_water_level
---- ----------------
1970-01-01T00:00:00Z 2.69
该查询返回measurement h2o_feet
中每个包含单词water
的field key对应的field value中出现频率最高的值。
> 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,并将返回的序列偏移一个(即第一个序列的数据不返回)。
SELECT SPREAD( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SPREAD(field_key)
返回field key对应的field value中最大值和最小值之差。
SPREAD(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value中最大值和最小值之差。
SPREAD(*)
返回在measurement中每个field key对应的field value中最大值和最小值之差。
SPREAD()
支持数据类型为int64和float64的field value。
> SELECT SPREAD("water_level") FROM "h2o_feet"
name: h2o_feet
time spread
---- ------
1970-01-01T00:00:00Z 10.574
该查询返回measurement h2o_feet
中field key water_level
对应的field value中最大值和最小值之差。
> SELECT SPREAD(*) FROM "h2o_feet"
name: h2o_feet
time spread_water_level
---- ------------------
1970-01-01T00:00:00Z 10.574
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value中最大值和最小值之差。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT SPREAD(/water/) FROM "h2o_feet"
name: h2o_feet
time spread_water_level
---- ------------------
1970-01-01T00:00:00Z 10.574
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value中最大值和最小值之差。
> SELECT SPREAD("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18) LIMIT 3 SLIMIT 1 SOFFSET 1
name: h2o_feet
tags: location=santa_monica
time spread
---- ------
2015-08-17T23:48:00Z 18
2015-08-18T00:00:00Z 0.052000000000000046
2015-08-18T00:12:00Z 0.09799999999999986
该查询返回measurement h2o_feet
中field key water_level
对应的field value中最大值和最小值之差,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用18
填充没有数据的时间间隔,将返回的数据点个数和序列个数分别限制为3和1,并将返回的序列偏移一个(即第一个序列的数据不返回)。
SELECT STDDEV( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
STDDEV(field_key)
返回field key对应的field value的标准差。
STDDEV(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的标准差。
STDDEV(*)
返回在measurement中每个field key对应的field value的标准差。
STDDEV()
支持数据类型为int64和float64的field value。
> SELECT STDDEV("water_level") FROM "h2o_feet"
name: h2o_feet
time stddev
---- ------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回measurement h2o_feet
中field key water_level
对应的field value的标准差。
> SELECT STDDEV(*) FROM "h2o_feet"
name: h2o_feet
time stddev_water_level
---- ------------------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的标准差。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT STDDEV(/water/) FROM "h2o_feet"
name: h2o_feet
time stddev_water_level
---- ------------------
1970-01-01T00:00:00Z 2.279144584196141
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的标准差。
> SELECT STDDEV("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18000) LIMIT 2 SLIMIT 1 SOFFSET 1
name: h2o_feet
tags: location=santa_monica
time stddev
---- ------
2015-08-17T23:48:00Z 18000
2015-08-18T00:00:00Z 0.03676955262170051
该查询返回measurement h2o_feet
中field key water_level
对应的field value的标准差,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用18000
填充没有数据的时间间隔,将返回的数据点个数和序列个数分别限制为2和1,并将返回的序列偏移一个(即第一个序列的数据不返回)。
SELECT SUM( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SUM(field_key)
返回field key对应的field value的总和。
SUM(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的总和。
SUM(*)
返回在measurement中每个field key对应的field value的总和。
SUM()
支持数据类型为int64和float64的field value。
> SELECT SUM("water_level") FROM "h2o_feet"
name: h2o_feet
time sum
---- ---
1970-01-01T00:00:00Z 67777.66900000004
该查询返回measurement h2o_feet
中field key water_level
对应的field value的总和。
> SELECT SUM(*) FROM "h2o_feet"
name: h2o_feet
time sum_water_level
---- ---------------
1970-01-01T00:00:00Z 67777.66900000004
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的总和。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT SUM(/water/) FROM "h2o_feet"
name: h2o_feet
time sum_water_level
---- ---------------
1970-01-01T00:00:00Z 67777.66900000004
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的总和。
> SELECT SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(18000) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time sum
---- ---
2015-08-17T23:48:00Z 18000
2015-08-18T00:00:00Z 16.125
2015-08-18T00:12:00Z 15.649
2015-08-18T00:24:00Z 15.135
该查询返回measurement h2o_feet
中field key water_level
对应的field value的总和,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用18000
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为4和1。
SELECT BOTTOM(<field_key>[,<tag_key(s)>],<N> )[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
BOTTOM(field_key,N)
返回field key对应的最小的N个值。
BOTTOM(field_key,tag_key(s),N)
返回tag key的N个tag value对应的field key的最小值。
BOTTOM(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的最小的N个值,以及相关的tag和/或field。
BOTTOM()
支持数据类型为int64和float64的field value。
注释:
- 如果最小值有两个或多个相等的值,
BOTTOM()
返回具有最早时间戳的field value。- 当
BOTTOM()
函数与INTO
子句一起使用时,BOTTOM()
与其它InfluxQL函数不同。请查看BOTTOM()
的常见问题章节获得更多信息。
> 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
对应的最小的三个值。
> 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
的最小值。
> 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
的值。
> SELECT BOTTOM("water_level",3),"location" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) ORDER BY time DESC
name: h2o_feet
time bottom location
---- ------ --------
2015-08-18T00:48:00Z 1.991 santa_monica
2015-08-18T00:54:00Z 2.054 santa_monica
2015-08-18T00:54:00Z 6.982 coyote_creek
2015-08-18T00:24:00Z 2.041 santa_monica
2015-08-18T00:30:00Z 2.051 santa_monica
2015-08-18T00:42:00Z 2.057 santa_monica
2015-08-18T00:00:00Z 2.064 santa_monica
2015-08-18T00:06:00Z 2.116 santa_monica
2015-08-18T00:12:00Z 2.028 santa_monica
该查询返回在2015-08-18T00:00:00Z
和2015-08-18T00:54:00Z
之间的每个24分钟间隔内,field key water_level
对应的最小的三个值,并且以递减的时间戳顺序返回结果。
请注意,GROUP BY time()
子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。
BOTTOM()
的常见问题BOTTOM()
和GROUP BY time()
子句同时使用对于同时带有BOTTOM()
和GROUP BY time()
子句的查询,将返回每个GROUP BY time()
时间间隔的指定个数的数据点。对于大多数GROUP BY time()
查询,返回的时间戳表示GROUP BY time()
时间间隔的开始时间,但是,带有BOTTOM()
函数的GROUP BY time()
查询则不一样,它们保留原始数据点的时间戳。
示例
以下查询返回每18分钟GROUP BY time()
间隔对应的两个数据点。请注意,返回的时间戳是数据点的原始时间戳;它们不会被强制要求必须匹配GROUP BY time()
间隔的开始时间。
> SELECT BOTTOM("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)
name: h2o_feet
time bottom
---- ------
__
2015-08-18T00:00:00Z 2.064 |
2015-08-18T00:12:00Z 2.028 | <------- Smallest points for the first time interval
--
__
2015-08-18T00:24:00Z 2.041 |
2015-08-18T00:30:00Z 2.051 | <------- Smallest points for the second time interval
--
BOTTOM()
和具有少于N个tag value的tag key使用语法SELECT BOTTOM(<field_key>,<tag_key>,<N>)
的查询可以返回比预期少的数据点。如果tag key有X
个tag value,但是查询指定的是N
个tag value,如果X
小于N
,那么查询将返回X
个数据点。
示例
以下查询请求的是tag key location
的三个tag value对于的water_level
的最小值。因为tag key location
只有两个tag value(santa_monica
和coyote_creek
),所以该查询返回两个数据点而不是三个。
> SELECT BOTTOM("water_level","location",3) FROM "h2o_feet"
name: h2o_feet
time bottom location
---- ------ --------
2015-08-29T10:36:00Z -0.243 santa_monica
2015-08-29T14:30:00Z -0.61 coyote_creek
BOTTOM()
、tag和INTO
子句当使用INTO
子句但没有使用GROUP BY tag
子句时,大多数InfluxQL函数将原始数据中的tag转换为新写入数据中的field。这种行为同样适用于BOTTOM()
函数除非BOTTOM()
中包含tag key作为参数:BOTTOM(field_key,tag_key(s),N)
。在这些情况下,系统会将指定的tag保留为新写入数据中的tag。
示例
下面代码块中的第一个查询返回tag key location
的两个tag value对应的field key water_level
的最小值,并且,它这些结果写入measurement bottom_water_levels
中。第二个查询展示了TSDB For InfluxDB®将tag location
保留为measurement bottom_water_levels
中的tag。
> SELECT BOTTOM("water_level","location",2) INTO "bottom_water_levels" FROM "h2o_feet"
name: result
time written
---- -------
1970-01-01T00:00:00Z 2
> SHOW TAG KEYS FROM "bottom_water_levels"
name: bottom_water_levels
tagKey
------
location
SELECT FIRST(<field_key>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
FIRST(field_key)
返回field key对应的具有最早时间戳的field value。
FIRST(/regular_expression/)
返回与正则表达式匹配的每个field key对应的具有最早时间戳的field value。
FIRST(*)
返回在measurement中每个field key对应的具有最早时间戳的field value。
FIRST(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的具有最早时间戳的field value,以及相关的tag和/或field。
FIRST()
支持所有数据类型的field value。
> 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。
> 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
。
> 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。
> 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
的值。
> SELECT FIRST("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time first
---- -----
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.12
2015-08-18T00:12:00Z 7.887
2015-08-18T00:24:00Z 7.635
该查询返回measurement h2o_feet
中field key water_level
对应的具有最早时间戳的field value,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用9.01
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为4和1。
请注意,GROUP BY time()
子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间,其中,第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z
和2015-08-18T00:00:00Z
之间,最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z
和2015-08-18T00:36:00Z
之间。
SELECT LAST(<field_key>)[,<tag_key(s)>|<field_keys(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
LAST(field_key)
返回field key对应的具有最新时间戳的field value。
LAST(/regular_expression/)
返回与正则表达式匹配的每个field key对应的具有最新时间戳的field value。
LAST(*)
返回在measurement中每个field key对应的具有最新时间戳的field value。
LAST(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的具有最新时间戳的field value,以及相关的tag和/或field。
LAST()
支持所有数据类型的field value。
> 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。
> 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
。
> 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。
> 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
的值。
> SELECT LAST("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time last
---- ----
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.005
2015-08-18T00:12:00Z 7.762
2015-08-18T00:24:00Z 7.5
该查询返回measurement h2o_feet
中field key water_level
对应的具有最新时间戳的field value,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用9.01
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为4和1。
请注意,GROUP BY time()
子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间,其中,第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z
和2015-08-18T00:00:00Z
之间,最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z
和2015-08-18T00:36:00Z
之间。
SELECT MAX(<field_key>)[,<tag_key(s)>|<field__key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MAX(field_key)
返回field key对应的field value的最大值。
MAX(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的最大值。
MAX(*)
返回在measurement中每个field key对应的field value的最大值。
MAX(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的field value的最大值,以及相关的tag和/或field。
MAX()
支持数据类型为int64和float64的field value。
> SELECT MAX("water_level") FROM "h2o_feet"
name: h2o_feet
time max
---- ---
2015-08-29T07:24:00Z 9.964
该查询返回measurement h2o_feet
中field key water_level
对应的field value的最大值。
> SELECT MAX(*) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的最大值。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT MAX(/water/) FROM "h2o_feet"
name: h2o_feet
time max_water_level
---- ---------------
2015-08-29T07:24:00Z 9.964
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的最大值。
> SELECT MAX("water_level"),"location","level description" FROM "h2o_feet"
name: h2o_feet
time max location level description
---- --- -------- -----------------
2015-08-29T07:24:00Z 9.964 coyote_creek at or greater than 9 feet
该查询返回measurement h2o_feet
中field key water_level
对应的field value的最大值,以及相关的tag key location
和field key level description
的值。
> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time max
---- ---
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.12
2015-08-18T00:12:00Z 7.887
2015-08-18T00:24:00Z 7.635
该查询返回measurement h2o_feet
中field key water_level
对应的field value的最大值,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用9.01
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为4和1。
请注意,GROUP BY time()
子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间,其中,第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z
和2015-08-18T00:00:00Z
之间,最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z
和2015-08-18T00:36:00Z
之间。
SELECT MIN(<field_key>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MIN(field_key)
返回field key对应的field value的最小值。
MIN(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的最小值。
MIN(*)
返回在measurement中每个field key对应的field value的最小值。
MIN(field_key),tag_key(s),field_key(s)
返回括号中的field key对应的field value的最小值,以及相关的tag和/或field。
MIN()
支持数据类型为int64和float64的field value。
> 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的最小值。
> 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
。
> 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的最小值。
> 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
的值。
> SELECT MIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m),* fill(9.01) LIMIT 4 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time min
---- ---
2015-08-17T23:48:00Z 9.01
2015-08-18T00:00:00Z 8.005
2015-08-18T00:12:00Z 7.762
2015-08-18T00:24:00Z 7.5
该查询返回measurement h2o_feet
中field key water_level
对应的field value的最小值,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按12分钟的时间间隔和每个tag进行分组,同时,该查询用9.01
填充没有数据的时间间隔,并将返回的数据点个数和序列个数分别限制为4和1。
请注意,GROUP BY time()
子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每12分钟时间间隔的开始时间,其中,第一个数据点涵盖的时间间隔在2015-08-17T23:48:00Z
和2015-08-18T00:00:00Z
之间,最后一个数据点涵盖的时间间隔在2015-08-18T00:24:00Z
和2015-08-18T00:36:00Z
之间。
SELECT PERCENTILE(<field_key>, <N>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
PERCENTILE(field_key,N)
返回指定field key对应的第N个百分位数的field value。
PERCENTILE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的第N个百分位数的field value。
PERCENTILE(*,N)
返回在measurement中每个field key对应的第N个百分位数的field value。
PERCENTILE(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的第N个百分位数的field value,以及相关的tag和/或field。
N
必须是0到100之间的整数或浮点数。PERCENTILE()
支持数据类型为int64和float64的field value。
> SELECT PERCENTILE("water_level",5) FROM "h2o_feet"
name: h2o_feet
time percentile
---- ----------
2015-08-31T03:42:00Z 1.122
该查询返回的field value大于measurement h2o_feet
中field key water_level
对应的所有field value中的百分之五。
> SELECT PERCENTILE(*,5) FROM "h2o_feet"
name: h2o_feet
time percentile_water_level
---- ----------------------
2015-08-31T03:42:00Z 1.122
该查询返回的field value大于measurement h2o_feet
中每个存储数值的field key对应的所有field value中的百分之五。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT PERCENTILE(/water/,5) FROM "h2o_feet"
name: h2o_feet
time percentile_water_level
---- ----------------------
2015-08-31T03:42:00Z 1.122
该查询返回的field value大于measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的所有field value中的百分之五。
> SELECT PERCENTILE("water_level",5),"location","level description" FROM "h2o_feet"
name: h2o_feet
time percentile location level description
---- ---------- -------- -----------------
2015-08-31T03:42:00Z 1.122 coyote_creek below 3 feet
该查询返回的field value大于measurement h2o_feet
中field key water_level
对应的所有field value中的百分之五,以及相关的tag key location
和field key level description
的值。
> SELECT PERCENTILE("water_level",20) FROM "h2o_feet" WHERE time >= '2015-08-17T23:48:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) fill(15) LIMIT 2
name: h2o_feet
time percentile
---- ----------
2015-08-17T23:36:00Z 15
2015-08-18T00:00:00Z 2.064
该查询返回的field value大于measurement h2o_feet
中field key water_level
对应的所有field value中的百分之二十,它涵盖的时间范围在2015-08-17T23:48:00Z
和2015-08-18T00:54:00Z
之间,并将查询结果按24分钟的时间间隔进行分组,同时,该查询用15
填充没有数据的时间间隔,并将返回的数据点个数限制为2。
请注意,GROUP BY time()
子句会覆盖数据点的原始时间戳。查询结果中的时间戳表示每24分钟时间间隔的开始时间,其中,第一个数据点涵盖的时间间隔在2015-08-17T23:36:00Z
和2015-08-18T00:00:00Z
之间,最后一个数据点涵盖的时间间隔在2015-08-18T00:00:00Z
和2015-08-18T00:24:00Z
之间。
PERCENTILE()
的常见问题PERCENTILE()
vs 其它InfluxQL函数PERCENTILE(<field_key>,100)
相当于MAX(<field_key>)
。PERCENTILE(<field_key>, 50)
近似于MEDIAN(<field_key>)
,除非field key包含的field value有偶数个,那么这时候MEDIAN()
将返回两个中间值的平均数。PERCENTILE(<field_key>,0)
不等于MIN(<field_key>)
,PERCENTILE(<field_key>,0)
会返回null
。SAMPLE()
使用reservoir sampling来生成随机数据点。
SELECT SAMPLE(<field_key>, <N>)[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SAMPLE(field_key,N)
返回指定field key对应的N个随机选择的field value。
SAMPLE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的N个随机选择的field value。
SAMPLE(*,N)
返回在measurement中每个field key对应的N个随机选择的field value。
SAMPLE(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的N个随机选择的field value,以及相关的tag和/或field。
N
必须是整数。SAMPLE()
支持所有数据类型的field value。
> SELECT SAMPLE("water_level",2) FROM "h2o_feet"
name: h2o_feet
time sample
---- ------
2015-09-09T21:48:00Z 5.659
2015-09-18T10:00:00Z 6.939
该查询返回measurement h2o_feet
中field key water_level
对应的两个随机选择的数据点。
> SELECT SAMPLE(*,2) FROM "h2o_feet"
name: h2o_feet
time sample_level description sample_water_level
---- ------------------------ ------------------
2015-08-25T17:06:00Z 3.284
2015-09-03T04:30:00Z below 3 feet
2015-09-03T20:06:00Z between 3 and 6 feet
2015-09-08T21:54:00Z 3.412
该查询返回measurement h2o_feet
中每个field key对应的两个随机选择的数据点。measurement h2o_feet
中有两个field key:level description
和water_level
。
> SELECT SAMPLE(/level/,2) FROM "h2o_feet"
name: h2o_feet
time sample_level description sample_water_level
---- ------------------------ ------------------
2015-08-30T05:54:00Z between 6 and 9 feet
2015-09-07T01:18:00Z 7.854
2015-09-09T20:30:00Z 7.32
2015-09-13T19:18:00Z between 3 and 6 feet
该查询返回measurement h2o_feet
中每个包含单词level
的field key对应的两个随机选择的数据点。
> SELECT SAMPLE("water_level",2),"location","level description" FROM "h2o_feet"
name: h2o_feet
time sample location level description
---- ------ -------- -----------------
2015-08-29T10:54:00Z 5.689 coyote_creek between 3 and 6 feet
2015-09-08T15:48:00Z 6.391 coyote_creek between 6 and 9 feet
该查询返回measurement h2o_feet
中field key water_level
对应的两个随机选择的数据点,以及相关的tag key location
和field key level description
的值。
> SELECT SAMPLE("water_level",1) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)
name: h2o_feet
time sample
---- ------
2015-08-18T00:12:00Z 2.028
2015-08-18T00:30:00Z 2.051
该查询返回measurement h2o_feet
中field key water_level
对应的一个随机选择的数据点,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并将查询结果按18分钟的时间间隔进行分组。
请注意,GROUP BY time()
子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。
SAMPLE()
的常见问题SAMPLE()
和GROUP BY time()
子句同时使用对于同时带有SAMPLE()
和GROUP BY time()
子句的查询,将返回每个GROUP BY time()
时间间隔的指定个数(N
)的数据点。对于大多数GROUP BY time()
查询,返回的时间戳表示GROUP BY time()
时间间隔的开始时间,但是,带有SAMPLE()
函数的GROUP BY time()
查询则不一样,它们保留原始数据点的时间戳。
示例
以下查询返回每18分钟GROUP BY time()
间隔对应的两个随机选择的数据点。请注意,返回的时间戳是数据点的原始时间戳;它们不会被强制要求必须匹配GROUP BY time()
间隔的开始时间。
> SELECT SAMPLE("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)
name: h2o_feet
time sample
---- ------
__
2015-08-18T00:06:00Z 2.116 |
2015-08-18T00:12:00Z 2.028 | <------- Randomly-selected points for the first time interval
--
__
2015-08-18T00:18:00Z 2.126 |
2015-08-18T00:30:00Z 2.051 | <------- Randomly-selected points for the second time interval
--
SELECT TOP( <field_key>[,<tag_key(s)>],<N> )[,<tag_key(s)>|<field_key(s)>] [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TOP(field_key,N)
返回field key对应的最大的N个值。
TOP(field_key,tag_key(s),N)
返回tag key的N个tag value对应的field key的最大值。
TOP(field_key,N),tag_key(s),field_key(s)
返回括号中的field key对应的最大的N个值,以及相关的tag和/或field。
TOP()
支持数据类型为int64和float64的field value。
注释:
- 如果最大值有两个或多个并且它们之间有关联,
TOP()
返回具有最早时间戳的field value。- 当
TOP()
函数与INTO
子句一起使用时,TOP()
与其它InfluxQL函数不同。请查看TOP()的常见问题章节获得更多信息。
> SELECT TOP("water_level",3) FROM "h2o_feet"
name: h2o_feet
time top
---- ---
2015-08-29T07:18:00Z 9.957
2015-08-29T07:24:00Z 9.964
2015-08-29T07:30:00Z 9.954
该查询返回measurement h2o_feet
中field key water_level
对应的最大的三个值。
> SELECT TOP("water_level","location",2) FROM "h2o_feet"
name: h2o_feet
time top location
---- --- --------
2015-08-29T03:54:00Z 7.205 santa_monica
2015-08-29T07:24:00Z 9.964 coyote_creek
该查询返回tag key location
的两个tag value对应的field key water_level
的最大值。
> SELECT TOP("water_level",4),"location","level description" FROM "h2o_feet"
name: h2o_feet
time top location level description
---- --- -------- -----------------
2015-08-29T07:18:00Z 9.957 coyote_creek at or greater than 9 feet
2015-08-29T07:24:00Z 9.964 coyote_creek at or greater than 9 feet
2015-08-29T07:30:00Z 9.954 coyote_creek at or greater than 9 feet
2015-08-29T07:36:00Z 9.941 coyote_creek at or greater than 9 feet
该查询返回field key water_level
对应的最大的四个值,以及相关的tag key location
和field key level description
的值。
> SELECT TOP("water_level",3),"location" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(24m) ORDER BY time DESC
name: h2o_feet
time top location
---- --- --------
2015-08-18T00:48:00Z 7.11 coyote_creek
2015-08-18T00:54:00Z 6.982 coyote_creek
2015-08-18T00:54:00Z 2.054 santa_monica
2015-08-18T00:24:00Z 7.635 coyote_creek
2015-08-18T00:30:00Z 7.5 coyote_creek
2015-08-18T00:36:00Z 7.372 coyote_creek
2015-08-18T00:00:00Z 8.12 coyote_creek
2015-08-18T00:06:00Z 8.005 coyote_creek
2015-08-18T00:12:00Z 7.887 coyote_creek
该查询返回在2015-08-18T00:00:00Z
和2015-08-18T00:54:00Z
之间的每个24分钟间隔内,field key water_level
对应的最大的三个值,并且以递减的时间戳顺序返回结果。
请注意,GROUP BY time()
子句不会覆盖数据点的原始时间戳。请查看下面章节获得更详细的说明。
TOP()
的常见问题TOP()
和GROUP BY time()
子句同时使用对于同时带有TOP()
和GROUP BY time()
子句的查询,将返回每个GROUP BY time()
时间间隔的指定个数的数据点。对于大多数GROUP BY time()
查询,返回的时间戳表示GROUP BY time()
时间间隔的开始时间,但是,带有TOP()
函数的GROUP BY time()
查询则不一样,它们保留原始数据点的时间戳。
示例
以下查询返回每18分钟GROUP BY time()
间隔对应的两个数据点。请注意,返回的时间戳是数据点的原始时间戳;它们不会被强制要求必须匹配GROUP BY time()
间隔的开始时间。
> SELECT TOP("water_level",2) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(18m)
name: h2o_feet
time top
---- ------
__
2015-08-18T00:00:00Z 2.064 |
2015-08-18T00:06:00Z 2.116 | <------- Greatest points for the first time interval
--
__
2015-08-18T00:18:00Z 2.126 |
2015-08-18T00:30:00Z 2.051 | <------- Greatest points for the second time interval
--
TOP()
和具有少于N个tag value的tag key使用语法SELECT TOP(<field_key>,<tag_key>,<N>)
的查询可以返回比预期少的数据点。如果tag key有X
个tag value,但是查询指定的是N
个tag value,如果X
小于N
,那么查询将返回X
个数据点。
示例
以下查询请求的是tag key location
的三个tag value对于的water_level
的最大值。因为tag key location
只有两个tag value(santa_monica
和coyote_creek
),所以该查询返回两个数据点而不是三个。
> SELECT TOP("water_level","location",3) FROM "h2o_feet"
name: h2o_feet
time top location
---- --- --------
2015-08-29T03:54:00Z 7.205 santa_monica
2015-08-29T07:24:00Z 9.964 coyote_creek
TOP()
、tag和INTO
子句当使用INTO
子句但没有使用GROUP BY tag
子句时,大多数InfluxQL函数将原始数据中的tag转换为新写入数据中的field。这种行为同样适用于TOP()
函数,除非TOP()
中包含tag key作为参数:TOP(field_key,tag_key(s),N)
。在这些情况下,系统会将指定的tag保留为新写入数据中的tag。
示例
下面代码块中的第一个查询返回tag key location
的两个tag value对应的field key water_level
的最大值,并且,它这些结果写入measurement top_water_levels
中。第二个查询展示了TSDB For InfluxDB®将tag location
保留为measurement top_water_levels
中的tag。
> SELECT TOP("water_level","location",2) INTO "top_water_levels" FROM "h2o_feet"
name: result
time written
---- -------
1970-01-01T00:00:00Z 2
> SHOW TAG KEYS FROM "top_water_levels"
name: top_water_levels
tagKey
------
location
SELECT ABS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ABS(field_key)
返回field key对应的field value的绝对值。
ABS(*)
返回在measurement中每个field key对应的field value的绝对值。
ABS()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ABS()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT * FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'
name: data
time a b
---- - -
1529841600000000000 1.33909108671076 -0.163643058925645
1529841660000000000 -0.774984088561186 0.137034364053949
1529841720000000000 -0.921037167720451 -0.482943221384294
1529841780000000000 -1.73880754843378 -0.0729732928756677
1529841840000000000 -0.905980032168252 1.77857552719844
1529841900000000000 -0.891164752631417 0.741147445214238
> SELECT ABS("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'
name: data
time abs
---- ---
1529841600000000000 1.33909108671076
1529841660000000000 0.774984088561186
1529841720000000000 0.921037167720451
1529841780000000000 1.73880754843378
1529841840000000000 0.905980032168252
1529841900000000000 0.891164752631417
该查询返回measurement data
中field key a
对应的field value的绝对值。
> SELECT ABS(*) FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z'
name: data
time abs_a abs_b
---- ----- -----
1529841600000000000 1.33909108671076 0.163643058925645
1529841660000000000 0.774984088561186 0.137034364053949
1529841720000000000 0.921037167720451 0.482943221384294
1529841780000000000 1.73880754843378 0.0729732928756677
1529841840000000000 0.905980032168252 1.77857552719844
1529841900000000000 0.891164752631417 0.741147445214238
该查询返回measurement data
中每个存储数值的field key对应的field value的绝对值。measurement data
中有两个数值类型的field:a
和b
。
> SELECT ABS("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T12:05:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2
name: data
time abs
---- ---
1529841780000000000 1.73880754843378
1529841720000000000 0.921037167720451
1529841660000000000 0.774984088561186
1529841600000000000 1.33909108671076
该查询返回measurement data
中field key a
对应的field value的绝对值,它涵盖的时间范围在2018-06-24T12:00:00Z
和2018-06-24T12:05:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ABS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的绝对值。
ABS()支持以下嵌套函数:
> SELECT ABS(MEAN("a")) FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T13:00:00Z' GROUP BY time(12m)
time abs
---- ---
1529841600000000000 0.3960977256302787
1529842320000000000 0.0010541018316373302
1529843040000000000 0.04494733240283668
1529843760000000000 0.2553594777104415
1529844480000000000 0.20382988543108413
1529845200000000000 0.790836070736962
该查询返回field key a
对应的每12分钟的时间间隔的field value的平均值的绝对值。
为了得到这些结果,TSDB For InfluxDB®首先计算field key a
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ABS()
的情形一样:
> SELECT MEAN("a") FROM "data" WHERE time >= '2018-06-24T12:00:00Z' AND time <= '2018-06-24T13:00:00Z' GROUP BY time(12m)
name: data
time mean
---- ----
1529841600000000000 -0.3960977256302787
1529842320000000000 0.0010541018316373302
1529843040000000000 0.04494733240283668
1529843760000000000 0.2553594777104415
1529844480000000000 0.20382988543108413
1529845200000000000 -0.790836070736962
然后,TSDB For InfluxDB®计算这些平均值的绝对值。
SELECT ACOS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ACOS(field_key)
返回field key对应的field value的反余弦。
ACOS(*)
返回在measurement中每个field key对应的field value的反余弦。
ACOS()
支持数据类型为int64和float64的field value,并且field value必须在-1和1之间。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ACOS()
和GROUP BY time()
子句。
下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是,所有的field value都在ACOS()
函数的可计算范围里(-1到1):
> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time capacity
---- --------
2017-05-01T00:00:00Z 0.83
2017-05-02T00:00:00Z 0.3
2017-05-03T00:00:00Z 0.84
2017-05-04T00:00:00Z 0.22
2017-05-05T00:00:00Z 0.17
2017-05-06T00:00:00Z 0.77
2017-05-07T00:00:00Z 0.64
2017-05-08T00:00:00Z 0.72
2017-05-09T00:00:00Z 0.16
> SELECT ACOS("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time acos
---- ----
2017-05-01T00:00:00Z 0.591688642426544
2017-05-02T00:00:00Z 1.266103672779499
2017-05-03T00:00:00Z 0.5735131044230969
2017-05-04T00:00:00Z 1.3489818562981022
2017-05-05T00:00:00Z 1.399966657665792
2017-05-06T00:00:00Z 0.6919551751263169
2017-05-07T00:00:00Z 0.8762980611683406
2017-05-08T00:00:00Z 0.7669940078618667
2017-05-09T00:00:00Z 1.410105673842986
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反余弦。
> SELECT ACOS(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time acos_of_capacity
---- -------------
2017-05-01T00:00:00Z 0.591688642426544
2017-05-02T00:00:00Z 1.266103672779499
2017-05-03T00:00:00Z 0.5735131044230969
2017-05-04T00:00:00Z 1.3489818562981022
2017-05-05T00:00:00Z 1.399966657665792
2017-05-06T00:00:00Z 0.6919551751263169
2017-05-07T00:00:00Z 0.8762980611683406
2017-05-08T00:00:00Z 0.7669940078618667
2017-05-09T00:00:00Z 1.410105673842986
该查询返回measurement park_occupancy
中每个存储数值的field key对应的field value的反余弦。measurement park_occupancy
中只有一个数值类型的field:of_capacity
。
> SELECT ACOS("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2
name: park_occupancy
time acos
---- ----
2017-05-07T00:00:00Z 0.8762980611683406
2017-05-06T00:00:00Z 0.6919551751263169
2017-05-05T00:00:00Z 1.399966657665792
2017-05-04T00:00:00Z 1.3489818562981022
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反余弦,它涵盖的时间范围在2017-05-01T00:00:00Z
和2017-05-09T00:00:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ACOS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的反余弦。
ACOS()支持以下嵌套函数:
> SELECT ACOS(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time acos
---- ----
2017-04-30T00:00:00Z 0.9703630732143733
2017-05-03T00:00:00Z 1.1483422646081407
2017-05-06T00:00:00Z 0.7812981174487247
2017-05-09T00:00:00Z 1.410105673842986
该查询返回field key of_capacity
对应的每三天的时间间隔的field value的平均值的反余弦。
为了得到这些结果,TSDB For InfluxDB®首先计算field key of_capacity
对应的每三天的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ACOS()
的情形一样:
> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time mean
---- ----
2017-04-30T00:00:00Z 0.565
2017-05-03T00:00:00Z 0.41
2017-05-06T00:00:00Z 0.71
2017-05-09T00:00:00Z 0.16
然后,TSDB For InfluxDB®计算这些平均值的反余弦。
SELECT ASIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ASIN(field_key)
返回field key对应的field value的反正弦。
ASIN(*)
返回在measurement中每个field key对应的field value的反正弦。
ASIN()
支持数据类型为int64和float64的field value,并且field value必须在-1和1之间。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ASIN()
和GROUP BY time()
子句。
下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是,所有的field value都在ASIN()
函数的可计算范围里(-1到1):
> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time capacity
---- --------
2017-05-01T00:00:00Z 0.83
2017-05-02T00:00:00Z 0.3
2017-05-03T00:00:00Z 0.84
2017-05-04T00:00:00Z 0.22
2017-05-05T00:00:00Z 0.17
2017-05-06T00:00:00Z 0.77
2017-05-07T00:00:00Z 0.64
2017-05-08T00:00:00Z 0.72
2017-05-09T00:00:00Z 0.16
> SELECT ASIN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time asin
---- ----
2017-05-01T00:00:00Z 0.9791076843683526
2017-05-02T00:00:00Z 0.3046926540153975
2017-05-03T00:00:00Z 0.9972832223717997
2017-05-04T00:00:00Z 0.22181447049679442
2017-05-05T00:00:00Z 0.1708296691291045
2017-05-06T00:00:00Z 0.8788411516685797
2017-05-07T00:00:00Z 0.6944982656265559
2017-05-08T00:00:00Z 0.8038023189330299
2017-05-09T00:00:00Z 0.1606906529519106
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反正弦。
> SELECT ASIN(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time asin_of_capacity
---- -------------
2017-05-01T00:00:00Z 0.9791076843683526
2017-05-02T00:00:00Z 0.3046926540153975
2017-05-03T00:00:00Z 0.9972832223717997
2017-05-04T00:00:00Z 0.22181447049679442
2017-05-05T00:00:00Z 0.1708296691291045
2017-05-06T00:00:00Z 0.8788411516685797
2017-05-07T00:00:00Z 0.6944982656265559
2017-05-08T00:00:00Z 0.8038023189330299
2017-05-09T00:00:00Z 0.1606906529519106
该查询返回measurement park_occupancy
中每个存储数值的field key对应的field value的反正弦。measurement park_occupancy
中只有一个数值类型的field:of_capacity
。
> SELECT ASIN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2
name: park_occupancy
time asin
---- ----
2017-05-07T00:00:00Z 0.6944982656265559
2017-05-06T00:00:00Z 0.8788411516685797
2017-05-05T00:00:00Z 0.1708296691291045
2017-05-04T00:00:00Z 0.22181447049679442
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反正弦,它涵盖的时间范围在2017-05-01T00:00:00Z
和2017-05-09T00:00:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ASIN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的反正弦。
ASIN()支持以下嵌套函数:
> SELECT ASIN(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time asin
---- ----
2017-04-30T00:00:00Z 0.6004332535805232
2017-05-03T00:00:00Z 0.42245406218675574
2017-05-06T00:00:00Z 0.7894982093461719
2017-05-09T00:00:00Z 0.1606906529519106
该查询返回field key of_capacity
对应的每三天的时间间隔的field value的平均值的反正弦。
为了得到这些结果,TSDB For InfluxDB®首先计算field key of_capacity
对应的每三天的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ASIN()
的情形一样:
> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time mean
---- ----
2017-04-30T00:00:00Z 0.565
2017-05-03T00:00:00Z 0.41
2017-05-06T00:00:00Z 0.71
2017-05-09T00:00:00Z 0.16
然后,TSDB For InfluxDB®计算这些平均值的反正弦。
SELECT ATAN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ATAN(field_key)
返回field key对应的field value的反正切。
ATAN(*)
返回在measurement中每个field key对应的field value的反正切。
ATAN()
支持数据类型为int64和float64的field value,并且field value必须在-1和1之间。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ATAN()
和GROUP BY time()
子句。
下面的示例将使用如下模拟的公园占有率(相对于总空间)的数据。需要注意的重要事项是,所有的field value都在ATAN()
函数的可计算范围里(-1到1):
> SELECT "of_capacity" FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time capacity
---- --------
2017-05-01T00:00:00Z 0.83
2017-05-02T00:00:00Z 0.3
2017-05-03T00:00:00Z 0.84
2017-05-04T00:00:00Z 0.22
2017-05-05T00:00:00Z 0.17
2017-05-06T00:00:00Z 0.77
2017-05-07T00:00:00Z 0.64
2017-05-08T00:00:00Z 0.72
2017-05-09T00:00:00Z 0.16
> SELECT ATAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time atan
---- ----
2017-05-01T00:00:00Z 0.6927678353971222
2017-05-02T00:00:00Z 0.2914567944778671
2017-05-03T00:00:00Z 0.6986598247214632
2017-05-04T00:00:00Z 0.2165503049760893
2017-05-05T00:00:00Z 0.16839015714752992
2017-05-06T00:00:00Z 0.6561787179913948
2017-05-07T00:00:00Z 0.5693131911006619
2017-05-08T00:00:00Z 0.6240230529767568
2017-05-09T00:00:00Z 0.1586552621864014
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反正切。
> SELECT ATAN(*) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z'
name: park_occupancy
time atan_of_capacity
---- -------------
2017-05-01T00:00:00Z 0.6927678353971222
2017-05-02T00:00:00Z 0.2914567944778671
2017-05-03T00:00:00Z 0.6986598247214632
2017-05-04T00:00:00Z 0.2165503049760893
2017-05-05T00:00:00Z 0.16839015714752992
2017-05-06T00:00:00Z 0.6561787179913948
2017-05-07T00:00:00Z 0.5693131911006619
2017-05-08T00:00:00Z 0.6240230529767568
2017-05-09T00:00:00Z 0.1586552621864014
该查询返回measurement park_occupancy
中每个存储数值的field key对应的field value的反正切。measurement park_occupancy
中只有一个数值类型的field:of_capacity
。
> SELECT ATAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2
name: park_occupancy
time atan
---- ----
2017-05-07T00:00:00Z 0.5693131911006619
2017-05-06T00:00:00Z 0.6561787179913948
2017-05-05T00:00:00Z 0.16839015714752992
2017-05-04T00:00:00Z 0.2165503049760893
该查询返回measurement park_occupancy
中field key of_capacity
对应的field value的反正切,它涵盖的时间范围在2017-05-01T00:00:00Z
和2017-05-09T00:00:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ATAN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的反正切。
ATAN()支持以下嵌套函数:
> SELECT ATAN(MEAN("of_capacity")) FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time atan
---- ----
2017-04-30T00:00:00Z 0.5142865412694495
2017-05-03T00:00:00Z 0.3890972310552784
2017-05-06T00:00:00Z 0.6174058917515726
2017-05-09T00:00:00Z 0.1586552621864014
该查询返回field key of_capacity
对应的每三天的时间间隔的field value的平均值的反正切。
为了得到这些结果,TSDB For InfluxDB®首先计算field key of_capacity
对应的每三天的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ATAN()
的情形一样:
> SELECT MEAN("of_capacity") FROM "park_occupancy" WHERE time >= '2017-05-01T00:00:00Z' AND time <= '2017-05-09T00:00:00Z' GROUP BY time(3d)
name: park_occupancy
time mean
---- ----
2017-04-30T00:00:00Z 0.565
2017-05-03T00:00:00Z 0.41
2017-05-06T00:00:00Z 0.71
2017-05-09T00:00:00Z 0.16
然后,TSDB For InfluxDB®计算这些平均值的反正切。
y/x
的反正切。
SELECT ATAN2( [ * | <field_key> | num ], [ <field_key> | num ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ATAN2(field_key_y, field_key_x)
返回field key “field_key_y”对应的field value除以field key “field_key_x”对应的field value的反正切。
ATAN2(*, field_key_x)<br />
返回在measurement中每个field key对应的field value除以field key “field_key_x”对应的field value的反正切。
ATAN2()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ATAN2()
和GROUP BY time()
子句。
下面的示例将使用如下模拟的飞行数据:
> SELECT "altitude_ft", "distance_ft" FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'
name: flight_data
time altitude_ft distance_ft
---- ----------- -----------
2018-05-16T12:01:00Z 1026 50094
2018-05-16T12:02:00Z 2549 53576
2018-05-16T12:03:00Z 4033 55208
2018-05-16T12:04:00Z 5579 58579
2018-05-16T12:05:00Z 7065 61213
2018-05-16T12:06:00Z 8589 64807
2018-05-16T12:07:00Z 10180 67707
2018-05-16T12:08:00Z 11777 69819
2018-05-16T12:09:00Z 13321 72452
2018-05-16T12:10:00Z 14885 75881
> SELECT ATAN2("altitude_ft", "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'
name: flight_data
time atan2
---- -----
2018-05-16T12:01:00Z 0.020478631571881498
2018-05-16T12:02:00Z 0.04754142349303296
2018-05-16T12:03:00Z 0.07292147724575364
2018-05-16T12:04:00Z 0.09495251193874832
2018-05-16T12:05:00Z 0.11490822875441563
2018-05-16T12:06:00Z 0.13176409347584003
2018-05-16T12:07:00Z 0.14923587589682233
2018-05-16T12:08:00Z 0.1671059946640312
2018-05-16T12:09:00Z 0.18182893717409565
2018-05-16T12:10:00Z 0.1937028631495223
该查询返回field key altitude_ft
对应的field value除以field key distance_ft
对应的field value的反正切。这两个field key都在measurement flight_data
中。
> SELECT ATAN2(*, "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z'
name: flight_data
time atan2_altitude_ft atan2_distance_ft
---- ----------------- -----------------
2018-05-16T12:01:00Z 0.020478631571881498 0.7853981633974483
2018-05-16T12:02:00Z 0.04754142349303296 0.7853981633974483
2018-05-16T12:03:00Z 0.07292147724575364 0.7853981633974483
2018-05-16T12:04:00Z 0.09495251193874832 0.7853981633974483
2018-05-16T12:05:00Z 0.11490822875441563 0.7853981633974483
2018-05-16T12:06:00Z 0.13176409347584003 0.7853981633974483
2018-05-16T12:07:00Z 0.14923587589682233 0.7853981633974483
2018-05-16T12:08:00Z 0.1671059946640312 0.7853981633974483
2018-05-16T12:09:00Z 0.18182893717409565 0.7853981633974483
2018-05-16T12:10:00Z 0.19370286314952234 0.7853981633974483
该查询返回measurement flight_data
中每个存储数值的field key对应的field value除以field key distance_ft
对应的field value的反正切。measurement flight_data
中有两个数值类型的field:altitude_ft
和distance_ft
。
> SELECT ATAN2("altitude_ft", "distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T12:10:00Z' ORDER BY time DESC LIMIT 4 OFFSET 2
name: flight_data
time atan2
---- -----
2018-05-16T12:08:00Z 0.1671059946640312
2018-05-16T12:07:00Z 0.14923587589682233
2018-05-16T12:06:00Z 0.13176409347584003
2018-05-16T12:05:00Z 0.11490822875441563
该查询返回field key altitude_ft
对应的field value除以field key distance_ft
对应的field value的反正切,它涵盖的时间范围在2018-05-16T12:10:00Z
和2018-05-16T12:10:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ATAN2(<function()>, <function()>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的反正切(ATAN2()
)。
ATAN2()支持以下嵌套函数:
> SELECT ATAN2(MEAN("altitude_ft"), MEAN("distance_ft")) FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T13:01:00Z' GROUP BY time(12m)
name: flight_data
time atan2
---- -----
2018-05-16T12:00:00Z 0.133815587896842
2018-05-16T12:12:00Z 0.2662716308351908
2018-05-16T12:24:00Z 0.2958845306108965
2018-05-16T12:36:00Z 0.23783439588429497
2018-05-16T12:48:00Z 0.1906803720242831
2018-05-16T13:00:00Z 0.17291511946158172
该查询返回field key altitude_ft
对应的field value的平均值除以field key distance_ft
对应的field value的平均值的反正切。平均值是按每12分钟的时间间隔计算的。
为了得到这些结果,TSDB For InfluxDB®首先计算field key altitude_ft
和distance_ft
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ATAN2()
的情形一样:
> SELECT MEAN("altitude_ft"), MEAN("distance_ft") FROM "flight_data" WHERE time >= '2018-05-16T12:01:00Z' AND time <= '2018-05-16T13:01:00Z' GROUP BY time(12m)
name: flight_data
time mean mean_1
---- ---- ------
2018-05-16T12:00:00Z 8674 64433.181818181816
2018-05-16T12:12:00Z 26419.833333333332 96865.25
2018-05-16T12:24:00Z 40337.416666666664 132326.41666666666
2018-05-16T12:36:00Z 41149.583333333336 169743.16666666666
2018-05-16T12:48:00Z 41230.416666666664 213600.91666666666
2018-05-16T13:00:00Z 41184.5 235799
然后,TSDB For InfluxDB®计算这些平均值的反正切。
SELECT CEIL( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
CEIL(field_key)
返回field key对应的大于field value的最小整数。
CEIL(*)
返回在measurement中每个field key对应的大于field value的最小整数。
CEIL()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用CEIL()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT CEIL("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ceil
---- ----
2015-08-18T00:00:00Z 3
2015-08-18T00:06:00Z 3
2015-08-18T00:12:00Z 3
2015-08-18T00:18:00Z 3
2015-08-18T00:24:00Z 3
2015-08-18T00:30:00Z 3
该查询返回measurement h2o_feet
中field key water_level
对应的大于field value的最小整数。
> SELECT CEIL(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ceil_water_level
---- ----------------
2015-08-18T00:00:00Z 3
2015-08-18T00:06:00Z 3
2015-08-18T00:12:00Z 3
2015-08-18T00:18:00Z 3
2015-08-18T00:24:00Z 3
2015-08-18T00:30:00Z 3
该查询返回measurement h2o_feet
中每个存储数值的field key对应的大于field value的最小整数。measurement h2o_feet
只有一个数值类型的field:water_level
。
> SELECT CEIL("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time ceil
---- ----
2015-08-18T00:18:00Z 3
2015-08-18T00:12:00Z 3
2015-08-18T00:06:00Z 3
2015-08-18T00:00:00Z 3
该查询返回field key water_level
对应的大于field value的最小整数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT CEIL(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后将CEIL()
应用于这些结果。
CEIL()支持以下嵌套函数:
> SELECT CEIL(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time ceil
---- ----
2015-08-18T00:00:00Z 3
2015-08-18T00:12:00Z 3
2015-08-18T00:24:00Z 3
该查询返回每12分钟的时间间隔对应的大于water_level
平均值的最小整数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的大于water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用CEIL()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算大于这些平均值的最小整数。
SELECT COS( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
COS(field_key)
返回field key对应的field value的余弦值。
COS(*)
返回在measurement中每个field key对应的field value的余弦值。
COS()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用COS()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> 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的余弦值。
> 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("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time cos
---- ---
2015-08-18T00:18:00Z -0.5271163912192579
2015-08-18T00:12:00Z -0.4414407189100776
2015-08-18T00:06:00Z -0.5185922462666872
2015-08-18T00:00:00Z -0.47345017433543124
该查询返回measurement h2o_feet
中field key water_level
对应的field value的余弦值,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT COS(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的余弦值。
COS()支持以下嵌套函数:
> SELECT COS(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time cos
---- ---
2015-08-18T00:00:00Z -0.49618891270599885
2015-08-18T00:12:00Z -0.4848605136571181
2015-08-18T00:24:00Z -0.4575195627907578
该查询返回field key water_level
对应的每12分钟的时间间隔的field value的平均值的余弦值。
为了得到这些结果,TSDB For InfluxDB®首先计算field key water_level
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用COS()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的余弦值。
SELECT CUMULATIVE_SUM( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
CUMULATIVE_SUM(field_key)
返回field key对应的field value的累积总和。
CUMULATIVE_SUM(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的累积总和。
CUMULATIVE_SUM(*)
返回在measurement中每个field key对应的field value的累积总和。
CUMULATIVE_SUM()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用CUMULATIVE_SUM()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT CUMULATIVE_SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time cumulative_sum
---- --------------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 4.18
2015-08-18T00:12:00Z 6.208
2015-08-18T00:18:00Z 8.334
2015-08-18T00:24:00Z 10.375
2015-08-18T00:30:00Z 12.426
该查询返回measurement h2o_feet
中field key water_level
对应的field value的累积总和。
> SELECT CUMULATIVE_SUM(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time cumulative_sum_water_level
---- --------------------------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 4.18
2015-08-18T00:12:00Z 6.208
2015-08-18T00:18:00Z 8.334
2015-08-18T00:24:00Z 10.375
2015-08-18T00:30:00Z 12.426
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的累积总和。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT CUMULATIVE_SUM(/water/) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time cumulative_sum_water_level
---- --------------------------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 4.18
2015-08-18T00:12:00Z 6.208
2015-08-18T00:18:00Z 8.334
2015-08-18T00:24:00Z 10.375
2015-08-18T00:30:00Z 12.426
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的累积总和。
> SELECT CUMULATIVE_SUM("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time cumulative_sum
---- --------------
2015-08-18T00:18:00Z 6.218
2015-08-18T00:12:00Z 8.246
2015-08-18T00:06:00Z 10.362
2015-08-18T00:00:00Z 12.426
该查询返回measurement h2o_feet
中field key water_level
对应的field value的累积总和,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT CUMULATIVE_SUM(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的累积总和。
CUMULATIVE_SUM()支持以下嵌套函数:
> SELECT CUMULATIVE_SUM(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time cumulative_sum
---- --------------
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 4.167
2015-08-18T00:24:00Z 6.213
该查询返回field key water_level
对应的每12分钟的时间间隔的field value的平均值的累积总和。
为了得到这些结果,TSDB For InfluxDB®首先计算field key water_level
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用CUMULATIVE_SUM()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的累积总和。最终查询结果中的第二个数据点(4.167
)是2.09
和2.077
的总和,第三个数据点(6.213
)是2.09
、2.077
和2.0460000000000003
的总和。
SELECT DERIVATIVE( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TSDB For InfluxDB®计算field value之间的差值,并将这些结果转换为每个unit
的变化率。参数unit
的值是一个整数,后跟一个时间单位。这个参数是可选的,不是必须要有的。如果查询没有指定unit
的值,那么unit
默认为一秒(1s
)。
DERIVATIVE(field_key)
返回field key对应的field value的变化率。
DERIVATIVE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的变化率。
DERIVATIVE(*)
返回在measurement中每个field key对应的field value的变化率。
DERIVATIVE()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用DERIVATIVE()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT DERIVATIVE("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:06:00Z 0.00014444444444444457
2015-08-18T00:12:00Z -0.00024444444444444465
2015-08-18T00:18:00Z 0.0002722222222222218
2015-08-18T00:24:00Z -0.000236111111111111
2015-08-18T00:30:00Z 2.777777777777842e-05
该查询返回measurement h2o_feet
中field key water_level
对应的field value的每秒变化率。
第一个结果(0.00014444444444444457
)是原始数据中前两个field value在一秒内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为一秒的变化率:
(2.116 - 2.064) / (360s / 1s)
-------------- ----------
| |
| the difference between the field values' timestamps / the default unit
second field value - first field value
unit
> SELECT DERIVATIVE("water_level",6m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:06:00Z 0.052000000000000046
2015-08-18T00:12:00Z -0.08800000000000008
2015-08-18T00:18:00Z 0.09799999999999986
2015-08-18T00:24:00Z -0.08499999999999996
2015-08-18T00:30:00Z 0.010000000000000231
该查询返回measurement h2o_feet
中field key water_level
对应的field value的每六分钟的变化率。
第一个结果(0.052000000000000046
)是原始数据中前两个field value在六分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为六分钟的变化率:
(2.116 - 2.064) / (6m / 6m)
-------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
unit
> SELECT DERIVATIVE(*,3m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time derivative_water_level
---- ----------------------
2015-08-18T00:06:00Z 0.026000000000000023
2015-08-18T00:12:00Z -0.04400000000000004
2015-08-18T00:18:00Z 0.04899999999999993
2015-08-18T00:24:00Z -0.04249999999999998
2015-08-18T00:30:00Z 0.0050000000000001155
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的每三分钟的变化率。measurement h2o_feet
中只有一个数值类型的field:water_level
。
第一个结果(0.026000000000000023
)是原始数据中前两个field value在三分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为三分钟的变化率:
(2.116 - 2.064) / (6m / 3m)
-------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
unit
> SELECT DERIVATIVE(/water/,2m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time derivative_water_level
---- ----------------------
2015-08-18T00:06:00Z 0.01733333333333335
2015-08-18T00:12:00Z -0.02933333333333336
2015-08-18T00:18:00Z 0.03266666666666662
2015-08-18T00:24:00Z -0.02833333333333332
2015-08-18T00:30:00Z 0.0033333333333334103
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value的每两分钟的变化率。measurement h2o_feet
中只有一个数值类型的field:water_level
。
第一个结果(0.01733333333333335
)是原始数据中前两个field value在两分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为两分钟的变化率:
(2.116 - 2.064) / (6m / 2m)
-------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
> SELECT DERIVATIVE("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' ORDER BY time DESC LIMIT 1 OFFSET 2
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:12:00Z -0.0002722222222222218
该查询返回measurement h2o_feet
中field key water_level
对应的field value的每秒变化率,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为1,并将返回的数据点偏移两个(即前两个数据点不返回)。
唯一的结果(-0.0002722222222222218
)是原始数据中前两个field value在一秒内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为一秒的变化率:
(2.126 - 2.028) / (360s / 1s)
-------------- ----------
| |
| the difference between the field values' timestamps / the default unit
second field value - first field value
SELECT DERIVATIVE(<function> ([ * | <field_key> | /<regular_expression>/ ]) [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的导数。
参数unit
的值是一个整数,后跟一个时间单位。这个参数是可选的,不是必须要有的。如果查询没有指定unit
的值,那么unit
默认为GROUP BY time()
的时间间隔。请注意,这里unit
的默认值跟基本语法中unit
的默认值不一样。
DERIVATIVE()支持以下嵌套函数:
> SELECT DERIVATIVE(MEAN("water_level")) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:12:00Z -0.0129999999999999
2015-08-18T00:24:00Z -0.030999999999999694
该查询返回field key water_level
对应的每12分钟的时间间隔的field value的平均值的每12分钟变化率。
为了得到这些结果,TSDB For InfluxDB®首先计算field key water_level
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用DERIVATIVE()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的每12分钟的变化率。第一个结果(-0.0129999999999999
)是原始数据中前两个field value在12分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为12分钟的变化率:
(2.077 - 2.09) / (12m / 12m)
------------- ----------
| |
| the difference between the field values' timestamps / the default unit
second field value - first field value
unit
> SELECT DERIVATIVE(MEAN("water_level"),6m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time derivative
---- ----------
2015-08-18T00:12:00Z -0.00649999999999995
2015-08-18T00:24:00Z -0.015499999999999847
该查询返回field key water_level
对应的每12分钟的时间间隔的field value的平均值的每六分钟变化率。
为了得到这些结果,TSDB For InfluxDB®首先计算field key water_level
对应的每12分钟的时间间隔的field value的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用DERIVATIVE()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的每六分钟的变化率。第一个结果(-0.00649999999999995
)是原始数据中前两个field value在六分钟内的变化率。TSDB For InfluxDB®计算两个field value之间的差值,并将该值标准化为六分钟的变化率:
(2.077 - 2.09) / (12m / 6m)
------------- ----------
| |
| the difference between the field values' timestamps / the specified unit
second field value - first field value
SELECT DIFFERENCE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
DIFFERENCE(field_key)
返回field key对应的field value的差值。
DIFFERENCE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的差值。
DIFFERENCE(*)
返回在measurement中每个field key对应的field value的差值。
DIFFERENCE()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用DIFFERENCE()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT DIFFERENCE("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time difference
---- ----------
2015-08-18T00:06:00Z 0.052000000000000046
2015-08-18T00:12:00Z -0.08800000000000008
2015-08-18T00:18:00Z 0.09799999999999986
2015-08-18T00:24:00Z -0.08499999999999996
2015-08-18T00:30:00Z 0.010000000000000231
该查询返回measurement h2o_feet
中field key water_level
对应的field value之间的差值。
> SELECT DIFFERENCE(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time difference_water_level
---- ----------------------
2015-08-18T00:06:00Z 0.052000000000000046
2015-08-18T00:12:00Z -0.08800000000000008
2015-08-18T00:18:00Z 0.09799999999999986
2015-08-18T00:24:00Z -0.08499999999999996
2015-08-18T00:30:00Z 0.010000000000000231
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value之间的差值。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT DIFFERENCE(/water/) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time difference_water_level
---- ----------------------
2015-08-18T00:06:00Z 0.052000000000000046
2015-08-18T00:12:00Z -0.08800000000000008
2015-08-18T00:18:00Z 0.09799999999999986
2015-08-18T00:24:00Z -0.08499999999999996
2015-08-18T00:30:00Z 0.010000000000000231
该查询返回measurement h2o_feet
中每个存储数值并包含单词water
的field key对应的field value之间的差值。
> SELECT DIFFERENCE("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 2 OFFSET 2
name: h2o_feet
time difference
---- ----------
2015-08-18T00:12:00Z -0.09799999999999986
2015-08-18T00:06:00Z 0.08800000000000008
该查询返回measurement h2o_feet
中field key water_level
对应的field value之间的差值,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为2,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT DIFFERENCE(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果之间的差值。
DIFFERENCE()支持以下嵌套函数:
> SELECT DIFFERENCE(MAX("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time difference
---- ----------
2015-08-18T00:12:00Z 0.009999999999999787
2015-08-18T00:24:00Z -0.07499999999999973
该查询返回field key water_level
对应的每12分钟的时间间隔的field value的最大值之间的差值。
为了得到这些结果,TSDB For InfluxDB®首先计算field key water_level
对应的每12分钟的时间间隔的field value的最大值。这一步跟同时使用MAX()
函数和GROUP BY time()
子句、但不使用DIFFERENCE()
的情形一样:
> SELECT MAX("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time max
---- ---
2015-08-18T00:00:00Z 2.116
2015-08-18T00:12:00Z 2.126
2015-08-18T00:24:00Z 2.051
然后,TSDB For InfluxDB®计算这些最大值之间的差值。最终查询结果中的第一个数据点(0.009999999999999787
)是2.126
和2.116
的差,第二个数据点(-0.07499999999999973
)是2.051
和2.126
的差。
SELECT ELAPSED( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TSDB For InfluxDB®计算时间戳之间的差值。参数unit
的值是一个整数,后跟一个时间单位,它决定了返回的差值的单位。这个参数是可选的,不是必须要有的。如果没有指定unit
的值,那么查询将返回以纳秒为单位的两个时间戳之间的差值。
ELAPSED(field_key)
返回field key对应的时间戳之间的差值。
ELAPSED(/regular_expression/)
返回与正则表达式匹配的每个field key对应的时间戳之间的差值。
ELAPSED(*)
返回在measurement中每个field key对应的时间戳之间的差值。
ELAPSED()
支持所有数据类型的field value。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
> SELECT ELAPSED("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time elapsed
---- -------
2015-08-18T00:06:00Z 360000000000
2015-08-18T00:12:00Z 360000000000
该查询返回measurement h2o_feet
中field key water_level
对应的时间戳之间的差值(以纳秒为单位)。
unit
> SELECT ELAPSED("water_level",1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time elapsed
---- -------
2015-08-18T00:06:00Z 6
2015-08-18T00:12:00Z 6
该查询返回measurement h2o_feet
中field key water_level
对应的时间戳之间的差值(以分钟为单位)。
unit
> SELECT ELAPSED(*,1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time elapsed_level description elapsed_water_level
---- ------------------------- -------------------
2015-08-18T00:06:00Z 6 6
2015-08-18T00:12:00Z 6 6
该查询返回measurement h2o_feet
中每个field key对应的时间戳之间的差值(以分钟为单位)。measurement h2o_feet
中有两个field key:level description
和water_level
。
unit
> SELECT ELAPSED(/level/,1s) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time elapsed_level description elapsed_water_level
---- ------------------------- -------------------
2015-08-18T00:06:00Z 360 360
2015-08-18T00:12:00Z 360 360
该查询返回measurement h2o_feet
中每个包含单词level
的field key对应的时间戳之间的差值(以秒为单位)。
> SELECT ELAPSED("water_level",1ms) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z' ORDER BY time DESC LIMIT 1 OFFSET 1
name: h2o_feet
time elapsed
---- -------
2015-08-18T00:00:00Z -360000
该查询返回measurement h2o_feet
中field key water_level
对应的时间戳之间的差值(以毫秒为单位),它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:12:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为1,并将返回的数据点偏移一个(即前一个数据点不返回)。
请注意,查询结果是负数;因为ORDER BY time DESC
子句按递减的顺序对时间戳进行排序,所以ELAPSED()
以相反的顺序计算时间戳的差值。
ELAPSED()
的常见问题ELAPSED()
和大于经过时间的单位如果unit
的值大于时间戳之间的差值,那么TSDB For InfluxDB®将会返回0
。
示例
measurement h2o_feet
中每六分钟有一个数据点。如果查询将unit
设置为一小时,TSDB For InfluxDB®将会返回0
:
> SELECT ELAPSED("water_level",1h) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time elapsed
---- -------
2015-08-18T00:06:00Z 0
2015-08-18T00:12:00Z 0
ELAPSED()
和GROUP BY time()
子句同时使用ELAPSED()
函数支持GROUP BY time()
子句,但是查询结果不是特别有用。目前,如果ELAPSED()
查询包含一个嵌套的InfluxQL函数和一个GROUP BY time()
子句,那么只会返回指定GROUP BY time()
子句中的时间间隔。
GROUP BY time()
子句决定了查询结果中的时间戳:每个时间戳表示时间间隔的开始时间。该行为也适用于嵌套的selector函数(例如FIRST()
或MAX()
),而在其它的所有情况下,这些函数返回的是原始数据的特定时间戳。因为GROUP BY time()
子句会覆盖原始时间戳,所以ELAPSED()
始终返回与GROUP BY time()
的时间间隔相同的时间戳。
示例
下面代码块中的第一个查询尝试使用ELAPSED()
和GROUP BY time()
子句来查找最小的water_level
的值之间经过的时间(以分钟为单位)。查询的两个时间间隔都返回了12分钟。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔的water_level
的最小值。代码块中的第二个查询展示了这一步的结果。这一步跟同时使用MIN()
函数和GROUP BY time()
子句、但不使用ELAPSED()
的情形一样。请注意,第二个查询返回的时间戳间隔12分钟。在原始数据中,第一个结果(2.057
)发生在2015-08-18T00:42:00Z
,但是GROUP BY time()
子句覆盖了原始的时间戳。因为时间戳由GROUP BY time()
的时间间隔(而不是原始数据)决定,所以ELAPSED()
始终返回与GROUP BY time()的时间间隔相同的时间戳。
> SELECT ELAPSED(MIN("water_level"),1m) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:36:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m)
name: h2o_feet
time elapsed
---- -------
2015-08-18T00:36:00Z 12
2015-08-18T00:48:00Z 12
> SELECT MIN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:36:00Z' AND time <= '2015-08-18T00:54:00Z' GROUP BY time(12m)
name: h2o_feet
time min
---- ---
2015-08-18T00:36:00Z 2.057 <--- Actually occurs at 2015-08-18T00:42:00Z
2015-08-18T00:48:00Z 1.991
SELECT EXP( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
EXP(field_key)
返回field key对应的field value的指数。
EXP(*)
返回在measurement中每个field key对应的field value的指数。
EXP()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用EXP()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT EXP("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time exp
---- ---
2015-08-18T00:00:00Z 7.877416541092307
2015-08-18T00:06:00Z 8.297879498060171
2015-08-18T00:12:00Z 7.598873404088091
2015-08-18T00:18:00Z 8.381274573459967
2015-08-18T00:24:00Z 7.6983036546645645
2015-08-18T00:30:00Z 7.775672892658607
该查询返回measurement h2o_feet
中field key water_level
对应的field value的指数。
> SELECT EXP(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time exp_water_level
---- ---------------
2015-08-18T00:00:00Z 7.877416541092307
2015-08-18T00:06:00Z 8.297879498060171
2015-08-18T00:12:00Z 7.598873404088091
2015-08-18T00:18:00Z 8.381274573459967
2015-08-18T00:24:00Z 7.6983036546645645
2015-08-18T00:30:00Z 7.775672892658607
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的指数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT EXP("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time exp
---- ---
2015-08-18T00:18:00Z 8.381274573459967
2015-08-18T00:12:00Z 7.598873404088091
2015-08-18T00:06:00Z 8.297879498060171
2015-08-18T00:00:00Z 7.877416541092307
该查询返回measurement h2o_feet
中field key water_level
对应的field value的指数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT EXP(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的指数。
EXP()支持以下嵌套函数:
> SELECT EXP(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time exp
---- ---
2015-08-18T00:00:00Z 8.084915164305059
2015-08-18T00:12:00Z 7.980491491670466
2015-08-18T00:24:00Z 7.736891562315577
该查询返回每12分钟的时间间隔对应的water_level
的平均值的绝对值。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用EXP()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的指数。
SELECT FLOOR( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
FLOOR(field_key)
返回field key对应的小于field value的最大整数。
FLOOR(*)
返回在measurement中每个field key对应的小于field value的最大整数。
FLOOR()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用FLOOR()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT FLOOR("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time floor
---- -----
2015-08-18T00:00:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:18:00Z 2
2015-08-18T00:24:00Z 2
2015-08-18T00:30:00Z 2
该查询返回measurement h2o_feet
中field key water_level
对应的小于field value的最大整数。
> SELECT FLOOR(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time floor_water_level
---- -----------------
2015-08-18T00:00:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:18:00Z 2
2015-08-18T00:24:00Z 2
2015-08-18T00:30:00Z 2
该查询返回measurement h2o_feet
中每个存储数值的field key对应的小于field value的最大整数。measurement h2o_feet
只有一个数值类型的field:water_level
。
> SELECT FLOOR("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time floor
---- -----
2015-08-18T00:18:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:00:00Z 2
该查询返回field key water_level
对应的小于field value的最大整数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT FLOOR(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后将FLOOR()
应用于这些结果。
FLOOR()支持以下嵌套函数:
> SELECT FLOOR(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time floor
---- -----
2015-08-18T00:00:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:24:00Z 2
该查询返回每12分钟的时间间隔对应的小于water_level
平均值的最大整数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用FLOOR()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算小于这些平均值的最大整数。
SELECT LN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
LN(field_key)
返回field key对应的field value的自然对数。
LN(*)
返回在measurement中每个field key对应的field value的自然对数。
LN()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用LN()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT LN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ln
---- --
2015-08-18T00:00:00Z 0.7246458476193163
2015-08-18T00:06:00Z 0.749527513996053
2015-08-18T00:12:00Z 0.7070500857289368
2015-08-18T00:18:00Z 0.7542422799197561
2015-08-18T00:24:00Z 0.7134398838277077
2015-08-18T00:30:00Z 0.7183274790902436
该查询返回measurement h2o_feet
中field key water_level
对应的field value的自然对数。
> SELECT LN(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time ln_water_level
---- --------------
2015-08-18T00:00:00Z 0.7246458476193163
2015-08-18T00:06:00Z 0.749527513996053
2015-08-18T00:12:00Z 0.7070500857289368
2015-08-18T00:18:00Z 0.7542422799197561
2015-08-18T00:24:00Z 0.7134398838277077
2015-08-18T00:30:00Z 0.7183274790902436
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的自然对数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT EXP("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time exp
---- ---
2015-08-18T00:18:00Z 8.381274573459967
2015-08-18T00:12:00Z 7.598873404088091
2015-08-18T00:06:00Z 8.297879498060171
2015-08-18T00:00:00Z 7.877416541092307
该查询返回measurement h2o_feet
中field key water_level
对应的field value的自然对数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT LN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的自然对数。
LN()支持以下嵌套函数:
> SELECT LN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time ln
---- --
2015-08-18T00:00:00Z 0.7371640659767196
2015-08-18T00:12:00Z 0.7309245448939752
2015-08-18T00:24:00Z 0.7158866675294349
该查询返回每12分钟的时间间隔对应的water_level
的平均值的自然对数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用LN()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的自然对数。
b
为底数的对数。
SELECT LOG( [ * | <field_key> ], <b> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
LOG(field_key, b)
返回field key对应的field value的以b
为底数的对数。
LOG(*, b)
返回在measurement中每个field key对应的field value的以b
为底数的对数。
LOG()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用LOG()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT LOG("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log
---- ---
2015-08-18T00:00:00Z 0.5227214853805835
2015-08-18T00:06:00Z 0.5406698137259695
2015-08-18T00:12:00Z 0.5100288261706268
2015-08-18T00:18:00Z 0.5440707984345088
2015-08-18T00:24:00Z 0.5146380911853161
2015-08-18T00:30:00Z 0.5181637459088826
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以4为底数的对数。
> SELECT LOG(*, 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log_water_level
---- ---------------
2015-08-18T00:00:00Z 0.5227214853805835
2015-08-18T00:06:00Z 0.5406698137259695
2015-08-18T00:12:00Z 0.5100288261706268
2015-08-18T00:18:00Z 0.5440707984345088
2015-08-18T00:24:00Z 0.5146380911853161
2015-08-18T00:30:00Z 0.5181637459088826
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的以4为底数的对数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT LOG("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time log
---- ---
2015-08-18T00:18:00Z 0.5440707984345088
2015-08-18T00:12:00Z 0.5100288261706268
2015-08-18T00:06:00Z 0.5406698137259695
2015-08-18T00:00:00Z 0.5227214853805835
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以4为底数的对数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT LOG(<function>( [ * | <field_key> ] ), <b>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的对数。
LOG()支持以下嵌套函数:
> SELECT LOG(MEAN("water_level"), 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time log
---- ---
2015-08-18T00:00:00Z 0.531751471153079
2015-08-18T00:12:00Z 0.5272506080912802
2015-08-18T00:24:00Z 0.5164030725416209
该查询返回每12分钟的时间间隔对应的water_level
的平均值的以4为底数的对数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用LOG()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的以4为底数的对数。
SELECT LOG2( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
LOG2(field_key)
返回field key对应的field value的以2为底数的对数。
LOG2(*)
返回在measurement中每个field key对应的field value的以2为底数的对数。
LOG2()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用LOG2()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT LOG2("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log2
---- ----
2015-08-18T00:00:00Z 1.045442970761167
2015-08-18T00:06:00Z 1.081339627451939
2015-08-18T00:12:00Z 1.0200576523412537
2015-08-18T00:18:00Z 1.0881415968690176
2015-08-18T00:24:00Z 1.0292761823706322
2015-08-18T00:30:00Z 1.0363274918177652
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以2为底数的对数。
> SELECT LOG2(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log2_water_level
---- ----------------
2015-08-18T00:00:00Z 1.045442970761167
2015-08-18T00:06:00Z 1.081339627451939
2015-08-18T00:12:00Z 1.0200576523412537
2015-08-18T00:18:00Z 1.0881415968690176
2015-08-18T00:24:00Z 1.0292761823706322
2015-08-18T00:30:00Z 1.0363274918177652
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的以2为底数的对数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT LOG2("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time log2
---- ----
2015-08-18T00:18:00Z 1.0881415968690176
2015-08-18T00:12:00Z 1.0200576523412537
2015-08-18T00:06:00Z 1.081339627451939
2015-08-18T00:00:00Z 1.045442970761167
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以2为底数的对数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT LOG2(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的以2为底数的对数。
LOG2()支持以下嵌套函数:
> SELECT LOG2(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time log2
---- ----
2015-08-18T00:00:00Z 1.063502942306158
2015-08-18T00:12:00Z 1.0545012161825604
2015-08-18T00:24:00Z 1.0328061450832418
该查询返回每12分钟的时间间隔对应的water_level
的平均值的以2为底数的对数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用LOG2()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的以2为底数的对数。
SELECT LOG10( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
LOG10(field_key)
返回field key对应的field value的以10为底数的对数。
LOG10(*)
返回在measurement中每个field key对应的field value的以10为底数的对数。
LOG10()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用LOG10()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT LOG10("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log10
---- -----
2015-08-18T00:00:00Z 0.3147096929551737
2015-08-18T00:06:00Z 0.32551566336314813
2015-08-18T00:12:00Z 0.3070679506612984
2015-08-18T00:18:00Z 0.32756326018727794
2015-08-18T00:24:00Z 0.3098430047160705
2015-08-18T00:30:00Z 0.3119656603683663
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以10为底数的对数。
> SELECT LOG10(*) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time log10_water_level
---- -----------------
2015-08-18T00:00:00Z 0.3147096929551737
2015-08-18T00:06:00Z 0.32551566336314813
2015-08-18T00:12:00Z 0.3070679506612984
2015-08-18T00:18:00Z 0.32756326018727794
2015-08-18T00:24:00Z 0.3098430047160705
2015-08-18T00:30:00Z 0.3119656603683663
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的以10为底数的对数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT LOG10("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time log10
---- -----
2015-08-18T00:18:00Z 0.32756326018727794
2015-08-18T00:12:00Z 0.3070679506612984
2015-08-18T00:06:00Z 0.32551566336314813
2015-08-18T00:00:00Z 0.3147096929551737
该查询返回measurement h2o_feet
中field key water_level
对应的field value的以10为底数的对数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT LOG10(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的以10为底数的对数。
LOG10()支持以下嵌套函数:
> SELECT LOG10(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time log10
---- -----
2015-08-18T00:00:00Z 0.32014628611105395
2015-08-18T00:12:00Z 0.3174364965350991
2015-08-18T00:24:00Z 0.3109056293761414
该查询返回每12分钟的时间间隔对应的water_level
的平均值的以10为底数的对数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用LOG10()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的以10为底数的对数。
SELECT MOVING_AVERAGE( [ * | <field_key> | /<regular_expression>/ ] , <N> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
MOVING_AVERAGE()
计算包含N
个连续field value的窗口的滚动平均值。参数N
是一个整数,并且它是必须的。
MOVING_AVERAGE(field_key,N)
返回field key对应的N个field value的滚动平均值。
MOVING_AVERAGE(/regular_expression/,N)
返回与正则表达式匹配的每个field key对应的N个field value的滚动平均值。
MOVING_AVERAGE(*,N)
返回在measurement中每个field key对应的N个field value的滚动平均值。
MOVING_AVERAGE()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用MOVING_AVERAGE()
和GROUP BY time()
子句。
下面的示例将使用NOAA_water_database
数据集的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT MOVING_AVERAGE("water_level",2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time moving_average
---- --------------
2015-08-18T00:06:00Z 2.09
2015-08-18T00:12:00Z 2.072
2015-08-18T00:18:00Z 2.077
2015-08-18T00:24:00Z 2.0835
2015-08-18T00:30:00Z 2.0460000000000003
该查询返回measurement h2o_feet
中field key water_level
对应的窗口大小为两个field value的滚动平均值。第一个结果(2.09
)是原始数据中前两个field value的平均值:(2.064 + 2.116) / 2。第二个结果(2.072
)是原始数据中第二和第三个field value的平均值:(2.116 + 2.028) / 2。
> SELECT MOVING_AVERAGE(*,3) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time moving_average_water_level
---- --------------------------
2015-08-18T00:12:00Z 2.0693333333333332
2015-08-18T00:18:00Z 2.09
2015-08-18T00:24:00Z 2.065
2015-08-18T00:30:00Z 2.0726666666666667
该查询返回measurement h2o_feet
中每个存储数值的field key对应的窗口大小为三个field value的滚动平均值。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT MOVING_AVERAGE(/level/,4) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z'
name: h2o_feet
time moving_average_water_level
---- --------------------------
2015-08-18T00:18:00Z 2.0835
2015-08-18T00:24:00Z 2.07775
2015-08-18T00:30:00Z 2.0615
该查询返回measurement h2o_feet
中每个存储数值并包含单词level
的field key对应的窗口大小为四个field value的滚动平均值。
> SELECT MOVING_AVERAGE("water_level",2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' ORDER BY time DESC LIMIT 2 OFFSET 3
name: h2o_feet
time moving_average
---- --------------
2015-08-18T00:06:00Z 2.072
2015-08-18T00:00:00Z 2.09
该查询返回measurement h2o_feet
中field key water_level
对应的窗口大小为两个field value的滚动平均值,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为2,并将返回的数据点偏移三个(即前三个数据点不返回)。
SELECT MOVING_AVERAGE(<function> ([ * | <field_key> | /<regular_expression>/ ]) , N ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果之间的滚动平均值。
MOVING_AVERAGE()支持以下嵌套函数:
> SELECT MOVING_AVERAGE(MAX("water_level"),2) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time moving_average
---- --------------
2015-08-18T00:12:00Z 2.121
2015-08-18T00:24:00Z 2.0885
该查询返回每12分钟的时间间隔对应的water_level
的最大值的窗口大小为两个值的滚动平均值。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的最大值。这一步跟同时使用MAX()
函数和GROUP BY time()
子句、但不使用MOVING_AVERAGE()
的情形一样:
> SELECT MAX("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time max
---- ---
2015-08-18T00:00:00Z 2.116
2015-08-18T00:12:00Z 2.126
2015-08-18T00:24:00Z 2.051
然后,TSDB For InfluxDB®计算这些最大值的窗口大小为两个值的滚动平均值。最终查询结果中的第一个数据点(2.121
)是前两个最大值的平均值((2.116 + 2.126) / 2
)。
SELECT NON_NEGATIVE_DERIVATIVE( [ * | <field_key> | /<regular_expression>/ ] [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TSDB For InfluxDB®计算field value之间的差值,并将这些结果转换为每个unit
的变化率。参数unit
的值是一个整数,后跟一个时间单位。这个参数是可选的,不是必须要有的。如果查询没有指定unit
的值,那么unit
默认为一秒(1s
)。NON_NEGATIVE_DERIVATIVE()
只返回正的变化率和等于0的变化率。
NON_NEGATIVE_DERIVATIVE(field_key)
返回field key对应的field value的非负变化率。
NON_NEGATIVE_DERIVATIVE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的非负变化率。
NON_NEGATIVE_DERIVATIVE(*)
返回在measurement中每个field key对应的field value的非负变化率。
NON_NEGATIVE_DERIVATIVE()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用NON_NEGATIVE_DERIVATIVE()
和GROUP BY time()
子句。
请查看DERIVATIVE()
文档中的示例,NON_NEGATIVE_DERIVATIVE()
跟DERIVATIVE()
的运行方式相同,但是NON_NEGATIVE_DERIVATIVE()
只返回查询结果中正的变化率和等于0的变化率。
SELECT NON_NEGATIVE_DERIVATIVE(<function> ([ * | <field_key> | /<regular_expression>/ ]) [ , <unit> ] ) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的非负导数。
参数unit
的值是一个整数,后跟一个时间单位。这个参数是可选的,不是必须要有的。如果查询没有指定unit
的值,那么unit
默认为GROUP BY time()
的时间间隔。请注意,这里unit
的默认值跟基本语法中unit
的默认值不一样。NON_NEGATIVE_DERIVATIVE()
只返回正的变化率和等于0的变化率。
NON_NEGATIVE_DERIVATIVE()支持以下嵌套函数:
请查看DERIVATIVE()
文档中的示例,NON_NEGATIVE_DERIVATIVE()
跟DERIVATIVE()
的运行方式相同,但是NON_NEGATIVE_DERIVATIVE()
只返回查询结果中正的变化率和等于0的变化率。
SELECT NON_NEGATIVE_DIFFERENCE( [ * | <field_key> | /<regular_expression>/ ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
NON_NEGATIVE_DIFFERENCE(field_key)
返回field key对应的field value的非负差值。
NON_NEGATIVE_DIFFERENCE(/regular_expression/)
返回与正则表达式匹配的每个field key对应的field value的非负差值。
NON_NEGATIVE_DIFFERENCE(*)
返回在measurement中每个field key对应的field value的非负差值。
NON_NEGATIVE_DIFFERENCE()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用NON_NEGATIVE_DIFFERENCE()
和GROUP BY time()
子句。
请查看DIFFERENCE()
文档中的示例,NON_NEGATIVE_DIFFERENCE()
跟DIFFERENCE()
的运行方式相同,但是NON_NEGATIVE_DIFFERENCE()
只返回查询结果中正的差值和等于0的差值。
SELECT NON_NEGATIVE_DIFFERENCE(<function>( [ * | <field_key> | /<regular_expression>/ ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果之间的非负差值。
NON_NEGATIVE_DIFFERENCE()支持以下嵌套函数:
请查看DIFFERENCE()
文档中的示例,NON_NEGATIVE_DIFFERENCE()
跟DIFFERENCE()
的运行方式相同,但是NON_NEGATIVE_DIFFERENCE()
只返回查询结果中正的差值和等于0的差值。
x
次方。
SELECT POW( [ * | <field_key> ], <x> ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
POW(field_key, x)
返回field key对应的field value的x
次方。
POW(*, x)
返回在measurement中每个field key对应的field value的x
次方。
POW()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用POW()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT POW("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time pow
---- ---
2015-08-18T00:00:00Z 18.148417929216
2015-08-18T00:06:00Z 20.047612231936
2015-08-18T00:12:00Z 16.914992230656004
2015-08-18T00:18:00Z 20.429279055375993
2015-08-18T00:24:00Z 17.352898193760993
2015-08-18T00:30:00Z 17.69549197320101
该查询返回measurement h2o_feet
中field key water_level
对应的field value的4次方。
> SELECT POW(*, 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time pow_water_level
---- ---------------
2015-08-18T00:00:00Z 18.148417929216
2015-08-18T00:06:00Z 20.047612231936
2015-08-18T00:12:00Z 16.914992230656004
2015-08-18T00:18:00Z 20.429279055375993
2015-08-18T00:24:00Z 17.352898193760993
2015-08-18T00:30:00Z 17.69549197320101
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的4次方。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT POW("water_level", 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time pow
---- ---
2015-08-18T00:18:00Z 20.429279055375993
2015-08-18T00:12:00Z 16.914992230656004
2015-08-18T00:06:00Z 20.047612231936
2015-08-18T00:00:00Z 18.148417929216
该查询返回measurement h2o_feet
中field key water_level
对应的field value的4次方,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT POW(<function>( [ * | <field_key> ] ), <x>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的x
次方。
POW()支持以下嵌套函数:
> SELECT POW(MEAN("water_level"), 4) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time pow
---- ---
2015-08-18T00:00:00Z 19.08029760999999
2015-08-18T00:12:00Z 18.609983417041
2015-08-18T00:24:00Z 17.523567165456008
该查询返回每12分钟的时间间隔对应的water_level
的平均值的4次方。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用POW()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的4次方。
SELECT ROUND( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
ROUND(field_key)
返回field key对应的field value四舍五入后的整数。
ROUND(*)
返回在measurement中每个field key对应的field value四舍五入后的整数。
ROUND()
支持数据类型为int64和float64的field value。
基本语法支持group by tags的GROUP BY
子句,但是不支持group by time。请查看高级语法章节了解如何使用ROUND()
和GROUP BY time()
子句。
下面的示例将使用示例数据中的如下数据:
> SELECT "water_level" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time water_level
---- -----------
2015-08-18T00:00:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT ROUND("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time round
---- -----
2015-08-18T00:00:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:18:00Z 2
2015-08-18T00:24:00Z 2
2015-08-18T00:30:00Z 2
该查询返回measurement h2o_feet
中field key water_level
对应的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:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:18:00Z 2
2015-08-18T00:24:00Z 2
2015-08-18T00:30:00Z 2
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value四舍五入后的整数。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT ROUND("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time round
---- -----
2015-08-18T00:18:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:06:00Z 2
2015-08-18T00:00:00Z 2
该查询返回measurement h2o_feet
中field key water_level
对应的field value四舍五入后的整数,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT ROUND(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果四舍五入后的整数。
ROUND()支持以下嵌套函数:
> SELECT ROUND(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time round
---- -----
2015-08-18T00:00:00Z 2
2015-08-18T00:12:00Z 2
2015-08-18T00:24:00Z 2
该查询返回每12分钟的时间间隔对应的water_level
的平均值四舍五入后的整数。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用ROUND()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值四舍五入后的整数。
SELECT SIN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SIN(field_key)
返回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:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT SIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time sin
---- ---
2015-08-18T00:00:00Z 0.8808206017241819
2015-08-18T00:06:00Z 0.8550216851706579
2015-08-18T00:12:00Z 0.8972904165810275
2015-08-18T00:18:00Z 0.8497930984115993
2015-08-18T00:24:00Z 0.8914760289023131
2015-08-18T00:30:00Z 0.8869008523376968
该查询返回measurement h2o_feet
中field key water_level
对应的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:00Z 0.8808206017241819
2015-08-18T00:06:00Z 0.8550216851706579
2015-08-18T00:12:00Z 0.8972904165810275
2015-08-18T00:18:00Z 0.8497930984115993
2015-08-18T00:24:00Z 0.8914760289023131
2015-08-18T00:30:00Z 0.8869008523376968
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的正弦值。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT SIN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time sin
---- ---
2015-08-18T00:18:00Z 0.8497930984115993
2015-08-18T00:12:00Z 0.8972904165810275
2015-08-18T00:06:00Z 0.8550216851706579
2015-08-18T00:00:00Z 0.8808206017241819
该查询返回measurement h2o_feet
中field key water_level
对应的field value的正弦值,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT SIN(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的正弦值。
SIN()支持以下嵌套函数:
> SELECT SIN(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time sin
---- ---
2015-08-18T00:00:00Z 0.8682145834456126
2015-08-18T00:12:00Z 0.8745914945253902
2015-08-18T00:24:00Z 0.8891995555912935
该查询返回每12分钟的时间间隔对应的water_level
的平均值的正弦值。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用SIN()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的正弦值。
SELECT SQRT( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
SQRT(field_key)
返回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:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT SQRT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time sqrt
---- ----
2015-08-18T00:00:00Z 1.4366627996854378
2015-08-18T00:06:00Z 1.4546477236774544
2015-08-18T00:12:00Z 1.4240786495134319
2015-08-18T00:18:00Z 1.4580809305384939
2015-08-18T00:24:00Z 1.4286357128393508
2015-08-18T00:30:00Z 1.4321312788986909
该查询返回measurement h2o_feet
中field key water_level
对应的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:00Z 1.4366627996854378
2015-08-18T00:06:00Z 1.4546477236774544
2015-08-18T00:12:00Z 1.4240786495134319
2015-08-18T00:18:00Z 1.4580809305384939
2015-08-18T00:24:00Z 1.4286357128393508
2015-08-18T00:30:00Z 1.4321312788986909
该查询返回measurement h2o_feet
中每个存储数值的field key对应的field value的平方根。measurement h2o_feet
中只有一个数值类型的field:water_level
。
> SELECT SQRT("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' ORDER BY time DESC LIMIT 4 OFFSET 2
name: h2o_feet
time sqrt
---- ----
2015-08-18T00:18:00Z 1.4580809305384939
2015-08-18T00:12:00Z 1.4240786495134319
2015-08-18T00:06:00Z 1.4546477236774544
2015-08-18T00:00:00Z 1.4366627996854378
该查询返回measurement h2o_feet
中field key water_level
对应的field value的平方根,它涵盖的时间范围在2015-08-18T00:00:00Z
和2015-08-18T00:30:00Z
之间,并且以递减的时间戳顺序返回结果,同时,该查询将返回的数据点个数限制为4,并将返回的数据点偏移两个(即前两个数据点不返回)。
SELECT SQRT(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的平方根。
SQRT()支持以下嵌套函数:
> SELECT SQRT(MEAN("water_level")) FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time sqrt
---- ----
2015-08-18T00:00:00Z 1.445683229480096
2015-08-18T00:12:00Z 1.4411800720243115
2015-08-18T00:24:00Z 1.430384563675098
该查询返回每12分钟的时间间隔对应的water_level
的平均值的平方根。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用SQRT()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的平方根。
SELECT TAN( [ * | <field_key> ] ) [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
TAN(field_key)
返回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:00Z 2.064
2015-08-18T00:06:00Z 2.116
2015-08-18T00:12:00Z 2.028
2015-08-18T00:18:00Z 2.126
2015-08-18T00:24:00Z 2.041
2015-08-18T00:30:00Z 2.051
> SELECT TAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica'
name: h2o_feet
time tan
---- ---
2015-08-18T00:00:00Z -1.8604293534384375
2015-08-18T00:06:00Z -1.6487359603347427
2015-08-18T00:12:00Z -2.0326408012302273
2015-08-18T00:18:00Z -1.6121545688343464
2015-08-18T00:24:00Z -1.9676434782626282
2015-08-18T00:30:00Z -1.9198657720074992
该查询返回measurement h2o_feet
中field key water_level
对应的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
。
> 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(<function>( [ * | <field_key> ] )) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
高级语法需要一个GROUP BY time()
子句和一个嵌套的InfluxQL函数。查询首先计算在指定的GROUP BY time()
间隔内嵌套函数的结果,然后计算这些结果的正切值。
TAN()支持以下嵌套函数:
> 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
的平均值的正切值。
为了得到这些结果,TSDB For InfluxDB®首先计算每12分钟的时间间隔对应的water_level
的平均值。这一步跟同时使用MEAN()
函数和GROUP BY time()
子句、但不使用TAN()
的情形一样:
> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' AND "location" = 'santa_monica' GROUP BY time(12m)
name: h2o_feet
time mean
---- ----
2015-08-18T00:00:00Z 2.09
2015-08-18T00:12:00Z 2.077
2015-08-18T00:24:00Z 2.0460000000000003
然后,TSDB For InfluxDB®计算这些平均值的正切值。
HOLT_WINTERS()
可用于:
SELECT HOLT_WINTERS[_WITH-FIT](<function>(<field_key>),<N>,<S>) [INTO_clause] FROM_clause [WHERE_clause] GROUP_BY_clause [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause]
HOLT_WINTERS(function(field_key),N,S)
返回field key对应的N
个季节性调整的预测field value。
N
个预测值出现的时间间隔跟group by time时间间隔相同。如果您的GROUP BY time()
时间间隔是6m
并且N
等于3
,那么您将会得到3个时间间隔为6分钟的预测值。
S
是一个季节性模式参数,并且根据GROUP BY time()
时间间隔限定一个季节性模式的长度。如果您的GROUP BY time()
时间间隔是2m
并且S
等于3
,那么这个季节性模式每六分钟出现一次,也就是每三个数据点。如果您不希望季节性调整您的预测值,请将S
设置为0
或1
。
HOLT_WINTERS_WITH_FIT(function(field_key),N,S)
除了返回field key对应的N
个季节性调整的预测field value,还返回拟合值。
HOLT_WINTERS()
和HOLT_WINTERS_WITH_FIT()
处理以相同的时间间隔出现的数据;嵌套的InfluxQL函数和GROUP BY time()
子句确保Holt-Winters函数能够对常规数据进行操作。
HOLT_WINTERS()
和HOLT_WINTERS_WITH_FIT()
支持数据类型为int64和float64的field value。
原始数据
示例一使用了Chronograf来可视化数据。该示例重点关注NOAA_water_database
数据集的如下数据:
SELECT "water_level" FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-08-22 22:12:00' AND time <= '2015-08-28 03:00:00'
步骤一:匹配原始数据的趋势
编写一个GROUP BY time()
查询,使得它匹配原始water_level
数据的总体趋势。这里,我们使用了FIRST()
函数:
SELECT FIRST("water_level") FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' and time >= '2015-08-22 22:12:00' and time <= '2015-08-28 03:00:00' GROUP BY time(379m,348m)
在GROUP BY time()
子句中,第一个参数(379m
)匹配water_level
数据中每个波峰和波谷之间发生的时间长度,第二个参数(348m
)是一个偏移间隔,它通过改变TSDB For InfluxDB®的默认GROUP BY time()
边界来匹配原始数据的时间范围。
蓝线显示了查询结果:
步骤二:确定季节性模式
使用步骤一中查询的信息确定数据中的季节性模式。
关注下图中的蓝线,water_level
数据中的模式大约每25小时15分钟重复一次。每个季节有四个数据点,所以4
是季节性模式参数。
步骤三:应用HOLT_WINTERS()
函数
在查询中加入Holt-Winters函数。这里,我们使用HOLT_WINTERS_WITH_FIT()
来查看拟合值和预测值:
SELECT HOLT_WINTERS_WITH_FIT(FIRST("water_level"),10,4) FROM "NOAA_water_database"."autogen"."h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-08-22 22:12:00' AND time <= '2015-08-28 03:00:00' GROUP BY time(379m,348m)
在HOLT_WINTERS_WITH_FIT()
函数中,第一个参数(10
)请求10个预测的field value。每个预测的数据点相距379m
,与GROUP BY time()
子句中的第一个参数相同。HOLT_WINTERS_WITH_FIT()
函数中的第二个参数(4
)是我们在上一步骤中确定的季节性模式。
蓝线显示了查询结果:
HOLT_WINTERS()
的常见问题HOLT_WINTERS()
和收到的数据点少于”N”个在某些情况下,用户可能会收到比参数N
请求的更少的预测数据点。当数学计算不稳定和不能预测更多数据点时,这种情况就会发生。这意味着该数据集不适合使用HOLT_WINTERS()
,或者,季节性调整参数是无效的并且是算法混乱。
下面技术分析的函数将广泛使用的算法应用在您的数据中。虽然这些函数主要应用在金融和投资领域,但是它们也适用于其它行业和用例。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE()
KAUFMANS_ADAPTIVE_MOVING_AVERAGE()
TRIPLE_EXPONENTIAL_MOVING_AVERAGE()
TRIPLE_EXPONENTIAL_DERIVATIVE()
除了field key,技术分析函数还接受以下参数:
必需,整数,min=1
算法的样本大小。这基本上是对算法的输出有显著影响的历史样本的数量。例如,2
表示当前的数据点和前一个数据点。算法使用指数衰减率来决定历史数据点的权重,通常称为alpha(α)
。参数PERIOD
控制衰减率。
请注意,历史数据点仍然可以产生影响。
整数,min=-1
算法需要多少个样本才会开始发送结果。默认值-1
表示该参数的值基于算法、PERIOD
和WARMUP_TYPE
,但是这是一个可以使算法发送有意义的结果的值。
默认的Hold Periods:
对于大多数提供的技术分析,HOLD_PERIOD
的默认值由您使用的技术分析算法和WARMUP_TYPE
决定。
算法 \ Warmup Type | simple | exponential | none |
---|---|---|---|
EXPONENTIAL_MOVING_AVERAGE | PERIOD - 1 | PERIOD - 1 | n/a |
DOUBLE_EXPONENTIAL_MOVING_AVERAGE | ( PERIOD - 1 ) * 2 | PERIOD - 1 | n/a |
TRIPLE_EXPONENTIAL_MOVING_AVERAGE | ( PERIOD - 1 ) * 3 | PERIOD - 1 | n/a |
TRIPLE_EXPONENTIAL_DERIVATIVE | ( PERIOD - 1 ) * 3 + 1 | PERIOD | n/a |
RELATIVE_STRENGTH_INDEX | PERIOD | PERIOD | n/a |
CHANDE_MOMENTUM_OSCILLATOR | PERIOD | PERIOD | PERIOD - 1 |
Kaufman算法默认的Hold Periods:
算法 | 默认的Hold Period |
---|---|
KAUFMANS_EFFICIENCY_RATIO() | PERIOD |
KAUFMANS_ADAPTIVE_MOVING_AVERAGE() | PERIOD |
默认=”exponential”
这个参数控制算法如何为第一个PERIOD
样本初始化自身,它本质上是具有不完整样本集的持续时间。
simple
第一个PERIOD
样本的简单移动平均值(simple moving average,SMA)。这是ta-lib使用的方法。
exponential
具有缩放alpha(α)的指数移动平均值(exponential moving average,EMA)。基本上是这样使用EMA:PERIOD=1
用于第一个点,PERIOD=2
用于第二个点,以此类推,直至算法已经消耗了PERIOD
个数据点。由于算法一开始就使用了EMA,当使用此方法并且没有指定HOLD_PERIOD
的值或HOLD_PERIOD
的值为-1
时,算法可能会在比simple
小得多的样本大小的情况下开始发送数据点。
none
算法不执行任何的平滑操作。这是ta-lib使用的方法。当使用此方法并且没有指定HOLD_PERIOD
时,HOLD_PERIOD
的默认值是PERIOD - 1
。
类型
none
仅适用于CHANDE_MOMENTUM_OSCILLATOR()
函数。
CHANDE_MOMENTUM_OSCILLATOR([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>, [warmup_type]])
可用的参数:
period
hold_period (可选的)
warmup_type (可选的)
CHANDE_MOMENTUM_OSCILLATOR(field_key, 2)
返回使用CMO算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
CHANDE_MOMENTUM_OSCILLATOR(field_key, 10, 9, 'none')
返回使用CMO算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为9,warmup type设为none
。
CHANDE_MOMENTUM_OSCILLATOR(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用CMO算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在CHANDE_MOMENTUM_OSCILLATOR()
函数中调用聚合函数。
CHANDE_MOMENTUM_OSCILLATOR(/regular_expression/, 2)
返回使用CMO算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
CHANDE_MOMENTUM_OSCILLATOR(*, 2)
返回使用CMO算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
CHANDE_MOMENTUM_OSCILLATOR()
支持数据类型为int64和float64的field value。
EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用的参数:
period
hold_period (可选的)
warmup_type (可选的)
EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回使用EMA算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回使用EMA算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为9,warmup type设为exponential
。
EXPONENTIAL_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用EMA算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在EXPONENTIAL_MOVING_AVERAGE()
函数中调用聚合函数。
EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回使用EMA算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回使用EMA算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
EXPONENTIAL_MOVING_AVERAGE()
支持数据类型为int64和float64的field value。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用的参数:
period
hold_period (可选的)
warmup_type (可选的)
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回使用DEMA算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回使用DEMA算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为9,warmup type设为exponential
。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用DEMA算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在DOUBLE_EXPONENTIAL_MOVING_AVERAGE()
函数中调用聚合函数。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回使用DEMA算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回使用DEMA算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
DOUBLE_EXPONENTIAL_MOVING_AVERAGE()
支持数据类型为int64和float64的field value。
ER跟Chande Momentum Oscillator (CMO)非常类似。不同的是,CMO将市场方向考虑在内,但是如果您将CMO的绝对值除以100,就可以得到ER。
KAUFMANS_EFFICIENCY_RATIO([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>])
可用的参数:
period
hold_period (可选的)
KAUFMANS_EFFICIENCY_RATIO(field_key, 2)
返回使用效率指数(Efficiency Index)算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_EFFICIENCY_RATIO(field_key, 10, 10)
返回使用效率指数算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为10。
KAUFMANS_EFFICIENCY_RATIO(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用效率指数算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在KAUFMANS_EFFICIENCY_RATIO()
函数中调用聚合函数。
KAUFMANS_EFFICIENCY_RATIO(/regular_expression/, 2)
返回使用效率指数算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_EFFICIENCY_RATIO(*, 2)
返回使用效率指数算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_EFFICIENCY_RATIO()
支持数据类型为int64和float64的field value。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period>])
可用的参数:
period
hold_period (可选的)
warmup_type (可选的)
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(field_key, 2)
返回使用KAMA算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(field_key, 10, 10)
返回使用KAMA算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为10。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用KAMA算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在KAUFMANS_ADAPTIVE_MOVING_AVERAGE()
函数中调用聚合函数。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(/regular_expression/, 2)
返回使用KAMA算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE(*, 2)
返回使用KAMA算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period。
KAUFMANS_ADAPTIVE_MOVING_AVERAGE()
支持数据类型为int64和float64的field value。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用的参数:period
hold_period (可选的)
warmup_type (可选的)
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 2)
返回使用TEMA算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(field_key, 10, 9, 'exponential')
返回使用TEMA算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为9,warmup type设为exponential
。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用TEMA算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在TRIPLE_EXPONENTIAL_MOVING_AVERAGE()
函数中调用聚合函数。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(/regular_expression/, 2)
返回使用TEMA算法处理与正则表达式匹配的每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE(*, 2)
返回使用TEMA算法处理measurement中每个field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
TRIPLE_EXPONENTIAL_MOVING_AVERAGE()
支持数据类型为int64和float64的field value。
跟很多振荡器一样,TRIX围绕着零线震荡。当它用作振荡器时,正数表示炒买超买市场,而负数表示超卖市场。当它用作动量指标时,正数表示动量在增加,而负数表示动量在减少。很多分析师认为,当TRIX超过零线时,它会给出买入信号,当低于零线时,它会给出卖出信号。
TRIPLE_EXPONENTIAL_DERIVATIVE([ * | <field_key> | /regular_expression/ ], <period>[, <hold_period)[, <warmup_type]])
可用的参数:period
hold_period (可选的)
warmup_type (可选的)
TRIPLE_EXPONENTIAL_DERIVATIVE(field_key, 2)
返回使用三重指数导数算法处理field key对应的field value后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
TRIPLE_EXPONENTIAL_DERIVATIVE(field_key, 10, 10, 'exponential')
返回使用三重指数导数算法处理field key对应的field value后的结果,该算法中,period设为10,hold period设为10,warmup type设为exponential
。
TRIPLE_EXPONENTIAL_DERIVATIVE(MEAN(<field_key>), 2) ... GROUP BY time(1d)
返回使用三重指数导数算法处理field key对应的field value平均值后的结果,该算法中,period设为2,使用默认的hold period和warmup type。
注释:当使用
GROUP BY
子句将数据进行聚合时,您必须在