`](/fr/reference/settings/server-settings/settings#macros) du fichier de configuration et peuvent être utilisées pour distinguer les serveurs à l’aide de noms explicites, même si leurs noms d’hôte sont complexes.
Si la fonction est exécutée dans le contexte d’une table distribuée, elle génère une colonne normale avec des valeurs correspondant à chaque fragment.
**Syntaxe**
```sql theme={null}
getMacro(name)
```
**Arguments**
* `name` — Le nom de la macro à récupérer. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur de la macro spécifiée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT getMacro('test');
```
```response title=Response theme={null}
┌─getMacro('test')─┐
│ Value │
└──────────────────┘
```
## getMaxTableNameLengthForDatabase
Introduit dans : v25.1.0
Renvoie la longueur maximale d’un nom de table dans une base de données donnée.
**Syntaxe**
```sql theme={null}
getMaxTableNameLengthForDatabase(database_name)
```
**Arguments**
* `database_name` — Nom de la base de données spécifiée. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la longueur maximale d’un nom de table, sous forme d’entier
**Exemples**
**type**
```sql title=Query theme={null}
SELECT getMaxTableNameLengthForDatabase('default');
```
```response title=Response theme={null}
┌─getMaxTableNameLengthForDatabase('default')─┐
│ 206 │
└─────────────────────────────────────────────┘
```
## getMergeTreeSetting
Introduit dans : v25.6.0
Renvoie la valeur actuelle d’un paramètre MergeTree.
**Syntaxe**
```sql theme={null}
getMergeTreeSetting(setting_name)
```
**Arguments**
* `setting_name` — Nom du paramètre. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur actuelle du paramètre MergeTree.
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT getMergeTreeSetting('index_granularity');
```
```response title=Response theme={null}
┌─getMergeTreeSetting('index_granularity')─┐
│ 8192 │
└──────────────────────────────────────────┘
```
## getOSKernelVersion
Introduit dans : v21.11.0
Renvoie une chaîne de caractères contenant la version du noyau du système d’exploitation.
**Syntaxe**
```sql theme={null}
getOSKernelVersion()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la version actuelle du noyau du système d’exploitation. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT getOSKernelVersion();
```
```response title=Response theme={null}
┌─getOSKernelVersion()────┐
│ Linux 4.15.0-55-generic │
└─────────────────────────┘
```
## getServerPort
Introduit dans : v21.10.0
Renvoie le numéro de port du serveur pour un protocole donné.
**Syntaxe**
```sql theme={null}
getServerPort(port_name)
```
**Arguments**
* `port_name` — Le nom du port. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le numéro de port du serveur. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT getServerPort('tcp_port');
```
```response title=Response theme={null}
┌─getServerPort('tcp_port')─┐
│ 9000 │
└───────────────────────────┘
```
## getServerSetting
Introduit dans : v25.6.0
Renvoie la valeur actuellement définie pour le paramètre serveur indiqué.
**Syntaxe**
```sql theme={null}
getServerSetting(setting_name')
```
**Arguments**
* `setting_name` — Le nom du paramètre du serveur. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur actuelle du paramètre du serveur. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT getServerSetting('allow_use_jemalloc_memory');
```
```response title=Response theme={null}
┌─getServerSetting('allow_use_jemalloc_memory')─┐
│ true │
└───────────────────────────────────────────────┘
```
## getSetting
Introduit dans : v20.7.0
Renvoie la valeur actuelle d’un paramètre.
**Syntaxe**
```sql theme={null}
getSetting(setting_name)
```
**Arguments**
* `setting_Name` — Le nom du paramètre. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur actuelle du paramètre. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT getSetting('enable_analyzer');
SET enable_analyzer = false;
SELECT getSetting('enable_analyzer');
```
```response title=Response theme={null}
┌─getSetting('⋯_analyzer')─┐
│ true │
└──────────────────────────┘
┌─getSetting('⋯_analyzer')─┐
│ false │
└──────────────────────────┘
```
## getSettingOrDefault
Introduit dans : v24.10.0
Renvoie la valeur actuelle d’un paramètre, ou la valeur par défaut spécifiée dans le deuxième argument si le paramètre n’est pas défini dans le profil actuel.
**Syntaxe**
```sql theme={null}
getSettingOrDefault(setting_name, default_value)
```
**Arguments**
* `setting_name` — Le nom du paramètre. [`String`](/fr/reference/data-types/string)
* `default_value` — Valeur à renvoyer si custom\_setting n’est pas défini. La valeur peut être de n’importe quel type de données ou de NULL.
**Valeur renvoyée**
Renvoie la valeur actuelle du paramètre spécifié ou `default_value` si le paramètre n’est pas défini.
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT getSettingOrDefault('custom_undef1', 'my_value');
SELECT getSettingOrDefault('custom_undef2', 100);
SELECT getSettingOrDefault('custom_undef3', NULL);
```
```response title=Response theme={null}
my_value
100
NULL
```
## getSizeOfEnumType
Introduit dans : v1.1.0
Renvoie le nombre de champs de l’[`Enum`](/fr/reference/data-types/enum) donné.
**Syntaxe**
```sql theme={null}
getSizeOfEnumType(x)
```
**Arguments**
* `x` — Valeur de type `Enum`. [`Enum`](/fr/reference/data-types/enum)
**Valeur renvoyée**
Renvoie le nombre de champs dont les valeurs d’entrée sont de type `Enum`. [`UInt8/16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT getSizeOfEnumType(CAST('a' AS Enum8('a' = 1, 'b' = 2))) AS x;
```
```response title=Response theme={null}
┌─x─┐
│ 2 │
└───┘
```
## getSubcolumn
Introduit dans : v23.3.0
Reçoit l’expression ou l’identifiant, ainsi qu’une chaîne constante contenant le nom de la sous-colonne.
Renvoie la sous-colonne demandée extraite de l’expression.
**Syntaxe**
```sql theme={null}
getSubcolumn(nested_value, subcolumn_name)
```
**Arguments**
* Aucun.
**Valeur renvoyée**
**Exemples**
**getSubcolumn**
```sql title=Query theme={null}
SELECT getSubcolumn(array_col, 'size0'), getSubcolumn(tuple_col, 'elem_name')
```
```response title=Response theme={null}
```
## getTypeSerializationStreams
Introduit dans : v22.6.0
Répertorie les chemins des flux de sérialisation d’un type de données.
Cette fonction est destinée à un usage de développement.
**Syntaxe**
```sql theme={null}
getTypeSerializationStreams(col)
```
**Arguments**
* `col` — Colonne ou représentation sous forme de chaîne d’un type de données à partir de laquelle le type de données sera détecté. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie un tableau contenant tous les chemins des sous-flux de sérialisation. [`Array(String)`](/fr/reference/data-types/array)
**Exemples**
**tuple**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams(tuple('a', 1, 'b', 2))
```
```response title=Response theme={null}
['{TupleElement(1), Regular}','{TupleElement(2), Regular}','{TupleElement(3), Regular}','{TupleElement(4), Regular}']
```
**map**
```sql title=Query theme={null}
SELECT getTypeSerializationStreams('Map(String, Int64)')
```
```response title=Response theme={null}
['{ArraySizes}','{ArrayElements, TupleElement(keys), Regular}','{ArrayElements, TupleElement(values), Regular}']
```
## globalVariable
Introduit dans : v20.5.0
Prend un argument String constant et renvoie la valeur de la variable globale portant ce nom. Cette fonction est destinée à assurer la compatibilité avec MySQL et n'est ni nécessaire ni utile au fonctionnement normal de ClickHouse. Seules quelques variables globales factices sont définies.
**Syntaxe**
```sql theme={null}
globalVariable(name)
```
**Arguments**
* `name` — Nom de variable globale. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la valeur de la variable `name`. [`Any`](/fr/reference/data-types/index)
**Exemples**
**globalVariable**
```sql title=Query theme={null}
SELECT globalVariable('max_allowed_packet')
```
```response title=Response theme={null}
67108864
```
## hasColumnInTable
Introduit dans : v1.1.0
Vérifie si une colonne spécifique existe dans une table d’une base de données.
Pour les éléments d’une structure de données imbriquée, la fonction vérifie l’existence d’une colonne.
Pour la structure de données imbriquée elle-même, la fonction renvoie `0`.
**Syntaxe**
```sql theme={null}
hasColumnInTable([hostname[, username[, password]],]database, table, column)
```
**Arguments**
* `database` — Nom de la base de données. [`const String`](/fr/reference/data-types/string)
* `table` — Nom de la table. [`const String`](/fr/reference/data-types/string)
* `column` — Nom de la colonne. [`const String`](/fr/reference/data-types/string)
* `hostname` — Facultatif. Nom du serveur distant sur lequel effectuer la vérification. [`const String`](/fr/reference/data-types/string)
* `username` — Facultatif. Nom d'utilisateur du serveur distant. [`const String`](/fr/reference/data-types/string)
* `password` — Facultatif. Mot de passe du serveur distant. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la colonne indiquée existe, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Vérifier l'existence d'une colonne**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','metric')
```
```response title=Response theme={null}
1
```
**Vérifier une colonne qui n’existe pas**
```sql title=Query theme={null}
SELECT hasColumnInTable('system','metrics','non-existing_column')
```
```response title=Response theme={null}
0
```
## hasThreadFuzzer
Introduit dans : v20.6.0
Indique si le thread fuzzer est activé.
Cette fonction n’est utile que pour les tests et le débogage.
**Syntaxe**
```sql theme={null}
hasThreadFuzzer()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Indique si le Thread Fuzzer est actif. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Vérifier le statut du Thread Fuzzer**
```sql title=Query theme={null}
SELECT hasThreadFuzzer()
```
```response title=Response theme={null}
┌─hasThreadFuzzer()─┐
│ 0 │
└───────────────────┘
```
## highlightQuery
Introduit dans : v26.5.0
Analyse une chaîne de requête SQL ClickHouse et renvoie un tableau de plages mises en surbrillance pour la coloration syntaxique.
Chaque plage est un tuple nommé contenant la position de début (en octets), la position de fin et le type de surbrillance.
Les types de surbrillance décrivent le rôle syntaxique du fragment (mot-clé, identifiant, fonction, etc.)
et peuvent être utilisés pour attribuer des couleurs dans une UI. Dans les motifs de chaîne LIKE et REGEXP, les métacaractères
et les caractères d’échappement sont mis en surbrillance séparément.
**Syntaxe**
```sql theme={null}
highlightQuery(query)
```
**Arguments**
* `query` — Une chaîne de requête SQL ClickHouse. String.
**Valeur renvoyée**
Un tableau de tuples nommés `(begin UInt64, end UInt64, type Enum8(...))` représentant des plages mises en évidence. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/fr/reference/data-types/array)
**Exemples**
**simple**
```sql title=Query theme={null}
SELECT highlightQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'keyword'),(7,8,'number')]
```
## hostName
Introduit dans : v20.5.0
Renvoie le nom de l’hôte sur lequel cette fonction a été exécutée.
Si la fonction s’exécute sur un serveur distant (traitement distribué), le nom du serveur distant est renvoyé.
Si la fonction s’exécute dans le contexte d’une table distribuée, elle génère une colonne normale avec des valeurs correspondant à chaque shard.
Sinon, elle produit une valeur constante.
**Syntaxe**
```sql theme={null}
hostName()
```
**Alias** : `hostname`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le nom d’hôte. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT hostName()
```
```response title=Response theme={null}
┌─hostName()─┐
│ clickhouse │
└────────────┘
```
## icebergBucket
Introduit dans : v25.5.0
Implémente la logique de la [transformation bucket d’Iceberg](https://iceberg.apache.org/spec/#bucket-transform-details.)
**Syntaxe**
```sql theme={null}
icebergBucket(N, value)
```
**Arguments**
* `N` — Le nombre de buckets (modulo). [`const (U)Int*`](/fr/reference/data-types/int-uint)
* `value` — La valeur source à transformer. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Bool`](/fr/reference/data-types/boolean) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`UUID`](/fr/reference/data-types/uuid) ou [`Date`](/fr/reference/data-types/date) ou [`Time`](/fr/reference/data-types/time) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie un hachage de 32 bits de la valeur source. [`Int32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT icebergBucket(5, 1.0 :: Float32)
```
```response title=Response theme={null}
4
```
## icebergTruncate
Introduit dans : v25.3.0
Implémente la logique de la transformation TRUNCATE d’Iceberg : [https://iceberg.apache.org/spec/#truncate-transform-details](https://iceberg.apache.org/spec/#truncate-transform-details).
**Syntaxe**
```sql theme={null}
icebergTruncate(N, value)
```
**Arguments**
* `value` — La valeur à convertir. [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Le même type que l’argument
**Exemples**
**Exemple**
```sql title=Query theme={null}
SELECT icebergTruncate(3, 'iceberg')
```
```response title=Response theme={null}
ice
```
## identity
Introduit dans : v1.1.0
Cette fonction renvoie l’argument que vous lui passez, ce qui est utile pour le débogage et les tests. Elle vous permet de contourner l’utilisation des index afin d’observer à la place les performances d’un parcours complet. L’analyseur de requêtes ignore tout ce qui se trouve à l’intérieur des fonctions identity lorsqu’il recherche les index à utiliser, et désactive également le constant folding.
**Syntaxe**
```sql theme={null}
identity(x)
```
**Arguments**
* `x` — Valeur d’entrée. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la valeur d’entrée inchangée. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT identity(42)
```
```response title=Response theme={null}
42
```
## ignore
Introduit dans : v1.1.0
Accepte n’importe quels arguments et renvoie toujours `0`.
**Syntaxe**
```sql theme={null}
ignore(x)
```
**Arguments**
* `x` — Une valeur d’entrée non utilisée, transmise uniquement pour éviter une erreur de syntaxe. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie toujours `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT ignore(0, 'ClickHouse', NULL)
```
```response title=Response theme={null}
┌─ignore(0, 'ClickHouse', NULL)─┐
│ 0 │
└───────────────────────────────┘
```
## indexHint
Introduit dans : v1.1.0
Cette fonction est destinée au débogage et à l’introspection.
Elle ignore son argument et renvoie toujours 1.
Les arguments ne sont pas évalués.
Lors de l’analyse de l’index, on suppose que l’argument de cette fonction n’est pas encapsulé dans `indexHint`.
Cela vous permet de sélectionner des données dans des plages d’index à l’aide de la condition correspondante, mais sans filtrage supplémentaire sur cette condition.
L’index de ClickHouse est sparse, et l’utilisation de `indexHint` renverra plus de données que si vous spécifiez directement la même condition.
Lorsque vous exécutez :
```sql theme={null}
SELECT * FROM test WHERE key = 123;
```
ClickHouse effectue deux opérations :
1. Il utilise l’index pour trouver quelles granules (blocs d’environ 8192 lignes) peuvent contenir `key = 123`
2. Il lit ces granules et les filtre ligne par ligne pour ne renvoyer que les lignes où `key = 123`
Ainsi, même s’il lit 8 192 lignes sur disque, il ne renvoie que l’unique ligne qui correspond réellement.
Avec `indexHint`, lorsque vous exécutez :
```sql theme={null}
SELECT * FROM test WHERE indexHint(key = 123);
```
ClickHouse n’effectue qu’une seule opération :
1. Il utilise l’index pour trouver quelles granules peuvent contenir key = 123 et renvoie toutes les lignes de ces granules **sans** les filtrer.
Il renvoie les 8 192 lignes, y compris les lignes où `key = 456`, `key = 789`, etc. (Autrement dit, tout ce qui se trouvait stocké dans la même granule.)
`indexHint()` n’est pas fait pour améliorer les performances. Il sert au débogage et à comprendre comment fonctionne l’index de ClickHouse :
* Quelles granules ma condition sélectionne-t-elle ?
* Combien de lignes y a-t-il dans ces granules ?
* Mon index est-il utilisé efficacement ?
Remarque : il n’est pas possible d’optimiser une requête avec la fonction `indexHint`. La fonction `indexHint` n’optimise pas la requête, car elle ne fournit aucune information supplémentaire pour l’analyse de la requête. Mettre une expression à l’intérieur de la fonction `indexHint` n’est en aucun cas préférable à ne pas utiliser la fonction `indexHint`. La fonction `indexHint` ne peut être utilisée qu’à des fins d’introspection et de débogage, et n’améliore pas les performances. Si vous voyez `indexHint` utilisé par quelqu’un d’autre que les contributeurs de ClickHouse, il s’agit probablement d’une erreur et vous devriez le supprimer.
**Syntaxe**
```sql theme={null}
indexHint(expression)
```
**Arguments**
* `expression` — Toute expression utilisée pour la sélection de plages d’index. [`Expression`](/fr/reference/data-types/special-data-types/expression)
**Valeur renvoyée**
Renvoie `1` dans tous les cas. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation avec filtrage sur la date**
```sql title=Query theme={null}
SELECT FlightDate AS k, count() FROM ontime WHERE indexHint(k = '2025-09-15') GROUP BY k ORDER BY k ASC;
```
```response title=Response theme={null}
┌──────────k─┬─count()─┐
│ 2025-09-14 │ 7071 │
│ 2025-09-15 │ 16428 │
│ 2025-09-16 │ 1077 │
│ 2025-09-30 │ 8167 │
└────────────┴─────────┘
```
## initialQueryID
Introduit dans : v1.1.0
Renvoie l’ID de la requête initiale en cours.
D’autres paramètres d’une requête peuvent être extraits du champ `initial_query_id` de [`system.query_log`](/fr/reference/system-tables/query_log).
Contrairement à la fonction [`queryID`](/fr/reference/functions/regular-functions/other-functions#queryID), `initialQueryID` renvoie les mêmes résultats sur différents shards.
**Syntaxe**
```sql theme={null}
initialQueryID()
```
**Alias** : `initial_query_id`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’ID de la requête initiale. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initialQueryStartTime
Introduit dans : v25.4.0
Renvoie l'heure de début de la requête initiale en cours.
`initialQueryStartTime` renvoie les mêmes résultats sur différents shards.
**Syntaxe**
```sql theme={null}
initialQueryStartTime()
```
**Alias** : `initial_query_start_time`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’heure de début de la requête initiale en cours. [`DateTime`](/fr/reference/data-types/datetime)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT initialQueryStartTime() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 1 │
└───────────────────┘
```
## initializeAggregation
Introduit dans : v20.6.0
Calcule le résultat d’une fonction d’agrégation à partir d’une valeur unique.
Cette fonction peut être utilisée pour initialiser des fonctions d’agrégation avec le combinateur [-State](/fr/reference/functions/aggregate-functions/combinators#-state).
Vous pouvez créer des états de fonctions d’agrégation et les insérer dans des colonnes de type [`AggregateFunction`](/fr/reference/data-types/aggregatefunction), ou utiliser des agrégats initialisés comme valeurs par défaut.
**Syntaxe**
```sql theme={null}
initializeAggregation(aggregate_function, arg1[, arg2, ...])
```
**Arguments**
* `aggregate_function` — Nom de la fonction d’agrégation à initialiser. [`String`](/fr/reference/data-types/string)
* `arg1[, arg2, ...]` — Arguments de la fonction d’agrégation. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie le résultat de l’agrégation pour chaque ligne transmise à la fonction. Le type de retour est le même que celui de la fonction dont `initializeAggregation` prend le premier argument. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Utilisation de base avec uniqState**
```sql title=Query theme={null}
SELECT uniqMerge(state) FROM (SELECT initializeAggregation('uniqState', number % 3) AS state FROM numbers(10000));
```
```response title=Response theme={null}
┌─uniqMerge(state)─┐
│ 3 │
└──────────────────┘
```
**Utilisation de sumState et de finalizeAggregation**
```sql title=Query theme={null}
SELECT finalizeAggregation(state), toTypeName(state) FROM (SELECT initializeAggregation('sumState', number % 3) AS state FROM numbers(5));
```
```response title=Response theme={null}
┌─finalizeAggregation(state)─┬─toTypeName(state)─────────────┐
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
│ 2 │ AggregateFunction(sum, UInt8) │
│ 0 │ AggregateFunction(sum, UInt8) │
│ 1 │ AggregateFunction(sum, UInt8) │
└────────────────────────────┴───────────────────────────────┘
```
## isConstant
Introduit dans : v20.3.0
Indique si l’argument est une expression constante.
Une expression constante est une expression dont le résultat est connu lors de l’analyse de la requête, c’est-à-dire avant l’exécution.
Par exemple, les expressions construites à partir de [littéraux](/fr/reference/syntax#literals) sont des expressions constantes.
Cette fonction est principalement destinée au développement, au débogage et à la démonstration.
**Syntaxe**
```sql theme={null}
isConstant(x)
```
**Arguments**
* `x` — Une expression à vérifier. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie `1` si `x` est constante, `0` si `x` ne l'est pas. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Expression constante**
```sql title=Query theme={null}
SELECT isConstant(x + 1)
FROM (SELECT 43 AS x)
```
```response title=Response theme={null}
┌─isConstant(plus(x, 1))─┐
│ 1 │
└────────────────────────┘
```
**Constante avec une fonction**
```sql title=Query theme={null}
WITH 3.14 AS pi
SELECT isConstant(cos(pi))
```
```response title=Response theme={null}
┌─isConstant(cos(pi))─┐
│ 1 │
└─────────────────────┘
```
**Expression non constante**
```sql title=Query theme={null}
SELECT isConstant(number)
FROM numbers(1)
```
```response title=Response theme={null}
┌─isConstant(number)─┐
│ 0 │
└────────────────────┘
```
**Comportement de la fonction now()**
```sql title=Query theme={null}
SELECT isConstant(now())
```
```response title=Response theme={null}
┌─isConstant(now())─┐
│ 1 │
└───────────────────┘
```
## isDecimalOverflow
Introduit dans : v20.8.0
Vérifie si un nombre décimal comporte trop de chiffres pour être correctement représenté dans un type de données Decimal avec la précision donnée.
**Syntaxe**
```sql theme={null}
isDecimalOverflow(value[, precision])
```
**Arguments**
* `value` — Valeur Decimal à vérifier. [`Decimal`](/fr/reference/data-types/decimal)
* `precision` — Facultatif. Précision du type Decimal. Si elle est omise, la précision initiale du premier argument est utilisée. [`UInt8`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie `1` si la valeur décimale comporte plus de chiffres que n’en autorise sa précision, `0` si la valeur décimale respecte la précision spécifiée. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT isDecimalOverflow(toDecimal32(1000000000, 0), 9),
isDecimalOverflow(toDecimal32(1000000000, 0)),
isDecimalOverflow(toDecimal32(-1000000000, 0), 9),
isDecimalOverflow(toDecimal32(-1000000000, 0));
```
```response title=Response theme={null}
┌─isDecimalOverflow(toDecimal32(1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(1000000000, 0))─┬─isDecimalOverflow(toDecimal32(-1000000000, 0), 9)─┬─isDecimalOverflow(toDecimal32(-1000000000, 0))─┐
│ 1 │ 1 │ 1 │ 1 │
└──────────────────────────────────────────────────┴───────────────────────────────────────────────┴───────────────────────────────────────────────────┴────────────────────────────────────────────────┘
```
## joinGet
Introduit dans : v18.16.0
Permet d’extraire des données d’une table de la même manière que depuis un dictionnaire.
Récupère des données à partir de tables Join à l’aide de la clé de jointure spécifiée.
Prend uniquement en charge les tables créées avec l’`ENGINE = Join(ANY, LEFT, )` [instruction](/fr/reference/engines/table-engines/special/join).
**Syntaxe**
```sql theme={null}
joinGet(join_storage_table_name, value_column, join_keys)
```
**Arguments**
* `join_storage_table_name` — Un identifiant qui indique où rechercher. L’identifiant est recherché dans la base de données `default` (voir le paramètre `default_database` dans le fichier de configuration). Pour remplacer la base de données par défaut, utilisez la requête `USE database_name` ou précisez la base de données et la table en les séparant par un point, comme `database_name.table_name`. [`String`](/fr/reference/data-types/string)
* `value_column` — Le nom de la colonne de la table qui contient les données requises. [`const String`](/fr/reference/data-types/string)
* `join_keys` — Une liste de clés de jointure. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une liste de valeurs correspondant à la liste des clés. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGet(db_test.id_val, 'val', toUInt32(1));
```
```response title=Response theme={null}
┌─joinGet(db_test.id_val, 'val', toUInt32(1))─┐
│ 11 │
└─────────────────────────────────────────────┘
```
**Utilisation avec une table de la base de données courante**
```sql title=Query theme={null}
USE db_test;
SELECT joinGet(id_val, 'val', toUInt32(2));
```
```response title=Response theme={null}
┌─joinGet(id_val, 'val', toUInt32(2))─┐
│ 12 │
└─────────────────────────────────────┘
```
**Utiliser des tableaux comme clés de jointure**
```sql title=Query theme={null}
CREATE TABLE some_table (id1 UInt32, id2 UInt32, name String) ENGINE = Join(ANY, LEFT, id1, id2);
INSERT INTO some_table VALUES (1, 11, 'a') (2, 12, 'b') (3, 13, 'c');
SELECT joinGet(some_table, 'name', 1, 11);
```
```response title=Response theme={null}
┌─joinGet(some_table, 'name', 1, 11)─┐
│ a │
└────────────────────────────────────┘
```
## joinGetOrNull
Introduit dans : v20.4.0
Permet d’extraire des données d’une table de la même manière que depuis un dictionnaire.
Récupère des données depuis des tables Join à l’aide de la clé de jointure spécifiée.
Contrairement à [`joinGet`](#joinGet), renvoie `NULL` lorsque la clé est absente.
Prend uniquement en charge les tables créées avec l’[instruction](/fr/reference/engines/table-engines/special/join) `ENGINE = Join(ANY, LEFT, )`.
**Syntaxe**
```sql theme={null}
joinGetOrNull(join_storage_table_name, value_column, join_keys)
```
**Arguments**
* `join_storage_table_name` — Un identifiant qui indique où effectuer la recherche. L’identifiant est recherché dans la base de données `default` (voir le paramètre default\_database dans le fichier de configuration). Pour remplacer la base de données par défaut, utilisez la requête `USE database_name` ou indiquez la base de données et la table en les séparant par un point, comme `database_name.table_name`. [`String`](/fr/reference/data-types/string)
* `value_column` — Le nom de la colonne de la table qui contient les données requises. [`const String`](/fr/reference/data-types/string)
* `join_keys` — Une liste de clés de jointure. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une liste de valeurs correspondant à la liste des clés, ou `NULL` si une clé est introuvable. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id);
INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13);
SELECT joinGetOrNull(db_test.id_val, 'val', toUInt32(1)), joinGetOrNull(db_test.id_val, 'val', toUInt32(999));
```
```response title=Response theme={null}
┌─joinGetOrNull(db_test.id_val, 'val', toUInt32(1))─┬─joinGetOrNull(db_test.id_val, 'val', toUInt32(999))─┐
│ 11 │ ᴺᵁᴸᴸ │
└───────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘
```
## lowCardinalityIndices
Introduit dans : v18.12.0
Renvoie la position d’une valeur dans le dictionnaire d’une colonne [LowCardinality](/fr/reference/data-types/lowcardinality). Les positions commencent à 1. Comme LowCardinality utilise des dictionnaires propres à chaque part, cette fonction peut renvoyer des positions différentes pour une même valeur selon les parts.
**Syntaxe**
```sql theme={null}
lowCardinalityIndices(col)
```
**Arguments**
* `col` — Une colonne à faible cardinalité. [`LowCardinality`](/fr/reference/data-types/lowcardinality)
**Valeur renvoyée**
La position de la valeur dans le dictionnaire de la part actuelle. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemples d'utilisation**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- create two parts:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityIndices(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityIndices(s)─┐
│ ab │ 1 │
│ cd │ 2 │
│ ab │ 1 │
│ ab │ 1 │
│ df │ 3 │
└────┴──────────────────────────┘
┌─s──┬─lowCardinalityIndices(s)─┐
│ ef │ 1 │
│ cd │ 2 │
│ ab │ 3 │
│ cd │ 2 │
│ ef │ 1 │
└────┴──────────────────────────┘
```
## lowCardinalityKeys
Introduit dans : v18.12.0
Renvoyer les valeurs du dictionnaire d’une colonne [LowCardinality](/fr/reference/data-types/lowcardinality).
Si le bloc est plus petit ou plus grand que la taille du dictionnaire, le résultat sera tronqué ou complété avec des valeurs par défaut.
Comme LowCardinality utilise des dictionnaires par part, cette fonction peut renvoyer des valeurs de dictionnaire différentes d’une part à l’autre.
**Syntaxe**
```sql theme={null}
lowCardinalityKeys(col)
```
**Arguments**
* `col` — Une colonne à faible cardinalité. [`LowCardinality`](/fr/reference/data-types/lowcardinality)
**Valeur renvoyée**
Renvoie les clés du dictionnaire. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**lowCardinalityKeys**
```sql title=Query theme={null}
DROP TABLE IF EXISTS test;
CREATE TABLE test (s LowCardinality(String)) ENGINE = Memory;
-- create two parts:
INSERT INTO test VALUES ('ab'), ('cd'), ('ab'), ('ab'), ('df');
INSERT INTO test VALUES ('ef'), ('cd'), ('ab'), ('cd'), ('ef');
SELECT s, lowCardinalityKeys(s) FROM test;
```
```response title=Response theme={null}
┌─s──┬─lowCardinalityKeys(s)─┐
│ ef │ │
│ cd │ ef │
│ ab │ cd │
│ cd │ ab │
│ ef │ │
└────┴───────────────────────┘
┌─s──┬─lowCardinalityKeys(s)─┐
│ ab │ │
│ cd │ ab │
│ ab │ cd │
│ ab │ df │
│ df │ │
└────┴───────────────────────┘
```
## materialize
Introduit dans : v1.1.0
Transforme une constante en une colonne complète contenant une seule valeur.
Les colonnes complètes et les constantes sont représentées différemment en mémoire.
Les fonctions exécutent généralement un code différent pour les arguments normaux et constants, même si le résultat devrait en principe être le même.
Cette fonction peut être utilisée pour déboguer ce comportement.
**Syntaxe**
```sql theme={null}
materialize(x)
```
**Arguments**
* `x` — Une constante. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une colonne complète contenant la valeur constante. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
-- In the example below the `countMatches` function expects a constant second argument.
-- This behaviour can be debugged by using the `materialize` function to turn a constant into a full column,
-- verifying that the function throws an error for a non-constant argument.
SELECT countMatches('foobarfoo', 'foo');
SELECT countMatches('foobarfoo', materialize('foo'));
```
```response title=Response theme={null}
2
Code: 44. DB::Exception: Received from localhost:9000. DB::Exception: Illegal type of argument #2 'pattern' of function countMatches, expected constant String, got String
```
## minSampleSizeContinuous
Introduit dans : v23.10.0
Calcule la taille d’échantillon minimale requise pour un test A/B comparant les moyennes d’une métrique continue dans deux échantillons.
Utilise la formule décrite dans [cet article](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a).
Suppose des tailles égales pour les groupes de traitement et témoin.
Renvoie la taille d’échantillon requise pour un groupe (c’est-à-dire que la taille d’échantillon requise pour l’ensemble de l’expérience est égale à deux fois la valeur renvoyée).
Suppose également une variance égale de la métrique testée dans les groupes de traitement et témoin.
**Syntaxe**
```sql theme={null}
minSampleSizeContinuous(baseline, sigma, mde, power, alpha)
```
**Alias** : `minSampleSizeContinous`
**Arguments**
* `baseline` — Valeur de référence d'une métrique. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `sigma` — Écart type de référence d'une métrique. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `mde` — Effet minimal détectable (MDE) en pourcentage de la valeur de référence (par ex. pour une valeur de référence de 112.25, un MDE de 0.03 correspond à une variation attendue de 112.25 ± 112.25\*0.03). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `power` — Puissance statistique requise d'un test (1 - probabilité d'une erreur de type II). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
* `alpha` — Niveau de signification requis d'un test (probabilité d'une erreur de type I). [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie un Tuple nommé avec 3 éléments : `minimum_sample_size`, `detect_range_lower` et `detect_range_upper`. Il s'agit respectivement de la taille d'échantillon requise, de la borne inférieure de la plage de valeurs non détectables avec la taille d'échantillon requise renvoyée, calculée comme `baseline * (1 - mde)`, et de la borne supérieure de la plage de valeurs non détectables avec la taille d'échantillon requise renvoyée, calculée comme `baseline * (1 + mde)` (Float64). [`Tuple(Float64, Float64, Float64)`](/fr/reference/data-types/tuple)
**Exemples**
**minSampleSizeContinuous**
```sql title=Query theme={null}
SELECT minSampleSizeContinuous(112.25, 21.1, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(616.2931945826209,108.8825,115.6175)
```
## minSampleSizeConversion
Introduit dans : v22.6.0
Calcule la taille d’échantillon minimale requise pour un test A/B comparant les conversions (proportions) entre deux échantillons.
Utilise la formule décrite dans [cet article](https://towardsdatascience.com/required-sample-size-for-a-b-testing-6f6608dd330a). Suppose des tailles égales pour les groupes de traitement et témoin. Renvoie la taille d’échantillon requise pour un groupe (c.-à-d. que la taille d’échantillon requise pour l’ensemble de l’expérience est le double de la valeur renvoyée).
**Syntaxe**
```sql theme={null}
minSampleSizeConversion(baseline, mde, power, alpha)
```
**Arguments**
* `baseline` — Conversion de référence. [`Float*`](/fr/reference/data-types/float)
* `mde` — Effet minimal détectable (MDE), exprimé en points de pourcentage (par ex., pour une conversion de référence de 0.25, un MDE de 0.03 correspond à une variation attendue vers 0.25 ± 0.03). [`Float*`](/fr/reference/data-types/float)
* `power` — Puissance statistique requise pour un test (1 - probabilité d’erreur de type II). [`Float*`](/fr/reference/data-types/float)
* `alpha` — Niveau de signification requis pour un test (probabilité d’erreur de type I). [`Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie un Tuple nommé avec 3 éléments : `minimum_sample_size`, `detect_range_lower`, `detect_range_upper`. Il s’agit, respectivement, de la taille d’échantillon requise, de la borne inférieure de la plage de valeurs non détectables avec la taille d’échantillon requise renvoyée, calculée comme `baseline - mde`, et de la borne supérieure de la plage de valeurs non détectables avec la taille d’échantillon requise renvoyée, calculée comme `baseline + mde`. [`Tuple(Float64, Float64, Float64)`](/fr/reference/data-types/tuple)
**Exemples**
**minSampleSizeConversion**
```sql title=Query theme={null}
SELECT minSampleSizeConversion(0.25, 0.03, 0.80, 0.05) AS sample_size
```
```response title=Response theme={null}
(3396.077603219163,0.22,0.28)
```
## neighbor
Introduit dans : v20.1.0
Renvoie une valeur d’une colonne à l’offset spécifié par rapport à la ligne courante.
Cette fonction est déconseillée et sujette aux erreurs, car elle s’appuie sur l’ordre physique des blocs de données, qui peut ne pas correspondre à l’ordre logique attendu par les utilisateurs.
Envisagez plutôt d’utiliser de véritables fonctions de fenêtre.
La fonction peut être activée en définissant `allow_deprecated_error_prone_window_functions = 1`.
**Syntaxe**
```sql theme={null}
neighbor(column, offset[, default_value])
```
**Arguments**
* `column` — La colonne source. [`Any`](/fr/reference/data-types/index)
* `offset` — Le décalage par rapport à la ligne actuelle. Les valeurs positives portent vers l’avant, les valeurs négatives vers l’arrière. [`Integer`](/fr/reference/data-types/int-uint)
* `default_value` — Facultatif. Valeur à renvoyer si le décalage dépasse les limites des données. Si elle n’est pas spécifiée, la valeur par défaut du type de colonne est utilisée. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une valeur au décalage spécifié, ou la valeur par défaut si elle est hors limites. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 0 │
│ 9 │ 0 │
└────────┴─────────────────────┘
```
**Avec une valeur par défaut**
```sql title=Query theme={null}
SELECT number, neighbor(number, 2, 999) FROM system.numbers LIMIT 10;
```
```response title=Response theme={null}
┌─number─┬─neighbor(number, 2, 999)─┐
│ 0 │ 2 │
│ 1 │ 3 │
│ 2 │ 4 │
│ 3 │ 5 │
│ 4 │ 6 │
│ 5 │ 7 │
│ 6 │ 8 │
│ 7 │ 9 │
│ 8 │ 999 │
│ 9 │ 999 │
└────────┴──────────────────────────┘
```
## normalizeQuery
Introduit dans : v20.8.0
Remplace les littéraux, les suites de littéraux et les alias complexes (contenant des espaces, plus de deux chiffres ou d’au moins 36 octets, comme les UUID) par le caractère de substitution `?`.
**Syntaxe**
```sql theme={null}
normalizeQuery(x)
```
**Arguments**
* `x` — Séquence de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la séquence de caractères donnée avec des placeholders. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT normalizeQuery('[1, 2, 3, x]') AS query
```
```response title=Response theme={null}
┌─query────┐
│ [?.., x] │
└──────────┘
```
## normalizeQueryKeepNames
Introduit dans : v21.2.0
Remplace les littéraux et les séquences de littéraux par le caractère de substitution `?`, mais ne remplace pas les alias complexes (contenant des espaces, plus de deux chiffres ou d’une longueur d’au moins 36 octets, comme les UUIDs).
Cela permet de mieux analyser les journaux de requêtes complexes.
**Syntaxe**
```sql theme={null}
normalizeQueryKeepNames(x)
```
**Arguments**
* `x` — Séquence de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie la séquence de caractères donnée avec des marqueurs de substitution. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT normalizeQuery('SELECT 1 AS aComplexName123'), normalizeQueryKeepNames('SELECT 1 AS aComplexName123')
```
```response title=Response theme={null}
┌─normalizeQuery('SELECT 1 AS aComplexName123')─┬─normalizeQueryKeepNames('SELECT 1 AS aComplexName123')─┐
│ SELECT ? AS `?` │ SELECT ? AS aComplexName123 │
└───────────────────────────────────────────────┴────────────────────────────────────────────────────────┘
```
## normalizedQueryHash
Introduit dans : v20.8.0
Renvoie des valeurs de hachage 64 bits identiques, sans les valeurs des littéraux, pour des requêtes similaires.
Peut être utile pour l’analyse des journaux de requêtes.
**Syntaxe**
```sql theme={null}
normalizedQueryHash(x)
```
**Arguments**
* `x` — Suite de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de hachage sur 64 bits. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res
```
```response title=Response theme={null}
┌─res─┐
│ 1 │
└─────┘
```
## normalizedQueryHashKeepNames
Introduit dans : v21.2.0
Comme [`normalizedQueryHash`](#normalizedQueryHash), elle renvoie des valeurs de hachage 64 bits identiques pour des requêtes similaires, sans les valeurs des littéraux, mais ne remplace pas les alias complexes (contenant des espaces, plus de deux chiffres ou d’une longueur d’au moins 36 octets, comme les UUID) par un caractère de substitution avant le hachage.
Peut être utile pour analyser les journaux de requêtes.
**Syntaxe**
```sql theme={null}
normalizedQueryHashKeepNames(x)
```
**Arguments**
* `x` — Séquence de caractères. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une valeur de hachage sur 64 bits. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT normalizedQueryHash('SELECT 1 AS `xyz123`') != normalizedQueryHash('SELECT 1 AS `abc123`') AS normalizedQueryHash;
SELECT normalizedQueryHashKeepNames('SELECT 1 AS `xyz123`') != normalizedQueryHashKeepNames('SELECT 1 AS `abc123`') AS normalizedQueryHashKeepNames;
```
```response title=Response theme={null}
┌─normalizedQueryHash─┐
│ 0 │
└─────────────────────┘
┌─normalizedQueryHashKeepNames─┐
│ 1 │
└──────────────────────────────┘
```
## obfuscateQuery
Introduit dans : v26.4.0
Masque une requête SQL en remplaçant les identifiants par des mots aléatoires et les littéraux par des valeurs aléatoires, tout en préservant la structure de la requête.
Cette fonction est utile pour anonymiser les requêtes avant de les consigner dans les logs ou de les partager à des fins de débogage.
Des lignes différentes produiront des résultats masqués différents, même pour la même requête en entrée, ce qui aide
à préserver la confidentialité lors du traitement de plusieurs requêtes.
Le paramètre facultatif `tag` empêche l’élimination des sous-expressions communes lorsque le même appel de fonction
est utilisé plusieurs fois dans une requête. Cela garantit que chaque appel produit un résultat masqué différent.
Fonctionnalités :
* Remplace les noms de table, les noms de colonnes et les alias par des mots aléatoires
* Remplace les littéraux numériques et textuels par des valeurs aléatoires
* Préserve la structure globale de la requête et la syntaxe SQL
* Produit des résultats différents pour des lignes différentes
**Syntaxe**
```sql theme={null}
obfuscateQuery(query[, tag])
```
**Arguments**
* `query` — La requête SQL à obfusquer. [`String`](/fr/reference/data-types/string)
* `tag` — Facultatif. Une valeur permettant d’éviter l’élimination des sous-expressions communes lorsque le même appel de fonction est utilisé plusieurs fois.
**Valeur renvoyée**
La requête obfusquée, dans laquelle les identifiants et les littéraux sont remplacés tout en préservant la structure d’origine de la requête. [`String`](/fr/reference/data-types/string)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT name, age FROM users WHERE age > 30')
```
```response title=Response theme={null}
SELECT fruit, number FROM table WHERE number > 12
```
**Avec un tag pour éviter l'élimination des sous-expressions communes**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT * FROM t', 1), obfuscateQuery('SELECT * FROM t', 2)
```
```response title=Response theme={null}
SELECT a FROM b, SELECT c FROM d
```
**Des lignes différentes donnent des résultats différents**
```sql title=Query theme={null}
SELECT obfuscateQuery('SELECT 1') AS a, obfuscateQuery('SELECT 1') AS b
```
```response title=Response theme={null}
A B
```
## obfuscateQueryWithSeed
Introduite dans : v26.4.0
Obfusque une requête SQL à l’aide d’une seed spécifiée afin d’obtenir des résultats déterministes.
Contrairement à `obfuscateQuery()`, cette fonction produit des résultats déterministes lorsqu’elle reçoit la même seed.
Cela est utile lorsque vous avez besoin d’une obfuscation constante sur plusieurs exécutions, ou lorsque vous souhaitez
reproduire la même requête obfusquée à des fins de test ou de débogage.
Fonctionnalités :
* Obfuscation déterministe basée sur la seed fournie
* La même seed produit toujours le même résultat obfusqué
* Des seeds différentes produisent des résultats différents
* Préserve la structure de la requête, comme `obfuscateQuery()`
Cas d’utilisation :
* Cas de test reproductibles
* Anonymisation constante sur plusieurs exécutions
* Débogage avec des requêtes obfusquées cohérentes
**Syntaxe**
```sql theme={null}
obfuscateQueryWithSeed(query, seed)
```
**Arguments**
* `query` — La requête SQL à obfusquer. [`String`](/fr/reference/data-types/string)
* `seed` — La valeur d'initialisation pour l'obfuscation. La même valeur d'initialisation produit des résultats déterministes. [`Integer`](/fr/reference/data-types/int-uint) ou [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
La requête obfusquée, générée de manière déterministe à partir de la valeur d'initialisation fournie. [`String`](/fr/reference/data-types/string)
**Exemples**
**Obfuscation déterministe avec une valeur d'initialisation entière**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT name FROM users', 42)
```
```response title=Response theme={null}
SELECT fruit FROM table
```
**Obfuscation déterministe avec une valeur d’initialisation de type chaîne**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT id, value FROM data', 'myseed')
```
```response title=Response theme={null}
SELECT a, b FROM c
```
**Même seed, même résultat**
```sql title=Query theme={null}
SELECT obfuscateQueryWithSeed('SELECT 1', 100) = obfuscateQueryWithSeed('SELECT 1', 100)
```
```response title=Response theme={null}
true
```
## parseReadableSize
Introduit dans : v24.6.0
À partir d’une chaîne contenant une taille en octets et `B`, `KiB`, `KB`, `MiB`, `MB`, etc. comme unité (c.-à-d. [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou unité décimale d’octets), cette fonction renvoie le nombre d’octets correspondant.
Si la fonction ne parvient pas à analyser la valeur d’entrée, elle lève une exception.
Les opérations inverses de cette fonction sont [`formatReadableSize`](#formatReadableSize) et [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Syntaxe**
```sql theme={null}
parseReadableSize(x)
```
**Arguments**
* `x` — Taille dans un format lisible avec ISO/IEC 80000-13 ou une unité décimale d’octets. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoyer le nombre d’octets, arrondi à l’entier supérieur le plus proche. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB']) AS readable_sizes, parseReadableSize(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
└────────────────┴─────────┘
```
## parseReadableSizeOrNull
Introduit dans : v24.6.0
Étant donnée une chaîne contenant une taille en octets et `B`, `KiB`, `KB`, `MiB`, `MB`, etc. comme unité (c.-à-d. [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou une unité d’octets décimale), cette fonction renvoie le nombre d’octets correspondant.
Si la fonction ne parvient pas à analyser la valeur d’entrée, elle renvoie `NULL`.
Les opérations inverses de cette fonction sont [`formatReadableSize`](#formatReadableSize) et [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Syntaxe**
```sql theme={null}
parseReadableSizeOrNull(x)
```
**Arguments**
* `x` — Taille en format lisible avec ISO/IEC 80000-13 ou une unité d’octets décimale. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre d’octets, arrondi à l’entier supérieur, ou `NULL` si l’entrée ne peut pas être interprétée [`Nullable(UInt64)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrNull(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ ᴺᵁᴸᴸ │
└────────────────┴─────────┘
```
## parseReadableSizeOrZero
Introduit dans : v24.6.0
Étant donnée une chaîne contenant une taille en octets avec `B`, `KiB`, `KB`, `MiB`, `MB`, etc. comme unité (c.-à-d. [ISO/IEC 80000-13](https://en.wikipedia.org/wiki/ISO/IEC_80000) ou unité d’octets décimale), cette fonction renvoie le nombre d’octets correspondant.
Si la fonction ne parvient pas à analyser la valeur d’entrée, elle renvoie `0`.
Les opérations inverses de cette fonction sont [`formatReadableSize`](#formatReadableSize) et [`formatReadableDecimalSize`](#formatReadableDecimalSize).
**Syntaxe**
```sql theme={null}
parseReadableSizeOrZero(x)
```
**Arguments**
* `x` — Taille lisible avec une unité de taille ISO/IEC 80000-13 ou une unité de taille décimale. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre d’octets, arrondi à l’entier supérieur le plus proche, ou `0` s’il est impossible d’analyser l’entrée. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT arrayJoin(['1 B', '1 KiB', '3 MB', '5.314 KiB', 'invalid']) AS readable_sizes, parseReadableSizeOrZero(readable_sizes) AS sizes;
```
```response title=Response theme={null}
┌─readable_sizes─┬───sizes─┐
│ 1 B │ 1 │
│ 1 KiB │ 1024 │
│ 3 MB │ 3000000 │
│ 5.314 KiB │ 5442 │
│ invalid │ 0 │
└────────────────┴─────────┘
```
## parseTimeDelta
Introduit dans : v22.7.0
Analyse une suite de nombres suivie d’un élément ressemblant à une unité de temps.
La chaîne de décalage temporel utilise les spécifications d’unité de temps suivantes :
* `years`, `year`, `yr`, `y`
* `months`, `month`, `mo`
* `weeks`, `week`, `w`
* `days`, `day`, `d`
* `hours`, `hour`, `hr`, `h`
* `minutes`, `minute`, `min`, `m`
* `seconds`, `second`, `sec`, `s`
* `milliseconds`, `millisecond`, `millisec`, `ms`
* `microseconds`, `microsecond`, `microsec`, `μs`, `µs`, `us`
* `nanoseconds`, `nanosecond`, `nanosec`, `ns`
Plusieurs unités de temps peuvent être combinées à l’aide de séparateurs (espace, `;`, `-`, `+`, `,`, `:`).
La durée des années et des mois est approximative : une année correspond à 365 jours et un mois à 30,5 jours.
**Syntaxe**
```sql theme={null}
parseTimeDelta(timestr)
```
**Arguments**
* `timestr` — Une suite de nombres suivie d’un élément ressemblant à une unité de temps. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Le nombre de secondes. [`Float64`](/fr/reference/data-types/float)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT parseTimeDelta('11s+22min')
```
```response title=Response theme={null}
┌─parseTimeDelta('11s+22min')─┐
│ 1331 │
└─────────────────────────────┘
```
**Unités temporelles complexes**
```sql title=Query theme={null}
SELECT parseTimeDelta('1yr2mo')
```
```response title=Response theme={null}
┌─parseTimeDelta('1yr2mo')─┐
│ 36806400 │
└──────────────────────────┘
```
## partitionId
Introduit dans : v21.4.0
Calcule l’[identifiant de partition](/fr/reference/engines/table-engines/mergetree-family/custom-partitioning-key).
Cette fonction est lente et ne doit pas être utilisée sur un grand nombre de lignes.
**Syntaxe**
```sql theme={null}
partitionId(column1[, column2, ...])
```
**Alias** : `partitionID`
**Arguments**
* `column1, column2, ...` — Colonne pour laquelle l'identifiant de partition doit être renvoyé.
**Valeur renvoyée**
Renvoie l'identifiant de partition de la ligne. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
DROP TABLE IF EXISTS tab;
CREATE TABLE tab
(
i int,
j int
)
ENGINE = MergeTree
PARTITION BY i
ORDER BY tuple();
INSERT INTO tab VALUES (1, 1), (1, 2), (1, 3), (2, 4), (2, 5), (2, 6);
SELECT i, j, partitionId(i), _partition_id FROM tab ORDER BY i, j;
```
```response title=Response theme={null}
┌─i─┬─j─┬─partitionId(i)─┬─_partition_id─┐
│ 1 │ 1 │ 1 │ 1 │
│ 1 │ 2 │ 1 │ 1 │
│ 1 │ 3 │ 1 │ 1 │
│ 2 │ 4 │ 2 │ 2 │
│ 2 │ 5 │ 2 │ 2 │
│ 2 │ 6 │ 2 │ 2 │
└───┴───┴────────────────┴───────────────┘
```
## queryID
Introduit dans : v21.9.0
Renvoie l’ID de la requête en cours.
Les autres paramètres d’une requête peuvent être extraits du champ `query_id` de la table [`system.query_log`](/fr/reference/system-tables/query_log).
Contrairement à la fonction [`initialQueryID`](#initialQueryID), `queryID` peut renvoyer des résultats différents selon les shards.
**Syntaxe**
```sql theme={null}
queryID()
```
**Alias** : `query_id`
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’identifiant de la requête en cours. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE tmp (str String) ENGINE = Log;
INSERT INTO tmp (*) VALUES ('a');
SELECT count(DISTINCT t) FROM (SELECT queryID() AS t FROM remote('127.0.0.{1..3}', currentDatabase(), 'tmp') GROUP BY queryID());
```
```response title=Response theme={null}
┌─count(DISTINCT t)─┐
│ 3 │
└───────────────────┘
```
## revision
Introduit dans : v22.7.0
Renvoie la révision actuelle du serveur ClickHouse.
**Syntaxe**
```sql theme={null}
revision()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la révision actuelle du serveur ClickHouse. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT revision()
```
```response title=Response theme={null}
┌─revision()─┐
│ 54485 │
└────────────┘
```
## rowNumberInAllBlocks
Introduit dans : v1.1.0
Renvoie un numéro de ligne unique pour chaque ligne traitée.
**Syntaxe**
```sql theme={null}
rowNumberInAllBlocks()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le numéro ordinal de la ligne dans le bloc de données, à partir de `0`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT rowNumberInAllBlocks()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
)
SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInAllBlocks()─┐
│ 0 │
│ 1 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 4 │
│ 5 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 2 │
│ 3 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 6 │
│ 7 │
└────────────────────────┘
┌─rowNumberInAllBlocks()─┐
│ 8 │
│ 9 │
└────────────────────────┘
```
## rowNumberInBlock
Introduit dans : v1.1.0
Pour chaque [bloc](/fr/resources/develop-contribute/introduction/architecture#block) traité par `rowNumberInBlock`, renvoie le numéro de la ligne courante.
Le numéro renvoyé commence à 0 pour chaque bloc.
**Syntaxe**
```sql theme={null}
rowNumberInBlock()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le numéro ordinal de la ligne dans le bloc de données, à partir de `0`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT rowNumberInBlock()
FROM
(
SELECT *
FROM system.numbers_mt
LIMIT 10
) SETTINGS max_block_size = 2
```
```response title=Response theme={null}
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
┌─rowNumberInBlock()─┐
│ 0 │
│ 1 │
└────────────────────┘
```
## runningAccumulate
Introduit dans : v1.1.0
Accumule les états d'une fonction d'agrégation pour chaque ligne d'un bloc de données.
**Obsolète**
L'état est réinitialisé pour chaque nouveau bloc de données.
En raison de ce comportement sujet aux erreurs, cette fonction est obsolète ; il est recommandé d'utiliser plutôt les [fonctions de fenêtre](/fr/reference/functions/window-functions/index).
Vous pouvez utiliser le paramètre [`allow_deprecated_error_prone_window_functions`](/fr/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) pour autoriser l'utilisation de cette fonction.
**Syntaxe**
```sql theme={null}
runningAccumulate(agg_state[, grouping])
```
**Arguments**
* `agg_state` — État de la fonction d’agrégation. [`AggregateFunction`](/fr/reference/data-types/aggregatefunction)
* `grouping` — Facultatif. Clé de regroupement. L’état de la fonction est réinitialisé si la valeur de `grouping` change. Il peut s’agir de n’importe quel type de données pris en charge pour lequel l’opérateur d’égalité est défini. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie le résultat accumulé pour chaque ligne. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation avec initializeAggregation**
```sql title=Query theme={null}
WITH initializeAggregation('sumState', number) AS one_row_sum_state
SELECT
number,
finalizeAggregation(one_row_sum_state) AS one_row_sum,
runningAccumulate(one_row_sum_state) AS cumulative_sum
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─one_row_sum─┬─cumulative_sum─┐
│ 0 │ 0 │ 0 │
│ 1 │ 1 │ 1 │
│ 2 │ 2 │ 3 │
│ 3 │ 3 │ 6 │
│ 4 │ 4 │ 10 │
└────────┴─────────────┴────────────────┘
```
## runningConcurrency
Introduite dans : v21.3.0
Calcule le nombre d’événements simultanés.
Chaque événement possède une heure de début et une heure de fin.
L’heure de début est incluse dans l’événement, tandis que l’heure de fin ne l’est pas.
Les colonnes contenant l’heure de début et l’heure de fin doivent être du même type de données.
La fonction calcule le nombre total d’événements actifs (simultanés) pour chaque heure de début d’événement.
**Prérequis**
Les événements doivent être triés par heure de début dans l’ordre croissant.
Si cette condition n’est pas respectée, la fonction génère une exception.
Chaque bloc de données est traité séparément.
Si des événements provenant de différents blocs de données se chevauchent, ils ne peuvent pas être traités correctement.
**Obsolète**
Il est recommandé d’utiliser plutôt les [fonctions de fenêtre](/fr/reference/functions/window-functions/index).
**Syntaxe**
```sql theme={null}
runningConcurrency(start, end)
```
**Arguments**
* `start` — Colonne contenant l'horodatage de début des événements. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
* `end` — Colonne contenant l'horodatage de fin des événements. [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`DateTime64`](/fr/reference/data-types/datetime64)
**Valeur renvoyée**
Renvoie le nombre d'événements simultanés pour chaque horodatage de début d'événement. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT start, runningConcurrency(start, end) FROM example_table;
```
```response title=Response theme={null}
┌──────start─┬─runningConcurrency(start, end)─┐
│ 2025-03-03 │ 1 │
│ 2025-03-06 │ 2 │
│ 2025-03-07 │ 3 │
│ 2025-03-11 │ 2 │
└────────────┴────────────────────────────────┘
```
## runningDifference
Introduit dans : v1.1.0
Calcule la différence entre les valeurs de deux lignes consécutives dans le bloc de données.
Renvoie `0` pour la première ligne, puis, pour les lignes suivantes, la différence par rapport à la ligne précédente.
**Obsolète**
Renvoie uniquement les différences à l’intérieur du bloc de données en cours de traitement.
En raison de ce comportement sujet aux erreurs, cette fonction est obsolète.
Il est recommandé d’utiliser à la place les [fonctions de fenêtre](/fr/reference/functions/window-functions/index).
Vous pouvez utiliser le paramètre [`allow_deprecated_error_prone_window_functions`](/fr/reference/settings/session-settings#allow_deprecated_error_prone_window_functions) pour autoriser l’utilisation de cette fonction.
Le résultat de la fonction dépend des blocs de données concernés et de l’ordre des données dans le bloc.
L’ordre des lignes lors du calcul de `runningDifference()` peut différer de l’ordre des lignes renvoyées à l’utilisateur.
Pour éviter cela, vous pouvez créer une sous-requête avec [`ORDER BY`](/fr/reference/statements/select/order-by) et appeler la fonction en dehors de la sous-requête.
Veuillez noter que la taille du bloc influe sur le résultat.
L’état interne de `runningDifference` est réinitialisé pour chaque nouveau bloc.
**Syntaxe**
```sql theme={null}
runningDifference(x)
```
**Arguments**
* `x` — Colonne pour laquelle calculer la différence entre valeurs consécutives. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la différence entre des valeurs consécutives, avec 0 pour la première ligne.
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
EventID,
EventTime,
runningDifference(EventTime) AS delta
FROM
(
SELECT
EventID,
EventTime
FROM events
WHERE EventDate = '2025-11-24'
ORDER BY EventTime ASC
LIMIT 5
);
```
```response title=Response theme={null}
┌─EventID─┬───────────EventTime─┬─delta─┐
│ 1106 │ 2025-11-24 00:00:04 │ 0 │
│ 1107 │ 2025-11-24 00:00:05 │ 1 │
│ 1108 │ 2025-11-24 00:00:05 │ 0 │
│ 1109 │ 2025-11-24 00:00:09 │ 4 │
│ 1110 │ 2025-11-24 00:00:10 │ 1 │
└─────────┴─────────────────────┴───────┘
```
**Exemple d’impact de la taille des blocs**
```sql title=Query theme={null}
SELECT
number,
runningDifference(number + 1) AS diff
FROM numbers(100000)
WHERE diff != 1;
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
└────────┴──────┘
┌─number─┬─diff─┐
│ 65536 │ 0 │
└────────┴──────┘
```
## runningDifferenceStartingWithFirstValue
Introduit dans : v1.1.0
Calcule la différence entre les valeurs de lignes consécutives dans un bloc de données, mais contrairement à [`runningDifference`](#runningDifference), cette fonction renvoie la valeur réelle de la première ligne au lieu de `0`.
**Obsolète**
Renvoie uniquement les différences à l’intérieur du bloc de données en cours de traitement.
En raison de ce comportement propice aux erreurs, cette fonction est obsolète.
Il est recommandé d’utiliser plutôt les [fonctions de fenêtre](/fr/reference/functions/window-functions/index).
Vous pouvez utiliser le paramètre `allow_deprecated_error_prone_window_functions` pour autoriser l’utilisation de cette fonction.
**Syntaxe**
```sql theme={null}
runningDifferenceStartingWithFirstValue(x)
```
**Arguments**
* `x` — Colonne pour laquelle calculer la différence entre valeurs consécutives. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la différence entre valeurs consécutives ; pour la première ligne, renvoie la valeur de cette ligne. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT
number,
runningDifferenceStartingWithFirstValue(number) AS diff
FROM numbers(5);
```
```response title=Response theme={null}
┌─number─┬─diff─┐
│ 0 │ 0 │
│ 1 │ 1 │
│ 2 │ 1 │
│ 3 │ 1 │
│ 4 │ 1 │
└────────┴──────┘
```
## serverUUID
Introduit dans : v20.1.0
Renvoie l’UUID (v4) aléatoire et unique généré au premier démarrage du serveur.
Cet UUID est conservé, c’est-à-dire que les deuxième, troisième, etc. démarrages du serveur renvoient le même UUID.
**Syntaxe**
```sql theme={null}
serverUUID()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’UUID aléatoire du serveur. [`UUID`](/fr/reference/data-types/uuid)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT serverUUID();
```
```response title=Response theme={null}
┌─serverUUID()─────────────────────────────┐
│ 7ccc9260-000d-4d5c-a843-5459abaabb5f │
└──────────────────────────────────────────┘
```
## shardCount
Introduit dans : v21.9.0
Renvoyer le nombre total de shards pour une requête distribuée.
Si une requête n'est pas distribuée, la valeur constante `0` est renvoyée.
**Syntaxe**
```sql theme={null}
shardCount()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le nombre total de shards, ou `0`. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
-- See shardNum() example above which also demonstrates shardCount()
CREATE TABLE shard_count_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT shardCount() FROM shard_count_example;
```
```response title=Response theme={null}
┌─shardCount()─┐
│ 2 │
│ 2 │
└──────────────┘
```
## shardNum
Introduit dans : v21.9.0
Renvoie l’indice du shard qui traite une partie des données dans une requête distribuée.
Les indices commencent à `1`.
Si une requête n’est pas distribuée, la valeur constante `0` est renvoyée.
**Syntaxe**
```sql theme={null}
shardNum()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’index du shard ou la constante `0`. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE shard_num_example (dummy UInt8)
ENGINE=Distributed(test_cluster_two_shards_localhost, system, one, dummy);
SELECT dummy, shardNum(), shardCount() FROM shard_num_example;
```
```response title=Response theme={null}
┌─dummy─┬─shardNum()─┬─shardCount()─┐
│ 0 │ 1 │ 2 │
│ 0 │ 2 │ 2 │
└───────┴────────────┴──────────────┘
```
## showCertificate
Introduit dans : v22.6.0
Affiche des informations sur le certificat Secure Sockets Layer (SSL) du serveur actuel, s’il est configuré.
Consultez [Configuration de TLS](/fr/concepts/features/security/tls/configuring-tls) pour plus d’informations sur la façon de configurer ClickHouse pour utiliser des certificats OpenSSL afin de valider les connexions.
**Syntaxe**
```sql theme={null}
showCertificate()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie une map de paires clé-valeur associées au certificat SSL configuré. [`Map(String, String)`](/fr/reference/data-types/map)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT showCertificate() FORMAT LineAsString;
```
```response title=Response theme={null}
{'version':'1','serial_number':'2D9071D64530052D48308473922C7ADAFA85D6C5','signature_algo':'sha256WithRSAEncryption','issuer':'/CN=marsnet.local CA','not_before':'May 7 17:01:21 2024 GMT','not_after':'May 7 17:01:21 2025 GMT','subject':'/CN=chnode1','pkey_algo':'rsaEncryption'}
```
## sleep
Introduit dans : v1.1.0
Suspend l’exécution d’une requête pendant le nombre de secondes indiqué.
La fonction est principalement utilisée à des fins de test et de débogage.
La fonction `sleep()` ne doit généralement pas être utilisée dans des environnements de production, car elle peut nuire aux performances des requêtes et à la réactivité du système.
Cependant, elle peut s’avérer utile dans les scénarios suivants :
1. **Test** : lors de tests ou de benchmarking de ClickHouse, vous pouvez vouloir simuler des délais ou introduire des pauses afin d’observer comment le système se comporte dans certaines conditions.
2. **Débogage** : si vous devez examiner l’état du système ou l’exécution d’une requête à un moment précis, vous pouvez utiliser `sleep()` pour introduire une pause, ce qui vous permet d’inspecter ou de collecter des informations pertinentes.
3. **Simulation** : dans certains cas, vous pouvez vouloir simuler des situations réelles où des délais ou des pauses se produisent, comme la latence réseau ou des dépendances à des systèmes externes.
Il est important d’utiliser la fonction `sleep()` avec discernement et uniquement lorsque cela est nécessaire, car elle peut affecter les performances globales et la réactivité de votre système ClickHouse.
Pour des raisons de sécurité, la fonction ne peut être exécutée que dans le profil utilisateur par défaut (avec `allow_sleep` activé).
**Syntaxe**
```sql theme={null}
sleep(seconds)
```
**Arguments**
* `seconds` — Le nombre de secondes pendant lequel suspendre l’exécution de la requête, dans la limite de 3 secondes. Il peut s’agir d’une valeur à virgule flottante pour spécifier des fractions de seconde. [`const UInt*`](/fr/reference/data-types/int-uint) ou [`const Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
-- This query will pause for 2 seconds before completing.
-- During this time, no results will be returned, and the query will appear to be hanging or unresponsive.
SELECT sleep(2);
```
```response title=Response theme={null}
┌─sleep(2)─┐
│ 0 │
└──────────┘
1 row in set. Elapsed: 2.012 sec.
```
## sleepEachRow
Introduit dans : v1.1.0
Met en pause l’exécution d’une requête pendant un nombre donné de secondes pour chaque ligne du jeu de résultats.
La fonction `sleepEachRow()` est principalement utilisée à des fins de test et de débogage, à l’instar de la fonction [`sleep()`](#sleep).
Elle permet de simuler des délais ou d’introduire des pauses dans le traitement de chaque ligne, ce qui peut être utile dans des scénarios tels que :
1. **Test** : lors de tests ou de benchmarks de performance de ClickHouse dans des conditions spécifiques, vous pouvez utiliser `sleepEachRow()` pour simuler des délais ou introduire des pauses pour chaque ligne traitée.
2. **Débogage** : si vous devez examiner l’état du système ou l’exécution d’une requête pour chaque ligne traitée, vous pouvez utiliser `sleepEachRow()` pour introduire des pauses et ainsi inspecter le système ou recueillir les informations pertinentes.
3. **Simulation** : dans certains cas, vous pouvez vouloir reproduire des scénarios réels dans lesquels des délais ou des pauses surviennent pour chaque ligne traitée, par exemple lors d’interactions avec des systèmes externes ou en présence de latences réseau.
Comme pour la fonction `sleep()`, il est important d’utiliser `sleepEachRow()` avec discernement et uniquement lorsque nécessaire, car elle peut affecter de manière significative les performances globales et la réactivité de votre système ClickHouse, en particulier avec des jeux de résultats volumineux.
**Syntaxe**
```sql theme={null}
sleepEachRow(seconds)
```
**Arguments**
* `seconds` — Le nombre de secondes pendant lequel l'exécution de la requête est mise en pause pour chaque ligne du jeu de résultats, avec un maximum de 3 secondes. Il peut s'agir d'une valeur à virgule flottante pour spécifier des fractions de seconde. [`const UInt*`](/fr/reference/data-types/int-uint) ou [`const Float*`](/fr/reference/data-types/float)
**Valeur renvoyée**
Renvoie `0` pour chaque ligne. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
-- The output will be delayed, with a 0.5-second pause between each row.
SELECT number, sleepEachRow(0.5) FROM system.numbers LIMIT 5;
```
```response title=Response theme={null}
┌─number─┬─sleepEachRow(0.5)─┐
│ 0 │ 0 │
│ 1 │ 0 │
│ 2 │ 0 │
│ 3 │ 0 │
│ 4 │ 0 │
└────────┴───────────────────┘
```
## structureToCapnProtoSchema
Introduit dans : v23.8.0
Fonction qui convertit la structure d’une table ClickHouse en schéma au format CapnProto
**Syntaxe**
```sql theme={null}
structureToCapnProtoSchema(table_structure, message)
```
**Arguments**
* Aucun.
**Valeur de retour**
**Exemples**
**random**
```sql title=Query theme={null}
SELECT structureToCapnProtoSchema('s String, x UInt32', 'MessageName') format TSVRaw
```
```response title=Response theme={null}
struct MessageName
{
s @0 : Data;
x @1 : UInt32;
}
```
## structureToProtobufSchema
Introduit dans : v23.8.0
Convertit la structure d’une table ClickHouse en schéma au format Protobuf.
Cette fonction prend une définition de structure de table ClickHouse et la convertit en définition de schéma Protocol Buffers (Protobuf)
en syntaxe proto3. Elle est utile pour générer des schémas Protobuf correspondant à la structure de vos tables ClickHouse
pour l’échange de données.
**Syntaxe**
```sql theme={null}
structureToProtobufSchema(structure, message_name)
```
**Arguments**
* `structure` — Définition de la structure d’une table ClickHouse sous forme de chaîne de caractères (par ex. 'column1 Type1, column2 Type2'). [`String`](/fr/reference/data-types/string)
* `message_name` — Nom du type de message Protobuf dans le schéma généré. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie une définition de schéma Protobuf en syntaxe proto3 correspondant à la structure ClickHouse en entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Conversion d’une structure ClickHouse en schéma Protobuf**
```sql title=Query theme={null}
SELECT structureToProtobufSchema('s String, x UInt32', 'MessageName') FORMAT TSVRaw;
```
```response title=Response theme={null}
syntax = "proto3";
message MessageName
{
bytes s = 1;
uint32 x = 2;
}
```
## tcpPort
Introduit dans : v20.12.0
Renvoie le numéro du port TCP de l’[interface native](/fr/concepts/features/interfaces/tcp) sur lequel le serveur écoute.
Si elle est exécutée dans le contexte d’une table distribuée, cette fonction génère une colonne ordinaire avec des valeurs propres à chaque shard.
Sinon, elle produit une valeur constante.
**Syntaxe**
```sql theme={null}
tcpPort()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le numéro du port TCP. [`UInt16`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT tcpPort()
```
```response title=Response theme={null}
┌─tcpPort()─┐
│ 9000 │
└───────────┘
```
## throwIf
Introduit dans : v1.1.0
Lève une exception si l’argument x est vrai.
Pour utiliser l’argument `error_code`, le paramètre de configuration `allow_custom_error_code_in_throw` doit être activé.
**Syntaxe**
```sql theme={null}
throwIf(x[, message[, error_code]])
```
**Arguments**
* `x` — La condition à vérifier. [`Any`](/fr/reference/data-types/index)
* `message` — Facultatif. Message d’erreur personnalisé. [`const String`](/fr/reference/data-types/string)
* `error_code` — Facultatif. Code d’erreur personnalisé. [`const Int8/16/32`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie `0` si la condition est false, et lève une exception si la condition est true. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT throwIf(number = 3, 'Too many') FROM numbers(10);
```
```response title=Response theme={null}
↙ Progress: 0.00 rows, 0.00 B (0.00 rows/s., 0.00 B/s.) Received exception from server (version 19.14.1):
Code: 395. DB::Exception: Received from localhost:9000. DB::Exception: Too many.
```
## toColumnTypeName
Introduit dans : v1.1.0
Renvoie le nom interne du type de données de la valeur donnée.
Contrairement à la fonction [`toTypeName`](#toTypeName), le type de données renvoyé peut inclure des colonnes d’encapsulation internes telles que `Const` et `LowCardinality`.
**Syntaxe**
```sql theme={null}
toColumnTypeName(value)
```
**Arguments**
* `value` — Valeur pour laquelle renvoyer le type de données interne. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie le type de données interne utilisé pour représenter la valeur. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT toColumnTypeName(CAST('2025-01-01 01:02:03' AS DateTime));
```
```response title=Response theme={null}
┌─toColumnTypeName(CAST('2025-01-01 01:02:03', 'DateTime'))─┐
│ Const(UInt32) │
└───────────────────────────────────────────────────────────┘
```
## toTypeName
Introduit dans : v1.1.0
Renvoie le nom du type de l’argument passé.
Si `NULL` est passé, la fonction renvoie le type `Nullable(Nothing)`, qui correspond à la représentation interne de `NULL` dans ClickHouse.
**Syntaxe**
```sql theme={null}
toTypeName(x)
```
**Arguments**
* `x` — Une valeur de type arbitraire. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie le nom du type de données de la valeur en entrée. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT toTypeName(123)
```
```response title=Response theme={null}
┌─toTypeName(123)─┐
│ UInt8 │
└─────────────────┘
```
## tokenizeQuery
Introduit dans : v26.5.0
Tokenise une chaîne de requête ClickHouse SQL et renvoie un tableau de tokens.
Chaque token est un tuple nommé comprenant la position de début (en octets), la position de fin et le type de token.
**Syntaxe**
```sql theme={null}
tokenizeQuery(query)
```
**Arguments**
* `query` — Une chaîne de requête en ClickHouse SQL. String.
**Valeur renvoyée**
Un tableau de tuples nommés `(begin UInt64, end UInt64, type Enum8(...))` représentant les jetons de la requête. [`Array(Tuple(begin UInt64, end UInt64, type Enum8(...)))`](/fr/reference/data-types/array)
**Exemples**
**simple**
```sql title=Query theme={null}
SELECT tokenizeQuery('SELECT 1')
```
```response title=Response theme={null}
[(0,6,'BareWord'),(6,7,'Whitespace'),(7,8,'Number')]
```
## transactionID
Introduit dans : v22.6.0
Renvoie l’ID d’une transaction.
Cette fonction fait partie d’un ensemble de fonctionnalités expérimentales.
Activez la prise en charge expérimentale des transactions en ajoutant ce paramètre à votre [configuration](/fr/concepts/features/configuration/server-config/configuration-files) :
```xml theme={null}
1
```
Pour plus d’informations, consultez la page [Prise en charge des transactions (ACID)](/fr/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Syntaxe**
```sql theme={null}
transactionID()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie un tuple composé de `start_csn`, `local_tid` et `host_id`.
* `start_csn` : Numéro séquentiel global, correspondant au timestamp de commit le plus récent observé au moment où cette transaction a commencé.
* `local_tid` : Numéro séquentiel local, unique pour chaque transaction lancée par cet hôte pour un `start_csn` donné.
* `host_id` : UUID de l'hôte qui a lancé cette transaction.
[`Tuple(UInt64, UInt64, UUID)`](/fr/reference/data-types/tuple)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionID();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionID()────────────────────────────────┐
│ (32,34,'0ee8b069-f2bb-4748-9eae-069c85b5252b') │
└────────────────────────────────────────────────┘
```
## transactionLatestSnapshot
Introduit dans : v22.6.0
Renvoie l’instantané le plus récent (Commit Sequence Number) d’une [transaction](/fr/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) disponible à la lecture.
Cette fonction fait partie d’un ensemble de fonctionnalités expérimentales. Activez la prise en charge expérimentale des transactions en ajoutant ce paramètre à votre configuration :
```xml theme={null}
1
```
Pour plus d’informations, consultez la page [Prise en charge des transactions (ACID)](/fr/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Syntaxe**
```sql theme={null}
transactionLatestSnapshot()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie l’instantané (CSN) le plus récent d’une transaction. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionLatestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionLatestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transactionOldestSnapshot
Introduit dans : v22.6.0
Renvoie l’instantané le plus ancien (Commit Sequence Number) visible par une [transaction](/fr/concepts/features/operations/insert/transactions#transactions-commit-and-rollback) en cours.
Cette fonction fait partie d’un ensemble de fonctionnalités expérimentales. Activez la prise en charge expérimentale des transactions en ajoutant ce paramètre à votre configuration :
```xml theme={null}
1
```
Pour plus d’informations, consultez la page [Prise en charge des transactions (ACID)](/fr/concepts/features/operations/insert/transactions#transactions-commit-and-rollback).
**Syntaxe**
```sql theme={null}
transactionOldestSnapshot()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie le plus ancien instantané (CSN) d’une transaction. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
BEGIN TRANSACTION;
SELECT transactionOldestSnapshot();
ROLLBACK;
```
```response title=Response theme={null}
┌─transactionOldestSnapshot()─┐
│ 32 │
└─────────────────────────────┘
```
## transform
Introduite dans : v1.1.0
Transforme une valeur selon une correspondance explicitement définie entre certains éléments et d’autres.
Il existe deux variantes de cette fonction :
* `transform(x, array_from, array_to, default)` - transforme `x` à l’aide de tableaux de correspondance, avec une valeur par défaut pour les éléments sans correspondance
* `transform(x, array_from, array_to)` - même transformation, mais renvoie la valeur d’origine de `x` si aucune correspondance n’est trouvée
La fonction recherche `x` dans `array_from` et renvoie l’élément correspondant de `array_to` au même indice.
Si `x` n’est pas trouvé dans `array_from`, elle renvoie soit la valeur `default` (version à 4 paramètres), soit la valeur d’origine de `x` (version à 3 paramètres).
Si plusieurs éléments correspondants existent dans `array_from`, elle renvoie l’élément associé à la première correspondance.
Exigences :
* `array_from` et `array_to` doivent contenir le même nombre d’éléments
* Pour la version à 4 paramètres : `transform(T, Array(T), Array(U), U) -> U` où `T` et `U` peuvent être des types compatibles différents
* Pour la version à 3 paramètres : `transform(T, Array(T), Array(T)) -> T` où tous les types doivent être identiques
**Syntaxe**
```sql theme={null}
transform(x, array_from, array_to[, default])
```
**Arguments**
* `x` — Valeur à transformer. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
* `array_from` — Tableau constant de valeurs dans lequel rechercher des correspondances. [`Array((U)Int*)`](/fr/reference/data-types/array) ou [`Array(Decimal)`](/fr/reference/data-types/array) ou [`Array(Float*)`](/fr/reference/data-types/array) ou [`Array(String)`](/fr/reference/data-types/array) ou [`Array(Date)`](/fr/reference/data-types/array) ou [`Array(DateTime)`](/fr/reference/data-types/array)
* `array_to` — Tableau constant de valeurs à renvoyer pour les correspondances dans `array_from`. [`Array((U)Int*)`](/fr/reference/data-types/array) ou [`Array(Decimal)`](/fr/reference/data-types/array) ou [`Array(Float*)`](/fr/reference/data-types/array) ou [`Array(String)`](/fr/reference/data-types/array) ou [`Array(Date)`](/fr/reference/data-types/array) ou [`Array(DateTime)`](/fr/reference/data-types/array)
* `default` — Facultatif. Valeur à renvoyer si `x` n'est pas trouvé dans `array_from`. S'il est omis, renvoie `x` inchangé. [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Decimal`](/fr/reference/data-types/decimal) ou [`Float*`](/fr/reference/data-types/float) ou [`String`](/fr/reference/data-types/string) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime)
**Valeur renvoyée**
Renvoie la valeur correspondante de `array_to` si `x` correspond à un élément de `array_from`, sinon renvoie `default` (s'il est fourni) ou `x` (si `default` n'est pas fourni). [`Any`](/fr/reference/data-types/index)
**Exemples**
**transform(T, Array(T), Array(U), U) -> U**
```sql title=Query theme={null}
SELECT
transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title,
count() AS c
FROM test.hits
WHERE SearchEngineID != 0
GROUP BY title
ORDER BY c DESC
```
```response title=Response theme={null}
┌─title─────┬──────c─┐
│ Yandex │ 498635 │
│ Google │ 229872 │
│ Other │ 104472 │
└───────────┴────────┘
```
**transform(T, Array(T), Array(T)) -> T**
```sql title=Query theme={null}
SELECT
transform(domain(Referer), ['yandex.ru', 'google.ru', 'vkontakte.ru'], ['www.yandex', 'example.com', 'vk.com']) AS s, count() AS c
FROM test.hits
GROUP BY domain(Referer)
ORDER BY count() DESC
LIMIT 10
```
```response title=Response theme={null}
┌─s──────────────┬───────c─┐
│ │ 2906259 │
│ www.yandex │ 867767 │
│ ███████.ru │ 313599 │
│ mail.yandex.ru │ 107147 │
│ ██████.ru │ 100355 │
│ █████████.ru │ 65040 │
│ news.yandex.ru │ 64515 │
│ ██████.net │ 59141 │
│ example.com │ 57316 │
└────────────────┴─────────┘
```
## uniqThetaIntersect
Introduit dans : v22.9.0
Deux objets uniqThetaSketch permettent d'effectuer un calcul d'intersection (opération ensembliste ∩) ; le résultat est un nouvel objet uniqThetaSketch.
**Syntaxe**
```sql theme={null}
uniqThetaIntersect(uniqThetaSketch,uniqThetaSketch)
```
**Arguments**
* `uniqThetaSketch` — objet uniqThetaSketch. [`Tuple`](/fr/reference/data-types/tuple) ou [`Array`](/fr/reference/data-types/array) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur de retour**
Un nouvel objet uniqThetaSketch contenant le résultat de l’intersection. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaIntersect(a, b)) AS a_intersect_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_intersect_b─┬─a_cardinality─┬─b_cardinality─┐
│ 1 │ 2 │ 3 │
└───────────────┴───────────────┴───────────────┘
```
## uniqThetaNot
Introduit dans : v22.9.0
Deux objets uniqThetaSketch permettant d’effectuer un calcul a\_not\_b (opération ensembliste ×) ; le résultat est un nouvel objet uniqThetaSketch.
**Syntaxe**
```sql theme={null}
uniqThetaNot(uniqThetaSketch,uniqThetaSketch)
```
**Arguments**
* `uniqThetaSketch` — objet uniqThetaSketch. [`Tuple`](/fr/reference/data-types/tuple) ou [`Array`](/fr/reference/data-types/array) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie un nouvel objet uniqThetaSketch contenant le résultat de a\_not\_b. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaNot(a, b)) AS a_not_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [2, 3, 4]) AS a, arrayReduce('uniqThetaState', [1, 2]) AS b);
```
```response title=Response theme={null}
┌─a_not_b─┬─a_cardinality─┬─b_cardinality─┐
│ 2 │ 3 │ 2 │
└─────────┴───────────────┴───────────────┘
```
## uniqThetaUnion
Introduit dans : v22.9.0
Prend deux objets uniqThetaSketch pour effectuer une union (opération ensembliste ∪) ; le résultat est un nouvel objet uniqThetaSketch.
**Syntaxe**
```sql theme={null}
uniqThetaUnion(uniqThetaSketch,uniqThetaSketch)
```
**Arguments**
* `uniqThetaSketch` — objet uniqThetaSketch. [`Tuple`](/fr/reference/data-types/tuple) ou [`Array`](/fr/reference/data-types/array) ou [`Date`](/fr/reference/data-types/date) ou [`DateTime`](/fr/reference/data-types/datetime) ou [`String`](/fr/reference/data-types/string) ou [`(U)Int*`](/fr/reference/data-types/int-uint) ou [`Float*`](/fr/reference/data-types/float) ou [`Decimal`](/fr/reference/data-types/decimal)
**Valeur renvoyée**
Renvoie un nouvel objet uniqThetaSketch contenant le résultat de l'union. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT finalizeAggregation(uniqThetaUnion(a, b)) AS a_union_b, finalizeAggregation(a) AS a_cardinality, finalizeAggregation(b) AS b_cardinality
FROM
(SELECT arrayReduce('uniqThetaState', [1, 2]) AS a, arrayReduce('uniqThetaState', [2, 3, 4]) AS b);
```
```response title=Response theme={null}
┌─a_union_b─┬─a_cardinality─┬─b_cardinality─┐
│ 4 │ 2 │ 3 │
└───────────┴───────────────┴───────────────┘
```
## durée de fonctionnement
Introduit dans : v1.1.0
Renvoie la durée de fonctionnement du serveur en secondes.
Si elle est exécutée dans le contexte d'une table distribuée, cette fonction génère une colonne normale avec des valeurs propres à chaque shard.
Sinon, elle renvoie une valeur constante.
**Syntaxe**
```sql theme={null}
uptime()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la durée de fonctionnement du serveur, en secondes. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT uptime() AS Uptime
```
```response title=Response theme={null}
┌─Uptime─┐
│ 55867 │
└────────┘
```
## variantElement
Introduit dans : v25.2.0
Extrait d’une colonne `Variant` une colonne du type spécifié.
**Syntaxe**
```sql theme={null}
variantElement(variant, type_name[, default_value])
```
**Arguments**
* `variant` — Colonne Variant. [`Variant`](/fr/reference/data-types/variant)
* `type_name` — Le nom du type de variante à extraire. [`String`](/fr/reference/data-types/string)
* `default_value` — La valeur par défaut utilisée si le variant ne contient pas de variante du type spécifié. Peut être de n’importe quel type. Facultatif. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie une colonne contenant le type de variante spécifié extrait de la colonne Variant. [`Any`](/fr/reference/data-types/index)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT v, variantElement(v, 'String'), variantElement(v, 'UInt64'), variantElement(v, 'Array(UInt64)') FROM test;
```
```response title=Response theme={null}
┌─v─────────────┬─variantElement(v, 'String')─┬─variantElement(v, 'UInt64')─┬─variantElement(v, 'Array(UInt64)')─┐
│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [] │
│ 42 │ ᴺᵁᴸᴸ │ 42 │ [] │
│ Hello, World! │ Hello, World! │ ᴺᵁᴸᴸ │ [] │
│ [1,2,3] │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ [1,2,3] │
└───────────────┴─────────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
```
## variantType
Introduit dans : v24.2.0
Renvoie le nom du type de variante pour chaque ligne d’une colonne `Variant`. Si une ligne contient NULL, la fonction renvoie 'None'.
**Syntaxe**
```sql theme={null}
variantType(variant)
```
**Arguments**
* `variant` — colonne Variant. [`Variant`](/fr/reference/data-types/variant)
**Valeur renvoyée**
Renvoie une colonne Enum contenant, pour chaque ligne, le nom du type de variante. [`Enum`](/fr/reference/data-types/enum)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
CREATE TABLE test (v Variant(UInt64, String, Array(UInt64))) ENGINE = Memory;
INSERT INTO test VALUES (NULL), (42), ('Hello, World!'), ([1, 2, 3]);
SELECT variantType(v) FROM test;
```
```response title=Response theme={null}
┌─variantType(v)─┐
│ None │
│ UInt64 │
│ String │
│ Array(UInt64) │
└────────────────┘
```
## version
Introduite dans : v1.1.0
Renvoie la version actuelle de ClickHouse sous la forme d’une chaîne au format : `major_version.minor_version.patch_version.number_of_commits_since_the_previous_stable_release`.
Si elle est exécutée dans le contexte d’une table distribuée, cette fonction génère une colonne normale avec des valeurs propres à chaque shard.
Sinon, elle renvoie une valeur constante.
**Syntaxe**
```sql theme={null}
version()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la version actuelle de ClickHouse. [`String`](/fr/reference/data-types/string)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT version()
```
```response title=Response theme={null}
┌─version()─┐
│ 24.2.1.1 │
└───────────┘
```
## visibleWidth
Introduit dans : v1.1.0
Calcule la largeur approximative lors de la sortie des valeurs dans la console au format texte (séparé par des tabulations).
Cette fonction est utilisée par le système pour implémenter les formats Pretty.
`NULL` est représenté sous la forme d'une chaîne correspondant à `NULL` dans les formats Pretty.
**Syntaxe**
```sql theme={null}
visibleWidth(x)
```
**Arguments**
* `x` — Une valeur de n’importe quel type de données. [`Any`](/fr/reference/data-types/index)
**Valeur renvoyée**
Renvoie la largeur approximative de la valeur lorsqu’elle est affichée au format texte. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Calcul de la largeur visible de NULL**
```sql title=Query theme={null}
SELECT visibleWidth(NULL)
```
```response title=Response theme={null}
┌─visibleWidth(NULL)─┐
│ 4 │
└────────────────────┘
```
## zookeeperSessionUptime
Introduite dans : v21.11.0
Renvoie la durée de fonctionnement de la session ZooKeeper actuelle, en secondes.
**Syntaxe**
```sql theme={null}
zookeeperSessionUptime()
```
**Arguments**
* Aucun.
**Valeur renvoyée**
Renvoie la durée de fonctionnement de la session ZooKeeper actuelle, en secondes. [`UInt32`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT zookeeperSessionUptime();
```
```response title=Response theme={null}
┌─zookeeperSessionUptime()─┐
│ 286 │
└──────────────────────────┘
```