字符串搜索函数 - ClickHouse Documentation

本节中的所有函数默认都执行区分大小写的搜索。不区分大小写的搜索通常由单独的函数变体提供。

不区分大小写的搜索遵循英语的大小写转换规则。例如，英语中的小写 i 的大写形式是 I，而土耳其语中则是 İ——对于英语以外的语言，结果可能不符合预期。

本节中的函数还假定被搜索的字符串 (本节中称为 haystack) 和搜索字符串 (本节中称为 needle) 都是单字节编码文本。如果这一假设不成立，不会抛出异常，结果未定义。对 UTF-8 编码字符串的搜索通常由单独的函数变体提供。同样，如果使用 UTF-8 函数变体，而输入字符串并非 UTF-8 编码文本，也不会抛出异常，且结果未定义。请注意，不会自动执行 Unicode 规范化，不过你可以使用 normalizeUTF8*() 函数来实现这一点。通用字符串函数和字符串替换函数将单独介绍。

以下文档由 system.functions 系统表生成。

countMatches

引入版本：v21.1.0 返回字符串中正则表达式的匹配次数。

此函数的行为取决于 ClickHouse 版本：

在 < v25.6 的版本中，即使模式能够匹配空字符串，函数也会在第一次空匹配时停止计数。
在 >= 25.6 的版本中，发生空匹配时，函数会继续执行。可使用设置 count_matches_stop_at_empty_match = true 恢复旧版行为；

语法

countMatches(haystack, pattern)

参数

haystack — 要搜索的字符串。String
pattern — 正则表达式模式。String

返回值 返回找到的匹配次数。UInt64 示例 统计数字串的数量

Query

SELECT countMatches('hello 123 world 456 test', '[0-9]+')

Response

┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                  2 │
└────────────────────────────────────────────────────┘

countMatchesCaseInsensitive

引入版本：v21.1.0 与 countMatches 类似，但执行不区分大小写的匹配。语法

countMatchesCaseInsensitive(haystack, pattern)

参数

haystack — 要在其中搜索的字符串。String
pattern — 正则表达式模式。const String

返回值 返回找到的匹配次数。UInt64 示例 不区分大小写的计数

Query

SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')

Response

┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

countSubstrings

引入版本：v21.1.0 返回子串 needle 在字符串 haystack 中出现的频次。语法

countSubstrings(haystack, needle[, start_pos])

参数

haystack — 要在其中执行搜索的 String。String 或枚举。 - needle — 要搜索的子串。String。 - start_pos — 在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt。可选。

返回值 出现的次数。UInt64 示例 使用示例

Query

SELECT countSubstrings('aaaa', 'aa');

Response

┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘

使用 start_pos 参数

Query

SELECT countSubstrings('abc___abc', 'abc', 4);

Response

┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

countSubstringsCaseInsensitive

引入版本：v21.1.0 与 countSubstrings 类似，但按不区分大小写的方式计数。语法

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

参数

haystack — 执行搜索的字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*

返回值 返回 needle 在 haystack 中出现的次数。UInt64 示例 使用示例

Query

SELECT countSubstringsCaseInsensitive('AAAA', 'aa');

Response

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

使用 start_pos 参数

Query

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

Response

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

countSubstringsCaseInsensitiveUTF8

Introduced in: v21.1.0 与 countSubstrings 类似，但以不区分大小写的方式进行计数，并假定 haystack 为 UTF-8 字符串。 Syntax

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

haystack — 执行搜索的 UTF-8 字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始) 。UInt*

返回值 返回 needle 在 haystack 中出现的次数。UInt64 示例 使用示例

Query

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

Response

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

使用 start_pos 参数

Query

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

Response

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

extract

Introduced in：v1.1.0 提取字符串中第一个匹配正则表达式的内容。如果 ‘haystack’ 与 ‘pattern’ 不匹配，则返回空字符串。此函数使用 RE2 regular expression 库。支持的语法请参阅 re2。如果正则表达式包含捕获组 (子模式) ，则函数会返回输入字符串中与第一个捕获组匹配的内容。 Syntax

extract(haystack, pattern)

参数

haystack — 要从中提取内容的 String。String
pattern — 正则表达式，通常包含一个捕获组。const String

返回值 返回提取出的字符串片段。String 示例 从电子邮件地址中提取域名

Query

SELECT extract('test@clickhouse.com', '.*@(.*)$')

Response

┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

未匹配时返回空字符串

Query

SELECT extract('test@clickhouse.com', 'no_match')

Response

┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll

引入于：v1.1.0 与 extract 类似，但返回字符串中匹配正则表达式的所有结果组成的数组。如果 ‘haystack’ 不匹配 ‘pattern’ 正则表达式，则返回空数组。如果正则表达式包含捕获组 (子模式) ，则该函数会针对第一个捕获组匹配输入字符串。语法

extractAll(haystack, pattern)

参数

haystack — 要从中提取片段的 String。String
pattern — 正则表达式，可包含捕获组。const String

返回值 返回提取出的片段数组。Array(String) 示例 提取所有数字

Query

SELECT extractAll('hello 123 world 456', '[0-9]+')

Response

┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘

使用捕获组提取

Query

SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')

Response

┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

extractAllGroupsHorizontal

引入版本：v20.5.0 使用提供的正则表达式匹配字符串中的所有组，并返回一个嵌套数组，其中每个数组包含同一捕获组的所有捕获结果，按组号排列。语法

extractAllGroupsHorizontal(s, regexp)

参数

s — 要从中提取内容的输入字符串。String 或 FixedString
regexp — 用于匹配的正则表达式。const String 或 const FixedString

返回值 返回一个嵌套数组，其中每个内部数组都包含某个捕获组在所有匹配结果中的全部捕获内容。第一个内部数组包含第 1 组的所有捕获，第二个包含第 2 组的所有捕获，依此类推。如果未找到匹配项，则返回空数组。Array(Array(String)) 示例 用法示例

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

Introduced in: v20.5.0 从正则表达式匹配到的第一个子串中提取捕获组。要从所有匹配结果中提取捕获组，请使用 extractAllGroupsHorizontal 或 extractAllGroupsVertical。 Syntax

extractGroups(s, regexp)

参数

s — 要从中提取内容的输入字符串。String 或 FixedString
regexp — 正则表达式。必须至少包含一个捕获组。常量。const String 或 const FixedString

返回值 如果正则表达式匹配，则返回一个数组，包含首次匹配中捕获的各组 (1 到 N，其中 N 为 regexp 中捕获组的数量) 。如果没有匹配，则返回空数组。Array(String) 示例 使用示例

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

引入版本：v25.10.0 与 hasAnyTokens 类似，但仅当 needle 字符串或数组中的所有标记都与 input 字符串匹配时返回 1，否则返回 0。如果 input 是一列，则返回满足此条件的所有行。

列 input 应定义一个文本索引以获得最佳性能。如果未定义文本索引，该函数会对该列执行穷举列扫描，其速度比索引查找慢几个数量级。

在搜索之前，该函数会对文本进行分词处理

input 参数 (始终如此) 以及
needle 参数 (如果为 String) 会使用为文本索引指定的分词器进行处理。如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。如果 needle 参数的类型为 Array(String)，则数组中的每个元素都会被视为一个标记——不会再进行额外的标记化。如果文本索引配置了预处理器表达式，则会在标记化之前将预处理器应用到 needle (如果其类型为 String) 。如果文本索引配置了后处理器表达式，则会将后处理器应用到 needle 标记和 input 标记 (即两者都在标记化之后处理) 。

重复的标记将被忽略。例如，needles = [‘ClickHouse’, ‘ClickHouse’] 与 [‘ClickHouse’] 等效。

当文本索引定义了一个预处理器 (例如 lowerUTF8) 时，hasAllTokens 会将其应用于 input；如果 needles 是 String，则也会在标记化之前将其应用于 needles。当 needles 是 Array(String) 时，其元素会按原样传递，不会对其应用预处理器。预处理器仅在文本索引路径上生效，因此，使用文本索引的查询与不使用文本索引的查询，结果可能会有所不同 (例如 SETTINGS use_skip_indexes = 0) 。为提高全文检索的易用性，这种不一致是可以接受的。

语法

hasAllTokens(input, needles[, tokenizer])

别名: hasAllToken 参数

input — 输入列。String、FixedString、Nullable(String)、Nullable(FixedString)、Array(String)、Array(FixedString)、Array(Nullable(String)) 或 Array(Nullable(FixedString))
needles — 待搜索的标记。String 或 Array(String)
tokenizer — 使用的分词器。有效参数包括 splitByNonAlpha、splitByString、splitByRegexp、asciiCJK、chinese、icu('<locale>')、japanese、ngrams、sparseGrams 和 array。可选；如果未显式设置，默认为 splitByNonAlpha。const String

返回值 如果所有 needle 都匹配，则返回 1；否则返回 0。UInt8 示例 使用字符串 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 hasAllTokens(msg, 'a\\d()');

Response

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

指定要在数组中按 AS-IS (不分词) 方式搜索的 needles

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

使用 tokens 函数生成 needles

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

通过第 3 个参数指定自定义分词器

Query

SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');

Response

┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                          1 │
└────────────────────────────────────────────┘

数组列和 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'});

数组列示例

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

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

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

引入版本：v25.10.0 如果 needle 字符串或数组中至少有一个标记与 input 字符串匹配，则返回 1，否则返回 0。如果 input 是一列，则返回满足此条件的所有行。

列 input 应定义文本索引，以获得最佳性能。如果未定义文本索引，该函数会对列执行穷举列扫描，其速度比索引查找慢几个数量级。

在搜索之前，该函数会对文本进行分词处理

input 参数 (始终如此) ，以及
needle 参数 (如果其类型为 String) 会使用为文本索引指定的分词器进行分词。如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。如果 needle 参数的类型为 Array(String)，则会将数组中的每个元素视为一个标记——不会再进行额外标记化。如果文本索引配置了预处理器表达式，则会在标记化前将预处理器应用于 needle (如果其类型为 String)。如果文本索引配置了后处理器表达式，则会在标记化后将后处理器应用于 needle 标记和 input 标记 (即两者都会应用)。

重复的标记将被忽略。例如，[‘ClickHouse’, ‘ClickHouse’] 与 [‘ClickHouse’] 的处理方式相同。

当文本索引定义了预处理器 (例如 lowerUTF8) 时，hasAnyTokens 会在标记化前将其应用于 input；当 needles 为 String 时，也会将其应用于 needles。当 needles 为 Array(String) 时，其元素会按原样传递，不会对其应用预处理器。预处理器仅在文本索引路径上应用，因此，使用文本索引的查询与不使用文本索引的查询之间的结果可能不同 (例如 SETTINGS use_skip_indexes = 0) 。为了提高全文检索的易用性，可以容忍这种不一致性。

语法

hasAnyTokens(input, needles[, tokenizer])

别名: hasAnyToken 参数

input — 输入列。String 或 FixedString 或 Nullable(String) 或 Nullable(FixedString) 或 Array(String) 或 Array(FixedString) 或 Array(Nullable(String)) 或 Array(Nullable(FixedString))
needles — 待搜索的标记。String 或 Array(String)
tokenizer — 使用的分词器。有效参数包括 splitByNonAlpha、splitByString、splitByRegexp、asciiCJK、chinese、icu('<locale>')、japanese、ngrams、sparseGrams 和 array。该参数为可选项；如果未显式设置，则默认为 splitByNonAlpha。const String

返回值 如果至少有一个匹配项，则返回 1，否则返回 0。UInt8 示例 使用字符串 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 │
└─────────┘

指定要在数组中按原样搜索的 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 │
└─────────┘

使用 tokens 函数生成 needles

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

数组列和 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'});

数组列示例

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

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

使用 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

引入版本：v26.4.0 检查 input 是否按连续顺序包含 phrase 中的所有标记。

为获得最佳性能，列 input 应定义文本索引。如果未定义文本索引，该函数会执行穷举列扫描，其速度比索引查找慢几个数量级。

搜索前，该函数会使用为文本索引指定的分词器，对 input 和 phrase 参数进行标记化。如果该列未定义文本索引，则改用 splitByNonAlpha 分词器——除非通过可选的第三个参数提供了分词器。 tokenizer 参数必须是 splitByNonAlpha、splitByString、splitByRegexp、ngrams、asciiCJK 或 icu 之一。请注意，当文本索引还定义了后处理器时，hasPhrase 不支持 splitByRegexp。

当文本索引定义了预处理器 (例如 lowerUTF8) 时，hasPhrase 会在标记化前将其应用于 input 和 phrase。预处理器仅在文本索引路径上生效，因此，使用文本索引的查询与不使用文本索引的查询，结果可能不同 (例如 SETTINGS use_skip_indexes = 0) 。为了提高全文检索的易用性，可以容忍这种不一致。

与 hasToken、hasAnyTokens 和 hasAllTokens 不同，hasPhrase 要求这些标记按相同顺序连续出现，中间不能有任何其他标记。例如，hasPhrase('the quick brown fox', 'quick fox') 返回 0，因为 “brown” 出现在 “quick” 和 “fox” 之间。语法

hasPhrase(input, phrase[, tokenizer])

别名：matchPhrase 参数

input — 输入列。String 或 FixedString
phrase — 要搜索的短语。const String
tokenizer — 使用的分词器。可选，默认为 splitByNonAlpha。const String

返回值 如果找到该短语对应的连续标记序列，则返回 1；否则返回 0。UInt8 示例 短语匹配

Query

SELECT hasPhrase('the quick brown fox jumps', 'quick brown')

Response

┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘

不连续标记

Query

SELECT hasPhrase('the quick brown fox jumps', 'quick fox')

Response

┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│                                                   0 │
└─────────────────────────────────────────────────────┘

hasSubsequence

Introduced in: v23.7.0 检查 needle 是否是 haystack 的子序列。字符串的子序列，是指在不改变其余字符顺序的前提下，通过删除另一个字符串中的部分字符或不删除任何字符得到的序列。 Syntax

hasSubsequence(haystack, needle)

参数

haystack — 在其中搜索子序列的 String。String
needle — 要搜索的子序列。String

返回值 如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8 示例 基本的子序列检查

Query

SELECT hasSubsequence('Hello World', 'HlWrd')

Response

┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘

未找到子序列

Query

SELECT hasSubsequence('Hello World', 'xyz')

Response

┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

hasSubsequenceCaseInsensitive

引入版本：v23.7.0 与 hasSubsequence 类似，但搜索时不区分大小写。语法

hasSubsequenceCaseInsensitive(haystack, needle)

参数

haystack — 在其中执行搜索的 String。String
needle — 要搜索的子序列。String

返回值 如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8 示例 使用示例

Query

SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');

Response

┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

hasSubsequenceCaseInsensitiveUTF8

引入版本：v23.7.0 与 hasSubsequenceUTF8 类似，但搜索时不区分大小写。语法

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

参数

haystack — 执行搜索所在的 UTF8 编码字符串。String
needle — 要搜索的 UTF8 编码子序列字符串。String

返回值 如果 needle 是 haystack 的子序列，则返回 1；否则返回 0。UInt8 示例 使用示例

Query

SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');

Response

┌─hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА')─┐
│                                                                                                        1 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────┘

hasSubsequenceUTF8

引入版本：v23.7.0 与 hasSubsequence 类似，但假设 haystack 和 needle 是以 UTF-8 编码的字符串。语法

hasSubsequenceUTF8(haystack, needle)

参数

haystack — 要在其中进行搜索的字符串。String
needle — 要查找的子序列。String

返回值 如果 needle 是 haystack 的子序列，则返回 1；否则返回 0。UInt8 示例 用法示例

Query

SELECT hasSubsequenceUTF8('картошка', 'кошка');

Response

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

不匹配子序列

Query

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

Response

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

hasToken

引入版本：v20.1.0

在使用非 splitByNonAlpha 分词器和/或预处理器/后处理器表达式的文本索引中进行查找时，hasToken 存在一些隐患。我们建议改用 hasAnyTokens 和 hasAllTokens。

检查给定的标记是否存在于 haystack 中。使用 splitByNonAlpha 作为分词器，也就是说，标记被定义为由连续字符 [0-9A-Za-z_] (数字、ASCII 字符和下划线) 构成的最长子序列。语法

hasToken(haystack, token)

参数

haystack — 被搜索的字符串。String
token — 要查找的标记。const String

返回值 如果找到该标记，则返回 1；否则返回 0。UInt8 示例 标记搜索

Query

SELECT hasToken('clickhouse test', 'test')

Response

┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

hasTokenCaseInsensitive

引入版本：v20.1.0 使用 tokenbf_v1 索引在 haystack 中执行对 needle 的不区分大小写查找。

此函数在配合非 default 分词器以及预处理器或后处理器表达式时存在一些陷阱。我们建议改用 hasAnyTokens 和 hasAllTokens。

语法

hasTokenCaseInsensitive(haystack, needle)

参数

无。

返回值 示例

hasTokenCaseInsensitiveOrNull

引入版本：v23.1.0 使用 tokenbf_v1 索引在 haystack 中不区分大小写地查找 needle。如果 needle 的格式不合法，则返回 NULL。

该函数在使用非 default 分词器以及预处理器或后处理器表达式时有一些注意事项。我们建议改用 hasAnyTokens 和 hasAllTokens。

语法

hasTokenCaseInsensitiveOrNull(haystack, needle)

参数

无。

返回值 示例

hasTokenOrNull

首次引入版本：v20.1.0 与 hasToken 类似，但如果标记格式不合法，则返回 NULL。语法

hasTokenOrNull(haystack, token)

参数

haystack — 要搜索的字符串。必须为常量。String
token — 要搜索的标记。const String

返回值 如果找到该标记，则返回 1；否则返回 0。如果 token 格式不合法，则返回 NULL。Nullable(UInt8) 示例 使用示例

Query

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');

Response

┌─hasTokenOrNull('apple banana cherry', 'ban ana')─┐
│                                             ᴺᵁᴸᴸ │
└──────────────────────────────────────────────────┘

highlight

引入版本：v26.4.0 使用 HTML 标签包裹文本字符串中搜索词的匹配项，从而将其高亮显示。该函数执行 ASCII 不区分大小写匹配。如果多个搜索词在文本中重叠或彼此相邻，则匹配区域会合并为一个高亮 span。语法

highlight(haystack, needles[, open_tag, close_tag])

参数

haystack — 要搜索的文本。String 或 FixedString
needles — 要高亮显示的搜索词数组。const Array(String)
open_tag — 在每个匹配项前插入的起始标签。默认值：<em>。const String
close_tag — 在每个匹配项后插入的结束标签。默认值：</em>。const String

返回值 返回将匹配词用指定标签包裹后的输入文本。String 示例 基本高亮

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

自定义标签

Query

SELECT highlight('Hello World', ['hello'], '<b>', '</b>')

Response

┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

ilike

引入版本：v20.6.0 与 like 类似，但以不区分大小写的方式进行搜索。支持可选的 ESCAPE 子句 (参见 like) 。语法

ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']

参数

haystack — 执行搜索的字符串。String 或 FixedString
pattern — 用于匹配的 LIKE 模式。String
escape_character — 可选的单字符字符串，用作转义字符以替代 \。默认值：\。String

返回值 如果字符串与 LIKE 模式匹配 (不区分大小写) ，则返回 1，否则返回 0。UInt8 示例 使用示例

Query

SELECT ilike('ClickHouse', '%house%');

Response

┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

like

引入版本：v1.1.0 返回字符串 haystack 是否匹配 LIKE 表达式 pattern。 LIKE 表达式可以包含普通字符以及以下元符号：

% 表示任意数量的任意字符 (包括零个字符) 。
_ 表示任意单个字符。
\ 用于转义字面量 %、_ 和 \。

匹配基于 UTF-8，例如，_ 可以匹配 Unicode 码点 ¥，该字符在 UTF-8 中用两个字节表示。如果 haystack 或 LIKE 表达式不是有效的 UTF-8，则其行为未定义。不会自动执行 Unicode 规范化；你可以使用 normalizeUTF8* 函数来完成此操作。要匹配字面量 %、_ 和 \ (它们是 LIKE 元字符) ，请在它们前面加上反斜杠：\%、\_ 和 \\。如果反斜杠后面的字符不是 %、_ 或 \，则反斜杠会失去其特殊含义 (即按字面量解释) 。

ClickHouse 要求字符串中的反斜杠也需要转义，因此实际需要写成 \\%、\\_ 和 \\\\。

对于形如 %needle% 的 LIKE 表达式，该函数的速度与 position 函数一样快。所有其他 LIKE 表达式在内部都会转换为正则表达式，并以与 match 函数相近的性能执行。

ESCAPE 子句

可选的 ESCAPE 子句用于指定自定义转义字符 (必须是单个 ASCII 字符) 。提供后，自定义转义字符会替代默认的反斜杠，用于转义 % 和 _ 元字符。转义字符可以转义三种内容：% (字面量百分号) 、_ (字面量下划线) 以及其自身 (字面量转义字符) 。使用自定义转义字符时，反斜杠不再具有特殊含义，而是按字面量字符处理。语法

like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']

参数

haystack — 要在其中执行搜索的 String。String 或 FixedString
pattern — 要匹配的 LIKE 模式。可包含 % (匹配任意数量的字符) 、_ (匹配单个字符) 以及用于转义的 \。String
escape_character — 可选的单字符字符串，用作 \ 的替代转义字符。默认值：\。String

返回值 如果字符串与 LIKE 模式匹配，则返回 1；否则返回 0。UInt8 示例 用法示例

Query

SELECT like('ClickHouse', '%House');

Response

┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘

单字符通配符

Query

SELECT like('ClickHouse', 'Click_ouse');

Response

┌─like('ClickHouse', 'Click_ouse')─┐
│                                1 │
└──────────────────────────────────┘

不匹配模式

Query

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

Response

┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘

ESCAPE 子句

Query

SELECT '50%off' LIKE '50#%off' ESCAPE '#';

Response

┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

locate

引入版本：v18.16.0 与 position 类似，但参数 haystack 和 locate 的顺序互换了。

此函数的行为取决于 ClickHouse 的版本：

在 < v24.3 的版本中，locate 是函数 position 的别名，接受参数 (haystack, needle[, start_pos])。
在 >= 24.3 的版本中，locate 是一个独立函数 (为了更好地兼容 MySQL) ，接受参数 (needle, haystack[, start_pos])。可以通过设置 function_locate_has_mysql_compatible_argument_order = false 恢复之前的行为。

语法

locate(needle, haystack[, start_pos])

参数

needle — 要搜索的子串。String
haystack — 要在其中进行搜索的字符串。String 或 Enum
start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt

返回值 如果找到子串，则返回其起始位置 (按字节计数，且从 1 开始) ；如果未找到子串，则返回 0。UInt64 示例 基本用法

Query

SELECT locate('ca', 'abcabc')

Response

┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

match

引入版本：v1.1.0 检查给定字符串是否与指定的正则表达式模式匹配。此函数使用 RE2 正则表达式库。支持的语法请参阅 re2。匹配基于 UTF-8 假设进行，例如 ¥ 在内部占用两个字节，但在匹配时会被视为单个码点。正则表达式不能包含 NULL 字节。如果 haystack 或模式不是有效的 UTF-8，则其行为未定义。与 re2 的默认行为不同，. 会匹配换行符。要禁用此行为，请在模式前添加 (?-s)。模式不会自动加上锚点。若要匹配整个字符串，请自行使用 ^ 和 $ 对模式加锚。如果你只是想搜索子字符串，可以改用函数 like 或 position，它们的速度比此函数快得多。可选的运算符语法：haystack REGEXP pattern 或 haystack ~ pattern (PostgreSQL 风格) 。语法

match(haystack, pattern)

别名: REGEXP_MATCHES 参数

haystack — 在其中搜索模式的 String。String
pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值 如果匹配该模式，则返回 1，否则返回 0。UInt8 示例 基本模式匹配

Query

SELECT match('Hello World', 'Hello.*')

Response

┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘

模式不匹配

Query

SELECT match('Hello World', 'goodbye.*')

Response

┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘

匹配子串

Query

SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')

Response

┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                      1 │                        0 │
└────────────────────────┴──────────────────────────┘

matchCaseInsensitive

引入版本：v26.8.0 与 match 类似，但进行不区分大小写的匹配。此函数使用 RE2 正则表达式库。支持的语法请参阅 re2。可选的运算符语法：haystack ~* pattern (PostgreSQL 风格) 。语法

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

参数

haystack — 在其中搜索模式的 String。String
pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值 如果不区分大小写地匹配该模式，则返回 1，否则返回 0。UInt8 示例 使用示例

Query

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

Response

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

multiFuzzyMatchAllIndices

引入版本：v20.1.0 与 multiFuzzyMatchAny 类似，但会返回在固定编辑距离内与 haystack 匹配的所有索引组成的数组，顺序不限。语法

multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])

参数

haystack — 执行搜索的 String。String
distance — 模糊匹配允许的最大编辑距离。UInt8
pattern — 要匹配的模式数组。Array(String)

返回值 返回一个数组，包含在指定编辑距离内以任意顺序匹配 haystack 的所有索引 (从 1 开始) 。如果未找到匹配项，则返回空数组。Array(UInt64) 示例 使用示例

Query

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);

Response

┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House'])─┐
│ [3,1,4,2]                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAny

引入版本：v20.1.0 与 multiMatchAny 类似，但如果任意模式在固定的编辑距离内匹配 haystack，则返回 1。此函数依赖 hyperscan 库的 Experimental 功能，在某些边缘情况下可能较慢。其性能取决于编辑距离的取值和所使用的模式，但与非模糊变体相比，开销始终更高。

由于 hyperscan 的限制，multiFuzzyMatch*() 函数家族不支持 UTF-8 正则表达式 (会将其视为字节序列) 。

语法

multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])

参数

haystack — 执行搜索的 String。String
distance — 模糊匹配的最大编辑距离。UInt8
pattern — 可选。用于匹配的模式数组。Array(String)

返回值 如果任一模式在指定的编辑距离内与 haystack 匹配，则返回 1；否则返回 0。UInt8 示例 使用示例

Query

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);

Response

┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAnyIndex

引入于：v20.1.0 与 multiFuzzyMatchAny 类似，但会返回在固定编辑距离内与 haystack 匹配的任意一个索引。语法

multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])

参数

haystack — 执行搜索的字符串。String
distance — 模糊匹配允许的最大编辑距离。UInt8
pattern — 用于匹配的模式数组。Array(String)

返回值 返回在指定编辑距离内与 haystack 匹配的任意一个模式的索引 (从 1 开始) ；如果都不匹配，则返回 0。UInt64 示例 使用示例

Query

SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);

Response

┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  2 │
└────────────────────────────────────────────────────────────────────────────────────┘

multiMatchAllIndices

引入版本：v20.1.0 与 multiMatchAny 类似，但返回按任意顺序与 haystack 匹配的所有索引组成的数组。语法

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

参数

haystack — 执行搜索的字符串。String
pattern — 用于匹配的正则表达式。String

返回值 由按任意顺序与 haystack 匹配的所有索引 (从 1 开始) 组成的数组。如果未找到匹配项，则返回空数组。Array(UInt64) 示例 使用示例

Query

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

Response

┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse'])─┐
│ [3,2,4]                                                                 │
└─────────────────────────────────────────────────────────────────────────┘

multiMatchAny

引入版本：v20.1.0 检查多个正则表达式模式中是否至少有一个与 haystack 匹配。如果你只想在一个字符串中搜索多个子字符串，可以改用函数 multiSearchAny——它的速度比此函数快得多。语法

multiMatchAny(haystack, pattern1[, pattern2, ...])

参数

haystack — 在其中搜索模式的 String。String
pattern1[, pattern2, ...] — 包含一个或多个正则表达式模式的数组。Array(String)

返回值 如果任意模式匹配则返回 1，否则返回 0。UInt8 示例 多个模式匹配

Query

SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])

Response

┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

没有任何模式匹配

Query

SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])

Response

┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

multiMatchAnyIndex

引入版本：v20.1.0 与 multiMatchAny 类似，但会返回任意一个与 haystack 匹配的索引。语法

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

参数

haystack — 执行搜索的字符串。String
pattern — 用于匹配的正则表达式。Array(String)

返回值 返回第一个匹配 pattern 的索引 (从 1 开始) ；如果未找到匹配项，则返回 0。UInt64 示例 使用示例

Query

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

Response

┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

multiSearchAllPositions

Introduced in: v20.1.0 与 position 类似，但它返回一个位置数组，表示 haystack 字符串中多个 needle 子字符串的位置 (以字节为单位，从 1 开始计数) 。所有 multiSearch*() 函数最多仅支持 2^8 个 needle。 Syntax

multiSearchAllPositions(haystack, needle1[, needle2, ...])

参数

haystack — 执行搜索的字符串。String
needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)

返回值 如果找到子串，则返回由起始位置组成的数组，位置以字节为单位并从 1 开始计数；如果未找到子串，则返回 0。Array(UInt64) 示例 多个 needle 搜索

Query

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])

Response

┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsCaseInsensitive

引入版本：v20.1.0 与 multiSearchAllPositions 类似，但不区分大小写。语法

multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])

参数

haystack — 要在其中执行搜索的 String。String
needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)

返回值 返回一个数组，表示起始位置 (按字节计算，从 1 开始；如果找到了子串) ；如果未找到子串，则返回 0。Array(UInt64) 示例 不区分大小写的多重搜索

Query

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])

Response

┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│ [1,6]                                                            │
└──────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsCaseInsensitiveUTF8

引入版本：v20.1.0 与 multiSearchAllPositionsUTF8 类似，但不区分大小写。语法

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

参数

haystack — 执行搜索的 UTF-8 编码字符串。String
needle — 要搜索的 UTF-8 编码子字符串。Array(String)

返回值 由起始位置组成的数组；位置按字节计算，从 1 开始 (如果找到了子字符串) 。如果未找到子字符串，则返回 0。Array 示例 不区分大小写的 UTF-8 搜索

Query

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);

Response

┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [1,13]                                                                                │
└───────────────────────────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsUTF8

引入版本：v20.1.0 与 multiSearchAllPositions 类似，但假定 haystack 和 needle 子串均为 UTF-8 编码的字符串。语法

multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])

参数

haystack — 要在其中执行搜索的 UTF-8 编码字符串。String
needle1[, needle2, ...] — 要搜索的 UTF-8 编码子字符串数组。Array(String)

返回值 返回一个数组：如果找到子串，则返回其以字节为单位、从 1 开始计数的起始位置；如果未找到子串，则返回 0。Array 示例 UTF-8 多重搜索

Query

SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])

Response

┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

multiSearchAny

引入版本：v20.1.0 检查多个 needle 字符串中是否至少有一个与 haystack 字符串匹配。函数 multiSearchAnyCaseInsensitive、multiSearchAnyUTF8 和 multiSearchAnyCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。语法

multiSearchAny(haystack, needle1[, needle2, ...])

参数

haystack — 在其中执行搜索的 String。String
needle1[, needle2, ...] — 要查找的子字符串数组。Array(String)

返回值 如果至少有一个匹配项，则返回 1；否则返回 0。UInt8 示例 任意匹配查找

Query

SELECT multiSearchAny('ClickHouse',['C','H'])

Response

┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

multiSearchAnyCaseInsensitive

引入版本：v20.1.0 与 multiSearchAny 类似，但不区分大小写。语法

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

参数

haystack — 在其中执行搜索的 String。String
needle — 要搜索的子字符串。Array(String)

返回值 如果至少有一个不区分大小写的匹配，则返回 1；否则返回 0。UInt8 示例 不区分大小写的搜索

Query

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])

Response

┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

multiSearchAnyCaseInsensitiveUTF8

首次引入于：v20.1.0 与 multiSearchAnyUTF8 类似，但不区分大小写。语法

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

参数

haystack — 在其中执行搜索的 UTF-8 字符串。String
needle — 待搜索的 UTF-8 子字符串。Array(String)

返回值 如果至少有一个不区分大小写的匹配，则返回 1；否则返回 0。UInt8 示例 给定 UTF-8 字符串 ‘Здравствуйте’，检查是否包含字符 ‘з’ (小写)

Query

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])

Response

┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

multiSearchAnyUTF8

引入版本：v20.1.0 与 multiSearchAny 类似，但假定 haystack 和 needle 子串都是 UTF-8 编码的字符串。语法

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

参数

haystack — 执行搜索的 UTF-8 字符串。String
needle — 要搜索的 UTF-8 子字符串。Array(String)

返回值 如果至少有一个匹配，则返回 1；否则返回 0。UInt8 示例 给定 UTF-8 字符串 ‘你好，世界’ (‘Hello, world’) ，检查该字符串中是否包含字符你或界

Query

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result

Response

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

multiSearchFirstIndex

引入版本：v20.1.0 在 haystack 字符串中搜索多个 needle 字符串 (区分大小写) ，并返回找到的第一个 needle 的从 1 开始的索引。语法

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

参数

haystack — 要在其中搜索的字符串。String
needles — 要查找的字符串数组。Array(String)

返回值 返回在 haystack 中找到的第一个 needle 的从 1 开始的索引 (即其在 needles 数组中的位置) 。如果未找到任何 needle，则返回 0。搜索区分大小写。UInt64 示例 用法示例

Query

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

Response

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

区分大小写

Query

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

Response

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

未找到匹配项

Query

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

Response

┌─multiSearchFirstIndex('Hello World', ['goodbye', 'test'])─┐
│                                                         0 │
└───────────────────────────────────────────────────────────┘

multiSearchFirstIndexCaseInsensitive

引入版本：v20.1.0 返回字符串 haystack 中最左侧匹配到的 needle_i 的索引 i (从 1 开始) ，否则返回 0。不区分大小写。语法

multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]

参数

haystack — 执行搜索的 String。String
needle — 要搜索的子字符串。Array(String)

返回值 返回最靠左匹配到的 needle 的索引 (从 1 开始) 。如果没有匹配项，则返回 0。UInt8 示例 使用示例

Query

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);

Response

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

multiSearchFirstIndexCaseInsensitiveUTF8

引入版本：v20.1.0 在支持 UTF-8 编码的情况下，以不区分大小写的方式在 haystack 字符串中搜索多个 needle 字符串，并返回第一个匹配到的 needle 的从 1 开始的索引。语法

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

参数

haystack — 要搜索的字符串。String
needles — 要查找的字符串数组。Array(String)

返回值 返回在 haystack 中找到的第一个 needle 的从 1 开始的索引 (即其在 needles 数组中的位置) 。如果未找到任何 needle，则返回 0。搜索不区分大小写，并遵循 UTF-8 字符编码。UInt64 示例 用法示例

Query

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);

Response

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

UTF-8 字母大小写处理

Query

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

Response

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

未找到匹配结果

Query

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

Response

┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test'])─┐
│                                                                            0 │
└──────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstIndexUTF8

引入版本：v20.1.0 返回字符串 haystack 中最靠左匹配到的 needle_i 的索引 i (从 1 开始) ，否则返回 0。假定 haystack 和 needle 是采用 UTF-8 编码的字符串。语法

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

参数

haystack — 在其中进行搜索的 UTF-8 字符串。String
needle — 要搜索的 UTF-8 子字符串数组。Array(String)

返回值 返回最先找到的、最靠左的 needle 的索引 (从 1 开始计数) 。如果没有匹配，则返回 0。UInt8 示例 使用示例

Query

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);

Response

┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      1 │
└────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPosition

引入版本：v20.1.0 与 position 类似，但返回 haystack 字符串中与多个 needle 字符串里任意一个匹配的最左偏移量。函数 multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8 和 multiSearchFirstPositionCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。语法

multiSearchFirstPosition(haystack, needle1[, needle2, ...])

参数

haystack — 执行搜索的 String。String
needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)

返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量；如果没有匹配，则返回 0。UInt64 示例 搜索首个位置

Query

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])

Response

┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitive

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但不区分大小写。语法

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

参数

haystack — 执行搜索的字符串。String
needle — 要搜索的子字符串数组。Array(String)

返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量。如果没有匹配，则返回 0。UInt64 示例 大小写不敏感的第一个位置

Query

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])

Response

┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPositionCaseInsensitiveUTF8

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但假定 haystack 和 needle 均为 UTF-8 字符串，且不区分大小写。语法

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

参数

haystack — 执行搜索的 UTF-8 字符串。String
needle — 要搜索的 UTF-8 子字符串数组。Array(String)

返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量，忽略大小写。如果没有匹配，则返回 0。UInt64 示例 查找 UTF-8 字符串 ‘Здравствуй, мир’ (‘Hello, world’) 中与给定 needle 中任意一个匹配的最左侧偏移量

Query

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])

Response

┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│                                                                                      1 │
└────────────────────────────────────────────────────────────────────────────────────────┘

multiSearchFirstPositionUTF8

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但假设 haystack 和 needle 都是 UTF-8 字符串。语法

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

参数

haystack — 执行搜索的 UTF-8 字符串。String
needle — 要搜索的 UTF-8 子字符串数组。Array(String)

返回值 haystack 字符串中与多个 needle 字符串中任意一个匹配的最左侧偏移量。如果没有匹配，则返回 0。UInt64 示例 查找 UTF-8 字符串 ‘Здравствуй, мир’ (‘Hello, world’) 中与给定任意一个 needle 匹配的最左侧偏移量

Query

SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])

Response

┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       4 │
└─────────────────────────────────────────────────────────────────────────┘

ngramDistance

引入版本：v20.1.0 计算两个字符串之间的 4-gram 距离。为此，它会统计两个 4-gram 多重集合之间的对称差，并用它们的基数之和对结果进行归一化。返回值越小，字符串越相似。如需进行不区分大小写的搜索和/或使用 UTF8 格式，请使用函数 ngramDistanceCaseInsensitive、ngramDistanceUTF8、ngramDistanceCaseInsensitiveUTF8。语法

ngramDistance(haystack, needle)

参数

haystack — 用于比较的字符串。String
needle — 用于比较的字符串。String

返回值 返回一个介于 0 和 1 之间的 Float32 数值。返回值越小，字符串越相似。Float32 示例 计算 4-gram 距离

Query

SELECT ngramDistance('ClickHouse', 'ClickHouses')

Response

┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                 0.06666667 │
└────────────────────────────────────────────┘

ngramDistanceCaseInsensitive

引入版本：v20.1.0 提供 ngramDistance 的不区分大小写 Variant。计算两个字符串之间的 4-gram 距离，忽略大小写。返回值越小，字符串越相似。语法

ngramDistanceCaseInsensitive(haystack, needle)

参数

haystack — 第一个比较字符串。String
needle — 第二个比较字符串。String

返回值 返回一个介于 0 和 1 之间的 Float32 数值。Float32 示例 不区分大小写的 4-gram 距离

Query

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')

Response

┌─ngramDistanceCaseInsensitive('ClickHouse', 'clickhouse')─┐
│                                                        0 │
└──────────────────────────────────────────────────────────┘

ngramDistanceCaseInsensitiveUTF8

引入版本：v20.1.0 提供 ngramDistance 的不区分大小写 UTF-8 Variant。假定 needle 和 haystack 字符串均为 UTF-8 编码，并忽略大小写。计算两个 UTF-8 字符串之间不区分大小写的 3-gram 距离。返回值越小，字符串越相似。语法

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

参数

haystack — 第一个采用 UTF-8 编码的比较字符串。String
needle — 第二个采用 UTF-8 编码的比较字符串。String

返回值 返回一个介于 0 和 1 之间的 Float32 数值。Float32 示例 不区分大小写的 UTF-8 3-gram 距离

Query

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')

Response

┌─ngramDistanceCaseInsensitiveUTF8('abcde', 'CDE')─┐
│                                              0.5 │
└──────────────────────────────────────────────────┘

ngramDistanceUTF8

引入版本：v20.1.0 提供 ngramDistance 的 UTF-8 Variant。假定 needle 和 haystack 字符串均为 UTF-8 编码。计算两个 UTF-8 字符串之间的 3-gram 距离。返回值越小，字符串越相似。语法

ngramDistanceUTF8(haystack, needle)

参数

haystack — 第一个 UTF-8 编码的比较字符串。String
needle — 第二个 UTF-8 编码的比较字符串。String

返回值 返回 0 到 1 之间的 Float32 数值。Float32 示例 UTF-8 3-gram 距离

Query

SELECT ngramDistanceUTF8('abcde','cde')

Response

┌─ngramDistanceUTF8('abcde', 'cde')─┐
│                               0.5 │
└───────────────────────────────────┘

ngramSearch

引入版本：v20.1.0 检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值。如需进行不区分大小写的搜索和/或使用 UTF8 格式，请使用函数 ngramSearchCaseInsensitive、ngramSearchUTF8、ngramSearchCaseInsensitiveUTF8。语法

ngramSearch(haystack, needle)

参数

haystack — 用于比较的字符串。String
needle — 用于比较的字符串。String

返回值 如果两个字符串之间的 4-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 4-gram 进行搜索

Query

SELECT ngramSearch('ClickHouse', 'Click')

Response

┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

ngramSearchCaseInsensitive

引入版本：v20.1.0 提供 ngramSearch 的不区分大小写 Variant。计算 needle 字符串与 haystack 字符串之间的非对称差，即用 needle 中的 n-gram 数量减去共有的 n-gram 数量，再按 needle 的 n-gram 数量进行归一化。检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值，并忽略大小写。语法

ngramSearchCaseInsensitive(haystack, needle)

参数

haystack — 用于比较的 String。String
needle — 用于比较的 String。String

返回值 如果两个字符串之间的 4-gram 距离小于或等于阈值 (默认值为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 4-gram 的不区分大小写搜索

Query

SELECT ngramSearchCaseInsensitive('Hello World','hello')

Response

┌─ngramSearchCaseInsensitive('Hello World', 'hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

ngramSearchCaseInsensitiveUTF8

引入版本：v20.1.0 提供 ngramSearch 的不区分大小写 UTF-8 Variant。假定 haystack 和 needle 为 UTF-8 字符串，并且不区分大小写。检查两个 UTF-8 字符串之间的 3-gram 距离是否小于或等于给定阈值，且不区分大小写。语法

ngramSearchCaseInsensitiveUTF8(haystack, needle)

参数

haystack — 用于比较的 UTF-8 字符串。String
needle — 用于比较的 UTF-8 字符串。String

返回值 如果两个字符串之间的 3-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 3-gram 的不区分大小写 UTF-8 搜索

Query

SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')

Response

┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                               0.57142854 │
└──────────────────────────────────────────────────────────┘

ngramSearchUTF8

引入版本：v20.1.0 提供 ngramSearch 的 UTF-8 Variant。假定 haystack 和 needle 为 UTF-8 字符串。检查两个 UTF-8 字符串之间的 3-gram 距离是否小于或等于给定阈值。语法

ngramSearchUTF8(haystack, needle)

参数

haystack — 用于比较的 UTF-8 字符串。String
needle — 用于比较的 UTF-8 字符串。String

返回值 如果两个字符串之间的 3-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 3-gram 进行 UTF-8 搜索

Query

SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')

Response

┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                    0.5 │
└────────────────────────────────────────┘

notILike

引入版本：v20.6.0 检查字符串是否不匹配某个模式，且不区分大小写。该模式可包含用于 SQL LIKE 匹配的特殊字符 % 和 _。支持可选的 ESCAPE 子句 (参见 like) 。语法

notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']

参数

haystack — 待搜索的输入字符串。String 或 FixedString
pattern — 要匹配的 SQL LIKE 模式。% 匹配任意数量的字符 (包括零个) ，_ 恰好匹配一个字符。String
escape_character — 可选的单字符字符串，用作转义字符来替代 \。默认值：\。String

返回值 如果字符串与模式不匹配 (不区分大小写) ，则返回 1，否则返回 0。UInt8 示例 用法示例

Query

SELECT notILike('ClickHouse', '%house%');

Response

┌─notILike('ClickHouse', '%house%')─┐
│                                 0 │
└───────────────────────────────────┘

notLike

Introduced in：v1.1.0 与 like 类似，但会返回相反的结果。支持可选的 ESCAPE 子句 (参见 like) 。语法

notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']

参数

haystack — 要在其中执行搜索的字符串。String 或 FixedString
pattern — 用于匹配的 LIKE 模式。String
escape_character — 可选的单字符字符串，用作转义字符，以替代 \。默认值：\。String

返回值 如果字符串与 LIKE 模式不匹配，则返回 1；否则返回 0。UInt8 示例 使用示例

Query

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

Response

┌─notLike('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

不匹配的模式

Query

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

Response

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

notMatch

引入版本：v26.8.0 与 match 类似，但会对结果取反：检查字符串是否不匹配正则表达式模式。此函数使用 RE2 正则表达式库。支持的语法请参阅 re2。可选的运算符语法：haystack !~ pattern (PostgreSQL 风格) 。语法

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

参数

haystack — 在其中搜索模式的 String。String
pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值 如果匹配该模式，则返回 0，否则返回 1。UInt8 示例 使用示例

Query

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

Response

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

notMatchCaseInsensitive

引入版本：v26.8.0 与 matchCaseInsensitive 类似，但会对结果取反：检查字符串是否不与正则表达式模式进行不区分大小写的匹配。此函数使用 RE2 正则表达式库。支持的语法请参阅 re2。可选的运算符语法：haystack !~* pattern (PostgreSQL 风格) 。语法

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

参数

haystack — 在其中搜索模式的 String。String
pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值 如果不区分大小写地匹配该模式，则返回 0，否则返回 1。UInt8 示例 使用示例

Query

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

Response

┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   1 │
└───────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘

position

引入版本：v1.1.0 返回子串 needle 在字符串 haystack 中的位置 (以字节为单位，从 1 开始计数) 。如果子串 needle 为空，则适用以下规则：

如果未指定 start_pos：返回 1
如果 start_pos = 0：返回 1
如果 start_pos >= 1 且 start_pos <= length(haystack) + 1：返回 start_pos
否则：返回 0

同样的规则也适用于函数 locate、positionCaseInsensitive、positionUTF8 和 positionCaseInsensitiveUTF8。语法

position(haystack, needle[, start_pos])

参数

haystack — 执行搜索的字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — haystack 中开始搜索的位置 (从 1 开始计数) 。可选。UInt

返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 基本用法

Query

SELECT position('Hello, world!', '!')

Response

┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘

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

Needle IN haystack 语法

Query

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)

Response

┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

空 needle 的子串

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

引入版本：v1.1.0 与 position 类似，但不区分大小写。语法

positionCaseInsensitive(haystack, needle[, start_pos])

别名: instr 参数

haystack — 执行搜索的字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*

返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到子串，则返回 0。UInt64 示例 不区分大小写的搜索

Query

SELECT positionCaseInsensitive('Hello, world!', 'hello')

Response

┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

positionCaseInsensitiveUTF8

引入版本：v1.1.0 与 positionUTF8 类似，但按不区分大小写的方式搜索。语法

positionCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

haystack — 执行搜索的字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始) 。UInt*

返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 不区分大小写的 UTF-8 搜索

Query

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')

Response

┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

positionUTF8

引入版本：v1.1.0 与 position 类似，但假定 haystack 和 needle 为 UTF-8 编码的字符串。语法

positionUTF8(haystack, needle[, start_pos])

参数

haystack — 执行搜索的字符串。String 或 枚举
needle — 要搜索的子串。String
start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*

返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 按 UTF-8 字符计数

Query

SELECT positionUTF8('Motörhead', 'r')

Response

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

​countMatches

​countMatchesCaseInsensitive

​countSubstrings

​countSubstringsCaseInsensitive

​countSubstringsCaseInsensitiveUTF8

​extract

​extractAll

​extractAllGroupsHorizontal

​extractGroups

​hasAllTokens

​hasAnyTokens

​hasPhrase

​hasSubsequence

​hasSubsequenceCaseInsensitive

​hasSubsequenceCaseInsensitiveUTF8

​hasSubsequenceUTF8

​hasToken

​hasTokenCaseInsensitive

​hasTokenCaseInsensitiveOrNull

​hasTokenOrNull

​highlight

​ilike

​like

​ESCAPE 子句

​locate

​match

​matchCaseInsensitive

​multiFuzzyMatchAllIndices

​multiFuzzyMatchAny

​multiFuzzyMatchAnyIndex

​multiMatchAllIndices

​multiMatchAny

​multiMatchAnyIndex

​multiSearchAllPositions

​multiSearchAllPositionsCaseInsensitive

​multiSearchAllPositionsCaseInsensitiveUTF8

​multiSearchAllPositionsUTF8

​multiSearchAny

​multiSearchAnyCaseInsensitive

​multiSearchAnyCaseInsensitiveUTF8

​multiSearchAnyUTF8

​multiSearchFirstIndex

​multiSearchFirstIndexCaseInsensitive

​multiSearchFirstIndexCaseInsensitiveUTF8

​multiSearchFirstIndexUTF8

​multiSearchFirstPosition

​multiSearchFirstPositionCaseInsensitive

​multiSearchFirstPositionCaseInsensitiveUTF8

​multiSearchFirstPositionUTF8

​ngramDistance

​ngramDistanceCaseInsensitive

​ngramDistanceCaseInsensitiveUTF8

​ngramDistanceUTF8

​ngramSearch

​ngramSearchCaseInsensitive

​ngramSearchCaseInsensitiveUTF8

​ngramSearchUTF8

​notILike

​notLike

​notMatch

​notMatchCaseInsensitive

​position

​positionCaseInsensitive

​positionCaseInsensitiveUTF8

​positionUTF8

countMatches

countMatchesCaseInsensitive

countSubstrings

countSubstringsCaseInsensitive

countSubstringsCaseInsensitiveUTF8

extract

extractAll

extractAllGroupsHorizontal

extractGroups

hasAllTokens

hasAnyTokens

hasPhrase

hasSubsequence

hasSubsequenceCaseInsensitive

hasSubsequenceCaseInsensitiveUTF8

hasSubsequenceUTF8

hasToken

hasTokenCaseInsensitive

hasTokenCaseInsensitiveOrNull

hasTokenOrNull

highlight

ilike

like

ESCAPE 子句

locate

match

matchCaseInsensitive

multiFuzzyMatchAllIndices

multiFuzzyMatchAny

multiFuzzyMatchAnyIndex

multiMatchAllIndices

multiMatchAny

multiMatchAnyIndex

multiSearchAllPositions

multiSearchAllPositionsCaseInsensitive

multiSearchAllPositionsCaseInsensitiveUTF8

multiSearchAllPositionsUTF8

multiSearchAny

multiSearchAnyCaseInsensitive

multiSearchAnyCaseInsensitiveUTF8

multiSearchAnyUTF8

multiSearchFirstIndex

multiSearchFirstIndexCaseInsensitive

multiSearchFirstIndexCaseInsensitiveUTF8

multiSearchFirstIndexUTF8

multiSearchFirstPosition

multiSearchFirstPositionCaseInsensitive

multiSearchFirstPositionCaseInsensitiveUTF8

multiSearchFirstPositionUTF8

ngramDistance

ngramDistanceCaseInsensitive

ngramDistanceCaseInsensitiveUTF8

ngramDistanceUTF8

ngramSearch

ngramSearchCaseInsensitive

ngramSearchCaseInsensitiveUTF8

ngramSearchUTF8

notILike

notLike

notMatch

notMatchCaseInsensitive

position

positionCaseInsensitive

positionCaseInsensitiveUTF8

positionUTF8