文档文档

InfluxDB OSS v1

InfluxQL 连续查询

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

简介

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

基本语法高级语法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 数据库的预设时间边界来确定何时执行以及查询中要覆盖的时间范围。

CQ 的执行间隔与 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 数据库中的以下示例数据。measurement bus_data 存储有关公交车 passengers 和 complaints 数量的 15 分钟分辨率数据

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 自动下采样来自单个字段的数据，并将结果写入同一数据库中的另一个 measurement。

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 measurement 中每小时的平均乘客数，并将结果存储在 transportation 数据库的 average_passengers measurement 中。

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
自动将数据下采样到另一个保留策略中

完全限定目标 measurement，以将下采样数据存储在非 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 measurement 中每小时的平均乘客数，并将结果存储在 transportation 数据库、three_weeks RP 和 average_passengers measurement 中。

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 使用 CQ 和保留策略自动下采样数据，并将这些下采样数据保存更长的时间。有关此 CQ 用例的深入讨论，请参阅下采样和数据保留指南。

使用反向引用自动下采样数据库

将函数与通配符 (*) 和 INTO 查询的反向引用语法结合使用，以自动下采样来自数据库中所有 measurement 和数值字段的数据。

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 数据库中每个 measurement（在本例中，只有 bus_data measurement）的 passengers 和 complaints 的 30 分钟平均值。它将结果存储在 downsampled_transportation 数据库中。

cq_basic_br 以 30 分钟间隔执行，间隔与 GROUP BY time() 间隔相同。每 30 分钟，cq_basic_br 运行一个查询，该查询覆盖 now() 和 now() 减去 GROUP BY time() 间隔之间的时间范围，即 now() 和 now() 前 30 分钟之间的时间范围。

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 measurement 中每小时的平均乘客数，并将结果存储在 average_passengers measurement 中。

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。

基本语法的常见问题

处理没有数据的时间间隔

如果时间间隔内没有数据，则 CQ 不会为该时间间隔写入任何结果。

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

重新采样先前的时间间隔

基本 CQ 运行一个查询，该查询覆盖 now() 和 now() 减去 GROUP BY time() 间隔之间的时间范围。有关如何配置查询的时间范围，请参阅高级语法。

回填旧数据的结果

CQ 在实时数据上运行，即时间戳相对于 now() 发生的数据。使用基本 INTO 查询来回填旧时间戳的数据的结果。

CQ 结果中缺少标签

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

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

高级语法

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

高级语法描述

cq_query

请参阅基本语法描述。

计划和覆盖范围

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

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

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

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

高级语法示例

以下示例使用 transportation 数据库中的以下示例数据。measurement 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 measurement 中每小时的平均 passengers，并将结果存储在 transportation 数据库的 average_passengers measurement 中。

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 measurement 中 passengers 的 30 分钟平均值，并将结果存储在 transportation 数据库的 average_passengers measurement 中。

cq_advanced_for 以 30 分钟间隔执行，间隔与 GROUP BY time() 间隔相同。每 30 分钟，cq_advanced_for 运行一个查询，该查询覆盖 now() 和 now() 减去 FOR 间隔之间的时间范围，即 now() 和 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 measurement 中 passengers 的 30 分钟平均值，并将结果存储在 transportation 数据库的 average_passengers measurement 中。

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 不会将点写入目标 measurement。

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 measurement 中每小时的平均 passengers，并将结果存储在 transportation 数据库的 average_passengers measurement 中。在可能的情况下，它为没有结果的时间间隔写入值 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 概述了 CQ 支持数据覆盖范围中存在间隙的功能请求。

连续查询管理

只有管理员用户才能使用 CQ。有关用户权限的更多信息，请参阅身份验证和授权。

列出连续查询

使用以下命令列出 InfluxDB 实例上的每个 CQ

SHOW CONTINUOUS QUERIES

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

示例

输出显示 telegraf 和 mydb 数据库具有 CQ

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

更改连续查询

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

连续查询统计信息

如果在您的 influxdb.conf 中或使用 INFLUXDB_CONTINUOUS_QUERIES_QUERY_STATS_ENABLED 环境变量将 query-stats-enabled 设置为 true，则数据将写入 _internal，其中包含有关连续查询何时运行及其持续时间的信息。有关 CQ 配置设置的信息，请参见配置文档。

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

连续查询用例

下采样和数据保留

将 CQ 与 InfluxDB 数据库保留策略 (RP) 结合使用，以缓解存储问题。将 CQ 和 RP 结合使用，以自动将高精度数据下采样为较低精度，并从数据库中删除可有可无的高精度数据。

有关此常见用例的详细演练，请参阅下采样和数据保留指南。

预先计算开销大的查询

通过使用 CQ 预先计算开销大的查询来缩短查询运行时间。使用 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 measurement 中的 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 部分。

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

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

替代嵌套函数

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

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

示例

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

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

要获得相同的结果

1. 创建 CQ

此步骤执行上述嵌套函数的 count("bees") 部分。由于此步骤创建 CQ，因此您只需执行一次即可。

以下 CQ 自动计算 30 分钟间隔内 bees 的非空值的数量，并将这些计数写入 aggregate_bees measurement 中的 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([...]) 部分。

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

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

更多信息

要了解如何结合使用 InfluxDB 的两个功能（CQ 和保留策略）来定期下采样数据并自动过期可有可无的高精度数据，请参阅下采样和数据保留。

Kapacitor（InfluxData 的数据处理引擎）可以执行与 InfluxDB 数据库中的连续查询相同的工作。

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

此页面是否对您有帮助？

感谢您的反馈！

© 2025 InfluxData, Inc.

您的 InfluxDB OSS URL 是什么？

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

默认
自定义

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

感谢您的反馈！

请告诉我们如何做得更好

谢谢！

不用了，谢谢

Flux 的未来

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

阅读更多

现已全面上市

InfluxDB 3 Core 和 Enterprise

快速启动。更快扩展。

获取更新

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

有关更多信息，请查看