Fonctions de recherche dans les chaînes

Documentation des 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*() à 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.

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

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

┌─countSubstringsCaseInsensitive('AAAA', 'aa')─┐
│                                            2 │
└──────────────────────────────────────────────┘

Avec l’argument start_pos

Query

SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);

Response

┌─countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4)─┐
│                                                           2 │
└─────────────────────────────────────────────────────────────┘

​

countSubstringsCaseInsensitiveUTF8

Introduit dans : v21.1.0

Comme countSubstrings, mais compte sans tenir compte de la casse 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

┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА')─┐
│                                                                  4 │
└────────────────────────────────────────────────────────────────────┘

Avec l’argument start_pos

Query

SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);

Response

┌─countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 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('[e-mail]', '.*@(.*)$')

Response

┌─extract('[e-mail]', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

En l’absence de correspondance, une chaîne vide est renvoyée

Query

SELECT extract('[e-mail]', 'no_match')

Response

┌─extract('[e-mail]', '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('[e-mail], [e-mail]', '([a-zA-Z0-9]+)@')

Response

┌─extractAll('[e-mail], [e-mail]', '([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

• s — Chaîne d’entrée à partir de laquelle extraire. String ou FixedString
• regexp — Expression régulière à faire correspondre. const String ou const 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))

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

• s — Chaîne d’entrée dans laquelle extraire. String ou FixedString
• regexp — Expression régulière. Doit contenir au moins un groupe de capture. Constante. const String ou const 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)

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 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’a lieu. Si l’index de texte a une expression de preprocessor configurée, le preprocessor est appliqué à needle (s’il est fourni en tant que String) avant la tokenisation. Si l’index de texte a une expression de postprocessor configurée, le postprocessor est appliqué aux tokens de needle et à ceux de input (c’est-à-dire aux deux après la tokenisation).

Les tokens dupliqués 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 lors de l’utilisation 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[, tokenizer])

Alias : hasAllToken

Arguments

• input — La colonne d’entrée. String ou FixedString ou Nullable(String) ou Nullable(FixedString) ou Array(String) ou Array(FixedString) ou Array(Nullable(String)) ou Array(Nullable(FixedString))
• needles — Les tokens à rechercher. String ou Array(String)
• tokenizer — Le tokenizer à utiliser. Les arguments valides sont splitByNonAlpha, splitByString, splitByRegexp, asciiCJK, chinese, icu('<locale>'), japanese, 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 toutes les aiguilles correspondent. 0 sinon. UInt8

Exemples

Utilisation de base avec une chaîne comme aiguille

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc WHERE hasAllTokens(msg, 'a\\d()');

Response

┌─count()─┐
│       1 │
└─────────┘

Spécifier des needles à rechercher telles quelles (sans tokenisation) dans un Array

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc WHERE hasAllTokens(msg, ['a', 'd']);

Response

┌─count()─┐
│       1 │
└─────────┘

Créer des needles avec la fonction tokens

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc 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 de type Array et Map

Query

DROP TABLE IF EXISTS log;

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'});

Exemple avec une colonne de type Array

Query

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');

Response

┌─count()─┐
│       1 │
└─────────┘

Exemple avec mapKeys

Query

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);

Response

┌─count()─┐
│       1 │
└─────────┘

Exemple avec mapValues

Query

DROP TABLE IF EXISTS log;

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'});

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 jeton dans la chaîne ou le 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. Si l’index de texte a une expression preprocessor configurée, le preprocessor est appliqué à needle (s’il est fourni sous forme de String) avant la tokenisation. Si l’index de texte a une expression postprocessor configurée, le postprocessor est appliqué aux tokens de needle et aux tokens de input (c’est-à-dire aux deux après la tokenisation).

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 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.

Syntaxe

hasAnyTokens(input, needles[, tokenizer])

Alias : hasAnyToken

Arguments

• input — La colonne d’entrée. String ou FixedString ou Nullable(String) ou Nullable(FixedString) ou Array(String) ou Array(FixedString) ou Array(Nullable(String)) ou Array(Nullable(FixedString))
• needles — Les tokens à rechercher. String ou Array(String)
• tokenizer — Le tokenizer à utiliser. Les arguments valides sont splitByNonAlpha, splitByString, splitByRegexp, asciiCJK, chinese, icu('<locale>'), japanese, 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

Valeur renvoyée

Renvoie 1 s’il existe au moins une correspondance. 0 sinon. UInt8

Exemples

Utilisation de base avec une chaîne needle

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, 'a\\d()');

Response

┌─count()─┐
│       3 │
└─────────┘

Spécifier les ‘needles’ à rechercher tels quels (sans tokenisation) dans un tableau

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, ['a', 'd']);

Response

┌─count()─┐
│       3 │
└─────────┘

Générer des needles avec la fonction tokens

Query

DROP TABLE IF EXISTS doc;

CREATE TABLE doc (
    id UInt32,
    msg String,
    INDEX idx(msg) TYPE text(tokenizer = splitByString(['()', '\\']))
)
ENGINE = MergeTree
ORDER BY id;

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));

Response

┌─count()─┐
│       3 │
└─────────┘

Exemples d’utilisation des colonnes Array et Map

Query

DROP TABLE IF EXISTS log;

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'});

Exemple avec une colonne Array

Query

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');

Response

┌─count()─┐
│       1 │
└─────────┘

Exemple avec mapKeys

Query

DROP TABLE IF EXISTS log;

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'});

SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);

Response

┌─count()─┐
│       2 │
└─────────┘

Exemple avec mapValues

Query

DROP TABLE IF EXISTS log;

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'});

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 recherche via 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, splitByRegexp, ngrams, asciiCJK ou icu. Notez que splitByRegexp n’est pas pris en charge pour hasPhrase lorsque l’index de texte définit également un postprocessor.

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

┌─hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА')─┐
│                                                                                                        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

┌─hasSubsequenceUTF8('картошка', 'кошка')─┐
│                                       1 │
└─────────────────────────────────────────┘

Sous-séquence non correspondante

Query

SELECT hasSubsequenceUTF8('картошка', 'апельсин');

Response

┌─hasSubsequenceUTF8('картошка', 'апельсин')─┐
│                                          0 │
└────────────────────────────────────────────┘

​

hasToken

Introduit dans : v20.1.0

hasToken présente certains pièges lorsqu’il est utilisé pour des recherches dans des text indexes avec des tokenizers autres que splitByNonAlpha et/ou avec des expressions de prétraitement/post-traitement. Nous recommandons d’utiliser hasAnyTokens et hasAllTokens à la place.

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.

Cette fonction présente certains pièges avec les tokenizers non par défaut et les expressions de prétraitement ou de post-traitement. Nous recommandons d’utiliser hasAnyTokens et hasAllTokens à la place.

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é.

Cette fonction présente certains écueils avec des tokenizers non par défaut et des expressions de prétraitement ou de post-traitement. Nous recommandons d’utiliser hasAnyTokens et hasAllTokens à la place.

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

┌─hasTokenOrNull('apple banana cherry', '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('ClickHouse', 'Click_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.

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

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 est indé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 ou haystack ~ pattern (style PostgreSQL).

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 │
└────────────────────────┴──────────────────────────┘

​

matchCaseInsensitive

Introduit dans : v26.8.0

Similaire à match, mais effectue une correspondance sans tenir compte de la casse.

Cette fonction utilise la bibliothèque d’expressions régulières RE2. Veuillez consulter re2 pour connaître la syntaxe prise en charge.

Syntaxe d’opérateur alternative : haystack ~* pattern (style PostgreSQL).

Syntaxe

matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern

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 sans tenir compte de la casse, 0 sinon. UInt8

Exemples

Exemple d’utilisation

Query

SELECT matchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' ~* 'HELLO.*'

Response

┌─matchCaseInsensitive('Hello World', 'hello.*')─┬─matchCaseInsensitive('Hello World', 'HELLO.*')─┐
│                                              1 │                                              1 │
└────────────────────────────────────────────────┴────────────────────────────────────────────────┘

​

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

┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', '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

┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             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

┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  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

┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', '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 haystack.

Syntaxe

multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])

Arguments

• haystack — Chaîne haystack dans laquelle effectuer la recherche. String
• pattern — Motifs à mettre en correspondance. Array(String)

Valeur renvoyée

Renvoie l’indice (à partir de 1) du premier motif correspondant, ou 0 si aucune correspondance n’est trouvée. UInt64

Exemples

Exemple d’utilisation

Query

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);

Response

┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', '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épart 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

┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['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épart 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

┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [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 — needles 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

┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        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('你好，世界', ['你', '界']) AS result

Response

┌─result─┐
│      1 │
└────────┘

​

multiSearchFirstIndex

Introduit dans : v20.1.0

Recherche plusieurs needles dans une chaîne haystack (sensible à la casse) et renvoie l’indice, à partir de 1, du premier needle trouvé.

Syntaxe

multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])

Arguments

• haystack — La chaîne haystack dans laquelle effectuer la recherche. String
• needles — Tableau de needles à rechercher. Array(String)

Valeur renvoyée

Renvoie l’indice à partir de 1 (position dans le tableau needles) du premier needle trouvé dans haystack. Renvoie 0 si aucun needle n’est trouvé. La recherche est sensible à la casse. UInt64

Exemples

Exemple d’utilisation

Query

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);

Response

┌─multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

Sensibilité à la casse

Query

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);

Response

┌─multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

Aucune correspondance trouvée

Query

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);

Response

┌─multiSearchFirstIndex('Hello World', ['goodbye', '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

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

┌─multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello'])─┐
│                                                                       1 │
└─────────────────────────────────────────────────────────────────────────┘

​

multiSearchFirstIndexCaseInsensitiveUTF8

Introduit dans : v20.1.0

Recherche plusieurs needles dans une chaîne haystack, sans tenir compte de la casse avec prise en charge de l’encodage UTF-8, et renvoie l’indice, à partir de 1, du premier needle trouvé.

Syntaxe

multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])

Arguments

• haystack — La chaîne haystack dans laquelle effectuer la recherche. String
• needles — Tableau de needles à rechercher. Array(String)

Valeur renvoyée

Renvoie l’indice à partir de 1 (position dans le tableau needles) du premier needle trouvé dans haystack. Renvoie 0 si aucun needle n’est trouvé. 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

┌─multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server'])─┐
│                                                                                            1 │
└──────────────────────────────────────────────────────────────────────────────────────────────┘

Gestion de la casse en UTF-8

Query

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);

Response

┌─multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ'])─┐
│                                                                         1 │
└───────────────────────────────────────────────────────────────────────────┘

Aucune correspondance trouvée

Query

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);

Response

┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', '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

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

┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      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-gramme 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 à comparer. String
• needle — Chaîne à comparer. 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.06666667 │
└────────────────────────────────────────────┘

​

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 codé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 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

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('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                               0.57142854 │
└──────────────────────────────────────────────────────────┘

​

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('абвгдеёжз', 'гдеёзд')─┐
│                                    0.5 │
└────────────────────────────────────────┘

​

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('ClickHouse', '%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('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

Motif sans correspondance

Query

SELECT notLike('ClickHouse', '%SQL%');

Response

┌─notLike('ClickHouse', '%SQL%')─┐
│                              1 │
└────────────────────────────────┘

​

notMatch

Introduit dans : v26.8.0

Similaire à match, mais inverse le résultat : vérifie que la chaîne ne correspond pas au motif d’expression régulière.

Cette fonction utilise la bibliothèque d’expressions régulières RE2. Veuillez consulter re2 pour connaître la syntaxe prise en charge.

Syntaxe d’opérateur alternative : haystack !~ pattern (style PostgreSQL).

Syntaxe

notMatch(haystack, pattern)
-- haystack !~ pattern

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 0 si le motif correspond, 1 sinon. UInt8

Exemples

Exemple d’utilisation

Query

SELECT notMatch('Hello World', 'Hello.*'), 'Hello World' !~ 'goodbye.*'

Response

┌─notMatch('Hello World', 'Hello.*')─┬─notMatch('Hello World', 'goodbye.*')─┐
│                                  0 │                                    1 │
└────────────────────────────────────┴──────────────────────────────────────┘

​

notMatchCaseInsensitive

Introduit dans : v26.8.0

Similaire à matchCaseInsensitive, mais inverse le résultat : vérifie que la chaîne ne correspond pas au motif d’expression régulière sans tenir compte de la casse.

Cette fonction utilise la bibliothèque d’expressions régulières RE2. Veuillez consulter re2 pour connaître la syntaxe prise en charge.

Syntaxe d’opérateur alternative : haystack !~* pattern (style PostgreSQL).

Syntaxe

notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern

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 0 si le motif correspond sans tenir compte de la casse, 1 sinon. UInt8

Exemples

Exemple d’utilisation

Query

SELECT notMatchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' !~* 'GOODBYE.*'

Response

┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   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

┌─positionUTF8('Motörhead', 'r')─┐
│                              5 │
└────────────────────────────────┘