Tuple(T1, T2, ...)

Una tupla de elementos, cada uno con un tipo. 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 y funciones de orden superior. 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:

tuple(T1, T2, ...)

Ejemplo de cómo crear una tupla:

SELECT tuple(1, 'a') AS x, toTypeName(x)

┌─x───────┬─toTypeName(tuple(1, 'a'))─┐
│ (1,'a') │ Tuple(UInt8, String)      │
└─────────┴───────────────────────────┘

Un Tuple puede contener un único elemento Ejemplo:

SELECT tuple('a') AS x;

┌─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:

SELECT (1, 'a') AS x, (today(), rand(), 'someString') AS y, ('a') AS not_a_tuple;

┌─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, el tipo inferido es Nullable. Ejemplo de detección automática de tipos de datos:

SELECT tuple(1, NULL) AS x, toTypeName(x)

┌─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:

Query

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

Response

┌─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:

SELECT (1, 'z') > (1, 'a') c1, (2022, 01, 02) > (2023, 04, 02) c2, (1,2,3) = (3,2,1) c3;

┌─c1─┬─c2─┬─c3─┐
│  1 │  0 │  0 │
└────┴────┴────┘

Ejemplos reales:

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, …))

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:

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;

┌─id─┬─data─┐
│  2 │ ᴺᵁᴸᴸ │
└────┴──────┘

Referencia de SQL

Tipos de datos

Motores

Funciones

Formatos

Configuración

Tablas del sistema

Lagos de datos

Creación de tuplas

Detección de tipos de datos

Referencia a los elementos de Tuple

Operaciones de comparación con Tuple

Nullable(Tuple(T1, T2, …))

​Creación de tuplas

​Detección de tipos de datos

​Referencia a los elementos de Tuple

​Operaciones de comparación con Tuple

​Nullable(Tuple(T1, T2, …))

Creación de tuplas

Detección de tipos de datos

Referencia a los elementos de Tuple

Operaciones de comparación con Tuple

Nullable(Tuple(T1, T2, …))