日志服务查询分析功能支持通过Lambda函数对日志数据进行分析处理。

Lambda表达式

Lambda表达式的形式为->。

样例如下： 
x -> x + 1
(x, y) -> x + y
x -> regexp_like(x, 'a+')
x -> x[1] / x[2]
x -> IF(x > 0, x, -x)
x -> COALESCE(x, 0)
x -> CAST(x AS JSON)
x -> x + TRY(1 / 0)

大多数的MySQL表达式都可以在Lambda中使用。

filter(array<T>, function<T, boolean>) → ARRAY<T>

从array中过滤数据，只获取满足function且返回true的元素。

示例如下： 
SELECT filter(ARRAY [], x -> true); -- []
SELECT filter(ARRAY [5, -6, NULL, 7], x -> x > 0); -- [5, 7]
SELECT filter(ARRAY [5, NULL, 7, NULL], x -> x IS NOT NULL); -- [5, 7]

map_filter(map<K, V>, function<K, V, boolean>) → MAP<K,V>

从map中过滤数据，只获取满足function且返回true的元素对。

示例如下： 
SELECT map_filter(MAP(ARRAY[], ARRAY[]), (k, v) -> true); -- {}
SELECT map_filter(MAP(ARRAY[10, 20, 30], ARRAY['a', NULL, 'c']), (k, v) -> v IS NOT NULL); -- {10 -> a, 30 -> c}
SELECT map_filter(MAP(ARRAY['k1', 'k2', 'k3'], ARRAY[20, 3, 15]), (k, v) -> v > 10); -- {k1 -> 20, k3 -> 15}

reduce(array<T>, initialState S, inputFunction<S, T, S>, outputFunction<S, R>) → R

使用reduce函数，从初始状态开始，依次遍历array中的每一个元素，每次在状态S的基础上计算inputFunction(s,t)后生成新的状态。最终应用outputFunction把最终状态S变成输出结果R。详细步骤如下：

  1. 初始状态S。
  2. 遍历每个元素T。
  3. 计算inputFunction(S,T)，生成新状态S。
  4. 重复步骤2~步骤3，直到最后一个元素被遍历以及生成新状态。
  5. 利用最终状态S，获取最终输出结果R。
示例如下： 
SELECT reduce(ARRAY [], 0, (s, x) -> s + x, s -> s); -- 0
SELECT reduce(ARRAY [5, 20, 50], 0, (s, x) -> s + x, s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + x, s -> s); -- NULL
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> s + COALESCE(x, 0), s -> s); -- 75
SELECT reduce(ARRAY [5, 20, NULL, 50], 0, (s, x) -> IF(x IS NULL, s, s + x), s -> s); -- 75
SELECT reduce(ARRAY [2147483647, 1], CAST (0 AS BIGINT), (s, x) -> s + x, s -> s); -- 2147483648
SELECT reduce(ARRAY [5, 6, 10, 20], -- calculates arithmetic average: 10.25
              CAST(ROW(0.0, 0) AS ROW(sum DOUBLE, count INTEGER)),
              (s, x) -> CAST(ROW(x + s.sum, s.count + 1) AS ROW(sum DOUBLE, count INTEGER)),
              s -> IF(s.count = 0, NULL, s.sum / s.count));

transform(array<T>, function<T, U>) → ARRAY<U>

对数组中的每个元素，依次调用function，生成新的结果U。

示例如下： 
SELECT transform(ARRAY [], x -> x + 1); -- []
SELECT transform(ARRAY [5, 6], x -> x + 1); -- [6, 7] 表示对每个元素执行加1操作
SELECT transform(ARRAY [5, NULL, 6], x -> COALESCE(x, 0) + 1); -- [6, 1, 7]
SELECT transform(ARRAY ['x', 'abc', 'z'], x -> x || '0'); -- ['x0', 'abc0', 'z0']
SELECT transform(ARRAY [ARRAY [1, NULL, 2], ARRAY[3, NULL]], a -> filter(a, x -> x IS NOT NULL)); -- [[1, 2], [3]]

zip_with(array<T>, array<U>, function<T, U, R>) → array<R>

将两个array合并，根据元素T和元素U，通过函数生成新的array中的元素R。

示例如下： 
SELECT zip_with(ARRAY[1, 3, 5], ARRAY['a', 'b', 'c'], (x, y) -> (y, x)); --表示调换前后两个数组的元素位置，生成一个新的数组。结果： [['a', 1], ['b', 3],['c', 5]]
SELECT zip_with(ARRAY[1, 2], ARRAY[3, 4], (x, y) -> x + y); -- 结果[4, 6]
SELECT zip_with(ARRAY['a', 'b', 'c'], ARRAY['d', 'e', 'f'], (x, y) -> concat(x, y)); 表示把前后两个数组的元素拼接，生成一个新的字符串。结果： ['ad', 'be', 'cf']