文档文档

InfluxDB OSS v1

使用 InfluxQL 探索数据

此页面记录了早期版本的 InfluxDB OSS。InfluxDB OSS v2 是最新的稳定版本。请参阅等效的 InfluxDB v2 文档： 查询字段和标签。

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.12.0
InfluxDB shell 1.12.0
>

接下来，熟悉 h2o_feet 测量数据中的这个子样本

名称：h2o_feet

时间水位描述位置水位
2015-08-18T00:00:00Z6 到 9 英尺之间coyote_creek8.12
2015-08-18T00:00:00Z低于 3 英尺santa_monica2.064
2015-08-18T00:06:00Z6 到 9 英尺之间coyote_creek8.005
2015-08-18T00:06:00Z低于 3 英尺santa_monica2.116
2015-08-18T00:12:00Z6 到 9 英尺之间coyote_creek7.887
2015-08-18T00:12:00Z低于 3 英尺santa_monica2.028

h2o_feet measurement 中的数据以六分钟的时间间隔出现。该 measurement 有一个 tag key (location)，它有两个 tag value：coyote_creek 和 santa_monica。该 measurement 还有两个 field：level description 存储字符串 field value，water_level 存储浮点 field value。所有这些数据都在 NOAA_water_database database 中。

免责声明： level description 字段不是原始 NOAA 数据的一部分 - 我们偷偷将其放入其中，以便拥有一个带有特殊字符和字符串 field value 的 field key。

基本的 SELECT 语句

SELECT 语句从特定的 measurement 或多个 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 语句不能同时包含聚合函数和非聚合函数、field key 或 tag key。有关更多信息，请参阅关于混合聚合查询和非聚合查询的错误。

FROM 子句

FROM 子句支持多种格式来指定 measurement(s)

FROM <measurement_name>            返回来自单个 measurement 的数据。如果您正在使用 CLI，则 InfluxDB 将查询 USEd database 和 DEFAULT retention policy 中的 measurement。如果您正在使用 InfluxDB API，则 InfluxDB 将查询 db 查询字符串参数和 DEFAULT retention policy 中指定的 database 中的 measurement。

FROM <measurement_name>,<measurement_name>            返回来自多个 measurement 的数据。

FROM <database_name>.<retention_policy_name>.<measurement_name>            返回来自完全限定 measurement 的数据。通过指定 measurement 的 database 和 retention policy 来完全限定 measurement。

FROM <database_name>..<measurement_name>            返回来自用户指定的 database 和 DEFAULT retention policy 中的 measurement 的数据。

其他支持的功能：正则表达式

引用

标识符如果包含 [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 查询 USEd database 和 DEFAULT retention policy 中的数据。如果您正在使用 InfluxDB API，请务必将 db 查询字符串参数设置为 NOAA_water_database。如果您未设置 rp 查询字符串参数，则 InfluxDB API 会自动查询 database 的 DEFAULT retention policy。

从单个 measurement 中选择特定的 tag 和 field

> 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

该查询选择 level description field、location tag 和 water_level field。请注意，当 SELECT 子句包含 tag 时，必须至少指定一个 field。

从单个 measurement 中选择特定的 tag 和 field，并提供其标识符类型

> 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

该查询从 h2o_feet measurement 中选择 level description field、location tag 和 water_level field。::[field | tag] 语法指定标识符是 field 还是 tag。使用 ::[field | tag] 来区分相同的 field key 和 tag key 。对于大多数用例，此语法不是必需的。

从单个 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 measurement 中选择所有 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 的 field value 乘以 2，并将这些值加上 4。请注意，InfluxDB 遵循标准运算顺序。有关支持的运算符的更多信息，请参阅数学运算符。

从多个 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

该查询选择 NOAA_water_database、autogen retention policy 和 measurement h2o_feet 中的数据。

在 CLI 中，完全限定 measurement 以查询 USEd database 以外的 database 和 DEFAULT retention policy 以外的 retention policy 中的数据。在 InfluxDB API 中，如果需要，完全限定 measurement 以代替使用 db 和 rp 查询字符串参数。

从特定 database 中的 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

该查询选择 NOAA_water_database、DEFAULT retention policy 和 h2o_feet measurement 中的数据。.. 表示指定 database 的 DEFAULT retention policy。

在 CLI 中，指定 database 以查询 USEd database 以外的 database 中的数据。在 InfluxDB API 中，如果需要，指定 database 以代替使用 db 查询字符串参数。

SELECT 语句的常见问题

在 SELECT 子句中选择 tag key

查询需要在 SELECT 子句中至少包含一个 field key 才能返回数据。如果 SELECT 子句仅包含单个 tag key 或多个 tag key，则查询返回空响应。此行为是系统存储数据方式的结果。

示例

以下查询不返回任何数据，因为它在 SELECT 子句中指定了单个 tag key (location)

> SELECT "location" FROM "h2o_feet"
>

要返回与 location tag key 关联的任何数据，查询的 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 和/或 时间戳过滤数据。

阅读累了吗？查看此 InfluxQL 短视频

语法

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

WHERE 子句支持对 field、tag 和时间戳的 conditional_expression。

注意 InfluxDB 不支持在 WHERE 子句中使用 OR 来指定多个时间范围。例如，InfluxDB 为以下查询返回空响应

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

Field

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

WHERE 子句支持与字符串、布尔值、浮点数和整数 field value 进行比较。

在 WHERE 子句中用单引号引起字符串 field value。使用未加引号的字符串 field value 或双引号引起的字符串 field value 的查询将不返回任何数据，并且在大多数情况下，不会返回错误。

支持的运算符
运算符含义
=等于
<>不等于
!=不等于
>大于
>=大于或等于
<小于
<=小于或等于

其他支持的功能：算术运算、正则表达式

Tag

tag_key <operator> ['tag_value']

在 WHERE 子句中用单引号引起 tag value。使用未加引号的 tag value 或双引号引起的 tag value 的查询将不返回任何数据，并且在大多数情况下，不会返回错误。

支持的运算符
运算符含义
=等于
<>不等于
!=不等于

其他支持的功能：正则表达式

时间戳

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

此页面上的时间语法部分详细介绍了如何在 WHERE 子句中指定替代时间范围。

示例

选择具有特定 field key-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 measurement 中返回 field value 为 water_level 且大于 8 的数据。

选择具有特定字符串 field key-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 measurement 中返回 field value 为 level description 且等于 below 3 feet 字符串的数据。InfluxQL 要求在 WHERE 子句中用单引号引起字符串 field value。

选择具有特定 field key-value 并执行基本算术运算的数据

> 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 measurement 中返回 field value water_level 加 2 且大于 11.9 的数据。请注意，InfluxDB 遵循标准运算顺序。有关支持的运算符的更多信息，请参阅数学运算符。

选择具有特定 tag key-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 measurement 中返回 tag key location 设置为 santa_monica 的数据。InfluxQL 要求在 WHERE 子句中用单引号引起 tag value。

选择具有特定 field key-value 和 tag key-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 measurement 中返回 tag key location 未设置为 santa_monica 且 field value water_level 小于 -0.59 或大于 9.95 的数据。WHERE 子句支持运算符 AND 和 OR，并支持使用括号分隔逻辑。

选择具有特定时间戳的数据

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

该查询从 h2o_feet measurement 中返回 时间戳在过去七天内的数据。此页面上的时间语法部分提供了有关 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 对 field 进行分组。

GROUP BY tag
GROUP BY 时间间隔基本语法高级语法GROUP BY 时间间隔和 fill()

GROUP BY tag

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

观看关于 GROUP BY with tag 的 InfluxQL 短视频

语法

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 子句之后。

其他支持的功能：正则表达式

示例

按单个 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 函数来计算 h2o_feet measurement 中 location 的每个 tag value 的平均 water_level。InfluxDB 在两个 series 中返回结果：每个 location tag value 一个。

注意： 在 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 函数来计算 h2o_quality measurement 中 location tag 和 randtag tag 的每个组合的平均 index。在 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 函数来计算 h2o_quality measurement 中每个可能的 tag 组合的平均 index。

请注意，查询结果与示例 2中明确指定 location 和 randtag tag key 的查询结果相同。这是因为 h2o_quality measurement 只有两个 tag key。

GROUP BY 时间间隔

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 literal。它确定 InfluxDB 如何按时间对查询结果进行分组。例如，5m 的 time_interval 将查询结果分组为跨 WHERE 子句中指定的时间范围的五分钟时间组。

fill(<fill_option>)

fill(<fill_option>) 是可选的。它更改了没有数据的时间间隔报告的值。有关更多信息，请参阅GROUP BY 时间间隔和 fill()。

覆盖范围

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

基本语法示例

以下示例使用示例数据的以下子样本

> 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 函数来计算 tag location = coyote_creek 的 water_level 点的数量，并将结果分组为 12 分钟间隔。

每个 时间戳的结果代表一个 12 分钟的间隔。第一个时间戳的计数涵盖了 2015-08-18T00:00:00Z 和高达但不包括 2015-08-18T00:12:00Z 之间的原始数据。第二个时间戳的计数涵盖了 2015-08-18T00:12:00Z 和高达但不包括 2015-08-18T00:24:00Z 之间的原始数据。

将查询结果分组为 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 点的数量。它按 location tag 并分组为 12 分钟间隔来分组结果。请注意，时间间隔和 tag key 在 GROUP BY 子句中用逗号分隔。

该查询返回两个 series 的结果：每个 location tag 的 tag value 一个。每个时间戳的结果代表一个 12 分钟的间隔。第一个时间戳的计数涵盖了 2015-08-18T00:00:00Z 和高达但不包括 2015-08-18T00:12:00Z 之间的原始数据。第二个时间戳的计数涵盖了 2015-08-18T00:12:00Z 和高达但不包括 2015-08-18T00:24:00Z 之间的原始数据。

基本语法的常见问题

查询结果中意外的时间戳和值

使用基本语法，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时间 >= 2015-08-18T00:00:00Z 且时间 < 2015-08-18T00:12:00Z时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:12:00Z8.0052015-08-18T00:00:00Z
2时间 >= 2015-08-12T00:12:00Z 且时间 < 2015-08-18T00:24:00Z时间 >= 2015-08-12T00:12:00Z 且时间 < 2015-08-18T00:18:00Z7.8872015-08-18T00:12:00Z

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

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

高级 GROUP BY time() 语法允许用户移动 InfluxDB database 的预设时间边界的开始时间。示例 3在高级语法部分中继续显示此处显示的查询；它将预设时间边界向前移动六分钟，以便 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 literal。它向前或向后移动 InfluxDB database 的预设时间边界。 offset_interval 可以是正数或负数。

fill(<fill_option>)

fill(<fill_option>) 是可选的。它更改了没有数据的时间间隔报告的值。有关更多信息，请参阅GROUP BY 时间间隔和 fill()。

覆盖范围

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

高级语法示例

以下示例使用示例数据的以下子样本

> 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

该查询使用 InfluxDB 函数来计算平均 water_level，将结果分组为 18 分钟的时间间隔，并将预设时间边界偏移六分钟。

没有 offset_interval 的查询的时间边界和返回的时间戳符合 InfluxDB database 的预设时间边界。让我们首先检查没有偏移的结果

> 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 database 的预设时间边界

时间间隔编号预设时间边界GROUP BY time() 间隔包含的点返回的时间戳
1时间 >= 2015-08-18T00:00:00Z 且时间 < 2015-08-18T00:18:00Z时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:18:00Z8.005,7.8872015-08-18T00:00:00Z
2时间 >= 2015-08-18T00:18:00Z 且时间 < 2015-08-18T00:36:00Z<— 相同7.762,7.635,7.52015-08-18T00:18:00Z
3时间 >= 2015-08-18T00:36:00Z 且时间 < 2015-08-18T00:54:00Z<— 相同7.372,7.234,7.112015-08-18T00:36:00Z
4时间 >= 2015-08-18T00:54:00Z 且时间 < 2015-08-18T01:12:00Z时间 = 2015-08-18T00:54:00Z6.9822015-08-18T00:54:00Z

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

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

第四个预设的 18 分钟时间边界从 00:54 开始，到 1:12:00 之前结束。一个原始点 (6.982) 同时落在第四个 GROUP BY time() 间隔和第四个时间边界内。

带有 offset_interval 的查询的时间边界和返回的时间戳符合偏移时间边界

时间间隔编号偏移时间边界GROUP BY time() 间隔包含的点返回的时间戳
1时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:24:00Z<— 相同8.005,7.887,7.7622015-08-18T00:06:00Z
2时间 >= 2015-08-18T00:24:00Z 且时间 < 2015-08-18T00:42:00Z<— 相同7.635,7.5,7.3722015-08-18T00:24:00Z
3时间 >= 2015-08-18T00:42:00Z 且时间 < 2015-08-18T01:00:00Z<— 相同7.234,7.11,6.9822015-08-18T00:42:00Z
4时间 >= 2015-08-18T01:00:00Z 且时间 < 2015-08-18T01:18:00ZNANANA

六分钟的偏移间隔向前移动了预设边界的时间范围，以便边界时间范围和相关的 GROUP BY time() 间隔时间范围始终相同。使用偏移量，每个间隔对三个点执行计算，并且返回的时间戳与边界时间范围的开始和 GROUP BY time() 间隔时间范围的开始都匹配。

请注意，offset_interval 强制第四个时间边界超出查询的时间范围，因此查询不返回最后一个间隔的结果。

将查询结果分组为 12 分钟间隔并向后移动预设时间边界
> 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

该查询使用 InfluxDB 函数来计算平均 water_level，将结果分组为 18 分钟的时间间隔，并将预设时间边界偏移 -12 分钟。

注意： 示例 2 中的查询返回的结果与示例 1 中的查询相同，但示例 2 中的查询使用负 offset_interval 而不是正 offset_interval。两个查询之间没有性能差异；在决定正负 offset_interval 之间进行选择时，请随意选择最直观的选项。

没有 offset_interval 的查询的时间边界和返回的时间戳符合 InfluxDB database 的预设时间边界。让我们首先检查没有偏移的结果

> 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 database 的预设时间边界

时间间隔编号预设时间边界GROUP BY time() 间隔包含的点返回的时间戳
1时间 >= 2015-08-18T00:00:00Z 且时间 < 2015-08-18T00:18:00Z时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:18:00Z8.005,7.8872015-08-18T00:00:00Z
2时间 >= 2015-08-18T00:18:00Z 且时间 < 2015-08-18T00:36:00Z<— 相同7.762,7.635,7.52015-08-18T00:18:00Z
3时间 >= 2015-08-18T00:36:00Z 且时间 < 2015-08-18T00:54:00Z<— 相同7.372,7.234,7.112015-08-18T00:36:00Z
4时间 >= 2015-08-18T00:54:00Z 且时间 < 2015-08-18T01:12:00Z时间 = 2015-08-18T00:54:00Z6.9822015-08-18T00:54:00Z

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

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

第四个预设的 18 分钟时间边界从 00:54 开始，到 1:12:00 之前结束。一个原始点 (6.982) 同时落在第四个 GROUP BY time() 间隔和第四个时间边界内。

带有 offset_interval 的查询的时间边界和返回的时间戳符合偏移时间边界

时间间隔编号偏移时间边界GROUP BY time() 间隔包含的点返回的时间戳
1时间 >= 2015-08-17T23:48:00Z 且时间 < 2015-08-18T00:06:00ZNANANA
2时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:24:00Z<— 相同8.005,7.887,7.7622015-08-18T00:06:00Z
3时间 >= 2015-08-18T00:24:00Z 且时间 < 2015-08-18T00:42:00Z<— 相同7.635,7.5,7.3722015-08-18T00:24:00Z
4时间 >= 2015-08-18T00:42:00Z 且时间 < 2015-08-18T01:00:00Z<— 相同7.234,7.11,6.9822015-08-18T00:42:00Z

负 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 分钟的时间间隔，并将预设时间边界偏移六分钟。

没有 offset_interval 的查询的时间边界和返回的时间戳符合 InfluxDB database 的预设时间边界。让我们首先检查没有偏移的结果

> 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时间 >= 2015-08-18T00:00:00Z 且时间 < 2015-08-18T00:12:00Z时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:12:00Z8.0052015-08-18T00:00:00Z
2时间 >= 2015-08-12T00:12:00Z 且时间 < 2015-08-18T00:24:00Z时间 >= 2015-08-12T00:12:00Z 且时间 < 2015-08-18T00:18:00Z7.8872015-08-18T00:12:00Z

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

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

带有 offset_interval 的查询的时间边界和返回的时间戳符合偏移时间边界

时间间隔编号偏移时间边界GROUP BY time() 间隔包含的点返回的时间戳
1时间 >= 2015-08-18T00:06:00Z 且时间 < 2015-08-18T00:18:00Z<— 相同8.005,7.8872015-08-18T00:06:00Z
2time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:30:00ZNANANA

六分钟偏移间隔会将预设边界的时间范围向前移动，使得预设边界时间范围和相关的 GROUP BY time() 间隔时间范围相同。使用偏移后，查询返回单个结果，并且返回的时间戳与边界时间范围的开始和 GROUP BY time() 间隔时间范围的开始都匹配。

请注意，offset_interval 强制第二个时间边界位于查询的时间范围之外，因此查询不会为第二个间隔返回任何结果。

GROUP BY 时间间隔和 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 多个内容（例如，标签和时间间隔），则 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)

不使用 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

使用 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) 将没有数据的时间间隔报告的值更改为 100。

不使用 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

使用 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) 将没有数据的时间间隔报告的值更改为线性插值的结果。

注意： 示例 2 中的数据不在 NOAA_water_database 中。我们必须创建一个数据不太规则的数据集才能使用 fill(linear)。

不使用 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

使用 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) 为没有数据的时间间隔报告无值且无时间戳。

不使用 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

使用 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(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

使用 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) 将没有数据的时间间隔报告的值更改为 3.235，即前一个时间间隔的值。

fill() 的常见问题

当查询的时间范围内没有数据时，使用 fill() 的查询

目前，如果查询的时间范围内没有数据，则查询会忽略 fill()。这是预期行为。GitHub 上有一个未解决的功能请求建议即使查询的时间范围不包含任何数据，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) 不会填充没有数据的时间间隔的结果。

示例

以下查询涵盖 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() previous 不会填充 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

注意： 问题 3 中的数据不在 NOAA_water_database 中。我们必须创建一个数据不太规则的数据集才能使用 fill(linear)。

INTO 子句

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

语法

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

INTO 子句支持多种格式来指定指标

INTO <measurement_name>            将数据写入指定的指标。如果您正在使用CLI，则 InfluxDB 会将数据写入 USEd 数据库和 DEFAULT 保留策略中的指标。如果您正在使用 InfluxDB API，则 InfluxDB 会将数据写入 db 查询字符串参数和 DEFAULT 保留策略中指定的数据库中的指标。

INTO <database_name>.<retention_policy_name>.<measurement_name>            将数据写入完全限定的指标。通过指定数据库和保留策略来完全限定指标。

INTO <database_name>..<measurement_name>            将数据写入用户指定的数据库和 DEFAULT 保留策略中的指标。

INTO <database_name>.<retention_policy_name>.:MEASUREMENT FROM /<regular_expression>/            将数据写入用户指定的数据库和保留策略中，与 FROM 子句中的正则表达式匹配的所有指标。:MEASUREMENT 是对 FROM 子句中匹配的每个指标的反向引用。

示例

重命名数据库

> 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) 在目标数据库中维护源指标名称。请注意，copy_NOAA_water_database 数据库及其 autogen 保留策略必须在运行 INTO 查询之前存在。请参阅数据库管理，了解如何管理数据库和保留策略。

GROUP BY * 子句在目标数据库中保留标签，作为目标数据库中的标签。以下查询不维护标签的系列上下文；标签将作为字段存储在目标数据库 (copy_NOAA_water_database) 中

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

在移动大量数据时，为了避免内存不足，请为不同的指标和时间边界顺序运行 INTO 查询。使用WHERE 子句为每个查询定义时间边界。

没有时间边界的 INTO 查询失败，并显示错误：ERR: no data received。

使用顺序查询移动大量数据
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 *

将查询结果写入指标

> 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

该查询将其结果写入新的指标：h2o_feet_copy_1。如果您正在使用CLI，则 InfluxDB 会将数据写入 USEd 数据库和 DEFAULT 保留策略。如果您正在使用 InfluxDB API，则 InfluxDB 会将数据写入 db 和 rp 查询字符串参数中指定的数据库和保留策略。如果您未设置 rp 查询字符串参数，则 InfluxDB API 会自动将数据写入数据库的 DEFAULT 保留策略。

响应显示 InfluxDB 写入 h2o_feet_copy_1 的点数 (7605)。响应中的时间戳没有意义；InfluxDB 使用 epoch 0 (1970-01-01T00:00:00Z) 作为等效的空时间戳。

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

> 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

该查询将其结果写入新的指标：h2o_feet_copy_2。InfluxDB 将数据写入 where_else 数据库和 autogen 保留策略。请注意，where_else 和 autogen 都必须在运行 INTO 查询之前存在。请参阅数据库管理，了解如何管理数据库和保留策略。

响应显示 InfluxDB 写入 h2o_feet_copy_2 的点数 (7605)。响应中的时间戳没有意义；InfluxDB 使用 epoch 0 (1970-01-01T00:00:00Z) 作为等效的空时间戳。

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

> 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() 子句聚合数据。它还将结果写入 all_my_averages 指标。

响应显示 InfluxDB 写入 all_my_averages 的点数 (3)。响应中的时间戳没有意义；InfluxDB 使用 epoch 0 (1970-01-01T00:00:00Z) 作为等效的空时间戳。

该查询是降采样的示例：获取更高精度的数据，将这些数据聚合为较低精度，并将较低精度的数据存储在数据库中。降采样是 INTO 子句的常见用例。

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

> 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 子句中的正则表达式匹配的每个指标中的数据，并将结果写入 where_else 数据库和 autogen 保留策略中具有相同名称的指标。请注意，where_else 和 autogen 都必须在运行 INTO 查询之前存在。请参阅数据库管理，了解如何管理数据库和保留策略。

响应显示 InfluxDB 写入 where_else 数据库和 autogen 保留策略的点数 (5)。响应中的时间戳没有意义；InfluxDB 使用 epoch 0 (1970-01-01T00:00:00Z) 作为等效的空时间戳。

该查询是使用反向引用进行降采样的示例。它从多个指标中获取更高精度的数据，将这些数据聚合为较低精度，并将较低精度的数据存储在数据库中。使用反向引用进行降采样是 INTO 子句的常见用例。

INTO 子句的常见问题

数据丢失

如果 INTO 查询在 SELECT 子句中包含标签键，则查询会将当前指标中的标签转换为目标指标中的字段。这可能会导致 InfluxDB 覆盖先前由标签值区分的点。请注意，此行为不适用于使用 TOP() 或 BOTTOM() 函数的查询。常见问题解答文档详细描述了该行为。

要在目标指标中保留当前指标中的标签作为标签，请在 INTO 查询中 GROUP BY 相关的标签键或 GROUP BY *。

使用 INTO 子句自动化查询

本文档中的 INTO 子句部分介绍了如何手动实现带有 INTO 子句的查询。请参阅连续查询文档，了解如何自动化实时数据上的 INTO 子句查询。在其他用途中，连续查询自动化了降采样过程。

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

该查询首先从 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

该查询在 GROUP BY 子句中使用 InfluxQL 函数和时间间隔来计算查询时间范围中每十二分钟间隔的平均 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> 从指定的指标返回前 N 个点。

语法

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

N 指定要从指定的指标返回的点数。如果 N 大于指标中的点数，则 InfluxDB 返回该系列中的所有点。

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

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

该查询在 GROUP BY 子句中使用 InfluxQL 函数和 标签来计算每个标签和查询时间范围中每十二分钟间隔的平均 water_level。LIMIT 2 请求两个最旧的十二分钟平均值（由时间戳确定）。

请注意，如果不使用 LIMIT 2，则查询将为每个系列返回四个点；查询时间范围中的每个十二分钟间隔一个点。

SLIMIT 子句

SLIMIT <N> 从指定的指标中的 <N> 个系列返回每个点。

语法

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

N 指定要从指定的指标返回的系列数。如果 N 大于指标中的系列数，则 InfluxDB 返回该指标中的所有系列。

有一个未解决的问题，要求带有 SLIMIT 的查询包含 GROUP BY *。请注意，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

该查询从与 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

该查询在 GROUP BY 子句中使用 InfluxQL 函数和时间间隔来计算查询时间范围中每十二分钟间隔的平均 water_level。SLIMIT 1 请求与 h2o_feet 指标关联的单个系列。

请注意，如果不使用 SLIMIT 1，则查询将返回与 h2o_feet 指标关联的两个系列的结果：location=coyote_creek 和 location=santa_monica。

LIMIT 和 SLIMIT

LIMIT <N> 后跟 SLIMIT <N> 从指定指标中的 <N> 个系列返回前 <N> 个点。

语法

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

N1 指定每个指标要返回的点数。如果 N1 大于指标中的点数，则 InfluxDB 返回该指标中的所有点。

N2 指定要从指定的指标返回的系列数。如果 N2 大于指标中的系列数，则 InfluxDB 返回该指标中的所有系列。

有一个未解决的问题，要求带有 LIMIT 和 SLIMIT 的查询包含 GROUP BY *。请注意，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

该查询从与指标 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

该查询在 GROUP BY 子句中使用 InfluxQL 函数和时间间隔来计算查询时间范围中每十二分钟间隔的平均 water_level。LIMIT 2 请求两个最旧的十二分钟平均值（由时间戳确定），SLIMIT 1 请求与 h2o_feet 指标关联的单个系列。

请注意，如果不使用 LIMIT 2 SLIMIT 1，则查询将为与 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 指定要分页的点数。OFFSET 子句需要LIMIT 子句。在没有 LIMIT 子句的情况下使用 OFFSET 子句可能会导致查询结果不一致。

注意： 如果 WHERE 子句包含时间范围，并且 OFFSET 子句将导致 InfluxDB 返回时间戳在该时间范围之外的点，则 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

该查询从 h2o_feet 指标返回第四、第五和第六个点。如果查询不包含 OFFSET 3，则它将返回该指标中的第一、第二和第三个点。

分页点并包含多个子句

> 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 子句指定单个指标。WHERE 子句指定查询的时间范围。GROUP BY 子句按所有标签 (*) 分组结果，并分组为 12 分钟间隔。ORDER BY time DESC 子句以降序时间戳顺序返回结果。LIMIT 2 子句将返回的点数限制为两个。OFFSET 2 子句从查询结果中排除前两个平均值。SLIMIT 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> 分页查询结果中的 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 子句可能会导致查询结果不一致。有一个未解决的问题，要求带有 SLIMIT 的查询包含 GROUP BY *。

注意： 如果 SOFFSET 子句分页超过系列总数，则 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

该查询返回与 h2o_feet 指标和 location = santa_monica 标签关联的系列的数据。如果不使用 SOFFSET 1，则查询返回与 h2o_feet 指标和 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 子句指定单个指标。WHERE 子句指定查询的时间范围。GROUP BY 子句按所有标签 (*) 分组结果，并分组为 12 分钟间隔。ORDER BY time DESC 子句以降序时间戳顺序返回结果。LIMIT 2 子句将返回的点数限制为两个。OFFSET 2 子句从查询结果中排除前两个平均值。SLIMIT 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

时区子句

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 夏令时 (DST) 偏移量。返回的时间戳必须采用RFC3339 格式，UTC 偏移量或 UTC DST 才会显示。time_zone 参数遵循 Internet Assigned Numbers Authority 时区数据库中的 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 和 2262-04-11T23:47:16.854775806Z UTC 之间。对于带有 GROUP BY time() 子句的 SELECT 语句，默认时间范围介于 1677-09-21 00:12:43.145224194 UTC 和 now() 之间。以下部分详细介绍了如何在 SELECT 语句的 WHERE 子句中指定替代时间范围。

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

阅读累了吗？查看此 InfluxQL 短视频

绝对时间

使用日期时间字符串和 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 与绝对时间一起使用。请参阅常见问题解答文档和 GitHub Issue 以获取更多信息。

rfc3339_date_time_string

'YYYY-MM-DDTHH:MM:SS.nnnnnnnnnZ'

.nnnnnnnnn 是可选的，如果未包含，则设置为 .000000000。RFC3339 日期时间字符串需要单引号。

rfc3339_like_date_time_string

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

HH:MM:SS.nnnnnnnnn.nnnnnnnnn 是可选的，如果未包含，则设置为 00:00:00.000000000。类 RFC3339 日期时间字符串需要单引号。

epoch_time

Epoch 时间是自 1970 年 1 月 1 日星期四协调世界时 (UTC) 00:00:00 以来经过的时间量。

默认情况下，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 之间发生的数据。epoch 时间戳末尾的 s 持续时间文字表示 epoch 时间戳以秒为单位。

对类 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 年 9 月 18 日 21:24: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 年 9 月 18 日 21:24:00 之前至少六分钟发生的数据。请注意，- 和 6m 之间的空格是必需的。

相对时间

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

语法

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

now() 是服务器在服务器上执行查询时的 Unix 时间。- 或 + 与持续时间文字之间的空格是必需的。

支持的运算符

运算符含义
=等于
<>不等于
!=不等于
>大于
>=大于或等于
<小于
<=小于或等于

duration_literal

  • 微秒：u 或 µ
  • 毫秒：ms
  • 秒s
  • 分钟m
  • 小时：h
  • 天：d
  • 周：w

示例

使用相对时间指定时间范围

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

该查询返回时间戳在过去一小时内的数据。- 和 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 天之间的数据。+ 和 1000d 之间的空格是必需的。

时间语法的常见问题

使用 OR 选择多个时间间隔

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

有关更多信息，请参阅常见问题解答。

查询 GROUP BY time() 子句中 now() 之后发生的数据

大多数 SELECT 语句的默认时间范围在1677-09-21 00:12:43.145224194 和 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 子句中提供备选的上限。

示例

使用 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() 上限。以下查询仅将下限重置为 now()，使得查询的时间范围在 now() 和 now() 之间

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

配置返回的时间戳

CLI 默认以纳秒纪元格式返回时间戳。使用 precision <format> 命令指定备选格式。InfluxDB API 默认以 RFC3339 格式返回时间戳。使用 epoch 查询字符串参数指定备选格式。

正则表达式

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

目前，InfluxQL 不支持在 WHERE 子句、数据库和保留策略中使用正则表达式来匹配非字符串字段值。

注意： 正则表达式比较比精确字符串比较计算量更大；使用正则表达式的查询不如不使用正则表达式的查询性能好。

语法

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 子句中指定字段键和标签键

> 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 的字段键和标签键。请注意，SELECT 子句中的正则表达式必须至少匹配一个字段键，才能为与正则表达式匹配的标签键返回结果。

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

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

> 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 的测量的平均 degrees。

使用正则表达式在 WHERE 子句中指定标签值

> 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 函数来计算 location 的标签值包含 m 且 water_level 大于 3 的平均 water_level。

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

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

该查询从 h2o_feet 测量中选择 location 标签没有值的所有数据。NOAA_water_database 中的每个数据点都有 location 的标签值。

可以不使用正则表达式执行相同的查询。有关更多信息，请参阅常见问题解答文档。

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

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" =~ /./

name: h2o_feet
time                   mean
----                   ----
1970-01-01T00:00:00Z   4.442107025822523

该查询使用 InfluxQL 函数来计算所有具有 location 标签值的数据的平均 water_level。

使用正则表达式在 WHERE 子句中指定字段值

> 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 函数来计算 level description 的字段值包含单词 between 的所有数据的平均 water_level。

使用正则表达式在 GROUP BY 子句中指定标签键

> 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 函数来选择每个标签键中包含字母 l 的标签的第一个 index 值。

数据类型和强制转换操作

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

数据类型类型转换操作

数据类型

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

注意： 通常，没有必要在SELECT 子句中指定字段值类型。在大多数情况下，InfluxDB 会拒绝任何尝试将字段值写入到先前接受不同类型字段值的字段的写入操作。

字段值类型可能在不同的分片组中有所不同。在这些情况下，可能有必要在 SELECT 子句中指定字段值类型。请参阅常见问题解答文档，了解有关 InfluxDB 如何处理字段值类型差异的更多信息。

语法

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

该查询返回 water_level 字段键的浮点数值。

类型转换操作

:: 语法允许用户在查询中执行基本类型转换操作。目前，InfluxDB 支持将字段值从整数转换为浮点数或从浮点数转换为整数。

语法

SELECT_clause <field_key>::<type> FROM_clause

type 可以是 float 或 integer。

如果查询尝试将整数或浮点数转换为字符串或布尔值，InfluxDB 不会返回任何数据。

示例

将浮点字段值转换为整数

> 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 的浮点字段值的整数形式。

将浮点字段值转换为字符串（此功能尚不支持）

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

由于尚不支持将浮点字段值转换为字符串，因此该查询不返回任何数据。

合并行为

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

示例

NOAA_water_database 中的 h2o_feet 测量是两个序列的一部分。第一个序列由 h2o_feet 测量和 location = coyote_creek 标签组成。第二个序列由 h2o_feet 测量和 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 子句中指定相关标签

> 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 语句。

示例

示例 1：CLI 示例 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 ) [...] ) [...]

提高时间限制子查询的性能

为了提高带有时间限制子查询的 InfluxQL 查询的性能，请将 WHERE time 子句应用于外部查询，而不是内部查询。例如，以下查询返回相同的结果，但外部查询带有时间限制的查询比内部查询带有时间限制的查询性能更高

SELECT inner_value AS value FROM (SELECT raw_value as inner_value)
WHERE time >= '2020-07-19T21:00:00Z'
AND time <= '2020-07-20T22:00:00Z'
内部查询上的时间限制
SELECT inner_value AS value FROM (
  SELECT raw_value as inner_value
  WHERE time >= '2020-07-19T21:00:00Z'
  AND time <= '2020-07-20T22:00:00Z'
)

示例

计算多个 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() 函数中的字段键。

计算两个字段之间 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

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

InfluxDB 首先执行子查询。子查询计算 cats 字段中的值与 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() 函数中的字段键。

计算多个 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

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

InfluxDB 首先执行子查询。子查询计算从 2015-08-18T00:00:00Z 到 2015-08-18T00:30:00Z 的 water_level 的 MEAN() 值，并将结果分组为 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 子句中的字段键。

计算多个 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() 函数中的字段键。

子查询的常见问题

子查询中的多个 SELECT 语句

InfluxQL 支持每个主查询中嵌套多个子查询

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

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

SELECT_clause FROM (SELECT_statement; SELECT_statement) [...]

如果子查询包含多个 SELECT 语句，系统将返回解析错误。

此页面是否对您有帮助？

感谢您的反馈！

© 2025 InfluxData, Inc.

您的 InfluxDB OSS URL 是什么？

自定义您的 InfluxDB OSS URL，我们将为您更新代码示例。

默认
自定义

有关更多信息，请参阅InfluxDB OSS URL。

感谢您的反馈！

请告诉我们如何做得更好

谢谢！

不用了，谢谢

Flux 的未来

Flux 将进入维护模式。您可以继续像现在一样使用它，而无需更改任何代码。

阅读更多

现已正式发布

InfluxDB 3 Core 和 Enterprise

快速启动。更快扩展。

获取更新

InfluxDB 3 Core 是一个开源、高速、近期数据引擎，可实时收集和处理数据，并将其持久化到本地磁盘或对象存储。InfluxDB 3 Enterprise 构建在 Core 的基础上，增加了高可用性、读取副本、增强的安全性以及数据压缩，从而实现更快的查询和优化的存储。InfluxDB 3 Enterprise 的免费层级可供非商业家庭或业余爱好者使用。

有关更多信息，请查看