> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Documentation des fonctions de recherche dans les chaînes
# Fonctions de recherche dans les chaînes
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\*()](/fr/reference/functions/regular-functions/string-functions#normalizeUTF8NFC) à cette fin.
Les [fonctions générales sur les chaînes](/fr/reference/functions/regular-functions/string-functions) et les [fonctions de remplacement dans les chaînes](/fr/reference/functions/regular-functions/string-replace-functions) sont décrites séparément.
La documentation ci-dessous est générée à partir de la table système `system.functions`.
{/*AUTOGENERATED_START*/}
## countMatches
Introduit dans : v21.1.0
Renvoie le nombre de correspondances d'une expression régulière dans une chaîne.
**Comportement selon la version**
Le 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**
```sql theme={null}
countMatches(haystack, pattern)
```
**Arguments**
* `haystack` — La chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Motif d’expression régulière. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre de correspondances trouvées. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Compter les séquences de chiffres**
```sql title=Query theme={null}
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
```
```response title=Response theme={null}
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│ 2 │
└─────────────────────────────────────────────────────┘
```
## countMatchesCaseInsensitive
Introduite dans : v21.1.0
Comme [`countMatches`](#countMatches), mais effectue une correspondance sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
countMatchesCaseInsensitive(haystack, pattern)
```
**Arguments**
* `haystack` — La chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Motif d'expression régulière. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le nombre de correspondances trouvées. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Comptage insensible à la casse**
```sql title=Query theme={null}
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
countSubstrings(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [String](/fr/reference/data-types/string) ou [Enum](/fr/reference/data-types/enum). - `needle` — Sous-chaîne à rechercher. [String](/fr/reference/data-types/string). - `start_pos` — Position (à partir de 1) dans `haystack` à laquelle la recherche commence. [UInt](/fr/reference/data-types/int-uint). Facultatif.
**Valeur de retour**
Le nombre d'occurrences. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT countSubstrings('aaaa', 'aa');
```
```response title=Response theme={null}
┌─countSubstrings('aaaa', 'aa')─┐
│ 2 │
└───────────────────────────────┘
```
**Avec l’argument start\_pos**
```sql title=Query theme={null}
SELECT countSubstrings('abc___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│ 1 │
└────────────────────────────────────────┘
```
## countSubstringsCaseInsensitive
Introduit dans : v21.1.0
Comme [`countSubstrings`](#countSubstrings), mais effectue le comptage sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Facultatif. Position (à partir de 1) dans `haystack` à laquelle la recherche commence. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie le nombre d'occurrences de `needle` dans `haystack`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
```
```response title=Response theme={null}
┌─countSubstri⋯AAA', 'aa')─┐
│ 2 │
└──────────────────────────┘
```
**Avec l’argument start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'abc', 4)─┐
│ 2 │
└──────────────────────────┘
```
## countSubstringsCaseInsensitiveUTF8
Introduit dans : v21.1.0
Comme [`countSubstrings`](#countSubstrings), mais compte sans distinction entre majuscules et minuscules et suppose que haystack est une chaîne UTF-8.
**Syntaxe**
```sql theme={null}
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne UTF-8 dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Facultatif. Position (à partir de 1) dans `haystack` à laquelle la recherche commence. [`UInt*`](/fr/reference/data-types/int-uint)
**Valeur renvoyée**
Renvoie le nombre d'occurrences de `needle` dans `haystack`. [`UInt64`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
```
```response title=Response theme={null}
┌─countSubstri⋯шка', 'КА')─┐
│ 4 │
└──────────────────────────┘
```
**Avec l’argument start\_pos**
```sql title=Query theme={null}
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
```
```response title=Response theme={null}
┌─countSubstri⋯, 'КА', 13)─┐
│ 2 │
└──────────────────────────┘
```
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](https://github.com/google/re2/wiki/Syntax) 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**
```sql theme={null}
extract(haystack, pattern)
```
**Arguments**
* `haystack` — Chaîne à partir de laquelle extraire. [`String`](/fr/reference/data-types/string)
* `pattern` — Expression régulière, contenant généralement un groupe de capture. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le fragment extrait sous forme de chaîne. [`String`](/fr/reference/data-types/string)
**Exemples**
**Extraire le domaine d’une adresse e-mail**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', '.*@(.*)$')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com │
└───────────────────────────────────────────┘
```
**En l'absence de correspondance, une chaîne vide est renvoyée**
```sql title=Query theme={null}
SELECT extract('test@clickhouse.com', 'no_match')
```
```response title=Response theme={null}
┌─extract('test@clickhouse.com', 'no_match')─┐
│ │
└────────────────────────────────────────────┘
```
Introduite dans : v1.1.0
Comme [`extract`](#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**
```sql theme={null}
extractAll(haystack, pattern)
```
**Arguments**
* `haystack` — Chaîne dont extraire les fragments. [`String`](/fr/reference/data-types/string)
* `pattern` — Expression régulière pouvant contenir des groupes de capture. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un tableau contenant les fragments extraits. [`Array(String)`](/fr/reference/data-types/array)
**Exemples**
**Extraire tous les nombres**
```sql title=Query theme={null}
SELECT extractAll('hello 123 world 456', '[0-9]+')
```
```response title=Response theme={null}
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456'] │
└─────────────────────────────────────────────┘
```
**Extraire à l’aide d’un groupe de capture**
```sql title=Query theme={null}
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
```
```response title=Response theme={null}
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user'] │
└────────────────────────────────────────────────────────────────────┘
```
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**
```sql theme={null}
extractAllGroupsHorizontal(s, regexp)
```
**Arguments**
* `s` — Chaîne d'entrée à partir de laquelle extraire. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `regexp` — Expression régulière à faire correspondre. [`const String`](/fr/reference/data-types/string) ou [`const FixedString`](/fr/reference/data-types/fixedstring)
**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))`](/fr/reference/data-types/array)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
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 title=Response theme={null}
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]
```
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`](#extractAllGroupsHorizontal) ou [`extractAllGroupsVertical`](/fr/reference/functions/regular-functions/splitting-merging-functions#extractAllGroupsVertical).
**Syntaxe**
```sql theme={null}
extractGroups(s, regexp)
```
**Arguments**
* `s` — Chaîne d’entrée dans laquelle extraire. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `regexp` — Expression régulière. Doit contenir au moins un groupe de capture. Constante. [`const String`](/fr/reference/data-types/string) ou [`const FixedString`](/fr/reference/data-types/fixedstring)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
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 title=Response theme={null}
['Server','nginx']
```
## hasAllTokens
Introduit dans : v25.10.0
Comme [`hasAnyTokens`](#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](/fr/reference/engines/table-engines/mergetree-family/textindexes) 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](/fr/reference/data-types/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)](/fr/reference/data-types/array), 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](/fr/reference/engines/table-engines/mergetree-family/textindexes#creating-a-text-index) (par exemple `lowerUTF8`), `hasAllTokens` l'applique à `input` et, lorsque `needles` est un [String](/fr/reference/data-types/string), à `needles` avant la tokenisation. Lorsque `needles` est un [Array(String)](/fr/reference/data-types/array), 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**
```sql theme={null}
hasAllTokens(input, needles)
```
**Alias** : `hasAllToken`
**Arguments**
* `input` — La colonne d’entrée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Array(String)`](/fr/reference/data-types/array) ou [`Array(FixedString)`](/fr/reference/data-types/array)
* `needles` — Les tokens à rechercher. [`String`](/fr/reference/data-types/string) ou [`Array(String)`](/fr/reference/data-types/array)
* `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`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie 1 si tous les `needles` correspondent. Sinon, renvoie 0. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base avec un `needle` de type chaîne**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Spécifiez un tableau de motifs à rechercher tels quels (sans tokenisation)**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Générer des needles à l’aide de la fonction `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Utilisez un tokenizer personnalisé avec le 3e argument**
```sql title=Query theme={null}
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
```
```response title=Response theme={null}
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│ 1 │
└──────────────────────────────────────────────┘
```
**Exemples d'utilisation des colonnes Array et Map**
```sql title=Query theme={null}
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 title=Response theme={null}
```
**Exemple avec une colonne de type Array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Exemple avec mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Exemple avec mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─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](/fr/reference/engines/table-engines/mergetree-family/textindexes) 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](/fr/reference/data-types/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)](/fr/reference/data-types/array), 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](/fr/reference/engines/table-engines/mergetree-family/textindexes#creating-a-text-index) (par exemple `lowerUTF8`), `hasAnyTokens` l'applique à `input` et, lorsque `needles` est une [String](/fr/reference/data-types/string), à `needles` avant la tokenisation. Lorsque `needles` est un [Array(String)](/fr/reference/data-types/array), 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**
```sql theme={null}
hasAnyTokens(input, needles)
```
**Alias** : `hasAnyToken`
**Arguments**
* `input` — La colonne d’entrée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring) ou [`Nullable(String)`](/fr/reference/data-types/nullable) ou [`Nullable(FixedString)`](/fr/reference/data-types/nullable) ou [`Array(String)`](/fr/reference/data-types/array) ou [`Array(FixedString)`](/fr/reference/data-types/array) ou [`Array(Nullable(String))`](/fr/reference/data-types/array) ou [`Array(Nullable(FixedString))`](/fr/reference/data-types/array)
* `needles` — Les tokens à rechercher. [`String`](/fr/reference/data-types/string) ou [`Array(String)`](/fr/reference/data-types/array)
* `tokenizer` — Le tokenizer à utiliser. Les arguments valides sont `splitByNonAlpha`, `splitByString`, `asciiCJK`, `ngrams`, `sparseGrams` et `array`. Ce paramètre est facultatif ; s’il n’est pas défini explicitement, la valeur par défaut est `splitByNonAlpha`. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` s’il existe au moins une correspondance. `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base avec une chaîne comme terme recherché**
```sql title=Query theme={null}
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 title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Spécifier les motifs à rechercher tels quels (sans tokenisation) dans un tableau**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Générez des needles avec la fonction `tokens`**
```sql title=Query theme={null}
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
```
```response title=Response theme={null}
┌─count()─┐
│ 3 │
└─────────┘
```
**Exemples d’utilisation de colonnes array et map**
```sql title=Query theme={null}
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 title=Response theme={null}
```
**Exemple avec une colonne Array**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
```
```response title=Response theme={null}
┌─count()─┐
│ 1 │
└─────────┘
```
**Exemple avec mapKeys**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
```
```response title=Response theme={null}
┌─count()─┐
│ 2 │
└─────────┘
```
**Exemple avec mapValues**
```sql title=Query theme={null}
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
```
```response title=Response theme={null}
┌─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](/fr/reference/engines/table-engines/mergetree-family/textindexes) 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](/fr/reference/engines/table-engines/mergetree-family/textindexes#creating-a-text-index) (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`](#hasToken), [`hasAnyTokens`](#hasAnyTokens) et [`hasAllTokens`](#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**
```sql theme={null}
hasPhrase(input, phrase[, tokenizer])
```
**Alias** : `matchPhrase`
**Arguments**
* `input` — La colonne d’entrée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `phrase` — Phrase à rechercher. [`const String`](/fr/reference/data-types/string)
* `tokenizer` — Le tokenizer à utiliser. Facultatif, `splitByNonAlpha` est utilisé par défaut. [`const String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
**Exemples**
**Correspondance de phrase**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
```
```response title=Response theme={null}
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│ 1 │
└────────────────────────────────────────────────────────┘
```
**Tokens non consécutifs**
```sql title=Query theme={null}
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
hasSubsequence(haystack, needle)
```
**Arguments**
* `haystack` — Chaîne dans laquelle rechercher la sous-séquence. [`String`](/fr/reference/data-types/string)
* `needle` — Sous-séquence à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `needle` est une sous-séquence de `haystack`, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Vérification de base d'une sous-séquence**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'HlWrd')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│ 1 │
└────────────────────────────────────────┘
```
**Aucune sous-séquence n’a été trouvée**
```sql title=Query theme={null}
SELECT hasSubsequence('Hello World', 'xyz')
```
```response title=Response theme={null}
┌─hasSubsequence('Hello World', 'xyz')─┐
│ 0 │
└──────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitive
Introduit dans : v23.7.0
Comme [`hasSubsequence`](#hasSubsequence), mais effectue une recherche sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
hasSubsequenceCaseInsensitive(haystack, needle)
```
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needle` — Sous-séquence à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie 1 si needle est une sous-séquence de haystack, sinon 0. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
```
```response title=Response theme={null}
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│ 1 │
└─────────────────────────────────────────────────┘
```
## hasSubsequenceCaseInsensitiveUTF8
Introduit dans : v23.7.0
Comme [`hasSubsequenceUTF8`](#hasSubsequenceUTF8), mais la recherche s’effectue sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
```
**Arguments**
* `haystack` — chaîne encodée en UTF8 dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needle` — motif de sous-séquence encodé en UTF8 à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie 1 si `needle` est une sous-séquence de `haystack`, sinon 0. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
```
```response title=Response theme={null}
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│ 1 │
└──────────────────────────┘
```
## hasSubsequenceUTF8
Introduit dans : v23.7.0
Comme [`hasSubsequence`](/fr/reference/functions/regular-functions/string-search-functions#hasSubsequence), mais suppose que `haystack` et `needle` sont des chaînes encodées en UTF-8.
**Syntaxe**
```sql theme={null}
hasSubsequenceUTF8(haystack, needle)
```
**Arguments**
* `haystack` — La chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needle` — Le motif à rechercher. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si `needle` est une sous-séquence de `haystack`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'кошка');
```
```response title=Response theme={null}
┌─hasSubsequen⋯', 'кошка')─┐
│ 1 │
└──────────────────────────┘
```
**Sous-séquence non correspondante**
```sql title=Query theme={null}
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
```
```response title=Response theme={null}
┌─hasSubsequen⋯'апельсин')─┐
│ 0 │
└──────────────────────────┘
```
## hasToken
Introduit dans : v20.1.0
Vérifie si le token donné est présent dans la chaîne.
Utilise [splitByNonAlpha](/fr/reference/functions/regular-functions/splitting-merging-functions#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**
```sql theme={null}
hasToken(haystack, token)
```
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `token` — Token à rechercher. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si le token est trouvé, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche de token**
```sql title=Query theme={null}
SELECT hasToken('clickhouse test', 'test')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
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**
```sql theme={null}
hasTokenCaseInsensitiveOrNull(haystack, needle)
```
**Arguments**
* Aucun.
**Valeur renvoyée**
**Exemples**
## hasTokenOrNull
Introduit dans : v20.1.0
Comme [`hasToken`](#hasToken), mais renvoie NULL si le token est mal formé.
**Syntaxe**
```sql theme={null}
hasTokenOrNull(haystack, token)
```
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. Doit être constante. [`String`](/fr/reference/data-types/string)
* `token` — Token à rechercher. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si le token est trouvé, `0` sinon, `NULL` si le token est mal formé. [`Nullable(UInt8)`](/fr/reference/data-types/nullable)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
highlight(haystack, needles[, open_tag, close_tag])
```
**Arguments**
* `haystack` — Le texte dans lequel effectuer la recherche. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `needles` — Un tableau de termes de recherche à mettre en évidence. [`const Array(String)`](/fr/reference/data-types/array)
* `open_tag` — La balise ouvrante à insérer avant chaque correspondance. Par défaut : ``. [`const String`](/fr/reference/data-types/string)
* `close_tag` — La balise fermante à insérer après chaque correspondance. Par défaut : ``. [`const String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie le texte d’entrée avec les termes correspondants entourés des balises spécifiées. [`String`](/fr/reference/data-types/string)
**Exemples**
**Mise en évidence simple**
```sql title=Query theme={null}
SELECT highlight('The quick brown fox', ['quick', 'fox'])
```
```response title=Response theme={null}
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The quick brown fox │
└────────────────────────────────────────────────────┘
```
**Tags personnalisés**
```sql title=Query theme={null}
SELECT highlight('Hello World', ['hello'], '', '')
```
```response title=Response theme={null}
┌─highlight('Hello World', ['hello'], '', '')─┐
│ Hello World │
└────────────────────────────────────────────────────┘
```
## ilike
Introduit dans : v20.6.0
Comme [`like`](#like), mais effectue une recherche sans tenir compte de la casse. Prend en charge la clause `ESCAPE` facultative (voir `like`).
**Syntaxe**
```sql theme={null}
ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `pattern` — Motif LIKE auquel la chaîne doit correspondre. [`String`](/fr/reference/data-types/string)
* `escape_character` — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de `\`. Par défaut : `\`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la chaîne correspond au motif LIKE (insensible à la casse), sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT ilike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─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](/fr/reference/syntax#string) ; 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**
```sql theme={null}
like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/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`](/fr/reference/data-types/string)
* `escape_character` — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de `\\`. Par défaut : `\\`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la chaîne correspond au motif `LIKE`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%House');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%House')─┐
│ 1 │
└──────────────────────────────┘
```
**Joker à un seul caractère**
```sql title=Query theme={null}
SELECT like('ClickHouse', 'Click_ouse');
```
```response title=Response theme={null}
┌─like('ClickH⋯lick_ouse')─┐
│ 1 │
└──────────────────────────┘
```
**Motif sans correspondance**
```sql title=Query theme={null}
SELECT like('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─like('ClickHouse', '%SQL%')─┐
│ 0 │
└─────────────────────────────┘
```
**Clause ESCAPE**
```sql title=Query theme={null}
SELECT '50%off' LIKE '50#%off' ESCAPE '#';
```
```response title=Response theme={null}
┌─like('50%off', '50#%off', '#')─┐
│ 1 │
└────────────────────────────────┘
```
## locate
Introduit dans : v18.16.0
Comme [`position`](#position), mais avec les arguments `haystack` et `locate` inversés.
**Comportement selon la version**
Le 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**
```sql theme={null}
locate(needle, haystack[, start_pos])
```
**Arguments**
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `start_pos` — Facultatif. Position (indexée à partir de 1) dans `haystack` à partir de laquelle la recherche commence. [`UInt`](/fr/reference/data-types/int-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`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT locate('ca', 'abcabc')
```
```response title=Response theme={null}
┌─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](https://github.com/google/re2/wiki/Syntax) 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`](#like) ou [`position`](#position), qui sont bien plus rapides que cette fonction.
Syntaxe d’opérateur alternative : `haystack REGEXP pattern`.
**Syntaxe**
```sql theme={null}
match(haystack, pattern)
```
**Alias** : `REGEXP_MATCHES`
**Arguments**
* `haystack` — Chaîne dans laquelle le motif est recherché. [`String`](/fr/reference/data-types/string)
* `pattern` — Motif d’expression régulière. Peut être une constante ou provenir d’un colonne. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si le motif correspond, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Correspondance simple de motifs**
```sql title=Query theme={null}
SELECT match('Hello World', 'Hello.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'Hello.*')─┐
│ 1 │
└─────────────────────────────────┘
```
**Motif sans correspondance**
```sql title=Query theme={null}
SELECT match('Hello World', 'goodbye.*')
```
```response title=Response theme={null}
┌─match('Hello World', 'goodbye.*')─┐
│ 0 │
└───────────────────────────────────┘
```
**Correspondance avec une sous-chaîne**
```sql title=Query theme={null}
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
```
```response title=Response theme={null}
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│ 1 │ 0 │
└─────────────────────────┴───────────────────────────┘
```
## multiFuzzyMatchAllIndices
Introduit dans : v20.1.0
Comme [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), mais renvoie le tableau de tous les indices correspondant, dans un ordre quelconque, à la chaîne recherchée avec une [distance d’édition](https://en.wikipedia.org/wiki/Edit_distance) constante.
**Syntaxe**
```sql theme={null}
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `distance` — Distance d’édition maximale pour la correspondance approximative. [`UInt8`](/fr/reference/data-types/int-uint)
* `pattern` — Tableau de motifs à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2] │
└──────────────────────────┘
```
## multiFuzzyMatchAny
Introduit dans : v20.1.0
Comme [`multiMatchAny`](#multiMatchAny), mais renvoie 1 si un motif correspond à la chaîne recherchée pour une [distance d’édition](https://en.wikipedia.org/wiki/Edit_distance) constante.
Cette fonction s’appuie sur la fonctionnalité expérimentale de la bibliothèque [hyperscan](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching) 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**
```sql theme={null}
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `distance` — Distance d’édition maximale pour la correspondance approximative. [`UInt8`](/fr/reference/data-types/int-uint)
* `pattern` — Facultatif. Tableau de motifs à comparer. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯lickHose'])─┐
│ 1 │
└──────────────────────────┘
```
## multiFuzzyMatchAnyIndex
Introduite dans : v20.1.0
Comme [`multiFuzzyMatchAny`](#multiFuzzyMatchAny), mais renvoie un indice correspondant à la chaîne dans une [distance d’édition](https://en.wikipedia.org/wiki/Edit_distance) constante.
**Syntaxe**
```sql theme={null}
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `distance` — Distance d’édition maximale pour la correspondance approximative. [`UInt8`](/fr/reference/data-types/int-uint)
* `pattern` — Tableau de motifs à mettre en correspondance. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
```
```response title=Response theme={null}
┌─multiFuzzyMa⋯ickHouse'])─┐
│ 2 │
└──────────────────────────┘
```
## multiMatchAllIndices
Introduit dans : v20.1.0
Comme [`multiMatchAny`](#multiMatchAny), mais renvoie le tableau de tous les indices qui correspondent à la chaîne analysée, dans n’importe quel ordre.
**Syntaxe**
```sql theme={null}
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `pattern` — Expressions régulières à rechercher. [`String`](/fr/reference/data-types/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)`](/fr/reference/data-types/array)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
```
```response title=Response theme={null}
┌─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`](#multiSearchAny) à la place - elle est bien plus rapide que celle-ci.
**Syntaxe**
```sql theme={null}
multiMatchAny(haystack, pattern1[, pattern2, ...])
```
**Arguments**
* `haystack` — Chaîne dans laquelle les motifs sont recherchés. [`String`](/fr/reference/data-types/string)
* `pattern1[, pattern2, ...]` — Tableau contenant un ou plusieurs motifs d’expression régulière. [`Array(String)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` si l’un des motifs correspond, `0` sinon. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Correspondance avec plusieurs motifs**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
**Aucun des motifs ne correspond**
```sql title=Query theme={null}
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
```
```response title=Response theme={null}
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│ 0 │
└──────────────────────────────────────────────────────┘
```
## multiMatchAnyIndex
Introduit dans : v20.1.0
Comme [`multiMatchAny`](#multiMatchAny), mais renvoie l’un des indices correspondant à la chaîne analysée.
**Syntaxe**
```sql theme={null}
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
```
**Arguments**
* `haystack` — Chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `pattern` — Expressions régulières à mettre en correspondance. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
```
```response title=Response theme={null}
┌─multiMatchAn⋯, 'Click'])─┐
│ 3 │
└──────────────────────────┘
```
## multiSearchAllPositions
Introduit dans : v20.1.0
Comme [`position`](#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**
```sql theme={null}
multiSearchAllPositions(haystack, needle1[, needle2, ...])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle1[, needle2, ...]` — Tableau d'une ou plusieurs sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Recherche de plusieurs sous-chaînes**
```sql title=Query theme={null}
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
```
```response title=Response theme={null}
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└───────────────────────────────────────────────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitive
Introduit dans : v20.1.0
Comme [`multiSearchAllPositions`](#multiSearchAllPositions), mais sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle1[, needle2, ...]` — Tableau d’une ou plusieurs sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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)`](/fr/reference/data-types/array)
**Exemples**
**Recherche multiple insensible à la casse**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6] │
└──────────────────────────┘
```
## multiSearchAllPositionsCaseInsensitiveUTF8
Introduit dans : v20.1.0
Identique à [`multiSearchAllPositionsUTF8`](#multiSearchAllPositionsUTF8), mais sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne encodée en UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — sous-chaînes encodées en UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/array)
**Exemples**
**Recherche UTF-8 insensible à la casse**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
```
```response title=Response theme={null}
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13] │
└──────────────────────────┘
```
## multiSearchAllPositionsUTF8
Introduit dans : v20.1.0
Comme [`multiSearchAllPositions`](#multiSearchAllPositions), mais suppose que `haystack` et les sous-chaînes `needle` sont des chaînes encodées en UTF-8.
**Syntaxe**
```sql theme={null}
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
```
**Arguments**
* `haystack` — Chaîne encodée en UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle1[, needle2, ...]` — Tableau de sous-chaînes encodées en UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/array)
**Exemples**
**Recherche multiple en UTF-8**
```sql title=Query theme={null}
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─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`](#multiSearchAnyCaseInsensitive), [`multiSearchAnyUTF8`](#multiSearchAnyUTF8) et [`multiSearchAnyCaseInsensitiveUTF8`](#multiSearchAnyCaseInsensitiveUTF8) fournissent des variantes insensibles à la casse et/ou en UTF-8 de cette fonction.
**Syntaxe**
```sql theme={null}
multiSearchAny(haystack, needle1[, needle2, ...])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle1[, needle2, ...]` — Tableau de sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` s'il y a au moins une correspondance, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche d'au moins une correspondance**
```sql title=Query theme={null}
SELECT multiSearchAny('ClickHouse',['C','H'])
```
```response title=Response theme={null}
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│ 1 │
└──────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitive
Introduit dans : v20.1.0
Comme [multiSearchAny](#multiSearchAny), mais sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — Sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` s’il existe au moins une correspondance insensible à la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche insensible à la casse**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
```
```response title=Response theme={null}
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ 1 │
└─────────────────────────────────────────────────────────┘
```
## multiSearchAnyCaseInsensitiveUTF8
Introduit dans : v20.1.0
Comme [multiSearchAnyUTF8](#multiSearchAnyUTF8), mais sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — sous-chaînes UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoye `1` s'il existe au moins une correspondance insensible à la casse, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Étant donné la chaîne UTF-8 'Здравствуйте', vérifiez si le caractère 'з' (en minuscule) est présent**
```sql title=Query theme={null}
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
```
```response title=Response theme={null}
┌─multiSearchA⋯те', ['з'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchAnyUTF8
Introduit dans : v20.1.0
Semblable à [multiSearchAny](#multiSearchAny), mais suppose que `haystack` et les sous-chaînes `needle` sont encodées en UTF-8.
**Syntaxe**
```sql theme={null}
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — sous-chaînes UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**Valeur renvoyée**
Renvoie `1` s'il y a au moins une correspondance, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Étant donné '你好，世界' ('Hello, world') comme chaîne UTF-8, vérifiez si la chaîne contient les caractères 你 ou 界**
```sql title=Query theme={null}
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — La chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needles` — Tableau de chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d'utilisation**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 1 │
└──────────────────────────┘
```
**Sensibilité à la casse**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'Server'])─┐
│ 2 │
└──────────────────────────┘
```
**Aucune correspondance trouvée**
```sql title=Query theme={null}
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexCaseInsensitive
Introduit dans : v20.1.0
Renvoie l’indice `i` (à partir de 1) du `needle_i` trouvé le plus à gauche dans la chaîne `haystack`, et 0 sinon.
Sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — Sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — La chaîne dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needles` — Tableau de chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'server'])─┐
│ 1 │
└──────────────────────────┘
```
**Gestion de la casse en UTF-8**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
```
```response title=Response theme={null}
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│ 1 │
└──────────────────────────┘
```
**Aucune correspondance trouvée**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
```
```response title=Response theme={null}
┌─multiSearchF⋯', 'test'])─┐
│ 0 │
└──────────────────────────┘
```
## multiSearchFirstIndexUTF8
Introduit dans : v20.1.0
Renvoie l’index `i` (à partir de 1) du `needle_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**
```sql theme={null}
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — tableau de sous-chaînes UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
```
```response title=Response theme={null}
┌─multiSearchF⋯вствуйте'])─┐
│ 1 │
└──────────────────────────┘
```
## multiSearchFirstPosition
Introduit dans : v20.1.0
Comme [`position`](#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`](#multiSearchFirstPositionCaseInsensitive), [`multiSearchFirstPositionUTF8`](#multiSearchFirstPositionUTF8) et [`multiSearchFirstPositionCaseInsensitiveUTF8`](#multiSearchFirstPositionCaseInsensitiveUTF8) fournissent des variantes insensibles à la casse et/ou UTF-8 de cette fonction.
**Syntaxe**
```sql theme={null}
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle1[, needle2, ...]` — Tableau d'une ou plusieurs sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche de la première position**
```sql title=Query theme={null}
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
```
```response title=Response theme={null}
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│ 3 │
└───────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitive
Introduit dans : v20.1.0
Comme [multiSearchFirstPosition](#multiSearchFirstPosition), mais sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — Tableau de sous-chaînes à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**Exemples**
**Première position sans distinction de casse**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│ 2 │
└───────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionCaseInsensitiveUTF8
Introduit dans : v20.1.0
Comme [multiSearchFirstPosition](#multiSearchFirstPosition), mais considère `haystack` et `needle` comme des chaînes UTF-8 et ne tient pas compte de la casse.
**Syntaxe**
```sql theme={null}
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne UTF-8 dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string)
* `needle` — tableau de sous-chaînes UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**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**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
```
```response title=Response theme={null}
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│ 1 │
└────────────────────────────────────────────────────────────────────────────────────────┘
```
## multiSearchFirstPositionUTF8
Introduit dans : v20.1.0
Semblable à [multiSearchFirstPosition](#multiSearchFirstPosition), mais considère `haystack` et `needle` comme des chaînes UTF-8.
**Syntaxe**
```sql theme={null}
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
```
**Arguments**
* `haystack` — chaîne UTF-8 dans laquelle effectuer la recherche. [`String`](/fr/reference/data-types/string)
* `needle` — tableau de sous-chaînes UTF-8 à rechercher. [`Array(String)`](/fr/reference/data-types/array)
**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`](/fr/reference/data-types/int-uint)
**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**
```sql title=Query theme={null}
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
```
```response title=Response theme={null}
┌─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`](#ngramDistanceCaseInsensitive), [`ngramDistanceUTF8`](#ngramDistanceUTF8), [`ngramDistanceCaseInsensitiveUTF8`](#ngramDistanceCaseInsensitiveUTF8).
**Syntaxe**
```sql theme={null}
ngramDistance(haystack, needle)
```
**Arguments**
* `haystack` — Chaîne de caractères de comparaison. [`String`](/fr/reference/data-types/string)
* `needle` — Chaîne de caractères de comparaison. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/float)
**Exemples**
**Calcul de la distance de 4-grammes**
```sql title=Query theme={null}
SELECT ngramDistance('ClickHouse', 'ClickHouses')
```
```response title=Response theme={null}
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│ 0.1 │
└────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitive
Introduite dans : v20.1.0
Fournit une variante de [`ngramDistance`](#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**
```sql theme={null}
ngramDistanceCaseInsensitive(haystack, needle)
```
**Arguments**
* `haystack` — Première chaîne de comparaison. [`String`](/fr/reference/data-types/string)
* `needle` — Deuxième chaîne de comparaison. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre `Float32` compris entre `0` et `1`. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Distance de 4-grammes insensible à la casse**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│ 0 │
└─────────────────────────────────────────────────────────┘
```
## ngramDistanceCaseInsensitiveUTF8
Introduit dans : v20.1.0
Fournit une variante UTF-8 insensible à la casse de [`ngramDistance`](#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**
```sql theme={null}
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
```
**Arguments**
* `haystack` — Première chaîne de comparaison codée en UTF-8. [`String`](/fr/reference/data-types/string)
* `needle` — Deuxième chaîne de comparaison codée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre Float32 compris entre `0` et `1`. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Distance de 3-grammes UTF-8 insensible à la casse**
```sql title=Query theme={null}
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
```
```response title=Response theme={null}
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│ 0.5 │
└─────────────────────────────────────────────────┘
```
## ngramDistanceUTF8
Introduit dans : v20.1.0
Fournit une variante UTF-8 de [`ngramDistance`](#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**
```sql theme={null}
ngramDistanceUTF8(haystack, needle)
```
**Arguments**
* `haystack` — Première chaîne de comparaison encodée en UTF-8. [`String`](/fr/reference/data-types/string)
* `needle` — Deuxième chaîne de comparaison encodée en UTF-8. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie un nombre Float32 compris entre `0` et `1`. [`Float32`](/fr/reference/data-types/float)
**Exemples**
**Distance de 3-grammes UTF-8**
```sql title=Query theme={null}
SELECT ngramDistanceUTF8('abcde','cde')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
ngramSearch(haystack, needle)
```
**Arguments**
* `haystack` — Chaîne à comparer. [`String`](/fr/reference/data-types/string)
* `needle` — Chaîne à comparer. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche par 4-grammes**
```sql title=Query theme={null}
SELECT ngramSearch('ClickHouse', 'Click')
```
```response title=Response theme={null}
┌─ngramSearch('ClickHouse', 'Click')─┐
│ 1 │
└────────────────────────────────────┘
```
## ngramSearchCaseInsensitive
Introduite dans : v20.1.0
Fournit une variante insensible à la casse de [`ngramSearch`](#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**
```sql theme={null}
ngramSearchCaseInsensitive(haystack, needle)
```
**Arguments**
* `haystack` — Chaîne à comparer. [`String`](/fr/reference/data-types/string)
* `needle` — Chaîne à comparer. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche insensible à la casse à l’aide de 4-grammes**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitive('Hello World','hello')
```
```response title=Response theme={null}
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│ 1 │
└────────────────────────────────────────────────────┘
```
## ngramSearchCaseInsensitiveUTF8
Introduit dans : v20.1.0
Fournit une variante UTF-8 insensible à la casse de [`ngramSearch`](#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**
```sql theme={null}
ngramSearchCaseInsensitiveUTF8(haystack, needle)
```
**Arguments**
* `haystack` — chaîne UTF-8 à comparer. [`String`](/fr/reference/data-types/string)
* `needle` — chaîne UTF-8 à comparer. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche UTF-8 insensible à la casse à l’aide de 3-grammes**
```sql title=Query theme={null}
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
ngramSearchUTF8(haystack, needle)
```
**Arguments**
* `haystack` — chaîne UTF-8 de comparaison. [`String`](/fr/reference/data-types/string)
* `needle` — chaîne UTF-8 de comparaison. [`String`](/fr/reference/data-types/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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche UTF-8 avec des 3-grammes**
```sql title=Query theme={null}
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
```
```response title=Response theme={null}
┌─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**
```sql theme={null}
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`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `pattern` — Le motif SQL LIKE à appliquer. `%` correspond à un nombre quelconque de caractères (y compris zéro), `_` correspond à exactement un caractère. [`String`](/fr/reference/data-types/string)
* `escape_character` — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de `\`. Par défaut : `\`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la chaîne ne correspond pas au motif (insensible à la casse), sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT notILike('ClickHouse', '%house%');
```
```response title=Response theme={null}
┌─notILike('Cl⋯ '%house%')─┐
│ 0 │
└──────────────────────────┘
```
## notLike
Introduit dans : v1.1.0
Semblable à [`like`](#like), mais en inverse le résultat. Prend en charge la clause `ESCAPE` facultative (voir `like`).
**Syntaxe**
```sql theme={null}
notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`FixedString`](/fr/reference/data-types/fixedstring)
* `pattern` — Motif LIKE auquel la chaîne est comparée. [`String`](/fr/reference/data-types/string)
* `escape_character` — Chaîne facultative d’un seul caractère à utiliser comme caractère d’échappement à la place de `\`. Par défaut : `\`. [`String`](/fr/reference/data-types/string)
**Valeur renvoyée**
Renvoie `1` si la chaîne ne correspond pas au motif `LIKE`, sinon `0`. [`UInt8`](/fr/reference/data-types/int-uint)
**Exemples**
**Exemple d’utilisation**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%House%');
```
```response title=Response theme={null}
┌─notLike('Cli⋯ '%House%')─┐
│ 0 │
└──────────────────────────┘
```
**Motif sans correspondance**
```sql title=Query theme={null}
SELECT notLike('ClickHouse', '%SQL%');
```
```response title=Response theme={null}
┌─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`](#locate), [`positionCaseInsensitive`](#positionCaseInsensitive), [`positionUTF8`](#positionUTF8) et [`positionCaseInsensitiveUTF8`](#positionCaseInsensitiveUTF8).
**Syntaxe**
```sql theme={null}
position(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Position dans `haystack` à partir de laquelle la recherche commence (indexation à partir de 1). Facultatif. [`UInt`](/fr/reference/data-types/int-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`](/fr/reference/data-types/int-uint)
**Exemples**
**Utilisation de base**
```sql title=Query theme={null}
SELECT position('Hello, world!', '!')
```
```response title=Response theme={null}
┌─position('Hello, world!', '!')─┐
│ 13 │
└────────────────────────────────┘
```
**Avec l’argument start\_pos**
```sql title=Query theme={null}
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
```
```response title=Response theme={null}
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│ 5 │ 9 │
└───────────────────────────────────┴───────────────────────────────────┘
```
**Syntaxe needle IN haystack**
```sql title=Query theme={null}
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
```
```response title=Response theme={null}
┌─equals(6, position(s, '/'))─┐
│ 1 │
└─────────────────────────────┘
```
**Sous-chaîne recherchée vide**
```sql title=Query theme={null}
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
```
```response title=Response theme={null}
┌─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`](#position), mais insensible à la casse.
**Syntaxe**
```sql theme={null}
positionCaseInsensitive(haystack, needle[, start_pos])
```
**Alias** : `instr`
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Facultatif. Position (à partir de 1) dans `haystack` à laquelle la recherche commence. [`UInt*`](/fr/reference/data-types/int-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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche insensible à la casse**
```sql title=Query theme={null}
SELECT positionCaseInsensitive('Hello, world!', 'hello')
```
```response title=Response theme={null}
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1 │
└───────────────────────────────────────────────────┘
```
## positionCaseInsensitiveUTF8
Introduit dans : v1.1.0
Semblable à [`positionUTF8`](#positionUTF8), mais effectue la recherche sans tenir compte de la casse.
**Syntaxe**
```sql theme={null}
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Facultatif. Position (à partir de 1) dans `haystack` à laquelle la recherche commence. [`UInt*`](/fr/reference/data-types/int-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`](/fr/reference/data-types/int-uint)
**Exemples**
**Recherche UTF-8 insensible à la casse**
```sql title=Query theme={null}
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
```
```response title=Response theme={null}
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│ 8 │
└──────────────────────────────────────────────────┘
```
## positionUTF8
Introduit dans : v1.1.0
Comme [`position`](#position), mais suppose que `haystack` et `needle` sont des chaînes codées en UTF-8.
**Syntaxe**
```sql theme={null}
positionUTF8(haystack, needle[, start_pos])
```
**Arguments**
* `haystack` — Chaîne dans laquelle la recherche est effectuée. [`String`](/fr/reference/data-types/string) ou [`Enum`](/fr/reference/data-types/enum)
* `needle` — Sous-chaîne à rechercher. [`String`](/fr/reference/data-types/string)
* `start_pos` — Facultatif. Position (indexée à partir de 1) dans `haystack` à partir de laquelle la recherche commence. [`UInt*`](/fr/reference/data-types/int-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`](/fr/reference/data-types/int-uint)
**Exemples**
**Comptage des caractères UTF-8**
```sql title=Query theme={null}
SELECT positionUTF8('Motörhead', 'r')
```
```response title=Response theme={null}
┌─position('Motörhead', 'r')─┐
│ 5 │
└────────────────────────────┘
```