首页

使用InfluxQL探索数据

InfluxQL是一种类SQL的查询语言，用于与InfluxDB中的数据进行交互。下面将详细介绍InfluxQL的SELECT语句和实用的数据查询语法。

基础 查询结果的配置 有关查询语法的提示
SELECT语句 ORDER BY time DESC 时间语法
WHERE子句 LIMIT和SLIMIT子句 正则表达式
GROUP BY子句 OFFSET和SOFFSET子句 数据类型和转换
INTO子句 时区子句 合并
多个语句
子查询

示例数据

本文档使用美国国家海洋和大气管理局(NOAA)业务海洋产品和服务中心提供的公开数据。请参阅示例数据章节下载数据，并按照下面的例子进行查询。

首先，登录Influx CLI：

$ influx -precision rfc3339 -database NOAA_water_database
Connected to http://localhost:8086 version 1.8.x
InfluxDB shell 1.8.x
>

接着，熟悉以下h2o_feet中measurement的部分示例数据。

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:00:00Z below 3 feet santa_monica 2.064
2015-08-18T00:06:00Z between 6 and 9 feet coyote_creek 8.005
2015-08-18T00:06:00Z below 3 feet santa_monica 2.116
2015-08-18T00:12:00Z between 6 and 9 feet coyote_creek 7.887
2015-08-18T00:12:00Z below 3 feet santa_monica 2.028

h2o_feet中的数据以六分钟为间隔。h2o_feet有一个tag key（location），它有两个tag value：coyote_creek和santa_monica。h2o_feet还有两个field：level description存储字符串类型的field value，而water_level存储浮点类型的field value。所有这些数据都存在数据库NOAA_water_database中。

免责声明：level description不是NOAA原始数据的一部分，我们在这里加入这个field是为了拥有具有特殊字符和特殊字符串的field value。

SELECT语句

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

语法

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

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

SELECT子句

SELECT           子句支持多种指定数据的格式：

SELECT *           返回所有的fields和tags。

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。 The ::[field | tag]

​  返回特定的field和tag。::[field | tag]语法指定的标识符的类型。使用此语法来区分具有相同名称的field key和tag key。

支持的其他功能：数学运算符，函数，基本数据类型转换，正则表达式

注意： SELECT语句不能包含聚合函数和非聚合函数，field key或tag key。有关更多信息，请参阅有关混合聚合查询和非聚合查询的错误。

FROM子句

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

FROM <measurement_name>从一个measurement中返回数据。如果您使用CLI查询数据，那么访问的measurement属于USE指定的数据库，并且使用的是默认保留策略。如果您使用的是InfluxDB 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:00Z   20.24
2015-08-18T00:00:00Z   8.128
[...]
2015-09-18T21:36:00Z   14.132
2015-09-18T21:42:00Z   13.876

该查询将water_level中的每个值乘以2，然后再加上4。请注意，InfluxDB遵循标准的算术运算顺序。可查看InfluxQL数学运算符章节了解更多相关信息。

查询多个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"
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-09-18T21:36:00Z   5.066        santa_monica
2015-09-18T21:42:00Z   4.938        santa_monica

WHERE语句

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

语法

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

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

注意 InfluxDB不支持在WHERE子句中使用OR来指定多个时间范围。 例如，InfluxDB对以下查询不返回任何数：

> SELECT * FROM "absolutismus" WHERE time = '2016-07-31T20:07:00Z' OR time = '2016-07-31T23:07:17Z'

Fields

field_key <operator> ['string' | boolean | float | integer]

WHERE子句支持对field value进行比较，field value可以是字符串、布尔值、浮点数或者整数。

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

支持的操作符：

支持的操作符：
操作符 含义
= 等于
<> 不等于
!= 不等于
> 大于
>= 大于等于
< 小于
<= 小于等于

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

Tags

tag_key <operator> ['tag_value']

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

支持的操作符：
操作符 含义
= 等于
<> 不等于
!= 不等于

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

Timestamps

对于大多数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()。

本页面中的时间语法 章节将详细介绍如何在WHERE子句中指定其它的时间范围。

示例

查询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。请注意，TSDBInfluxDB遵循标准的算术运算顺序。可查看数学运算符章节了解更多相关信息。

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

GROUP BY子句

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

GROUP BY子句按以下方式对查询结果进行分组：

  • 一个或多个指定的tags
  • 指定的时间间隔

**注意：**不能使用GROUP BY对fields进行分组

按tags进行分组
按时间间隔分组: 基础语法 高级语法 按时间间隔分组并回填数据

GROUP BY tags

GROUP BY <tag>按一个或多个指定的tags对查询结果进行分组

语法

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

GROUP BY *    按所有tags对查询结果进行分组。

GROUP BY <tag_key>    按指定的一个tag对查询结果进行分组。

GROUP BY <tag_key>,<tag_key>    按多个tag对查询结果进行分组， tag keys的顺序对结果无影响。

如果查询语句中包含一个 WHERE clause子句，那么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:00Z	 5.359342451341401


name: h2o_feet
tags: location=santa_monica
time			               mean
----			               ----
1970-01-01T00:00:00Z	 3.530863470081006

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

注意：在InfluxDB中，epoch 0（1970-01-01T00:00:00Z）通常用作空时间戳。如果在您的请求结果中没有时间戳返回，例如您用了具有无限时间范围的聚合函数，InfluxDB将返回epoch 0作为时间戳。

按多个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:00Z  50.69033760186263

name: h2o_quality
tags: location=coyote_creek, randtag=2
time                   mean
----                   ----
1970-01-01T00:00:00Z   49.661867544220485

name: h2o_quality
tags: location=coyote_creek, randtag=3
time                   mean
----                   ----
1970-01-01T00:00:00Z   49.360939907550076

name: h2o_quality
tags: location=santa_monica, randtag=1
time                   mean
----                   ----
1970-01-01T00:00:00Z   49.132712456344585

name: h2o_quality
tags: location=santa_monica, randtag=2
time                   mean
----                   ----
1970-01-01T00:00:00Z   50.2937984496124

name: h2o_quality
tags: location=santa_monica, randtag=3
time                   mean
----                   ----
1970-01-01T00:00:00Z   49.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:00Z	 50.55405446521169


name: h2o_quality
tags: location=coyote_creek, randtag=2
time			               mean
----			               ----
1970-01-01T00:00:00Z	 50.49958856271162


name: h2o_quality
tags: location=coyote_creek, randtag=3
time			               mean
----			               ----
1970-01-01T00:00:00Z	 49.5164137518956


name: h2o_quality
tags: location=santa_monica, randtag=1
time			               mean
----			               ----
1970-01-01T00:00:00Z	 50.43829082296367


name: h2o_quality
tags: location=santa_monica, randtag=2
time			               mean
----			               ----
1970-01-01T00:00:00Z	 52.0688508894012


name: h2o_quality
tags: location=santa_monica, randtag=3
time			               mean
----			               ----
1970-01-01T00:00:00Z	 49.29386362086556

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

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

GROUP BY time intervals

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

基本的GROUP BY time()语法

语法

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

GROUP BY time()子句中的time_interval（时间间隔）是一个持续时间（duration），决定了InfluxDB按多大的时间间隔将查询结果进行分组。例如，当time_interval为5m时，那么在WHERE子句中指定的时间范围内，将查询结果按5分钟进行分组。

fill(<fill_option>)

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:00Z   8.12          coyote_creek
2015-08-18T00:00:00Z   2.064         santa_monica
2015-08-18T00:06:00Z   8.005         coyote_creek
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
2015-08-18T00:18:00Z   7.762         coyote_creek
2015-08-18T00:18:00Z   2.126         santa_monica
2015-08-18T00:24:00Z   7.635         coyote_creek
2015-08-18T00:24:00Z   2.041         santa_monica
2015-08-18T00:30:00Z   7.5           coyote_creek
2015-08-18T00:30:00Z   2.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:00Z   2
2015-08-18T00:12:00Z   2
2015-08-18T00:24:00Z   2

该查询使用了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:00Z   2
2015-08-18T00:12:00Z   2
2015-08-18T00:24:00Z   2

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

该查询使用了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:00Z   8.12
2015-08-18T00:06:00Z   8.005
2015-08-18T00:12:00Z   7.887
2015-08-18T00:18:00Z   7.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:00Z   1        <----- 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()间隔所对应的实际返回的时间戳。

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:12:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:12:00Z 8.005 2015-08-18T00:00:00Z
2 time >= 2015-08-12T00:12:00Z AND time < 2015-08-18T00:24:00Z time >= 2015-08-12T00:12:00Z AND time < 2015-08-18T00:18:00Z 7.887 2015-08-18T00:12:00Z

第一个预设的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:00Z   2

高级GROUP BY time()语法

语法

SELECT <function>(<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），TSDB For InfluxDB的预设时间边界向前或向后偏移。offset_interval可以是正数或者负数。

fill(<fill_option>)

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:00Z   8.12
2015-08-18T00:06:00Z   8.005
2015-08-18T00:12:00Z   7.887
2015-08-18T00:18:00Z   7.762
2015-08-18T00:24:00Z   7.635
2015-08-18T00:30:00Z   7.5
2015-08-18T00:36:00Z   7.372
2015-08-18T00:42:00Z   7.234
2015-08-18T00:48:00Z   7.11
2015-08-18T00:54:00Z   6.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:00Z   7.884666666666667
2015-08-18T00:24:00Z   7.502333333333333
2015-08-18T00:42:00Z   7.108666666666667

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

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用TSDB For 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:00Z   7.946
2015-08-18T00:18:00Z   7.6323333333333325
2015-08-18T00:36:00Z   7.238666666666667
2015-08-18T00:54:00Z   6.982

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

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:18:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z 8.005,7.887 2015-08-18T00:00:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:36:00Z <— same 7.762,7.635,7.5 2015-08-18T00:18:00Z
3 time >= 2015-08-18T00:36:00Z AND time < 2015-08-18T00:54:00Z <— same 7.372,7.234,7.11 2015-08-18T00:36:00Z
4 time >= 2015-08-18T00:54:00Z AND time < 2015-08-18T01:12:00Z time = 2015-08-18T00:54:00Z 6.982 2015-08-18T00:54:00Z

第一个预设的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的查询，时间边界和返回的时间戳符合指定的偏移时间边界：

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z <— same 8.005,7.887,7.762 2015-08-18T00:06:00Z
2 time >= 2015-08-18T00:24:00Z AND time < 2015-08-18T00:42:00Z <— same 7.635,7.5,7.372 2015-08-18T00:24:00Z
3 time >= 2015-08-18T00:42:00Z AND time < 2015-08-18T01:00:00Z <— same 7.234,7.11,6.982 2015-08-18T00:42:00Z
4 time >= 2015-08-18T01:00:00Z AND time < 2015-08-18T01:18:00Z NA NA NA

这个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:00Z   7.884666666666667
2015-08-18T00:24:00Z   7.502333333333333
2015-08-18T00:42:00Z   7.108666666666667

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

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

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用TSDB For 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:00Z    7.946
2015-08-18T00:18:00Z    7.6323333333333325
2015-08-18T00:36:00Z    7.238666666666667
2015-08-18T00:54:00Z    6.982

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

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:18:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z 8.005,7.887 2015-08-18T00:00:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:36:00Z <— same 7.762,7.635,7.5 2015-08-18T00:18:00Z
3 time >= 2015-08-18T00:36:00Z AND time < 2015-08-18T00:54:00Z <— same 7.372,7.234,7.11 2015-08-18T00:36:00Z
4 time >= 2015-08-18T00:54:00Z AND time < 2015-08-18T01:12:00Z time = 2015-08-18T00:54:00Z 6.982 2015-08-18T00:54:00Z

第一个预设的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的查询，时间边界和返回的时间戳符合指定的偏移时间边界：

时间间隔序号 预设的时间边界 GROUP BY time() 时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-17T23:48:00Z AND time < 2015-08-18T00:06:00Z NA NA NA
2 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z <— same 8.005,7.887,7.762 2015-08-18T00:06:00Z
3 time >= 2015-08-18T00:24:00Z AND time < 2015-08-18T00:42:00Z <— same 7.635,7.5,7.372 2015-08-18T00:24:00Z
4 time >= 2015-08-18T00:42:00Z AND time < 2015-08-18T01:00:00Z <— same 7.234,7.11,6.982 2015-08-18T00:42:00Z

这个负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:00Z   2

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

对于没有offset_interval的查询，时间边界和返回的时间戳依旧沿用TSDB For 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:00Z   1
2015-08-18T00:12:00Z   1

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

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:12:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:12:00Z 8.005 2015-08-18T00:00:00Z
2 time >= 2015-08-12T00:12:00Z AND time < 2015-08-18T00:24:00Z time >= 2015-08-12T00:12:00Z AND time < 2015-08-18T00:18:00Z 7.887 2015-08-18T00:12:00Z

第一个预设的12分钟时间边界从00:00开始，刚好在12:00前结束。只有一个数据点（8.005），同时落在查询的第一个GROUP BY time()时间间隔和第一个时间边界内。请注意，虽然返回的时间戳发生在查询的时间范围开始之前，但是查询结果排除了在查询时间范围之前发生的数据。

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

对于有offset_interval的查询，时间边界和返回的时间戳符合指定的偏移时间边界：

时间间隔序号 预设的时间边界 GROUP BY time()时间间隔 包含的数据点 返回的时间戳
1 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z <— same 8.005,7.887 2015-08-18T00:06:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:30:00Z NA NA NA

这个6分钟的偏移间隔将预设边界的时间范围向前偏移6分钟，使得边界的时间范围跟相关的GROUP BY time()间隔的时间范围始终相同。

使用偏移间隔，该查询返回一个结果，并且返回的时间戳与边界时间范围的开始和GROUP BY time()时间范围的开始都相匹配。

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

GROUP BY time() 时间间隔和数据回填 fill()

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

语法

SELECT <function>(<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多个对象（例如，tags 和时间间隔），那么fill()必须放在GROUP BY子句后面。

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

示例

示例 1: fill(100) 示例 2: fill(linear) 示例 3: fill(none) 示例 4: fill(null) 示例 5: fill(previous)

Without 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With 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
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z   100

fill(100) changes the value reported for the time interval with no data to 100.

Without 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:00Z   1
2016-11-11T21:12:00Z
2016-11-11T21:24:00Z   3
2016-11-11T21:36:00Z
2016-11-11T21:48:00Z
2016-11-11T22:00:00Z   6

With 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:00Z   1
2016-11-11T21:12:00Z   2
2016-11-11T21:24:00Z   3
2016-11-11T21:36:00Z   4
2016-11-11T21:48:00Z   5
2016-11-11T22:00:00Z   6

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

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

Without 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235

fill(none) reports no value and no timestamp for the time interval with no data.

Without 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

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

Without 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With 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:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z   3.235

fill(previous) changes the value reported for the time interval with no data to 3.235, the value from the previous time interval.

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:00Z   3.235
2015-09-18T16:36:00Z   3.235
2015-09-18T16:48:00Z   4

下一个查询将缩短以上查询的时间范围，现在，查询覆盖的时间范围变为从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:00Z   4
在前一个或后一个结果不在查询时间范围内的情况下使用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:00Z   3
2016-11-11T21:36:00Z   4
2016-11-11T21:48:00Z   5
2016-11-11T22:00:00Z   6

下一个查询将缩短以上查询的时间范围，现在，查询覆盖的时间范围变为从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:00Z   6

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

INTO子句

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

语法

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

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

INTO <measurement_name>

将数据写入到一个指定的measurement。如果您使用CLI写入数据，那么写入数据的measurement属于指定的数据库，并且使用的是默认（DEFAULT）的保留策略。如果您使用的是InfluxDB 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 < 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）的保留策略。如果您使用的是InfluxDB 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。TSDB For 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。

返回结果显示TSDB For InfluxDB®写入到all_my_averages中的数据点个数(3)。返回结果中的时间戳是没有意义的，TSDB For 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子句自动查询实时数据。连续查询其中一个用途就是使降采样的过程自动化。

ORDER BY time DESC

InfluxDB默认按递增的时间顺序返回结果。第一个返回的数据点，其时间戳是最早的，而最后一个返回的数据点，其时间戳是最新的。ORDER BY time DESC将默认的时间顺序调转，使得TSDB For 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的数据点。

LIMIT和SLIMIT子句

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

LIMIT子句

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

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] LIMIT <N>

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 <N> 返回指定measurement的前N个系列中的每一个数据点。

语法

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

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 <N>放在LIMIT <N>的后面，则返回指定measurement的N个系列中的前N个数据点。

语法

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

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中的两个序列，并且，每个序列返回四个数据点。

OFFSET及SOFFSET子句

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

OFFSET子句 SOFFSET子句

OFFSET子句

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

语法

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] LIMIT_clause OFFSET <N> [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

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

如果以上查询语句中没有使用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>表示从查询结果中的第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表示从第N个系列开始返回。使用SOFFSET子句需要先使用SLIMIT子句，在没有SLIMIT子句的情况下使用SOFFSET子句，可能会导致出现不一致的查询结果。

Note: InfluxDB returns no results if the SOFFSET clause paginates through more than the total number of series.

注意：：如果*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

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

如果以上查询语句中没有使用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

The Time Zone clause

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

InfluxDB默认以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）。

时间语法

对于大多数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子句中指定其它的时间范围。

以下详细介绍了如何在SELECT中指定替代时间范围语句的WHERE子句。

绝对时间 相对时间 时间语法常见问题

绝对时间

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

语法

SELECT_clause FROM_clause WHERE time <operator> ['<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，请查看FAQ文档和GitHub问题获得更多相关信息。

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 <operator> now() [[ - | + ] <duration_literal>] [(AND|OR) now() [...]]

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

支持的操作符

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

duration_literal

单位 含义
u或µ 微秒
ms 毫秒
s 秒
m 分钟
h 小时
d 天
w 周

示例

用相对时间指定时间范围

> 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来指定多个时间间隔。若想获得更多相关信息，请查阅FAQ相关章节。

在带有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()之间的数据：

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location"='santa_monica' AND time >= '2015-09-18T21:30:00Z' 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

运行一个带有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 <format> 来指定其它的时间格式。InfluxDB API默认返回RFC3339格式的时间戳，可通过参数epoch来指定其它的时间格式。

正则表达式

在以下指定内容中，InfluxQL支持使用正则表达式：

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

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

语法

SELECT /<regular_expression_field_key>/ FROM /<regular_expression_measurement>/ WHERE [<tag_key> <operator> /<regular_expression_tag_value>/ | <field_key> <operator> /<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]。

在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，所以该查询不返回任何结果。

在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不为空。

在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的第一个值。

数据类型和转换

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

The query returns no data as casting a float field value to a string is not yet supported.

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

合并

在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

多个语句

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

示例

Example 1: CLI Example 2: InfluxDB API

在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

在InfluxDB 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
                        ]
                    ]
                }
            ]
        }
    ]
}

子查询

子查询是嵌套在另一个查询的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语句，那么系统会返回解析错误。

Where are you running InfluxDB?

Select where you're using InfluxDB Cloud or InfluxDB OSS and we'll customize code examples with your InfluxDB URL.

InfluxDB OSS

Default
Custom

InfluxDB Cloud

AWS
GCP
Azure

For more information, see InfluxDB URLs.

InfluxDB OSS 2.0 release candidate

InfluxDB OSS v2.0.rc includes breaking changes that require a manual upgrade from all alpha and beta versions. For information, see:

Upgrade to InfluxDB OSS v2.0.rc