Tuple(T1, T2, ...)

Documentation du type de données Tuple dans ClickHouse

Un tuple d’éléments, chacun ayant son propre type. Un tuple doit contenir au moins un élément.

Les tuples sont utilisés pour le regroupement temporaire de colonnes. Les colonnes peuvent être regroupées lorsqu’une expression IN est utilisée dans une requête, ainsi que pour spécifier certains paramètres formels des fonctions lambda. Pour plus d’informations, consultez les sections opérateurs IN et fonctions d’ordre supérieur.

Les tuples peuvent être le résultat d’une requête. Dans ce cas, pour les formats texte autres que JSON, les valeurs sont séparées par des virgules dans (). Dans les formats JSON, les tuples sont renvoyés sous forme de tableaux (dans []).

​

Créer des tuples

Vous pouvez utiliser une fonction pour créer un tuple :

tuple(T1, T2, ...)

Exemple de création d’un tuple :

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

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

Un Tuple peut contenir un seul élément

Exemple :

SELECT tuple('a') AS x;

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

La syntaxe (tuple_element1, tuple_element2) peut être utilisée pour créer un tuple comportant plusieurs éléments sans appeler la fonction tuple().

Exemple :

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

​

Détection du type de données

Lors de la création de tuples à la volée, ClickHouse déduit le type des arguments du tuple en choisissant les types les plus petits capables de contenir la valeur fournie. Si la valeur est NULL, le type déduit est Nullable.

Exemple de détection automatique du type de données :

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

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

​

Référence aux éléments d’un Tuple

On peut faire référence aux éléments d’un Tuple par leur nom ou leur indice :

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; -- by name
SELECT a.2 FROM named_tuples; -- by index

Response

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

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

​

Opérations de comparaison avec Tuple

Deux tuples sont comparés en examinant successivement leurs éléments de gauche à droite. Si le premier élément du premier tuple est supérieur (inférieur) à l’élément correspondant du second tuple, alors le premier tuple est supérieur (inférieur) au second ; sinon (si les deux éléments sont égaux), on compare l’élément suivant.

Exemple :

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

Exemples concrets :

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

-- Let's find a value for each key with the biggest duration, if durations are equal, select the biggest value

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

Permet au tuple dans son ensemble d’être NULL, contrairement à Tuple(Nullable(T1), Nullable(T2), ...), où seuls les éléments individuels peuvent être NULL.

Type	Le tuple peut être NULL	Les éléments peuvent être NULL
Nullable(Tuple(String, Int64))	✅	❌
Tuple(Nullable(String), Nullable(Int64))	❌	✅

Exemple :

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