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

​
alphaTokens

Introduit dans : v1.1.0 Sélectionne les sous-chaînes d’octets consécutifs dans les plages a-z et A-Z, et renvoie un tableau des sous-chaînes sélectionnées. Syntaxe 
alphaTokens(s[, max_substrings])
Alias : splitByAlpha Arguments
  • s — La chaîne à découper. String
  • max_substrings — Facultatif. Lorsque max_substrings > 0, le nombre de sous-chaînes renvoyées ne dépassera pas max_substrings ; sinon, la fonction renverra autant de sous-chaînes que possible. Int64
Valeur renvoyée Renvoie un tableau des sous-chaînes sélectionnées de s. Array(String) Exemples Exemple d’utilisation
Query
SELECT alphaTokens('abca1abc');
Response
┌─alphaTokens('abca1abc')─┐
│ ['abca','abc']          │
└─────────────────────────┘

​
arrayStringConcat

Introduit dans : v1.1.0 Concatène les représentations sous forme de chaîne des valeurs présentes dans le tableau à l’aide du séparateur fourni, qui est un paramètre facultatif défini par défaut comme une chaîne vide. Syntaxe 
arrayStringConcat(arr[, separator])
Alias : array_to_string Arguments
  • arr — Le tableau à concaténer. Array(T)
  • separator — Facultatif. Chaîne de séparation. Par défaut, une chaîne vide. const String
Valeur renvoyée Renvoie la chaîne concaténée. String Exemples Exemple d’utilisation
Query
SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString;
Response
┌─DateString──────────┐
│ 12/05/2021 12:50:00 │
└─────────────────────┘

​
extractAllGroupsVertical

Introduit dans : v20.5.0 Recherche toutes les correspondances de groupes dans une chaîne à l’aide d’une expression régulière et renvoie un tableau de tableaux, où chaque tableau contient les fragments correspondants de chaque groupe, regroupés selon leur ordre d’apparition dans la chaîne d’entrée. Syntaxe 
extractAllGroupsVertical(s, regexp)
Alias : extractAllGroups Arguments Valeur renvoyée Renvoie un tableau de tableaux, où chaque tableau interne contient les groupes capturés pour une correspondance. Chaque correspondance produit un tableau dont les éléments correspondent aux groupes de capture de l’expression régulière (groupe 1, groupe 2, etc.). Si aucune correspondance n’est trouvée, renvoie un tableau vide. Array(Array(String)) Exemples Exemple d’utilisation
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsVertical(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

​
ngrams

Introduit dans : v21.11.0 Découpe une chaîne UTF-8 en n-grammes de longueur N. Syntaxe 
ngrams(s, N)
Arguments Valeur renvoyée Renvoie un tableau de n-grammes. Array(String) Exemples Exemple d’utilisation
Query
SELECT ngrams('ClickHouse', 3);
Response
['Cli','lic','ick','ckH','kHo','Hou','ous','use']

​
reverseBySeparator

Introduite dans : v26.2.0 Inverse l’ordre des sous-chaînes d’une chaîne, séparées par un séparateur donné. Cette fonction découpe la chaîne selon le séparateur, inverse l’ordre des parties obtenues, puis les réassemble à l’aide du même séparateur. Elle est utile pour analyser des noms de domaine, des chemins de fichiers ou d’autres données hiérarchiques lorsqu’il faut inverser l’ordre des éléments. Exemples :
  • reverseBySeparator(‘www.google.com’) renvoie ‘com.google.www’
  • reverseBySeparator(‘a/b/c’, ’/’) renvoie ‘c/b/a’
  • reverseBySeparator(‘x::y::z’, ’::’) renvoie ‘z::y::x’
Syntaxe 
reverseBySeparator(string[, separator])
Arguments
  • string — La chaîne d’entrée dont il faut inverser l’ordre des segments. String
  • separator — La chaîne utilisée comme séparateur pour identifier les segments. S’il n’est pas fourni, ’.’ (point) est utilisé. Par défaut : ’.’ String
Valeur renvoyée Renvoie une chaîne dont les sous-chaînes sont réordonnées de droite à gauche par rapport à la chaîne d’origine, en utilisant le même séparateur. String Exemples Inversion de domaine simple
Query
SELECT reverseBySeparator('www.google.com')
Response
'com.google.www'
Inversion du chemin
Query
SELECT reverseBySeparator('a/b/c', '/')
Response
'c/b/a'
Séparateur personnalisé
Query
SELECT reverseBySeparator('x::y::z', '::')
Response
'z::y::x'
Cas particulier avec des points
Query
SELECT reverseBySeparator('.a.b.', '.')
Response
'.b.a.'
Élément unique
Query
SELECT reverseBySeparator('single')
Response
'single'
Séparateur vide
Query
SELECT reverseBySeparator('abcde', '')
Response
'edcba'

​
splitByChar

Introduit dans : v1.1.0 Divise une chaîne, séparée par la chaîne constante spécifiée separator composée d’exactement un caractère, en un tableau de sous-chaînes. Des sous-chaînes vides peuvent être renvoyées si le séparateur apparaît au début ou à la fin de la chaîne, ou s’il y a plusieurs séparateurs consécutifs.
Le paramètre splitby_max_substrings_includes_remaining_string (par défaut : 0) détermine si la chaîne restante est incluse dans le dernier élément du tableau résultant lorsque l’argument max_substrings > 0.
Des sous-chaînes vides peuvent être renvoyées dans les cas suivants :
  • Un séparateur apparaît au début ou à la fin de la chaîne
  • Il y a plusieurs séparateurs consécutifs
  • La chaîne d’origine s est vide
Syntaxe 
splitByChar(separator, s[, max_substrings])
Arguments
  • separator — Le séparateur doit être un caractère sur un seul octet. String
  • s — La chaîne à découper. String
  • max_substrings — Facultatif. Si max_substrings > 0, le tableau renvoyé contiendra au plus max_substrings sous-chaînes ; sinon, la fonction renverra autant de sous-chaînes que possible. La valeur par défaut est 0. Int64
Valeur renvoyée Retourne un tableau des sous-chaînes sélectionnées. Array(String) Exemples Exemple d’utilisation
Query
SELECT splitByChar(',', '1,2,3,abcde');
Response
┌─splitByChar(⋯2,3,abcde')─┐
│ ['1','2','3','abcde']    │
└──────────────────────────┘

​
splitByNonAlpha

Introduit dans : v21.9.0 Découpe une chaîne délimitée par des caractères d’espacement et de ponctuation en un tableau de sous-chaînes.
Le paramètre splitby_max_substrings_includes_remaining_string (par défaut : 0) détermine si le reste de la chaîne est inclus dans le dernier élément du tableau de résultats lorsque l’argument max_substrings > 0.
Syntaxe 
splitByNonAlpha(s[, max_substrings])
Arguments
  • s — La chaîne à découper. String
  • max_substrings — Facultatif. Lorsque max_substrings > 0, le nombre de sous-chaînes renvoyées ne dépassera pas max_substrings ; sinon, la fonction renverra autant de sous-chaînes que possible. Valeur par défaut : 0. Int64
Valeur renvoyée Renvoie un tableau contenant les sous-chaînes sélectionnées de s. Array(String) Exemples Exemple d’utilisation
Query
SELECT splitByNonAlpha('user@domain.com');
Response
['user','domain','com']

​
splitByRegexp

Introduit dans : v21.6.0 Scinde une chaîne, en utilisant l’expression régulière fournie comme séparateur, en un tableau de sous-chaînes. Si l’expression régulière fournie est vide, la chaîne sera scindée en un tableau de caractères individuels. Si aucune correspondance avec l’expression régulière n’est trouvée, la chaîne ne sera pas scindée. Des sous-chaînes vides peuvent être produites lorsque :
  • une correspondance non vide avec l’expression régulière se produit au début ou à la fin de la chaîne
  • plusieurs correspondances non vides avec l’expression régulière se suivent
  • la chaîne d’origine est vide alors que l’expression régulière ne l’est pas.
Le paramètre splitby_max_substrings_includes_remaining_string (par défaut : 0) détermine si la chaîne restante est incluse dans le dernier élément du tableau de résultats lorsque l’argument max_substrings > 0.
Syntaxe 
splitByRegexp(regexp, s[, max_substrings])
Arguments
  • regexp — Expression régulière. Constante. String ou FixedString
  • s — La chaîne à découper. String
  • max_substrings — Facultatif. Lorsque max_substrings > 0, le nombre de sous-chaînes renvoyées ne dépassera pas max_substrings ; sinon, la fonction renverra autant de sous-chaînes que possible. Valeur par défaut : 0. Int64
Valeur renvoyée Renvoie un tableau des sous-chaînes sélectionnées de s. Array(String) Exemples Exemple d’utilisation
Query
SELECT splitByRegexp('\\d+', 'a12bc23de345f');
Response
┌─splitByRegex⋯c23de345f')─┐
│ ['a12bc23de345f']        │
└──────────────────────────┘
Expression régulière vide
Query
SELECT splitByRegexp('', 'abcde');
Response
┌─splitByRegexp('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

​
splitByString

Introduit dans : v1.1.0 Divise une chaîne à l’aide d’un separator constant composé de plusieurs caractères en un tableau de sous-chaînes. Si la chaîne separator est vide, la chaîne s est divisée en un tableau de caractères individuels. Des sous-chaînes vides peuvent être produites lorsque :
  • Un séparateur non vide apparaît au début ou à la fin de la chaîne
  • Plusieurs séparateurs non vides se suivent
  • La chaîne d’origine s est vide alors que le séparateur ne l’est pas
Le paramètre splitby_max_substrings_includes_remaining_string (par défaut : 0) détermine si la chaîne restante est incluse dans le dernier élément du tableau de résultats lorsque l’argument max_substrings > 0.
Syntaxe 
splitByString(separator, s[, max_substrings])
Arguments
  • separator — Le séparateur. String
  • s — La chaîne à scinder. String
  • max_substrings — Facultatif. Lorsque max_substrings > 0, le nombre de sous-chaînes renvoyées ne dépassera pas max_substrings ; sinon, la fonction renverra autant de sous-chaînes que possible. Valeur par défaut : 0. Int64
Valeur renvoyée Renvoie un tableau contenant les sous-chaînes sélectionnées de s Array(String) Exemples Exemple d’utilisation
Query
SELECT splitByString(', ', '1, 2 3, 4,5, abcde');
Response
┌─splitByStrin⋯4,5, abcde')─┐
│ ['1','2 3','4,5','abcde'] │
└───────────────────────────┘
Séparateur vide
Query
SELECT splitByString('', 'abcde');
Response
┌─splitByString('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

​
splitByWhitespace

Introduit dans : v21.9.0 Découpe une chaîne délimitée par des caractères d’espacement en un tableau de sous-chaînes.
Le paramètre splitby_max_substrings_includes_remaining_string (par défaut : 0) détermine si le reste de la chaîne est inclus dans le dernier élément du tableau résultant lorsque l’argument max_substrings > 0.
Syntaxe 
splitByWhitespace(s[, max_substrings])
Arguments
  • s — La chaîne à découper. String
  • max_substrings — Facultatif. Lorsque max_substrings > 0, le nombre de sous-chaînes renvoyées ne dépasse pas max_substrings ; sinon, la fonction renvoie autant de sous-chaînes que possible. Valeur par défaut : 0. Int64
Valeur renvoyée Renvoie un tableau des sous-chaînes sélectionnées de s. Array(String) Exemples Exemple d’utilisation
Query
SELECT splitByWhitespace('  1!  a,  b.  ');
Response
['1!','a,','b.']

​
tokens

Introduit dans : v21.11.0 Découpe une chaîne en tokens à l’aide du tokenizer indiqué. Tokenizers disponibles :
  • splitByNonAlpha découpe les chaînes sur les caractères ASCII non alphanumériques (voir aussi la fonction splitByNonAlpha).
  • splitByString(S) découpe les chaînes selon certaines chaînes séparatrices S définies par l’utilisateur (voir aussi la fonction splitByString). Les séparateurs peuvent être spécifiés à l’aide d’un paramètre facultatif, par exemple tokens(value, 'splitByString', [', ', '; ', '\n', '\\']). Notez que chaque chaîne peut être composée de plusieurs caractères (', ' dans l’exemple). La liste de séparateurs par défaut, si elle n’est pas explicitement spécifiée, est un seul espace [' '].
  • asciiCJK découpe les chaînes en tokens en appliquant les règles Unicode de délimitation des mots (similaires à UAX #29). Les caractères ASCII alphanumériques et les traits de soulignement forment des tokens avec des connecteurs (: pour les lettres, . et ' pour les caractères de même type). Les caractères Unicode non ASCII deviennent des tokens d’un seul caractère.
  • ngrams(N) découpe les chaînes en N-grammes de taille identique (voir aussi la fonction ngrams). La longueur des ngrams peut être spécifiée à l’aide d’un paramètre entier facultatif compris entre 1 et 8, par exemple tokens(value, 'ngrams', 3). La taille de ngram par défaut, si elle n’est pas explicitement spécifiée, est 3.
  • sparseGrams(min_length, max_length, min_cutoff_length) découpe les chaînes en n-grammes de longueur variable comportant au minimum min_length caractères et au maximum max_length caractères (bornes incluses) (voir aussi la fonction sparseGrams). Sauf indication explicite, min_length et max_length valent respectivement 3 et 100. Si le paramètre min_cutoff_length est fourni, seuls les n-grammes dont la longueur est supérieure ou égale à min_cutoff_length sont renvoyés. Par rapport à ngrams(N), le tokenizer sparseGrams produit des N-grammes de longueur variable, ce qui permet une représentation plus souple du texte d’origine. Par exemple, tokens(value, 'sparseGrams', 3, 5, 4) génère en interne des 3-, 4- et 5-grammes à partir de la chaîne d’entrée, mais seuls les 4- et 5-grammes sont renvoyés.
  • array n’effectue aucune tokenisation, c’est-à-dire que chaque valeur de ligne constitue un token (voir aussi la fonction array).
Dans le cas du tokenizer splitByString, si les tokens ne forment pas un code préfixe, vous souhaiterez probablement que la correspondance privilégie d’abord les séparateurs les plus longs. Pour ce faire, transmettez les séparateurs par ordre décroissant de longueur. Par exemple, avec separators = ['%21', '%'], la chaîne %21abc serait découpée en ['abc'], tandis que separators = ['%', '%21'] donnerait ['21ac'] (ce qui n’est probablement pas ce que vous vouliez). Syntaxe 
tokens(value) -- 'splitByNonAlpha' tokenizer
tokens(value, 'splitByNonAlpha')
tokens(value, 'splitByString'[, separators])
tokens(value, 'asciiCJK')
tokens(value, 'ngrams'[, n])
tokens(value, 'sparseGrams'[, min_length, max_length[, min_cutoff_length]])
tokens(value, 'array')
Arguments
  • value — La chaîne d’entrée. String ou FixedString
  • tokenizer — Le tokenizer à utiliser. Les valeurs acceptées sont splitByNonAlpha, splitByString, asciiCJK, ngrams, sparseGrams et array. Facultatif ; s’il n’est pas défini explicitement, la valeur par défaut est splitByNonAlpha. const String
  • n — Pertinent uniquement si l’argument tokenizer est ngrams : paramètre facultatif qui définit la longueur des ngrammes. S’il n’est pas défini explicitement, la valeur par défaut est 3. const UInt8
  • separators — Pertinent uniquement si l’argument tokenizer est split : paramètre facultatif qui définit les chaînes de séparation. S’il n’est pas défini explicitement, la valeur par défaut est [' ']. const Array(String)
  • min_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur minimale des grammes, par défaut 3. const UInt8
  • max_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur maximale des grammes, par défaut 100. const UInt8
  • min_cutoff_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur minimale de coupure. const UInt8
Valeur renvoyée Renvoie le tableau de tokens résultant de la chaîne d’entrée. Array Exemples Tokenizer par défaut
Query
SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\   test4') AS tokens;
Response
['test1','test2','test3','test4']
Tokenizer n-gram
Query
SELECT tokens('abc def', 'ngrams', 3) AS tokens;
Response
['abc','bc ','c d',' de','def']

​
tokensForLikePattern

Introduit dans : v26.3.0 Découpe une chaîne de motif LIKE en tokens à l’aide du tokenizer spécifié. Contrairement à la fonction tokens, cette fonction tient compte de la sémantique des motifs LIKE (comme les caractères génériques en début et en fin) et applique des règles propres au tokenizer pour extraire des tokens pertinents pour la correspondance de motifs. Elle prend en charge les mêmes jeux d’arguments que la fonction tokens ; les arguments supplémentaires après tokenizer sont interprétés en fonction du tokenizer sélectionné (par exemple, n pour ngrams, separators pour splitByString, et min_length / max_length [/ min_cutoff_length] pour sparseGrams). Cette fonction est principalement destinée au débogage et aux tests, et est utilisée en interne pour analyser le comportement de la tokenisation des motifs LIKE. Syntaxe 
tokensForLikePattern(value[, tokenizer[, tokenizer_specific_arguments...]])
Arguments
  • value — La chaîne d’entrée. String ou FixedString
  • tokenizer — Le tokenizer à utiliser. Les arguments valides sont splitByNonAlpha, splitByString, asciiCJK, ngrams, sparseGrams et array. Facultatif ; s’il n’est pas défini explicitement, sa valeur par défaut est splitByNonAlpha. const String
  • n — Pertinent uniquement si l’argument tokenizer est ngrams : paramètre facultatif qui définit la longueur des ngrams. S’il n’est pas défini explicitement, sa valeur par défaut est 3. const UInt8
  • separators — Pertinent uniquement si l’argument tokenizer est split : paramètre facultatif qui définit les chaînes de séparation. S’il n’est pas défini explicitement, sa valeur par défaut est [' ']. const Array(String)
  • min_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur minimale des grammes, par défaut 3. const UInt8
  • max_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur maximale des grammes, par défaut 100. const UInt8
  • min_cutoff_length — Pertinent uniquement si l’argument tokenizer est sparseGrams : paramètre facultatif qui définit la longueur minimale de coupure. const UInt8
Valeur renvoyée Renvoie le tableau de tokens obtenu à partir de la chaîne d’entrée. Array Exemples Tokenizer par défaut
Query
SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens;
Response
['test2']
Dernière modification le 29 juin 2026