跳转至

DQL 外层函数

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

文档评价

文档内容是否对您有帮助? ×