`](/es/reference/settings/server-settings/settings#macros) del archivo de configuración y pueden utilizarse para distinguir servidores mediante nombres fáciles de identificar, incluso si tienen nombres de host complejos.
Si la función se ejecuta en el contexto de una tabla distribuida, genera una columna normal con valores correspondientes a cada segmento.
**Sintaxis**
```sql theme={null}
getMacro(name)
```
**Argumentos**
* `name` — El nombre de la macro que se va a obtener. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor de la macro especificada. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT getMacro('test');
```
```response title=Response theme={null}
┌─getMacro('test')─┐
│ Value │
└──────────────────┘
```
## getMaxTableNameLengthForDatabase
Introducido en: v25.1.0
Devuelve la longitud máxima del nombre de una tabla en la base de datos especificada.
**Sintaxis**
```sql theme={null}
getMaxTableNameLengthForDatabase(database_name)
```
**Argumentos**
* `database_name` — El nombre de la base de datos especificada. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la longitud del nombre de tabla más largo, un entero
**Ejemplos**
**típico**
```sql title=Query theme={null}
SELECT getMaxTableNameLengthForDatabase('default');
```
```response title=Response theme={null}
┌─getMaxTableNameLengthForDatabase('default')─┐
│ 206 │
└─────────────────────────────────────────────┘
```
## getMergeTreeSetting
Introducido en: v25.6.0
Devuelve el valor actual de un SETTING de MergeTree.
**Sintaxis**
```sql theme={null}
getMergeTreeSetting(setting_name)
```
**Argumentos**
* `setting_name` — El nombre del SETTING. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor actual del SETTING de MergeTree.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getMergeTreeSetting('index_granularity');
```
```response title=Response theme={null}
┌─getMergeTreeSetting('index_granularity')─┐
│ 8192 │
└──────────────────────────────────────────┘
```
## getOSKernelVersion
Introducido en: v21.11.0
Devuelve una cadena con la versión del kernel del sistema operativo.
**Sintaxis**
```sql theme={null}
getOSKernelVersion()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la versión actual del kernel del sistema operativo. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getOSKernelVersion();
```
```response title=Response theme={null}
┌─getOSKernelVersion()────┐
│ Linux 4.15.0-55-generic │
└─────────────────────────┘
```
## getServerPort
Introducido en: v21.10.0
Devuelve el número de puerto del servidor para un protocolo dado.
**Sintaxis**
```sql theme={null}
getServerPort(port_name)
```
**Argumentos**
* `port_name` — Nombre del puerto. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de puerto del servidor. [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getServerPort('tcp_port');
```
```response title=Response theme={null}
┌─getServerPort('tcp_port')─┐
│ 9000 │
└───────────────────────────┘
```
## getServerSetting
Introducido en: v25.6.0
Devuelve el valor establecido actualmente a partir del nombre de un SETTING del servidor.
**Sintaxis**
```sql theme={null}
getServerSetting(setting_name')
```
**Argumentos**
* `setting_name` — El nombre del SETTING del servidor. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor actual del SETTING del servidor. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getServerSetting('allow_use_jemalloc_memory');
```
```response title=Response theme={null}
┌─getServerSetting('allow_use_jemalloc_memory')─┐
│ true │
└───────────────────────────────────────────────┘
```
## getSetting
Introducido en: v20.7.0
Devuelve el valor actual de un SETTING.
**Sintaxis**
```sql theme={null}
getSetting(setting_name)
```
**Argumentos**
* `setting_Name` — El nombre del SETTING. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor actual del SETTING. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getSetting('enable_analyzer');
SET enable_analyzer = false;
SELECT getSetting('enable_analyzer');
```
```response title=Response theme={null}
┌─getSetting('⋯_analyzer')─┐
│ true │
└──────────────────────────┘
┌─getSetting('⋯_analyzer')─┐
│ false │
└──────────────────────────┘
```
## getSettingOrDefault
Introducido en: v24.10.0
Devuelve el valor actual de un SETTING, o el valor predeterminado especificado en el segundo argumento si el SETTING no está definido en el perfil actual.
**Sintaxis**
```sql theme={null}
getSettingOrDefault(setting_name, default_value)
```
**Argumentos**
* `setting_name` — El nombre del SETTING. [`String`](/es/reference/data-types/string)
* `default_value` — Valor que se devolverá si no se ha establecido custom\_setting. El valor puede ser de cualquier tipo de dato o NULL.
**Valor devuelto**
Devuelve el valor actual del SETTING especificado o `default_value` si el SETTING no se ha establecido.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getSettingOrDefault('custom_undef1', 'my_value');
SELECT getSettingOrDefault('custom_undef2', 100);
SELECT getSettingOrDefault('custom_undef3', NULL);
```
```response title=Response theme={null}
my_value
100
NULL
```
## getSizeOfEnumType
Introducido en: v1.1.0
Devuelve el número de campos del [`Enum`](/es/reference/data-types/enum) proporcionado.
**Sintaxis**
```sql theme={null}
getSizeOfEnumType(x)
```
**Argumentos**
* `x` — Valor de tipo `Enum`. [`Enum`](/es/reference/data-types/enum)
**Valor devuelto**
Devuelve el número de campos con valores de entrada de tipo `Enum`. [`UInt8/16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT getSizeOfEnumType(CAST('a' AS Enum8('a' = 1, 'b' = 2))) AS x;
```
```response title=Response theme={null}
┌─x─┐
│ 2 │
└───┘
```
## getSubcolumn
Introducido en: v23.3.0
Recibe una expresión o un identificador, y una cadena constante con el nombre de la subcolumna.
Devuelve la subcolumna solicitada extraída de la expresión.
**Sintaxis**
```sql theme={null}
getSubcolumn(nested_value, subcolumn_name)
```
**Argumentos**
* Ninguno.
**Valor devuelto**
**Ejemplos**
**getSubcolumn**
```sql title=Query theme={null}
SELECT getSubcolumn(array_col, 'size0'), getSubcolumn(tuple_col, 'elem_name')
```
```response title=Response theme={null}
```
## getTypeSerializationStreams
Introducido en: v22.6.0
Enumera las rutas de los streams de serialización de un tipo de dato.
Esta función está pensada para fines de desarrollo.
**Sintaxis**
```sql theme={null}
getTypeSerializationStreams(col)
```
**Argumentos**
* `col` — Columna o representación en cadena de un tipo de dato a partir de la cual se detectará el tipo de dato. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve un array con todas las rutas de los subflujos de serialización. [`Array(String)`](/es/reference/data-types/array)
**Ejemplos**
**tupla**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams(tuple('a', 1, 'b', 2))
```
```response title=Response theme={null}
['{TupleElement(1), Regular}','{TupleElement(2), Regular}','{TupleElement(3), Regular}','{TupleElement(4), Regular}']
```
**map**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams('Map(String, Int64)')
```
```response title=Response theme={null}
['{ArraySizes}','{ArrayElements, TupleElement(keys), Regular}','{ArrayElements, TupleElement(values), Regular}']
```
## globalVariable
Introducido en: v20.5.0
Toma un argumento de tipo cadena constante y devuelve el valor de la variable global con ese nombre. Esta función está pensada para mantener la compatibilidad con MySQL y no es necesaria ni útil para el funcionamiento normal de ClickHouse. Solo hay definidas unas pocas variables globales ficticias.
**Sintaxis**
```sql theme={null}
globalVariable(name)
```
**Argumentos**
* `name` — Nombre de la variable global. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el valor de la variable `name`. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**globalVariable**
```sql title=Query theme={null}
SELECT globalVariable('max_allowed_packet')
```
```response title=Response theme={null}
67108864
```
## hasColumnInTable
Introducido en: v1.1.0
Comprueba si una columna específica existe en una tabla de una base de datos.
En el caso de los elementos de una estructura de datos anidada, la función comprueba si existe una columna.
En el caso de la propia estructura de datos anidada, la función devuelve `0`.
**Sintaxis**
```sql theme={null}
hasColumnInTable([hostname[, username[, password]],]database, table, column)
```
**Argumentos**
* `database` — Nombre de la base de datos. [`const String`](/es/reference/data-types/string)
* `table` — Nombre de la tabla. [`const String`](/es/reference/data-types/string)
* `column` — Nombre de la columna. [`const String`](/es/reference/data-types/string)
* `hostname` — Opcional. Nombre del servidor remoto en el que realizar la comprobación. [`const String`](/es/reference/data-types/string)
* `username` — Opcional. Nombre de usuario del servidor remoto. [`const String`](/es/reference/data-types/string)
* `password` — Opcional. Contraseña del servidor remoto. [`const String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve `1` si la columna indicada existe; en caso contrario, `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Comprobar si existe una columna**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','metric')
```
```response title=Response theme={null}
1
```
**Comprobar una columna que no existe**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','non-existing_column')
```
```response title=Response theme={null}
0
```
## hasThreadFuzzer
Introducido en: v20.6.0
Devuelve si el thread fuzzer está habilitado.
Esta función solo es útil para pruebas y depuración.
**Sintaxis**
```sql theme={null}
hasThreadFuzzer()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Indica si Thread Fuzzer está activo. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Comprobar el estado de Thread Fuzzer**
```sql title=Query theme={null}
SELECT hasThreadFuzzer()
```
```response title=Response theme={null}
┌─hasThreadFuzzer()─┐
│ 0 │
└───────────────────┘
```
## highlightQuery
Introducido en: v26.5.0
Analiza una cadena con una consulta de ClickHouse SQL y devuelve un array de rangos destacados para el resaltado de sintaxis.
Cada rango es una tupla con nombre con la posición inicial (en bytes), la posición final y el tipo de resaltado.
Los tipos de resaltado describen el papel sintáctico del fragmento (palabra clave, identificador, función, etc.)
y pueden usarse para asignar colores en una UI. Dentro de los patrones de cadena de LIKE y REGEXP, los metacaracteres
y los caracteres de escape se resaltan por separado.
**Sintaxis**
```sql theme={null}
highlightQuery(query)
```
**Argumentos**
* `query` — Una cadena de consulta de ClickHouse SQL. String.
**Valor devuelto**
Un array de tuplas con nombre `(begin UInt64, end UInt64, type Enum8(...))` que representa rangos resaltados. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/es/reference/data-types/array)
**Ejemplos**
**simple**
```sql title=Query theme={null}
SELECT highlightQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'keyword'),(7,8,'number')]
```
## hostName
Introducido en: v20.5.0
Devuelve el nombre del host en el que se ejecutó esta función.
Si la función se ejecuta en un servidor remoto (procesamiento distribuido), se devuelve el nombre de ese servidor.
Si la función se ejecuta en el contexto de una tabla distribuida, genera una columna normal con valores correspondientes a cada segmento.
De lo contrario, produce un valor constante.
**Sintaxis**
```sql theme={null}
hostName()
```
**Alias**: `hostname`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el nombre del host. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT hostName()
```
```response title=Response theme={null}
┌─hostName()─┐
│ clickhouse │
└────────────┘
```
## icebergBucket
Introducido en: v25.5.0
Implementa la lógica de la [transformación bucket de Iceberg](https://iceberg.apache.org/spec/#bucket-transform-details.)
**Sintaxis**
```sql theme={null}
icebergBucket(N, value)
```
**Argumentos**
* `N` — El número de buckets; módulo. [`const (U)Int*`](/es/reference/data-types/int-uint)
* `value` — El valor de entrada que se va a transformar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Bool`](/es/reference/data-types/boolean) o [`Decimal`](/es/reference/data-types/decimal) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string) o [`FixedString`](/es/reference/data-types/fixedstring) o [`UUID`](/es/reference/data-types/uuid) o [`Date`](/es/reference/data-types/date) o [`Time`](/es/reference/data-types/time) o [`DateTime`](/es/reference/data-types/datetime)
**Valor devuelto**
Devuelve un hash de 32 bits del valor de entrada. [`Int32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT icebergBucket(5, 1.0 :: Float32)
```
```response title=Response theme={null}
4
```
## icebergTruncate
Introducido en: v25.3.0
Implementa la lógica de la transformación `truncate` de Iceberg: [https://iceberg.apache.org/spec/#truncate-transform-details](https://iceberg.apache.org/spec/#truncate-transform-details).
**Sintaxis**
```sql theme={null}
icebergTruncate(N, value)
```
**Argumentos**
* `value` — El valor que se va a transformar. [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
El mismo tipo que el del argumento
**Ejemplos**
**Ejemplo**
```sql title=Query theme={null}
SELECT icebergTruncate(3, 'iceberg')
```
```response title=Response theme={null}
ice
```
## identity
Introducido en: v1.1.0
Esta función devuelve el argumento que se le pasa, lo que resulta útil para la depuración y las pruebas. Permite omitir el uso de índices para ver, en su lugar, el rendimiento de un escaneo completo. El analizador de consultas ignora todo lo que haya dentro de las funciones identity al buscar índices que usar, y también desactiva el plegado de constantes.
**Sintaxis**
```sql theme={null}
identity(x)
```
**Argumentos**
* `x` — Valor de entrada. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el valor de entrada sin modificar. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT identity(42)
```
```response title=Response theme={null}
42
```
## ignore
Introducido en: v1.1.0
Acepta cualquier argumento y siempre devuelve `0`.
**Sintaxis**
```sql theme={null}
ignore(x)
```
**Argumentos**
* `x` — Un valor de entrada que no se utiliza y se pasa únicamente para evitar un error de sintaxis. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Siempre devuelve `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT ignore(0, 'ClickHouse', NULL)
```
```response title=Response theme={null}
┌─ignore(0, 'ClickHouse', NULL)─┐
│ 0 │
└───────────────────────────────┘
```
## indexHint
Introducido en: v1.1.0
Esta función está pensada para depuración e introspección.
Ignora su argumento y siempre devuelve 1.
Los argumentos no se evalúan.
Durante el análisis del índice, se asume que el argumento de esta función no está envuelto en `indexHint`.
Esto le permite seleccionar datos en rangos del índice mediante la condición correspondiente, pero sin aplicar después un filtrado por esa condición.
El índice de ClickHouse es disperso, y usar `indexHint` devolverá más datos que especificar directamente la misma condición.
Cuando ejecuta:
```sql theme={null}
SELECT * FROM test WHERE key = 123;
```
ClickHouse hace dos cosas:
1. Usa el índice para encontrar qué gránulos (bloques de \~8192 filas) podrían contener `key = 123`
2. Lee esos gránulos y los filtra fila por fila para devolver solo las filas donde `key = 123`
Así que, aunque lea 8192 filas del disco, solo devuelve la única fila que realmente coincide.
Con `indexHint`, cuando ejecuta:
```sql theme={null}
SELECT * FROM test WHERE indexHint(key = 123);
```
ClickHouse hace solo una cosa:
1. Usa el índice para encontrar qué gránulos podrían contener `key = 123` y devuelve todas las filas de esos gránulos **sin** filtrarlas.
Devuelve las 8192 filas, incluidas las filas donde `key = 456`, `key = 789`, etc. (Todo lo que haya quedado almacenado en el mismo gránulo).
`indexHint()` no sirve para mejorar el rendimiento. Sirve para depurar y entender cómo funciona el índice de ClickHouse:
* ¿Qué gránulos selecciona mi condición?
* ¿Cuántas filas hay en esos gránulos?
* ¿Se está usando mi índice de forma eficaz?
Nota: No es posible optimizar una consulta con la función `indexHint`. La función `indexHint` no optimiza la consulta, ya que no proporciona ninguna información adicional para el análisis de la consulta. Tener una expresión dentro de la función `indexHint` no es en modo alguno mejor que no usar la función `indexHint`. La función `indexHint` solo puede usarse con fines de introspección y depuración, y no mejora el rendimiento. Si ve que alguien que no sea colaborador de ClickHouse usa `indexHint`, probablemente sea un error y debería eliminarlo.
**Sintaxis**
```sql theme={null}
indexHint(expression)
```
**Argumentos**
* `expression` — Cualquier expresión para la selección del rango del índice. [`Expression`](/es/reference/data-types/special-data-types/expression)
**Valor devuelto**
Devuelve `1` en todos los casos. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso con filtro por fecha**
```sql title=Query theme={null}
SELECT FlightDate AS k, count() FROM ontime WHERE indexHint(k = '2025-09-15') GROUP BY k ORDER BY k ASC;
```
```response title=Response theme={null}
┌──────────k─┬─count()─┐
│ 2025-09-14 │ 7071 │
│ 2025-09-15 │ 16428 │
│ 2025-09-16 │ 1077 │
│ 2025-09-30 │ 8167 │
└────────────┴─────────┘
```
## initialQueryID
Introducido en: v1.1.0
Devuelve el ID de la consulta inicial de la consulta actual.
Otros parámetros de una consulta pueden extraerse del campo `initial_query_id` en [`system.query_log`](/es/reference/system-tables/query_log).
A diferencia de la función [`queryID`](/es/reference/functions/regular-functions/other-functions#queryID), `initialQueryID` devuelve los mismos resultados en diferentes segmentos.
**Sintaxis**
```sql theme={null}
initialQueryID()
```
**Aliases**: `initial_query_id`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el ID de la consulta inicial asociada a la consulta actual. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initialQueryStartTime
Introducido en: v25.4.0
Devuelve la hora de inicio de la consulta actual original.
`initialQueryStartTime` devuelve los mismos resultados en diferentes segmentos.
**Sintaxis**
```sql theme={null}
initialQueryStartTime()
```
**Alias**: `initial_query_start_time`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la hora de inicio de la consulta inicial de la consulta actual. [`DateTime`](/es/reference/data-types/datetime)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryStartTime() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initializeAggregation
Introducido en: v20.6.0
Calcula el resultado de una función de agregación a partir de un único valor.
Esta función puede utilizarse para inicializar funciones de agregación con el combinador [-State](/es/reference/functions/aggregate-functions/combinators#-state).
Puede crear estados de funciones de agregación e insertarlos en columnas de tipo [`AggregateFunction`](/es/reference/data-types/aggregatefunction), o usar agregados inicializados como valores por defecto.
**Sintaxis**
```sql theme={null}
initializeAggregation(aggregate_function, arg1[, arg2, ...])
```
**Argumentos**
* `aggregate_function` — Nombre de la función de agregación que se va a inicializar. [`String`](/es/reference/data-types/string)
* `arg1[, arg2, ...]` — Argumentos de la función de agregación. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el resultado de la agregación para cada fila que se pasa a la función. El tipo de retorno es el mismo que el de la función que `initializeAggregation` recibe como primer argumento. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Uso básico con uniqState**
```sql title=Query theme={null}
SELECT uniqMerge(state) FROM (SELECT initializeAggregation('uniqState', number % 3) AS state FROM numbers(10000));
```
```response title=Response theme={null}
┌─uniqMerge(state)─┐
│ 3 │
└──────────────────┘
```
**Uso de sumState y finalizeAggregation**
```sql title=Query theme={null}
SELECT finalizeAggregation(state), toTypeName(state) FROM (SELECT initializeAggregation('sumState', number % 3) AS state FROM numbers(5));
```
```response title=Response theme={null}
┌─finalizeAggregation(state)─┬─toTypeName(state)─────────────┐
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
│ 2 │ AggregateFunction(sum, UInt8) │
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
└────────────────────────────┴───────────────────────────────┘
```
## isConstant
Introducido en: v20.3.0
Indica si el argumento es una expresión constante.
Una expresión constante es una expresión cuyo resultado se conoce durante el análisis de la consulta, es decir, antes de la ejecución.
Por ejemplo, las expresiones sobre [literales](/es/reference/syntax#literals) son expresiones constantes.
Esta función está pensada principalmente para desarrollo, depuración y demostración.
**Sintaxis**
```sql theme={null}
isConstant(x)
```
**Argumentos**
* `x` — Una expresión que se debe comprobar. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve `1` si `x` es constante y `0` si `x` no es constante. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Expresión constante**
```sql title=Query theme={null}
SELECT isConstant(x + 1)
FROM (SELECT 43 AS x)
```
```response title=Response theme={null}
┌─isConstant(plus(x, 1))─┐
│ 1 │
└────────────────────────┘
```
**Constante con una función**
```sql title=Query theme={null}
WITH 3.14 AS pi
SELECT isConstant(cos(pi))
```
```response title=Response theme={null}
┌─isConstant(cos(pi))─┐
│ 1 │
└─────────────────────┘
```
**Expresión no constante**
```sql title=Query theme={null}
SELECT isConstant(number)
FROM numbers(1)
```
```response title=Response theme={null}
┌─isConstant(number)─┐
│ 0 │
└────────────────────┘
```
**Comportamiento de la función now()**
```sql title=Query theme={null}
SELECT isConstant(now())
```
```response title=Response theme={null}
┌─isConstant(now())─┐
│ 1 │
└───────────────────┘
```
## isDecimalOverflow
Introducido en: v20.8.0
Comprueba si un número decimal tiene demasiados dígitos para caber correctamente en un tipo de dato Decimal con la precisión indicada.
**Sintaxis**
```sql theme={null}
isDecimalOverflow(value[, precision])
```
**Argumentos**
* `value` — Valor `Decimal` que se va a comprobar. [`Decimal`](/es/reference/data-types/decimal)
* `precision` — Opcional. La precisión del tipo `Decimal`. Si se omite, se usa la precisión inicial del primer argumento. [`UInt8`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve `1` si el valor decimal tiene más dígitos de los permitidos por su precisión, y `0` si el valor decimal cumple la precisión especificada. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT isDecimalOverflow(toDecimal32(1000000000, 0), 9),
isDecimalOverflow(toDecimal32(1000000000, 0)),
isDecimalOverflow(toDecimal32(-1000000000, 0), 9),
isDecimalOverflow(toDecimal32(-1000000000, 0));
```
```response title=Response theme={null}
┌─isDecimalOverflow(toDecimal32(1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(1000000000, 0))─┬─isDecimalOverflow(toDecimal32(-1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(-1000000000, 0))─┐
│ 1 │ 1 │ 1 │ 1 │
└──────────────────────────────────────────────────┴───────────────────────────────────────────────┴───────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## joinGet
Introducido en: v18.16.0
Permite extraer datos de una tabla de la misma manera que de un diccionario.
Obtiene datos de tablas Join usando la clave de join especificada.
Solo admite tablas creadas con la instrucción `ENGINE = Join(ANY, LEFT, )` [sentencia](/es/reference/engines/table-engines/special/join).
**Sintaxis**
```sql theme={null}
joinGet(join_storage_table_name, value_column, join_keys)
```
**Argumentos**
* `join_storage_table_name` — Un identificador que indica dónde realizar la búsqueda. El identificador se busca en la base de datos predeterminada (consulte el parámetro `default_database` en el archivo de configuración). Para anular la base de datos predeterminada, use la consulta `USE database_name` o especifique la base de datos y la tabla mediante un punto, como `database_name.table_name`. [`String`](/es/reference/data-types/string)
* `value_column` — El nombre de la columna de la tabla que contiene los datos necesarios. [`const String`](/es/reference/data-types/string)
* `join_keys` — Una lista de claves de join. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve una lista de valores correspondientes a la lista de claves. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGet(db_test.id_val, 'val', toUInt32(1));
```
```response title=Response theme={null}
┌─joinGet(db_test.id_val, 'val', toUInt32(1))─┐
│ 11 │
└─────────────────────────────────────────────┘
```
**Uso con una tabla de la base de datos actual**
```sql title=Query theme={null}
USE db_test;
SELECT joinGet(id_val, 'val', toUInt32(2));
```
```response title=Response theme={null}
┌─joinGet(id_val, 'val', toUInt32(2))─┐
│ 12 │
└─────────────────────────────────────┘
```
**Uso de arrays como claves de JOIN**
```sql title=Query theme={null}
CREATE TABLE some_table (id1 UInt32, id2 UInt32, name String) ENGINE = Join(ANY, LEFT, id1, id2);
INSERT INTO some_table VALUES (1, 11, 'a') (2, 12, 'b') (3, 13, 'c');
SELECT joinGet(some_table, 'name', 1, 11);
```
```response title=Response theme={null}
┌─joinGet(some_table, 'name', 1, 11)─┐
│ a │
└────────────────────────────────────┘
```
## joinGetOrNull
Introducido en: v20.4.0
Permite extraer datos de una tabla de la misma forma que de un diccionario.
Obtiene datos de tablas Join mediante la clave de join especificada.
A diferencia de [`joinGet`](#joinGet), devuelve `NULL` cuando la clave no existe.
Solo admite tablas creadas con la `ENGINE = Join(ANY, LEFT, )` [sentencia](/es/reference/engines/table-engines/special/join).
**Sintaxis**
```sql theme={null}
joinGetOrNull(join_storage_table_name, value_column, join_keys)
```
**Argumentos**
* `join_storage_table_name` — Un identificador que indica dónde realizar la búsqueda. El identificador se busca en la base de datos predeterminada (consulte el parámetro default\_database en el archivo de configuración). Para usar otra base de datos distinta de la predeterminada, utilice la consulta `USE database_name` o especifique la base de datos y la tabla separadas por un punto, como en `database_name.table_name`. [`String`](/es/reference/data-types/string)
* `value_column` — El nombre de la columna de la tabla que contiene los datos necesarios. [`const String`](/es/reference/data-types/string)
* `join_keys` — Una lista de claves de join. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve una lista de valores correspondientes a la lista de claves, o `NULL` si no se encuentra una clave. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGetOrNull(db_test.id_val, 'val', toUInt32(1)), joinGetOrNull(db_test.id_val, 'val', toUInt32(999));
```
```response title=Response theme={null}
┌─joinGetOrNull(db_test.id_val, 'val', toUInt32(1))─┬─joinGetOrNull(db_test.id_val, 'val', toUInt32(999))─┐
│ 11 │ ᴺᵁᴸᴸ │
└───────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘
```
## lowCardinalityIndices
Introducido en: v18.12.0
Devuelve la posición de un valor en el diccionario de una columna [LowCardinality](/es/reference/data-types/lowcardinality). Las posiciones empiezan en 1. Como LowCardinality tiene diccionarios por cada parte, esta función puede devolver posiciones distintas para el mismo valor en diferentes partes.
**Sintaxis**
```sql theme={null}
lowCardinalityIndices(col)
```
**Argumentos**
* `col` — Una columna de baja cardinalidad. [`LowCardinality`](/es/reference/data-types/lowcardinality)
**Valor devuelto**
La posición del valor en el diccionario de la parte actual. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplos de uso**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- crear dos partes:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityIndices(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityIndices(s)─┐
│ ab │ 1 │
│ cd │ 2 │
│ ab │ 1 │
│ ab │ 1 │
│ df │ 3 │
└────┴──────────────────────────┘
┌─s──┬─lowCardinalityIndices(s)─┐
│ ef │ 1 │
│ cd │ 2 │
│ ab │ 3 │
│ cd │ 2 │
│ ef │ 1 │
└────┴──────────────────────────┘
```
## lowCardinalityKeys
Introducido en: v18.12.0
Devuelve los valores del diccionario de una columna [LowCardinality](/es/reference/data-types/lowcardinality).
Si el bloque es más pequeño o más grande que el tamaño del diccionario, el resultado se truncará o se completará con valores predeterminados.
Dado que LowCardinality tiene diccionarios por parte, esta función puede devolver valores de diccionario diferentes en distintas partes.
**Sintaxis**
```sql theme={null}
lowCardinalityKeys(col)
```
**Argumentos**
* `col` — Una columna de baja cardinalidad. [`LowCardinality`](/es/reference/data-types/lowcardinality)
**Valor devuelto**
Devuelve las claves del diccionario. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**lowCardinalityKeys**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- crear dos partes:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityKeys(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityKeys(s)─┐
│ ef │ │
│ cd │ ef │
│ ab │ cd │
│ cd │ ab │
│ ef │ │
└────┴───────────────────────┘
┌─s──┬─lowCardinalityKeys(s)─┐
│ ab │ │
│ cd │ ab │
│ ab │ cd │
│ ab │ df │
│ df │ │
└────┴───────────────────────┘
```
## materialize
Introducido en: v1.1.0
Convierte una constante en una columna completa que contiene un solo valor.
Las columnas completas y las constantes se representan de forma diferente en memoria.
Las funciones suelen ejecutar código diferente para los argumentos normales y los constantes, aunque por lo general el resultado debería ser el mismo.
Esta función puede utilizarse para depurar este comportamiento.
**Sintaxis**
```sql theme={null}
materialize(x)
```
**Argumentos**
* `x` — Una constante. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve una columna completa con el valor constante. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
-- In the example below the `countMatches` function expects a constant second argument.
-- This behaviour can be debugged by using the `materialize` function to turn a constant into a full column,
-- verifying that the function throws an error for a non-constant argument.
SELECT countMatches('foobarfoo', 'foo');
SELECT countMatches('foobarfoo', materialize('foo'));
```
```response title=Response theme={null}
2
Code: 44. DB::Exception: Received from localhost:9000. DB::Exception: Illegal type of argument #2 'pattern' of function countMatches, expected constant String, got String
```
## minSampleSizeContinuous
Introducido en: v23.10.0
Calcula el tamaño mínimo de muestra necesario para una prueba A/B que compara las medias de una métrica continua en dos muestras.
Usa la fórmula descrita en [este artículo](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a).
Asume tamaños iguales para los grupos de tratamiento y de control.
Devuelve el tamaño de muestra necesario para un grupo (es decir, el tamaño de muestra necesario para todo el experimento es el doble del valor devuelto).
También asume una varianza igual de la métrica evaluada en los grupos de tratamiento y de control.
**Sintaxis**
```sql theme={null}
minSampleSizeContinuous(baseline, sigma, mde, power, alpha)
```
**Alias**: `minSampleSizeContinous`
**Argumentos**
* `baseline` — Valor de referencia de una métrica. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `sigma` — Desviación estándar de referencia de una métrica. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `mde` — Efecto mínimo detectable (MDE) como porcentaje del valor de referencia (p. ej., para un valor de referencia de 112.25, un MDE de 0.03 significa un cambio esperado a 112.25 ± 112.25\*0.03). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `power` — Potencia estadística requerida de una prueba (1 - probabilidad de error de tipo II). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
* `alpha` — Nivel de significación requerido de una prueba (probabilidad de error de tipo I). [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve un Tuple con nombre con 3 elementos: `minimum_sample_size`, `detect_range_lower` y `detect_range_upper`. Estos corresponden, respectivamente, al tamaño de muestra requerido, al límite inferior del rango de valores no detectables con el tamaño de muestra requerido devuelto, calculado como `baseline * (1 - mde)`, y al límite superior del rango de valores no detectables con el tamaño de muestra requerido devuelto, calculado como `baseline * (1 + mde)` (Float64). [`Tuple(Float64, Float64, Float64)`](/es/reference/data-types/tuple)
**Ejemplos**
**minSampleSizeContinuous**
```sql title=Query theme={null}
SELECT minSampleSizeContinuous(112.25, 21.1, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(616.2931945826209,108.8825,115.6175)
```
## minSampleSizeConversion
Introducido en: v22.6.0
Calcula el tamaño mínimo de muestra necesario para una prueba A/B que compara conversiones (proporciones) en dos muestras.
Utiliza la fórmula descrita en [este artículo](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a). Asume tamaños iguales para los grupos de tratamiento y de control. Devuelve el tamaño de muestra necesario para un grupo (es decir, el tamaño de muestra necesario para todo el experimento es el doble del valor devuelto).
**Sintaxis**
```sql theme={null}
minSampleSizeConversion(baseline, mde, power, alpha)
```
**Argumentos**
* `baseline` — Tasa de conversión de referencia. [`Float*`](/es/reference/data-types/float)
* `mde` — Efecto mínimo detectable (MDE), en puntos porcentuales (p. ej., para una tasa de conversión de referencia de 0.25, un MDE de 0.03 significa un cambio esperado a 0.25 ± 0.03). [`Float*`](/es/reference/data-types/float)
* `power` — Potencia estadística requerida de una prueba (1 - probabilidad de error de tipo II). [`Float*`](/es/reference/data-types/float)
* `alpha` — Nivel de significación requerido de una prueba (probabilidad de error de tipo I). [`Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve un Tuple con nombre con 3 elementos: `minimum_sample_size`, `detect_range_lower`, `detect_range_upper`. Estos son, respectivamente: el tamaño de muestra requerido, el límite inferior del intervalo de valores no detectables con el tamaño de muestra requerido devuelto, calculado como `baseline - mde`, y el límite superior del intervalo de valores no detectables con el tamaño de muestra requerido devuelto, calculado como `baseline + mde`. [`Tuple(Float64, Float64, Float64)`](/es/reference/data-types/tuple)
**Ejemplos**
**minSampleSizeConversion**
```sql title=Query theme={null}
SELECT minSampleSizeConversion(0.25, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(3396.077603219163,0.22,0.28)
```
## neighbor
Introducido en: v20.1.0
Devuelve un valor de una columna con un desplazamiento especificado respecto de la fila actual.
Esta función está obsoleta y es propensa a errores porque opera sobre el orden físico de los bloques de datos, que puede no corresponderse con el orden lógico que esperan los usuarios.
Considere usar funciones de ventana adecuadas en su lugar.
La función puede habilitarse estableciendo `allow_deprecated_error_prone_window_functions = 1`.
**Sintaxis**
```sql theme={null}
neighbor(column, offset[, default_value])
```
**Argumentos**
* `column` — La columna de origen. [`Any`](/es/reference/data-types/index)
* `offset` — El desplazamiento con respecto a la fila actual. Los valores positivos avanzan y los valores negativos retroceden. [`Integer`](/es/reference/data-types/int-uint)
* `default_value` — Opcional. El valor que se devuelve si el desplazamiento queda fuera de los límites de los datos. Si no se especifica, se usa el valor predeterminado del tipo de columna. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve un valor en el desplazamiento especificado o el valor predeterminado si queda fuera de los límites. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 0 │
│ 9 │ 0 │
└────────┴─────────────────────┘
```
**Con valor predeterminado**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2, 999) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2, 999)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 999 │
│ 9 │ 999 │
└────────┴──────────────────────────┘
```
## normalizeQuery
Introducido en: v20.8.0
Sustituye los literales, las secuencias de literales y los alias complejos (que contienen espacios en blanco, más de dos dígitos o tienen una longitud de al menos 36 bytes, como los UUID) por el marcador de posición `?`.
**Sintaxis**
```sql theme={null}
normalizeQuery(x)
```
**Argumentos**
* `x` — Secuencia de caracteres. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la secuencia de caracteres proporcionada con marcadores de posición. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT normalizeQuery('[1, 2, 3, x]') AS query
```
```response title=Response theme={null}
┌─query────┐
│ [?.., x] │
└──────────┘
```
## normalizeQueryKeepNames
Introducido en: v21.2.0
Reemplaza los literales y las secuencias de literales por el marcador de posición `?`, pero no reemplaza los alias complejos (que contienen espacios en blanco, más de dos dígitos o tienen una longitud de al menos 36 bytes, como los UUID).
Esto ayuda a analizar mejor los logs de consultas complejas.
**Sintaxis**
```sql theme={null}
normalizeQueryKeepNames(x)
```
**Argumentos**
* `x` — Secuencia de caracteres. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve la secuencia de caracteres proporcionada con marcadores de posición. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT normalizeQuery('SELECT 1 AS aComplexName123'), normalizeQueryKeepNames('SELECT 1 AS aComplexName123')
```
```response title=Response theme={null}
┌─normalizeQuery('SELECT 1 AS aComplexName123')─┬─normalizeQueryKeepNames('SELECT 1 AS aComplexName123')─┐
│ SELECT ? AS `?` │ SELECT ? AS aComplexName123 │
└───────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
```
## normalizedQueryHash
Introducido en: v20.8.0
Devuelve valores hash idénticos de 64 bits para consultas similares, sin tener en cuenta los valores de los literales.
Puede ser útil para analizar los logs de consultas.
**Sintaxis**
```sql theme={null}
normalizedQueryHash(x)
```
**Argumentos**
* `x` — Secuencia de caracteres. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor hash de 64 bits. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res
```
```response title=Response theme={null}
┌─res─┐
│ 1 │
└─────┘
```
## normalizedQueryHashKeepNames
Introducido en la versión v21.2.0
Al igual que [`normalizedQueryHash`](#normalizedQueryHash), devuelve valores hash idénticos de 64 bits para consultas similares sin incluir los valores de los literales, pero no reemplaza los alias complejos (que contienen espacios en blanco, más de dos dígitos o tienen una longitud mínima de 36 bytes, como los UUID) por un marcador de posición antes de calcular el hash.
Puede ser útil para analizar el log de consulta.
**Sintaxis**
```sql theme={null}
normalizedQueryHashKeepNames(x)
```
**Argumentos**
* `x` — Secuencia de caracteres. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve un valor hash de 64 bits. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz123`') != normalizedQueryHash('SELECT 1 AS `abc123`') AS normalizedQueryHash;
SELECT normalizedQueryHashKeepNames('SELECT 1 AS `xyz123`') != normalizedQueryHashKeepNames('SELECT 1 AS `abc123`') AS normalizedQueryHashKeepNames;
```
```response title=Response theme={null}
┌─normalizedQueryHash─┐
│ 0 │
└─────────────────────┘
┌─normalizedQueryHashKeepNames─┐
│ 1 │
└──────────────────────────────┘
```
## obfuscateQuery
Introducido en: v26.4.0
Ofusca una consulta SQL sustituyendo los identificadores por palabras aleatorias y los literales por valores aleatorios, a la vez que conserva la estructura de la consulta.
Esta función es útil para anonimizar consultas antes de registrarlas o compartirlas con fines de depuración.
Distintas filas producirán resultados ofuscados diferentes incluso para la misma consulta de entrada, lo que ayuda
a mantener la privacidad al trabajar con múltiples consultas.
El parámetro opcional `tag` evita la eliminación de subexpresiones comunes cuando la misma llamada a la función
se usa varias veces en una consulta. Esto garantiza que cada invocación produzca un resultado ofuscado diferente.
Características:
* Sustituye los nombres de tabla, los nombres de columna y los alias por palabras aleatorias
* Sustituye los literales numéricos y de texto por valores aleatorios
* Conserva la estructura general de la consulta y la sintaxis SQL
* Produce resultados diferentes para distintas filas
**Sintaxis**
```sql theme={null}
obfuscateQuery(query[, tag])
```
**Argumentos**
* `query` — La consulta SQL que se va a ofuscar. [`String`](/es/reference/data-types/string)
* `tag` — Opcional. Un valor para evitar la eliminación de subexpresiones comunes cuando la misma llamada a función se utiliza varias veces.
**Valor devuelto**
La consulta ofuscada, con los identificadores y literales reemplazados, conservando la estructura original de la consulta. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Uso básico**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT name, age FROM users WHERE age > 30')
```
```response title=Response theme={null}
SELECT fruit, number FROM table WHERE number > 12
```
**Con una etiqueta para evitar la eliminación de subexpresiones comunes**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT * FROM t', 1), obfuscateQuery('SELECT * FROM t', 2)
```
```response title=Response theme={null}
SELECT a FROM b, SELECT c FROM d
```
**Filas distintas producen resultados diferentes**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT 1') AS a, obfuscateQuery('SELECT 1') AS b
```
```response title=Response theme={null}
A B
```
## obfuscateQueryWithSeed
Introducido en: v26.4.0
Ofusca una consulta SQL usando una semilla específica para obtener resultados deterministas.
A diferencia de `obfuscateQuery()`, esta función produce resultados deterministas cuando se le proporciona la misma semilla.
Esto resulta útil cuando necesitas una ofuscación coherente en varias ejecuciones o cuando quieres
reproducir la misma consulta ofuscada para fines de prueba o depuración.
Características:
* Ofuscación determinista basada en la semilla proporcionada
* La misma semilla siempre produce el mismo resultado ofuscado
* Semillas diferentes producen resultados diferentes
* Conserva la estructura de la consulta, igual que obfuscateQuery()
Casos de uso:
* Casos de prueba reproducibles
* Anonimización coherente en varias ejecuciones
* Depuración con consultas ofuscadas coherentes
**Sintaxis**
```sql theme={null}
obfuscateQueryWithSeed(query, seed)
```
**Argumentos**
* `query` — La consulta SQL que se va a ofuscar. [`String`](/es/reference/data-types/string)
* `seed` — La semilla de la ofuscación. La misma semilla produce resultados deterministas. [`Integer`](/es/reference/data-types/int-uint) o [`String`](/es/reference/data-types/string)
**Valor devuelto**
La consulta ofuscada, generada de forma determinista a partir de la semilla proporcionada. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ofuscación determinista con una semilla entera**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT name FROM users', 42)
```
```response title=Response theme={null}
SELECT fruit FROM table
```
**Ofuscación determinista con una semilla de texto**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT id, value FROM data', 'myseed')
```
```response title=Response theme={null}
SELECT a, b FROM c
```
**La misma semilla da el mismo resultado**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT 1', 100) = obfuscateQueryWithSeed('SELECT 1', 100)
```
```response title=Response theme={null}
true
```
## parseReadableSize
Introducido en: v24.6.0
Dada una cadena que contiene un tamaño en bytes y `B`, `KiB`, `KB`, `MiB`, `MB`, etc. como unidad (es decir, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) o una unidad decimal de bytes), esta función devuelve el número de bytes correspondiente.
Si la función no puede interpretar el valor de entrada, lanza una excepción.
Las operaciones inversas de esta función son [`formatReadableSize`](#formatReadableSize) y [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxis**
```sql theme={null}
parseReadableSize(x)
```
**Argumentos**
* `x` — Tamaño legible con una unidad de bytes ISO/IEC 80000-13 o decimal. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de bytes, redondeado hacia arriba al entero más cercano. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB']) AS readable_sizes, parseReadableSize(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
└────────────────┴─────────┘
```
## parseReadableSizeOrNull
Introducido en: v24.6.0
Dada una cadena que contiene un tamaño de bytes y `B`, `KiB`, `KB`, `MiB`, `MB`, etc. como unidad (es decir, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) o una unidad decimal de bytes), esta función devuelve el número de bytes correspondiente.
Si la función no puede interpretar el valor de entrada, devuelve `NULL`.
Las operaciones inversas de esta función son [`formatReadableSize`](#formatReadableSize) y [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxis**
```sql theme={null}
parseReadableSizeOrNull(x)
```
**Argumentos**
* `x` — Tamaño en formato legible con una unidad de bytes ISO/IEC 80000-13 o decimal. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de bytes, redondeado hacia arriba al entero más cercano, o `NULL` si no se puede interpretar la entrada [`Nullable(UInt64)`](/es/reference/data-types/nullable)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrNull(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ ᴺᵁᴸᴸ │
└────────────────┴─────────┘
```
## parseReadableSizeOrZero
Introducido en: v24.6.0
Dada una cadena que contiene un tamaño en bytes y `B`, `KiB`, `KB`, `MiB`, `MB`, etc. como unidad (es decir, [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) o una unidad decimal de bytes), esta función devuelve el número de bytes correspondiente.
Si la función no puede interpretar el valor de entrada, devuelve `0`.
Las operaciones inversas de esta función son [`formatReadableSize`](#formatReadableSize) y [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Sintaxis**
```sql theme={null}
parseReadableSizeOrZero(x)
```
**Argumentos**
* `x` — Tamaño legible con una unidad de bytes según ISO/IEC 80000-13 o decimal. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve el número de bytes, redondeado hacia arriba al entero más cercano, o `0` si no es posible analizar la entrada. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrZero(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ 0 │
└────────────────┴─────────┘
```
## parseTimeDelta
Introducido en: v22.7.0
Analiza una secuencia de números seguida de algo que se asemeja a una unidad de tiempo.
La cadena de intervalo de tiempo usa estas especificaciones de unidades de tiempo:
* `years`, `year`, `yr`, `y`
* `months`, `month`, `mo`
* `weeks`, `week`, `w`
* `days`, `day`, `d`
* `hours`, `hour`, `hr`, `h`
* `minutes`, `minute`, `min`, `m`
* `seconds`, `second`, `sec`, `s`
* `milliseconds`, `millisecond`, `millisec`, `ms`
* `microseconds`, `microsecond`, `microsec`, `μs`, `µs`, `us`
* `nanoseconds`, `nanosecond`, `nanosec`, `ns`
Se pueden combinar varias unidades de tiempo con separadores (espacio, `;`, `-`, `+`, `,`, `:`).
La duración de los años y los meses es aproximada: un año equivale a 365 días y un mes a 30.5 días.
**Sintaxis**
```sql theme={null}
parseTimeDelta(timestr)
```
**Argumentos**
* `timestr` — Una secuencia de números seguida de algo parecido a una unidad de tiempo. [`String`](/es/reference/data-types/string)
**Valor devuelto**
El número de segundos. [`Float64`](/es/reference/data-types/float)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT parseTimeDelta('11s+22min')
```
```response title=Response theme={null}
┌─parseTimeDelta('11s+22min')─┐
│ 1331 │
└─────────────────────────────┘
```
**Unidades de tiempo complejas**
```sql title=Query theme={null}
SELECT parseTimeDelta('1yr2mo')
```
```response title=Response theme={null}
┌─parseTimeDelta('1yr2mo')─┐
│ 36806400 │
└──────────────────────────┘
```
## partitionId
Introducido en: v21.4.0
Calcula el [ID de la partición](/es/reference/engines/table-engines/mergetree-family/custom-partitioning-key).
Esta función es lenta y no debe utilizarse con grandes cantidades de filas.
**Sintaxis**
```sql theme={null}
partitionId(column1[, column2, ...])
```
**Alias**: `partitionID`
**Argumentos**
* `column1, column2, ...` — Columna cuyo ID de partición se devuelve.
**Valor devuelto**
Devuelve el ID de partición al que pertenece la fila. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
DROP TABLE IF EXISTS tab;
CREATE TABLE tab
(
i int,
j int
)
ENGINE = MergeTree
PARTITION BY i
ORDER BY tuple();
INSERT INTO tab VALUES (1, 1), (1, 2), (1, 3), (2, 4), (2, 5), (2, 6);
SELECT i, j, partitionId(i), _partition_id FROM tab ORDER BY i, j;
```
```response title=Response theme={null}
┌─i─┬─j─┬─partitionId(i)─┬─_partition_id─┐
│ 1 │ 1 │ 1 │ 1 │
│ 1 │ 2 │ 1 │ 1 │
│ 1 │ 3 │ 1 │ 1 │
│ 2 │ 4 │ 2 │ 2 │
│ 2 │ 5 │ 2 │ 2 │
│ 2 │ 6 │ 2 │ 2 │
└───┴───┴────────────────┴───────────────┘
```
## queryID
Introducido en: v21.9.0
Devuelve el ID de la consulta actual.
Se pueden extraer otros parámetros de la consulta del campo `query_id` de la tabla [`system.query_log`](/es/reference/system-tables/query_log).
A diferencia de la función [`initialQueryID`](#initialQueryID), `queryID` puede devolver resultados diferentes en distintos segmentos.
**Sintaxis**
```sql theme={null}
queryID()
```
**Alias**: `query_id`
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el ID de la consulta actual. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT queryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 3 │
└───────────────────┘
```
## revision
Introducido en: v22.7.0
Devuelve la revisión actual del servidor de ClickHouse.
**Sintaxis**
```sql theme={null}
revision()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la revisión actual del servidor de ClickHouse. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT revision()
```
```response title=Response theme={null}
┌─revision()─┐
│ 54485 │
└────────────┘
```
## rowNumberInAllBlocks
Introducido en: v1.1.0
Devuelve un número de fila único para cada fila que se procesa.
**Sintaxis**
```sql theme={null}
rowNumberInAllBlocks()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el número ordinal de la fila en el bloque de datos, начиная desde `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT rowNumberInAllBlocks()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
)
SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInAllBlocks()─┐
│ 0 │
│ 1 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 4 │
│ 5 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 2 │
│ 3 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 6 │
│ 7 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 8 │
│ 9 │
└────────────────────────┘
```
## rowNumberInBlock
Introducido en: v1.1.0
Para cada [bloque](/es/resources/develop-contribute/introduction/architecture#block) procesado por `rowNumberInBlock`, devuelve el número de la fila actual.
El número devuelto comienza en 0 en cada bloque.
**Sintaxis**
```sql theme={null}
rowNumberInBlock()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el número ordinal de la fila del bloque de datos a partir de `0`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT rowNumberInBlock()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
) SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
```
## runningAccumulate
Introducido en: v1.1.0
Acumula los estados de una función de agregación para cada fila de un bloque de datos.
**Obsoleto**
El estado se restablece con cada nuevo bloque de datos.
Debido a este comportamiento propenso a errores, la función ha quedado obsoleta, y se recomienda usar [funciones de ventana](/es/reference/functions/window-functions/index) en su lugar.
Puede usar la configuración [`allow_deprecated_error_prone_window_functions`](/es/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) para permitir el uso de esta función.
**Sintaxis**
```sql theme={null}
runningAccumulate(agg_state[, grouping])
```
**Argumentos**
* `agg_state` — Estado de la función de agregación. [`AggregateFunction`](/es/reference/data-types/aggregatefunction)
* `grouping` — Opcional. Clave de agrupación. El estado de la función se restablece si cambia el valor de `grouping`. Puede ser cualquiera de los tipos de datos compatibles para los que esté definido el operador de igualdad. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el resultado acumulado para cada fila. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso con initializeAggregation**
```sql title=Query theme={null}
WITH initializeAggregation('sumState', number) AS one_row_sum_state
SELECT
number,
finalizeAggregation(one_row_sum_state) AS one_row_sum,
runningAccumulate(one_row_sum_state) AS cumulative_sum
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─one_row_sum─┬─cumulative_sum─┐
│ 0 │ 0 │ 0 │
│ 1 │ 1 │ 1 │
│ 2 │ 2 │ 3 │
│ 3 │ 3 │ 6 │
│ 4 │ 4 │ 10 │
└────────┴─────────────┴────────────────┘
```
## runningConcurrency
Introducido en: v21.3.0
Calcula el número de eventos concurrentes.
Cada evento tiene una hora de inicio y una hora de finalización.
La hora de inicio se incluye en el evento, mientras que la hora de finalización se excluye.
Las columnas con una hora de inicio y una hora de finalización deben tener el mismo tipo de dato.
La función calcula el número total de eventos activos (concurrentes) para cada hora de inicio de evento.
**Requisitos**
Los eventos deben estar ordenados por hora de inicio en orden ascendente.
Si no se cumple este requisito, la función genera una excepción.
Cada bloque de datos se procesa por separado.
Si los eventos de distintos bloques de datos se superponen, no se pueden procesar correctamente.
**Obsoleto**
Se recomienda usar [funciones de ventana](/es/reference/functions/window-functions/index) en su lugar.
**Sintaxis**
```sql theme={null}
runningConcurrency(start, end)
```
**Argumentos**
* `start` — Una columna con la hora de inicio de los eventos. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
* `end` — Una columna con la hora de finalización de los eventos. [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`DateTime64`](/es/reference/data-types/datetime64)
**Valor devuelto**
Devuelve el número de eventos concurrentes en cada hora de inicio de los eventos. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT start, runningConcurrency(start, end) FROM example_table;
```
```response title=Response theme={null}
┌──────start─┬─runningConcurrency(start, end)─┐
│ 2025-03-03 │ 1 │
│ 2025-03-06 │ 2 │
│ 2025-03-07 │ 3 │
│ 2025-03-11 │ 2 │
└────────────┴────────────────────────────────┘
```
## runningDifference
Introducido en: v1.1.0
Calcula la diferencia entre los valores de dos filas consecutivas en el bloque de datos.
Devuelve `0` para la primera fila y, para las siguientes, la diferencia con respecto a la fila anterior.
**Obsoleto**
Solo devuelve diferencias dentro del bloque de datos que se está procesando en ese momento.
Debido a este comportamiento propenso a errores, la función está obsoleta.
Se recomienda usar [funciones de ventana](/es/reference/functions/window-functions/index) en su lugar.
Puede usar la configuración [`allow_deprecated_error_prone_window_functions`](/es/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) para permitir el uso de esta función.
El resultado de la función depende de los bloques de datos procesados y del orden de los datos dentro del bloque.
El orden de las filas durante el cálculo de `runningDifference()` puede diferir del orden de las filas que se devuelven al usuario.
Para evitarlo, puede crear una subconsulta con [`ORDER BY`](/es/reference/statements/select/order-by) y llamar a la función fuera de la subconsulta.
Tenga en cuenta que el tamaño del bloque afecta al resultado.
El estado interno de `runningDifference` se restablece con cada bloque nuevo.
**Sintaxis**
```sql theme={null}
runningDifference(x)
```
**Argumentos**
* `x` — Columna para la que se calcula la diferencia entre valores consecutivos. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve la diferencia entre valores consecutivos, con 0 en la primera fila.
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
EventID,
EventTime,
runningDifference(EventTime) AS delta
FROM
(
SELECT
EventID,
EventTime
FROM events
WHERE EventDate = '2025-11-24'
ORDER BY EventTime ASC
LIMIT 5
);
```
```response title=Response theme={null}
┌─EventID─┬───────────EventTime─┬─delta─┐
│ 1106 │ 2025-11-24 00:00:04 │ 0 │
│ 1107 │ 2025-11-24 00:00:05 │ 1 │
│ 1108 │ 2025-11-24 00:00:05 │ 0 │
│ 1109 │ 2025-11-24 00:00:09 │ 4 │
│ 1110 │ 2025-11-24 00:00:10 │ 1 │
└─────────┴─────────────────────┴───────┘
```
**Ejemplo del impacto del tamaño de bloque**
```sql title=Query theme={null}
SELECT
number,
runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1;
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
└────────┴──────┘
┌─number─┬─diff─┐
│ 65536 │ 0 │
└────────┴──────┘
```
## runningDifferenceStartingWithFirstValue
Introducido en: v1.1.0
Calcula la diferencia entre los valores de filas consecutivas en un bloque de datos, pero, a diferencia de [`runningDifference`](#runningDifference), devuelve el valor real de la primera fila en lugar de `0`.
**Obsoleto**
Solo devuelve las diferencias dentro del bloque de datos que se está procesando en ese momento.
Debido a este comportamiento propenso a errores, la función está obsoleta.
Se recomienda usar [funciones de ventana](/es/reference/functions/window-functions/index) en su lugar.
Puede usar la configuración `allow_deprecated_error_prone_window_functions` para permitir el uso de esta función.
**Sintaxis**
```sql theme={null}
runningDifferenceStartingWithFirstValue(x)
```
**Argumentos**
* `x` — Columna para la que se calcula la diferencia acumulada. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve la diferencia entre valores consecutivos; para la primera fila, devuelve el valor de esa misma fila. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT
number,
runningDifferenceStartingWithFirstValue(number) AS diff
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 1 │
│ 3 │ 1 │
│ 4 │ 1 │
└────────┴──────┘
```
## serverUUID
Introducido en: v20.1.0
Devuelve el UUID (v4) aleatorio y único generado cuando el servidor se inicia por primera vez.
El UUID se almacena de forma persistente; es decir, en el segundo, tercer, etc. inicio del servidor se devuelve el mismo UUID.
**Sintaxis**
```sql theme={null}
serverUUID()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el UUID aleatorio del servidor. [`UUID`](/es/reference/data-types/uuid)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT serverUUID();
```
```response title=Response theme={null}
┌─serverUUID()─────────────────────────────┐
│ 7ccc9260-000d-4d5c-a843-5459abaabb5f │
└──────────────────────────────────────────┘
```
## shardCount
Introducido en: v21.9.0
Devuelve el número total de segmentos de una consulta distribuida.
Si la consulta no es distribuida, se devuelve el valor constante `0`.
**Sintaxis**
```sql theme={null}
shardCount()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el número total de segmentos o `0`. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
-- Consulta el ejemplo de shardNum() anterior, que también muestra shardCount()
CREATE TABLE shard_count_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT shardCount() FROM shard_count_example;
```
```response title=Response theme={null}
┌─shardCount()─┐
│ 2 │
│ 2 │
└──────────────┘
```
## shardNum
Introducido en: v21.9.0
Devuelve el índice de un segmento que procesa una parte de los datos en una consulta distribuida.
Los índices comienzan en `1`.
Si una consulta no es distribuida, se devuelve el valor constante `0`.
**Sintaxis**
```sql theme={null}
shardNum()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el índice del segmento o una constante `0`. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE shard_num_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT dummy, shardNum(), shardCount() FROM shard_num_example;
```
```response title=Response theme={null}
┌─dummy─┬─shardNum()─┬─shardCount()─┐
│ 0 │ 1 │ 2 │
│ 0 │ 2 │ 2 │
└───────┴────────────┴──────────────┘
```
## showCertificate
Introducido en: v22.6.0
Muestra información sobre el certificado SSL actual del servidor, si se ha configurado.
Consulta [Configuración de TLS](/es/concepts/features/security/tls/configuring-tls) para obtener más información sobre cómo configurar ClickHouse para usar certificados OpenSSL para validar las conexiones.
**Sintaxis**
```sql theme={null}
showCertificate()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve un mapa de pares clave-valor relacionados con el certificado SSL configurado. [`Map(String, String)`](/es/reference/data-types/map)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT showCertificate() FORMAT LineAsString;
```
```response title=Response theme={null}
{'version':'1','serial_number':'2D9071D64530052D48308473922C7ADAFA85D6C5','signature_algo':'sha256WithRSAEncryption','issuer':'/CN=marsnet.local CA','not_before':'May 7 17:01:21 2024 GMT','not_after':'May 7 17:01:21 2025 GMT','subject':'/CN=chnode1','pkey_algo':'rsaEncryption'}
```
## sleep
Introducido en: v1.1.0
Pausa la ejecución de una consulta durante el número de segundos especificado.
La función se utiliza principalmente para pruebas y depuración.
Por lo general, la función `sleep()` no debe usarse en entornos de producción, ya que puede afectar negativamente al rendimiento de las consultas y a la capacidad de respuesta del sistema.
Sin embargo, puede resultar útil en los siguientes casos:
1. **Pruebas**: Al probar o ejecutar benchmarks de ClickHouse, es posible que desee simular retrasos o introducir pausas para observar cómo se comporta el sistema en determinadas condiciones.
2. **Depuración**: Si necesita examinar el estado del sistema o la ejecución de una consulta en un momento concreto, puede usar `sleep()` para introducir una pausa, lo que le permitirá inspeccionar o recopilar información relevante.
3. **Simulación**: En algunos casos, es posible que desee simular situaciones reales en las que se producen retrasos o pausas, como la latencia de red o las dependencias de sistemas externos.
Es importante usar la función `sleep()` con prudencia y solo cuando sea necesario, ya que puede afectar al rendimiento general y a la capacidad de respuesta de su sistema ClickHouse.
Por razones de seguridad, la función solo puede ejecutarse en el perfil de usuario predeterminado (con `allow_sleep` habilitado).
**Sintaxis**
```sql theme={null}
sleep(seconds)
```
**Argumentos**
* `seconds` — El número de segundos durante los que se pausará la ejecución de la consulta, con un máximo de 3 segundos. Puede ser un valor de coma flotante para especificar fracciones de segundo. [`const UInt*`](/es/reference/data-types/int-uint) o [`const Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `0`. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
-- Esta consulta se pausará durante 2 segundos antes de completarse.
-- Durante este tiempo, no se devolverán resultados y la consulta parecerá estar bloqueada o sin respuesta.
SELECT sleep(2);
```
```response title=Response theme={null}
┌─sleep(2)─┐
│ 0 │
└──────────┘
1 row in set. Elapsed: 2.012 sec.
```
## sleepEachRow
Introducido en: v1.1.0
Pausa la ejecución de una consulta durante un número determinado de segundos por cada fila del conjunto de resultados.
La función `sleepEachRow()` se utiliza principalmente para pruebas y depuración, de forma similar a la función [`sleep()`](#sleep).
Permite simular retrasos o introducir pausas en el procesamiento de cada fila, lo que puede resultar útil en escenarios como los siguientes:
1. **Pruebas**: Al probar o hacer benchmark del rendimiento de ClickHouse en condiciones específicas, puede usar `sleepEachRow()` para simular retrasos o introducir pausas en cada fila procesada.
2. **Depuración**: Si necesita examinar el estado del sistema o la ejecución de una consulta para cada fila procesada, puede usar `sleepEachRow()` para introducir pausas, lo que le permitirá inspeccionar o recopilar información relevante.
3. **Simulación**: En algunos casos, puede que desee simular situaciones del mundo real en las que se producen retrasos o pausas por cada fila procesada, como al trabajar con sistemas externos o con latencias de red.
Al igual que con la función `sleep()`, es importante usar `sleepEachRow()` con prudencia y solo cuando sea necesario, ya que puede afectar significativamente al rendimiento general y a la capacidad de respuesta de su sistema ClickHouse, especialmente al trabajar con conjuntos de resultados grandes.
**Sintaxis**
```sql theme={null}
sleepEachRow(seconds)
```
**Argumentos**
* `seconds` — Número de segundos durante los que se pausa la ejecución de la consulta para cada fila del conjunto de resultados, con un máximo de 3 segundos. Puede ser un valor de punto flotante para especificar fracciones de segundo. [`const UInt*`](/es/reference/data-types/int-uint) o [`const Float*`](/es/reference/data-types/float)
**Valor devuelto**
Devuelve `0` para cada fila. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
-- La salida se retrasará, con una pausa de 0,5 segundos entre cada fila.
SELECT number, sleepEachRow(0.5) FROM system.numbers LIMIT 5;
```
```response title=Response theme={null}
┌─number─┬─sleepEachRow(0.5)─┐
│ 0 │ 0 │
│ 1 │ 0 │
│ 2 │ 0 │
│ 3 │ 0 │
│ 4 │ 0 │
└────────┴───────────────────┘
```
## structureToCapnProtoSchema
Introducido en: v23.8.0
Función que convierte la estructura de una tabla de ClickHouse a un esquema en formato CapnProto
**Sintaxis**
```sql theme={null}
structureToCapnProtoSchema(table_structure, message)
```
**Argumentos**
* Ninguno.
**Valor devuelto**
**Ejemplos**
**random**
```sql title=Query theme={null}
SELECT structureToCapnProtoSchema('s String, x UInt32', 'MessageName') format TSVRaw
```
```response title=Response theme={null}
struct MessageName
{
s @0 : Data;
x @1 : UInt32;
}
```
## structureToProtobufSchema
Introducido en: v23.8.0
Convierte la estructura de una tabla de ClickHouse en un esquema de formato Protobuf.
Esta función toma la definición de la estructura de una tabla de ClickHouse y la convierte en una definición de esquema de Protocol Buffers (Protobuf) con sintaxis proto3. Esto resulta útil para generar esquemas de Protobuf que coincidan con las estructuras de tus tablas de ClickHouse para el intercambio de datos.
**Sintaxis**
```sql theme={null}
structureToProtobufSchema(structure, message_name)
```
**Argumentos**
* `structure` — Definición de la estructura de la tabla de ClickHouse como una cadena (p. ej., 'column1 Type1, column2 Type2'). [`String`](/es/reference/data-types/string)
* `message_name` — Nombre del tipo de mensaje de Protobuf en el esquema generado. [`String`](/es/reference/data-types/string)
**Valor devuelto**
Devuelve una definición de esquema Protobuf en sintaxis proto3 que corresponde a la estructura de ClickHouse proporcionada. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Conversión de la estructura de ClickHouse a un esquema Protobuf**
```sql title=Query theme={null}
SELECT structureToProtobufSchema('s String, x UInt32', 'MessageName') FORMAT TSVRaw;
```
```response title=Response theme={null}
syntax = "proto3";
message MessageName
{
bytes s = 1;
uint32 x = 2;
}
```
## tcpPort
Introducido en: v20.12.0
Devuelve el número de puerto TCP en el que escucha el [server nativo](/es/concepts/features/interfaces/tcp).
Si se ejecuta en el contexto de una tabla distribuida, esta función genera una columna normal con valores correspondientes a cada segmento.
De lo contrario, devuelve un valor constante.
**Sintaxis**
```sql theme={null}
tcpPort()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el número de puerto TCP. [`UInt16`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT tcpPort()
```
```response title=Response theme={null}
┌─tcpPort()─┐
│ 9000 │
└───────────┘
```
## throwIf
Introducido en: v1.1.0
Lanza una excepción si el argumento `x` es verdadero.
Para usar el argumento `error_code`, el parámetro de configuración `allow_custom_error_code_in_throw` debe estar habilitado.
**Sintaxis**
```sql theme={null}
throwIf(x[, message[, error_code]])
```
**Argumentos**
* `x` — La condición que se debe comprobar. [`Any`](/es/reference/data-types/index)
* `message` — Opcional. Mensaje de error personalizado. [`const String`](/es/reference/data-types/string)
* `error_code` — Opcional. Código de error personalizado. [`const Int8/16/32`](/es/reference/data-types/int-uint)
**Valor devuelto**
Devuelve `0` si la condición es falsa; lanza una excepción si la condición es verdadera. [`UInt8`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT throwIf(number = 3, 'Too many') FROM numbers(10);
```
```response title=Response theme={null}
↙ Progress: 0.00 rows, 0.00 B (0.00 rows/s., 0.00 B/s.) Received exception from server (version 19.14.1):
Code: 395. DB::Exception: Received from localhost:9000. DB::Exception: Too many.
```
## toColumnTypeName
Introducido en: v1.1.0
Devuelve el nombre interno del tipo de dato del valor dado.
A diferencia de la función [`toTypeName`](#toTypeName), el tipo de dato devuelto puede incluir columnas internas contenedoras como `Const` y `LowCardinality`.
**Sintaxis**
```sql theme={null}
toColumnTypeName(value)
```
**Argumentos**
* `value` — Valor para el que se devuelve el tipo de dato interno. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el tipo de dato interno que se usa para representar el valor. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toColumnTypeName(CAST('2025-01-01 01:02:03' AS DateTime));
```
```response title=Response theme={null}
┌─toColumnTypeName(CAST('2025-01-01 01:02:03', 'DateTime'))─┐
│ Const(UInt32) │
└───────────────────────────────────────────────────────────┘
```
## toTypeName
Introducido en: v1.1.0
Devuelve el nombre del tipo del argumento proporcionado.
Si se pasa `NULL`, la función devuelve el tipo `Nullable(Nothing)`, que corresponde a la representación interna de `NULL` en ClickHouse.
**Sintaxis**
```sql theme={null}
toTypeName(x)
```
**Argumentos**
* `x` — Un valor de tipo arbitrario. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el nombre del tipo de datos del valor de entrada. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT toTypeName(123)
```
```response title=Response theme={null}
┌─toTypeName(123)─┐
│ UInt8 │
└─────────────────┘
```
## tokenizeQuery
Introducido en: v26.5.0
Tokeniza una cadena de consulta SQL de ClickHouse y devuelve un array de tokens.
Cada token es una tupla con nombre con la posición inicial (en bytes), la posición final y el tipo de token.
**Sintaxis**
```sql theme={null}
tokenizeQuery(query)
```
**Argumentos**
* `query` — Una cadena con una consulta de ClickHouse SQL. String.
**Valor devuelto**
Un array de tuplas con nombre `(begin UInt64, end UInt64, type Enum8(...))` que representa los tokens de la consulta. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/es/reference/data-types/array)
**Ejemplos**
**simple**
```sql title=Query theme={null}
SELECT tokenizeQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'BareWord'),(6,7,'Whitespace'),(7,8,'Number')]
```
## transactionID
Introducido en: v22.6.0
Devuelve el ID de una transacción.
Esta función forma parte de un conjunto de funcionalidades experimentales.
Habilite la compatibilidad experimental con transacciones añadiendo este ajuste a su [configuración](/es/concepts/features/configuration/server-config/configuration-files):
```xml theme={null}
1
```
Para obtener más información, consulte la página [compatibilidad transaccional (ACID)](/es/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxis**
```sql theme={null}
transactionID()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve una tupla formada por `start_csn`, `local_tid` y `host_id`.
* `start_csn`: Número secuencial global; la marca temporal de confirmación más reciente observada al iniciarse esta transacción.
* `local_tid`: Número secuencial local, único para cada transacción iniciada por este host dentro de un `start_csn` específico.
* `host_id`: UUID del host que inició esta transacción.
[`Tuple(UInt64, UInt64, UUID)`](/es/reference/data-types/tuple)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionID();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionID()────────────────────────────────┐
│ (32,34,'0ee8b069-f2bb-4748-9eae-069c85b5252b') │
└────────────────────────────────────────────────┘
```
## transactionLatestSnapshot
Introducido en: v22.6.0
Devuelve la instantánea más reciente (Commit Sequence Number) de una [transacción](/es/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) disponible para lectura.
Esta función forma parte de un conjunto de características experimentales. Habilite la compatibilidad experimental con transacciones añadiendo esta configuración a su archivo de configuración:
```xml theme={null}
1
```
Para obtener más información, consulte la página [Compatibilidad transaccional (ACID)](/es/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxis**
```sql theme={null}
transactionLatestSnapshot()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la instantánea (CSN) más reciente de una transacción. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionLatestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionLatestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transactionOldestSnapshot
Introducido en: v22.6.0
Devuelve la instantánea más antigua (Commit Sequence Number) visible para alguna [transacción](/es/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) en ejecución.
Esta función forma parte de un conjunto de características experimentales. Habilite la compatibilidad con transacciones experimentales añadiendo esta configuración a su configuración:
```xml theme={null}
1
```
Para obtener más información, consulte la página [Compatibilidad transaccional (ACID)](/es/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Sintaxis**
```sql theme={null}
transactionOldestSnapshot()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la instantánea (CSN) más antigua de una transacción. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionOldestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionOldestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transform
Introducido en: v1.1.0
Transforma un valor según una asignación definida explícitamente de unos elementos a otros.
Hay dos variantes de esta función:
* `transform(x, array_from, array_to, default)` - transforma `x` mediante arrays de asignación, con un valor predeterminado para los elementos que no coincidan
* `transform(x, array_from, array_to)` - realiza la misma transformación, pero devuelve el `x` original si no se encuentra ninguna coincidencia
La función busca `x` en `array_from` y devuelve el elemento correspondiente de `array_to` en el mismo índice.
Si `x` no se encuentra en `array_from`, devuelve el valor `default` (versión de 4 parámetros) o el `x` original (versión de 3 parámetros).
Si hay varios elementos coincidentes en `array_from`, devuelve el elemento correspondiente a la primera coincidencia.
Requisitos:
* `array_from` y `array_to` deben tener el mismo número de elementos
* Para la versión de 4 parámetros: `transform(T, Array(T), Array(U), U) -> U` donde `T` y `U` pueden ser tipos compatibles distintos
* Para la versión de 3 parámetros: `transform(T, Array(T), Array(T)) -> T` donde todos los tipos deben ser iguales
**Sintaxis**
```sql theme={null}
transform(x, array_from, array_to[, default])
```
**Argumentos**
* `x` — Valor que se va a transformar. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Decimal`](/es/reference/data-types/decimal) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
* `array_from` — Array constante de valores en el que buscar coincidencias. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Array(Decimal)`](/es/reference/data-types/array) o [`Array(Float*)`](/es/reference/data-types/array) o [`Array(String)`](/es/reference/data-types/array) o [`Array(Date)`](/es/reference/data-types/array) o [`Array(DateTime)`](/es/reference/data-types/array)
* `array_to` — Array constante de valores que se devolverán para las coincidencias correspondientes de `array_from`. [`Array((U)Int*)`](/es/reference/data-types/array) o [`Array(Decimal)`](/es/reference/data-types/array) o [`Array(Float*)`](/es/reference/data-types/array) o [`Array(String)`](/es/reference/data-types/array) o [`Array(Date)`](/es/reference/data-types/array) o [`Array(DateTime)`](/es/reference/data-types/array)
* `default` — Opcional. Valor que se devolverá si `x` no se encuentra en `array_from`. Si se omite, devuelve x sin cambios. [`(U)Int*`](/es/reference/data-types/int-uint) o [`Decimal`](/es/reference/data-types/decimal) o [`Float*`](/es/reference/data-types/float) o [`String`](/es/reference/data-types/string) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime)
**Valor devuelto**
Devuelve el valor correspondiente de `array_to` si x coincide con un elemento de `array_from`; de lo contrario, devuelve default (si se proporciona) o x (si no se proporciona default). [`Any`](/es/reference/data-types/index)
**Ejemplos**
**transform(T, Array(T), Array(U), U) -> U**
```sql title=Query theme={null}
SELECT
transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title,
count() AS c
FROM test.hits
WHERE SearchEngineID != 0
GROUP BY title
ORDER BY c DESC
```
```response title=Response theme={null}
┌─title─────┬──────c─┐
│ Yandex │ 498635 │
│ Google │ 229872 │
│ Other │ 104472 │
└───────────┴────────┘
```
**transform(T, Array(T), Array(T)) -> T**
```sql title=Query theme={null}
SELECT
transform(domain(Referer), ['yandex.ru', 'google.ru', 'vkontakte.ru'], ['www.yandex', 'example.com', 'vk.com']) AS s, count() AS c
FROM test.hits
GROUP BY domain(Referer)
ORDER BY count() DESC
LIMIT 10
```
```response title=Response theme={null}
┌─s──────────────┬───────c─┐
│ │ 2906259 │
│ www.yandex │ 867767 │
│ ███████.ru │ 313599 │
│ mail.yandex.ru │ 107147 │
│ ██████.ru │ 100355 │
│ █████████.ru │ 65040 │
│ news.yandex.ru │ 64515 │
│ ██████.net │ 59141 │
│ example.com │ 57316 │
└────────────────┴─────────┘
```
## uniqThetaIntersect
Introducido en: v22.9.0
Calcula la intersección de dos objetos `uniqThetaSketch` (operación de conjuntos ∩); el resultado es un nuevo `uniqThetaSketch`.
**Sintaxis**
```sql theme={null}
uniqThetaIntersect(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto uniqThetaSketch. [`Tuple`](/es/reference/data-types/tuple) o [`Array`](/es/reference/data-types/array) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Un nuevo uniqThetaSketch que contiene el resultado de `intersect`. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaIntersect(a, b)) AS a_intersect_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_intersect_b─┬─a_cardinality─┬─b_cardinality─┐
│ 1 │ 2 │ 3 │
└───────────────┴───────────────┴───────────────┘
```
## uniqThetaNot
Introducido en: v22.9.0
Dados dos objetos uniqThetaSketch, realiza el cálculo a\_not\_b (operación de conjuntos ×) y el resultado es un nuevo uniqThetaSketch.
**Sintaxis**
```sql theme={null}
uniqThetaNot(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto uniqThetaSketch. [`Tuple`](/es/reference/data-types/tuple) o [`Array`](/es/reference/data-types/array) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un nuevo uniqThetaSketch que contiene el resultado de a\_not\_b. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaNot(a, b)) AS a_not_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [2, 3, 4]) AS a, arrayReduce('uniqThetaState', [1, 2]) AS b);
```
```response title=Response theme={null}
┌─a_not_b─┬─a_cardinality─┬─b_cardinality─┐
│ 2 │ 3 │ 2 │
└─────────┴───────────────┴───────────────┘
```
## uniqThetaUnion
Introducido en: v22.9.0
Une dos objetos uniqThetaSketch para realizar el cálculo de unión (operación de conjuntos ∪); el resultado es un nuevo uniqThetaSketch.
**Sintaxis**
```sql theme={null}
uniqThetaUnion(uniqThetaSketch,uniqThetaSketch)
```
**Argumentos**
* `uniqThetaSketch` — objeto uniqThetaSketch. [`Tuple`](/es/reference/data-types/tuple) o [`Array`](/es/reference/data-types/array) o [`Date`](/es/reference/data-types/date) o [`DateTime`](/es/reference/data-types/datetime) o [`String`](/es/reference/data-types/string) o [`(U)Int*`](/es/reference/data-types/int-uint) o [`Float*`](/es/reference/data-types/float) o [`Decimal`](/es/reference/data-types/decimal)
**Valor devuelto**
Devuelve un nuevo uniqThetaSketch con el resultado de la unión. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaUnion(a, b)) AS a_union_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_union_b─┬─a_cardinality─┬─b_cardinality─┐
│ 4 │ 2 │ 3 │
└───────────┴───────────────┴───────────────┘
```
## uptime
Introducido en: v1.1.0
Devuelve el tiempo de actividad del servidor en segundos.
Si se ejecuta en el contexto de una tabla distribuida, esta función genera una columna normal con valores correspondientes a cada segmento.
De lo contrario, produce un valor constante.
**Sintaxis**
```sql theme={null}
uptime()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el tiempo de actividad del servidor en segundos. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT uptime() AS Uptime
```
```response title=Response theme={null}
┌─Uptime─┐
│ 55867 │
└────────┘
```
## variantElement
Introducido en: v25.2.0
Extrae una columna del tipo especificado de una columna `Variant`.
**Sintaxis**
```sql theme={null}
variantElement(variant, type_name[, default_value])
```
**Argumentos**
* `variant` — columna de tipo Variant. [`Variant`](/es/reference/data-types/variant)
* `type_name` — El nombre del tipo de variante que se va a extraer. [`String`](/es/reference/data-types/string)
* `default_value` — El valor predeterminado que se usará si `variant` no tiene una variante del tipo especificado. Puede ser de cualquier tipo. Opcional. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve una columna con el tipo de variante especificado extraído de la columna Variant. [`Any`](/es/reference/data-types/index)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT v, variantElement(v, 'String'), variantElement(v, 'UInt64'), variantElement(v, 'Array(UInt64)') FROM test;
```
```response title=Response theme={null}
┌─v─────────────┬─variantElement(v, 'String')─┬─variantElement(v, 'UInt64')─┬─variantElement(v, 'Array(UInt64)')─┐
│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [] │
│ 42 │ ᴺᵁᴸᴸ │ 42 │ [] │
│ Hello, World! │ Hello, World! │ ᴺᵁᴸᴸ │ [] │
│ [1,2,3] │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [1,2,3] │
└───────────────┴─────────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
```
## variantType
Introducido en: v24.2.0
Devuelve el nombre del tipo de variante de cada fila de una columna `Variant`. Si una fila contiene NULL, devuelve 'None'.
**Sintaxis**
```sql theme={null}
variantType(variant)
```
**Argumentos**
* `variant` — columna de tipo Variant. [`Variant`](/es/reference/data-types/variant)
**Valor devuelto**
Devuelve una columna Enum con el nombre del tipo de Variant para cada fila. [`Enum`](/es/reference/data-types/enum)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT variantType(v) FROM test;
```
```response title=Response theme={null}
┌─variantType(v)─┐
│ None │
│ UInt64 │
│ String │
│ Array(UInt64) │
└────────────────┘
```
## version
Introducido en: v1.1.0
Devuelve la versión actual de ClickHouse como una cadena con el formato: `major_version.minor_version.patch_version.number_of_commits_since_the_previous_stable_release`.
Si se ejecuta en el contexto de una tabla distribuida, esta función genera una columna normal con valores correspondientes a cada segmento.
En caso contrario, produce un valor constante.
**Sintaxis**
```sql theme={null}
version()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve la versión actual de ClickHouse. [`String`](/es/reference/data-types/string)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT version()
```
```response title=Response theme={null}
┌─version()─┐
│ 24.2.1.1 │
└───────────┘
```
## visibleWidth
Introducido en: v1.1.0
Calcula el ancho aproximado al mostrar valores en la consola en formato de texto (separado por tabulaciones).
El sistema usa esta función para implementar los formatos Pretty.
`NULL` se representa como una cadena correspondiente a `NULL` en los formatos Pretty.
**Sintaxis**
```sql theme={null}
visibleWidth(x)
```
**Argumentos**
* `x` — Un valor de cualquier tipo de datos. [`Any`](/es/reference/data-types/index)
**Valor devuelto**
Devuelve el ancho aproximado del valor al mostrarse en formato de texto. [`UInt64`](/es/reference/data-types/int-uint)
**Ejemplos**
**Calcular el ancho visible de NULL**
```sql title=Query theme={null}
SELECT visibleWidth(NULL)
```
```response title=Response theme={null}
┌─visibleWidth(NULL)─┐
│ 4 │
└────────────────────┘
```
## zookeeperSessionUptime
Introducido en: v21.11.0
Devuelve el tiempo de actividad de la sesión actual de ZooKeeper en segundos.
**Sintaxis**
```sql theme={null}
zookeeperSessionUptime()
```
**Argumentos**
* Ninguno.
**Valor devuelto**
Devuelve el tiempo de actividad de la sesión actual de ZooKeeper en segundos. [`UInt32`](/es/reference/data-types/int-uint)
**Ejemplos**
**Ejemplo de uso**
```sql title=Query theme={null}
SELECT zookeeperSessionUptime();
```
```response title=Response theme={null}
┌─zookeeperSessionUptime()─┐
│ 286 │
└──────────────────────────┘
```