文档文档

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

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 数据库中的以下示例数据。 度量 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 自动从单个字段降采样数据，并将结果写入同一数据库中的另一个度量。

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

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 使用 CQ 和保留策略自动降采样数据，并将这些降采样数据保留一段替代时间。 有关此 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 数据库中每个度量（在本例中，只有 bus_data 度量）的 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 度量中每小时的平均乘客人数，并将结果存储在 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。

基本语法的常见问题

处理没有数据的时间间隔

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

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

重新采样先前的时间间隔

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

为旧数据回填结果

CQ 在实时数据上运行，即时间戳相对于 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

请参阅 基本语法描述。

计划和覆盖范围

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 数据库中的以下示例数据。 度量 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() 和 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 度量中 passengers 的 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 概述了 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 中将 query-stats-enabled 设置为 true，或者使用 INFLUXDB_CONTINUOUS_QUERIES_QUERY_STATS_ENABLED 环境变量，则数据将被写入 _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 度量中的 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 中的数据，并在 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 度量中的 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 的两个功能、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 开源版本现已公开发布 Alpha 版

InfluxDB 3 开源版本现已可用于 alpha 测试，根据 MIT 或 Apache 2 许可获得许可。

我们正在发布两个作为 alpha 版本一部分的产品。

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

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