inteliword
inteliword

InfluxDB 使用InfluxQL语言检索数据语法

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

The Basics: Configure Query Results: General Tips on Query Syntax:
The SELECT statement ORDER BY time DESC Time Syntax
The WHERE clause The LIMIT and SLIMIT clauses Regular Expressions
The GROUP BY clause The OFFSET and SOFFSET clauses Data types and cast operations
The INTO clause The Time Zone clause Merge behavior
Multiple statements
Subqueries

The basic SELECT statement

SELECT语句从特定的measurement或measurements中查询数据。

SELECT [,,] FROM [,]

The SELECT statement requires a SELECT clause and a FROM clause.

SELECT子句

SELECT子句支持几种指定数据的格式：
SELECT * Returns all fields and tags.

SELECT "" Returns a specific field.

SELECT "",""Returns more than one field.

SELECT "","" Returns a specific field and tag. The SELECT clause must specify at least one field when it includes a tag.

SELECT ""::field,""::tag Returns a specific field and tag. The ::[field | tag] syntax specifies the identifier’s type. Use this syntax to differentiate between field keys and tag keys that have the same name.

FROM子句

SELECT子句支持几种指定数据的格式：
FROM 返回单个度量的数据。如果使用的是CLI influxdb，则查询所用数据库中的度量值和默认保留策略。如果使用influxdb API influxdb查询数据库中在db query string参数和默认保留策略中指定的度量值。

FROM , Returns data from more than one measurement.

FROM ..从完全限定的度量返回数据。通过指定度量值的数据库和保留策略来完全限定度量值。

FROM ..返回用户指定数据库中默认保留测量的度量值的数据.

Quoting引用

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

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

示例：
Select all fields and tags from a single measurement

> 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

如果您使用的是CLI，请确保在运行查询之前输入USE NOAA_water_database。CLI查询所用数据库中的数据和默认保留策略。如果使用influxDB API，请确保将db query string参数设置为NOAA_water_database数据库。如果未设置rp query string参数，InfluxDB API将自动查询数据库的默认保留策略。
Select specific tags and fields from a single measurement

> 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

The query selects the level description field, the location tag, and the water_level field.请注意，SELECT子句在包含tag时必须至少指定一个field。
Select specific tags and fields from a single measurement, and provide their identifier type

> 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

The query selects the level description field, the location tag, and the water_level field from the h2o_feet measurement.::[field | tag]语法指定标识符是字段还是标记。使用::[field | tag]区分相同的字段键和标记键。大多数用例都不需要这种语法。

Select all fields from a single measurement

> 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

The query selects all fields from the h2o_feet measurement. The SELECT clause supports combining the * syntax with the :: syntax.

Select a specific field from a measurement and perform basic arithmetic

> 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

The query multiplies water_level’s field values by two and adds four to those values. Note that InfluxDB follows the standard order of operations. See Mathematical Operators for more on supported operators.

Select all data from more than one measurement

> SELECT * FROM "h2o_feet","h2o_pH"

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

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

查询从两个测量值中选择所有字段和标记:h2o_feet and h2o_pH.用逗号(,)分隔多个测量值。

Select all data from a fully qualified measurement
从完全限定测量中查询所有数据

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

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

查询选择NOAA_water_darabase中的数据、autogen保留策略和h2o_feet。
在CLI中，完全限定一个度量值，以查询使用的数据库以外的数据库和默认保留策略以外的保留策略中的数据。在InfluxDB API中，如果需要，完全限定度量值，而不是使用db和rp查询字符串参数。

Select all data from a measurement in a particular database

> 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_darabase中的数据、默认保留策略和h2o_feet测量值。这个..指示指定数据库的默认保留策略。
在CLI中，指定要在已用数据库以外的数据库中查询数据的数据库。在InfluxDB API中，如果需要，指定数据库以代替使用db query string参数。

SELECT语句的常见问题

Selecting tag keys in the SELECT clause
查询要求SELECT子句中至少有一个字段键才能返回数据。如果SELECT子句只包含一个标记键或多个标记键，则查询返回空响应。此行为是系统存储数据方式的结果。
例子
以下查询不返回数据，因为它在SELECT子句中指定了单个标记键（位置）：

> 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

The WHERE clause

The WHERE filters data based on fields, tags, and/or timestamps.

SELECT_clause FROM_clause WHERE  [(AND|OR)  [...]]

The WHERE clause supports conditional_expressions on fields, tags, and timestamps.

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

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

Fields

field_key  ['string' | boolean | float | integer]

WHERE子句支持string、boolean、float和integer字段值进行比较。
WHERE子句中使用单引号字符串字段值。使用非引号字符串字段值或双引号字符串字段值的查询不会返回任何数据，并且在大多数情况下不会返回错误。
Supported operators：

Operator Meaning
= equal to
<> not equal to
!= not equal to
> greater than
>= greater than or equal to
< less than
<= less than or equal to

Tags

tag_key  ['tag_value']

WHERE子句中使用单引号标签值（tag values）。使用非引号字符串字段值或双引号字符串字段值的查询不会返回任何数据，并且在大多数情况下不会返回错误。
Supported operators：

Operator Meaning
= equal to
<> not equal to
!= not equal to

Timestamps

对于大多数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()之间。
此页上的Time语法部分详细说明如何在WHERE子句中指定可选时间范围。

示例：

Select data that have specific field key-values

> 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

The query returns data from the h2o_feet measurement with field values of water_level that are greater than eight.

Select data that have a specific string field key-value

> SELECT * FROM "h2o_feet" WHERE "level description" = 'below 3 feet'

name: h2o_feet
--------------
time                   level description   location       water_level
2015-08-18T00:00:00Z   below 3 feet        santa_monica   2.064
2015-08-18T00:06:00Z   below 3 feet        santa_monica   2.116
[...]
2015-09-18T14:06:00Z   below 3 feet        santa_monica   2.999
2015-09-18T14:36:00Z   below 3 feet        santa_monica   2.907

The query returns data from the h2o_feet measurement with field values of level description that equal the below 3 feet string. InfluxQL requires single quotes around string field values in the WHERE clause.

Select data that have a specific field key-value and perform basic arithmetic

> 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

The query returns data from the h2o_feet measurement with field values of water_level plus two that are greater than 11.9. Note that InfluxDB follows the standard order of operations See Mathematical Operators for more on supported operators.

Select data that have a specific tag key-value

> SELECT "water_level" FROM "h2o_feet" WHERE "location" = 'santa_monica'

name: h2o_feet
--------------
time                   water_level
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
[...]
2015-09-18T21:36:00Z   5.066
2015-09-18T21:42:00Z   4.938

The query returns data from the h2o_feet measurement where the tag key location is set to santa_monica. InfluxQL requires single quotes around tag values in the WHERE clause.

Select data that have specific field key-values and tag key-values

> 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

The query returns data from the h2o_feet measurement where the tag key location is not set to santa_monica and where the field values of water_level are either less than -0.59 or greater than 9.95. The WHERE clause supports the operators AND and OR, and supports separating logic with parentheses.

Select data that have specific timestamps

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

Common issues with the WHERE clause

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

下面代码块中的前两个查询尝试指定不带任何引号和双引号的长度大于或等于9英尺的字符串字段值。第一个查询返回一个错误，因为字符串字段值包含空格。第二个查询不返回结果。第三个查询单引号位于或大于9英尺（这是支持的语法）并返回预期结果。

> 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

The GROUP BY clause

GROUPBY子句按用户指定的标记集或时间间隔对查询结果进行分组。
GROUP BY tags
GROUP BY time intervals: Basic Syntax Advanced Syntax GROUP BY time intervals and fill()

GROUP BY tags

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

SELECT_clause FROM_clause [WHERE_clause] GROUP BY [* | [,

GROUP BY * Groups results by all tags

GROUP BY Groups results by a specific tag

GROUP BY , Groups results by more than one tag. The order of the tag keys is irrelevant.

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

示例

Group query results by a single tag

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

name: h2o_feet
tags: location=coyote_creek
time			               mean
----			               ----
1970-01-01T00:00:00Z	 5.359342451341401


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

查询使用InfluxQL函数计算water_level测量中每个位置标记值的平均水位。InfluxDB返回两个series的结果：location的每个标记值对应一个序列。

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

Group query results by more than one tag

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

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

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

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

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

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

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

查询使用InfluxQL函数来计算h2o_quality度量中location标记和randtag标记的每个组合的平均索引。在GROUPBY子句中用逗号分隔多个标记。
Group query results by all tags

> 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度量中每个可能的标记组合的平均索引。
注意，查询结果与示例2中的查询结果相同，在示例2中，我们显式指定了location和randtag标签键。这是因为h2o_quality测量只有两个标签键。

GROUP BY time intervals

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

SELECT () FROM_clause WHERE  GROUP BY time(),[tag_key] [fill()]

Basic GROUP BY time()查询需要SELECT子句中的InfluxQL函数和WHERE子句中的时间范围。注意GROUP BY子句必须在WHERE子句之后。
time(time_interval)
GROUP BY time()子句中的时间间隔是一个持续时间文本。它确定InfluxDB组随时间查询结果的方式。例如，在WHERE子句中指定的时间范围内，将时间间隔为5m的组查询结果分成5分钟的时间组。
fill()
fill() 是可选的。它更改没有数据的时间间隔的报告值。

Examples of basic syntax

The examples below use the following subsample of the sample data:

> 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

Group query results into 12 minute intervals

> 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之间的原始数据，但不包括上限。
Group query results into 12 minutes intervals and by a tag key

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

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

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

查询使用InfluxQL函数计算water_level点的数量。它按location标签将结果分组，并以12分钟为间隔。注意，时间间隔和标记键在GROUPBY子句中用逗号分隔。
查询返回两系列结果：location标记的每个标记值一个。每个时间戳的结果表示一个12分钟的间隔。第一个时间戳的计数包括2015-08-18T00:00:00Z到2015-08-18T00:12:00Z之间的原始数据，但不包括后者在内；第二个时间戳的计数包括2015-08-18T00:12:00Z到2015-08-18T00:24:00Z之间的原始数据，但不包括后者在内。
Common issues with basic syntax
查询结果中意外的时间戳和值
使用基本语法，infloxdb依赖于GROUP BY time()间隔和系统预设的时间边界来确定每个时间间隔中包含的原始数据和查询返回的时间戳。在某些情况下，这可能会导致意想不到的结果。
例如：
RAW data:

> 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使用预设的整数时间边界来按间隔分组，这些间隔独立于WHERE子句中的任何时间条件。在计算结果时，所有返回的数据都必须出现在查询的显式时间范围内，但按间隔分组将基于预设的时间边界。
下表显示了预设的时间边界、相关的GROUP BY time()间隔、包含的点以及结果中每个GROUP BY time()间隔返回的时间戳。

Time Interval Number Preset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
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继续执行此处显示的查询；它将预设的时间边界向前移动6分钟，以便InfluxDB返回：

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

Advanced GROUP BY time() syntax

SELECT () FROM_clause WHERE  GROUP BY time(,),[tag_key] [fill()]

高级GROUP BY time()查询要求在SELECT子句中使用influxQL函数，在WHERE子句中使用时间范围。注意GROUP BY子句必须在WHERE子句之后。
time(time_interval,offset_interval)
有关time_interval的详细信息，请参见Basic GROUP BY time（）语法。
offset_interval是持续时间文本。它向前或向后移动InfluxDB数据库的预设时间边界。offset_interval可以为正或负。
fill()
fill()是可选的。它更改没有数据的时间间隔的报告值。
总之：
高级的GROUP BY time()查询依赖于time_interval,、offset_interval和InfluxDB数据库的预设时间边界来确定每个时间间隔中包含的原始数据和查询返回的时间戳。
Examples of advanced syntax

> 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

Group query results into 18 minute intervals and shift the preset time boundaries forward

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

name: h2o_feet
time                   mean
----                   ----
2015-08-18T00:06:00Z   7.884666666666667
2015-08-18T00:24:00Z   7.502333333333333
2015-08-18T00:42:00Z   7.108666666666667

查询使用InfluxQL函数计算平均water_level，将结果分组为18分钟的时间间隔，并将预设的时间界限偏移6分钟。
没有偏移间隔的查询的时间边界和返回的时间戳遵循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
Time Interval Number Preset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:18:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z 8.005,7.887 2015-08-18T00:00:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:36:00Z <— same 7.762,7.635,7.5 2015-08-18T00:18:00Z
3 time >= 2015-08-18T00:36:00Z AND time < 2015-08-18T00:54:00Z <— same 7.372,7.234,7.11 2015-08-18T00:36:00Z
4 time >= 2015-08-18T00:54:00Z AND time < 2015-08-18T01:12:00Z time = 2015-08-18T00:54:00Z 6.982 2015-08-18T00:54:00Z

第一个预设的18分钟时间边界从00:00开始，在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的查询的时间边界和返回的时间戳遵循偏移时间边界：

Time Interval Number Offset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
1 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z <— same 8.005,7.887,7.762 2015-08-18T00:06:00Z
2 time >= 2015-08-18T00:24:00Z AND time < 2015-08-18T00:42:00Z <— same 7.635,7.5,7.372 2015-08-18T00:24:00Z
3 time >= 2015-08-18T00:42:00Z AND time < 2015-08-18T01:00:00Z <— same 7.234,7.11,6.982 2015-08-18T00:42:00Z
4 time >= 2015-08-18T01:00:00Z AND time < 2015-08-18T01:18:00Z NA NA NA

六分钟偏移间隔向前移动预设边界的时间范围，使得边界时间范围和相关的GROUP BY time()间隔时间范围始终相同。使用偏移量，每个间隔对三个点执行计算，返回的时间戳与边界时间范围的开始和GROUP BY time()间隔时间范围的开始都匹配。
请注意，offset_interval强制第四个时间边界位于查询的时间范围之外，因此查询不返回最后一个时间间隔的结果。
Group query results into 12 minute intervals and shift the preset time boundaries back

> 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中的查询使用负偏移间隔而不是正偏移间隔。两个查询之间没有性能差异；在确定正偏移间隔和负偏移间隔时，可以自由选择最直观的选项。

没有偏移间隔的查询的时间边界和返回的时间戳遵循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

没有偏移间隔的查询的时间边界和返回的时间戳遵循InfluxDB数据库的预设时间边界：

Time Interval Number Preset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
1 time >= 2015-08-18T00:00:00Z AND time < 2015-08-18T00:18:00Z time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z 8.005,7.887 2015-08-18T00:00:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:36:00Z <— same 7.762,7.635,7.5 2015-08-18T00:18:00Z
3 time >= 2015-08-18T00:36:00Z AND time < 2015-08-18T00:54:00Z <— same 7.372,7.234,7.11 2015-08-18T00:36:00Z
4 time >= 2015-08-18T00:54:00Z AND time < 2015-08-18T01:12:00Z time = 2015-08-18T00:54:00Z 6.982 2015-08-18T00:54:00Z

第一个预设的18分钟时间边界从00:00开始，在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()间隔内和第四个时间边界内。具有偏移间隔的查询的时间边界和返回的时间戳遵循偏移时间边界：

Time Interval Number Offset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
1 time >= 2015-08-17T23:48:00Z AND time < 2015-08-18T00:06:00Z NA NA NA
2 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:24:00Z <— same 8.005,7.887,7.762 2015-08-18T00:06:00Z
3 time >= 2015-08-18T00:24:00Z AND time < 2015-08-18T00:42:00Z <— same 7.635,7.5,7.372 2015-08-18T00:24:00Z
4 time >= 2015-08-18T00:42:00Z AND time < 2015-08-18T01:00:00Z <— same 7.234,7.11,6.982 2015-08-18T00:42:00Z

负的12分钟偏移间隔向后移动预设边界的时间范围，以便边界时间范围和相关的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分钟。
没有偏移间隔的查询的时间边界和返回的时间戳遵循InfluxDB数据库的预设时间边界。我们首先检查不带偏移量的结果：

Time Interval Number Preset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
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()间隔内和第二个时间边界内。
具有偏移间隔的查询的时间边界和返回的时间戳遵循偏移时间边界：

Time Interval Number Offset Time Boundary GROUP BY time() Interval Points Included Returned Timestamp
1 time >= 2015-08-18T00:06:00Z AND time < 2015-08-18T00:18:00Z <— same 8.005,7.887 2015-08-18T00:06:00Z
2 time >= 2015-08-18T00:18:00Z AND time < 2015-08-18T00:30:00Z NA NA NA

六分钟偏移间隔向前移动预设边界的时间范围，使得预设边界时间范围和相关的GROUP BY time()间隔时间范围相同。使用偏移量，查询返回单个结果，返回的时间戳与边界时间范围的开始和GROUP BY time()interval时间范围的开始都匹配。
请注意，offset_interval强制第二个时间边界位于查询的时间范围之外，因此查询不返回该第二个时间间隔的结果。

GROUP BY time intervals and fill()

fill()更改没有数据的时间间隔的报告值。

SELECT () FROM_clause WHERE  GROUP BY time(time_interval,[)]

默认情况下，没有数据的GROUP By time()间隔在输出列中报告空值。fill()更改没有数据的时间间隔的报告值。注意，如果要按多个内容（例如，标记和时间间隔）分组，fill()必须位于GROUP BY子句的末尾。
填充选项
Any numerical value: 在没有数据的情况下报告时间间隔的给定数值。
linear 报告没有数据的时间间隔的线性插值结果。
none没有时间戳和没有数据的时间间隔值。
null对于没有数据的时间间隔，报告null，但返回时间戳。这与默认行为相同。
previous报告没有数据的时间间隔的上一个时间间隔的值。
示例
Without fill(100):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With fill(100):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z   100

fill(100)将没有数据的时间间隔的报告值更改为100。

Without fill(linear):

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

name: pond
time                   mean
----                   ----
2016-11-11T21:00:00Z   1
2016-11-11T21:12:00Z
2016-11-11T21:24:00Z   3
2016-11-11T21:36:00Z
2016-11-11T21:48:00Z
2016-11-11T22:00:00Z   6

With fill(linear):

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

name: pond
time                   mean
----                   ----
2016-11-11T21:00:00Z   1
2016-11-11T21:12:00Z   2
2016-11-11T21:24:00Z   3
2016-11-11T21:36:00Z   4
2016-11-11T21:48:00Z   5
2016-11-11T22:00:00Z   6

fill(linear)在没有数据的情况下将为时间间隔报告的值更改为线性插值的结果。
注：示例2中的数据不在NOAA_water_database 中。我们必须用不太规则的数据创建一个数据集来处理fill(linear)。

Without fill(none):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With fill(none):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235

fill(none)在没有数据的时间间隔内报告没有值和时间戳。
Without fill(null):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With fill(null):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

fill(null)报告空值作为没有数据的时间间隔的值。该结果与不带fill(null)的查询结果相同。
Without fill(previous):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z

With fill(previous):

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

name: h2o_feet
--------------
time                   max
2015-09-18T16:00:00Z   3.599
2015-09-18T16:12:00Z   3.402
2015-09-18T16:24:00Z   3.235
2015-09-18T16:36:00Z   3.235

fill(previous)将为没有数据的时间间隔报告的值更改为3.235，即上一个时间间隔的值。

Common issues with 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 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(previous)。

The INTO clause

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

SELECT_clause INTO  FROM_clause [WHERE_clause] [GROUP_BY_clause]

INTO子句支持几种用于指定度量值的格式：
INTO将数据写入指定的度量。如果使用的是CLI InflouxDB，则会将数据写入所用数据库中的度量值和默认保留策略。如果使用InfluxDB API，InfluxDB会将数据写入db query string参数和默认保留策略中指定的数据库中的度量值。
INTO ..将数据写入完全限定的度量。通过指定度量值的数据库和保留策略来完全限定度量值。
INTO .. :将数据写入用户指定数据库中的度量值和默认保留策略。
INTO ..:MEASUREMENT FROM // 将数据写入用户指定数据库中与FROM子句中的正则表达式匹配的所有度量。:MEASUREMENT是对FROM子句中匹配的每个度量的回溯引用。
示例
Rename a database

> 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_ddatabase和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"./.*/

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

SELECT *
INTO ..
FROM ..
WHERE time > now() - 100w AND time < now() - 90w GROUP BY *

SELECT *
INTO ..
FROM ..}
WHERE time > now() - 90w AND < now() - 80w GROUP BY *

SELECT *
INTO ..
FROM ..
WHERE time > now() - 80w AND time < now() - 70w GROUP BY *

Write the results of a query to a measurement

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

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

> SELECT * FROM "h2o_feet_copy_1"

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

查询将其结果写入一个新的度量值：h2o_feet_copy_1。如果您使用的是CLI，InfluxDB会将数据写入使用的数据库和默认的保留策略。如果您使用的是InfluxDB API，InfluxDB会将数据写入数据库，并在db和rp查询字符串参数中指定保留策略。如果未设置rp query string参数，InfluxDB API会自动将数据写入数据库的默认保留策略。
响应显示InfluxDB写入h2o_feet_copy_1点数（7605）。响应中的时间戳没有意义；InfluxDB使用epoch 0（1970-01-01T00:00:00Z）作为空时间戳等价物。
Write the results of a query to a fully qualified measurement

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

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

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

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

查询将其结果写入一个新的测量值：h2o_-feet_-copy_2。InfluxDB 将数据写入where else数据库和autogen保留策略。请注意，在运行INTO查询之前，where-else和autogen都必须存在。有关如何管理数据库和保留策略，请参阅数据库管理。
响应显示InfluxDB写入h2o_feet_copy_2的点数（7605）。响应中的时间戳没有意义；InfluxDB使用epoch 0（1970-01-01T00:00:00Z）作为空时间戳等价物。
Write aggregated results to a measurement (downsampling)

> 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写入所有平均值的点数（3）。响应中的时间戳没有意义；InflUxDB使用epoch 0（1970-01-01T00:00:00Z）作为空时间戳等价物。查询是降采样的一个例子：获取高精度数据，将这些数据聚合到低精度，并将低精度数据存储在数据库中。降采样是INTO子句的常见用例。
Write aggregated results for more than one measurement to a different database (downsampling with backreferencing)

> 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保留策略中同名的度量。请注意，在运行INTO查询之前，where_else和autogen都必须存在。有关如何管理数据库和保留策略，请参阅数据库管理。
响应显示InfluxDB写入where_else数据库的点数（5）和autogen保留策略。响应中的时间戳没有意义；InfluxDB使用epoch 0（1970-01-01T00:00:00Z）作为空时间戳等价物。
该查询是使用反向引用进行降采样的示例。它从多个测量中获取高精度数据，将这些数据聚合到低精度，并将低精度数据存储在数据库中。带反向引用的降采样是INTO子句的常见用例。

Common issues with the INTO clause

丢失数据
如果INTO查询在SELECT子句中包含标记键，则查询会将当前度量中的标记转换为目标度量中的字段。这可能会导致InfluxDB覆盖先前由标记值区分的点。请注意，此行为不适用于使用TOP()或BOTTOM()函数的查询。常见问题文档详细描述了这种行为。
若要将当前度量中的标记保留为目标度量中的标记，请按相关标记键分组，或在“INTO”查询中按GROUP BY *分组。
Automating queries with the INTO clause
The INTO clause section in this document shows how to manually implement queries with an INTO clause. See the Continuous Queries documentation for how to automate INTO clause queries on realtime data. Among other uses, Continuous Queries automate the downsampling process.

ORDER BY time DESC

默认情况下，InfluxDB按时间升序返回结果；返回的第一个点具有最早的时间戳，返回的最后一个点具有最新的时间戳。ORDER BY time DESC反转该顺序，以便InfluxDB首先返回带有最新时间戳的点。

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

如果查询包含GROUP BY子句，则ORDER BY time DESC必须出现在GROUP BY子句之后。如果查询包含WHERE子句且没有GROUP BY子句，则ORDER BY time DESC必须出现在WHERE子句之后。
示例：
Return the newest points first

> 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

Return the newest points first and include a GROUP BY time() clause

> 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

The LIMIT and SLIMIT clauses

LIMIT子句

LIMIT返回指定测量值的前N个点。

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

N指定从指定测量返回的点数，如果N大于测量中的点数，则InfluxDB将返回该序列中的所有点数。
注意：LIMIT子句必须按照上述语法中列出的顺序出现。
示例
Limit the number of points returned

> 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

Limit the number points returned and include a GROUP BY clause

> 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子句计算查询时间范围内每个标记和每个12分钟间隔的平均水位。LIMIT 2请求两个最早的12分钟平均值（由时间戳确定）。
注意，在没有LIMIT 2的情况下，查询将在每个序列中返回4个点；在查询的时间范围内，每12分钟间隔返回一个点。

The SLIMIT clause

SLIMIT返回指定测量中序列中的每个点。

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

N指定从指定测量返回的序列数。如果N大于度量中的序列数，InfluxDB将返回该度量中的所有序列。
有一个持续的问题需要SLIMIT查询包含GROUP BY *。请注意，SLIMIT子句必须按上述语法中列出的顺序出现。
示例
Limit the number of series returned

> SELECT "water_level" FROM "h2o_feet" GROUP BY * SLIMIT 1

name: h2o_feet
tags: location=coyote_creek
time                   water_level
----                   -----
2015-08-18T00:00:00Z   8.12
2015-08-18T00:06:00Z   8.005
2015-08-18T00:12:00Z   7.887
[...]
2015-09-18T16:12:00Z   3.402
2015-09-18T16:18:00Z   3.314
2015-09-18T16:24:00Z   3.235

查询返回与h2o_feet相关联的序列之一中的所有点。
Limit the number of series returned and include a GROUP BY time() clause

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

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

查询使用InfluxQL函数和GROUP BY子句中的时间间隔来计算查询时间范围内每12分钟间隔的平均water_level。SLIMIT 1要求与h2o_feet测量相关的单个系列。
注意，如果没有SLIMIT 1，查询将返回与h2o_feet测量相关的两个系列的结果：location=coyote_creek和location=santa_monica。

LIMIT and SLIMIT

LIMIT followed by SLIMIT returns the first points from series in the specified measurement.

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

N1指定每次测量返回的点数。如果N1大于测量中的点数，InfluxDB将返回该测量中的所有点数。
N2指定从指定测量返回的序列数。如果N2大于测量中的序列数，InfluxDB将返回该测量中的所有序列。
存在一个持续的问题，需要使用LIMIT和SLIMIT查询来包含GROUP BY *。注意，LIMIT和SLIMIT子句必须按上述语法中列出的顺序出现。
示例
Limit the number of points and series returned

> 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相关的序列之一中的三个最早点（由时间戳确定）。
Limit the number of points and series returned and include a GROUP BY time() clause

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

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

查询使用InfluxQL函数和GROUP BY子句中的时间间隔来计算查询时间范围内每12分钟间隔的平均水位。LIMIT 2请求两个最早的12分钟平均值（由时间戳确定），SLIMIT 1请求与水英尺测量相关的单个序列。
请注意，如果没有LIMIT 2 SLIMIT 1，查询将为与h2o_feet测量相关的两个系列中的每一个返回四个点。

The OFFSET and SOFFSET clauses

OFFSET和SOFFSET对返回的点和序列进行分页。

The OFFSET clause

OFFSET为查询结果中的N个点分页。

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

N指定要分页的点数。OFFSET子句需要一个LIMIT子句。使用不带LIMIT子句的OFFSET子句可能会导致查询结果不一致。

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

示例
Paginate points

> 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

查询返回water_level测量值的第四、第五和第六个点。如果查询不包括OFFSET 3，它将返回该度量的第一、第二和第三个点。
Paginate points and include several clauses

> 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子句将返回的点数限制为2。OFFSET 2子句从查询结果中排除前两个平均值。SLIMIT 1子句将返回的序列数限制为1。
如果没有偏移量2，查询将返回查询结果的前两个平均值：

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

The SOFFSET clause

SOFFSET在查询结果中分页N个序列。

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

N指定要分页的序列数。SOFFSET子句需要SLIMIT子句。在没有SLIMIT子句的情况下使用SOFFSET子句可能会导致查询结果不一致。有一个持续的问题需要SLIMIT查询包含GROUP BY *。

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

示例
Paginate series

> 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

查询返回与water_level测量和location=santa_monica标记相关联的系列的数据。如果没有SOFFSET 1，查询将返回与water_level测量和location=coyote_creek标记相关的系列数据。
Paginate series and include all clauses

> 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子句将返回的点数限制为2。OFFSET 2子句从查询结果中排除前两个平均值。SLIMIT 1子句将返回的序列数限制为1。SOFFSET 1子句对返回的序列分页。
如果没有SOFFSET 1，查询将返回不同系列的结果：

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

The Time Zone clause

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

SELECT_clause [INTO_clause] FROM_clause [WHERE_clause] [GROUP_BY_clause] [ORDER_BY_clause] [LIMIT_clause] [OFFSET_clause] [SLIMIT_clause] [SOFFSET_clause] tz('')

默认情况下，InfluxDB以UTC格式存储并返回时间戳。tz()子句包括UTC偏移量，或者，如果适用的话，查询返回时间戳的UTC夏时制时间（DST）偏移量。返回的时间戳必须采用RFC3339格式才能显示UTC偏移量或UTC DST。时区参数遵循Internet Assigned Numbers Authority时区数据库中的TZ语法，需要单引号。
示例
Return the UTC offset for Chicago’s time zone

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

Time syntax

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

Absolute time

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

SELECT_clause FROM_clause WHERE time  ['' | '' | ] [AND ['' | '' | ] [...]]

支持的操作符

Operator Meaning
= equal to
<> not equal to
!= not equal to
> greater than
>= greater than or equal to
< less than
<= less than or equal to

目前，InfluxDB不支持在WHERE子句中使用OR连接绝对时间。有关更多信息，请参阅常见问题文档和GitHub问题。

rfc3339_date_time_string

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

.nnnnnnn是可选的，如果不包括，则设置为.000000000。RFC3339日期时间字符串需要单引号。
####rfc3339_like_date_time_string

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

HH:MM:SS.nnnnnnnnn.nnnnnnnnn是可选的，如果不包括，则设置为00:00:00.000000000。类似于rfc339的日期-时间字符串需要单引号。

epoch_time

Epoch time是自1970年1月1日星期四00:00:00协调世界时(UTC)起经过的时间量。
默认情况下，InfluxDB假设所有纪元时间戳都以纳秒为单位。在epoch时间戳的末尾包含一个duration文本，以指示纳秒以外的精度。
####Basic arithmetic
所有时间戳格式都支持基本算法。用持续时间文字从时间戳中加上或减去时间。注意，InfluxQL需要一个介于+或-和duration文本之间的空白。

示例

Specify a time range with RFC3339 date-time strings

> 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日期-时间字符串周围的单引号是必需的。

Specify a time range with RFC3339-like date-time strings

> 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。
注意，rfc339类日期-时间字符串周围的单引号是必需的。

Specify a time range with epoch timestamps

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

Specify a time range with second-precision epoch timestamps

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

name: h2o_feet
time                   water_level
----                   -----------
2015-08-18T00:00:00Z   2.064
2015-08-18T00:06:00Z   2.116
2015-08-18T00:12:00Z   2.028

查询返回时间戳介于2015年8月18日00:00:00和2015年8月18日00:12:00之间的数据。epoch时间戳末尾的s duration文字表示epoch时间戳以秒为单位。

Perform basic arithmetic on an RFC3339-like date-time string

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

Perform basic arithmetic on an epoch timestamp

> 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之前6分钟出现。注意-和6m之间的空白是必需的。

Relative time

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

SELECT_clause FROM_clause WHERE time  now() [[ - | + ] ] [(AND|OR) now() [...]]

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

Supported operators](https://docs.influxdata.com/influxdb/v1.8/query_language/explore-data/#supported-operators-3)

Operator Meaning
= equal to
<> not equal to
!= not equal to
> greater than
>= greater than or equal to
< less than
<= less than or equal to

duration_literal`](https://docs.influxdata.com/influxdb/v1.8/query_language/explore-data/#duration-literal)

u or µ microseconds ms    milliseconds s     seconds m     minutes h     hours d     days w     weeks

Examples

Specify a time range with relative time

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

查询返回在发生在过去1小时内的时间戳的数据，-和1h之间的空白是必须的。

Specify a time range with absolute time and relative time

> 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天（从现在起）之间的数据。+和1000d之间的空白是必须的。

time语法的常见问题

Using OR to select time multiple time intervals

InfluxDB不支持在WHERE子句中使用OR运算符指定多个时间间隔。
有关详细信息，请参见Frequently asked questions.

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

大多数SELECT语句的默认时间范围为1677-09-21 00:12:43.145224194和2262-04-11T23:47:16.854775806Z UTC。对于带有GROUP BY time()子句的SELECT语句，默认时间范围是1677-09-21 00:12:43.145224194 UTC和now()之间。
要使用now()之后出现的时间戳查询数据，带有GROUP BY time()子句的SELECT语句必须在WHERE子句中提供另一个上界。

Example

Use the CLI to write a point to the NOAA_water_database that occurs after 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命令指定替代格式。默认情况下，InfluxDB API以RFC3339格式返回时间戳，使用epoch查询字符串指定替代格式。

Regular expressions

InfluxQL supports using regular expressions when specifying:

  • field keys and tag keys in the SELECT clause
  • measurements in the FROM clause
  • tag values and string field values in the WHERE clause.
  • tag keys in the GROUP BY clause

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

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

SELECT // FROM // WHERE [  // |   //] GROUP BY //

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

Supported operators

=~ matches against !~ doesn’t match against

Examples

Use a regular expression to specify field keys and tag keys in the SELECT clause

> 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子句中没有语法来区分字段键的正则表达式和标记键的正则表达式。语法//::[field | tag]不受支持。

Use a regular expression to specify measurements in the FROM clause

> SELECT MEAN("degrees") FROM /temperature/

name: average_temperature
time			mean
----			----
1970-01-01T00:00:00Z   79.98472932232272

name: h2o_temperature
time			mean
----			----
1970-01-01T00:00:00Z   64.98872722506226

查询使用InfluxQL函数计算NOAA_water_database中包含单词temperature的每个测量值的平均degrees。

Use a regular expression to specify tag values in the WHERE clause

> 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大于3。

Use a regular expression to specify a tag with no value in the WHERE clause

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

查询将从位置标记没有值的h2o_feet测量中选择所有数据。NOAA_water_database的每个数据点都有一个位置标记值。
可以在不使用正则表达式的情况下执行相同的查询。有关详细信息，请参阅常见问题文档。

Use a regular expression to specify a tag with a value in the WHERE clause

> 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单词。

Use a regular expression to specify tag keys in the GROUP BY clause

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

数据类型和转换操作

Data types

Field values can be floats, integers, strings, or booleans. The :: syntax allows users to specify the field’s type in a query.

Note: Generally, it is not necessary to specify the field value type in the SELECT clause. In most cases, InfluxDB rejects any writes that attempt to write a field value to a field that previously accepted field values of a different type.
It is possible for field value types to differ across shard groups. In these cases, it may be necessary to specify the field value type in the SELECT clause. Please see the Frequently Asked Questions document for more information on how InfluxDB handles field value type discrepancies.

SELECT_clause :: FROM_clause

type can be float, integer, string, or boolean. In most cases, InfluxDB returns no data if the field_key does not store data of the specified type. See Cast Operations for more information.

Example

> 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
The query returns values of the water_leve

The query returns values of the water_level field key that are floats.

Cast operations

The :: syntax allows users to perform basic cast operations in queries. Currently, InfluxDB supports casting field values from integers to floats or from floats to integers.

Syntax

SELECT_clause <field_key>::<type> FROM_clause

type can be float or integer.

InfluxDB returns no data if the query attempts to cast an integer or float to a string or boolean.

Examples

Cast float field values to integers

> 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

The query returns the integer form of water_level’s float field values.

Cast float field values to strings (this functionality is not supported)

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

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

Merge behavior

In InfluxDB, queries merge series automatically.

Example

The h2o_feet measurement in the NOAA_water_database is part of two series. The first series is made up of the h2o_feet measurement and the location = coyote_creek tag. The second series is made of up the h2o_feet measurement and the location = santa_monica tag.

The following query automatically merges those two series when it calculates the average water_level:

> SELECT MEAN("water_level") FROM "h2o_feet"

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

If you want the average water_level for the first series only, specify the relevant tag in the WHERE clause:

> SELECT MEAN("water_level") FROM "h2o_feet" WHERE "location" = 'coyote_creek'

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

If you want the average water_level for each individual series, include a GROUP BY clause:

> 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

Multiple statements

Separate multiple SELECT statements in a query with a semicolon (;).

Examples

Example 1: CLIExample 2: InfluxDB API

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

Subqueries

A subquery is a query that is nested in the FROM clause of another query. Use a subquery to apply a query as a condition in the enclosing query. Subqueries offer functionality similar to nested functions and SQL HAVING clauses.

Syntax

SELECT_clause FROM ( SELECT_statement ) [...]

InfluxDB performs the subquery first and the main query second.

The main query surrounds the subquery and requires at least the SELECT clause and the FROM clause. The main query supports all clauses listed in this document.

The subquery appears in the main query’s FROM clause, and it requires surrounding parentheses. The subquery supports all clauses listed in this document.

InfluxQL supports multiple nested subqueries per main query. Sample syntax for multiple subqueries:

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

Examples

Calculate the SUM() of several MAX() values

> 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

The query returns the sum of the maximum water_level values across every tag value of location.

InfluxDB first performs the subquery; it calculates the maximum value of water_level for each tag value of 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

Next, InfluxDB performs the main query and calculates the sum of those maximum values: 9.964 + 7.205 = 17.169. Notice that the main query specifies max, not water_level, as the field key in the SUM() function.

Calculate the MEAN() difference between two fields

> SELECT MEAN("difference") FROM (SELECT "cats" - "dogs" AS "difference" FROM "pet_daycare")

name: pet_daycare
time                   mean
----                   ----
1970-01-01T00:00:00Z   1.75

The query returns the average of the differences between the number of cats and dogs in the pet_daycare measurement.

InfluxDB first performs the subquery. The subquery calculates the difference between the values in the cats field and the values in the dogs field, and it names the output column 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

Next, InfluxDB performs the main query and calculates the average of those differences. Notice that the main query specifies difference as the field key in the MEAN() function.

Calculate several MEAN() values and place a condition on those mean values

> 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

The query returns all mean values of the water_level field that are greater than five.

InfluxDB first performs the subquery. The subquery calculates MEAN() values of water_level from 2015-08-18T00:00:00Z through 2015-08-18T00:30:00Z and groups the results into 12-minute intervals. It also names the output column 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

Next, InfluxDB performs the main query and returns only those mean values that are greater than five. Notice that the main query specifies all_the_means as the field key in the SELECT clause.

Calculate the SUM() of several DERIVATIVE() values

> 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

The query returns the sum of the derivative of average water_level values for each tag value of location.

InfluxDB first performs the subquery. The subquery calculates the derivative of average water_level values taken at 12-minute intervals. It performs that calculation for each tag value of location and names the output column 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

Next, InfluxDB performs the main query and calculates the sum of the water_level_derivative values for each tag value of location. Notice that the main query specifies water_level_derivative, not water_level or derivative, as the field key in the SUM() function.

Common issues with subqueries

Multiple SELECT statements in a subquery

InfluxQL supports multiple nested subqueries per main query:

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

InfluxQL does not support multiple SELECT statements per subquery:

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

The system returns a parsing error if a subquery includes multiple SELECT statements.

你可能感兴趣的:(InfluxDB 使用InfluxQL语言检索数据语法)

  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 消息中间件有哪些常见类型 xmh-sxh-1314 java
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
  • html 中如何使用 uniapp 的部分方法 某公司摸鱼前端 htmluni-app前端
    示例代码：Documentconsole.log(window);效果展示：好了，现在就可以uni.使用相关的方法了
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值） 研学随笔 arcgis经验分享
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 水平垂直居中的几种方法（总结） LJ小番茄 CSS_玄学语言htmljavascript前端csscss3
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • LLM 词汇表 落难Coder LLMsNLP大语言模型大模型llama人工智能
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
  • PHP环境搭建详细教程 好看资源平台 前端php
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
  • 下载github patch到本地 小米人er 我的博客gitpatch
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器） 编程经验分享 开发工具服务器sshlinux
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 2020-04-12每天三百字之连接与替代 冷眼看潮
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
  • 【加密社】Solidity 中的事件机制及其应用 加密社 闲侃区块链智能合约区块链
    加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • 对股票分析时要注意哪些主要因素？ 会飞的奇葩猪 股票 分析 云掌股吧
    　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。     一、成交量 　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
  • 【Scala十八】视图界定与上下文界定 bit1129 scala
    Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。   隐式参数 首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b }  因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
  • C语言的分支——Object-C程序设计阅读有感 darkblue086 applec框架cocoa
    自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
  • 去除浏览器对表单值的记忆 周凡杨 html记忆autocompleteform浏览
                                       &n
  • java的树形通讯录 g21121 java
    最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
  • Nginx安装部署 510888780 nginxlinux
    Nginx ("engine x") 是一个高性能的 HTTP 和 反向代理 服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
  • java servelet异步处理请求 墙头上一根草 ｊａｖａ异步返回ｓｅｒｖｌｅｔ
    servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能，        final AsyncContext ac = request.startAsync(request, response);   ac.s
  • 我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
    在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。 （有构造方法的下个文细说） 2、还
  • 为Mysql创建最优的索引 annan211 mysql索引
    索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。 索引经常会被误解甚至忽略，而且经常被糟糕的设计。 索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比 较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
  • 日期函数 百合不是茶 oraclesql日期函数查询
      ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年 显示值:07 yyy three digits 三位年 显示值:007
  • 线程优先级 bijian1013 javathread多线程java多线程
    多线程运行时需要定义线程运行的先后顺序。 线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。 实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
  • 适配器模式和代理模式的区别 bijian1013 java设计模式
    一.简介        适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。      &nbs
  • 【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
     SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句， 这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
  • oracle大数据表复制备份个人经验 bitcarter oracle大表备份大表数据复制
    前提：    数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。    
  • HTTP加速器varnish安装小记 ronin47 http varnish 加速
    上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！ 苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
  • java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
    public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
  • 学习编程的一点感想 Cb123456 编程感想Gis
           写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目.      本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
  • [能源与安全]美国与中国 comsci 能源
         现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。       在这个大
  • SEMI-JOIN执行计划突然变成HASH JOIN了 的原因分析 cwqcwqmax9 oracle
    甲说： A B两个表总数据量都很大，在百万以上。 idx1  idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn      and exists (select 1 from B where B.idx2 =
  • SpringMVC-ajax返回值乱码解决方案 dashuaifu AjaxspringMVCresponse中文乱码
      SpringMVC-ajax返回值乱码解决方案   一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do")       public @ResponseBody void getPunishReasonB
  • Linux系统中查看日志的常用命令 dcj3sjt126com OS
    因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日 志 文 件 说 明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
  • [应用结构]应用 dcj3sjt126com PHPyii2
    应用主体 应用主体是管理 Yii 应用系统整体结构和生命周期的对象。 每个Yii应用系统只能包含一个应用主体，应用主体在 入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。 补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
  • assertThat用法 eksliang JUnitassertThat
    junit4.0  assertThat用法 一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
  • android点滴2 gundumw100 应用服务器android网络应用OSHTC
    如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
  • 超简洁的CSS下拉菜单 ini htmlWeb工作html5css
    效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
  • kafka consumer防止数据丢失 kane_xie kafkaoffset commit
    kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。   尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。   考虑这样一个case，partiton_num=2
  • @Repository、@Service、@Controller 和 @Component mhtbbx DAOspringbeanprototype
    @Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
  • java 多线程高并发读写控制 误区 qifeifei java thread
    先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
  • mongodb replica set(副本集)设置步骤 tcrct javamongodb
    网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下： 首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
  • rust学习笔记 wudixiaotie 学习笔记
    1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他