Simple Log Service:Expressions lambda

Syntaxe

Une expression lambda s'utilise conjointement avec une fonction d'ordre supérieur, telle que la fonction filter, la fonction reduce, la fonction transform, la fonction zip_with ou la fonction map_filter. La syntaxe d'une expression lambda est la suivante :

parameter -> expression

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)

Exemples

Exemple 1 : Filtrer les éléments null

Renvoie les éléments non nuls du tableau [5, null, 7, null].

• Instruction de requête et d'analyse

  * | SELECT filter(array[5, null, 7, null], x -> x is not null)

• Le résultat est [5,7].

Exemple 2 : Somme des éléments d'un tableau

Renvoie la somme de tous les éléments du tableau [5, 20, 50].

• Instruction de requête et d'analyse

  * | SELECT reduce(array[5, 20, 50], 0, (s, x) -> s + x, s -> s)

• Le résultat est 75 (somme cumulative de 5+20+50).

Exemple 3 : Filtrer une map par valeur

Crée une map à partir de deux tableaux et conserve uniquement les paires clé-valeur dont les valeurs sont supérieures à 10.

• Instruction de requête et d'analyse

  * | SELECT map_filter(map(array['class01', 'class02', 'class03'], array[11, 10, 9]), (k,v) -> v > 10)

• Le résultat est {"class01":11}. La fonction conserve uniquement les paires clé-valeur dont les valeurs sont supérieures à 10.

Exemple 4 : Inverser les éléments appariés

Cet exemple apparie les éléments de deux tableaux situés au même index. Il applique ensuite une expression lambda pour inverser les éléments de chaque paire, créant ainsi un nouveau tableau imbriqué.

• Instruction de requête et d'analyse

  * | SELECT zip_with(array[1, 3, 5], array['a', 'b', 'c'], (x, y) -> (y, x))

• Le résultat est [["a",1],["b",3],["c",5]]. L'expression lambda inverse l'ordre de chaque paire d'éléments et les combine dans un tableau imbriqué.

Exemple 5 : Transformer des éléments avec gestion des valeurs null

Ajoute 1 à chaque élément du tableau [5, NULL, 6]. Si un élément est null, il est d'abord converti en 0.

• Instruction de requête et d'analyse

  * | SELECT transform(array[5, NULL, 6], x -> coalesce(x, 0) + 1)

• Le résultat est [6,1,7].

Autres exemples

* | SELECT filter(array[], x -> true)
* | SELECT map_filter(map(array[],array[]), (k, v) -> true)
* | 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))
* | SELECT reduce(array[2147483647, 1], cast(0 AS bigint), (s, x) -> s + x, s -> s)
* | SELECT reduce(array[5, 20, null, 50], 0, (s, x) -> s + x, s -> s)
* | SELECT transform(array[array[1, null, 2], array[3, null]], a -> filter(a, x -> x is not null))
* | SELECT zip_with(array['a', 'b', 'c'], array['d', 'e', 'f'], (x, y) -> concat(x, y))