原地址：https://docs.influxdata.com/influxdb/v1.6/query_language/data_exploration/#order-by-time-desc

警告！此页面记录了不再积极开发的InfluxDB的早期版本。InfluxDB v1.7是InfluxDB的最新稳定版本。

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

基础：	配置查询结果：	查询语法的一般提示：
SELECT语句	按时间顺序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.6.x
InfluxDB shell 1.6.x
>

接下来，熟悉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语句查询来自特定测量或测量的数据。

句法

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

语法描述

该SELECT声明需要一个SELECT条款和一个FROM条款。

`SELECT` 条款

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

SELECT * 返回所有字段和标记。

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

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

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

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

其他支持的功能：算术运算，函数，基本转换运算，正则表达式

`FROM` 条款

该FROM子句支持几种用于指定测量的格式：

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

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

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

FROM <database_name>..<measurement_name> 从用户指定的数据库中的度量和DEFAULT 保留策略返回数据。

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

引用

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

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

例子

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

> 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

如果您使用的是CLI，请确保USE NOAA_water_database在运行查询之前输入。CLI查询USEd数据库中的数据和 DEFAULT 保留策略。如果您正在使用HTTP API，请确保将db 查询字符串参数设置为NOAA_water_database。如果未设置rp查询字符串参数，HTTP 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字段值乘以2，并将这些值加4。请注意，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中，完全限定度量以查询除USEd数据库以外的数据库和保留策略以外的 DEFAULT保留策略中的数据。在HTTP 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指定数据库保留策略。

在CLI中，指定数据库以查询除USEd数据库之外的数据库中的数据。在HTTP API中，根据需要指定数据库以代替使用db查询字符串参数。

SELECT语句的常见问题

在SELECT子句中选择标记键

查询至少需要一个场关键的在SELECT返回数据的条款。如果该SELECT子句仅包含单个标记键或多个标记键，则查询将返回空响应。此行为是系统存储数据的结果。

例

以下查询不返回任何数据，因为它location在SELECT子句中指定了单个标记key（）：

> SELECT "location" FROM "h2o_feet"
>

要返回与location标记键关联的任何数据，查询的SELECT 子句必须至少包含一个字段键（water_level）：

> 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-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子句支持conditional_expression字段，标记和时间戳。

字段

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

该WHERE子句支持对string，boolean，float和integer 字段值进行比较。

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

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

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

时间戳

对于大多数SELECT语句，默认时间范围介于UTC 1677-09-21 00:12:43.145224194和2262-04-11T23:47:16.854775806ZUTC之间。对于SELECT带有GROUP BY time()子句的语句，默认时间范围介于1677-09-21 00:12:43.145224194UTC和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.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测量的数据，字段值 water_level加上2，大于11.9。请注意，InfluxDB遵循标准操作顺序。有关支持的运算符的更多信息，请参阅数学运算符。

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

> 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测量数据。InfluxQL需要在子句中围绕标记值使用单引号。locationsanta_monicaWHERE

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

> 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`子句查询意外返回任何数据

在大多数情况下，此问题是标记值或字符串字段值周围缺少单引号的结果。使用不带引号或双引号的标记值或字符串字段值的查询将不会返回任何数据，并且在大多数情况下，不会返回错误。

下面代码块中的前两个查询尝试指定标记值， 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子句按用户指定的标记集或时间间隔对查询结果进行分组。

GROUP BY标签
GROUP BY时间间隔：	基本语法	高级语法	GROUP BY时间间隔和fill（）

GROUP BY标签

GROUP BY <tag>查询按用户指定的标记集对查询结果进行分组。

厌倦了阅读？看看这个InfluxQL短片：

句法

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

语法描述

GROUP BY * 按所有标签分组结果

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 函数计算测量中标记和标记的index每个组合的平均值。使用子句中的逗号分隔多个标记。location randtagh2o_qualityGROUP 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 函数计算测量中index每个可能的标记组合的h2o_quality平均值。

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

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()的查询需要InfluxQL 功能中SELECT条款和在一个时间范围 WHERE条款。请注意，该GROUP BY子句必须在该WHERE子句之后。

`time(time_interval)`

本time_interval该在GROUP BY time()子句是文字的持续时间。它确定InfluxDB组如何随时间查询结果。例如，time_interval的5m基团查询结果划分为横跨在指定的时间范围内的五分钟时间组WHERE子句。

`fill(<fill_option>)`

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

覆盖范围：

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

基本语法的示例

以下示例使用以下示例数据的子示例：

> 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分钟。

每个时间戳的结果代表一个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子句中用逗号分隔。

该查询返回两个系列的结果：每个标签值的的location标签。每个时间戳的结果代表一个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()查询需要InfluxQL 功能中SELECT条款和在一个时间范围 WHERE条款。请注意，该GROUP BY子句必须在该WHERE子句之后。

`time(time_interval,offset_interval)`

有关详细信息，请参阅Basic GROUP BY time（）语法time_interval。

这offset_interval是一个持续时间字面值。它向前或向后移动InfluxDB的预设时间边界。offset_interval可以是正面的也可以是负面的。

`fill(<fill_option>)`

fill(<fill_option>)是可选的。它会更改报告的没有数据的时间间隔值。有关详细信息，请参阅GROUP BY时间间隔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`	NA	NA	NA

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

时间界限，并返回时间戳查询，而不将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`

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

时间界限，并返回时间戳查询与该 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`	NA	NA	NA

六分钟偏移间隔向前移动预设边界的时间范围，使得预设边界时间范围和相关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()更改报告的没有数据的时间间隔的值。请注意，如果您有几件事情（例如，标签和时间间隔），则fill()必须在GROUP BY子句的末尾。GROUP(ing) BY

fill_option

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

linear 报告没有数据的时间间隔的线性插值结果。

none 报告没有时间戳，没有没有数据的时间间隔值。

null 对于没有数据但返回时间戳的时间间隔报告为null。这与默认行为相同。

previous 报告上一时间间隔的值，表示没有数据的时间间隔。

例子

示例1：fill（100）示例2：fill（线性）示例3：fill（无）示例4：fill（null）示例5：填充（上一个）

没有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()`

查询`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:36:00Z用结果填充结果2015-09-18T16:24: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:36:00Z时间间隔和2016-11-11T21:48:00Z时间间隔中的值填充 2016-11-11T21:24:00Z时间间隔和 2016-11-11T22:00: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子句将查询结果写入用户指定的度量。

句法

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

语法描述

该INTO子句支持几种指定测量的格式：

INTO <measurement_name> 将数据写入指定的测量值。如果您正在使用CLI，则 InfluxDB会将数据写入USEd 数据库中的度量和DEFAULT 保留策略。如果您正在使用HTTP 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子句中的时间边界。这可以防止系统内存不足。下面的代码块提供了这些查询的示例语法：

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

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

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

将查询结果写入度量

> 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 保留策略。如果您使用的HTTP API，InfluxDB将数据写入到指定的数据库和保留策略db和rp查询字符串参数。如果未设置rp查询字符串参数，则HTTP API会自动将数据写入数据库的DEFAULT保留策略。

响应显示7605InfluxDB写入的points（）数h2o_feet_copy_1。响应中的时间戳没有意义; 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 查询。有关如何管理数据库和保留策略，请参阅数据库管理。

响应显示7605InfluxDB写入的points（）数h2o_feet_copy_2。响应中的时间戳没有意义; 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测量结果。

响应显示3InfluxDB写入的points（）数all_my_averages。响应中的时间戳没有意义; 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 查询。有关如何管理数据库和保留策略，请参阅数据库管理。

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

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

该`INTO`条款的常见问题

缺失数据

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

将当前度量中的标记保留为目标度量中GROUP BY的标记，相关标记键或查询GROUP BY *中的标记INTO。

使用该`INTO`子句自动执行查询

INTO本文档中的子句部分显示了如何使用INTO子句手动实现查询。有关如何自动执行实时数据的子句查询，请参阅Continuous Queries文档INTO。在其他用途中，Continuous Queries自动执行下采样过程。

按时间顺序DESC

缺省情况下，InfluxDB按升序时间顺序返回结果; 返回的第一个点具有最旧的时间戳，返回的最后一个点具有最新的时间戳。 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子句之后。WHEREGROUP 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查询时间范围内每个12分钟间隔的平均值。 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指定从指定测量返回的点数。如果大于测量中的点数，InfluxDB将返回该系列中的所有点。N

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

该查询使用InfluxQL 函数和GROUP BY子句计算water_level每个标记的平均值以及查询时间范围内每个12分钟间隔的平均值。 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指定从指定测量返回的系列数。如果大于测量中的系列数，InfluxDB将返回该测量的所有系列。N

有一个持续的问题需要查询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查询时间范围内每个12分钟间隔的平均值。 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指定每次测量返回的点数。如果大于测量中的点数，InfluxDB将返回该测量中的所有点。N1

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

该查询使用InfluxQL 函数和GROUP BY子句中的时间间隔来计算water_level查询时间范围内每个12分钟间隔的平均值。 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条款。使用OFFSET不带LIMIT子句的子句会导致查询结果不一致。

注意：如果WHERE子句包含时间范围，InfluxDB将不返回任何结果，并且该OFFSET子句将导致InfluxDB返回时间戳超出该时间范围的点。

例子

Paginate点

> 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，则返回该测量的第一，第二和第三点。

Paginate指出并包括几个条款

> 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条款。使用SOFFSET不带SLIMIT子句的子句会导致查询结果不一致。有一个持续的问题需要查询SLIMIT包含GROUP BY *。

注意：如果SOFFSET子句分页超过系列总数，则InfluxDB不返回任何结果。

例子

Paginate系列

> 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 1h2o_feetlocation = coyote_creek

Paginate系列包括所有条款

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

name: h2o_feet
tags: location=santa_monica
time                   mean
----                   ----
2015-08-18T00:12:00Z   2.077
2015-08-18T00:00:00Z   2.09

这个例子非常复杂，所以这里是逐个细分的：

如果没有SOFFSET 1，查询将返回不同系列的结果：

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

时区条款

该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

查询结果包括时间戳中时区的UTC偏移量（-05:00）America/Chicago。

时间语法

绝对时间

相对时间

时间语法的常见问题

厌倦了阅读？看看这个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不支持OR在该WHERE 子句中使用绝对时间。有关详细信息，请参阅常见问题解答文档和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需要在or 和duration文本之间有一个空格。+-

例子

使用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 持续时间的文字是在信号出现时间标记的结束指示该历元时间戳是在秒。

对类似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需要。

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

> 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和1000天之间now()。之间的空白+和1000d需要。

时间语法的常见问题

使用`OR`选择的时间多的时间间隔

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

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

查询`now()`带有`GROUP BY time()`子句后发生的数据

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

要使用后面出现的时间戳查询数据now()，SELECT带有GROUP BY time()子句的语句必须在子句中提供备用上限 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:00Z180周和之间的数据 now()：

> 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>命令指定备用格式。默认情况下，HTTP 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]不受支持。

使用正则表达式在SELECT子句中使用函数指定字段键

> SELECT DISTINCT(/level/) FROM "h2o_feet" WHERE "location" = 'santa_monica' AND time >= '2015-08-18T00:00:00.000000000Z' AND time <= '2015-08-18T00:12:00Z'

name: h2o_feet
time                   distinct_level description   distinct_water_level
----                   --------------------------   --------------------
2015-08-18T00:00:00Z   below 3 feet                 2.064
2015-08-18T00:00:00Z                                2.116
2015-08-18T00:00:00Z                                2.028

该查询使用InfluxQL 函数为包含该单词的每个字段键返回不同的字段值level。

使用正则表达式在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 函数计算包含该单词的数据库中degrees每个度量的平均值。NOAA_water_databasetemperature

使用正则表达式在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测量中的所有数据。每个数据点中有一个标记值。locationNOAA_water_databaselocation

没有正则表达式就可以执行相同的查询。有关详细信息，请参阅常见问题解答文档。

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

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

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

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

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

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'santa_monica' AND "level description" =~ /between/

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

该查询使用InfluxQL 函数来计算water_level字段值level description包含该字的所有数据的平均值between。

使用正则表达式在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 函数为index包含l 其标记键中的字母的每个标记选择第一个值。

数据类型和强制转换操作

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

数据类型

演员行动

数据类型

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

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

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

句法

SELECT_clause <field_key>::<type> FROM_clause

语法描述

type可以是float，integer，string，或boolean。在大多数情况下，如果field_key不存储指定的数据，InfluxDB将不返回任何数据type。有关更多信息，请参阅Cast操作。

例

> 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不返回任何数据。

例子

将float字段值转换为整数

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

查询不返回任何数据，因为尚未支持将float字段值强制转换为字符串。

合并行为

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

例

该h2o_feet 测量在NOAA_water_database是的两部分串联。第一个系列由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：HTTP 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

子查询

子查询是嵌套在FROM另一个查询的子句中的查询。使用子查询将查询作为条件应用于封闭查询中。子查询提供类似于嵌套函数和SQL [ HAVING子句]（https://en.wikipedia.org/wiki/Having_ ( SQL ））的功能。

句法

SELECT_clause FROM ( SELECT_statement ) [...]

语法描述

InfluxDB首先执行子查询，然后执行主查询。

主查询围绕子查询，至少需要SELECT子句和FROM子句。主查询支持本文档中列出的所有子句。

子查询出现在主查询的FROM子句中，它需要包围括号。子查询支持本文档中列出的所有子句。

InfluxQL支持每个主查询多个嵌套子查询。多个子查询的示例语法：

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

例子

计算 `SUM()`几个`MAX()`值

> 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

查询返回water_level每个标记值的最大值之和location。

InfluxDB首先执行子查询; 它计算water_level每个标签值的最大值location：

> 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

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

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大于5 的字段的所有平均值。

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

计算 `SUM()`几个`DERIVATIVE()`值

> 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

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

InfluxDB首先执行子查询。子查询计算water_level以12分钟为间隔的平均值的导数。它为每个标记值执行该计算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执行主查询并计算water_level_derivative每个标记值的总和location。请注意，主查询指定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语句，则系统返回解析错误。

posted on 2019-01-08 16:37 *（00）* 阅读(555) 评论(0) 收藏举报

刷新页面返回顶部

公告

基本的SELECT语句

例

GROUP BY子句

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

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

按所有标记对结果进行分组

time(time_interval)

fill(<fill_option>)

将查询结果分组为12分钟

将查询结果分组为12分钟，并通过标记键

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

time(time_interval,offset_interval)

fill(<fill_option>)

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

将查询结果分组为12分钟，并将预设时间边界移回

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

fill_option

查询fill()时没有数据落在查询的时间范围内

查询fill(previous)以前的结果何时超出查询的时间范围

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

INTO条款

按时间顺序DESC

LIMIT和SLIMIT条款

OFFSET和SOFFSET条款

时区条款

时间语法

`time(time_interval)`

`fill(<fill_option>)`

`time(time_interval,offset_interval)`

`fill(<fill_option>)`

查询`fill()`时没有数据落在查询的时间范围内

查询`fill(previous)`以前的结果何时超出查询的时间范围

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