Passer au contenu principal
La documentation ci-dessous est générée à partir de la table système system.functions.

​
dotProduct

Introduit dans : v21.11.0 Calcule le produit scalaire (ou produit interne) de deux vecteurs (tuples ou tableaux de même taille). Renvoie la somme des produits des éléments correspondants. Syntaxe 
dotProduct(vector1, vector2)
Alias : scalarProduct Arguments Valeur renvoyée Renvoie le produit scalaire des deux vecteurs. (U)Int* ou Float* ou Decimal Exemples Utilisation de base
Query
SELECT dotProduct((1, 2), (3, 4))
Response
11

​
flattenTuple

Introduit dans : v22.6.0 Aplatit un tuple nommé et imbriqué. Les éléments du tuple renvoyé correspondent aux chemins du tuple d’entrée. Syntaxe 
flattenTuple(input)
Arguments Valeur renvoyée Renvoie un tuple de sortie dont les éléments correspondent aux chemins de l’entrée d’origine. Tuple(T) Exemples Exemple d’utilisation
Query
CREATE TABLE tab(t Tuple(a UInt32, b Tuple(c String, d UInt32))) ENGINE = MergeTree ORDER BY tuple();
INSERT INTO tab VALUES ((3, ('c', 4)));

SELECT flattenTuple(t) FROM tab;
Response
┌─flattenTuple(t)┐
│ (3, 'c', 4)    │
└────────────────┘

​
tuple

Introduit dans : v1.1.0 Renvoie un tuple en regroupant les arguments d’entrée. Pour les colonnes C1, C2, … de types T1, T2, …, la fonction renvoie un tuple de type nommé Tuple(C1 T1, C2 T2, …) contenant ces colonnes si leurs noms sont uniques et peuvent être interprétés comme des identifiants non quotés ; sinon, elle renvoie un Tuple(T1, T2, …). L’exécution de la fonction n’entraîne aucun coût. Les tuples sont généralement utilisés comme valeurs intermédiaires pour un argument des opérateurs IN, ou pour créer une liste de paramètres formels de fonctions lambda. Les tuples ne peuvent pas être écrits dans une table. La fonction implémente l’opérateur (x, y, ...). Syntaxe 
tuple([t1[, t2[ ...]])
Arguments
  • Aucun.
Valeur renvoyée Exemples typique
Query
SELECT tuple(1, 2)
Response
(1,2)

​
tupleConcat

Introduit dans : v23.8.0 Concatène les tuples passés en arguments. Syntaxe 
tupleConcat(tuple1[, tuple2, [...]])
Arguments
  • tupleN — Nombre arbitraire d’arguments de type Tuple. Tuple(T)
Valeur renvoyée Renvoie un tuple contenant tous les éléments des tuples en entrée. Tuple(T) Exemples Exemple d’utilisation
Query
SELECT tupleConcat((1, 2), ('a',), (true, false))
Response
(1, 2, 'a', true, false)

​
tupleDivide

Introduit dans : v21.11.0 Calcule la division élément par élément de deux tuples de même taille ou plus, en l’appliquant de gauche à droite.
Une division par zéro renvoie inf.
Syntaxe 
tupleDivide(t1, t2[, tN, ...])
Arguments Valeur renvoyée Renvoie un tuple contenant les quotients calculés élément par élément. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tupleDivide((1, 2), (2, 3))
Response
(0.5, 0.6666666666666666)
Trois tuples
Query
SELECT tupleDivide((100.0, 60.0), (5.0, 3.0), (2.0, 4.0))
Response
(10, 5)

​
tupleDivideByNumber

Introduit dans : v21.11.0 Renvoie un tuple dont chaque élément est divisé par un nombre.
Une division par zéro renverra inf.
Syntaxe 
tupleDivideByNumber(tuple, number)
Arguments Valeur renvoyée Renvoie un tuple contenant les éléments divisés. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleDivideByNumber((1, 2), 0.5)
Response
(2, 4)

​
tupleElement

Introduit dans : v1.1.0 Extrait un élément d’un tuple par index ou par nom. Pour l’accès par index, un index numérique basé sur 1 est attendu. Pour l’accès par nom, le nom de l’élément peut être fourni sous forme de chaîne (fonctionne uniquement pour les tuples nommés). Les index négatifs sont pris en charge. Dans ce cas, l’élément correspondant est sélectionné en comptant depuis la fin. Par exemple, tuple.-1 est le dernier élément du tuple. Un troisième argument facultatif spécifie une valeur par défaut, qui est renvoyée au lieu de lever une exception lorsque l’élément demandé n’existe pas. Tous les arguments doivent être des constantes. Cette fonction n’a aucun coût à l’exécution et implémente les opérateurs x.index et x.name. Syntaxe 
tupleElement(tuple, index|name[, default_value])
Arguments
  • tuple — Un tuple ou un tableau de tuples. Tuple(T) ou Array(Tuple(T))
  • index — Indice de colonne, à partir de 1. const UInt8/16/32/64
  • name — Nom de l’élément. const String
  • default_value — Valeur par défaut renvoyée lorsque l’indice est hors limites ou que l’élément n’existe pas. Any
Valeur renvoyée Renvoie l’élément à l’indice ou au nom spécifié. Any Exemples Accès par index
Query
SELECT tupleElement((1, 'hello'), 2)
Response
hello
Indexation avec indices négatifs
Query
SELECT tupleElement((1, 'hello'), -1)
Response
hello
Tuple nommé avec une table
Query
CREATE TABLE example (values Tuple(name String, age UInt32)) ENGINE = Memory;
INSERT INTO example VALUES (('Alice', 30));
SELECT tupleElement(values, 'name') FROM example;
Response
Alice
Avec une valeur par défaut
Query
SELECT tupleElement((1, 2), 5, 'not_found')
Response
not_found
Syntaxe de l’opérateur
Query
SELECT (1, 'hello').2
Response
hello

​
tupleHammingDistance

Introduit dans : v21.1.0 Renvoie la distance de Hamming entre deux tuples de même taille.
Le type du résultat est déterminé de la même manière que pour les fonctions arithmétiques, en fonction du nombre d’éléments des tuples d’entrée.
SELECT
    toTypeName(tupleHammingDistance(tuple(0), tuple(0))) AS t1,
    toTypeName(tupleHammingDistance((0, 0), (0, 0))) AS t2,
    toTypeName(tupleHammingDistance((0, 0, 0), (0, 0, 0))) AS t3,
    toTypeName(tupleHammingDistance((0, 0, 0, 0), (0, 0, 0, 0))) AS t4,
    toTypeName(tupleHammingDistance((0, 0, 0, 0, 0), (0, 0, 0, 0, 0))) AS t5

┌─t1────┬─t2─────┬─t3─────┬─t4─────┬─t5─────┐
│ UInt8 │ UInt16 │ UInt32 │ UInt64 │ UInt64 │
└───────┴────────┴────────┴────────┴────────┘
Syntaxe 
tupleHammingDistance(t1, t2)
Arguments Valeur renvoyée Renvoie la distance de Hamming. UInt8/16/32/64 Exemples Exemple d’utilisation
Query
SELECT tupleHammingDistance((1, 2, 3), (3, 2, 1))
Response
2
Avec MinHash pour détecter les chaînes semi-dupliquées
Query
SELECT tupleHammingDistance(wordShingleMinHash(string), wordShingleMinHashCaseInsensitive(string)) FROM (SELECT 'ClickHouse is a column-oriented database management system for online analytical processing of queries.' AS string)
Response
2

​
tupleIntDiv

Introduit dans : v23.8.0 Effectue la division entière élément par élément de deux tuples ou plus de même taille, de gauche à droite. Renvoie un tuple de quotients. Si un tuple contient des éléments non entiers, le résultat est calculé en arrondissant chaque numérateur ou diviseur non entier à l’entier le plus proche. Une division par 0 entraîne une exception. Syntaxe 
tupleIntDiv(t1, t2[, tN, ...])
Arguments Valeur renvoyée Renvoie un tuple de quotients entiers. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tupleIntDiv((15, 10, 5), (5, 5, 5))
Response
(3, 2, 1)
Avec des valeurs Decimal
Query
SELECT tupleIntDiv((15, 10, 5), (5.5, 5.5, 5.5))
Response
(2, 1, 0)
Trois tuples
Query
SELECT tupleIntDiv((120, 60), (4, 3), (2, 4))
Response
(15, 5)

​
tupleIntDivByNumber

Introduit dans : v23.8.0 Effectue la division entière d’un tuple de numérateurs par un dénominateur donné et renvoie un tuple de quotients. Si l’un des paramètres d’entrée contient des éléments non entiers, le résultat est calculé en arrondissant à l’entier le plus proche chaque numérateur ou diviseur non entier. Une erreur est levée en cas de division par 0. Syntaxe 
tupleIntDivByNumber(tuple_num, div)
Arguments Valeur renvoyée Renvoie un tuple contenant les quotients. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleIntDivByNumber((15, 10, 5), 5)
Response
(3, 2, 1)
Avec des valeurs Decimal
Query
SELECT tupleIntDivByNumber((15.2, 10.7, 5.5), 5.8)
Response
(2, 1, 0)

​
tupleIntDivOrZero

Introduit dans : v23.8.0 Comme tupleIntDiv, effectue une division entière élément par élément sur deux tuples ou plus de même taille, en l’appliquant de gauche à droite. En cas de division par 0, renvoie 0 pour l’élément concerné au lieu de lever une exception. Si un tuple contient des éléments non entiers, le résultat est calculé en arrondissant à l’entier le plus proche chaque numérateur ou diviseur non entier. Syntaxe 
tupleIntDivOrZero(t1, t2[, tN, ...])
Arguments Valeur renvoyée Renvoie un tuple de quotients entiers, avec 0 pour chaque élément dont le diviseur est 0. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Avec des diviseurs nuls
Query
SELECT tupleIntDivOrZero((5, 10, 15), (0, 0, 0))
Response
(0, 0, 0)
Trois tuples
Query
SELECT tupleIntDivOrZero((120, 60), (4, 3), (2, 4))
Response
(15, 5)

​
tupleIntDivOrZeroByNumber

Introduit dans : v23.8.0 Comme tupleIntDivByNumber, cette fonction effectue la division entière d’un Tuple de numérateurs par un dénominateur donné et renvoie un Tuple de quotients. Elle ne génère pas d’erreur en cas de diviseur nul, mais renvoie à la place un quotient de zéro. Si le Tuple ou le diviseur contient des éléments non entiers, le résultat est calculé en arrondissant chaque numérateur ou diviseur non entier à l’entier le plus proche. Syntaxe 
tupleIntDivOrZeroByNumber(tuple_num, div)
Arguments Valeur renvoyée Renvoie un tuple des quotients, avec 0 pour ceux dont le diviseur est 0. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleIntDivOrZeroByNumber((15, 10, 5), 5)
Response
(3, 2, 1)
Avec un diviseur égal à zéro
Query
SELECT tupleIntDivOrZeroByNumber((15, 10, 5), 0)
Response
(0, 0, 0)

​
tupleMinus

Introduit dans : v21.11.0 Calcule, de gauche à droite, la différence élément par élément entre deux tuples ou plus de même taille. Syntaxe 
tupleMinus(t1, t2[, tN, ...])
Alias : vectorDifference Arguments Valeur renvoyée Renvoie un tuple contenant les différences élément par élément. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tupleMinus((1, 2), (2, 3))
Response
(-1, -1)
Trois tuples
Query
SELECT tupleMinus((10, 10), (3, 4), (2, 1))
Response
(5, 5)

​
tupleModulo

Introduit dans : v23.8.0 Renvoie un tuple de restes calculés élément par élément en divisant deux tuples ou plus de même taille, de gauche à droite. Syntaxe 
tupleModulo(t1, t2[, tN, ...])
Arguments Valeur renvoyée Renvoie un tuple de restes calculés élément par élément. Une exception est levée en cas de division par zéro. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tupleModulo((15, 10, 5), (5, 3, 2))
Response
(0, 1, 1)
Trois tuples
Query
SELECT tupleModulo((10, 20), (7, 9), (3, 5))
Response
(0, 2)

​
tupleModuloByNumber

Introduit dans : v23.8.0 Renvoie un tuple des modulos (restes) des divisions d’un tuple par un diviseur donné. Syntaxe 
tupleModuloByNumber(tuple_num, div)
Arguments Valeur renvoyée Renvoie un tuple contenant les restes de la division. Une erreur est générée en cas de division par zéro. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleModuloByNumber((15, 10, 5), 2)
Response
(1, 0, 1)

​
tupleMultiply

Introduit dans : v21.11.0 Calcule le produit élément par élément de deux tuples ou plus de même taille. Syntaxe 
tupleMultiply(t1, t2[, tN, ...])
Arguments Valeur renvoyée Renvoie un tuple contenant les produits élément par élément. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tupleMultiply((1, 2), (2, 3))
Response
(2, 6)
Trois tuples
Query
SELECT tupleMultiply((1, 2), (2, 3), (1, 2))
Response
(2, 12)

​
tupleMultiplyByNumber

Introduit dans : v21.11.0 Renvoie un tuple dont tous les éléments sont multipliés par un nombre. Syntaxe 
tupleMultiplyByNumber(tuple, number)
Arguments Valeur renvoyée Renvoie un tuple dont les éléments sont multipliés. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleMultiplyByNumber((1, 2), -2.1)
Response
(-2.1, -4.2)

​
tupleNames

Introduit dans : v24.8.0 Convertit un tuple en tableau de noms de colonnes. Pour un tuple de la forme Tuple(a T, b T, ...), renvoie un tableau de chaînes de caractères représentant les noms des colonnes du tuple. Si les éléments du tuple n’ont pas de noms explicites, leurs indices sont utilisés à la place comme noms de colonnes. Syntaxe 
tupleNames(tuple)
Arguments
  • Aucun.
Valeur renvoyée Exemples typique
Query
SELECT tupleNames(tuple(1 as a, 2 as b))
Response
['a','b']

​
tupleNegate

Introduit dans : v21.11.0 Calcule l’opposé des éléments du tuple. Syntaxe 
tupleNegate(t)
Arguments Valeur renvoyée Renvoie un tuple contenant le résultat de la négation. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tupleNegate((1, 2))
Response
(-1, -2)

​
tuplePlus

Introduit dans : v21.11.0 Calcule la somme élément par élément de deux tuples ou plus de taille identique. Syntaxe 
tuplePlus(t1, t2[, tN, ...])
Alias : vectorSum Arguments Valeur renvoyée Renvoie un tuple contenant les sommes calculées élément par élément. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Deux tuples
Query
SELECT tuplePlus((1, 2), (2, 3))
Response
(3, 5)
Trois tuples
Query
SELECT tuplePlus((1, 2), (2, 3), (3, 4))
Response
(6, 9)

​
tuplePositiveModuloByNumber

Introduit dans : v26.4.0 Renvoie un tuple des modulos positifs (restes) des divisions d’un tuple par un diviseur donné. Contrairement à tupleModuloByNumber, le résultat est toujours non négatif. Syntaxe 
tuplePositiveModuloByNumber(tuple_num, div)
Arguments Valeur renvoyée Renvoie un tuple de restes non négatifs. Tuple((U)Int*) ou Tuple(Float*) ou Tuple(Decimal) Exemples Utilisation de base
Query
SELECT tuplePositiveModuloByNumber((15, 10, 5), 2)
Response
(1, 0, 1)

​
tupleToNameValuePairs

Introduit dans : v21.9.0 Convertit un tuple en un tableau de paires (nom, valeur). Par exemple, le tuple Tuple(n1 T1, n2 T2, ...) est converti en Array(Tuple('n1', T1), Tuple('n2', T2), ...). Toutes les valeurs du tuple doivent être du même type. Syntaxe 
tupleToNameValuePairs(tuple)
Arguments Valeur renvoyée Renvoie un tableau de paires (name, value). Array(Tuple(String, T)) Exemples tuple nommé
Query
SELECT tupleToNameValuePairs(tuple(1593 AS user_ID, 2502 AS session_ID))
Response
[('1', 1593), ('2', 2502)]
Tuple non nommé
Query
SELECT tupleToNameValuePairs(tuple(3, 2, 1))
Response
[('1', 3), ('2', 2), ('3', 1)]

​
untuple

Effectue une substitution syntaxique des éléments tuple dans l’appel. Les noms des colonnes du résultat dépendent de l’implémentation et peuvent changer. Ne supposez pas de noms de colonnes spécifiques après untuple. Syntaxe 
untuple(x)
Vous pouvez utiliser l’expression EXCEPT pour exclure des colonnes du résultat de la requête. Arguments
  • x — Une fonction tuple, une colonne ou un tuple d’éléments. Tuple.
Valeur renvoyée
  • Aucune.
Exemples Table d’entrée : 
┌─key─┬─v1─┬─v2─┬─v3─┬─v4─┬─v5─┬─v6────────┐
│   1 │ 10 │ 20 │ 40 │ 30 │ 15 │ (33,'ab') │
│   2 │ 25 │ 65 │ 70 │ 40 │  6 │ (44,'cd') │
│   3 │ 57 │ 30 │ 20 │ 10 │  5 │ (55,'ef') │
│   4 │ 55 │ 12 │  7 │ 80 │ 90 │ (66,'gh') │
│   5 │ 30 │ 50 │ 70 │ 25 │ 55 │ (77,'kl') │
└─────┴────┴────┴────┴────┴────┴───────────┘
Exemple d’utilisation d’une colonne de type Tuple comme paramètre de la fonction untuple :
Query
SELECT untuple(v6) FROM kv;
Response
┌─_ut_1─┬─_ut_2─┐
│    33 │ ab    │
│    44 │ cd    │
│    55 │ ef    │
│    66 │ gh    │
│    77 │ kl    │
└───────┴───────┘
Exemple d’utilisation d’une expression EXCEPT :
Query
SELECT untuple((* EXCEPT (v2, v3),)) FROM kv;
Response
┌─key─┬─v1─┬─v4─┬─v5─┬─v6────────┐
│   1 │ 10 │ 30 │ 15 │ (33,'ab') │
│   2 │ 25 │ 40 │  6 │ (44,'cd') │
│   3 │ 57 │ 10 │  5 │ (55,'ef') │
│   4 │ 55 │ 80 │ 90 │ (66,'gh') │
│   5 │ 30 │ 25 │ 55 │ (77,'kl') │
└─────┴────┴────┴────┴───────────┘

​
Fonctions de distance

Toutes les fonctions prises en charge sont décrites dans la documentation sur les fonctions de distance.
Dernière modification le 25 juin 2026