使用InfluxQL探索数据

InfluxQL 是一种类似 SQL 的查询语言，用于与 InfluxDB 中的数据交互。以下部分详细介绍 InfluxQL 的 SELECT 语句和用于探索数据的有用查询语法。

基础知识：	配置查询结果：	查询语法的一般提示：
选择语句	按时间降序排列	时间语法
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.11.8
InfluxDB shell 1.11.8
>

接下来，了解此数据子样本中的 h2o_feet 测量：

名称: h2o_feet

时间	级别描述	位置	水位
2015-08-18T00:00:00Z	在6到9英尺之间	coyote_creek	8.12
2015-08-18T00:00:00Z	低于3英尺	圣塔莫尼卡	2.064
2015-08-18T00:06:00Z	在6到9英尺之间	coyote_creek	8.005
2015-08-18T00:06:00Z	低于3英尺	圣塔莫尼卡	2.116
2015-08-18T00:12:00Z	在6到9英尺之间	coyote_creek	7.887
2015-08-18T00:12:00Z	低于3英尺	圣塔莫尼卡	2.028

数据在 h2o_feet 测量中发生，时间间隔为六分钟。该测量具有一个标签键 (location)，并具有两个标签值: coyote_creek 和 santa_monica。该测量还具有两个字段: level description 存储字符串字段值，而 water_level 存储浮点字段值。所有这些数据都在 NOAA_water_database 数据库中。

免责声明： level description 字段并不是原始 NOAA 数据的一部分 - 我们将其悄悄加入，以便拥有一个带有特殊字符和字符串字段值的字段键。

基本的 SELECT 语句

该 SELECT 语句从特定的 measurement 或多个测量中查询数据。

语法

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

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

`SELECT` 子句

《code》SELECT《/code》子句支持几种指定数据的格式：

SELECT * 返回所有 fields 和 tags。

SELECT "<field_key>" 返回特定字段。

SELECT "<field_key>","<field_key>" 返回多个字段。

SELECT "<field_key>","<tag_key>" 返回一个特定的字段和标签。 SELECT子句在包含标签时必须指定至少一个字段。

SELECT "<field_key>"::field,"<tag_key>"::tag 返回特定的字段和标签。 ::[field | tag] 语法指定了标识符的类型。使用此语法区分名称相同的字段键和标签键。

其他支持的功能：算术运算, 函数, 基本类型转换操作, 正则表达式

注意： SELECT 语句不能同时包含聚合函数和非聚合函数、字段关键字或标签关键字。有关更多信息，请参见关于混合聚合和非聚合查询的错误。

`FROM` 子句

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

FROM <measurement_name> 从单个测量中返回数据。如果您使用CLI，InfluxDB 查询在USEd的数据库中的测量和DEFAULT 保留策略。如果您使用InfluxDB API，InfluxDB 查询在db查询字符串参数指定的数据库中的测量和DEFAULT 保留策略。

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

FROM <database_name>.<retention_policy_name>.<measurement_name> 从完全合格的测量中返回数据。通过指定其数据库和保留策略来完全限定测量。

FROM <database_name>..<measurement_name> 从用户指定的数据库中的一个测量返回数据，以及DEFAULT 保留策略。

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

引用

标识符必须使用双引号，如果它们包含除了 [A-z,0-9,_] 以外的字符，或者如果它们以数字开头，或者如果它们是一个 InfluxQL 关键字。虽然并非总是必要，但我们建议您使用双引号标识符。

注意：查询的引用语法与行协议不同。请查看查询中的单引号和双引号规则。

示例

从单个测量中选择所有字段和标签

> 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 选择所有 fields 和 tags。

如果您正在使用CLI，请确保在运行查询之前输入USE NOAA_water_database。该CLI查询USE的数据库中的数据以及DEFAULT 保留策略。如果您正在使用InfluxDB API，请确保将db 查询字符串参数设置为NOAA_water_database。如果您不设置rp查询字符串参数，InfluxDB API会自动查询数据库的DEFAULT保留策略。

从单个测量中选择特定的标签和字段

> 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 字段，location 标签，以及 water_level 字段。注意，当 SELECT 子句包含标签时，必须至少指定一个字段。

从单个测量中选择特定标签和字段，并提供它们的标识符类型

> 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

查询选择 level description 字段、location 标签和 water_level 字段来自 h2o_feet 测量。 ::[field | tag] 语法指定标识符是字段还是标签。使用 ::[field | tag] 来区分相同的字段键和标签键。对于大多数用例，不需要该语法。

从单个测量中选择所有字段

> 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 测量中选择所有字段。
SELECT 子句支持将 * 语法与 :: 语法结合使用。

从测量中选择一个特定字段并执行基本算术运算

> 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 的字段值乘以二，并在这些值上加四。注意，InfluxDB 遵循标准的运算顺序。有关支持的运算符，请参见数学运算符。

选择来自多个测量的所有数据

> 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

查询选择两个测量的所有字段和标签： h2o_feet 和 h2o_pH。用逗号 (,) 分隔多个测量。

从完全限定的测量中选择所有数据

> 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 保留策略，以及测量 h2o_feet。

在CLI中，完全限定一个测量以查询其他数据库中的数据，而不是USE的数据库，并且在除了DEFAULT保留策略以外的保留策略中。在InfluxDB API中，如果需要，完全限定一个测量来替代使用db和rp查询字符串参数。

从特定数据库中的一个测量中选择所有数据

> 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 保留策略，以及 h2o_feet 测量值。 .. 表示指定数据库的 DEFAULT 保留政策。

在命令行界面中，指定要查询的数据库，以便在其他数据库中查询数据，而不是在USE的数据库中。在InfluxDB API中，如果需要，指定数据库来替代使用db查询字符串参数。

SELECT语句的常见问题

在SELECT子句中选择标签键

查询至少需要一个字段键在 SELECT 子句中以返回数据。如果 SELECT 子句仅包含一个标签键或多个标签键，则查询返回空响应。这种行为是由于系统存储数据的方式所致。

示例

以下查询返回没有数据，因为它在SELECT子句中指定了一个单一的标签键(location)：

> SELECT "location" FROM "h2o_feet"
>

要返回与location标签键相关的任何数据，查询的SELECT子句必须至少包含一个字段键(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 基于字段, 标签和/或时间戳过滤数据。

厌倦了阅读？查看这个 InfluxQL 简介：

语法

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

WHERE 子句支持针对字段、标签和时间戳的条件表达式。

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

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

字段

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

该 WHERE 子句支持与字符串、布尔值、浮点数和整数字段值的比较。

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

支持的操作符

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

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

时间戳

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

示例

选择具有特定字段键值的数据

> 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数据，字段值为water_level的值大于八。

选择具有特定字符串字段键值的数据

> 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 测量的数据，字段值为 level description 等于 below 3 feet 字符串。InfluxQL 在 WHERE 子句中要求字符串字段值使用单引号。

选择具有特定字段键值的数据并执行基本算术运算

> SELECT * FROM "h2o_feet" WHERE "water_level" + 2 > 11.10

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 测量的数据，字段值为 water_level 加上两个大于 11.10 的值。请注意，InfluxDB 遵循标准的运算顺序。有关支持的运算符的更多信息，请参见 Mathematical Operators。

选择具有特定标签键值的数据

> 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 测量中返回数据，其中标签键 location 设置为 santa_monica。InfluxQL 在 WHERE 子句中要求用单引号包围标签值。

选择具有特定字段键值和标签键值的数据

> 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度量的数据，其中标签键location未设置为santa_monica，并且字段值water_level小于-0.59或大于9.95。WHERE子句支持运算符AND和OR，并支持使用括号分隔逻辑。

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

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

查询返回过去七天内的时间戳的h2o_feet测量数据。本页的时间语法部分提供了关于WHERE子句中支持的时间语法的详细信息。

与`WHERE`子句相关的常见问题

一个 `WHERE` 子句查询意外地没有返回数据

在大多数情况下，这个问题是由于缺少单引号包围 tag values 或字符串 field values导致的。未加引号或使用双引号的标签值或字符串字段值的查询将不会返回任何数据，并且在大多数情况下，将不会返回错误。

下面代码块中的前两个查询尝试在没有任何引号和使用双引号的情况下指定标签值 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

下面代码块中的前两个查询尝试指定字符串字段值 at or greater than 9 feet，没有任何引号以及使用双引号。第一个查询返回错误，因为字符串字段值包含空格。第二个查询没有返回任何结果。第三个查询用单引号 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 子句：

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

注意： 您不能使用 GROUP BY 来对字段进行分组。

按标签分组
按时间区间分组:	基本语法	高级语法	按时间区间分组并填充()

按标签分组

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

观看有关 GROUP BY 和标签的 InfluxQL 短视频：

语法

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

GROUP BY * 通过所有 tags 分组结果

GROUP BY <tag_key> 根据特定标签对结果进行分组

GROUP BY <tag_key>,<tag_key> 按多个标签对结果进行分组。标签键的顺序无关紧要。

如果查询包括一个 WHERE 子句，则 GROUP BY 子句必须出现在 WHERE 子句之后。

其他支持的特性：正则表达式

示例

按单个标签分组查询结果

> 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 函数来计算每个标签值的 water_level 的平均值，location 在 h2o_feet 测量中。InfluxDB 返回两组系列的结果：每个 location 标签值对应一组。

注意：在 InfluxDB 中，epoch 0 (1970-01-01T00:00:00Z) 通常用作空时间戳的等效值。如果你请求一个没有时间戳返回的查询，例如一个具有无限时间范围的聚合函数，InfluxDB 将返回 epoch 0 作为时间戳。

按多个标签分组查询结果

> 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 函数来计算每个 location 标签和 randtag 标签在 h2o_quality 测量中的平均 index。在 GROUP BY 子句中使用逗号分隔多个标签。

按所有标签分组查询结果

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

请注意，查询结果与示例 2中查询的结果相同，在该示例中我们明确指定了location和randtag标签键。这是因为h2o_quality测量只有两个标签键。

按时间区间分组

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是一个持续时间字面量。它决定了InfluxDB如何对查询结果进行时间上的分组。例如，time_interval为5m时，会将查询结果分组为五分钟时间组，按照WHERE子句中指定的时间范围。

`fill(<fill_option>)`

fill(<fill_option>) 是可选的。它更改报告的没有数据的时间间隔的值。详情请参见按时间间隔分组及 fill()。

覆盖范围：

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

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

将查询结果按每12分钟进行分组，并按标签键进行分组

> 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 标签分组结果，并分成 12 分钟的时间间隔。请注意，时间间隔和标签键在 GROUP BY 子句中用逗号分隔。

该查询返回两组结果：每个标签值的系列。每个时间戳的结果代表一个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	`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 开始，并在 00:12 前结束。只有一个原始点 (8.005) 同时落在查询的第一个 GROUP BY time() 区间和那个第一个时间边界内。请注意，尽管返回的时间戳发生在查询时间范围开始之前，但查询结果不包含在查询时间范围之前发生的数据。

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

该高级 GROUP BY time() 语法允许用户调整 InfluxDB 数据库预设时间边界的开始时间。示例 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是一个持续时间字面量。它向前或向后移动InfluxDB数据库的预设时间边界。偏移间隔offset_interval可以是正值或负值。

`fill(<fill_option>)`

fill(<fill_option>) 是可选的。它更改报告的没有数据的时间间隔的值。详情请参见按时间间隔分组及 fill()。

覆盖范围：

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

查询不带 offset_interval 的时间边界和返回的时间戳遵循InfluxDB数据库的预设时间边界。让我们先检查不带偏移的结果：

> 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`	<— 相同	`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`	<— 相同	`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 开始，结束于刚好在 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	`time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z`	<— 相同	`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`	<— 相同	`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`	<— 相同	`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`	不适用	不适用	不适用

六分钟的偏移间隔向前移动预设边界的时间范围，使得边界时间范围和相关的 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

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

注意： 示例 2 中的查询返回与示例 1 中的查询相同的结果，但示例 2 中的查询使用的是负的 offset_interval 而非正的 offset_interval。这两个查询之间没有性能差异；在选择正的和负的 offset_interval 时，可以自由选择最直观的选项。

查询没有 offset_interval 的时间边界和返回的时间戳遵循InfluxDB数据库的预设时间边界。我们首先检查没有偏移的结果：

> 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`	<— 相同	`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`	<— 相同	`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:54 开始，结束于 1: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`	无	无	无
2	`time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z`	<— 相同	`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`	<— 相同	`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`	<— 相同	`7.234`,`7.11`,`6.982`	`2015-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数据库的预设时间边界。我们首先检查没有偏移的结果：

> 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`

查询使用的时间边界和返回的时间戳offset_interval 遵循时间偏移边界：

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

六分钟的偏移间隔向前移动预设边界的时间范围，使得预设边界时间范围和相关的 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(ing) BY 几个事物（例如，tags 和一个时间区间）。

填充选项

任何数值报告在没有数据的时间间隔内的给定数值。

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:36:00Z 的结果填充为来自 2015-09-18T16:24: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() 之前并没有填充 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 子句将查询结果写入用户指定的 measurement。

语法

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 保留策略。

反向引用backreference语法 (:MEASUREMENT) 在目标数据库中维护源测量名称。请注意，在运行INTO查询之前，copy_NOAA_water_database数据库及其autogen保留策略必须存在。参见数据库管理以了解如何管理数据库和保留策略。

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

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

当移动大量数据时，我们建议针对不同的测量顺序运行 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 *

将查询的结果写入一个度量

> 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，InfluxDB 会将数据写入 USE 的 database 和 DEFAULT retention policy。如果您使用 InfluxDB API，InfluxDB 会将数据写入在 db 和 rp query string parameters 中指定的数据库和保存策略。如果您没有设置 rp 查询字符串参数，InfluxDB API 会自动将数据写入数据库的 DEFAULT 保存策略。

响应显示了InfluxDB写入到 h2o_feet_copy_1 的点数 (7605)。响应中的时间戳没有意义；InfluxDB使用纪元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 保留策略。请注意，在运行 INTO 查询之前，where_else 和 autogen 必须存在。有关如何管理数据库和保留策略，请参见 Database Management。

响应显示了 InfluxDB 写入到 h2o_feet_copy_2 的点数 (7605)。响应中的时间戳没有意义；InfluxDB 使用时间戳 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 使用纪元 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 function和GROUP BY time()子句汇总数据。它汇总所有在FROM子句中匹配正则表达式的测量数据，并将结果写入同名的测量数据到where_else数据库和autogen保留策略中。请注意，在运行INTO查询之前，where_else和autogen必须存在。有关如何管理数据库和保留策略，请参见数据库管理。

响应显示了InfluxDB写入到where_else数据库和autogen保留策略的点数(5)。响应中的时间戳是无意义的；InfluxDB使用纪元0 (1970-01-01T00:00:00Z) 作为空时间戳的等价物。

该查询是一个带回溯的降采样示例。它从多个测量中获取高精度数据，将这些数据聚合到较低的精度，并将较低精度数据存储在数据库中。带回溯的降采样是INTO子句的一个常见用例。

关于`INTO`子句的常见问题

缺失数据

如果一个 INTO 查询在 SELECT 子句中包含一个 tag key，该查询将当前测量中的 tags 转换为目标测量中的 fields。这可能导致 InfluxDB 重写之前由 tag value 区分的 points。请注意，这种行为不适用于使用 TOP() 或 BOTTOM() 函数的查询。常见问题解答文档详细描述了该行为。

为了将当前测量中的标签作为目标测量中的标签，GROUP BY相关标签键或在INTO查询中使用GROUP BY *。

使用 `INTO` 子句自动化查询

本文件中的INTO子句部分展示了如何手动实现带有INTO子句的查询。有关如何在实时数据上自动化INTO子句查询的内容，请参见连续查询文档。在其他用途中，连续查询自动化了下采样过程。

按时间降序排列

默认情况下，InfluxDB 按时间升序返回结果；第一个 point 返回的是最旧的 timestamp，而最后一个返回的点是最新的时间戳。ORDER BY time DESC 反转了这个顺序，使得 InfluxDB 首先返回最新时间戳的点。

语法

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

ORDER by time DESC 必须出现在GROUP BY 子句之后，如果查询包含GROUP BY子句。ORDER by time DESC 必须出现在WHERE 子句之后，如果查询包含WHERE子句且没有GROUP BY子句。

示例

首先返回最新的积分

> 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

查询使用了一个 InfluxQL 函数和时间间隔在GROUP BY 子句中，计算查询时间范围内每个十二分钟的平均water_level。ORDER BY time DESC首先返回最近的十二分钟时间间隔。

如果没有 ORDER BY time DESC，查询将首先返回 2015-08-18T00:00:00Z，最后返回 2015-08-18T00:36:00Z。

LIMIT 和 SLIMIT 子句

LIMIT 和 SLIMIT 限制了每次查询返回的 points 数量和 series 数量。

LIMIT 子句

LIMIT <N> 返回指定measurement的前 N points。

语法

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

N指定要从指定的measurement返回的points数量。如果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

查询返回三个最古老的 points（由时间戳确定）来自 h2o_feet measurement。

限制返回的点数并包含 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 function 和一个 GROUP BY clause 来计算每个 tag 和查询时间范围内每个十二分钟间隔的平均 water_level。 LIMIT 2 请求两个最古老的十二分钟平均值（由时间戳确定）。

请注意，如果没有 LIMIT 2，则查询将返回每个 series 四个点；每个查询时间范围内的每个十二分钟间隔一个。

SLIMIT 子句

SLIMIT <N> 返回指定 measurement 中的每一个 point 从 <N> series。

语法

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

N 指定要从指定的 measurement 返回的 series 数量。如果 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

查询返回所有 water_level 点来自与 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) 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 子句中计算查询时间范围内每个十二分钟间隔的平均water_level。 SLIMIT 1 请求与h2o_feet测量相关联的单个系列。

请注意，如果没有 SLIMIT 1，查询将返回与 h2o_feet 测量相关的两个系列的结果： location=coyote_creek 和 location=santa_monica。

限制和小限制

LIMIT <N> 后面跟着 SLIMIT <N> 返回指定测量中的前 <N> points 来自 <N> series。

语法

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

N1 指定每个测量返回的点的数量。如果 N1 大于测量中的点数，InfluxDB 将返回该测量中的所有点。

N2 指定从指定的 measurement 返回的系列数量。如果 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

查询返回三个最古老的 points （根据时间戳确定）来自于与 measurement h2o_feet 相关的一个 series。

限制返回的点数和系列，并包含一个 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子句中计算查询时间范围内每个十二分钟的平均water_level。 LIMIT 2 请求两个最旧的十二分钟平均值（根据时间戳确定），SLIMIT 1 请求与h2o_feet 测量相关的单个系列。

请注意，如果没有 LIMIT 2 SLIMIT 1，查询将返回与 h2o_feet 测量相关的两个系列的四个点。

OFFSET 和 SOFFSET 子句

OFFSET 和 SOFFSET 用于分页 points 和 series 所返回的结果。

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 指定要分页的 points 数量。 OFFSET 子句需要一个 LIMIT 子句。使用 OFFSET 子句而不带 LIMIT 子句可能会导致不一致的查询结果。

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

这个例子相当复杂，因此以下是逐条细节的拆解：

The SELECT clause specifies an InfluxQL function. The FROM clause specifies a single measurement. The WHERE clause specifies the time range for the query. The GROUP BY clause groups results by all tags (*) and into 12-minute intervals. The ORDER BY time DESC clause returns results in descending timestamp order. The LIMIT 2 clause limits the number of points returned to two. The OFFSET 2 clause excludes the first two averages from the query results. The SLIMIT 1 clause limits the number of series returned to one.

没有 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 参数遵循互联网分配号码委员会时区数据库中的 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

查询结果包括时间戳的UTC偏移量 (-05:00)，对应于 America/Chicago 时区。

时间语法

对于大多数 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 简介：

绝对时间

使用日期时间字符串和时间戳指定绝对时间。

语法

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 问题获取更多信息。

`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`

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

默认情况下，InfluxDB 假设所有的纪元时间戳都是以纳秒为单位。包括一个持续时间文字在纪元时间戳的末尾，以指示除纳秒以外的精度。

基本算术

所有时间戳格式都支持基本的算术运算。
将一个时间加上 (+) 或减去 (-) 一个时间戳，并使用持续时间文字。请注意，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样式日期时间字符串周围的单引号是必需的。

指定一个时间范围，使用纪元时间戳

> 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假设纪元时间戳以纳秒为单位。

指定具有秒级精度的时间范围时间戳

> 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 duration literal 表示这些时间戳是以秒为单位的。

对RFC3339-like日期时间字符串执行基本算术运算

> 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之间的空格是必需的。

对纪元时间戳进行基本算术运算

> 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运算符来指定多个时间间隔。

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

查询发生在 `now()` 之后的数据，使用 `GROUP BY time()` 子句

大多数 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支持在指定时使用正则表达式：

字段键和标签键在 SELECT 子句
测量值在 FROM 子句中
标签值和字符串字段值在WHERE子句中。
标签键在 GROUP BY 子句

目前，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 函数来计算每个测量在包含单词temperature的NOAA_water_database 数据库中的平均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 函数来计算平均 water_level，其中标签值的 location 包含一个 m 并且 water_level 大于三。

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

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

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

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

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

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

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

该查询使用了一个 InfluxQL function 来计算所有具有 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 将不返回数据。有关更多信息，请参阅 Cast Operations。

示例

> 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 中，查询会自动合并 series。

示例

在 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: 命令行界面示例 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

查询返回所有大于五的 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 执行主查询，并仅返回大于五的平均值。注意，主查询在 SELECT 子句中指定 all_the_means 作为字段键。

计算几个 `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 语句，系统将返回解析错误。

使用InfluxQL探索数据

示例数据

基本的 SELECT 语句

语法

SELECT 子句

FROM 子句

引用

示例

从单个测量中选择所有字段和标签

从单个测量中选择特定的标签和字段

从单个测量中选择特定标签和字段，并提供它们的标识符类型

从单个测量中选择所有字段

从测量中选择一个特定字段并执行基本算术运算

选择来自多个测量的所有数据

从完全限定的测量中选择所有数据

从特定数据库中的一个测量中选择所有数据

SELECT语句的常见问题

在SELECT子句中选择标签键

示例

使用 WHERE 子句

语法

字段

支持的操作符

标签

支持的操作符

时间戳

示例

选择具有特定字段键值的数据

选择具有特定字符串字段键值的数据

选择具有特定字段键值的数据并执行基本算术运算

选择具有特定标签键值的数据

选择具有特定字段键值和标签键值的数据

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

与WHERE子句相关的常见问题

一个 WHERE 子句查询意外地没有返回数据

GROUP BY子句

按标签分组

语法

示例

按单个标签分组查询结果

按多个标签分组查询结果

按所有标签分组查询结果

按时间区间分组

基本的 GROUP BY time() 语法

语法

time(time_interval)

fill(<fill_option>)

基本语法示例

将查询结果分组为12分钟的间隔

将查询结果按每12分钟进行分组，并按标签键进行分组

基本语法的常见问题

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

高级 GROUP BY time() 语法

语法

time(time_interval,offset_interval)

fill(<fill_option>)

高级语法示例

将查询结果按18分钟间隔分组，并向前移动预设时间边界

将查询结果分组为12分钟的间隔，并将预设时间边界向后移动

将查询结果分组为12分钟的时间间隔，并向前移动预设的时间边界

GROUP BY 时间间隔和 fill()

语法

填充选项

示例

与 fill() 的常见问题

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

当上一个结果超出查询的时间范围时使用 fill(previous) 的查询

当前一个或下一个结果超出查询的时间范围时，使用fill(linear)

INTO 子句

语法

示例

重命名数据库

将查询的结果写入一个度量

将查询结果写入完全合格的测量

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

将多个测量的聚合结果写入不同的数据库（带回溯的下采样）

关于INTO子句的常见问题

缺失数据

使用 INTO 子句自动化查询

按时间降序排列

`SELECT` 子句

`FROM` 子句

使用 `WHERE` 子句

与`WHERE`子句相关的常见问题

一个 `WHERE` 子句查询意外地没有返回数据

`time(time_interval)`

`fill(<fill_option>)`

`time(time_interval,offset_interval)`

`fill(<fill_option>)`

`GROUP BY` 时间间隔和 `fill()`

与 `fill()` 的常见问题

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

当上一个结果超出查询的时间范围时使用 `fill(previous)` 的查询

当前一个或下一个结果超出查询的时间范围时，使用`fill(linear)`

关于`INTO`子句的常见问题

使用 `INTO` 子句自动化查询

`OFFSET` 子句

`SOFFSET` 子句

`rfc3339_date_time_string`

`rfc3339_like_date_time_string`

`epoch_time`

`duration_literal`

使用 `OR` 选择多个时间区间

查询发生在 `now()` 之后的数据，使用 `GROUP BY time()` 子句