在字符串中搜索的函数

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

注意

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

本节中的函数还假定被搜索的字符串（在本节中称为 haystack）和搜索字符串（称为 needle）是单字节编码文本。如果不满足这一假设，不会抛出异常，结果未定义。对 UTF-8 编码字符串的搜索通常由单独的函数变体提供。同样地，如果使用了 UTF-8 函数变体而输入字符串不是 UTF-8 编码文本，也不会抛出异常，结果同样未定义。请注意，不会自动执行 Unicode 规范化，但可以使用 normalizeUTF8*() 函数来完成这一操作。

通用字符串函数和字符串替换函数在单独的章节中说明。

注意

下文文档是从 system.functions 系统表生成的。

countMatches

引入版本：v21.1

返回字符串中某个正则表达式的匹配次数。

Version dependent behavior

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

在 < v25.6 的版本中，即使模式允许继续匹配，函数在遇到第一个空匹配时就会停止计数。
在 >= 25.6 的版本中，函数在发生空匹配时会继续执行。可以通过将设置 count_matches_stop_at_empty_match = true 打开来恢复旧的行为；

语法

countMatches(haystack, pattern)

参数

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

返回值

返回匹配的数量。UInt64

示例

统计数字序列

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

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

countMatchesCaseInsensitive

引入版本：v21.1

类似于 countMatches，但进行不区分大小写的匹配。

语法

countMatchesCaseInsensitive(haystack, pattern)

参数

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

返回值

返回匹配到的次数。UInt64

示例

不区分大小写的计数

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

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

countSubstrings

自 v21.1 版本引入。

返回子字符串 needle 在字符串 haystack 中出现的次数。

语法

countSubstrings(haystack, needle[, start_pos])

参数

haystack — 进行搜索的字符串。String 或 Enum。 - needle — 要搜索的子字符串。String。 - start_pos — 在 haystack 中开始搜索的位置（从 1 开始）。UInt。可选。

返回值

出现的次数。UInt64

示例

用法示例

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

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

使用 start_pos 参数

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

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

countSubstringsCaseInsensitive

自 v21.1 版本引入

与 countSubstrings 类似，但统计时不区分大小写。

语法

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

参数

haystack — 进行搜索的字符串。String 或 Enum
needle — 要搜索的子串。String
start_pos — 可选。在 haystack 中开始搜索的位置（从 1 开始）。UInt*

返回值

返回 needle 在 haystack 中出现的次数。UInt64

示例

用法示例

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

┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘

使用 start_pos 参数

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

┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

countSubstringsCaseInsensitiveUTF8

引入版本：v21.1

与 countSubstrings 类似，但以不区分大小写的方式计数，并假定 haystack 是 UTF-8 编码的字符串。

语法

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

haystack — 用于执行搜索的 UTF-8 字符串。String 或 Enum
needle — 要搜索的子字符串。String
start_pos — 可选。在 haystack 中开始搜索的位置（从 1 开始计数）。UInt*

返回值

返回 needle 在 haystack 中出现的次数。UInt64

示例

用法示例

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

┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘

使用 start_pos 参数

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

┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

extract

引入版本：v1.1

在字符串中提取正则表达式的第一个匹配项。如果 'haystack' 与 'pattern' 不匹配，则返回空字符串。

此函数使用 RE2 正则表达式库。有关支持的语法，请参阅 re2。

如果正则表达式包含捕获组（子模式），函数会根据第一个捕获组对输入字符串进行匹配。

语法

extract(haystack, pattern)

参数

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

返回值

返回提取出的片段，类型为字符串。String

示例

从邮箱地址中提取域名

SELECT extract('[email protected]', '.*@(.*)$')

┌─extract('[email protected]', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘

没有匹配时返回空字符串

SELECT extract('[email protected]', 'no_match')

┌─extract('[email protected]', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll

引入于：v1.1

类似于 extract，但会返回一个数组，包含字符串中与正则表达式匹配的所有结果。如果 'haystack' 与正则表达式 'pattern' 不匹配，则返回空数组。

如果正则表达式包含捕获组（子模式），函数会根据第一个捕获组对输入字符串进行匹配。

语法

extractAll(haystack, pattern)

参数

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

返回值

返回提取出的片段数组。Array(String)

示例

提取所有数字

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

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

通过捕获组提取

SELECT extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')

┌─extractAll('[email protected], [email protected]', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

extractAllGroupsHorizontal

引入版本：v20.5

使用给定的正则表达式匹配字符串中的所有分组，并返回一个由数组构成的数组，其中每个内部数组按分组编号组织，包含同一捕获组的所有捕获结果。

语法

extractAllGroupsHorizontal(s, regexp)

参数

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

返回值

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

示例

用法示例

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]+)');

[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

extractGroups

引入版本：v20.5

从正则表达式匹配到的、互不重叠的子串中提取所有分组。

语法

extractAllGroups(s, regexp)

参数

s — 要从中提取的输入字符串。String 或 FixedString
regexp — 正则表达式。常量值。const String 或 const FixedString

返回值

如果函数找到至少一个匹配的分组，则返回按 group_id（从 1 到 N，其中 N 是 regexp 中捕获分组数量）组织的 Array(Array(String)) 列。如果没有匹配分组，则返回空数组。Array(Array(String))

示例

使用示例

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 extractAllGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');

[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

hasAllTokens

引入版本：v25.10

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

注意

为获得最佳性能，应为列 input 定义 text index。如果未定义 text index，该函数会对整列执行全列扫描，其速度会比索引查找慢多个数量级。

在搜索之前，函数会对以下内容进行分词（tokenize）：

input 参数（始终），以及
needle 参数（如果以 String 形式给出），使用为该 text index 指定的 tokenizer。如果该列未定义 text index，则改用 splitByNonAlpha tokenizer。如果 needle 参数的类型为 Array(String)，则数组中的每个元素都被视为一个标记——不会进行额外的分词。

重复的标记会被忽略。例如，needles = ['ClickHouse', 'ClickHouse'] 与 ['ClickHouse'] 的处理方式相同。

语法

hasAllTokens(input, needles)

别名：hasAllToken

参数

input — 输入列。String 或 FixedString 或 Array(String) 或 Array(FixedString)
needles — 要搜索的词元（token）。String 或 Array(String)

返回值

如果所有词元都匹配则返回 1，否则返回 0。UInt8

示例

字符串列的使用示例

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

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

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

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

在数组中指定按原样（不进行分词）匹配的搜索词

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

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

使用 tokens 函数生成待查找的标记

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

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

数组和 Map 列的用法示例

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

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

mapKeys 示例

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

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

mapValues 示例

SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);

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

hasAnyTokens

引入版本：v25.10

如果 needle 字符串或数组中至少有一个 token 与 input 字符串匹配，则返回 1，否则返回 0。若 input 是一列，则返回所有满足此条件的行。

注意

为获得最佳性能，应为列 input 定义 text 索引。如果未定义 text 索引，该函数会对整列执行暴力扫描，其速度会比使用索引查找慢几个数量级。

在搜索之前，函数会对以下内容进行分词（tokenize）：

input 参数（始终），以及
needle 参数（如果以 String 形式给出），使用为 text 索引指定的分词器。如果该列未定义 text 索引，则会使用 splitByNonAlpha 分词器。如果 needle 参数的类型为 Array(String)，则数组中的每个元素都被视为一个 token——不会进行额外的分词。

重复的 token 会被忽略。例如，['ClickHouse', 'ClickHouse'] 与 ['ClickHouse'] 被视为相同。

语法

hasAnyTokens(input, needles)

别名: hasAnyToken

参数

input — 输入列。String 或 FixedString 或 Array(String) 或 Array(FixedString)
needles — 要搜索的标记（token）。String 或 Array(String)

返回值

如果存在至少一个匹配项，则返回 1，否则返回 0。UInt8

示例

字符串列的用法示例

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

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

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

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

指定在数组中按原样（不进行分词）查找的目标字符串

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

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

使用 tokens 函数生成搜索词

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

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

数组列和 Map 列的使用示例

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

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

使用 mapKeys 的示例

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

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

mapValues 示例

SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);

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

hasSubsequence

引入版本：v23.7

检查 needle 是否为 haystack 的子序列。字符串的子序列是指可以通过删除原字符串中的某些字符（也可以一个都不删），并保持剩余字符相对顺序不变而得到的序列。

语法

hasSubsequence(haystack, needle)

参数

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

返回值

如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8

示例

基本子序列检查

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

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

未找到匹配的子序列

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

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

hasSubsequenceCaseInsensitive

自 v23.7 引入

与 hasSubsequence 类似，但进行大小写不敏感的搜索。

语法

hasSubsequenceCaseInsensitive(haystack, needle)

参数

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

返回值

如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8

示例

用法示例

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

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

hasSubsequenceCaseInsensitiveUTF8

自 v23.7 引入

与 hasSubsequenceUTF8 类似，但执行不区分大小写的搜索。

语法

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

参数

haystack — 执行搜索的 UTF-8 编码字符串。String
needle — 要查找的 UTF-8 编码子序列字符串。String

返回值

如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8

示例

用法示例

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

┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

hasSubsequenceUTF8

引入版本：v23.7

类似于 hasSubsequence，但假设 haystack 和 needle 是 UTF-8 编码的字符串。

语法

hasSubsequenceUTF8(haystack, needle)

参数

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

返回值

如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8

示例

用法示例

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

┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘

未匹配的子序列

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

┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

hasToken

引入版本：v20.1

检查给定 token 是否存在于 haystack 中。

使用 splitByNonAlpha 作为分词器，即 token 被定义为由字符 [0-9A-Za-z_]（数字、ASCII 字符和下划线）组成的最长可能的连续子序列。

语法

hasToken(haystack, token)

参数

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

返回值

如果找到 token，则返回 1，否则返回 0。UInt8

示例

Token 查找

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

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

hasTokenCaseInsensitive

引入于：v

在 haystack 中使用 tokenbf_v1 索引对 needle 执行不区分大小写的查找。

语法

参数

无。

返回值

示例

hasTokenCaseInsensitiveOrNull

引入于：v

使用 tokenbf_v1 索引在 haystack 中对 needle 执行不区分大小写的查找。如果 needle 非法，则返回 NULL。

语法

参数

无。

返回值

示例

hasTokenOrNull

引入于：v20.1

类似于 hasToken，但当 token 格式不合法时返回 null。

语法

hasTokenOrNull(haystack, token)

参数

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

返回值

如果找到 token 则返回 1，否则返回 0；如果 token 格式不合法则返回 null。Nullable(UInt8)

示例

用法示例

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

┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

ilike

自 v20.6 引入

类似于 like，但进行大小写不敏感的匹配。

语法

ilike(haystack, pattern)
-- haystack ILIKE pattern

参数

haystack — 要在其中执行查找的字符串。String 或 FixedString
pattern — 要匹配的 LIKE 模式。String

返回值

如果字符串匹配 LIKE 模式（不区分大小写），则返回 1，否则返回 0。UInt8

示例

用法示例

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

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

like

引入版本：v1.1

返回字符串 haystack 是否与 LIKE 表达式 pattern 匹配。

一个 LIKE 表达式可以包含普通字符以及以下元符号：

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

匹配基于 UTF-8，例如 _ 可以匹配 Unicode 码点 ¥，该码点在 UTF-8 中使用两个字节表示。

如果 haystack 或 LIKE 表达式不是有效的 UTF-8，则行为未定义。

不会自动进行 Unicode 规范化，您可以使用 normalizeUTF8* 函数来实现这一点。

要匹配字面量 %、_ 和 \（它们是 LIKE 元字符），需要在前面加反斜杠：\%、\_ 和 \\。如果反斜杠位于除 %、_ 或 \ 之外的字符前时，其特殊含义将失效（即按字面量解释）。

注意

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

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

语法

like(haystack, pattern)
-- haystack LIKE pattern

参数

haystack — 要在其中执行搜索的字符串。String 或 FixedString
pattern — 用于匹配的 LIKE 模式。可以包含 %（匹配任意数量的字符）、_（匹配单个字符）以及用于转义的反斜杠 \。String

返回值

如果字符串与 LIKE 模式匹配，则返回 1，否则返回 0。UInt8

示例

用法示例

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

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

单字符通配符

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

┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘

未匹配的模式

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

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

locate

引入版本：v18.16

类似于 position，但参数 haystack 和 locate 的顺序是相反的。

Version dependent behavior

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

在 v24.3 之前的版本中，locate 是函数 position 的别名，接受参数 (haystack, needle[, start_pos])。
在 v24.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

示例

基本用法

SELECT locate('ca', 'abcabc')

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

match

引入版本：v1.1

检查给定字符串是否与给定的正则表达式模式匹配。

此函数使用 RE2 正则表达式库。有关支持的语法，请参阅 re2。

匹配基于 UTF-8 假设进行，例如 ¥ 在内部使用两个字节，但在匹配时被视为单个码点。正则表达式中不能包含 NULL 字节。如果 haystack 或 pattern 不是有效的 UTF-8，其行为未定义。

与 re2 的默认行为不同，. 会匹配换行符。若要禁用此行为，请在模式前加上 (?-s)。

模式会在两端自动锚定（就好像模式以 ^ 开头并以 $ 结尾）。

如果你只想查找子字符串，可以改用函数 like 或 position —— 它们的执行速度远快于此函数。

替代运算符语法：haystack REGEXP pattern。

语法

match(haystack, pattern)

别名: REGEXP_MATCHES

参数

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

返回值

如果模式匹配则返回 1，否则返回 0。UInt8

示例

基本模式匹配

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

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

未匹配到模式

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

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

multiFuzzyMatchAllIndices

引入版本：v20.1

与 multiFuzzyMatchAny 类似，但返回在固定编辑距离约束下，与 haystack 匹配的所有索引组成的数组，顺序任意。

语法

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

参数

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

返回值

返回一个数组，其中包含所有在指定编辑距离内与 haystack 匹配的索引（从 1 开始），顺序不固定。如果未找到匹配项，则返回空数组。Array(UInt64)

示例

用法示例

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

┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

multiFuzzyMatchAny

引入版本：v20.1

类似于 multiMatchAny，但在给定恒定的编辑距离内，只要任意模式与 haystack 匹配就返回 1。此函数依赖于 hyperscan 库的实验性特性，在某些极端情况下可能较慢。性能取决于编辑距离的大小和所使用的模式，但与非模糊变体相比，其开销始终更大。

注意

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

语法

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

参数

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

返回值

如果任意模式在指定编辑距离范围内匹配 haystack，则返回 1，否则返回 0。UInt8

示例

用法示例

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

┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

multiFuzzyMatchAnyIndex

引入于：v20.1

类似于 multiFuzzyMatchAny，但返回在给定常量编辑距离范围内与目标字符串匹配的任意索引。

语法

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

参数

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

返回值

返回在指定编辑距离内与 haystack 中任意一个模式匹配的索引（从 1 开始），否则返回 0。UInt64

示例

用法示例

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

┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

multiMatchAllIndices

自 v20.1 起提供

类似于 multiMatchAny，但会按任意顺序返回所有与 haystack 匹配的索引组成的数组。

语法

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

参数

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

返回值

所有匹配项的索引（从 1 开始）组成的数组，索引顺序任意。如果未找到匹配，则返回空数组。Array(UInt64)

示例

使用示例

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

┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

multiMatchAny

引入版本：v20.1

检查多个正则表达式模式中是否至少有一个与目标字符串匹配。

如果只需要在字符串中搜索多个子串，可以改用函数 multiSearchAny —— 它比本 FUNCTION 快得多。

语法

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

参数

haystack — 要在其中搜索的字符串。String
pattern1[, pattern2, ...] — 由一个或多个正则表达式模式组成的数组。Array(String)

返回值

如果任一模式匹配则返回 1，否则返回 0。UInt8

示例

多模式匹配

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

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

未匹配到任何模式

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

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

multiMatchAnyIndex

引入于：v20.1

类似于 multiMatchAny，但返回在 haystack 中匹配到的任意索引。

语法

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

参数

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

返回值

返回第一个匹配成功的模式的索引（从 1 开始），如果未找到匹配则返回 0。UInt64

示例

用法示例

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

┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

multiSearchAllPositions

引入版本：v20.1

类似于 position，但会返回一个位置数组，表示 haystack 字符串中多个 needle 子串的匹配位置（以字节为单位，从 1 开始计数）。

所有 multiSearch*() 函数至多支持 2^8 个 needle。

语法

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

参数

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

返回值

返回一个数组，元素为子字符串的起始位置（以字节为单位，从 1 开始计数）；如果找到子字符串则返回其位置，未找到则返回 0。Array(UInt64)

示例

多个 needle 搜索

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

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

multiSearchAllPositionsCaseInsensitive

自 v20.1 版本引入。

类似于 multiSearchAllPositions，但忽略大小写。

语法

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

参数

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

返回值

返回一个数组：如果找到子字符串，则为其起始位置（以字节为单位，从 1 开始计数）；如果未找到子字符串，则为 0。Array(UInt64)

示例

不区分大小写的多重搜索

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

┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

multiSearchAllPositionsCaseInsensitiveUTF8

自 v20.1 版本引入。

与 multiSearchAllPositionsUTF8 类似，但忽略大小写。

语法

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

参数

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

返回值

如果找到了子串，则返回一个以字节为单位、从 1 开始计数的起始位置数组。如果未找到子串，则返回 0。Array

示例

不区分大小写的 UTF-8 搜索

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

┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

multiSearchAllPositionsUTF8

引入版本：v20.1

与 multiSearchAllPositions 类似，但假定 haystack 和 needle 子串是 UTF-8 编码的字符串。

语法

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

参数

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

返回值

返回一个数组，其中每个元素为起始位置的字节偏移（从 1 开始计数，如果找到子字符串），若未找到子字符串则为 0。Array

示例

UTF-8 多重搜索

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

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

multiSearchAny

引入版本：v20.1

检查在多个 needle 字符串中，是否至少有一个与 haystack 字符串匹配。

函数 multiSearchAnyCaseInsensitive、multiSearchAnyUTF8 和 multiSearchAnyCaseInsensitiveUTF8 提供该函数的不区分大小写和/或 UTF-8 变体。

语法

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

参数

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

返回值

如果至少存在一个匹配，则返回 1；否则返回 0。UInt8

示例

任意匹配查找

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

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

multiSearchAnyCaseInsensitive

在 v20.1 版本中引入。

与 multiSearchAny 类似，但忽略大小写。

语法

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

参数

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

返回值

如果至少存在一个不区分大小写的匹配，则返回 1，否则（不存在任何不区分大小写的匹配时）返回 0。UInt8

示例

不区分大小写搜索

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

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

multiSearchAnyCaseInsensitiveUTF8

引入版本：v20.1

功能类似于 multiSearchAnyUTF8，但不区分大小写。

语法

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

参数

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

返回值

如果至少存在一个不区分大小写的匹配，则返回 1；否则返回 0。UInt8

示例

给定 UTF-8 字符串 'Здравствуйте'，检查字符 'з'（小写）是否存在

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

┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

multiSearchAnyUTF8

自 v20.1 版本引入

与 multiSearchAny 类似，但假定 haystack 和 needle 子字符串是 UTF-8 编码的字符串。

语法

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

参数

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

返回值

如果至少有一个匹配，则返回 1，否则返回 0。UInt8

示例

给定 '你好，世界'（'Hello, world'）作为 UTF-8 字符串，检查该字符串中是否存在任意一个「你」或「界」字符

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

┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstIndex

引入版本：v20.1

在一个源字符串中（区分大小写）搜索多个目标字符串，并返回首次匹配到的目标字符串的从 1 开始的索引。

语法

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

参数

haystack — 要在其中执行搜索的字符串。String
needles — 要搜索的字符串构成的数组。Array(String)

返回值

返回在 haystack 中找到的 needles 数组中第一个元素在该数组中的从 1 开始的索引（位置）。如果未找到任何元素，则返回 0。搜索区分大小写。UInt64

示例

用法示例

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

┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘

大小写敏感时的行为

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

┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘

未找到匹配结果

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

┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

multiSearchFirstIndexCaseInsensitive

引入版本：v20.1

返回在字符串 haystack 中从左侧起首次匹配到的 needle_i 的索引 i（从 1 开始计数）；如果未找到则返回 0。比较时忽略大小写。

语法

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

参数

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

返回值

返回最左边首次找到的 needle 的索引（从 1 开始计数）。如果没有匹配，则返回 0。UInt8

示例

用法示例

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

┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstIndexCaseInsensitiveUTF8

自 v20.1 引入

在一个字符串中不区分大小写地搜索多个子字符串（needle），支持 UTF-8 编码，并返回第一个被找到的子字符串的从 1 开始的索引位置。

语法

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

参数

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

返回值

返回在 haystack 中找到的第一个 needle 在 needles 数组中的从 1 开始的索引（位置）。如果未找到任何 needle，则返回 0。搜索大小写不敏感，并基于 UTF-8 字符编码。UInt64

示例

用法示例

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

┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘

UTF-8 大小写规则

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

┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘

未找到匹配结果

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

┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

multiSearchFirstIndexUTF8

引入版本：v20.1

返回在字符串 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

示例

用法示例

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

┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

multiSearchFirstPosition

引入于：v20.1

类似于 position，但返回在 haystack 字符串中，与多个 needle 字符串中任意一个匹配的最左侧位置的偏移量。

函数 multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8 和 multiSearchFirstPositionCaseInsensitiveUTF8 提供该函数的大小写不敏感和/或 UTF-8 版本。

语法

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

参数

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

返回值

返回 haystack 字符串中，与多个 needle 字符串中任意一个匹配的、最左侧出现位置的偏移量；如果没有匹配，则返回 0。UInt64

示例

首个位置搜索

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

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

multiSearchFirstPositionCaseInsensitive

自 v20.1 引入

与 multiSearchFirstPosition 类似，但忽略字符大小写。

语法

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

参数

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

返回值

返回在 haystack 字符串中与多个 needle 字符串中任意一个匹配的最左侧偏移量。如果没有匹配则返回 0。UInt64

示例

不区分大小写的首个匹配位置

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

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

multiSearchFirstPositionCaseInsensitiveUTF8

自 v20.1 引入

与 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 匹配的最左侧偏移量

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

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

multiSearchFirstPositionUTF8

自 v20.1 引入

与 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 匹配的最左侧偏移量

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

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

ngramDistance

引入版本：v20.1

计算两个字符串之间的 4-gram 距离。具体而言，它计算两个 4-gram 多重集之间的对称差，并用它们基数之和对结果进行归一化处理。返回值越小，字符串越相似。

对于不区分大小写的搜索和/或 UTF-8 格式，请使用函数 ngramDistanceCaseInsensitive、ngramDistanceUTF8、ngramDistanceCaseInsensitiveUTF8。

语法

ngramDistance(haystack, needle)

参数

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

返回值

返回一个介于 0 和 1 之间的 Float32 类型数值。返回值越小，字符串越相似。Float32

示例

计算 4-gram 距离

SELECT ngramDistance('ClickHouse', 'ClickHouses')

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

ngramDistanceCaseInsensitive

引入版本：v20.1

提供 ngramDistance 的不区分大小写变体。计算两个字符串之间的 4-gram 距离，忽略大小写。返回值越小，字符串越相似。

语法

ngramDistanceCaseInsensitive(haystack, needle)

参数

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

返回值

返回介于 0 和 1 之间的 Float32 类型数值。Float32

示例

不区分大小写的 4-gram 距离

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')

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

ngramDistanceCaseInsensitiveUTF8

引入版本：v20.1

提供 ngramDistance 的不区分大小写的 UTF-8 变体。假定 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 距离

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')

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

ngramDistanceUTF8

引入于：v20.1

提供 ngramDistance 的 UTF-8 变体。假定 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 距离

SELECT ngramDistanceUTF8('abcde','cde')

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

ngramSearch

引入于：v20.1

检查两个字符串之间的 4-gram 距离是否小于或等于给定阈值。

对于不区分大小写和/或 UTF8 格式的搜索，请使用函数 ngramSearchCaseInsensitive、ngramSearchUTF8、ngramSearchCaseInsensitiveUTF8。

语法

ngramSearch(haystack, needle)

参数

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

返回值

如果两个字符串之间的 4-gram 距离小于或等于阈值（默认 1.0），则返回 1，否则返回 0。UInt8

示例

使用 4-gram 进行搜索

SELECT ngramSearch('ClickHouse', 'Click')

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

ngramSearchCaseInsensitive

引入版本：v20.1

提供 ngramSearch 的大小写不敏感变体。计算 needle 字符串与 haystack 字符串之间的非对称差值，即 needle 中 n-gram 的数量减去两者共有的 n-gram 数量，并按 needle 中的 n-gram 数量归一化。在忽略大小写的情况下，检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值。

语法

ngramSearchCaseInsensitive(haystack, needle)

参数

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

返回值

如果字符串之间的 4-gram 距离小于或等于阈值（默认值为 1.0），则返回 1，否则返回 0。UInt8

示例

使用 4-gram 的不区分大小写搜索

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

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

ngramSearchCaseInsensitiveUTF8

引入版本：v20.1

提供 ngramSearch 的不区分大小写 UTF-8 变体。假定 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 不区分大小写搜索

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

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

ngramSearchUTF8

在 v20.1 中引入

提供 ngramSearch 的 UTF-8 变体。假定 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 搜索

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

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

notILike

引入版本：v20.6

在不区分大小写的情况下检查字符串是否不匹配某个模式。该模式可以包含用于 SQL LIKE 匹配的特殊字符 % 和 _。

语法

notILike(haystack, pattern)

参数

haystack — 要搜索的输入字符串。String 或 FixedString
pattern — 要匹配的 SQL LIKE 模式字符串。% 匹配任意数量的字符（包括零个），_ 匹配恰好一个字符。String

返回值

如果字符串与该模式不匹配（不区分大小写），则返回 1，否则返回 0。UInt8

示例

用法示例

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

┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

notLike

自 v1.1 版本引入

类似于 like，但会对结果取反。

语法

notLike(haystack, pattern)
-- haystack NOT LIKE pattern

参数

haystack — 执行搜索的字符串。String 或 FixedString
pattern — 用于匹配的 LIKE 模式。String

返回值

如果字符串不匹配 LIKE 模式则返回 1，否则返回 0。UInt8

示例

使用示例

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

┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘

未匹配到的模式

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

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

position

自 v1.1 起引入

返回子字符串 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 或 Enum
needle — 要查找的子字符串。String
start_pos — 在 haystack 中开始查找的位置（从 1 开始计数）。可选。UInt

返回值

如果找到子字符串，则返回起始位置（按字节计数，从 1 开始）；如果未找到，则返回 0。UInt64

示例

基本用法

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

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

使用 start_pos 参数

SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)

┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘

needle IN haystack 语法

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

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

空搜索子串

SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)

┌─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 中引入

与 position 类似，但不区分大小写。

语法

positionCaseInsensitive(haystack, needle[, start_pos])

别名: instr

参数

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

返回值

如果找到子字符串，则返回起始位置（按字节计，从 1 开始）；如果未找到子字符串，则返回 0。UInt64

示例

不区分大小写搜索

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

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

positionCaseInsensitiveUTF8

在 v1.1 中引入。

与 positionUTF8 类似，但进行不区分大小写的搜索。

语法

positionCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

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

返回值

如果找到子字符串，则返回从 1 开始计数的起始字节位置；如果未找到子字符串，则返回 0。UInt64

示例

不区分大小写的 UTF-8 搜索

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

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

positionUTF8

自 v1.1 版本引入

与 position 类似，但假设 haystack 和 needle 为 UTF-8 编码的字符串。

语法

positionUTF8(haystack, needle[, start_pos])

参数

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

返回值

如果找到子字符串，则返回其起始位置的字节偏移（从 1 开始计数）；如果未找到子字符串，则返回 0。UInt64

示例

UTF-8 字符计数

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

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

countMatches​

countMatchesCaseInsensitive​

countSubstrings​

countSubstringsCaseInsensitive​

countSubstringsCaseInsensitiveUTF8​

extract​

extractAll​

extractAllGroupsHorizontal​

extractGroups​

hasAllTokens​

hasAnyTokens​

hasSubsequence​

hasSubsequenceCaseInsensitive​

hasSubsequenceCaseInsensitiveUTF8​

hasSubsequenceUTF8​

hasToken​

hasTokenCaseInsensitive​

hasTokenCaseInsensitiveOrNull​

hasTokenOrNull​

ilike​

like​

locate​

match​

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​

position​

positionCaseInsensitive​

positionCaseInsensitiveUTF8​

positionUTF8​

countMatches

countMatchesCaseInsensitive

countSubstrings

countSubstringsCaseInsensitive

countSubstringsCaseInsensitiveUTF8

extract

extractAll

extractAllGroupsHorizontal

extractGroups

hasAllTokens

hasAnyTokens

hasSubsequence

hasSubsequenceCaseInsensitive

hasSubsequenceCaseInsensitiveUTF8

hasSubsequenceUTF8

hasToken

hasTokenCaseInsensitive

hasTokenCaseInsensitiveOrNull

hasTokenOrNull

ilike

like

locate

match

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

position

positionCaseInsensitive

positionCaseInsensitiveUTF8

positionUTF8