> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentación sobre funciones regulares

# 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».

<Note>
  Hay un tercer tipo de función, al que pertenece la [función 'arrayJoin'](/es/reference/functions/regular-functions/array-join). Las [funciones de tabla](/es/reference/functions/table-functions) también pueden mencionarse por separado.
</Note>

<div id="strong-typing">
  ## Tipado fuerte
</div>

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.

<div id="common-subexpression-elimination">
  ## Eliminación de subexpresiones comunes
</div>

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.

<div id="types-of-results">
  ## Tipos de resultados
</div>

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`.

<div id="constants">
  ## Constantes
</div>

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í.

<div id="null-processing">
  ## Procesamiento de NULL
</div>

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`.

<div id="constancy">
  ## Constancia
</div>

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.

<div id="higher-order-functions">
  ## Funciones de orden superior
</div>

<div id="arrow-operator-and-lambda">
  ### Operador `->` y funciones lambda(params, expr)
</div>

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:

```python theme={null}
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.

<div id="bare-function-names-as-lambdas">
  ### Nombres de funciones sin más como lambdas
</div>

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:

```sql theme={null}
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.

<div id="user-defined-functions-udfs">
  ## Funciones definidas por el usuario (UDFs)
</div>

ClickHouse admite funciones definidas por el usuario. Consulte [UDFs](/es/reference/functions/regular-functions/udf).