> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentación del tipo de dato Tuple en ClickHouse
# Tuple(T1, T2, ...)
Una tupla de elementos, cada uno con un [tipo](/es/reference/data-types/index). Tuple debe contener al menos un elemento.
Las tuplas se usan para la agrupación temporal de columnas. Las columnas pueden agruparse cuando se usa una expresión IN en una consulta, así como para especificar determinados parámetros formales de las funciones lambda. Para más información, consulte las secciones [operadores IN](/es/reference/statements/in) y [funciones de orden superior](/es/reference/functions/regular-functions/overview#higher-order-functions).
Las tuplas pueden ser el resultado de una consulta. En este caso, en los formatos de texto distintos de JSON, los valores aparecen separados por comas entre `()`. En los formatos JSON, las tuplas se representan como arrays (en `[]`).
## Creación de tuplas
Puede usar una función para crear una tupla:
```sql theme={null}
tuple(T1, T2, ...)
```
Ejemplo de cómo crear una tupla:
```sql theme={null}
SELECT tuple(1, 'a') AS x, toTypeName(x)
```
```text theme={null}
┌─x───────┬─toTypeName(tuple(1, 'a'))─┐
│ (1,'a') │ Tuple(UInt8, String) │
└─────────┴───────────────────────────┘
```
Un Tuple puede contener un único elemento
Ejemplo:
```sql theme={null}
SELECT tuple('a') AS x;
```
```text theme={null}
┌─x─────┐
│ ('a') │
└───────┘
```
La sintaxis `(tuple_element1, tuple_element2)` puede usarse para crear una tupla de varios elementos sin necesidad de llamar a la función `tuple()`.
Ejemplo:
```sql theme={null}
SELECT (1, 'a') AS x, (today(), rand(), 'someString') AS y, ('a') AS not_a_tuple;
```
```text theme={null}
┌─x───────┬─y──────────────────────────────────────┬─not_a_tuple─┐
│ (1,'a') │ ('2022-09-21',2006973416,'someString') │ a │
└─────────┴────────────────────────────────────────┴─────────────┘
```
## Detección de tipos de datos
Al crear tuplas sobre la marcha, ClickHouse infiere el tipo de los argumentos de las tuplas como los tipos más pequeños capaces de contener el valor del argumento proporcionado. Si el valor es [NULL](/es/reference/settings/formats#input_format_null_as_default), el tipo inferido es [Nullable](/es/reference/data-types/nullable).
Ejemplo de detección automática de tipos de datos:
```sql theme={null}
SELECT tuple(1, NULL) AS x, toTypeName(x)
```
```text theme={null}
┌─x─────────┬─toTypeName(tuple(1, NULL))──────┐
│ (1, NULL) │ Tuple(UInt8, Nullable(Nothing)) │
└───────────┴─────────────────────────────────┘
```
## Referencia a los elementos de Tuple
Se puede hacer referencia a los elementos de Tuple por nombre o por índice:
```sql title="Query" theme={null}
CREATE TABLE named_tuples (`a` Tuple(s String, i Int64)) ENGINE = Memory;
INSERT INTO named_tuples VALUES (('y', 10)), (('x',-10));
SELECT a.s FROM named_tuples; -- por nombre
SELECT a.2 FROM named_tuples; -- por índice
```
```text title="Response" theme={null}
┌─a.s─┐
│ y │
│ x │
└─────┘
┌─tupleElement(a, 2)─┐
│ 10 │
│ -10 │
└────────────────────┘
```
## Operaciones de comparación con Tuple
Dos tuplas se comparan secuencialmente, de izquierda a derecha. Si un elemento de la primera tupla es mayor (o menor) que el elemento correspondiente de la segunda, entonces la primera tupla es mayor (o menor) que la segunda; de lo contrario, si ambos elementos son iguales, se compara el siguiente elemento.
Ejemplo:
```sql theme={null}
SELECT (1, 'z') > (1, 'a') c1, (2022, 01, 02) > (2023, 04, 02) c2, (1,2,3) = (3,2,1) c3;
```
```text theme={null}
┌─c1─┬─c2─┬─c3─┐
│ 1 │ 0 │ 0 │
└────┴────┴────┘
```
Ejemplos reales:
```sql theme={null}
CREATE TABLE test
(
`year` Int16,
`month` Int8,
`day` Int8
)
ENGINE = Memory AS
SELECT *
FROM values((2022, 12, 31), (2000, 1, 1));
SELECT * FROM test;
┌─year─┬─month─┬─day─┐
│ 2022 │ 12 │ 31 │
│ 2000 │ 1 │ 1 │
└──────┴───────┴─────┘
SELECT *
FROM test
WHERE (year, month, day) > (2010, 1, 1);
┌─year─┬─month─┬─day─┐
│ 2022 │ 12 │ 31 │
└──────┴───────┴─────┘
CREATE TABLE test
(
`key` Int64,
`duration` UInt32,
`value` Float64
)
ENGINE = Memory AS
SELECT *
FROM values((1, 42, 66.5), (1, 42, 70), (2, 1, 10), (2, 2, 0));
SELECT * FROM test;
┌─key─┬─duration─┬─value─┐
│ 1 │ 42 │ 66.5 │
│ 1 │ 42 │ 70 │
│ 2 │ 1 │ 10 │
│ 2 │ 2 │ 0 │
└─────┴──────────┴───────┘
-- Busquemos un valor para cada clave con la mayor duración; si las duraciones son iguales, seleccionamos el valor más alto
SELECT
key,
max(duration),
argMax(value, (duration, value))
FROM test
GROUP BY key
ORDER BY key ASC;
┌─key─┬─max(duration)─┬─argMax(value, tuple(duration, value))─┐
│ 1 │ 42 │ 70 │
│ 2 │ 2 │ 0 │
└─────┴───────────────┴───────────────────────────────────────┘
```
## Nullable(Tuple(T1, T2, ...))
**Funcionalidad Beta**
Requiere `SET enable_nullable_tuple_type = 1`
Esta es una funcionalidad Beta.
Permite que la tupla completa sea `NULL`, a diferencia de `Tuple(Nullable(T1), Nullable(T2), ...)`, donde solo los elementos individuales pueden ser `NULL`.
| Tipo | Tuple puede ser NULL | Los elementos pueden ser NULL |
| ------------------------------------------ | -------------------- | ----------------------------- |
| `Nullable(Tuple(String, Int64))` | ✅ | ❌ |
| `Tuple(Nullable(String), Nullable(Int64))` | ❌ | ✅ |
Ejemplo:
```sql theme={null}
SET enable_nullable_tuple_type = 1;
CREATE TABLE test (
id UInt32,
data Nullable(Tuple(String, Int64))
) ENGINE = Memory;
INSERT INTO test VALUES (1, ('hello', 42)), (2, NULL);
SELECT * FROM test WHERE data IS NULL;
```
```txt theme={null}
┌─id─┬─data─┐
│ 2 │ ᴺᵁᴸᴸ │
└────┴──────┘
```