DQL 外层函数¶

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

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

函数链式调用¶

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
    }
  ]
}

外层函数列表¶

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()¶

说明: 计算处理集的平均值

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 对处理集累计求和

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 简单的表达式计算函数, 当前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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 计算某个指标一定时间范围内的变化率
详见: prometheus 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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 计算处理集每个元素的 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()¶

说明：计算处理集每个元素的 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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 计算处理集的最小值

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

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

参数	描述	类型	是否必填	默认值	示例
`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()¶

说明: 计算某个指标一定时间范围内的变化率
详见: prometheus 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()¶

说明: 当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": ""
    }
  ]
}