Tuple(T1, T2, ...)

Uma tupla de elementos, cada elemento com um tipo próprio. Tuple deve conter pelo menos um elemento. Tuplas são usadas para o agrupamento temporário de colunas. As colunas podem ser agrupadas quando uma expressão IN é usada em uma consulta e para especificar determinados parâmetros formais de funções lambda. Para mais informações, consulte as seções operadores IN e funções de ordem superior. Tuplas podem ser o resultado de uma consulta. Nesse caso, em formatos de texto diferentes de JSON, os valores são separados por vírgulas em (). Em formatos JSON, as tuplas são exibidas como arrays (em []).

Criando Tuplas

Você pode usar uma função para criar uma tupla:

tuple(T1, T2, ...)

Exemplo de como criar uma tupla:

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

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

Uma Tuple pode conter um único elemento Exemplo:

SELECT tuple('a') AS x;

┌─x─────┐
│ ('a') │
└───────┘

A sintaxe (tuple_element1, tuple_element2) pode ser usada para criar uma tupla com vários elementos sem chamar a função tuple(). Exemplo:

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           │
└─────────┴────────────────────────────────────────┴─────────────┘

Detecção de tipos de dados

Ao criar Tuples dinamicamente, o ClickHouse infere o tipo dos argumentos da Tuple como os menores tipos capazes de armazenar o valor do argumento fornecido. Se o valor for NULL, o tipo inferido será Nullable. Exemplo de detecção automática de tipos de dados:

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

┌─x─────────┬─toTypeName(tuple(1, NULL))──────┐
│ (1, NULL) │ Tuple(UInt8, Nullable(Nothing)) │
└───────────┴─────────────────────────────────┘

Referência aos elementos de Tuple

Os elementos de Tuple podem ser referenciados pelo nome ou pelo í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 nome
SELECT a.2 FROM named_tuples; -- por índice

Response

┌─a.s─┐
│ y   │
│ x   │
└─────┘

┌─tupleElement(a, 2)─┐
│                 10 │
│                -10 │
└────────────────────┘

Operações de comparação com Tuple

Duas tuplas são comparadas sequencialmente, da esquerda para a direita. Se o elemento da primeira tupla for maior (menor) que o elemento correspondente da segunda tupla, então a primeira tupla será maior (menor) que a segunda; caso contrário (se ambos os elementos forem iguais), compara-se o próximo elemento. Exemplo:

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 │
└────┴────┴────┘

Exemplos práticos:

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 │
└─────┴──────────┴───────┘

-- Vamos encontrar um valor para cada chave com a maior duração; se as durações forem iguais, selecione o maior valor

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 a tupla inteira seja NULL, ao contrário de Tuple(Nullable(T1), Nullable(T2), ...), em que apenas os elementos individuais podem ser NULL.

Tipo	A tupla pode ser NULL	Os elementos podem ser NULL
`Nullable(Tuple(String, Int64))`	✅	❌
`Tuple(Nullable(String), Nullable(Int64))`	❌	✅

Exemplo:

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 │ ᴺᵁᴸᴸ │
└────┴──────┘

Referência de SQL

Tipos de dados

Motores

Funções

Formatos

Configurações

Tabelas do sistema

Lagos de dados

Criando Tuplas

Detecção de tipos de dados

Referência aos elementos de Tuple

Operações de comparação com Tuple

Nullable(Tuple(T1, T2, …))

​Criando Tuplas

​Detecção de tipos de dados

​Referência aos elementos de Tuple

​Operações de comparação com Tuple

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

Criando Tuplas

Detecção de tipos de dados

Referência aos elementos de Tuple

Operações de comparação com Tuple

Nullable(Tuple(T1, T2, …))