Funciones regulares

Documentación sobre funciones regulares

Hay al menos* dos tipos de funciones: las funciones regulares (a las que simplemente se llama «funciones») y las funciones de agregación. Se trata de conceptos completamente distintos. Las funciones regulares actúan como si se aplicaran a cada fila por separado (para cada fila, el resultado de la función no depende de las demás filas). Las funciones de agregación acumulan un conjunto de valores de varias filas (es decir, dependen del conjunto completo de filas).

En esta sección se describen las funciones regulares. Para las funciones de agregación, consulte la sección «Funciones de agregación».

Hay un tercer tipo de función, al que pertenece la función ‘arrayJoin’. Las funciones de tabla también pueden mencionarse por separado.

​

Tipado fuerte

A diferencia del SQL estándar, ClickHouse tiene tipado fuerte. En otras palabras, no realiza conversiones implícitas entre tipos. Cada función funciona con un conjunto específico de tipos. Esto significa que a veces es necesario usar funciones de conversión de tipos.

​

Eliminación de subexpresiones comunes

Todas las expresiones de una consulta que tienen el mismo AST (el mismo registro o el mismo resultado del análisis sintáctico) se consideran equivalentes. Estas expresiones se agrupan y se ejecutan una sola vez. Las subconsultas idénticas también se eliminan de esta manera.

​

Tipos de resultados

Todas las funciones devuelven un único valor como resultado (no varios ni ninguno). El tipo del resultado suele definirse únicamente por los tipos de los argumentos, no por los valores. Las excepciones son la función tupleElement (el operador a.N) y la función toFixedString.

​

Constantes

Por simplicidad, ciertas funciones solo pueden funcionar con constantes en algunos argumentos. Por ejemplo, el argumento derecho del operador LIKE debe ser una constante. Casi todas las funciones devuelven una constante para argumentos constantes. La excepción son las funciones que generan números aleatorios. La función ‘now’ devuelve valores distintos para consultas ejecutadas en momentos diferentes, pero el resultado se considera una constante, ya que la constancia solo es importante dentro de una única consulta. Una expresión constante también se considera una constante (por ejemplo, la mitad derecha del operador LIKE puede construirse a partir de varias constantes).

Las funciones pueden implementarse de distintas maneras para argumentos constantes y no constantes (se ejecuta código diferente). Pero los resultados de una constante y de una columna real que contiene solo el mismo valor deben coincidir entre sí.

​

Procesamiento de NULL

Las funciones presentan los siguientes comportamientos:

• Si al menos uno de los argumentos de la función es NULL, el resultado de la función también será NULL.
• Un comportamiento especial que se especifica individualmente en la descripción de cada función. En el código fuente de ClickHouse, estas funciones tienen UseDefaultImplementationForNulls=false.

​

Constancia

Las funciones no pueden modificar los valores de sus argumentos; cualquier cambio se devuelve como resultado. Por lo tanto, el resultado de calcular funciones por separado no depende del orden en que se escriban en la consulta.

​

Funciones de orden superior

​

Operador -> y funciones lambda(params, expr)

Las funciones de orden superior solo pueden aceptar funciones lambda como argumento funcional. Para pasar una función lambda a una función de orden superior, use el operador ->. En el lado izquierdo de la flecha hay un parámetro formal, que puede ser cualquier ID, o varios parámetros formales: cualquier ID dentro de una tupla. En el lado derecho de la flecha hay una expresión que puede usar estos parámetros formales, así como cualquier columna de la tabla.

Ejemplos:

x -> 2 * x
str -> str != Referer

Una función lambda que acepta varios argumentos también puede pasarse a una función de orden superior. En este caso, a la función de orden superior se le pasan varios arrays de la misma longitud, con los que se corresponderán estos argumentos.

En algunas funciones, se puede omitir el primer argumento (la función lambda). En este caso, se asume un mapeo de identidad.

​

Nombres de funciones sin más como lambdas

En lugar de escribir una expresión lambda completa, puedes pasar directamente el nombre de una función a una función de orden superior. El nombre de la función se convierte automáticamente en una expresión lambda equivalente.

Por ejemplo, los siguientes pares son equivalentes:

SELECT arrayMap(negate, [1, 2, 3]);            -- [-1, -2, -3]
SELECT arrayMap(x -> negate(x), [1, 2, 3]);    -- [-1, -2, -3]

SELECT arrayMap(plus, [1, 2, 3], [10, 20, 30]);            -- [11, 22, 33]
SELECT arrayMap((x, y) -> plus(x, y), [1, 2, 3], [10, 20, 30]); -- [11, 22, 33]

SELECT arrayFilter(isNotNull, [1, NULL, 3, NULL, 5]);            -- [1, 3, 5]
SELECT arrayFilter(x -> isNotNull(x), [1, NULL, 3, NULL, 5]);    -- [1, 3, 5]

SELECT arrayFold(plus, [1, 2, 3, 4, 5], toUInt64(0));                      -- 15
SELECT arrayFold((acc, x) -> plus(acc, x), [1, 2, 3, 4, 5], toUInt64(0));  -- 15

Esto funciona con funciones integradas, UDFs SQL, UDFs ejecutables y UDFs de WebAssembly. Los nombres de columna y alias tienen prioridad sobre los nombres de función cuando hay ambigüedad.

La aridad de la lambda se toma de la función interna. Por ejemplo, arrayMap(plus, ...) usa aridad 2 porque plus toma dos argumentos, por lo que también funciona con tuplas de entrada como arrayMap(plus, [(1, 10), (2, 20)]), donde los elementos de la tupla se desempaquetan en los argumentos de la lambda.

En el caso de funciones internas variádicas (como concat, que acepta cualquier número de argumentos), la aridad de la lambda pasa a depender del número de argumentos de tipo array. Esto es correcto para funciones de orden superior como arrayMap, arrayFilter y arrayFold. En funciones de orden superior que aceptan parámetros fijos que no son arrays además de arrays —por ejemplo, arrayPartialSort(f, limit, arr)—, los nombres de funciones variádicas sin una lambda explícita pueden producir una aridad incorrecta, en cuyo caso se requiere una lambda explícita.

Las funciones internas variádicas tampoco desempaquetan automáticamente las tuplas de entrada. Por ejemplo, arrayMap(concat, [('a', 'b'), ('c', 'd')]) se reescribe como una lambda unaria y no es equivalente a arrayMap((x, y) -> concat(x, y), [('a', 'b'), ('c', 'd')]). Use una lambda explícita cuando quiera desestructurar elementos de una tupla en una llamada variádica.

​

Funciones definidas por el usuario (UDFs)

ClickHouse admite funciones definidas por el usuario. Consulte UDFs.