> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-3a82795f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentação do tipo de dado Tuple no ClickHouse
# Tuple(T1, T2, ...)
Uma tupla de elementos, cada elemento com um [tipo](/pt-BR/reference/data-types) 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](/pt-BR/reference/statements/in) e [funções de ordem superior](/pt-BR/reference/functions/regular-functions/overview#higher-order-functions).
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:
```sql theme={null}
tuple(T1, T2, ...)
```
Exemplo de como criar uma 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) │
└─────────┴───────────────────────────┘
```
Uma Tuple pode conter um único elemento
Exemplo:
```sql theme={null}
SELECT tuple('a') AS x;
```
```text theme={null}
┌─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:
```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 │
└─────────┴────────────────────────────────────────┴─────────────┘
```
## Detecção de tipos de dados
Ao criar tuplas dinamicamente, o ClickHouse infere o tipo dos argumentos da tupla como os menores tipos capazes de armazenar o valor do argumento fornecido. Se o valor for [NULL](/pt-BR/reference/settings/formats#input_format_null_as_default), o tipo inferido será [Nullable](/pt-BR/reference/data-types/nullable).
Exemplo de detecção automática de tipos de dados:
```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)) │
└───────────┴─────────────────────────────────┘
```
## Referência aos elementos de Tuple
Os elementos de Tuple podem ser referenciados pelo nome ou pelo í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 nome
SELECT a.2 FROM named_tuples; -- por índice
```
```text title="Response" theme={null}
┌─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:
```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 │
└────┴────┴────┘
```
Exemplos práticos:
```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 │
└─────┴──────────┴───────┘
-- 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, ...))
**Funcionalidade experimental**
Requer `SET allow_experimental_nullable_tuple_type = 1`
Esta funcionalidade é experimental e pode mudar em versões futuras.
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:
```sql theme={null}
SET allow_experimental_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 │ ᴺᵁᴸᴸ │
└────┴──────┘
```