Todos los productos
Search
Centro de documentos

Simple Log Service:Expresiones lambda

Última actualización: Sep 02, 2026

Log Service permite definir expresiones lambda en instrucciones SQL y en el lenguaje de procesamiento de Simple Log Service (SPL), así como pasarlas a funciones específicas para ampliar sus capacidades. Este tema describe la sintaxis de las expresiones lambda y proporciona ejemplos de uso.

Sintaxis

Las expresiones lambda deben usarse con una función de orden superior, como filter function, reduce function, transform function, zip_with function o map_filter function. La sintaxis de una expresión lambda es la siguiente:

parameter -> expression

Parámetro

Descripción

parameter

Identificador de los parámetros de entrada.

expression

Expresión por evaluar. La mayoría de las expresiones MySQL son válidas en una expresión lambda. Ejemplos:

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)

Ejemplos

Example 1: Filter null elements

Devuelve los elementos no nulos del arreglo [5, null, 7, null].

  • Instrucción de consulta y análisis

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

Example 2: Sum array elements

Devuelve la suma de todos los elementos del arreglo [5, 20, 50].

  • Instrucción de consulta y análisis

    * | SELECT reduce(array[5, 20, 50], 0, (s, x) -> s + x, s -> s)
  • Resultado: 75 (suma acumulativa de 5+20+50).

Example 3: Filter a map by value

Crea un mapa a partir de dos arreglos y conserva solo los pares clave-valor con valores mayores que 10.

  • Instrucción de consulta y análisis

    * | SELECT map_filter(map(array['class01', 'class02', 'class03'], array[11, 10, 9]), (k,v) -> v > 10)
  • Resultado: {"class01":11}. La función conserva únicamente los pares clave-valor cuyo valor es mayor que 10.

Example 4: Swap paired elements

Este ejemplo empareja elementos de dos arreglos en el mismo índice. Luego aplica una expresión lambda para intercambiar los elementos de cada par y crear un nuevo arreglo anidado.

  • Instrucción de consulta y análisis

    * | SELECT zip_with(array[1, 3, 5], array['a', 'b', 'c'], (x, y) -> (y, x))
  • Resultado: [["a",1],["b",3],["c",5]]. La expresión lambda invierte el orden de cada par de elementos y los combina en un arreglo anidado.

Example 5: Transform elements with null handling

Suma 1 a cada elemento del arreglo [5, NULL, 6]. Si un elemento es nulo, primero se convierte a 0.

  • Instrucción de consulta y análisis

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

Other examples

* | 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))