Passer au contenu principal
Toutes les fonctions de cette section effectuent, par défaut, une recherche sensible à la casse. Une recherche insensible à la casse est généralement proposée par des variantes de fonction distinctes.
La recherche insensible à la casse suit les règles de passage des minuscules aux majuscules de la langue anglaise. Par exemple, le i majuscule en anglais est I, alors qu’en turc c’est İ ; les résultats pour les langues autres que l’anglais peuvent donc être inattendus.
Les fonctions de cette section supposent également que la chaîne dans laquelle la recherche est effectuée (appelée dans cette section haystack) et la chaîne recherchée (appelée dans cette section needle) sont du texte encodé sur un seul octet. Si cette hypothèse est violée, aucune exception n’est levée et les résultats sont indéfinis. La recherche avec des chaînes encodées en UTF-8 est généralement proposée par des variantes de fonction distinctes. De même, si une variante de fonction UTF-8 est utilisée et que les chaînes d’entrée ne sont pas du texte encodé en UTF-8, aucune exception n’est levée et les résultats sont indéfinis. Notez qu’aucune normalisation Unicode automatique n’est effectuée ; vous pouvez toutefois utiliser les fonctions normalizeUTF8*() à cette fin. Les fonctions générales sur les chaînes et les fonctions de remplacement dans les chaînes sont décrites séparément.
La documentation ci-dessous est générée à partir de la table système system.functions.

​
countMatches

Introduit dans : v21.1.0 Renvoie le nombre de correspondances d’une expression régulière dans une chaîne.
Comportement selon la versionLe comportement de cette fonction dépend de la version de ClickHouse :
  • dans les versions < v25.6, la fonction arrête le comptage à la première correspondance vide, même si le motif autorise une correspondance vide.
  • dans les versions >= 25.6, la fonction continue à s’exécuter lorsqu’une correspondance vide se produit. Le comportement legacy peut être restauré à l’aide du paramètre count_matches_stop_at_empty_match = true;
Syntaxe 
countMatches(haystack, pattern)
Arguments
  • haystack — La chaîne dans laquelle effectuer la recherche. String
  • pattern — Motif d’expression régulière. String
Valeur renvoyée Renvoie le nombre de correspondances trouvées. UInt64 Exemples Compter les séquences de chiffres
Query
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
Response
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

​
countMatchesCaseInsensitive

Introduite dans : v21.1.0 Comme countMatches, mais effectue une correspondance sans tenir compte de la casse. Syntaxe 
countMatchesCaseInsensitive(haystack, pattern)
Arguments
  • haystack — La chaîne dans laquelle effectuer la recherche. String
  • pattern — Motif d’expression régulière. const String
Valeur renvoyée Renvoie le nombre de correspondances trouvées. UInt64 Exemples Comptage insensible à la casse
Query
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
Response
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

​
countSubstrings

Introduit dans : v21.1.0 Renvoie le nombre de fois où la sous-chaîne needle apparaît dans la chaîne haystack. Syntaxe 
countSubstrings(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum. - needle — Sous-chaîne à rechercher. String. - start_pos — Position (à partir de 1) dans haystack à laquelle la recherche commence. UInt. Facultatif.
Valeur de retour Le nombre d’occurrences. UInt64 Exemples Exemple d’utilisation
Query
SELECT countSubstrings('aaaa', 'aa');
Response
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘
Avec l’argument start_pos
Query
SELECT countSubstrings('abc___abc', 'abc', 4);
Response
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

​
countSubstringsCaseInsensitive

Introduit dans : v21.1.0 Comme countSubstrings, mais effectue le comptage sans tenir compte de la casse. Syntaxe 
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Facultatif. Position (à partir de 1) dans haystack à laquelle la recherche commence. UInt*
Valeur renvoyée Renvoie le nombre d’occurrences de needle dans haystack. UInt64 Exemples Exemple d’utilisation
Query
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
Response
┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘
Avec l’argument start_pos
Query
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
Response
┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

​
countSubstringsCaseInsensitiveUTF8

Introduit dans : v21.1.0 Comme countSubstrings, mais compte sans distinction entre majuscules et minuscules et suppose que haystack est une chaîne UTF-8. Syntaxe 
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne UTF-8 dans laquelle effectuer la recherche. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Facultatif. Position (à partir de 1) dans haystack à laquelle la recherche commence. UInt*
Valeur renvoyée Renvoie le nombre d’occurrences de needle dans haystack. UInt64 Exemples Exemple d’utilisation
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
Response
┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘
Avec l’argument start_pos
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
Response
┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

​
extract

Introduit dans : v1.1.0 Extrait la première correspondance d’une expression régulière dans une chaîne. Si ‘haystack’ ne correspond pas à ‘pattern’, une chaîne vide est renvoyée. Cette fonction utilise la bibliothèque d’expressions régulières RE2. Consultez re2 pour connaître la Syntax prise en charge. Si l’expression régulière comporte des groupes de capture (sous-motifs), la fonction fait correspondre la chaîne d’entrée au premier groupe de capture. Syntaxe 
extract(haystack, pattern)
Arguments
  • haystack — Chaîne à partir de laquelle extraire. String
  • pattern — Expression régulière, contenant généralement un groupe de capture. const String
Valeur renvoyée Renvoie le fragment extrait sous forme de chaîne. String Exemples Extraire le domaine d’une adresse e-mail
Query
SELECT extract('test@clickhouse.com', '.*@(.*)$')
Response
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘
En l’absence de correspondance, une chaîne vide est renvoyée
Query
SELECT extract('test@clickhouse.com', 'no_match')
Response
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

​
extractAll

Introduite dans : v1.1.0 Comme extract, mais renvoie un tableau contenant toutes les correspondances d’une expression régulière dans une chaîne. Si ‘haystack’ ne correspond pas à l’expression régulière ‘pattern’, un tableau vide est renvoyé. Si l’expression régulière comporte des groupes de capture (sous-motifs), la fonction fait correspondre la chaîne d’entrée au premier groupe de capture. Syntaxe 
extractAll(haystack, pattern)
Arguments
  • haystack — Chaîne dont extraire les fragments. String
  • pattern — Expression régulière pouvant contenir des groupes de capture. const String
Valeur renvoyée Renvoie un tableau contenant les fragments extraits. Array(String) Exemples Extraire tous les nombres
Query
SELECT extractAll('hello 123 world 456', '[0-9]+')
Response
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘
Extraire à l’aide d’un groupe de capture
Query
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
Response
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

​
extractAllGroupsHorizontal

Introduit dans : v20.5.0 Met en correspondance tous les groupes d’une chaîne à l’aide de l’expression régulière fournie et renvoie un tableau de tableaux, chaque tableau contenant toutes les captures d’un même groupe de capture, classées par numéro de groupe. Syntaxe 
extractAllGroupsHorizontal(s, regexp)
Arguments Valeur renvoyée Renvoie un tableau de tableaux, où chaque tableau interne contient toutes les captures d’un groupe de capture pour l’ensemble des correspondances. Le premier tableau interne contient toutes les captures du groupe 1, le deuxième celles du 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 extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

​
extractGroups

Introduit dans : v20.5.0 Extrait les groupes de capture de la première sous-chaîne correspondant à une expression régulière. Pour extraire les groupes de toutes les correspondances, utilisez extractAllGroupsHorizontal ou extractAllGroupsVertical. Syntaxe 
extractGroups(s, regexp)
Arguments Valeur renvoyée Si l’expression régulière trouve une correspondance, renvoie un tableau contenant les groupes capturés (1 à N, où N est le nombre de groupes de capture dans regexp) de la première correspondance. S’il n’y a pas de correspondance, renvoie un tableau vide. 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 extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
['Server','nginx']

​
hasAllTokens

Introduit dans : v25.10.0 Comme hasAnyTokens, mais renvoie 1 si tous les tokens de la chaîne ou du tableau needle correspondent à la chaîne input, et 0 sinon. Si input est une colonne, renvoie toutes les lignes qui satisfont cette condition.
La colonne input doit avoir un index de texte défini pour des performances optimales. Si aucun index de texte n’est défini, la fonction effectue un balayage exhaustif de la colonne, plusieurs ordres de grandeur plus lent qu’une recherche via l’index.
Avant la recherche, la fonction effectue la tokenisation de
  • l’argument input (toujours), et
  • l’argument needle (s’il est fourni sous forme de String) à l’aide du tokenizer spécifié pour l’index de texte. Si aucun index de texte n’est défini pour la colonne, le tokenizer splitByNonAlpha est utilisé à la place. Si l’argument needle est de type Array(String), chaque élément du tableau est traité comme un token — aucune tokenisation supplémentaire n’a lieu.
Les tokens en double sont ignorés. Par exemple, needles = [‘ClickHouse’, ‘ClickHouse’] est traité de la même manière que [‘ClickHouse’].
Lorsqu’un index de texte définit un preprocessor (par exemple lowerUTF8), hasAllTokens l’applique à input et, lorsque needles est un String, à needles avant la tokenisation. Lorsque needles est un Array(String), ses éléments sont transmis tels quels et le preprocessor ne leur est pas appliqué. Le preprocessor n’est appliqué que sur le chemin de l’index de texte, de sorte que les résultats peuvent différer entre les requêtes qui utilisent l’index de texte et celles qui ne l’utilisent pas (par ex. SETTINGS use_skip_indexes = 0). Cette incohérence est tolérée afin d’améliorer la facilité d’utilisation de la recherche en texte intégral.
Syntaxe 
hasAllTokens(input, needles)
Alias : hasAllToken Arguments
  • input — La colonne d’entrée. String ou FixedString ou Array(String) ou Array(FixedString)
  • needles — Les tokens à rechercher. String ou Array(String)
  • tokenizer — Le tokenizer à utiliser. Les arguments valides 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
Valeur renvoyée Renvoie 1 si tous les needles correspondent. Sinon, renvoie 0. UInt8 Exemples Utilisation de base avec un needle de type chaîne
Query
CREATE TABLE table (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM table WHERE hasAllTokens(msg, 'a\\d()');
Response
┌─count()─┐
│       1 │
└─────────┘
Spécifiez un tableau de motifs à rechercher tels quels (sans tokenisation)
Query
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       1 │
└─────────┘
Générer des needles à l’aide de la fonction tokens
Query
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       1 │
└─────────┘
Utilisez un tokenizer personnalisé avec le 3e argument
Query
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
Response
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                            1 │
└──────────────────────────────────────────────┘
Exemples d’utilisation des colonnes Array et Map
Query
CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
Response
Exemple avec une colonne de type Array
Query
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Exemple avec mapKeys
Query
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       1 │
└─────────┘
Exemple avec mapValues
Query
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       0 │
└─────────┘

​
hasAnyTokens

Introduit dans : v25.10.0 Renvoie 1 si au moins un token de la chaîne ou du tableau needle correspond à la chaîne input, et 0 sinon. Si input est une colonne, renvoie toutes les lignes qui satisfont cette condition.
La colonne input doit avoir un index de texte défini pour des performances optimales. Si aucun index de texte n’est défini, la fonction effectue un balayage exhaustif de la colonne, ce qui est de plusieurs ordres de grandeur plus lent qu’une recherche via l’index.
Avant la recherche, la fonction tokenise :
  • l’argument input (toujours), et
  • l’argument needle (s’il est fourni sous forme de String) à l’aide du tokenizer spécifié pour l’index de texte. Si aucun index de texte n’est défini pour la colonne, le tokenizer splitByNonAlpha est utilisé à la place. Si l’argument needle est de type Array(String), chaque élément du tableau est traité comme un token — aucune tokenisation supplémentaire n’est effectuée.
Les tokens dupliqués sont ignorés. Par exemple, [‘ClickHouse’, ‘ClickHouse’] est traité de la même manière que [‘ClickHouse’].
Lorsqu’un index de texte définit un preprocessor (par exemple lowerUTF8), hasAnyTokens l’applique à input et, lorsque needles est une String, à needles avant la tokenisation. Lorsque needles est un Array(String), ses éléments sont transmis tels quels et le preprocessor ne leur est pas appliqué. Le preprocessor n’est appliqué que sur le chemin de l’index de texte. Les résultats peuvent donc différer entre les requêtes qui utilisent l’index de texte et celles qui ne l’utilisent pas (par ex. SETTINGS use_skip_indexes = 0). Cette incohérence est tolérée afin d’améliorer la facilité d’utilisation de la recherche en texte intégral.
Syntaxe 
hasAnyTokens(input, needles)
Alias : hasAnyToken Arguments Valeur renvoyée Renvoie 1 s’il existe au moins une correspondance. 0 sinon. UInt8 Exemples Utilisation de base avec une chaîne comme terme recherché
Query
CREATE TABLE table (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO table VALUES (1, '()a,\\bc()d'), (2, '()\\a()bc\\d'), (3, ',()a\\,bc,(),d,');

SELECT count() FROM table WHERE hasAnyTokens(msg, 'a\\d()');
Response
┌─count()─┐
│       3 │
└─────────┘
Spécifier les motifs à rechercher tels quels (sans tokenisation) dans un tableau
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       3 │
└─────────┘
Générez des needles avec la fonction tokens
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       3 │
└─────────┘
Exemples d’utilisation de colonnes array et map
Query
CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});
Response
Exemple avec une colonne Array
Query
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
Exemple avec mapKeys
Query
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       2 │
└─────────┘
Exemple avec mapValues
Query
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       2 │
└─────────┘

​
hasPhrase

Introduit dans : v26.4.0 Vérifie si input contient tous les tokens de phrase dans un ordre consécutif.
La colonne input doit avoir un index de texte défini pour des performances optimales. Si aucun index de texte n’est défini, la fonction effectue un balayage exhaustif de la colonne, plusieurs ordres de grandeur plus lent qu’une consultation de l’index.
Avant la recherche, la fonction tokenise les arguments input et phrase à l’aide du tokenizer spécifié pour l’index de texte. Si aucun index de texte n’est défini pour la colonne, le tokenizer splitByNonAlpha est utilisé à la place — sauf si un tokenizer est fourni comme troisième argument facultatif. L’argument tokenizer doit être l’un de splitByNonAlpha, splitByString, ngrams ou asciiCJK.
Lorsqu’un index de texte définit un preprocessor (par exemple lowerUTF8), hasPhrase l’applique à la fois à input et à phrase avant la tokenisation. Le preprocessor n’est appliqué que lors de l’utilisation de l’index de texte ; les résultats peuvent donc différer entre les requêtes qui utilisent l’index de texte et celles qui ne l’utilisent pas (par ex. SETTINGS use_skip_indexes = 0). Cette incohérence est tolérée afin d’améliorer la facilité d’utilisation de la recherche en texte intégral.
Contrairement à hasToken, hasAnyTokens et hasAllTokens, hasPhrase exige que les tokens apparaissent dans le même ordre et sans aucun token intermédiaire. Par exemple, hasPhrase('the quick brown fox', 'quick fox') renvoie 0 car “brown” apparaît entre “quick” et “fox”. Syntaxe 
hasPhrase(input, phrase[, tokenizer])
Alias : matchPhrase Arguments
  • input — La colonne d’entrée. String ou FixedString
  • phrase — Phrase à rechercher. const String
  • tokenizer — Le tokenizer à utiliser. Facultatif, splitByNonAlpha est utilisé par défaut. const String
Valeur renvoyée Renvoie 1 si la phrase est trouvée sous la forme d’une séquence consécutive de tokens, sinon 0. UInt8 Exemples Correspondance de phrase
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                      1 │
└────────────────────────────────────────────────────────┘
Tokens non consécutifs
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
hasSubsequence

Introduit dans : v23.7.0 Vérifie si un motif est une sous-séquence d’une chaîne. Une sous-séquence d’une chaîne est une séquence qui peut être obtenue à partir d’une autre chaîne en supprimant certains caractères, ou aucun, sans modifier l’ordre des caractères restants. Syntaxe 
hasSubsequence(haystack, needle)
Arguments
  • haystack — Chaîne dans laquelle rechercher la sous-séquence. String
  • needle — Sous-séquence à rechercher. String
Valeur renvoyée Renvoie 1 si needle est une sous-séquence de haystack, 0 sinon. UInt8 Exemples Vérification de base d’une sous-séquence
Query
SELECT hasSubsequence('Hello World', 'HlWrd')
Response
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘
Aucune sous-séquence n’a été trouvée
Query
SELECT hasSubsequence('Hello World', 'xyz')
Response
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

​
hasSubsequenceCaseInsensitive

Introduit dans : v23.7.0 Comme hasSubsequence, mais effectue une recherche sans tenir compte de la casse. Syntaxe 
hasSubsequenceCaseInsensitive(haystack, needle)
Arguments
  • haystack — Chaîne dans laquelle effectuer la recherche. String
  • needle — Sous-séquence à rechercher. String
Valeur renvoyée Renvoie 1 si needle est une sous-séquence de haystack, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
Response
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

​
hasSubsequenceCaseInsensitiveUTF8

Introduit dans : v23.7.0 Comme hasSubsequenceUTF8, mais la recherche s’effectue sans tenir compte de la casse. Syntaxe 
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
Arguments
  • haystack — chaîne encodée en UTF8 dans laquelle effectuer la recherche. String
  • needle — motif de sous-séquence encodé en UTF8 à rechercher. String
Valeur renvoyée Renvoie 1 si needle est une sous-séquence de haystack, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
Response
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

​
hasSubsequenceUTF8

Introduit dans : v23.7.0 Comme hasSubsequence, mais suppose que haystack et needle sont des chaînes encodées en UTF-8. Syntaxe 
hasSubsequenceUTF8(haystack, needle)
Arguments
  • haystack — La chaîne dans laquelle effectuer la recherche. String
  • needle — Le motif à rechercher. String
Valeur renvoyée Renvoie 1 si needle est une sous-séquence de haystack, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT hasSubsequenceUTF8('картошка', 'кошка');
Response
┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘
Sous-séquence non correspondante
Query
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
Response
┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

​
hasToken

Introduit dans : v20.1.0 Vérifie si le token donné est présent dans la chaîne. Utilise splitByNonAlpha comme tokenizer, c’est-à-dire qu’un token est défini comme la plus longue sous-séquence possible de caractères consécutifs [0-9A-Za-z_] (chiffres, caractères ASCII et underscore). Syntaxe 
hasToken(haystack, token)
Arguments
  • haystack — Chaîne dans laquelle effectuer la recherche. String
  • token — Token à rechercher. const String
Valeur renvoyée Renvoie 1 si le token est trouvé, 0 sinon. UInt8 Exemples Recherche de token
Query
SELECT hasToken('clickhouse test', 'test')
Response
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

​
hasTokenCaseInsensitive

Introduit dans : v20.1.0 Effectue une recherche insensible à la casse du motif dans la chaîne source à l’aide de l’index tokenbf_v1. Syntaxe 
hasTokenCaseInsensitive(haystack, needle)
Arguments
  • Aucun.
Valeur renvoyée Exemples

​
hasTokenCaseInsensitiveOrNull

Introduit dans : v23.1.0 Effectue une recherche insensible à la casse du motif dans la chaîne à l’aide de l’index tokenbf_v1. Renvoie NULL si le motif est mal formé. Syntaxe 
hasTokenCaseInsensitiveOrNull(haystack, needle)
Arguments
  • Aucun.
Valeur renvoyée Exemples

​
hasTokenOrNull

Introduit dans : v20.1.0 Comme hasToken, mais renvoie NULL si le token est mal formé. Syntaxe 
hasTokenOrNull(haystack, token)
Arguments
  • haystack — Chaîne dans laquelle effectuer la recherche. Doit être constante. String
  • token — Token à rechercher. const String
Valeur renvoyée Renvoie 1 si le token est trouvé, 0 sinon, NULL si le token est mal formé. Nullable(UInt8) Exemples Exemple d’utilisation
Query
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
Response
┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

​
highlight

Introduit dans : v26.4.0 Met en évidence les occurrences des termes de recherche dans une chaîne de texte en les entourant de balises HTML. La fonction effectue une recherche ASCII insensible à la casse. Si plusieurs termes de recherche se chevauchent ou se touchent dans le texte, les zones correspondantes sont fusionnées en une seule plage mise en évidence. Syntaxe 
highlight(haystack, needles[, open_tag, close_tag])
Arguments
  • haystack — Le texte dans lequel effectuer la recherche. String ou FixedString
  • needles — Un tableau de termes de recherche à mettre en évidence. const Array(String)
  • open_tag — La balise ouvrante à insérer avant chaque correspondance. Par défaut : <em>. const String
  • close_tag — La balise fermante à insérer après chaque correspondance. Par défaut : </em>. const String
Valeur renvoyée Renvoie le texte d’entrée avec les termes correspondants entourés des balises spécifiées. String Exemples Mise en évidence simple
Query
SELECT highlight('The quick brown fox', ['quick', 'fox'])
Response
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘
Tags personnalisés
Query
SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
Response
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

​
ilike

Introduit dans : v20.6.0 Comme like, mais effectue une recherche sans tenir compte de la casse. Prend en charge la clause ESCAPE facultative (voir like). Syntaxe 
ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou FixedString
  • pattern — Motif LIKE auquel la chaîne doit correspondre. String
  • escape_character — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de \. Par défaut : \. String
Valeur renvoyée Renvoie 1 si la chaîne correspond au motif LIKE (insensible à la casse), sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT ilike('ClickHouse', '%house%');
Response
┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

​
like

Introduit dans : v1.1.0 Indique si la chaîne haystack correspond à l’expression LIKE pattern. Une expression LIKE peut contenir des caractères ordinaires et les métacaractères suivants :
  • % indique un nombre arbitraire de caractères quelconques (y compris zéro caractère).
  • _ indique un seul caractère quelconque.
  • \ sert à échapper les littéraux %, _ et \.
La correspondance s’appuie sur l’UTF-8. Par exemple, _ correspond au point de code Unicode ¥, qui est représenté en UTF-8 à l’aide de deux octets. Si la chaîne ou l’expression LIKE ne sont pas en UTF-8 valide, le comportement est indéfini. Aucune normalisation Unicode automatique n’est effectuée ; vous pouvez utiliser les fonctions normalizeUTF8* pour cela. Pour faire correspondre les littéraux %, _ et \ (qui sont des métacaractères LIKE), faites-les précéder d’une barre oblique inverse : \%, \_ et \\. La barre oblique inverse perd sa signification spéciale (c’est-à-dire qu’elle est interprétée littéralement) si elle précède un caractère autre que %, _ ou \.
ClickHouse exige que les barres obliques inverses dans les chaînes soient elles aussi échappées ; vous devez donc en pratique écrire \\%, \\_ et \\\\.
Pour les expressions LIKE de la forme %needle%, la fonction est aussi rapide que la fonction position. Toutes les autres expressions LIKE sont converties en interne en une expression régulière et exécutées avec des performances similaires à celles de la fonction match.

​
Clause ESCAPE

La clause ESCAPE facultative spécifie un caractère d’échappement personnalisé (qui doit être un seul caractère ASCII). Lorsqu’il est défini, le caractère d’échappement personnalisé remplace la barre oblique inverse par défaut pour échapper les métacaractères % et _. Le caractère d’échappement peut servir à échapper trois éléments : % (signe de pourcentage littéral), _ (trait de soulignement littéral) et lui-même (caractère d’échappement littéral). Lorsqu’un caractère d’échappement personnalisé est utilisé, la barre oblique inverse n’a aucune signification particulière et est traité comme un caractère littéral. Syntaxe 
like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou FixedString
  • pattern — Motif LIKE auquel la chaîne est comparée. Peut contenir % (correspond à un nombre quelconque de caractères), _ (correspond à un seul caractère) et \\ comme caractère d’échappement. String
  • escape_character — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de \\. Par défaut : \\. String
Valeur renvoyée Renvoie 1 si la chaîne correspond au motif LIKE, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT like('ClickHouse', '%House');
Response
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘
Joker à un seul caractère
Query
SELECT like('ClickHouse', 'Click_ouse');
Response
┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘
Motif sans correspondance
Query
SELECT like('ClickHouse', '%SQL%');
Response
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘
Clause ESCAPE
Query
SELECT '50%off' LIKE '50#%off' ESCAPE '#';
Response
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

​
locate

Introduit dans : v18.16.0 Comme position, mais avec les arguments haystack et locate inversés.
Comportement selon la versionLe comportement de cette fonction dépend de la version de ClickHouse :
  • dans les versions < v24.3, locate était un alias de la fonction position et acceptait les arguments (haystack, needle[, start_pos]).
  • dans les versions >= 24.3, locate est une fonction distincte (pour une meilleure compatibilité avec MySQL) et accepte les arguments (needle, haystack[, start_pos]). Le comportement précédent peut être rétabli à l’aide du paramètre function_locate_has_mysql_compatible_argument_order = false.
Syntaxe 
locate(needle, haystack[, start_pos])
Arguments
  • needle — Sous-chaîne à rechercher. String
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • start_pos — Facultatif. Position (indexée à partir de 1) dans haystack à partir de laquelle la recherche commence. UInt
Valeur renvoyée Renvoie la position de départ, en octets et à partir de 1, si la sous-chaîne est trouvée ; 0 si elle ne l’est pas. UInt64 Exemples Utilisation de base
Query
SELECT locate('ca', 'abcabc')
Response
┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

​
match

Introduit dans : v1.1.0 Vérifie si une chaîne donnée correspond au motif d’expression régulière fourni. Cette fonction utilise la bibliothèque d’expressions régulières RE2. Veuillez consulter re2 pour connaître la syntaxe prise en charge. La correspondance repose sur l’hypothèse UTF-8 : par exemple, ¥ utilise deux octets en interne, mais est traité comme un seul point de code lors de la correspondance. L’expression régulière ne doit pas contenir d’octets NULL. Si la chaîne d’entrée ou le motif ne sont pas en UTF-8 valide, le comportement n’est pas défini. Contrairement au comportement par défaut de re2, . correspond aux sauts de ligne. Pour désactiver cela, faites précéder le motif de (?-s). Le motif n’est pas ancré. Pour faire correspondre la chaîne entière, ancrez vous-même le motif à l’aide de ^ et $. Si vous souhaitez simplement rechercher des sous-chaînes, vous pouvez utiliser à la place les fonctions like ou position, qui sont bien plus rapides que cette fonction. Syntaxe d’opérateur alternative : haystack REGEXP pattern. Syntaxe 
match(haystack, pattern)
Alias : REGEXP_MATCHES Arguments
  • haystack — Chaîne dans laquelle le motif est recherché. String
  • pattern — Motif d’expression régulière. Peut être une constante ou provenir d’un colonne. String
Valeur renvoyée Renvoie 1 si le motif correspond, 0 sinon. UInt8 Exemples Correspondance simple de motifs
Query
SELECT match('Hello World', 'Hello.*')
Response
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘
Motif sans correspondance
Query
SELECT match('Hello World', 'goodbye.*')
Response
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘
Correspondance avec une sous-chaîne
Query
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
Response
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                       1 │                         0 │
└─────────────────────────┴───────────────────────────┘

​
multiFuzzyMatchAllIndices

Introduit dans : v20.1.0 Comme multiFuzzyMatchAny, mais renvoie le tableau de tous les indices correspondant, dans un ordre quelconque, à la chaîne recherchée avec une distance d’édition constante. Syntaxe 
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
Arguments
  • haystack — Chaîne dans laquelle effectuer la recherche. String
  • distance — Distance d’édition maximale pour la correspondance approximative. UInt8
  • pattern — Tableau de motifs à rechercher. Array(String)
Valeur renvoyée Renvoie un tableau de tous les indices (à partir de 1) correspondant à haystack selon la distance d’édition spécifiée, dans n’importe quel ordre. Renvoie un tableau vide si aucune correspondance n’est trouvée. Array(UInt64) Exemples Exemple d’utilisation
Query
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
Response
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

​
multiFuzzyMatchAny

Introduit dans : v20.1.0 Comme multiMatchAny, mais renvoie 1 si un motif correspond à la chaîne recherchée pour une distance d’édition constante. Cette fonction s’appuie sur la fonctionnalité expérimentale de la bibliothèque hyperscan et peut être lente dans certains cas limites. Les performances dépendent de la valeur de la distance d’édition et des motifs utilisés, mais restent toujours inférieures à celles des variantes non floues.
La famille de fonctions multiFuzzyMatch*() ne prend pas en charge les expressions régulières UTF-8 (elles les traitent comme une séquence d’octets) en raison des limitations de hyperscan.
Syntaxe 
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • distance — Distance d’édition maximale pour la correspondance approximative. UInt8
  • pattern — Facultatif. Tableau de motifs à comparer. Array(String)
Valeur renvoyée Renvoie 1 si un motif correspond au haystack dans la limite de la distance d’édition spécifiée, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
Response
┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

​
multiFuzzyMatchAnyIndex

Introduite dans : v20.1.0 Comme multiFuzzyMatchAny, mais renvoie un indice correspondant à la chaîne dans une distance d’édition constante. Syntaxe 
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • distance — Distance d’édition maximale pour la correspondance approximative. UInt8
  • pattern — Tableau de motifs à mettre en correspondance. Array(String)
Valeur renvoyée Renvoie l’indice (à partir de 1) de l’un des motifs correspondant à haystack dans la limite de la distance d’édition spécifiée ; sinon, 0. UInt64 Exemples Exemple d’utilisation
Query
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
Response
┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

​
multiMatchAllIndices

Introduit dans : v20.1.0 Comme multiMatchAny, mais renvoie le tableau de tous les indices qui correspondent à la chaîne analysée, dans n’importe quel ordre. Syntaxe 
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • pattern — Expressions régulières à rechercher. String
Valeur renvoyée Tableau de tous les indices (à partir de 1) correspondant à haystack, dans n’importe quel ordre. Renvoie un tableau vide si aucune correspondance n’est trouvée. Array(UInt64) Exemples Exemple d’utilisation
Query
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
Response
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

​
multiMatchAny

Introduit dans : v20.1.0 Vérifie si au moins un de plusieurs motifs d’expression régulière correspond à la chaîne recherchée. Si vous souhaitez uniquement rechercher plusieurs sous-chaînes dans une chaîne, vous pouvez utiliser la fonction multiSearchAny à la place - elle est bien plus rapide que celle-ci. Syntaxe 
multiMatchAny(haystack, pattern1[, pattern2, ...])
Arguments
  • haystack — Chaîne dans laquelle les motifs sont recherchés. String
  • pattern1[, pattern2, ...] — Tableau contenant un ou plusieurs motifs d’expression régulière. Array(String)
Valeur renvoyée Renvoie 1 si l’un des motifs correspond, 0 sinon. UInt8 Exemples Correspondance avec plusieurs motifs
Query
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘
Aucun des motifs ne correspond
Query
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
multiMatchAnyIndex

Introduit dans : v20.1.0 Comme multiMatchAny, mais renvoie l’un des indices correspondant à la chaîne analysée. Syntaxe 
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
Arguments
  • haystack — Chaîne dans laquelle effectuer la recherche. String
  • pattern — Expressions régulières à mettre en correspondance. Array(String)
Valeur renvoyée Renvoie l’indice (à partir de 1) de la première expression régulière correspondante, ou 0 si aucune correspondance n’est trouvée. UInt64 Exemples Exemple d’utilisation
Query
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
Response
┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

​
multiSearchAllPositions

Introduit dans : v20.1.0 Comme position, mais renvoie un tableau de positions (en octets, à partir de 1) pour plusieurs sous-chaînes needle dans une chaîne haystack. Toutes les fonctions multiSearch*() prennent uniquement en charge jusqu’à 2^8 needles. Syntaxe 
multiSearchAllPositions(haystack, needle1[, needle2, ...])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle1[, needle2, ...] — Tableau d’une ou plusieurs sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie un tableau contenant la position de départ en octets, à partir de 1, si la sous-chaîne a été trouvée, ou 0 si elle ne l’a pas été. Array(UInt64) Exemples Recherche de plusieurs sous-chaînes
Query
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
Response
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

​
multiSearchAllPositionsCaseInsensitive

Introduit dans : v20.1.0 Comme multiSearchAllPositions, mais sans tenir compte de la casse. Syntaxe 
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle1[, needle2, ...] — Tableau d’une ou plusieurs sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie un tableau contenant les positions de début en octets, comptées à partir de 1 (si la sous-chaîne a été trouvée), ou 0 si la sous-chaîne n’a pas été trouvée. Array(UInt64) Exemples Recherche multiple insensible à la casse
Query
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

​
multiSearchAllPositionsCaseInsensitiveUTF8

Introduit dans : v20.1.0 Identique à multiSearchAllPositionsUTF8, mais sans tenir compte de la casse. Syntaxe 
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne encodée en UTF-8 dans laquelle la recherche est effectuée. String
  • needle — sous-chaînes encodées en UTF-8 à rechercher. Array(String)
Valeur renvoyée Tableau des positions de début en octets, en comptant à partir de 1 (si la sous-chaîne a été trouvée). Renvoie 0 si la sous-chaîne n’a pas été trouvée. Array Exemples Recherche UTF-8 insensible à la casse
Query
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
Response
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

​
multiSearchAllPositionsUTF8

Introduit dans : v20.1.0 Comme multiSearchAllPositions, mais suppose que haystack et les sous-chaînes needle sont des chaînes encodées en UTF-8. Syntaxe 
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
Arguments
  • haystack — Chaîne encodée en UTF-8 dans laquelle la recherche est effectuée. String
  • needle1[, needle2, ...] — Tableau de sous-chaînes encodées en UTF-8 à rechercher. Array(String)
Valeur renvoyée Renvoie un tableau des positions de départ en octets, comptées à partir de 1 (si la sous-chaîne a été trouvée), 0 si la sous-chaîne n’a pas été trouvée. Array Exemples Recherche multiple en UTF-8
Query
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
Response
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

​
multiSearchAny

Introduit dans : v20.1.0 Vérifie si la chaîne haystack contient au moins une des chaînes needle. Les fonctions multiSearchAnyCaseInsensitive, multiSearchAnyUTF8 et multiSearchAnyCaseInsensitiveUTF8 fournissent des variantes insensibles à la casse et/ou en UTF-8 de cette fonction. Syntaxe 
multiSearchAny(haystack, needle1[, needle2, ...])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle1[, needle2, ...] — Tableau de sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie 1 s’il y a au moins une correspondance, sinon 0. UInt8 Exemples Recherche d’au moins une correspondance
Query
SELECT multiSearchAny('ClickHouse',['C','H'])
Response
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitive

Introduit dans : v20.1.0 Comme multiSearchAny, mais sans tenir compte de la casse. Syntaxe 
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle — Sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie 1 s’il existe au moins une correspondance insensible à la casse, sinon 0. UInt8 Exemples Recherche insensible à la casse
Query
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitiveUTF8

Introduit dans : v20.1.0 Comme multiSearchAnyUTF8, mais sans tenir compte de la casse. Syntaxe 
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne UTF-8 dans laquelle la recherche est effectuée. String
  • needle — sous-chaînes UTF-8 à rechercher. Array(String)
Valeur renvoyée Renvoye 1 s’il existe au moins une correspondance insensible à la casse, sinon 0. UInt8 Exemples Étant donné la chaîne UTF-8 ‘Здравствуйте’, vérifiez si le caractère ‘з’ (en minuscule) est présent
Query
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
Response
┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchAnyUTF8

Introduit dans : v20.1.0 Semblable à multiSearchAny, mais suppose que haystack et les sous-chaînes needle sont encodées en UTF-8. Syntaxe 
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne UTF-8 dans laquelle la recherche est effectuée. String
  • needle — sous-chaînes UTF-8 à rechercher. Array(String)
Valeur renvoyée Renvoie 1 s’il y a au moins une correspondance, sinon 0. UInt8 Exemples Étant donné ‘你好，世界’ (‘Hello, world’) comme chaîne UTF-8, vérifiez si la chaîne contient les caractères 你 ou 界
Query
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
Response
┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndex

Introduit dans : v20.1.0 Recherche plusieurs chaînes recherchées dans une chaîne source (sensible à la casse) et renvoie l’indice, à partir de 1, de la première chaîne trouvée. Syntaxe 
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — La chaîne dans laquelle effectuer la recherche. String
  • needles — Tableau de chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie l’indice à partir de 1 (position dans le tableau needles) de la première chaîne trouvée dans haystack. Renvoie 0 si aucune chaîne n’est trouvée. La recherche est sensible à la casse. UInt64 Exemples Exemple d’utilisation
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘
Sensibilité à la casse
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘
Aucune correspondance trouvée
Query
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitive

Introduit dans : v20.1.0 Renvoie l’indice i (à partir de 1) du needle&#95;i trouvé le plus à gauche dans la chaîne haystack, et 0 sinon. Sans tenir compte de la casse. Syntaxe 
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle — Sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie l’indice (à partir de 1) de la needle trouvée la plus à gauche. Sinon, renvoie 0 si aucune correspondance n’a été trouvée. UInt8 Exemples Exemple d’utilisation
Query
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
Response
┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitiveUTF8

Introduit dans : v20.1.0 Recherche plusieurs chaînes à trouver dans une chaîne source, sans tenir compte de la casse avec prise en charge de l’encodage UTF-8, et renvoie l’index, à partir de 1, de la première chaîne trouvée. Syntaxe 
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — La chaîne dans laquelle effectuer la recherche. String
  • needles — Tableau de chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie l’index à partir de 1 (position dans le tableau needles) de la première needle trouvée dans haystack. Renvoie 0 si aucune needle n’est trouvée. La recherche est insensible à la casse et respecte l’encodage des caractères UTF-8. UInt64 Exemples Exemple d’utilisation
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
Response
┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘
Gestion de la casse en UTF-8
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
Response
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘
Aucune correspondance trouvée
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexUTF8

Introduit dans : v20.1.0 Renvoie l’index i (à partir de 1) du needle&#95;i trouvé le plus à gauche dans la chaîne haystack, et 0 sinon. Suppose que haystack et needle sont des chaînes encodées en UTF-8. Syntaxe 
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne UTF-8 dans laquelle la recherche est effectuée. String
  • needle — tableau de sous-chaînes UTF-8 à rechercher. Array(String)
Valeur renvoyée Renvoie l’indice (à partir de 1) de la needle trouvée la plus à gauche. Sinon, 0 s’il n’y a aucune correspondance. UInt8 Exemples Exemple d’utilisation
Query
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
Response
┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstPosition

Introduit dans : v20.1.0 Comme position, mais renvoie le décalage le plus à gauche dans une chaîne haystack qui correspond à l’une des chaînes needle. Les fonctions multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8 et multiSearchFirstPositionCaseInsensitiveUTF8 fournissent des variantes insensibles à la casse et/ou UTF-8 de cette fonction. Syntaxe 
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle1[, needle2, ...] — Tableau d’une ou plusieurs sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie le décalage de l’occurrence la plus à gauche dans la chaîne haystack qui correspond à l’une des chaînes needle, ou 0 si aucune correspondance n’est trouvée. UInt64 Exemples Recherche de la première position
Query
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
Response
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitive

Introduit dans : v20.1.0 Comme multiSearchFirstPosition, mais sans tenir compte de la casse. Syntaxe 
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String
  • needle — Tableau de sous-chaînes à rechercher. Array(String)
Valeur renvoyée Renvoie la position la plus à gauche dans une chaîne haystack qui correspond à l’une des chaînes needle. Renvoie 0 si aucune correspondance n’est trouvée. UInt64 Exemples Première position sans distinction de casse
Query
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
Response
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitiveUTF8

Introduit dans : v20.1.0 Comme multiSearchFirstPosition, mais considère haystack et needle comme des chaînes UTF-8 et ne tient pas compte de la casse. Syntaxe 
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne UTF-8 dans laquelle la recherche est effectuée. String
  • needle — tableau de sous-chaînes UTF-8 à rechercher. Array(String)
Valeur renvoyée Renvoie la position la plus à gauche dans une chaîne haystack qui correspond à l’une des chaînes needle, sans tenir compte de la casse. Renvoie 0 s’il n’y a aucune correspondance. UInt64 Exemples Trouver la position la plus à gauche dans la chaîne UTF-8 ‘Здравствуй, мир’ (‘Hello, world’) qui correspond à l’une des sous-chaînes recherchées
Query
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
Response
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│                                                                                      1 │
└────────────────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionUTF8

Introduit dans : v20.1.0 Semblable à multiSearchFirstPosition, mais considère haystack et needle comme des chaînes UTF-8. Syntaxe 
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
Arguments
  • haystack — chaîne UTF-8 dans laquelle effectuer la recherche. String
  • needle — tableau de sous-chaînes UTF-8 à rechercher. Array(String)
Valeur renvoyée Position la plus à gauche dans une chaîne haystack correspondant à l’une des chaînes needle. Renvoie 0 s’il n’y a aucune correspondance. UInt64 Exemples Trouver la position la plus à gauche dans la chaîne UTF-8 ‘Здравствуй, мир’ (‘Bonjour, monde’) qui correspond à l’une des chaînes needle données
Query
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
Response
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       4 │
└─────────────────────────────────────────────────────────────────────────┘

​
ngramDistance

Introduit dans : v20.1.0 Calcule la distance 4-gram entre deux chaînes. Pour ce faire, elle calcule la différence symétrique entre deux multiensembles de 4-grammes et la normalise par la somme de leurs cardinalités. Plus la valeur renvoyée est faible, plus les chaînes sont similaires. Pour une recherche insensible à la casse et/ou au format UTF8, utilisez les fonctions ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8. Syntaxe 
ngramDistance(haystack, needle)
Arguments
  • haystack — Chaîne de caractères de comparaison. String
  • needle — Chaîne de caractères de comparaison. String
Valeur renvoyée Renvoie un nombre Float32 compris entre 0 et 1. Plus la valeur renvoyée est faible, plus les chaînes sont similaires. Float32 Exemples Calcul de la distance de 4-grammes
Query
SELECT ngramDistance('ClickHouse', 'ClickHouses')
Response
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitive

Introduite dans : v20.1.0 Fournit une variante de ngramDistance insensible à la casse. Calcule la distance de 4-grammes entre deux chaînes de caractères, sans tenir compte de la casse. Plus la valeur renvoyée est faible, plus les chaînes sont similaires. Syntaxe 
ngramDistanceCaseInsensitive(haystack, needle)
Arguments
  • haystack — Première chaîne de comparaison. String
  • needle — Deuxième chaîne de comparaison. String
Valeur renvoyée Renvoie un nombre Float32 compris entre 0 et 1. Float32 Exemples Distance de 4-grammes insensible à la casse
Query
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
Response
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitiveUTF8

Introduit dans : v20.1.0 Fournit une variante UTF-8 insensible à la casse de ngramDistance. Suppose que les chaînes needle et haystack sont encodées en UTF-8 et ignore la casse. Calcule la distance de 3-grammes entre deux chaînes UTF-8, sans tenir compte de la casse. Plus la valeur renvoyée est faible, plus les chaînes se ressemblent. Syntaxe 
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
Arguments
  • haystack — Première chaîne de comparaison codée en UTF-8. String
  • needle — Deuxième chaîne de comparaison codée en UTF-8. String
Valeur renvoyée Renvoie un nombre Float32 compris entre 0 et 1. Float32 Exemples Distance de 3-grammes UTF-8 insensible à la casse
Query
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
Response
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

​
ngramDistanceUTF8

Introduit dans : v20.1.0 Fournit une variante UTF-8 de ngramDistance. Suppose que les chaînes needle et haystack sont encodées en UTF-8. Calcule la distance de 3-grammes entre deux chaînes UTF-8. Plus la valeur renvoyée est faible, plus les chaînes sont similaires. Syntaxe 
ngramDistanceUTF8(haystack, needle)
Arguments
  • haystack — Première chaîne de comparaison encodée en UTF-8. String
  • needle — Deuxième chaîne de comparaison encodée en UTF-8. String
Valeur renvoyée Renvoie un nombre Float32 compris entre 0 et 1. Float32 Exemples Distance de 3-grammes UTF-8
Query
SELECT ngramDistanceUTF8('abcde','cde')
Response
┌─ngramDistanceUTF8('abcde','cde')─┐
│                               0.5 │
└───────────────────────────────────┘

​
ngramSearch

Introduit dans : v20.1.0 Vérifie si la distance de 4-grammes entre deux chaînes est inférieure ou égale à un seuil donné. Pour une recherche insensible à la casse et/ou au format UTF8, utilisez les fonctions ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8. Syntaxe 
ngramSearch(haystack, needle)
Arguments
  • haystack — Chaîne à comparer. String
  • needle — Chaîne à comparer. String
Valeur renvoyée Renvoie 1 si la distance de 4-grammes entre les chaînes est inférieure ou égale à un seuil (1.0 par défaut), sinon 0. UInt8 Exemples Recherche par 4-grammes
Query
SELECT ngramSearch('ClickHouse', 'Click')
Response
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

​
ngramSearchCaseInsensitive

Introduite dans : v20.1.0 Fournit une variante insensible à la casse de ngramSearch. Calcule la différence non symétrique entre la chaîne needle et la chaîne haystack, c’est-à-dire le nombre de n-grammes de needle moins le nombre de n-grammes communs, normalisé par le nombre de n-grammes de needle. Vérifie si la distance de 4-grammes entre deux chaînes est inférieure ou égale à un seuil donné, sans tenir compte de la casse. Syntaxe 
ngramSearchCaseInsensitive(haystack, needle)
Arguments
  • haystack — Chaîne à comparer. String
  • needle — Chaîne à comparer. String
Valeur renvoyée Renvoie 1 si la distance en 4-grammes entre les chaînes est inférieure ou égale à un seuil (1.0 par défaut), sinon 0. UInt8 Exemples Recherche insensible à la casse à l’aide de 4-grammes
Query
SELECT ngramSearchCaseInsensitive('Hello World','hello')
Response
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

​
ngramSearchCaseInsensitiveUTF8

Introduit dans : v20.1.0 Fournit une variante UTF-8 insensible à la casse de ngramSearch. Considère que haystack et needle sont des chaînes UTF-8 et ignore la casse. Vérifie si la distance de 3-grammes entre deux chaînes UTF-8 est inférieure ou égale à un seuil donné, sans tenir compte de la casse. Syntaxe 
ngramSearchCaseInsensitiveUTF8(haystack, needle)
Arguments
  • haystack — chaîne UTF-8 à comparer. String
  • needle — chaîne UTF-8 à comparer. String
Valeur renvoyée Renvoie 1 si la distance de 3-grammes entre les chaînes est inférieure ou égale à un seuil (1.0 par défaut), sinon 0. UInt8 Exemples Recherche UTF-8 insensible à la casse à l’aide de 3-grammes
Query
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
Response
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

​
ngramSearchUTF8

Introduit dans : v20.1.0 Fournit une variante UTF-8 de ngramSearch. Suppose que haystack et needle sont des chaînes en UTF-8. Vérifie si la distance 3-grammes entre deux chaînes en UTF-8 est inférieure ou égale à un seuil donné. Syntaxe 
ngramSearchUTF8(haystack, needle)
Arguments
  • haystack — chaîne UTF-8 de comparaison. String
  • needle — chaîne UTF-8 de comparaison. String
Valeur renvoyée Renvoie 1 si la distance de 3-grammes entre les chaînes est inférieure ou égale à un seuil (1.0 par défaut), sinon 0. UInt8 Exemples Recherche UTF-8 avec des 3-grammes
Query
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
Response
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                      1 │
└────────────────────────────────────────┘

​
notILike

Introduit dans : v20.6.0 Vérifie si une chaîne ne correspond pas à un motif, sans tenir compte de la casse. Le motif peut contenir les caractères spéciaux % et _ pour la correspondance SQL LIKE. Prend en charge la clause facultative ESCAPE (voir like). Syntaxe 
notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']
Arguments
  • haystack — La chaîne d’entrée dans laquelle effectuer la recherche. String ou FixedString
  • pattern — Le motif SQL LIKE à appliquer. % correspond à un nombre quelconque de caractères (y compris zéro), _ correspond à exactement un caractère. String
  • escape_character — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de \. Par défaut : \. String
Valeur renvoyée Renvoie 1 si la chaîne ne correspond pas au motif (insensible à la casse), sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT notILike('ClickHouse', '%house%');
Response
┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

​
notLike

Introduit dans : v1.1.0 Semblable à like, mais en inverse le résultat. Prend en charge la clause ESCAPE facultative (voir like). Syntaxe 
notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou FixedString
  • pattern — Motif LIKE auquel la chaîne est comparée. String
  • escape_character — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de \. Par défaut : \. String
Valeur renvoyée Renvoie 1 si la chaîne ne correspond pas au motif LIKE, sinon 0. UInt8 Exemples Exemple d’utilisation
Query
SELECT notLike('ClickHouse', '%House%');
Response
┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘
Motif sans correspondance
Query
SELECT notLike('ClickHouse', '%SQL%');
Response
┌─notLike('Cli⋯', '%SQL%')─┐
│                        1 │
└──────────────────────────┘

​
position

Introduit dans : v1.1.0 Renvoie la position (en octets, à partir de 1) d’une sous-chaîne needle dans une chaîne haystack. Si la sous-chaîne needle est vide, les règles suivantes s’appliquent :
  • si aucun start_pos n’est spécifié : renvoyer 1
  • si start_pos = 0 : renvoyer 1
  • si start_pos >= 1 et start_pos <= length(haystack) + 1 : renvoyer start_pos
  • sinon : renvoyer 0
Les mêmes règles s’appliquent également aux fonctions locate, positionCaseInsensitive, positionUTF8 et positionCaseInsensitiveUTF8. Syntaxe 
position(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Position dans haystack à partir de laquelle la recherche commence (indexation à partir de 1). Facultatif. UInt
Valeur renvoyée Renvoie la position de début en octets, en comptant à partir de 1, si la sous-chaîne est trouvée ; sinon, renvoie 0 si la sous-chaîne n’est pas trouvée. UInt64 Exemples Utilisation de base
Query
SELECT position('Hello, world!', '!')
Response
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘
Avec l’argument start_pos
Query
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
Response
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘
Syntaxe needle IN haystack
Query
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
Response
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘
Sous-chaîne recherchée vide
Query
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
Response
┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐
│                   1 │                      1 │                      1 │                      2 │                      3 │                      4 │                      0 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘

​
positionCaseInsensitive

Introduit dans : v1.1.0 Comme position, mais insensible à la casse. Syntaxe 
positionCaseInsensitive(haystack, needle[, start_pos])
Alias : instr Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Facultatif. Position (à partir de 1) dans haystack à laquelle la recherche commence. UInt*
Valeur renvoyée Renvoie la position de début, en octets et à partir de 1, si la sous-chaîne est trouvée ; sinon, 0. UInt64 Exemples Recherche insensible à la casse
Query
SELECT positionCaseInsensitive('Hello, world!', 'hello')
Response
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

​
positionCaseInsensitiveUTF8

Introduit dans : v1.1.0 Semblable à positionUTF8, mais effectue la recherche sans tenir compte de la casse. Syntaxe 
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Facultatif. Position (à partir de 1) dans haystack à laquelle la recherche commence. UInt*
Valeur renvoyée Renvoie la position de début en octets, en comptant à partir de 1, si la sous-chaîne a été trouvée ; sinon, 0 si elle n’a pas été trouvée. UInt64 Exemples Recherche UTF-8 insensible à la casse
Query
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
Response
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

​
positionUTF8

Introduit dans : v1.1.0 Comme position, mais suppose que haystack et needle sont des chaînes codées en UTF-8. Syntaxe 
positionUTF8(haystack, needle[, start_pos])
Arguments
  • haystack — Chaîne dans laquelle la recherche est effectuée. String ou Enum
  • needle — Sous-chaîne à rechercher. String
  • start_pos — Facultatif. Position (indexée à partir de 1) dans haystack à partir de laquelle la recherche commence. UInt*
Valeur renvoyée Renvoie la position de début en octets, en comptant à partir de 1, si la sous-chaîne est trouvée ; sinon, 0. UInt64 Exemples Comptage des caractères UTF-8
Query
SELECT positionUTF8('Motörhead', 'r')
Response
┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
Dernière modification le 25 juin 2026