Documentation

InfluxDB OSS v1

InfluxQL 持续查询

此页面记录了 InfluxDB OSS 的早期版本。InfluxDB OSS v2 是最新的稳定版本。请参见等效的 InfluxDB v2 文档： 使用 InfluxDB 任务处理数据。

简介

连续查询 (CQ) 是在实时数据上自动和定期运行的 InfluxQL 查询，并将查询结果存储在指定的测量中。

基本语法高级语法CQ 管理
基本语法示例高级语法示例CQ 用例
基本语法的常见问题高级语法的常见问题更多信息

语法

基本语法

CREATE CONTINUOUS QUERY <cq_name> ON <database_name>
BEGIN
  <cq_query>
END

基本语法的描述

查询函数 cq_query

该 cq_query 需要一个 函数, 一个 INTO 子句, 和一个 GROUP BY time() 子句：

SELECT <function[s]> INTO <destination_measurement> FROM <measurement> [WHERE <stuff>] GROUP BY time(<interval>)[,<tag_key[s]>]

注意： 请注意，cq_query 在WHERE子句中不需要时间范围。 InfluxDB 在执行 CQ 时会自动生成一个cq_query的时间范围。 系统将忽略cq_query中用户指定的WHERE子句中的任何时间范围。

计划和覆盖范围

连续查询在实时数据上运行。 它们使用本地服务器的时间戳、GROUP BY time() 间隔，以及 InfluxDB 数据库的预设时间边界来确定何时执行以及查询覆盖的时间范围。

CQs在与cq_query的GROUP BY time()间隔相同的时间间隔内执行，并且它们在InfluxDB数据库预设的时间边界开始时运行。如果GROUP BY time()间隔为一小时，则CQ在每个小时的开始时执行。

当CQ执行时，它将在now()和now()减去GROUP BY time()间隔之间运行单个查询。如果GROUP BY time()间隔为一小时，而当前时间为17:00，则查询的时间范围为16:00到16:59.999999999。

基本语法示例

以下示例使用以下样本数据在 transportation 数据库中。 测量 bus_data 存储每15分钟分辨率的公交车 passengers 和 complaints 的数据：

name: bus_data
--------------
time                   passengers   complaints
2016-08-28T07:00:00Z   5            9
2016-08-28T07:15:00Z   8            9
2016-08-28T07:30:00Z   8            9
2016-08-28T07:45:00Z   7            9
2016-08-28T08:00:00Z   8            9
2016-08-28T08:15:00Z   15           7
2016-08-28T08:30:00Z   15           7
2016-08-28T08:45:00Z   17           7
2016-08-28T09:00:00Z   20           7
自动下采样数据

使用简单的CQ自动从单个字段降采样数据，并将结果写入同一数据库中的另一个测量。

CREATE CONTINUOUS QUERY "cq_basic" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h)
END

cq_basic 计算来自 bus_data 测量的平均每小时乘客数量，并将结果存储在 average_passengers 测量中，位于 transportation 数据库中。

cq_basic 每小时执行一次，时间间隔与 GROUP BY time() 相同。每小时， cq_basic 执行一个查询，该查询涵盖的时间范围是从 now() 到 now() 减去 GROUP BY time() 的时间间隔，也就是从 now() 到 now() 前一小时的时间范围。

2016年8月28日上午的注释日志输出：

>
At **8:00** `cq_basic` executes a query with the time range `time >= '7:00' AND time < '08:00'`.
`cq_basic` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **9:00** `cq_basic` executes a query with the time range `time >= '8:00' AND time < '9:00'`.
`cq_basic` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

以下是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
将数据自动下采样到另一个保留策略

完全限定 目标度量，以便在非-DEFAULT 保留策略 (RP) 中存储降采样数据。

CREATE CONTINUOUS QUERY "cq_basic_rp" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "transportation"."three_weeks"."average_passengers" FROM "bus_data" GROUP BY time(1h)
END

cq_basic_rp 计算平均每小时乘客数量来自 bus_data 测量，并将结果存储在 transportation 数据库中， three_weeks RP，以及 average_passengers 测量。

cq_basic_rp 每小时执行一次，与 GROUP BY time() 的间隔相同。每小时，cq_basic_rp 执行一个覆盖 now() 和 now() 减去 GROUP BY time() 间隔的时间范围的单个查询，即从 now() 到 now() 的前一个小时的时间范围。

2016年8月28日上午的注释日志输出：

>
At **8:00** `cq_basic_rp` executes a query with the time range `time >= '7:00' AND time < '8:00'`.
`cq_basic_rp` writes one point to the `three_weeks` RP and the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **9:00** `cq_basic_rp` executes a query with the time range
`time >= '8:00' AND time < '9:00'`.
`cq_basic_rp` writes one point to the `three_weeks` RP and the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

下面是结果：

> SELECT * FROM "transportation"."three_weeks"."average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75

cq_basic_rp 使用 CQs 和保留策略自动对数据进行降采样，并将这些降采样的数据保留替代的时间长度。有关此 CQ 用例的深入讨论，请参阅 降采样和数据保留 指南。

自动降采样具有反向引用的数据库

使用带通配符 (*) 的函数和 INTO 查询的 回参语法 自动降采样数据库中所有测量和数值字段的数据。

CREATE CONTINUOUS QUERY "cq_basic_br" ON "transportation"
BEGIN
  SELECT mean(*) INTO "downsampled_transportation"."autogen".:MEASUREMENT FROM /.*/ GROUP BY time(30m),*
END

cq_basic_br 计算每个 transportation 数据库中的 passengers 和 complaints 的30分钟平均值 (在此情况下，只有 bus_data 测量)。它将结果存储在 downsampled_transportation 数据库中。

cq_basic_br 每30分钟执行一次，与GROUP BY time()的间隔相同。每30分钟，cq_basic_br 运行一个查询，覆盖的时间范围是从now()到now()减去GROUP BY time()间隔，也就是说，时间范围是从now()到30分钟前的now()。

2016年8月28日上午的注释日志输出：

>
At **7:30**, `cq_basic_br` executes a query with the time range `time >= '7:00' AND time < '7:30'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T07:00:00Z   9                 6.5
>
At **8:00**, `cq_basic_br` executes a query with the time range `time >= '7:30' AND time < '8:00'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T07:30:00Z   9                 7.5
>
[...]
>
At **9:00**, `cq_basic_br` executes a query with the time range `time >= '8:30' AND time < '9:00'`.
`cq_basic_br` writes two points to the `bus_data` measurement in the `downsampled_transportation` database:
>
    name: bus_data
    --------------
    time                   mean_complaints   mean_passengers
    2016-08-28T08:30:00Z   7                 16

以下是结果：

> SELECT * FROM "downsampled_transportation."autogen"."bus_data"
name: bus_data
--------------
time                   mean_complaints   mean_passengers
2016-08-28T07:00:00Z   9                 6.5
2016-08-28T07:30:00Z   9                 7.5
2016-08-28T08:00:00Z   8                 11.5
2016-08-28T08:30:00Z   7                 16
自动下采样数据和配置CQ时间边界

在 GROUP BY time() 子句中使用一个 偏移间隔 来改变 CQ 的默认执行时间和预设时间边界。

CREATE CONTINUOUS QUERY "cq_basic_offset" ON "transportation"
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h,15m)
END

cq_basic_offset计算来自bus_data测量的平均每小时乘客数量，并将结果存储在average_passengers测量中。

cq_basic_offset 每小时执行一次，和 GROUP BY time() 的间隔相同。 15分钟的偏移间隔强制 CQ 在默认执行时间之后15分钟执行；cq_basic_offset 在8:15执行，而不是8:00。

每小时， cq_basic_offset 运行一个单一查询，覆盖时间范围 从 now() 到 now() 减去 GROUP BY time() 的间隔，也就是 时间范围从 now() 到 now() 前一个小时。 15分钟的偏移间隔向前移动生成的预设时间边界在 CQ 的 WHERE 子句中； cq_basic_offset 查询在 7:15 和 8:14.999999999 之间，而不是 7:00 和 7:59.999999999。

2016年8月28日上午的注释日志输出：

>
At **8:15** `cq_basic_offset` executes a query with the time range `time >= '7:15' AND time < '8:15'`.
`cq_basic_offset` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:15:00Z   7.75
>
At **9:15** `cq_basic_offset` executes a query with the time range `time >= '8:15' AND time < '9:15'`.
`cq_basic_offset` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:15:00Z   16.75

下面是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:15:00Z   7.75
2016-08-28T08:15:00Z   16.75

请注意，时间戳是7:15和8:15，而不是7:00和8:00。

基本语法的常见问题

处理无数据的时间间隔

CQs在一个时间区间内如果没有数据落在该时间范围内，则不会写入任何结果。

请注意，基本语法不支持使用 fill() 来更改没有数据的区间所报告的值。 基本语法 CQs 如果在 CQ 查询中包含 fill()，则会被忽略。 一个可能的解决方法是使用 高级 CQ 语法。

重新采样之前的时间间隔

基础CQ运行一个单一的查询，覆盖从 now() 到 now() 减去 GROUP BY time() 间隔的时间范围。有关如何配置查询时间范围，请参见 advanced syntax。

旧数据的回填结果

CQs 操作实时数据，也就是说，数据的时间戳是相对于 now() 发生的。使用基本的 INTO 查询 来填充时间戳较旧的数据的结果。

CQ结果中缺失的标签

默认情况下，所有 INTO 查询 将源测量中的任何标签转换为目标测量中的字段。

在CQ中包含 GROUP BY * 以保留目标测量中的标签。

高级语法

CREATE CONTINUOUS QUERY <cq_name> ON <database_name>
RESAMPLE EVERY <interval> FOR <interval>
BEGIN
  <cq_query>
END

高级语法的描述

查询函数 cq_query

见 基本语法的描述。

调度与覆盖

CQs 在实时数据上运行。使用高级语法，CQs 利用本地服务器的时间戳、RESAMPLE 子句中的信息，以及 InfluxDB 服务器的预设时间边界来确定何时执行以及查询覆盖的时间范围。

CQs 在与 RESAMPLE 子句中的 EVERY 间隔相同的时间间隔内执行，并且在 InfluxDB 预设时间边界的开始时运行。如果 EVERY 间隔为两个小时，则 InfluxDB 在每隔一个小时的开始时执行 CQ。

当CQ执行时，它会在now()和now()减去FOR间隔的RESAMPLE子句之间运行一个查询。如果FOR间隔是两小时，并且当前时间是17:00，则查询的时间范围是15:00到16:59.999999999。

在 EVERY 间隔和 FOR 间隔都接受 持续时间文字。 RESAMPLE 子句可以与 EVERY 和 FOR 间隔中的一个或两个一起使用。 如果未提供 EVERY 间隔或 FOR 间隔，CQs 将默认采取相关的 基本语法行为 （有关异常情况，请参见 高级语法的常见问题中的第一个问题）。

高级语法示例

下面的示例使用以下样本数据在transportation数据库中。 测量bus_data存储有关公交车passengers数量的15分钟分辨率数据：

name: bus_data
--------------
time                   passengers
2016-08-28T06:30:00Z   2
2016-08-28T06:45:00Z   4
2016-08-28T07:00:00Z   5
2016-08-28T07:15:00Z   8
2016-08-28T07:30:00Z   8
2016-08-28T07:45:00Z   7
2016-08-28T08:00:00Z   8
2016-08-28T08:15:00Z   15
2016-08-28T08:30:00Z   15
2016-08-28T08:45:00Z   17
2016-08-28T09:00:00Z   20
配置执行间隔

在RESAMPLE 子句中使用 EVERY 间隔来指定 CQ 的执行间隔。

CREATE CONTINUOUS QUERY "cq_advanced_every" ON "transportation"
RESAMPLE EVERY 30m
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h)
END

cq_advanced_every 计算来自 bus_data 测量的 passengers 的一小时平均值，并将结果存储在 transportation 数据库中的 average_passengers 测量中。

cq_advanced_every 每30分钟执行一次，与EVERY间隔相同。 每30分钟，cq_advanced_every 执行一个单独的查询，覆盖当前时间段，即与now()相交的一小时时间段。

2016年8月28日上午的注释日志输出：

>
At **8:00**, `cq_advanced_every` executes a query with the time range `WHERE time >= '7:00' AND time < '8:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   7
>
At **8:30**, `cq_advanced_every` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   12.6667
>
At **9:00**, `cq_advanced_every` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_every` writes one point to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   13.75

下面是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75

请注意，cq_advanced_every 为 8:00 时间区间计算结果两次。 首先，它在 8:30 运行，并计算 8:00 到 9:00 之间每个可用数据点的平均值 (8,15, 和 15)。 第二，它在 9:00 运行，并计算 8:00 到 9:00 之间每个可用数据点的平均值 (8, 15, 15, 和 17)。 由于 InfluxDB 处理重复点 的方式，第二个结果简单地覆盖第一个结果。

配置重采样的时间范围

在RESAMPLE子句中使用FOR间隔以指定CQ的时间范围。

CREATE CONTINUOUS QUERY "cq_advanced_for" ON "transportation"
RESAMPLE FOR 1h
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(30m)
END

cq_advanced_for 计算 bus_data 测量中 passengers 的30分钟平均值，并将结果存储在 transportation 数据库中的 average_passengers 测量中。

cq_advanced_for 每30分钟执行一次，与GROUP BY time() 的时间间隔相同。 每30分钟，cq_advanced_for 运行一个单一的查询，覆盖从now() 到now() 减去FOR 间隔的时间范围，也就是从now() 到一个小时前的时间范围。

2016年8月28日上午的注释日志输出：

>
At **8:00** `cq_advanced_for` executes a query with the time range `WHERE time >= '7:00' AND time < '8:00'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:00:00Z   6.5
    2016-08-28T07:30:00Z   7.5
>
At **8:30** `cq_advanced_for` executes a query with the time range  `WHERE time >= '7:30' AND time < '8:30'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:30:00Z   7.5
    2016-08-28T08:00:00Z   11.5
>
At **9:00** `cq_advanced_for` executes a query with the time range `WHERE time >= '8:00' AND time < '9:00'`.
`cq_advanced_for` writes two points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T08:00:00Z   11.5
    2016-08-28T08:30:00Z   16

请注意，cq_advanced_for 将针对每个时间间隔计算结果两次。 CQ 在 8:00 和 8:30 计算 7:30 时间间隔的平均值， 并在 8:30 和 9:00 计算 8:00 时间间隔的平均值。

下面是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T07:00:00Z   6.5
2016-08-28T07:30:00Z   7.5
2016-08-28T08:00:00Z   11.5
2016-08-28T08:30:00Z   16
配置执行间隔和CQ时间范围

在 RESAMPLE 子句中使用 EVERY 间隔和 FOR 间隔来指定 CQ 的执行间隔和 CQ 的时间范围长度。

CREATE CONTINUOUS QUERY "cq_advanced_every_for" ON "transportation"
RESAMPLE EVERY 1h FOR 90m
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(30m)
END

cq_advanced_every_for 计算来自 bus_data 测量的乘客的 30 分钟平均值，并将结果存储在 transportation 数据库中的 average_passengers 测量中。

cq_advanced_every_for 每小时执行一次，与 EVERY 间隔相同。 每小时，cq_advanced_every_for 运行一个查询，该查询覆盖的时间范围是从 now() 到 now() 减去 FOR 间隔，也就是从 now() 到 now() 前90分钟的时间范围。

2016年8月28日上午的注释日志输出：

>
At **8:00** `cq_advanced_every_for` executes a query with the time range `WHERE time >= '6:30' AND time < '8:00'`.
`cq_advanced_every_for` writes three points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T06:30:00Z   3
    2016-08-28T07:00:00Z   6.5
    2016-08-28T07:30:00Z   7.5
>
At **9:00** `cq_advanced_every_for` executes a query with the time range `WHERE time >= '7:30' AND time < '9:00'`.
`cq_advanced_every_for` writes three points to the `average_passengers` measurement:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T07:30:00Z   7.5
    2016-08-28T08:00:00Z   11.5
    2016-08-28T08:30:00Z   16

注意 cq_advanced_every_for 将为每个时间间隔计算结果两次。 CQ 在 8:00 和 9:00 计算 7:30 时间间隔的平均值。

下面是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T06:30:00Z   3
2016-08-28T07:00:00Z   6.5
2016-08-28T07:30:00Z   7.5
2016-08-28T08:00:00Z   11.5
2016-08-28T08:30:00Z   16
配置CQ时间范围和填充空结果

使用一个 FOR 时间间隔和 fill() 来更改报告的时间值 对没有数据的时间间隔。 请注意，至少一个数据点必须落在 FOR 时间间隔内，以便 fill() 可以操作。 如果没有数据落在 FOR 时间间隔内，CQ 将不会向目标测量写入任何点。

CREATE CONTINUOUS QUERY "cq_advanced_for_fill" ON "transportation"
RESAMPLE FOR 2h
BEGIN
  SELECT mean("passengers") INTO "average_passengers" FROM "bus_data" GROUP BY time(1h) fill(1000)
END

cq_advanced_for_fill 计算来自 bus_data 测量的 passengers 的一小时平均值，并将结果存储在 transportation 数据库中的 average_passengers 测量中。尽可能在没有结果的时间间隔写入值 1000。

cq_advanced_for_fill 每小时执行一次，间隔与 GROUP BY time() 相同。 每小时，cq_advanced_for_fill 运行一个覆盖时间范围的单个查询，该时间范围为 now() 和 now() 减去 FOR 间隔，即 now() 和两小时前的 now() 之间的时间范围。

2016年8月28日上午的注释日志输出：

>
At **6:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '4:00' AND time < '6:00'`.
`cq_advanced_for_fill` writes nothing to `average_passengers`; `bus_data` has no data
that fall within that time range.
>
At **7:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '5:00' AND time < '7:00'`.
`cq_advanced_for_fill` writes two points to `average_passengers`:
>
    name: average_passengers
    ------------------------
    time                   mean
    2016-08-28T05:00:00Z   1000          <------ fill(1000)
    2016-08-28T06:00:00Z   3             <------ average of 2 and 4
>
[...]
>
At **11:00**, `cq_advanced_for_fill` executes a query with the time range `WHERE time >= '9:00' AND time < '11:00'`.
`cq_advanced_for_fill` writes two points to `average_passengers`:
>
    name: average_passengers
    ------------------------
    2016-08-28T09:00:00Z   20            <------ average of 20
    2016-08-28T10:00:00Z   1000          <------ fill(1000)
>

在 12:00，cq_advanced_for_fill 执行一个查询，时间范围为 WHERE time >= '10:00' AND time < '12:00'。cq_advanced_for_fill 没有写入任何内容到 average_passengers；bus_data 在该时间范围内没有数据。

下面是结果：

> SELECT * FROM "average_passengers"
name: average_passengers
------------------------
time                   mean
2016-08-28T05:00:00Z   1000
2016-08-28T06:00:00Z   3
2016-08-28T07:00:00Z   7
2016-08-28T08:00:00Z   13.75
2016-08-28T09:00:00Z   20
2016-08-28T10:00:00Z   1000

注意： fill(previous) 不会在前一个值超出查询的时间范围时填充时间间隔的结果。 有关更多信息，请参见 常见问题。

高级语法的常见问题

如果 EVERY 间隔大于 GROUP BY time() 间隔

如果 EVERY 时间间隔大于 GROUP BY time() 时间间隔，那么 CQ 将以与 EVERY 时间间隔相同的间隔执行，并运行一个覆盖从 now() 到 now() 减去 EVERY 时间间隔的时间范围的单个查询（而不是从 now() 到 now() 减去 GROUP BY time() 时间间隔）。

例如，如果 GROUP BY time() 的时间间隔是 5m 而 EVERY 的时间间隔是 10m，那么 CQ 每十分钟执行一次。每十分钟，CQ 会运行一个单一的查询，该查询覆盖从 now() 到 now() 减去 EVERY 时间间隔的时间范围，也就是说，从 now() 到 now() 之前的十分钟的时间范围。

这种行为是故意的，防止CQ在执行时间之间丢失数据。

如果FOR间隔小于执行间隔

如果 FOR 间隔小于 GROUP BY time() 间隔或者，如果指定了 EVERY 间隔，InfluxDB 将返回以下错误：

error parsing query: FOR duration must be >= GROUP BY time duration: must be a minimum of <minimum-allowable-interval> got <user-specified-interval>

为了避免在执行时间之间丢失数据，FOR 时间间隔必须等于或大于 GROUP BY time() 时间间隔，或者，如果指定了，EVERY 时间间隔。

目前，这就是预期的行为。 GitHub Issue #6963 概述了一个功能请求，要求CQs支持数据覆盖中的空缺。

连续查询管理

只有管理员用户被允许处理CQs。有关用户权限的更多信息，请参阅 Authentication and Authorization。

列出连续查询

列出每个在 InfluxDB 实例上的 CQ： 

SHOW CONTINUOUS QUERIES

SHOW CONTINUOUS QUERIES 按数据库分组结果。

示例

输出显示 telegraf 和 mydb 数据库有 CQs：

> SHOW CONTINUOUS QUERIES
name: _internal
---------------
name   query


name: telegraf
--------------
name           query
idle_hands     CREATE CONTINUOUS QUERY idle_hands ON telegraf BEGIN SELECT min(usage_idle) INTO telegraf.autogen.min_hourly_cpu FROM telegraf.autogen.cpu GROUP BY time(1h) END
feeling_used   CREATE CONTINUOUS QUERY feeling_used ON telegraf BEGIN SELECT mean(used) INTO downsampled_telegraf.autogen.:MEASUREMENT FROM telegraf.autogen./.*/ GROUP BY time(1h) END


name: downsampled_telegraf
--------------------------
name   query


name: mydb
----------
name      query
vampire   CREATE CONTINUOUS QUERY vampire ON mydb BEGIN SELECT count(dracula) INTO mydb.autogen.all_of_them FROM mydb.autogen.one GROUP BY time(5m) END

删除连续查询

从特定数据库中删除一个CQ：

DROP CONTINUOUS QUERY <cq_name> ON <database_name>

DROP CONTINUOUS QUERY 返回一个空结果。

示例

从 telegraf 数据库中删除 idle_hands CQ：

> DROP CONTINUOUS QUERY "idle_hands" ON "telegraf"`
>

更改连续查询

CQs 一旦创建就无法更改。要更改 CQ，您必须 DROP 并重新 CREATE 它，使用更新的设置。

连续查询统计

如果 query-stats-enabled 在你的 influxdb.conf 中设置为 true 或者使用 INFLUXDB_CONTINUOUS_QUERIES_QUERY_STATS_ENABLED 环境变量，则数据将被写入 _internal，其中包含关于连续查询运行时间及其持续时间的信息。关于 CQ 配置设置的信息可以在 Configuration 文档中找到。

注意： _internal 包含内部系统数据，仅供内部使用。 _internal 中的结构和存储的数据可能会随时更改。 使用这些数据不在官方 InfluxData 支持的范围内。

连续查询使用案例

降采样和数据保留

使用 CQs 和 InfluxDB 数据库 保留策略 (RPs) 来减轻存储问题。 结合 CQs 和 RPs 自动将高精度数据降采样为较低精度，并从数据库中移除可 dispensable 的高精度数据。

请参阅 Downsampling and data retention 指南，以获取关于这一常见用例的详细步骤。

预计算耗时的查询

通过预计算昂贵的查询来缩短查询运行时间。 使用CQ自动将常见查询的高精度数据降采样到较低的精度。 对较低精度数据的查询需要更少的资源并且返回更快。

提示： 为您喜欢的图形工具预先计算查询，以加快图表和仪表板的填充。

替代 HAVING 子句

InfluxQL 不支持 HAVING 子句。通过创建一个 CQ 来聚合数据并查询 CQ 结果以应用 HAVING 子句，可以获得相同的功能。

注意： InfluxQL支持子查询，它们也提供与HAVING子句类似的功能。 有关更多信息，请参见数据探索。

示例

InfluxDB 不接受带有 HAVING 子句的查询。该查询计算每 30 分钟间隔的 bees 平均数量，并请求大于 20 的平均值。

SELECT mean("bees") FROM "farm" GROUP BY time(30m) HAVING mean("bees") > 20

要获得相同的结果：

1. 创建一个 CQ

此步骤执行上述查询的 mean("bees") 部分。因为此步骤创建了 CQ，所以您只需执行一次。

以下CQ自动计算在30分钟间隔内的bees的平均数量，并将这些平均值写入aggregate_bees测量中的mean_bees字段。

CREATE CONTINUOUS QUERY "bee_cq" ON "mydb" BEGIN SELECT mean("bees") AS "mean_bees" INTO "aggregate_bees" FROM "farm" GROUP BY time(30m) END

2. 查询CQ结果

此步骤执行查询中 HAVING mean("bees") > 20 部分。

查询测量 aggregate_bees 中的数据，并请求 mean_bees 字段中大于 20 的值，在 WHERE 子句中：

SELECT "mean_bees" FROM "aggregate_bees" WHERE "mean_bees" > 20

替代嵌套函数

一些 InfluxQL 函数 支持嵌套 其他函数。 大多数不支持。 如果您的函数不支持嵌套，您可以使用 CQ 计算 最内层函数来获得相同的功能。 然后只需查询 CQ 结果以计算最外层函数。

注意： InfluxQL 支持 子查询，它们提供与嵌套函数相同的功能。有关更多信息，请参见 数据探索。

示例

InfluxDB 不接受以下带有嵌套函数的查询。 该查询计算 bees 在 30 分钟间隔内的非空值数量及这些计数的平均值：

SELECT mean(count("bees")) FROM "farm" GROUP BY time(30m)

要获得相同的结果：

1. 创建一个 CQ

此步骤执行上述嵌套函数中的 count("bees") 部分。 因为此步骤创建了CQ，所以您只需要执行一次。

以下 CQ 自动计算 bees 在 30 分钟间隔内的非空值数量，并将这些计数写入 aggregate_bees 测量中的 count_bees 字段。

CREATE CONTINUOUS QUERY "bee_cq" ON "mydb" BEGIN SELECT count("bees") AS "count_bees" INTO "aggregate_bees" FROM "farm" GROUP BY time(30m) END

2. 查询CQ结果

此步骤执行上面嵌套函数的 mean([...]) 部分。

查询测量 aggregate_bees 中的数据以计算 count_bees 字段的平均值：

SELECT mean("count_bees") FROM "aggregate_bees" WHERE time >= <start_time> AND time <= <end_time>

进一步的信息

要了解如何结合两个InfluxDB特性，即CQs和保留策略，以定期对数据进行降采样并自动过期可丢弃的高精度数据，请参见 Downsampling and data retention。

Kapacitor，InfluxData 的数据处理引擎，可以完成与 InfluxDB 数据库中的连续查询相同的工作。

要了解何时使用Kapacitor而不是InfluxDB，以及如何使用TICKscript执行相同的CQ功能，请参见Kapacitor中的连续查询示例。

© 2025 InfluxData, Inc.

你的 InfluxDB OSS URL 是什么？

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

默认
自定义

有关更多信息，请参见 InfluxDB OSS URLs。

感谢您的反馈!

让我们知道我们可以做得更好的地方：

谢谢！

No thanks

Flux的未来

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

阅读更多

InfluxDB 3 开源版本现已公开Alpha测试

InfluxDB 3 Open Source is now available for alpha testing, licensed under MIT or Apache 2 licensing.

我们将发布两个产品作为测试版的一部分。

InfluxDB 3 核心，是我们新的开源产品。 它是一个用于时间序列和事件数据的实时数据引擎。 InfluxDB 3 企业版是建立在核心基础之上的商业版本，增加了历史查询能力、读取副本、高可用性、可扩展性和细粒度安全性。

有关如何开始的更多信息，请查看：