influxDB 1.8 笔记（更新中）网站首页 技术杂谈

influxDB 1.8 笔记（更新中）

weixin_41827053 2024-10-11 00:01:03

简介influxDB 1.8 笔记（更新中）

1、InfluxDB基本数据结构

数据结构	含义
database	数据库
measurement	数据库中的表
retention policy	保存策略：让InfluxDB能够知道可以丢弃哪些数据，设置数据自动清除时间，从而更高效的处理数据
points	表里面的一行数据

points的数据结构

数据结构	含义
time	每个数据记录时间，是数据库中的主索引(会自动生成)
fields	各种记录值（没有索引的属性）也就是记录的值
tags	各种有索引的属性
series	表示这个表里面的数据，可以在图表上画成几条线：通过tags排列组合算出来。

2、InfluxQL语法

2.1 SELECT语句

SELECT语句从一个或多个measurement中查询数据。

SELECT <field_key>[,<field_key>,<tag_key>] FROM <measurement_name>[,<measurement_name>]

SELECT语句需要一个SELECT子句和一个FROM子句。

SELECT子句

SELECT子句支持多种指定数据的格式：
SELECT * 返回所有的field和tag。
SELECT “<field_key>” 返回一个特定的field。
SELECT “<field_key>”,“<field_key>” 返回多个field。
SELECT “<field_key>”,“<tag_key>” 返回一个特定的field和一个特定的tag，当SELECT子句包含tag时，它必须至少指定一个field。
SELECT “<field_key>”::field,“<tag_key>”::tag 返回一个特定的field和一个特定的tag。::[field | tag]语法指定了标识符的类型，使用这个语法是为了区分具有相同名字的field key和tag key。
除此之外，SELECT子句支持的功能还有：算术运算、函数、转换操作和正则表达式。

FROM子句

FROM子句支持多种指定measurement的格式：

FROM <measurement_name>从一个measurement中返回数据。如果您使用CLI查询数据，那么访问的measurement属于USE指定的数据库，并且使用的是默认保留策略。如果您使用的是HTTP API，那么measurement属于参数db指定的数据库，同样，使用的是默认（DEFAULT）的保留策略。

FROM <measurement_name>,<measurement_name>从多个measurement中返回数据。

FROM <database_name>.<retention_policy_name>.<measurement_name>从一个被完全限定的measurement中返回数据。通过明确指定measurement的数据库和保留策略来完全限定一个measurement。

FROM <database_name>…<measurement_name>从用户指定的一个数据库并使用默认保留策略的measurement中返回数据。

除此之外，FROM子句还支持的功能：正则表达式。

引号

如果标识符包含除了[A-z，0-9，_]之外的字符，或者以数字开头，又或者是InfluxQL关键字，那么它们必须使用双引号。虽然并不总是需要，但是我们建议您为标识符加上双引号。

说明这里关于引号的语法与行协议中的不同。

示例

查询单个measurement中的所有field和tag

SELECT * FROM "h2o_feet"

name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica   2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica   4.938

该语句从h2o_feet这个measurement中查询所有的field和tag。
如果您使用CLI，请确保在执行上面的查询前，先输入USE NOAA_water_database，CLI将查询被USE指定的数据库并且保留策略是默认的数据。如果您使用的是HTTP API，那么请确保将参数db设为NOAA_water_database，如果没有设置参数rp，那么HTTP API将自动使用该数据库的默认保留策略。

查询单个measurement中的特定的field和tag

SELECT "level description","location","water_level" FROM "h2o_feet"

name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica   2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica   4.938

该查询选择了两个field：level description和water_level，和一个tag：location。

说明 当SELECT子句包含tag时，它必须至少指定一个field。

查询单个measurement中的带标识符类型的特定的field和tag

SELECT "level description"::field,"location"::tag,"water_level"::field FROM "h2o_feet"

name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica   2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica   4.938

该查询选择了两个field：level description和water_level，和一个tag：location。::[field | tag]语法明确指出了该标识符是field还是tag。当field key和tag key的名字相同时，请使用::[field | tag]来区分它们。大多数情况下，并不需要使用该语法。

查询单个measurement中的所有field

SELECT *::field FROM "h2o_feet"

name: h2o_feet
--------------
time                   level description      water_level
2015-08-18T00:00:00Z   below 3 feet           2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   4.938

该查询从h2o_feet中选择了所有的field。SELECT子句支持将*和::这两个语法结合使用。

查询单个measurement中的特定的field并进行基本运算

SELECT ("water_level"*2)+4 from "h2o_feet"

name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z20.24
2015-08-18T00:00:00Z8.128
[...]
2015-09-18T21:36:00Z14.132
2015-09-18T21:42:00Z13.876

查询多个measurement中的所有数据

SELECT * FROM "h2o_feet","h2o_pH"

name: h2o_feet
--------------
time                   level description      location       pH   water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica        2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek        8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica        5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica        4.938

name: h2o_pH
------------
time                   level description   location       pH   water_level
2015-08-18T00:00:00Z                       santa_monica   6
2015-08-18T00:00:00Z                       coyote_creek   7
[...]
2015-09-18T21:36:00Z                       santa_monica   8
2015-09-18T21:42:00Z                       santa_monica   7

该查询从两个measurement（h2o_feet和h2o_pH）中选择所有的field和tag，多个measurement之间用逗号（,）隔开。

查询完全限定的measurement中的所有数据

SELECT * FROM "NOAA_water_database"."autogen"."h2o_feet"

name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica   2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica   4.938

该查询从h2o_feet中选择了所有数据，h2o_feet是属于数据库NOAA_water_database和保留策略autogen的measurement。

如果使用CLI，可以用这种完全限定measurement的方式来代替USE指定的数据库和指定DEFAULT之外的保留策略。如果使用HTTP API，可以通过完全限定measurement的方式，代替设置参数db和rp。

查询特定数据库的measurement中的所有数据

SELECT * FROM "NOAA_water_database".."h2o_feet"

name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   below 3 feet           santa_monica   2.064
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
[...]
2015-09-18T21:36:00Z   between 3 and 6 feet   santa_monica   5.066
2015-09-18T21:42:00Z   between 3 and 6 feet   santa_monica   4.938

该查询从h2o_feet中选择了所有数据，h2o_feet是属于数据库NOAA_water_database和默认（DEFAULT）保留策略的measurement。…表示指定数据库的默认保留策略。

如果使用CLI，可以这种指定数据库的方式来代替USE指定的数据库。如果使用HTTP API，同样可以通过指定数据库，代替设置参数db。

SELECT语句的常见问题

在SELECT子句中查询tag key

一个查询在SELECT子句中必须至少包含一个field key才能返回结果。如果SELECT子句中只包含一个或多个tag key，那么该查询会返回一个空的结果。这种返回结果的要求是系统存储数据的方式导致的。

示例

下面的查询不返回任何数据，因为它在SELECT子句中只给定了一个tag key（location）：

SELECT "location" FROM "h2o_feet"

想要返回跟tag key location相关的数据，查询中的SELECT子句必须至少包含一个field key（water_level）：

SELECT "water_level","location" FROM "h2o_feet" LIMIT 3
name: h2o_feet
time                   water_level  location
-----------------------
2015-08-18T00:00:00Z8.12         coyote_creek
2015-08-18T00:00:00Z2.064        santa_monica
[...]
2015-09-18T21:36:00Z5.066        santa_monica
2015-09-18T21:42:00Z4.938        santa_monica

2.2 WHERE语句

WHERE子句根据field、tag和/或timestamp来过滤数据。

SELECT_clause FROM_clause WHERE <conditional_expression> [(AND|OR) <conditional_expression> […]]

WHERE子句支持在field、tag和timestamp上的条件表达式（conditional_expression）。

field

field_key [‘string’ | boolean | float | integer]

WHERE子句支持对field value进行比较，field value可以是字符串、布尔值、浮点数或者整数。
在WHERE子句中，请对字符串类型的field value用单引号括起来。如果字符串类型的field value没有使用引号或者使用了双引号，那么不会返回任何查询结果，在大多数情况下，也不会返回错误。支持的操作符：

操作符	含义
=	等于
<>	不等于
!=	不等于
>	大于
>=	大于或等于
<	小于
<=	小于或等于

除此之外，还支持的功能：算术运算和正则表达式。

tag

tag_key [‘tag_value’]

在WHERE子句中，请对tag value用单引号括起来。如果tag value没有使用引号或者使用了双引号，那么不会返回任何查询结果，在大多数情况下，也不会返回错误。支持的操作符：

操作符	含义
=	等于
<>	不等于
!=	不等于

除此之外，还支持的功能：算术运算和正则表达式。

timestamp

对于大多数SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到2262-04-11T23:47:16.854775806Z UTC。对于带GROUP BY time()子句的SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到now()。

示例

查询field value满足一定条件的数据。

> SELECT * FROM "h2o_feet" WHERE "water_level" > 8
name: h2o_feet
--------------
time                   level description      location       water_level
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12
2015-08-18T00:06:00Z   between 6 and 9 feet   coyote_creek   8.005
[...]
2015-09-18T00:12:00Z   between 6 and 9 feet   coyote_creek   8.189
2015-09-18T00:18:00Z   between 6 and 9 feet   coyote_creek   8.084

该查询返回h2o_feet中的数据，这些数据满足条件：field key water_level的值大于8。

查询field value满足一定条件的数据（field value是字符串类型）

> SELECT * FROM "h2o_feet" WHERE "level description" = 'below 3 feet'
name: h2o_feet
--------------
time                   level description   location       water_level
2015-08-18T00:00:00Z   below 3 feet        santa_monica   2.064
2015-08-18T00:06:00Z   below 3 feet        santa_monica   2.116
[...]
2015-09-18T14:06:00Z   below 3 feet        santa_monica   2.999
2015-09-18T14:36:00Z   below 3 feet        santa_monica   2.907

该查询返回h2o_feet中的数据，这些数据满足条件：field key level description的值等于字符串below 3 feet。在WHERE子句中，需要用单引号将字符串类型的field value括起来。

查询field value满足一定条件的数据（WHERE子句包含基本运算）

> SELECT * FROM "h2o_feet" WHERE "water_level" + 2 > 11.9
name: h2o_feet
--------------
time                   level description           location       water_level
2015-08-29T07:06:00Z   at or greater than 9 feet   coyote_creek   9.902
2015-08-29T07:12:00Z   at or greater than 9 feet   coyote_creek   9.938
2015-08-29T07:18:00Z   at or greater than 9 feet   coyote_creek   9.957
2015-08-29T07:24:00Z   at or greater than 9 feet   coyote_creek   9.964
2015-08-29T07:30:00Z   at or greater than 9 feet   coyote_creek   9.954
2015-08-29T07:36:00Z   at or greater than 9 feet   coyote_creek   9.941
2015-08-29T07:42:00Z   at or greater than 9 feet   coyote_creek   9.925
2015-08-29T07:48:00Z   at or greater than 9 feet   coyote_creek   9.902
2015-09-02T23:30:00Z   at or greater than 9 feet   coyote_creek   9.902

该查询返回h2o_feet中的数据，这些数据满足条件：field key water_level的值加上2大于11.9。请注意，InfluxDB®遵循标准的算术运算顺序。可查看数学运算符章节了解更多相关信息。

查询tag value满足一定条件的数据

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica'
name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
[...]
2015-09-18T21:36:00Z   5.066
2015-09-18T21:42:00Z   4.938

该查询返回h2o_feet中的数据，这些数据满足条件：tag key location的值是santa_monica。在WHERE子句中，需要用单引号将字符串类型的tag value括起来。

查询field value和tag value都满足一定条件的数据

> SELECT "water_level" FROM "h2o_feet" WHERE "location" <> 'santa_monica' AND ("water_level" < -0.59 OR "water_level" > 9.95)
name: h2o_feet
--------------
time                   water_level
2015-08-29T07:18:00Z   9.957
2015-08-29T07:24:00Z   9.964
2015-08-29T07:30:00Z   9.954
2015-08-29T14:30:00Z   -0.61
2015-08-29T14:36:00Z   -0.591
2015-08-30T15:18:00Z   -0.594

该查询返回h2o_feet中的数据，这些数据满足条件：tag key location的值不等于santa_monica，并且，field key water_level的值小于-0.59或大于9.95。WHERE子句支持操作符AND和OR，并支持用括号将它们的逻辑分开。

查询timestamp满足一定条件的数据

> SELECT * FROM "h2o_feet" WHERE time > now() - 7d

该查询返回h2o_feet中的数据，这些数据满足条件：timestamp在过去7天内。本页面中的时间语法章节将详细介绍WHERE子句中支持的时间语法。

WHERE子句的常见问题

WHERE子句出现异常则没有结果返回

在大多数情况下，引起这个问题的原因是tag value或字符串类型的field value缺少单引号。如果tag value或字符串类型的field value没有使用引号或者使用了双引号，那么不会返回任何查询结果，在大多数情况下，也不会返回错误。

下面的代码块中，前两个查询分别尝试没有用引号或者尝试用双引号来指定tag value：santa_monica，这两个查询不会返回任何结果。第三个查询使用了单引号将santa_monica括起来（这是支持的语法），返回了预期的结果。

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = santa_monica
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = "santa_monica"
> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica'
name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z   2.064
[...]
2015-09-18T21:42:00Z   4.938

下面的代码块中，前两个查询分别尝试没有用引号或者尝试用双引号来指定字符串类型的field value：at or greater than 9 feet。第一个查询返回错误，因为该field value包含空格。第二个查询没有返回任何结果。第三个查询使用了单引号将at or greater than 9 feet括起来（这是支持的语法），返回了预期的结果。


> SELECT "level description" FROM "h2o_feet" WHERE "level description" = at or greater than 9 feet
ERR: error parsing query: found than, expected ; at line 1, char 86
> SELECT "level description" FROM "h2o_feet" WHERE "level description" = "at or greater than 9 feet"
> SELECT "level description" FROM "h2o_feet" WHERE "level description" = 'at or greater than 9 feet'
name: h2o_feet
--------------
time                   level description
2015-08-26T04:00:00Z   at or greater than 9 feet
[...]
2015-09-15T22:42:00Z   at or greater than 9 feet

2.3 GROUP BY子句

GROUP BY子句按用户指定的tag或者时间区间对查询结果进行分组

GROUP BY tags

GROUP BY 按用户指定的tag对查询结果进行分组。

SELECT_clause FROM_clause [WHERE_clause] GROUP BY [*|<tag_key>[,<tag_key]]

GROUP BY * 按所有tag对查询结果进行分组。
GROUP BY <tag_key>按指定的一个tag对查询结果进行分组。
GROUP BY <tag_key>,<tag_key>按多个tag对查询结果进行分组，tag key的顺序对结果无影响。
如果查询语句中包含一个WHERE子句，那么GROUP BY子句必须放在该WHERE子句后面。

除此之外，GROUP BY子句还支持的功能：正则表达式。

示例

按单个tag对查询结果进行分组

 SELECT MEAN("water_level") FROM "h2o_feet" GROUP BY "location"

name: h2o_feet
tags: location=coyote_creek
time                     mean
--------
1970-01-01T00:00:00Z5.359342451341401


name: h2o_feet
tags: location=santa_monica
time                     mean
--------
1970-01-01T00:00:00Z3.530863470081006

该查询使用了InfluxQL中的一个函数计算measurement h2o_feet中每个location的water_level的平均值。 InfluxDB®返回两个序列的结果：每个location的值对应一个序列。

按多个tag对查询结果进行分组

 SELECT MEAN("index") FROM "h2o_quality" GROUP BY location,randtag

name: h2o_quality
tags: location=coyote_creek, randtag=1
time                  mean
--------
1970-01-01T00:00:00Z50.69033760186263

name: h2o_quality
tags: location=coyote_creek, randtag=2
time                   mean
--------
1970-01-01T00:00:00Z49.661867544220485

name: h2o_quality
tags: location=coyote_creek, randtag=3
time                   mean
--------
1970-01-01T00:00:00Z49.360939907550076

name: h2o_quality
tags: location=santa_monica, randtag=1
time                   mean
--------
1970-01-01T00:00:00Z49.132712456344585

name: h2o_quality
tags: location=santa_monica, randtag=2
time                   mean
--------
1970-01-01T00:00:00Z50.2937984496124

name: h2o_quality
tags: location=santa_monica, randtag=3
time                   mean
--------
1970-01-01T00:00:00Z49.99919903884662

该查询使用了InfluxQL中的一个函数计算measurement h2o_quality中每个location和randtag的组合的index的平均值，其中，location有2个不同的值，randtag有3个不同的值，总共有6个不同的组合。在GROUP BY子句中，用逗号将多个tag隔开。

按所有tag对查询结果进行分组

 SELECT MEAN("index") FROM "h2o_quality" GROUP BY *

name: h2o_quality
tags: location=coyote_creek, randtag=1
time                  mean
--------
1970-01-01T00:00:00Z50.69033760186263

name: h2o_quality
tags: location=coyote_creek, randtag=2
time                   mean
--------
1970-01-01T00:00:00Z49.661867544220485

name: h2o_quality
tags: location=coyote_creek, randtag=3
time                   mean
--------
1970-01-01T00:00:00Z49.360939907550076

name: h2o_quality
tags: location=santa_monica, randtag=1
time                   mean
--------
1970-01-01T00:00:00Z49.132712456344585

name: h2o_quality
tags: location=santa_monica, randtag=2
time                   mean
--------
1970-01-01T00:00:00Z50.2937984496124

name: h2o_quality
tags: location=santa_monica, randtag=3
time                   mean
--------
1970-01-01T00:00:00Z49.99919903884662

该查询使用了InfluxQL中的一个函数计算measurement h2o_quality中每个tag的组合的index的平均值。

说明该查询的结果与上面例子中的查询结果相同，这是因为在h2o_quality中，只有两个tag key：location和randtag。

GROUP BY time intervals

GROUP BY time() 按用户指定的时间间隔对查询结果进行分组。

SELECT (<field_key>) FROM_clause WHERE <time_range> GROUP BY time(<time_interval>),[tag_key][fill(<fill_option>)]

基本的GROUP BY time()查询需要在SELECT子句中包含一个InfluxQL函数，并且在WHERE子句中包含时间范围。请注意，GROUP BY子句必须放在WHERE子句后面。
time(time_interval)：子句中的time_interval（时间间隔）是一个持续时间（duration），决定了InfluxDB按多大的时间间隔将查询结果进行分组。例如，当time_interval为5m时，那么在WHERE子句中指定的时间范围内，将查询结果按5分钟进行分组。
fill(<fill_option>)：可选，它会改变不含数据的时间间隔的返回值。

覆盖范围

基本的GROUP BY time()查询依赖time_interval和 InfluxDB 的预设时间边界来确定每个时间间隔内的原始数据和查询返回的时间戳。

基本语法示例

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

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

name: h2o_feet
--------------
time                   water_level   location
2015-08-18T00:00:00Z8.12          coyote_creek
2015-08-18T00:00:00Z2.064         santa_monica
2015-08-18T00:06:00Z8.005         coyote_creek
2015-08-18T00:06:00Z2.116         santa_monica
2015-08-18T00:12:00Z7.887         coyote_creek
2015-08-18T00:12:00Z2.028         santa_monica
2015-08-18T00:18:00Z7.762         coyote_creek
2015-08-18T00:18:00Z2.126         santa_monica
2015-08-18T00:24:00Z7.635         coyote_creek
2015-08-18T00:24:00Z2.041         santa_monica
2015-08-18T00:30:00Z7.5           coyote_creek
2015-08-18T00:30:00Z2.051         santa_monica

将查询结果按12分钟的时间间隔进行分组

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

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

该查询使用了InfluxQL中的一个函数计算measurement h2o_feet中location = coyote_creek的water_level的数据点数，并将结果按12分钟为间隔进行分组。

每个时间戳所对应的结果代表一个12分钟间隔所对应的结果。第一个时间戳的计数（count）涵盖了从2015-08-18T00:00:00Z到2015-08-18T00:12:00Z的原始数据（不包括2015-08-18T00:12:00Z）。第二个时间戳的计数涵盖了从2015-08-18T00:12:00Z到2015-08-18T00:24:00的原始数据（不包括2015-08-18T00:24:00）。

将查询结果按12分钟的时间间隔和一个tag key进行分组

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

name: h2o_feet
tags: location=coyote_creek
time                   count
---------
2015-08-18T00:00:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:24:00Z2

name: h2o_feet
tags: location=santa_monica
time                   count
---------
2015-08-18T00:00:00Z2
2015-08-18T00:12:00Z2
2015-08-18T00:24:00Z2

该查询使用了InfluxQL中的一个函数计算water_level的数据点数，并将结果按tag location和12分钟间隔进行分组。请注意，在GROUP BY子句中，用逗号将时间间隔和tag key隔开。

该查询返回两个序列：每个location的值对应一个序列。每个时间戳所对应的结果代表一个12分钟间隔所对应的结果。第一个时间戳的计数（count）涵盖了从2015-08-18T00:00:00Z到2015-08-18T00:12:00Z的原始数据（不包括2015-08-18T00:12:00Z）。第二个时间戳的计数涵盖了从2015-08-18T00:12:00Z到2015-08-18T00:24:00的原始数据（不包括2015-08-18T00:24:00）。

基本语法的常见问题

查询结果中出现时间戳和值
使用基本语法，InfluxDB 依赖GROUP BY time()中的时间间隔和系统的预设时间边界来确定每个时间间隔内的原始数据和查询返回的时间戳。
示例

原始数据：

 SELECT "water_level" FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-08-18T00:00:00Z' AND time <='2015-08-18T00:18:00Z'
name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z8.12
2015-08-18T00:06:00Z8.005
2015-08-18T00:12:00Z7.887
2015-08-18T00:18:00Z7.762

查询和结果：

以下查询覆盖的时间范围是12分钟，并将结果按12分钟的间隔进行分组，但是它返回了两个结果：

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

name: h2o_feet
time                   count
---------
2015-08-18T00:00:00Z1<-----Note that this timestamp occurs before the start of the query's time range
2015-08-18T00:12:00Z   1

说明 InfluxDB®对GROUP BY的时间间隔使用预设的四舍五入时间边界，不依赖于WHERE子句中任何时间条件。在计算结果的时候，所有返回数据的时间戳必须在查询中明确规定的时间范围内，但是GROUP BY的时间间隔将会基于预设的时间边界。

下面的表格展示了结果中预设的时间边界、相关的GROUP BY time()时间间隔、包含的数据点以及每个GROUP BY time()间隔所对应的实际返回的时间戳。
在这里插入图片描述
第一个预设的12分钟时间边界从00:00开始，刚好在12:00前结束。只有一个数据点（8.005），同时落在查询的第一个GROUP BY time()时间间隔和第一个时间边界内。请注意，虽然返回的时间戳发生在查询的时间范围开始之前，但是查询结果排除了在查询时间范围之前发生的数据。

第二个预设的12分钟时间边界从12:00开始，刚好在24:00前结束。只有一个数据点（7.887），同时落在查询的第二个GROUP BY time()时间间隔和第二个时间边界内。

高级GROUP BY time()语法允许用户修改 InfluxDB 的预设时间边界的开始时间。在高级语法章节中的示例将继续这里展示的查询，它将预设的时间边界向前偏移6分钟，以便 InfluxDB 返回：

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

高级的GROUP BY time()语法

SELECT (<field_key>) FROM_clause WHERE <time_range> GROUP BY time(<time_interval>,<offset_interval>),[tag_key][fill(<fill_option>)]

高级语法描述

高级的GROUP BY time()查询需要在SELECT子句中包含一个InfluxQL函数，并且在WHERE子句中包含时间范围。请注意，GROUP BY子句必须放在WHERE子句后面。

time(time_interval,offset_interval)：关于time_interval的详情，请查看基本的GROUP BY time()语法。
offset_interval（偏移间隔）是一个持续时间（duration），它将 InfluxDB 的预设时间边界向前或向后偏移。offset_interval可以是正数或者负数。
fill(<fill_option>)：可选，它会改变不含数据的时间间隔的返回值。

覆盖范围：

高级的GROUP BY time()查询依赖time_interval、offset_interval和 InfluxDB 的预设时间边界来确定每个时间间隔内的原始数据和查询返回的时间戳。

高级语法示例

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

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

name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z8.12
2015-08-18T00:06:00Z8.005
2015-08-18T00:12:00Z7.887
2015-08-18T00:18:00Z7.762
2015-08-18T00:24:00Z7.635
2015-08-18T00:30:00Z7.5
2015-08-18T00:36:00Z7.372
2015-08-18T00:42:00Z7.234
2015-08-18T00:48:00Z7.11
2015-08-18T00:54:00Z6.982

将查询结果按18分钟的时间间隔进行分组并将预设时间边界向前偏移

SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-08-18T00:06:00Z' AND time <='2015-08-18T00:54:00Z' GROUP BY time(18m,6m)

name: h2o_feet
time                   mean
--------
2015-08-18T00:06:00Z7.884666666666667
2015-08-18T00:24:00Z7.502333333333333
2015-08-18T00:42:00Z7.108666666666667

该查询使用了InfluxQL中的一个函数计算water_level的平均值，将结果按18分钟的时间间隔进行分组，并将预设时间边界向前偏移6分钟。

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用InfluxDB®预设的时间边界。我们先来看看没有offset_interval的查询结果

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:00:00Z7.946
2015-08-18T00:18:00Z7.6323333333333325
2015-08-18T00:36:00Z7.238666666666667
2015-08-18T00:54:00Z6.982

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用 InfluxDB 预设的时间边界
在这里插入图片描述
第一个预设的18分钟时间边界从00:00开始，刚好在18:00前结束。有两个数据点（8.005和7.887），同时落在查询的第一个GROUP BY time()时间间隔和第一个时间边界内。请注意，虽然返回的时间戳发生在查询的时间范围开始之前，但是查询结果排除了在查询时间范围之前发生的数据。

第二个预设的18分钟时间边界从18:00开始，刚好在36:00前结束。有三个数据点（7.762，7.635和7.5），同时落在查询的第二个GROUP BY time()时间间隔和第二个时间边界内。在这种情况下，边界时间范围和间隔时间范围是相同的。

第四个预设的18分钟时间边界从54:00开始，刚好在01:12:00前结束。只有一个数据点（6.982），同时落在查询的第四个GROUP BY time()时间间隔和第四个时间边界内。

对于有offset_interval的查询，时间边界和返回的时间戳符合指定的偏移时间边界：
在这里插入图片描述
这个6分钟的偏移间隔将预设边界的时间范围向前偏移6分钟，使得边界的时间范围跟相关的GROUP BY time()间隔的时间范围始终相同。使用偏移间隔，每个时间间隔对三个数据点进行计算，并且返回的时间戳与边界时间范围的开始和GROUP BY time()时间范围的开始都相匹配。

请注意，offset_interval强制使第四个时间边界超过该查询的时间范围，因此，该查询不会返回最后一个时间间隔的数据。

将查询结果按18分钟的时间间隔进行分组并将预设时间边界向后偏移

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

name: h2o_feet
time                   mean
--------
2015-08-18T00:06:00Z7.884666666666667
2015-08-18T00:24:00Z7.502333333333333
2015-08-18T00:42:00Z7.108666666666667

该查询使用了InfluxQL中的一个函数计算water_level的平均值，将结果按18分钟的时间间隔进行分组，并将预设时间边界向后偏移12分钟。

说明该示例与前面第一个例子（将查询结果按18分钟的时间间隔进行分组并将预设时间边界向前偏移）的查询结果相同，但是，在该示例中，使用了一个负数的offset_interval，而在前面的示例中offset_interval是一个正数。这两个查询之间没有性能差异。在选择没有正负offset_interval时，请选择最直观的数值。

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用 InfluxDB 预设的时间边界。没有offset_interval的查询结果：

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

name: h2o_feet
time                    mean
--------
2015-08-18T00:00:00Z7.946
2015-08-18T00:18:00Z7.6323333333333325
2015-08-18T00:36:00Z7.238666666666667
2015-08-18T00:54:00Z6.982

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用InfluxDB®预设的时间边界：
在这里插入图片描述
第一个预设的18分钟时间边界从00:00开始，刚好在18:00前结束。有两个数据点（8.005和7.887），同时落在查询的第一个GROUP BY time()时间间隔和第一个时间边界内。请注意，虽然返回的时间戳发生在查询的时间范围开始之前，但是查询结果排除了在查询时间范围之前发生的数据。

对于有offset_interval的查询，时间边界和返回的时间戳符合指定的偏移时间边界：
在这里插入图片描述
这个负12分钟的偏移间隔将预设边界的时间范围向后偏移12分钟，使得边界的时间范围跟相关的GROUP BY time()间隔的时间范围始终相同。使用偏移间隔，每个时间间隔对三个数据点进行计算，并且返回的时间戳与边界时间范围的开始和GROUP BY time()时间范围的开始都相匹配。

请注意，offset_interval强制使第一个时间边界超过该查询的时间范围，因此，该查询不会返回第一个时间间隔的数据。

将查询结果按12分钟的时间间隔进行分组并将预设时间边界向前偏移
这个例子是基本语法的常见问题章节中示例的延续。

SELECT COUNT("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-08-18T00:06:00Z' AND time <'2015-08-18T00:18:00Z' GROUP BY time(12m,6m)

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

该查询使用了InfluxQL中的一个函数计算water_level的数据点数，将结果按12分钟的时间间隔进行分组，并将预设时间边界向前偏移6分钟。

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用 InfluxDB 预设的时间边界。没有offset_interval的查询结果：

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

name: h2o_feet
time                   count
---------
2015-08-18T00:00:00Z1
2015-08-18T00:12:00Z1

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用 InfluxDB 预设的时间边界：
在这里插入图片描述
第一个预设的12分钟时间边界从00:00开始，刚好在12:00前结束。只有一个数据点（8.005），同时落在查询的第一个GROUP BY time()时间间隔和第一个时间边界内。请注意，虽然返回的时间戳发生在查询的时间范围开始之前，但是查询结果排除了在查询时间范围之前发生的数据。

对于有offset_interval的查询，时间边界和返回的时间戳符合指定的偏移时间边界：
在这里插入图片描述
这个6分钟的偏移间隔将预设边界的时间范围向前偏移6分钟，使得边界的时间范围跟相关的GROUP BY time()间隔的时间范围始终相同。使用偏移间隔，该查询返回一个结果，并且返回的时间戳与边界时间范围的开始和GROUP BY time()时间范围的开始都相匹配。

请注意，offset_interval强制使第二个时间边界超过该查询的时间范围，因此，该查询不会返回第二个时间间隔的数据。

GROUP BY time intervals和fill()

fill()（填充函数）改变不包含数据的时间间隔的返回值。

语法

SELECT (<field_key>) FROM_clause WHERE <time_range> GROUP BY time(time_interval,[<offset_interval])[,tag_key][fill(<fill_option>)]
语法描述

对于不包含数据的GROUP BY time()时间间隔，默认将null作为它在输出列中的返回值。如果想要改变不包含数据的时间间隔的返回值，可以使用fill()。请注意，如果您GROUP BY多个对象（例如，tag和时间间隔），那么fill()必须放在GROUP BY子句后面。

fill_option

任意数值：对于没有数据点的时间间隔，返回这个给定的数值。
linear：对于没有数据点的时间间隔，返回线性插值的结果。
none：对于没有数据点的时间间隔，不返回任何时间戳和值。
null：对于没有数据点的时间间隔，返回时间戳，并且返回null作为该时间戳所对应的值，这跟默认的情况相同。
previous：对于没有数据点的时间间隔，返回前一个时间间隔的值。

示例1：没有使用fill(100)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z

示例2：使用fill(100)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m) fill(100)

name: h2o_feet
--------------
ime                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z100

fill(100)改变了没有数据点的时间间隔的值。第四个时间间隔本来没有数据显示，但是使用了fill(100)后，返回值变为了100。

示例3：没有使用fill(linear)

SELECT MEAN("tadpoles") FROM "pond" WHERE time >='2016-11-11T21:00:00Z' AND time <='2016-11-11T22:06:00Z' GROUP BY time(12m)

name: pond
time                   mean
--------
2016-11-11T21:00:00Z1
2016-11-11T21:12:00Z
2016-11-11T21:24:00Z3
2016-11-11T21:36:00Z
2016-11-11T21:48:00Z
2016-11-11T22:00:00Z6

示例4：使用fill(linear)

SELECT MEAN("tadpoles") FROM "pond" WHERE time >='2016-11-11T21:00:00Z' AND time <='2016-11-11T22:06:00Z' GROUP BY time(12m) fill(linear)

name: pond
time                   mean
--------
2016-11-11T21:00:00Z1
2016-11-11T21:12:00Z2
2016-11-11T21:24:00Z3
2016-11-11T21:36:00Z4
2016-11-11T21:48:00Z5
2016-11-11T22:00:00Z6

fill(linear)将没有数据点的时间间隔的返回值更改为线性插值的结果。

说明示例二中的数据并不在数据库NOAA_water_database中。为了可以使用fill(linear)，创建一个有更少常规数据的数据集。

示例5：没有使用fill(none)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z

示例6：使用fill(none)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m) fill(none)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235

fill(null)对于没有数据点的时间间隔，既不返回时间戳，也不返回值。

示例7：没有使用fill(null)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z

示例8：使用fill(null)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m) fill(null)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z

fill(null)对于没有数据点的时间间隔，返回null作为它的值。使用fill(null)的查询结果跟没有使用fill(null)的结果一样。

示例9：没有使用fill(previous)

SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z

示例10：使用fill(previous)

> SELECT MAX("water_level") FROM "h2o_feet" WHERE "location"='coyote_creek' AND time >='2015-09-18T16:00:00Z' AND time <='2015-09-18T16:42:00Z' GROUP BY time(12m) fill(previous)

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z3.599
2015-09-18T16:12:00Z3.402
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z3.235

fill(previous)将没有数据点的时间间隔的返回值更改为3.235，跟上一个时间间隔的返回值一样。

fill()的常见问题

在查询时间范围内没有数据的情况下使用fill()

目前，如果在查询的时间范围内没有数据，那么查询会忽略fill()。这是符合预期的结果。

示例：
以下查询不会返回任何数据，因为water_level在查询的时间范围内没有任何数据点。请注意，fill(800)对以下查询结果无影响。

SELECT MEAN(“water_level”) FROM “h2o_feet” WHERE “location”=‘coyote_creek’ AND time >=‘2015-09-18T22:00:00Z’ AND time <=‘2015-09-18T22:18:00Z’ GROUP BY time(12m) fill(800)

在前一个结果不在查询时间范围内的情况下使用fill(previous)

如果前一个时间间隔超出查询的时间范围，那么fill(previous)不会填充该时间间隔所对应的值。
示例：
以下查询覆盖的时间范围是从2015-09-18T16:24:00Z到2015-09-18T16:54:00Z。请注意，fill(previous)使用2015-09-18T16:24:00Z的结果来填充2015-09-18T16:36:00Z对应的值。

SELECT MAX("water_level") FROM "h2o_feet" WHERE location ='coyote_creek' AND time >='2015-09-18T16:24:00Z' AND time <='2015-09-18T16:54:00Z' GROUP BY time(12m) fill(previous)

name: h2o_feet
--------------
time                   max
2015-09-18T16:24:00Z3.235
2015-09-18T16:36:00Z3.235
2015-09-18T16:48:00Z4

下一个查询将缩短以上查询的时间范围，现在，查询覆盖的时间范围变为从2015-09-18T16:36:00Z到2015-09-18T16:54:00Z。请注意，fill(previous)不会使用2015-09-18T16:24:00Z的结果来填充2015-09-18T16:36:00Z对应的值，因为2015-09-18T16:24:00Z不在查询较短的时间范围内。

SELECT MAX("water_level") FROM "h2o_feet" WHERE location ='coyote_creek' AND time >='2015-09-18T16:36:00Z' AND time <='2015-09-18T16:54:00Z' GROUP BY time(12m) fill(previous)

name: h2o_feet
--------------
time                   max
2015-09-18T16:36:00Z
2015-09-18T16:48:00Z4

在前一个或后一个结果不在查询时间范围内的情况下使用fill(linear)
如果前一个或后一个时间间隔超出查询的时间范围，那么fill(linear)不会填充（fill）该时间间隔所对应的值。

示例：
以下查询覆盖的时间范围是从2016-11-11T21:24:00Z到2016-11-11T22:06:00Z。请注意，fill(linear)使用2016-11-11T21:24:00Z和2016-11-11T22:00:00Z这两个时间间隔的值来填充2016-11-11T21:36:00Z和2016-11-11T21:48:00Z分别所对应的值。

SELECT MEAN("tadpoles") FROM "pond" WHERE time >'2016-11-11T21:24:00Z' AND time <='2016-11-11T22:06:00Z' GROUP BY time(12m) fill(linear)

name: pond
time                   mean
--------
2016-11-11T21:24:00Z3
2016-11-11T21:36:00Z4
2016-11-11T21:48:00Z5
2016-11-11T22:00:00Z6

下一个查询将缩短以上查询的时间范围，现在，查询覆盖的时间范围变为从2016-11-11T21:36:00Z到2016-11-11T22:06:00Z。请注意，fill(linear)不会填充2016-11-11T21:36:00Z和2016-11-11T21:48:00Z所对应的值，因为2016-11-11T21:24:00Z不在查询较短的时间范围内，InfluxDB 无法进行线性插值计算。

SELECT MEAN("tadpoles") FROM "pond" WHERE time >='2016-11-11T21:36:00Z' AND time <='2016-11-11T22:06:00Z' GROUP BY time(12m) fill(linear)
name: pond
time                   mean
--------
2016-11-11T21:36:00Z
2016-11-11T21:48:00Z
2016-11-11T22:00:00Z6

说明以上示例数据并不在数据库NOAA_water_database中。为了可以使用fill(linear)，创建一个有更少常规数据的数据集。

2.4 INTO子句

INTO子句将查询结果写入到用户指定的measurement中。

语法

SELECT_clause INTO <measurement_name> FROM_clause [WHERE_clause] [GROUP_BY_clause]

语法描述

INTO子句支持多种指定measurement的格式：

INTO <measurement_name>将数据写入到一个指定的measurement。如果您使用CLI写入数据，那么写入数据的measurement属于”USE”指定的数据库，并且使用的是默认（DEFAULT）的保留策略。如果您使用的是HTTP API，那么写入数据的measurement属于参数db指定的数据库，同样，使用的是默认（DEFAULT）的保留策略。
INTO <database_name>.<retention_policy_name>.<measurement_name>将数据写入到一个完全限定的measurement。通过明确指定measurement的数据库和保留策略来完全限定一个measurement。
INTO <database_name>…<measurement_name>将数据写入到一个measurement，这个measurement属于一个用户指定的数据库并使用默认保留策略。
INTO <database_name>.<retention_policy_name>.:MEASUREMENT FROM /<regular_expression>/将数据写入到与FROM子句中正则表达式相匹配的所有在用户指定的数据库和保留策略中的measurement。:MEASUREMENT是FROM子句中每个匹配的measurement的反向引用（backreference）。

示例

重命名数据库

 SELECT * INTO "copy_NOAA_water_database"."autogen".:MEASUREMENT FROM "NOAA_water_database"."autogen"./.*/ GROUP BY *

name: result
time written
---- -------
0    76290

在InfluxDB®中不能直接重命名数据库，所以INTO子句的一个常见用例是将数据从一个数据库移动到另外一个数据库。以上查询将数据库NOAA_water_database的保留策略autogen中的所有数据写入到数据库copy_NOAA_water_database的保留策略autogen中。

反向引用语法（:MEASUREMENT）将源数据库中measurement的名字维持在目标数据库中不变。请注意，在执行INTO查询之前，数据库NOAA_water_database及其保留策略autogen都必须已经存在。有关如何管理数据库和保留策略，请查看数据库管理章节。

GROUP BY *子句将源数据库中的tag保留在目标数据库中。以下查询并不为tag维护序列的上下文，tag将作为field保存在目标数据库（copy_NOAA_water_database）中：

SELECT * INTO “copy_NOAA_water_database”.“autogen”.:MEASUREMENT FROM “NOAA_water_database”.“autogen”./.*/

当移动大量数据时，我们建议按顺序对不同的measurement运行INTO查询，并且使用WHERE子句中的时间边界。这样可以防止系统内存不足。下面的代码块提供了这类查询的示例语法：

SELECT *
INTO <destination_database>.<retention_policy_name>.<measurement_name>
FROM <source_database>.<retention_policy_name>.<measurement_name>
WHERE time > now() - 100w and time < now() - 90w GROUP BY *

SELECT *
INTO <destination_database>.<retention_policy_name>.<measurement_name>
FROM <source_database>.<retention_policy_name>.<measurement_name>}
WHERE time > now() - 90w  and time < now() - 80w GROUP BY *

SELECT *
INTO <destination_database>.<retention_policy_name>.<measurement_name>
FROM <source_database>.<retention_policy_name>.<measurement_name>
WHERE time > now() - 80w  and time < now() - 70w GROUP BY *

将查询结果写入measurement

 SELECT "water_level" INTO "h2o_feet_copy_1" FROM "h2o_feet" WHERE "location" = 'coyote_creek'

name: result
------------
time                   written
1970-01-01T00:00:00Z   7604

 SELECT * FROM "h2o_feet_copy_1"

name: h2o_feet_copy_1
---------------------
time                   water_level
2015-08-18T00:00:00Z   8.12
[...]
2015-09-18T16:48:00Z   4

该查询将它的结果写入到一个新的measurement：h2o_feet_copy_1。如果您使用CLI写入数据，那么数据会写入到USE指定的数据库，并且使用的是默认（DEFAULT）的保留策略。如果您使用的是HTTP API，那么数据会写入到参数db指定的数据库，并且使用参数rp指定的保留策略。如果没有设置参数rp，HTTP API自动将数据写入到数据库的默认保留策略中。

返回结果显示InfluxDB®写入到h2o_feet_copy_1中的数据点个数(7604)。返回结果中的时间戳是没有意义的， InfluxDB 使用epoch 0（即1970-01-01T00:00:00Z）作为空时间戳。

将查询结果写入完全限定的measurement

 SELECT "water_level" INTO "where_else"."autogen"."h2o_feet_copy_2" FROM "h2o_feet" WHERE "location" = 'coyote_creek'

name: result
------------
time                   written
1970-01-01T00:00:00Z   7604

 SELECT * FROM "where_else"."autogen"."h2o_feet_copy_2"

name: h2o_feet_copy_2
---------------------
time                   water_level
2015-08-18T00:00:00Z   8.12
[...]
2015-09-18T16:48:00Z   4

该查询将它的结果写入到一个新的measurement：h2o_feet_copy_2。InfluxDB®将数据写入到数据库where_else的保留策略autogen中。请注意，在执行INTO查询前，数据库where_else及其保留策略autogen都必须已经存在。有关如何管理数据库和保留策略，请查看数据库管理章节。

返回结果显示InfluxDB®写入到h2o_feet_copy_2中的数据点个数（7604）。返回结果中的时间戳是没有意义的，InfluxDB®使用epoch 0（即1970-01-01T00:00:00Z）作为空时间戳。

将聚合结果写入measurement（降采样）

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

name: result
------------
time                   written
1970-01-01T00:00:00Z   3

 SELECT * FROM "all_my_averages"

name: all_my_averages
---------------------
time                   mean
2015-08-18T00:00:00Z   8.0625
2015-08-18T00:12:00Z   7.8245
2015-08-18T00:24:00Z   7.5675

该查询使用了一个InfluxQL函数和一个GROUP BY time()子句将数据进行聚合，并且将结果写入到measurement all_my_averages。

返回结果显示 InfluxDB 写入到all_my_averages中的数据点个数(3)。返回结果中的时间戳是没有意义的，InfluxDB 使用epoch 0（即1970-01-01T00:00:00Z）作为空时间戳。

该查询是降采样（downsampling）的一个示例：获取更高精度的数据并将这些数据聚合到较低精度，然后将较低精度的数据存储到数据库。降采样是INTO子句的一个常见用例。

数据写入
将多个measurement的聚合结果写入一个不同的数据库（使用反向引用进行降采样）。

 SELECT MEAN(*) INTO "where_else"."autogen".:MEASUREMENT FROM /.*/ WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:06:00Z' GROUP BY time(12m)

name: result
time                   written
----                   -------
1970-01-01T00:00:00Z   5

 SELECT * FROM "where_else"."autogen"./.*/

name: average_temperature
time                   mean_degrees   mean_index   mean_pH   mean_water_level
----                   ------------   ----------   -------   ----------------
2015-08-18T00:00:00Z   78.5

name: h2o_feet
time                   mean_degrees   mean_index   mean_pH   mean_water_level
----                   ------------   ----------   -------   ----------------
2015-08-18T00:00:00Z                                         5.07625

name: h2o_pH
time                   mean_degrees   mean_index   mean_pH   mean_water_level
----                   ------------   ----------   -------   ----------------
2015-08-18T00:00:00Z                               6.75

name: h2o_quality
time                   mean_degrees   mean_index   mean_pH   mean_water_level
----                   ------------   ----------   -------   ----------------
2015-08-18T00:00:00Z                  51.75

name: h2o_temperature
time                   mean_degrees   mean_index   mean_pH   mean_water_level
----                   ------------   ----------   -------   ----------------
2015-08-18T00:00:00Z   63.75

该查询使用了一个InfluxQL函数和一个GROUP BY time()子句将数据进行聚合，它将与FROM子句中正则表达式匹配的所有measurement中的数据进行聚合，并将结果写入到数据库where_else和查询策略autogen中有相同名字的measurement。请注意，在执行INTO查询前，数据库where_else及其保留策略autogen都必须已经存在。

返回结果显示InfluxDB®写入到数据库where_else和查询策略autogen中的数据点个数（5）。返回结果中的时间戳是没有意义的，InfluxDB®使用epoch 0（即1970-01-01T00:00:00Z）作为空时间戳。

该查询是使用反向引用进行降采样（downsampling with backreferencing）的一个示例：从多个measurement中获取更高精度的数据并将这些数据聚合到较低精度，然后将较低精度的数据存储到数据库。使用反向引用进行降采样是INTO子句的一个常见用例。

INTO子句的常见问题

数据丢失

如果一个INTO查询在SELECT子句中包含tag key，那么查询将当前measurement中的tag转换为目标measurement的field，这可能会导致 InfluxDB 覆盖以前由tag value区分的数据点。请注意，此行为不适用于使用TOP()或BOTTOM()函数的查询。

为了将当前measurement中的tag保留为目标measurement中的tag，可以在INTO查询中加上GROUP BY子句：GROUP BY相关的tag key或者GROUP BY *。

使用INTO子句自动查询

本文档中的INTO子句章节展示了如何使用INTO子句手动实现查询。通过连续查询（CQ），可以使INTO子句自动查询实时数据。连续查询其中一个用途就是使降采样的过程自动化。

2.5 ORDER BY time DESC

InfluxDB默认按递增的时间顺序返回结果。第一个返回的数据点，其时间戳是最早的，而最后一个返回的数据点，其时间戳是最新的。ORDER BY time DESC将默认的时间顺序调转，使得InfluxDB首先返回有最新时间戳的数据点，也就是说，按递减的时间顺序返回结果。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] ORDER BY time DESC

语法描述

如果查询语句中包含GROUP BY子句，那么ORDER BY time DESC必须放在GROUP BY子句后面。如果查询语句中包含WHERE子句并且没有GROUP BY子句，那么ORDER BY time DESC必须放在WHERE子句后面。

示例

首先返回最新的点

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' ORDER BY time DESC
name: h2o_feet
time                   water_level
----                   -----------
2015-09-18T21:42:00Z   4.938
2015-09-18T21:36:00Z   5.066
[...]
2015-08-18T00:06:00Z   2.116
2015-08-18T00:00:00Z   2.064

该查询首先从measurement h2o_feet中返回具有最新时间戳的数据点。如果以上查询语句中没有ORDER by time DESC，那么会首先返回时间戳为2015-08-18T00:00:00Z的数据点，最后返回时间戳为2015-09-18T21:42:00Z的数据点。

首先返回最新的点并且包含GROUP BY time()子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY time(12m) ORDER BY time DESC
name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:36:00Z   4.6825
2015-08-18T00:24:00Z   4.80675
2015-08-18T00:12:00Z   4.950749999999999
2015-08-18T00:00:00Z   5.07625

该查询使用了一个InfluxQL函数和GROUP BY子句中的时间间隔，计算查询时间范围内每12分钟的water_level的平均值。ORDER BY time DESC语句使得最新12分钟间隔的结果会首先返回。如果以上查询语句中没有ORDER by time DESC，那么会首先返回时间戳为2015-08-18T00:00:00Z的数据点，最后返回时间戳为2015-08-18T00:36:00Z的数据点。

2.6 LIMIT及SLIMIT子句

LIMIT和SLIMIT分别限制每个查询返回的数据点个数和序列个数。

LIMIT子句

LIMIT 返回指定measurement中的前N个数据点。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] LIMIT

语法描述

N表示从指定measurement中返回的数据点个数。如果N大于measurement中所有数据点的个数，InfluxDB将返回该measurement中的所有数据点。请注意，LIMIT子句必须按照上述语法中的顺序使用。

示例

限制返回的数据点个数

> SELECT "water_level","location" FROM "h2o_feet" LIMIT 3
name: h2o_feet
time                   water_level   location
----                   -----------   --------
2015-08-18T00:00:00Z   8.12          coyote_creek
2015-08-18T00:00:00Z   2.064         santa_monica
2015-08-18T00:06:00Z   8.005         coyote_creek

该查询从measurement h2o_feet中返回三个最早的数据点（由时间戳决定）。

限制返回的数据点个数并且包含GROUP BY子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY *,time(12m) LIMIT 2
name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-18T00:00:00Z   8.0625
2015-08-18T00:12:00Z   7.8245
name: h2o_feet
tags: location=santa_monica
time                   mean
----                   ----
2015-08-18T00:00:00Z   2.09
2015-08-18T00:12:00Z   2.077

该查询使用了一个InfluxQL函数和一个GROUP BY子句，计算每个tag以及查询时间范围内每12分钟的water_level的平均值。LIMIT 2表示该查询请求的是两个最早的12分钟间隔的平均值（由时间戳决定）。

请注意，如果以上查询语句中没有使用LIMIT 2，那么每个序列会返回四个数据点：在查询的时间范围内每隔十二分钟有一个数据点。

SLIMIT子句

SLIMIT 返回指定measurement的前N个序列中的每一个数据点。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] GROUP BY *[,time(<time_interval>)] [ORDER_BY_clause] SLIMIT

语法描述

N表示从指定measurement中返回的序列个数。如果N大于measurement中所有序列的个数，InfluxDB将返回该measurement中的所有序列。请注意，SLIMIT子句必须按照上述语法中的顺序使用。

示例

限制返回的序列个数

> SELECT "water_level" FROM "h2o_feet" GROUP BY * SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time                   water_level
----                   -----
2015-08-18T00:00:00Z   8.12
2015-08-18T00:06:00Z   8.005
2015-08-18T00:12:00Z   7.887
[...]
2015-09-18T16:12:00Z   3.402
2015-09-18T16:18:00Z   3.314
2015-09-18T16:24:00Z   3.235

该查询从measurement h2o_feet的一个序列中返回所有water_level数据点。

限制返回的序列个数并且包含GROUP BY time()子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY *,time(12m) SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
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

该查询使用了一个InfluxQL函数和GROUP BY子句中的时间间隔，计算查询时间范围内每12分钟的water_level的平均值。SLIMIT 1表示该查询请求的是measurement h2o_feet中的一个序列。

请注意，如果以上查询语句中没有使用SLIMIT 1，那么查询将返回measurement h2o_feet中的两个序列：location=coyote_creek和location=santa_monica。

LIMIT和SLIMIT

将SLIMIT 放在LIMIT 的后面，则返回指定measurement的N个序列中的前N个数据点。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] GROUP BY *[,time(<time_interval>)] [ORDER_BY_clause] LIMIT SLIMIT

语法描述

N1表示从measurement中返回的数据点个数。如果N1大于measurement中所有数据点的个数，InfluxDB®将返回该measurement中的所有数据点。
N2表示从指定measurement中返回的序列个数。如果N2大于measurement中所有序列的个数，InfluxDB®将返回该measurement中的所有序列。

请注意，LIMIT和SLIMIT子句必须按照上述语法中的顺序使用。

示例

限制返回的数据点个数和序列个数

> SELECT "water_level" FROM "h2o_feet" GROUP BY * LIMIT 3 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   8.12
2015-08-18T00:06:00Z   8.005
2015-08-18T00:12:00Z   7.887

该查询从measurement h2o_feet的一个序列中返回三个最早的数据点。

限制返回的数据点个数和序列个数，并且包含GROUP BY time()子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY *,time(12m) LIMIT 2 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-18T00:00:00Z   8.0625
2015-08-18T00:12:00Z   7.8245

该查询使用了一个InfluxQL函数和GROUP BY子句中的时间间隔，计算查询时间范围内每12分钟的water_level的平均值。LIMIT 2请求两个最早的12分钟间隔的平均值（由时间戳决定），SLIMIT 1请求measurement h2o_feet中的一个序列。

注意：如果以上查询语句中没有使用LIMIT 2 SLIMIT 1，那么查询将返回measurement h2o_feet中的两个序列，并且，每个序列返回四个数据点。

2.7 OFFSET及SOFFSET语句

OFFSET和SOFFSET分别标记数据点和序列返回的位置。

OFFSET子句

OFFSET 表示从查询结果中的第N个数据点开始返回。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] LIMIT_clause OFFSET [SLIMIT_clause]

语法描述

N表示从第N个数据点开始返回。使用OFFSET子句需要先使用LIMIT子句，在没有LIMIT子句的情况下使用OFFSET子句，可能会导致出现不一致的查询结果。

注释：如果WHERE子句包含时间范围，InfluxDB将不会返回任何结果，OFFSET子句可能会导致InfluxDB返回时间戳不在该时间范围内的数据点。

示例

标记数据点返回的位置

> SELECT "water_level","location" FROM "h2o_feet" LIMIT 3 OFFSET 3
name: h2o_feet
time                   water_level   location
----                   -----------   --------
2015-08-18T00:06:00Z   2.116         santa_monica
2015-08-18T00:12:00Z   7.887         coyote_creek
2015-08-18T00:12:00Z   2.028         santa_monica

该查询从measurement h2o_feet中返回第四、第五和第六个数据点。如果以上查询语句中没有使用OFFSET 3，那么查询将返回该measurement的第一、第二和第三个数据点。

标记数据点返回的位置并且包含多个子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY *,time(12m) ORDER BY time DESC LIMIT 2 OFFSET 2 SLIMIT 1
name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-18T00:12:00Z   7.8245
2015-08-18T00:00:00Z   8.0625

这个例子非常复杂，所以我们逐个子句来分析：

SELECT子句指定了一个InfluxQL函数；
FROM子句指定了measurement；
WHERE子句指定了查询的时间范围；
GROUP BY子句将查询结果按所有tag（*）和12分钟的时间间隔进行分组；
ORDER BY time DESC子句按递减的时间顺序返回结果；
LIMIT 2子句将返回的数据点个数限制为2；
OFFSET 2子句使查询结果的前两个平均值不返回；
SLIMIT 1子句将返回的序列个数限制为1。

如果以上查询语句中没有使用OFFSET 2，那么查询将返回结果中的前两个平均值：

name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-18T00:36:00Z   7.303
2015-08-18T00:24:00Z   7.5675

SOFFSET子句

SOFFSET 表示从查询结果中的第N个序列开始返回。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] GROUP BY *[,time(time_interval)] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] SLIMIT_clause SOFFSET

语法描述

N表示从第N个序列开始返回。使用SOFFSET子句需要先使用SLIMIT子句，在没有SLIMIT子句的情况下使用SOFFSET子句，可能会导致出现不一致的查询结果。

注释：如果N大于序列的个数，InfluxDB将不会返回任何结果。

示例

标记序列返回的位置

> SELECT "water_level" FROM "h2o_feet" GROUP BY * SLIMIT 1 SOFFSET 1
name: h2o_feet
tags: location=santa_monica
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
[...]
2015-09-18T21:36:00Z   5.066
2015-09-18T21:42:00Z   4.938

该查询返回measurement为h2o_feet、tag为location = santa_monica的序列中的数据。如果以上查询语句中没有使用SOFFSET 1，那么查询将返回measurement为h2o_feet、tag为location = coyote_creek的序列中的数据。

标记序列返回的位置并且包含多个子句

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:42:00Z' GROUP BY *,time(12m) ORDER BY time DESC LIMIT 2 OFFSET 2 SLIMIT 1 SOFFSET 1
name: h2o_feet
tags: location=santa_monica
time                   mean
----                   ----
2015-08-18T00:12:00Z   2.077
2015-08-18T00:00:00Z   2.09

这个例子非常复杂，所以我们逐个子句来分析：

SELECT子句指定了一个InfluxQL函数；

FROM子句指定了measurement；
WHERE子句指定了查询的时间范围；
GROUP BY子句将查询结果按所有tag(*)和12分钟的时间间隔进行分组；
ORDER BY time DESC子句按递减的时间顺序返回结果；
LIMIT 2子句将返回的数据点个数限制为2；
OFFSET 2子句使查询结果的前两个平均值不返回；
SLIMIT 1子句将返回的序列个数限制为1；
SOFFSET 1子句使查询结果中第一个序列的数据不返回。

如果以上查询语句中没有使用SOFFSET 1，那么查询将返回另外一个序列的结果：

name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
2015-08-18T00:12:00Z   7.8245
2015-08-18T00:00:00Z   8.0625

2.8 时区子句

tz()子句返回指定时区的UTC偏移量。

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause] tz(‘<time_zone>’)

语法描述

nfluxDB默认以UTC格式存储和返回时间戳。tz()子句包含UTC偏移量，或者UTC夏令时（Daylight Savings Time，简称DST）偏移量（如果适用的话），在查询返回的时间戳中。返回的时间戳必须是RFC3339格式才能显示UTC偏移量或者UTC夏令时偏移量。参数time_zone遵循Internet Assigned Numbers Authority time zone database（互联网号码分配局时区数据库）的TZ语法，需要用单引号将它括起来。

示例

返回芝加哥时区的UTC偏移量

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:18:00Z' tz('America/Chicago')
name: h2o_feet
time                       water_level
----                       -----------
2015-08-17T19:00:00-05:00  2.064
2015-08-17T19:06:00-05:00  2.116
2015-08-17T19:12:00-05:00  2.028
2015-08-17T19:18:00-05:00  2.126

该查询结果中，时间戳包含了美国/芝加哥（America/Chicago）的时区的UTC偏移量（-05:00）。

2.9 时间语法

对于大多数SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到2262-04-11T23:47:16.854775806Z UTC。对于包含GROUP BY time()子句的SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到now()。以下章节将详细介绍如何在SELECT语句的WHERE子句中指定其它的时间范围。

绝对时间

使用日期-时间字符串（date-time string）和epoch时间来指定绝对时间。

语法

SELECT_clause FROM_clause WHERE time [‘<rfc3339_date_time_string>’ | ‘<rfc3339_like_date_time_string>’ | <epoch_time>] [AND [‘<rfc3339_date_time_string>’ | ‘<rfc3339_like_date_time_string>’ | <epoch_time>] […]]

语法描述

支持的操作符如下表所示。
在这里插入图片描述
目前，InfluxDB 不支持在WHERE子句中的绝对时间使用OR。

rfc3339_date_time_string

YYYY-MM-DDTHH:MM:SS.nnnnnnnnnZ

.nnnnnnnnn是可选的，如果没有指定的话，默认设为.000000000。RFC3339格式的日期-时间字符串（RFC3339 date-time string）需要用单引号括起来。

rfc3339_like_date_time_string

YYYY-MM-DD HH:MM:SS.nnnnnnnnn

HH:MM:SS.nnnnnnnnn.nnnnnnnnn是可选的，如果没有指定的话，默认设为00:00:00.000000000。类似RFC3339格式的日期-时间字符串（RFC3339-like date-time string）需要用单引号括起来。
epoch_time

epoch时间是自1970年1月1日星期四00:00:00（UTC）以来所经过的时间。在默认情况下，InfluxDB假设所有epoch格式的时间戳都是以纳秒为单位。通过在epoch格式的时间戳末尾加上一个表示时间精度的字符，可以表示除纳秒外的时间精度。

基本运算

所有时间戳格式支持基本的算术运算。可以将带有时间精度的时间戳加上（+）或者减去（-）一个时间。请注意，InfluxQL需要用一个空格将+或-和时间戳隔开。

示例

用RFC3339格式的日期-时间字符串指定一个时间范围

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00.000000000Z' 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

该查询返回时间戳在2015年8月18日00:00:00.000000000和2015年8月18日00:12:00之间的数据。第一个时间戳的纳米精度（.000000000）是可选的。

请注意，RFC3339格式的日期-时间字符串需要用单引号括起来。

用类似RFC3339格式的日期-时间字符串指定一个时间范围

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

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年8月18日00:00:00和2015年8月18日00:12:00之间的数据。第一个日期-时间字符串没有包含时间， InfluxDB会假设时间是00:00:00。

请注意，类似RFC3339格式的日期-时间字符串需要用单引号括起来。

用epoch格式的时间戳指定一个时间范围

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= 1439856000000000000 AND time <= 1439856720000000000

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年8月18日00:00:00和2015年8月18日00:12:00之间的数据。在默认情况下，InfluxDB假设epoch格式的时间戳以纳秒为单位。

用其它时间精度的epoch格式的时间戳指定一个时间范围

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= 1439856000s AND time <= 1439856720s

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年8月18日00:00:00和2015年8月18日00:12:00之间的数据。时间戳末尾的s表示该时间戳以秒为单位。

对类似RFC3339格式的日期-时间字符串进行基本运算

> SELECT "water_level" FROM "h2o_feet" WHERE time > '2015-09-18T21:24:00Z' + 6m

name: h2o_feet
time                   water_level
----                   -----------
2015-09-18T21:36:00Z   5.066
2015-09-18T21:42:00Z   4.938

该查询返回时间戳在2015年8月18日21:24:00后6分钟之后的数据，即在2015年8月18日21:30:00之后的数据。请注意，需要用空格分别将时间戳和+、+和6m隔开。

对epoch格式的时间戳进行基本运算

> SELECT "water_level" FROM "h2o_feet" WHERE time > 24043524m - 6m

name: h2o_feet
time                   water_level
----                   -----------
2015-09-18T21:24:00Z   5.013
2015-09-18T21:30:00Z   5.01
2015-09-18T21:36:00Z   5.066
2015-09-18T21:42:00Z   4.938

该查询返回时间戳在2015年8月18日21:24:00前6分钟之后的数据，即在2015年8月18日21:18:00之后的数据。请注意，需要用空格分别将时间戳和-、-和6m隔开。

相对时间

使用now()查询时间戳相对于服务器本地时间戳的数据。

语法

SELECT_clause FROM_clause WHERE time now() [[ - | + ] <duration_literal>] [(AND|OR) now() […]]

语法描述

now()是在服务器上执行查询时该服务器的Unix时间。-或+和duration_literal之间必须要用空格隔开。

支持的操作符如下表所示。
duration_literal

示例

用相对时间指定时间范围

SELECT “water_level” FROM “h2o_feet” WHERE time > now() - 1h

该查询返回过去一个小时内的数据。需要用空格分别将now()和-、-和1h隔开。

用绝对时间和相对时间指定时间范围

> SELECT "level description" FROM "h2o_feet" WHERE time > '2015-09-18T21:18:00Z' AND time < now() + 1000d

name: h2o_feet
time                   level description
----                   -----------------
2015-09-18T21:24:00Z   between 3 and 6 feet
2015-09-18T21:30:00Z   between 3 and 6 feet
2015-09-18T21:36:00Z   between 3 and 6 feet
2015-09-18T21:42:00Z   between 3 and 6 feet

该查询返回时间戳在2015年9月18日21:18:00和now()之后的1000天之间的数据。需要用空格分别将now()和+、+和1000d隔开。

时间语法的常见问题

使用OR选择多个时间间隔

InfluxDB不支持在WHERE子句中使用OR来指定多个时间间隔。

在带有GROUP BY time()的查询语句中，查询发生在now()之后的数据

对于大多数SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到2262-04-11T23:47:16.854775806Z UTC。对于包含GROUP BY time()子句的SELECT语句，默认的时间范围是从1677-09-21 00:12:43.145224194 UTC到now()。

若想查询发生在now()之后的数据，包含GROUP BY time()子句的SELECT语句必须在WHERE子句中提供一个时间上限（upper bound）。

示例

使用CLI向数据库NOAA_water_database中写入一个发生在now()之后的数据点：

INSERT h2o_feet,location=santa_monica water_level=3.1 1587074400000000000

运行一个带有GROUP BY time()的查询，涵盖时间戳在2015-09-18T21:30:00Z和now()之后的180个星期之间的数据：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-09-18T21:30:00Z' AND time <= now() + 180w GROUP BY time(12m) fill(none)

name: h2o_feet
time                   mean
----                   ----
2015-09-18T21:24:00Z   5.01
2015-09-18T21:36:00Z   5.002
2020-04-16T22:00:00Z   3.1

注意：WHERE子句必须提供一个时间上限来覆盖默认的now()上限。以下查询仅仅是将时间下限（lower bound）重新设置为now()，使得查询的时间范围在now()和now()之间，所以没有返回任何数据：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location"='santa_monica' AND time >= now() GROUP BY time(12m) fill(none)
>

配置返回的时间戳

CLI默认返回epoch格式的时间戳，并且精确到纳秒，可通过命令precision 来指定其它的时间格式。HTTP API默认返回RFC3339格式的时间戳，可通过参数epoch来指定其它的时间格式。

2.10 正则表达式

InfluxQL支持在以下场景中使用正则表达式：

在SELECT子句中的field key和tag key。
在FROM子句中的measurement。
在WHERE子句中的tag value和字符串类型的field value。
在GROUP BY子句中的tag key。

目前，InfluxQL不支持在WHERE子句、数据库和保留策略中使用正则表达式去匹配非字符串类型的field value。

注释：正则表达式比较比字符串比较更加消耗计算资源；带有正则表达式的查询比那些不带的性能要低一些。

语法

SELECT /<regular_expression_field_key>/ FROM /<regular_expression_measurement>/ WHERE [<tag_key> /<regular_expression_tag_value>/ | <field_key> /<regular_expression_field_value>/] GROUP BY /<regular_expression_tag_key>/

语法描述

正则表达式被字符/包围，并使用Golang的正则表达式语法。

支持的操作符：


=~	匹配
!~	不匹配

示例

在SELECT子句中使用正则表达式指定field key和tag key

> SELECT /l/ FROM "h2o_feet" LIMIT 1
name: h2o_feet
time                   level description      location       water_level
----                   -----------------      --------       -----------
2015-08-18T00:00:00Z   between 6 and 9 feet   coyote_creek   8.12

该查询返回所有包含字符l的field key和tag key。请注意，在SELECT子句中的正则表达式必须至少匹配一个field key，才能返回与正则表达式匹配的tag key所对应的结果。

目前，没有语法可以区分SELECT子句中field key的正则表达式和tag key的正则表达式，不支持语法/<regular_expression>/::[field | tag]。

在SELECT子句中使用正则表达式指定带函数的field key

> SELECT DISTINCT(/level/) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00.000000000Z' AND time <= '2015-08-18T00:12:00Z'
name: h2o_feet
time                   distinct_level description   distinct_water_level
----                   --------------------------   --------------------
2015-08-18T00:00:00Z   below 3 feet                 2.064
2015-08-18T00:00:00Z                                2.116
2015-08-18T00:00:00Z                                2.028

该查询使用了一个InfluxQL函数，返回每个包含level的field key所对应的去重后的field value。

在FROM子句中使用正则表达式指定measurement

> SELECT MEAN("degrees") FROM /temperature/
name: average_temperature
time                    mean
----                    ----
1970-01-01T00:00:00Z   79.98472932232272
name: h2o_temperature
time                    mean
----                    ----
1970-01-01T00:00:00Z   64.98872722506226

该查询使用了一个InfluxQL函数，计算数据库NOAA_water_database中每个名字包含temperature的measurement的degrees的平均值。

在WHERE子句中使用正则表达式指定tag value

> SELECT MEAN(water_level) FROM "h2o_feet" WHERE "location" =~ /[m]/ AND "water_level" > 3
name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.47155532049926

该查询使用了一个InfluxQL函数，计算满足条件的water_level的平均值，需满足的条件是：location的tag value包含m并且water_level大于3。

在WHERE子句中使用正则表达式指定没有值的tag

> SELECT * FROM "h2o_feet" WHERE "location" !~ /./
>

该查询从measurement h2o_feet中选择数据，这些数据需满足条件：tag location中不包含数据。因为数据库NOAA_water_database里面每个数据点都有location对应的tag value，所以该查询不返回任何结果。

不使用正则表达式也可以执行相同的查询，请查阅FAQ章节获得更多相关信息。

在WHERE子句中使用正则表达式指定具有值的tag

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" =~ /./
name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.442107025822523

该查询使用了一个InfluxQL函数，计算满足条件的water_level的平均值，需满足的条件是：location具有tag value。

在WHERE子句中使用正则表达式指定field value

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND "level description" =~ /between/
name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.47155532049926

该查询使用了一个InfluxQL函数，计算满足条件的water_level的平均值，需满足的条件是：level description的field value包含between。

在GROUP BY子句中使用正则表达式指定tag key

> SELECT FIRST("index") FROM "h2o_quality" GROUP BY /l/
name: h2o_quality
tags: location=coyote_creek
time                   first
----                   -----
2015-08-18T00:00:00Z   41
name: h2o_quality
tags: location=santa_monica
time                   first
----                   -----
2015-08-18T00:00:00Z   99

该查询使用了一个InfluxQL函数，查询每个tag key包含l的tag所对应的index的第一个值。

2.11 数据类型和转换

SELECT子句支持使用语法::指定field的类型和基本的类型转换操作。

数据类型

field value可以是浮点数、整数、字符串或者布尔值。语法::允许用户在查询中指定field value的数据类型。

注释：通常，不需要在SELECT子句指定field value的数据类型。在大多数情况下，InfluxDB拒绝任何尝试将field value写入到之前接受不同数据类型field value的field。在不同的shard group中，field value的数据类型可能不同，在这些情况下，可能需要在SELECT子句中指定field value的数据类型。

语法

SELECT_clause <field_key>:: FROM_clause

语法描述

type可以是float，integer，string或boolean。在大多数情况下，如果field_key没有存储指定type的数据，那么InfluxDB将不会返回任何数据。请参见转换获得更多相关信息。

示例

> SELECT "water_level"::float FROM "h2o_feet" LIMIT 4
name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z   8.12
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   8.005
2015-08-18T00:06:00Z   2.116

该查询返回field key water_level为浮点型的数据。

转换

语法::允许用户在查询中执行基本的类型转换。目前，InfluxDB支持field value从整数转换成浮点数，或者从浮点数转换成整数。

语法

SELECT_clause <field_key>:: FROM_clause

语法描述

type可以是float或integer。如果查询试图把整数或浮点数转换成字符串或布尔值，那么InfluxDB将不会返回任何数据。

示例

将浮点型的field value转换成整型

> SELECT "water_level"::integer FROM "h2o_feet" LIMIT 4
name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z   8
2015-08-18T00:00:00Z   2
2015-08-18T00:06:00Z   8
2015-08-18T00:06:00Z   2

该查询将浮点型的water_level转换成整型，然后返回。

将浮点型的field value转换成字符串（不支持该功能）

> SELECT "water_level"::string FROM "h2o_feet" LIMIT 4
>

因为不支持将浮点型的field value转换成字符串，所以该查询不返回任何数据。

2.12 合并

在InfluxDB中，查询自动将序列合并。

示例

数据库NOAA_water_database中的measurement的h2o_feet是两个序列的一部分。第一个序列由measurement h2o_feet和tag location = coyote_creek组成。第二个序列由measurement h2o_feet和tag location = santa_monica组成。

以下查询在计算water_level的平均值时自动将这两个序列合并：

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

如果您只想要计算第一个序列的water_level的平均值，请在WHERE子句中指定相关的tag：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'coyote_creek'
name: h2o_feet
--------------
time                   mean
1970-01-01T00:00:00Z   5.359342451341401

如果您想要计算每个序列的water_level的平均值，请加上GROUP BY子句：

> SELECT MEAN("water_level") FROM "h2o_feet" GROUP BY "location"
name: h2o_feet
tags: location=coyote_creek
time                   mean
----                   ----
1970-01-01T00:00:00Z   5.359342451341401
name: h2o_feet
tags: location=santa_monica
time                   mean
----                   ----
1970-01-01T00:00:00Z   3.530863470081006

2.13 多个语句

在查询中请使用分号(;)将多个SELECT语句隔开。

示例

CLI

在InfluxDB®的CLI中：

> SELECT MEAN("water_level") FROM "h2o_feet"; SELECT "water_level" FROM "h2o_feet" LIMIT 2
name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.442107025822522
name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   8.12
2015-08-18T00:00:00Z   2.064

HTTP API

使用InfluxDB®的HTTP API：

{
    "results": [
        {
            "statement_id": 0,
            "series": [
                {
                    "name": "h2o_feet",
                    "columns": [
                        "time",
                        "mean"
                    ],
                    "values": [
                        [
                            "1970-01-01T00:00:00Z",
                            4.442107025822522
                        ]
                    ]
                }
            ]
        },
        {
            "statement_id": 1,
            "series": [
                {
                    "name": "h2o_feet",
                    "columns": [
                        "time",
                        "water_level"
                    ],
                    "values": [
                        [
                            "2015-08-18T00:00:00Z",
                            8.12
                        ],
                        [
                            "2015-08-18T00:00:00Z",
                            2.064
                        ]
                    ]
                }
            ]
        }
    ]
}

2.14 子查询

子查询是嵌套在另一个查询的FROM子句中的查询。使用子查询将查询作为条件应用在另一个查询中。子查询提供类似嵌套函数和SQL HAVING子句的功能。

语法

SELECT_clause FROM ( SELECT_statement ) […]

语法描述

InfluxDB®首先执行子查询，然后执行主查询。
主查询包含着子查询，至少需要SELECT子句和FROM子句。主查询支持本文档中列出的所有子句。
子查询在主查询的FROM子句中，需要用括号将子查询括起来。子查询支持本文档中列出的所有子句。

InfluxQL支持在主查询中有多个嵌套的子查询，示例语法如下：

SELECT_clause FROM ( SELECT_clause FROM ( SELECT_statement ) […] ) […]

示例

计算多个MAX()值的SUM()

> SELECT SUM("max") FROM (SELECT MAX("water_level") FROM "h2o_feet" GROUP BY "location")
name: h2o_feet
time                   sum
----                   ---
1970-01-01T00:00:00Z   17.169

该查询返回每个location中water_level的最大值的总和。

InfluxDB®首先执行子查询，计算每个location的water_level的最大值：

> SELECT MAX("water_level") FROM "h2o_feet" GROUP BY "location"
name: h2o_feet
tags: location=coyote_creek
time                   max
----                   ---
2015-08-29T07:24:00Z   9.964
name: h2o_feet
tags: location=santa_monica
time                   max
----                   ---
2015-08-29T03:54:00Z   7.205

然后，InfluxDB执行主查询，计算这些最大值的总和：9.964 + 7.205 = 17.169。请注意，该主查询指定max（而不是water_level）作为SUM()函数中的field key。

计算两个field的差值的MEAN()

> SELECT MEAN("difference") FROM (SELECT "cats" - "dogs" AS "difference" FROM "pet_daycare")
name: pet_daycare
time                   mean
----                   ----
1970-01-01T00:00:00Z   1.75

该查询返回measurement pet_daycare中cats数量和dogs数量的差异的平均值。

InfluxDB®首先执行子查询，计算field cats中的值和field dogs中的值的差异，并将输出列命名为difference：

> SELECT "cats" - "dogs" AS "difference" FROM "pet_daycare"
name: pet_daycare
time                   difference
----                   ----------
2017-01-20T00:55:56Z   -1
2017-01-21T00:55:56Z   -49
2017-01-22T00:55:56Z   66
2017-01-23T00:55:56Z   -9

然后，InfluxDB®执行主查询，计算这些差值的平均值。请注意，该主查询指定difference作为MEAN()函数中的field key。

计算多个MEAN()值并在这些值上加上条件

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

该查询返回water_level的所有大于5的平均值。

InfluxDB®首先执行子查询，计算从2015-08-18T00:00:00Z到2015-08-18T00:30:00Z water_level的平均值，并将结果按12分钟的时间间隔进行分组，同时将输出列命名为all_the_means：

> SELECT MEAN("water_level") AS "all_the_means" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m)
name: h2o_feet
time                   all_the_means
----                   -------------
2015-08-18T00:00:00Z   5.07625
2015-08-18T00:12:00Z   4.950749999999999
2015-08-18T00:24:00Z   4.80675

然后，InfluxDB®执行主查询，只返回那些大于5的平均值。请注意，该主查询指定all_the_means作为SELECT子句中的field key。

计算多个DERIVATIVE()值的SUM()

> SELECT SUM("water_level_derivative") AS "sum_derivative" FROM (SELECT DERIVATIVE(MEAN("water_level")) AS "water_level_derivative" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m),"location") GROUP BY "location"
name: h2o_feet
tags: location=coyote_creek
time                   sum_derivative
----                   --------------
1970-01-01T00:00:00Z   -0.4950000000000001
name: h2o_feet
tags: location=santa_monica
time                   sum_derivative
----                   --------------
1970-01-01T00:00:00Z   -0.043999999999999595

该查询返回每个location中water_level的平均值的导数之和。

InfluxDB®首先执行子查询，计算以12分钟为间隔获取的water_level的平均值的导数，它对每个location都进行了计算，并将输出列命名为water_level_derivative：

> SELECT DERIVATIVE(MEAN("water_level")) AS "water_level_derivative" FROM "h2o_feet" WHERE time >= '2015-08-18T00:00:00Z' AND time <= '2015-08-18T00:30:00Z' GROUP BY time(12m),"location"
name: h2o_feet
tags: location=coyote_creek
time                   water_level_derivative
----                   ----------------------
2015-08-18T00:12:00Z   -0.23800000000000043
2015-08-18T00:24:00Z   -0.2569999999999997
name: h2o_feet
tags: location=santa_monica
time                   water_level_derivative
----                   ----------------------
2015-08-18T00:12:00Z   -0.0129999999999999
2015-08-18T00:24:00Z   -0.030999999999999694

然后，InfluxDB®执行主查询，计算每个location的water_level_derivative的总和。请注意，该主查询指定water_level_derivative（而不是water_level或derivative）作为SUM()函数中的field key。

子查询的常见问题

在子查询中有多个SELECT语句

InfluxQL支持在主查询中有多个嵌套的子查询：

SELECT_clause FROM ( SELECT_clause FROM ( SELECT_statement ) [...] ) [...]
                     ------------------   ----------------
                         Subquery 1          Subquery 2

InfluxQL不支持在子查询中有多个SELECT语句：

SELECT_clause FROM (SELECT_statement; SELECT_statement) […]

如果在子查询中有多个SELECT语句，那么系统会返回解析错误。

3、InfluxQL函数

https://blog.csdn.net/weixin_41827053/article/details/131172670

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

上一篇
Open3D点云数据处理（五）：点云、mesh可...

下一篇
内网安全：内网穿透详解

站长推荐

stm32使用HAL库配置串口中断收发数据（保姆级教程）
stm32使用HAL库配置串口中断收发数据（保姆级教程）
SpringSecurity实现前后端分离认证授权
SpringSecurity实现前后端分离认证授权
U8W/U8W-Mini使用与常见问题解决
U8W/U8W-Mini使用与常见问题解决
【社区图书馆】伴我前行的一本书《The C Programming Language》
【社区图书馆】伴我前行的一本书《The C Programming Language》
【云原生进阶之容器】第六章容器网络6.6.1--Cilium网络方案概述
【云原生进阶之容器】第六章容器网络6.6.1--Cilium网络方案概述