DQL 外层函数

# DQL 外层函数

## DQL 外层函数说明[¶](https://docs.guance.com/dql/out-funcs/#dql)

DQL 中外层函数主要用于二次计算 DQL 返回的数据。

对外层函数而言，如无特殊说明，对所有数据类型均生效。

### 函数链式调用[¶](https://docs.guance.com/dql/out-funcs/#_1)

DQL 支持多个函数级联起来，实现链式调用。

```
# 请求
difference(dql=`R::resource:(resource_load) {resource_load > 100} [1614239472:1614239531] limit 3`).cumsum()

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614239530215,
              -364330000
            ],
            [
              1614239530135,
              -889240000
            ]
          ]
        }
      ],
      "cost": "16.873202ms",
      "group_by": null
    }
  ]
}
```

## 外层函数列表[¶](https://docs.guance.com/dql/out-funcs/#_2)

### abs()[¶](https://docs.guance.com/dql/out-funcs/#abs)

- 说明：计算处理集每个元素的绝对值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `abs('')` 或者 `abs(dql='')`： 当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `abs()` 当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
abs(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614566985356,
              8004050000
            ],
            [
              1614566982596,
              79325000
            ],
            [
              1614566922891,
              90110000
            ]
          ]
        }
      ],
      "cost": "43.333168ms",
      "group_by": null
    }
  ]
}
```

### avg()[¶](https://docs.guance.com/dql/out-funcs/#avg)

- 说明：计算处理集的平均值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `avg('')` 或者 `avg(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `avg()`：当作为链接调用的非第 1 个函数时，不需要参数。

**注意**：返回值 time 列的值为 0。

- 示例：

```
# 请求
avg(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              0,
              2674188333.3333335
            ]
          ]
        }
      ],
      "cost": "43.380748ms",
      "group_by": null
    }
  ]
}
```

### count()[¶](https://docs.guance.com/dql/out-funcs/#count)

- 说明：对返回结果，统计数量

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `count('')` 或者 `count(dql='')`： 当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `count()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
count(`L::nginxlog:(status) {client_ip='127.0.0.1'}`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "nginxlog",
          "columns": [
            "time",
            "status"
          ],
          "values": [
            [
              0,
              20
            ]
          ]
        }
      ],
      "cost": "21.159579ms",
      "group_by": null
    }
  ]
}
```

### count_distinct()[¶](https://docs.guance.com/dql/out-funcs/#count_distinct)

- 说明：对处理集, 去重统计数量

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `count_distinct('')` 或者 `count_distinct(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `count_distinct()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
count_distinct(`L::nginxlog:(status) {client_ip='127.0.0.1'}`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "nginxlog",
          "columns": [
            "time",
            "status"
          ],
          "values": [
            [
              0,
              2
            ]
          ]
        }
      ],
      "cost": "21.159579ms",
      "group_by": null
    }
  ]
}
```

### count_filter()[¶](https://docs.guance.com/dql/out-funcs/#count_filter)

- 说明：对于查询结果集，过滤部分数据

| 参数   | 描述         | 类型   | 是否必填 | 默认值 | 示例                  |
| :----- | :----------- | :----- | :------- | :----- | :-------------------- |
| `dql`  | DQL 查询语句 | string | 是       |        | `M::cpu [5m]`         |
| `expr` | 过滤表达式   | string | 是       |        | `status !=`critical`` |

- 示例：

```
# 请求
count_filter(
  dql="E::monitor:(event_id, status, source){source=monitor} by event_id", 
  expr="status != `critical`"
)

# 返回
{
  "content": [
    {
      "series": [
        {
          "tags": {
            "event_id": "event-0dbd135d36134f4d8d08cb85a378a9f3"
          },
          "columns": [
            "time",
            "event_id",
            "status",
            "source"
          ],
          "values": [
            [
              1619578141319,
              "event-0dbd135d36134f4d8d08cb85a378a9f3",
              "warning",
              "monitor"
            ]
          ]
        }
      ],
      "cost": "4.762239289s",
      "raw_query": "",
      "filter_count": 2
    }
  ]
}
```

### cumsum()[¶](https://docs.guance.com/dql/out-funcs/#cumsum)

- 说明：对处理集累计求和

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `cumsum('')` 或者 `cumsum(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `cumsum()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
cumsum(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250017606,
              985025000
            ],
            [
              1614250017602,
              1104300000
            ],
            [
              1614250017599,
              2253690000
            ]
          ]
        }
      ],
      "cost": "25.468929ms",
      "group_by": null
    }
  ]
}
```

### derivative()[¶](https://docs.guance.com/dql/out-funcs/#derivative)

- 说明：计算处理集相邻元素的导数

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：求导的时间单位为秒（s）。

- 场景：
- `derivative('')` 或者 `derivative(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `derivative()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
derivative(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250560828,
              2159233.6119981343
            ],
            [
              1614250560818,
              -11357500000
            ]
          ]
        }
      ],
      "cost": "24.817991ms",
      "group_by": null
    }
  ]
}
```

### difference()[¶](https://docs.guance.com/dql/out-funcs/#difference)

- 说明：计算处理集相邻元素的差值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：处理集至少大于一行，否则返回空值。

- 场景：
- `difference('')` 或者 `difference(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `difference()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
difference(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250788967,
              88595000
            ],
            [
              1614250788854,
              -89940000
            ]
          ]
        }
      ],
      "cost": "24.738317ms",
      "group_by": null
    }
  ]
}
```

### eval()[¶](https://docs.guance.com/dql/out-funcs/#eval)

- 说明：简单的表达式计算函数, 当前eval函数支持的运算符为: (1) 加减乘除四则运算 (+ - * /) ;(2) 取模 (%) ; (3)指数运算 (^)

| 参数        | 描述         | 类型   | 是否必填 | 默认值 | 示例                                           |
| :---------- | :----------- | :----- | :------- | :----- | :--------------------------------------------- |
| 表达式      | 表达式计算   | string | 是       |        | `A.a1 + B.b1 + 10`                             |
| DQL查询语句 | DQL 查询语句 | string | 是       |        | `M::cpu:(avg(usage_total) as a1) { } [2h::1h]` |

- 场景：
- `eval(表达式, 查询语句1， 查询语句...，查询语句n)`

**注意**：eval函数不支持链接调用， 即 eval 函数不能和其他外层函数组合使用。

- 示例：

```
# 请求
eval(A.a1 + B.b1 + 10 , A='M::`cpu`:(avg(usage_total) as `a1`) {  } [2h::1h]', B='M::`cpu`:(avg(usage_total) as `b1`) {  } [2h::1h]')

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "cpu",
          "columns": [
            "time",
            "a1"
          ],
          "values": [
            [
              1644300000000,
              30.329462776849976
            ],
            [
              1644303600000,
              30.164650529027888
            ],
            [
              1644307200000,
              29.609406296473907
            ]
          ]
        }
      ],
      "cost": "542.061008ms",
      "is_running": false,
      "async_id": ""
    }
  ]
}
```

### first()[¶](https://docs.guance.com/dql/out-funcs/#first)

- 说明：计算处理集的最早有意义的值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `first('')` 或者 `first(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `first()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
first(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614567497285,
              8003885000
            ]
          ]
        }
      ],
      "cost": "34.99329ms",
      "group_by": null
    }
  ]
}
```

### irate()[¶](https://docs.guance.com/dql/out-funcs/#irate)

- 说明：计算某个指标一定时间范围内的变化率
- 详见：[prometheus irate](https://prometheus.io/docs/prometheus/latest/querying/functions/#irate)

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：时间单位为秒（s）。

- 场景：
- `irate('')` 或者 `irate(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `irate()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
irate(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250560828,
              2159233.6119981343
            ],
            [
              1614250560818,
              -11357500000
            ]
          ]
        }
      ],
      "cost": "24.817991ms",
      "group_by": null
    }
  ]
}
```

### last()[¶](https://docs.guance.com/dql/out-funcs/#last)

- 说明：计算处理集的最近有意义的值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `last('')` 或者 `last(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `last()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
last(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614567720225,
              50490000
            ]
          ]
        }
      ],
      "cost": "35.016794ms",
      "group_by": null
    }
  ]
}
```

### log10()[¶](https://docs.guance.com/dql/out-funcs/#log10)

- 说明：计算处理集每个元素的 log10 值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `log10('')` 或者 `log10(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `log10()`：当作为链接调用的非第 1 个函数时，不需要参数。

**注意**：处理集至少大于一行，否则返回空值。

- 示例：

```
# 请求
log10(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614251956207,
              7.317750028842234
            ],
            [
              1614251955227,
              8.191939809656507
            ],
            [
              1614251925530,
              8.133810257633591
            ]
          ]
        }
      ],
      "cost": "717.257675ms",
      "group_by": null
    }
  ]
}
```

### log2()[¶](https://docs.guance.com/dql/out-funcs/#log2)

- 说明：计算处理集每个元素的 log2 值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：处理集至少大于一行，否则返回空值。

- 场景：
- `log2('')` 或者 `log2(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `log2()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
log2(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614251925530,
              27.019932813316046
            ],
            [
              1614251865510,
              26.439838744891972
            ],
            [
              1614251805516,
              29.703602660685803
            ]
          ]
        }
      ],
      "cost": "1.01630157s",
      "group_by": null
    }
  ]
}
```

### max()[¶](https://docs.guance.com/dql/out-funcs/#max)

- 说明：计算处理集的最大值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `max('')` 或者 `max(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `max()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
max(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614567387278,
              1006975000
            ]
          ]
        }
      ],
      "cost": "43.857171ms",
      "group_by": null
    }
  ]
}
```

### min()[¶](https://docs.guance.com/dql/out-funcs/#min)

- 说明：计算处理集的最小值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

- 场景：
- `min('')` 或者 `min(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 dql 查询，类型为字符串；
- `min()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
min(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614567507202,
              86480000
            ]
          ]
        }
      ],
      "cost": "42.551151ms",
      "group_by": null
    }
  ]
}
```

### moving_average()[¶](https://docs.guance.com/dql/out-funcs/#moving_average)

- 说明：计算处理集的移动平均值

| 参数   | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :----- | :----------- | :----- | :------- | :----- | :------------ |
| `dql`  | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |
| `size` | 窗口大小     | int    | 是       |        | 3             |

**注意**：窗口的大小需要不小于处理集的行数，否则返回空值。

- 场景：
- `moving_average('', n)` 或者 `moving_average(dql='', size=n)`；
- `moving_average(size=3)`：当作为链接调用的非第 1 个函数时，参数有且只有 1 个，表示窗口大小。
- 示例：

```
# 请求
moving_average(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`,size=2)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614251505520,
              106675000
            ],
            [
              1614251445542,
              102757500
            ]
          ]
        }
      ],
      "cost": "24.738867ms",
      "group_by": null
    }
  ]
}
```

### non_negative_derivative()[¶](https://docs.guance.com/dql/out-funcs/#non_negative_derivative)

- 说明：计算处理集相邻元素的非负导数

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：求导的时间单位为秒（s）。

- 场景：
- `non_negative_derivative('')` 或者 `non_negative_derivative(dql='')`
- `non_negative_derivative()` 当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
non_negative_derivative(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250901131,
              234697986.57718122
            ]
          ]
        }
      ],
      "cost": "25.706837ms",
      "group_by": null
    }
  ]
}
```

### non_negative_difference()[¶](https://docs.guance.com/dql/out-funcs/#non_negative_difference)

- 说明：计算处理集相邻元素的非负差值

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：处理集至少大于一行，否则返回空值。

- 场景：
- `non_negative_difference('')` 或者 `non_negative_difference(dql='')`
- `non_negative_difference()` 当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
non_negative_difference(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250900989,
              87595000
            ]
          ]
        }
      ],
      "cost": "23.694907ms",
      "group_by": null
    }
  ]
}
```

### rate()[¶](https://docs.guance.com/dql/out-funcs/#rate)

- 说明：计算某个指标一定时间范围内的变化率
- 详见：[prometheus rate](https://prometheus.io/docs/prometheus/latest/querying/functions/#rate)

| 参数  | 描述         | 类型   | 是否必填 | 默认值 | 示例          |
| :---- | :----------- | :----- | :------- | :----- | :------------ |
| `dql` | DQL 查询语句 | string | 是       |        | `M::cpu [5m]` |

**注意**：时间单位为秒（s）。

- 场景：
- `rate('')` 或者 `rate(dql='')`：当作为链接调用的第 1 个函数时，参数有且只有 1 个，第一个参数表示 DQL 查询，类型为字符串；
- `rate()`：当作为链接调用的非第 1 个函数时，不需要参数。
- 示例：

```
# 请求
rate(dql=`R::resource:(resource_load) {resource_load > 100} limit 3`)

# 返回
{
  "content": [
    {
      "series": [
        {
          "name": "resource",
          "columns": [
            "time",
            "resource_load"
          ],
          "values": [
            [
              1614250560828,
              2159233.6119981343
            ],
            [
              1614250560818,
              -11357500000
            ]
          ]
        }
      ],
      "cost": "24.817991ms",
      "group_by": null
    }
  ]
}
```

### series_sum()[¶](https://docs.guance.com/dql/out-funcs/#series_sum)

- 说明：当 `group by` 产生多个 `series`，根据时间点，合并为 1 个 `series`。其中，相同时间点的多个 `series` 求和

| 参数    | 描述             | 类型        | 是否必填 | 默认值 | 示例             |
| :------ | :--------------- | :---------- | :------- | :----- | :--------------- |
| `dql`   | DQL 查询语句     | string      | 是       |        | `M::cpu [5m]`    |
| `sumBy` | group by字段列表 | string_list | 否       |        | `sumBy=['host']` |

**注意**：处理集至少大于一行，否则返回空值。

> sumBy 举例:
>
> nsq 不同的node节点，可能有相同的 topic，假设某个指标集(f1)，是在topic上，
>
> M::nsq:(last(f1)) by host, topic, 需要按照 host 级别，统计一下 每个host的 topic指标 f1 总和
>
> series_sum(dql="M::rocketmq:(last(f1)) BY host, topic", sumBy = ["host"])

- 场景：`series_sum('')` 或者 `series_sum(dql='')` 或者 `series_sum(dql='', sumBy=['f1', 'f2'])`
- 示例：

```
# 请求
series_sum(dql="L::`*`:(last(f2)) [20d::1d] by f1")

# 返回
{
  "content": [
    {
      "series": [
        {
          "tags": {
            "f1": "all"
          },
          "columns": [
            "time",
            "last(f2)"
          ],
          "values": [
            [
              1625097600000,
              32
            ],
            [
              1625184000000,
              41
            ]
          ]
        }
      ],
      "cost": ""
    }
  ]
}
```