字符串搜索函数

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

注意

区分大小写的搜索遵循英语语言的小写和大写规则。例如，英语语言中的大写“i”是“I”，而土耳其语中的大写“i”是“İ” - 其他语言的结果可能与预期不符。

本节中的函数还假设被搜索的字符串（在本节中称为“haystack”）和搜索字符串（在本节中称为“needle”）是单字节编码的文本。如果违反此假设，则不会抛出异常，结果是未定义的。使用 UTF-8 编码字符串的搜索通常由单独的函数变体提供。同样，如果使用 UTF-8 函数变体并且输入字符串不是 UTF-8 编码的文本，则不会抛出异常，结果是未定义的。请注意，不会执行自动 Unicode 规范化，但是可以使用 normalizeUTF8*() 函数来实现这一点。

通用字符串函数和字符串替换函数在其他地方进行了描述。

position

返回字符串“haystack”中子字符串“needle”的位置（以字节为单位，从 1 开始）。

语法

position(haystack, needle[, start_pos])

别名

position(needle IN haystack)

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。字符串.
start_pos - haystack 中搜索开始的（从 1 开始的）位置。 UInt。可选。

返回值

如果找到子字符串，则以字节为单位，从 1 开始计数的起始位置。 UInt64.
如果未找到子字符串，则为 0。 UInt64.

如果子字符串“needle”为空，则应用以下规则

如果没有指定start_pos: 返回1
如果start_pos = 0: 返回1
如果start_pos >= 1 并且 start_pos <= length(haystack) + 1: 返回start_pos
否则: 返回0

相同的规则也适用于函数locate, positionCaseInsensitive, positionUTF8 和 positionCaseInsensitiveUTF8。

示例

查询

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

带有空needle 子字符串的示例

查询

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

locate

与 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])

positionCaseInsensitive

position 的不区分大小写的不变式。

示例

查询

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

结果

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

positionUTF8

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

示例

函数positionUTF8 正确地将字符ö（由两个点表示）计算为一个 Unicode 代码点

查询

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

结果

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

positionCaseInsensitiveUTF8

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

multiSearchAllPositions

与 position 相似，但返回一个数组，其中包含haystack 字符串中多个needle 子字符串的位置（以字节为单位，从 1 开始）。

注意

所有multiSearch*() 函数最多只支持 2⁸ 个针。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

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

示例

查询

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

结果

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

multiSearchAllPositionsCaseInsensitive

与 multiSearchAllPositions 相似，但不区分大小写。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

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

示例

查询

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

结果

["1","6"]

multiSearchAllPositionsUTF8

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

语法

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

参数

haystack - 执行搜索的 UTF-8 编码字符串。字符串.
needle - 要搜索的 UTF-8 编码子字符串。数组.

返回值

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

示例

给定 ClickHouse 作为 UTF-8 字符串，找到 C（\x43）和 H（\x48）的位置。

查询

SELECT multiSearchAllPositionsUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x43','\x48']);

结果

["1","6"]

multiSearchAllPositionsCaseInsensitiveUTF8

与 multiSearchAllPositionsUTF8 相似，但不区分大小写。

语法

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

参数

haystack - 执行搜索的 UTF-8 编码字符串。字符串.
needle - 要搜索的 UTF-8 编码子字符串。数组.

返回值

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

示例

给定 ClickHouse 作为 UTF-8 字符串，找到 c（\x63）和 h（\x68）的位置。

查询

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x63','\x68']);

结果

["1","6"]

multiSearchFirstPosition

与 position 相似，但返回haystack 字符串中与多个needle 字符串中的任何一个匹配的最左侧偏移量。

函数 multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8 和 multiSearchFirstPositionCaseInsensitiveUTF8 提供此函数的不区分大小写和/或 UTF-8 变体。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

haystack 字符串中与多个needle 字符串中的任何一个匹配的最左侧偏移量。
0，如果不存在匹配项。

示例

查询

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

结果

multiSearchFirstPositionCaseInsensitive

与 multiSearchFirstPosition 相似，但不区分大小写。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串数组。数组.

返回值

haystack 字符串中与多个needle 字符串中的任何一个匹配的最左侧偏移量。
0，如果不存在匹配项。

示例

查询

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

结果

multiSearchFirstPositionUTF8

与 multiSearchFirstPosition 相似，但假设haystack 和 needle 是 UTF-8 字符串。

语法

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

参数

haystack - 执行搜索的 UTF-8 字符串。字符串.
needle - 要搜索的 UTF-8 子字符串数组。数组.

返回值

haystack 字符串中与多个needle 字符串中的任何一个匹配的最左侧偏移量。
0，如果不存在匹配项。

示例

在 UTF-8 字符串hello world 中找到与给定针中的任何一个匹配的最左侧偏移量。

查询

SELECT multiSearchFirstPositionUTF8('\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64',['wor', 'ld', 'ello']);

结果

multiSearchFirstPositionCaseInsensitiveUTF8

与 multiSearchFirstPosition 相似，但假设haystack 和 needle 是 UTF-8 字符串，并且不区分大小写。

语法

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

参数

haystack - 执行搜索的 UTF-8 字符串。字符串.
needle - 要搜索的 UTF-8 子字符串数组。数组

返回值

haystack 字符串中与多个needle 字符串中的任何一个匹配的最左侧偏移量，不区分大小写。
0，如果不存在匹配项。

示例

在 UTF-8 字符串 HELLO WORLD 中查找与给定任何一个 needle 匹配的最左侧偏移量。

查询

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('\x48\x45\x4c\x4c\x4f\x20\x57\x4f\x52\x4c\x44',['wor', 'ld', 'ello']);

结果

multiSearchFirstIndex

返回字符串 haystack 中最左侧找到的 needle_i 的索引 i（从 1 开始），否则返回 0。

函数 multiSearchFirstIndexCaseInsensitive、multiSearchFirstIndexUTF8 和 multiSearchFirstIndexCaseInsensitiveUTF8 提供了此函数的区分大小写和/或 UTF-8 变体。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

最左侧找到的 needle 的索引（从 1 开始），否则为 0，如果未找到匹配项。 UInt8.

示例

查询

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

结果

multiSearchFirstIndexCaseInsensitive

返回字符串 haystack 中最左侧找到的 needle_i 的索引 i（从 1 开始），否则返回 0。忽略大小写。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

最左侧找到的 needle 的索引（从 1 开始），否则为 0，如果未找到匹配项。 UInt8.

示例

查询

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

结果

multiSearchFirstIndexUTF8

返回字符串 haystack 中最左侧找到的 needle_i 的索引 i（从 1 开始），否则返回 0。假设 haystack 和 needle 是 UTF-8 编码的字符串。

语法

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

参数

haystack - 执行搜索的 UTF-8 字符串。字符串.
needle - 要搜索的 UTF-8 子字符串数组。数组

返回值

最左侧找到的 needle 的索引（从 1 开始），否则为 0，如果未找到匹配项。 UInt8.

示例

给定一个 UTF-8 字符串 Hello World，查找 UTF-8 字符串 Hello 和 World 的第一个索引。

查询

SELECT multiSearchFirstIndexUTF8('\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64',['\x57\x6f\x72\x6c\x64','\x48\x65\x6c\x6c\x6f']);

结果

multiSearchFirstIndexCaseInsensitiveUTF8

返回字符串 haystack 中最左侧找到的 needle_i 的索引 i（从 1 开始），否则返回 0。假设 haystack 和 needle 是 UTF-8 编码的字符串。忽略大小写。

语法

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

参数

haystack - 执行搜索的 UTF-8 字符串。字符串.
needle - 要搜索的 UTF-8 子字符串数组。数组.

返回值

最左侧找到的 needle 的索引（从 1 开始），否则为 0，如果未找到匹配项。 UInt8.

示例

给定一个 UTF-8 字符串 HELLO WORLD，查找 UTF-8 字符串 hello 和 world 的第一个索引。

查询

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('\x48\x45\x4c\x4c\x4f\x20\x57\x4f\x52\x4c\x44',['\x68\x65\x6c\x6c\x6f','\x77\x6f\x72\x6c\x64']);

结果

multiSearchAny

如果至少一个字符串 needle_i 与字符串 haystack 匹配，则返回 1，否则返回 0。

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

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。数组.

返回值

如果至少存在一个匹配项，则为 1。
如果不存在至少一个匹配项，则为 0。

示例

查询

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

结果

multiSearchAnyCaseInsensitive

与 multiSearchAny 相同，但忽略大小写。

语法

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

参数

haystack - 执行搜索的字符串。字符串.
needle — 要搜索的子字符串。 Array

返回值

如果存在至少一个不区分大小写的匹配项，则为 1。
如果不存在至少一个不区分大小写的匹配项，则为 0。

示例

查询

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

结果

multiSearchAnyUTF8

与 multiSearchAny 相同，但假设 haystack 和 needle 子字符串是 UTF-8 编码的字符串。

*语法**

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

参数

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

返回值

如果至少存在一个匹配项，则为 1。
如果不存在至少一个匹配项，则为 0。

示例

给定一个 UTF-8 字符串 ClickHouse，检查单词中是否存在任何 C ('\x43') 或 H ('\x48') 字母。

查询

SELECT multiSearchAnyUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x43','\x48']);

结果

multiSearchAnyCaseInsensitiveUTF8

与 multiSearchAnyUTF8 相同，但忽略大小写。

*语法**

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

参数

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

返回值

如果存在至少一个不区分大小写的匹配项，则为 1。
如果不存在至少一个不区分大小写的匹配项，则为 0。

示例

给定一个 UTF-8 字符串 ClickHouse，检查单词中是否存在任何字母 h(\x68)，忽略大小写。

查询

SELECT multiSearchAnyCaseInsensitiveUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x68']);

结果

match

返回字符串 haystack 是否与正则表达式 pattern 在 re2 正则表达式语法中匹配。

匹配基于 UTF-8，例如 . 匹配 Unicode 代码点 ¥，它在 UTF-8 中用两个字节表示。正则表达式不能包含空字节。如果 haystack 或 pattern 不是有效的 UTF-8，则行为未定义。

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

如果您只想在字符串中搜索子字符串，可以使用函数 like 或 position 代替 - 它们比此函数快得多。

语法

match(haystack, pattern)

别名：haystack REGEXP pattern operator

multiMatchAny

与 match 相同，但如果至少一个模式匹配则返回 1，否则返回 0。

注意

multi[Fuzzy]Match*() 系列中的函数使用（Vectorscan）[https://github.com/VectorCamp/vectorscan]库。因此，只有在 ClickHouse 使用对 vectorscan 的支持进行编译时才会启用它们。

要关闭所有使用 hyperscan 的函数，请使用设置 SET allow_hyperscan = 0;。

由于 vectorscan 的限制，haystack 字符串的长度必须小于 2³² 字节。

Hyperscan 通常容易受到正则表达式拒绝服务 (ReDoS) 攻击（例如，参见（此处）[https://www.usenix.org/conference/usenixsecurity22/presentation/turonova]，（此处）[https://doi.org/10.1007/s10664-021-10033-1]和（此处）[https://doi.org/10.1145/3236024.3236027]。建议用户仔细检查提供的模式。

如果您只想在字符串中搜索多个子字符串，可以使用函数 multiSearchAny 代替 - 它比此函数快得多。

语法

multiMatchAny(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiMatchAnyIndex

与 multiMatchAny 相同，但返回任何与 haystack 匹配的索引。

语法

multiMatchAnyIndex(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiMatchAllIndices

与 multiMatchAny 相同，但返回与 haystack 匹配的所有索引的数组（以任何顺序）。

语法

multiMatchAllIndices(haystack, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAny

与 multiMatchAny 相同，但如果任何模式在恒定编辑距离内与 haystack 匹配，则返回 1。此函数依赖于 hyperscan 库的实验性功能，并且在某些极端情况下可能很慢。性能取决于编辑距离值和使用的模式，但始终比非模糊变体更昂贵。

注意

multiFuzzyMatch*() 函数族不支持 UTF-8 正则表达式（它将它们视为字节序列），因为 hyperscan 有限制。

语法

multiFuzzyMatchAny(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAnyIndex

与 multiFuzzyMatchAny 相同，但返回任何在恒定编辑距离内与 haystack 匹配的索引。

语法

multiFuzzyMatchAnyIndex(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

multiFuzzyMatchAllIndices

与 multiFuzzyMatchAny 相同，但返回在恒定编辑距离内与 haystack 匹配的所有索引的数组（以任何顺序）。

语法

multiFuzzyMatchAllIndices(haystack, distance, \[pattern<sub>1</sub>, pattern<sub>2</sub>, ..., pattern<sub>n</sub>\])

extract

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

如果正则表达式有捕获组，则该函数将输入字符串与第一个捕获组匹配。

语法

extract(haystack, pattern)

*参数**

haystack — 输入字符串。 String.
pattern — 使用 re2 正则表达式语法的正则表达式。

返回值

haystack 字符串中正则表达式的第一个匹配项。 String.

示例

查询

SELECT extract('number: 1, number: 2, number: 3', '\\d+') AS result;

结果

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

extractAll

返回字符串中正则表达式的所有匹配项的数组。如果 haystack 不匹配 pattern 正则表达式，则返回空字符串。

关于子模式的行为与函数 extract 相同。

语法

extractAll(haystack, pattern)

*参数**

haystack — 输入字符串。 String.
pattern — 使用 re2 正则表达式语法的正则表达式。

返回值

haystack 字符串中正则表达式的所有匹配项的数组。 Array(String).

示例

查询

SELECT extractAll('number: 1, number: 2, number: 3', '\\d+') AS result;

结果

┌─result────────┐
│ ['1','2','3'] │
└───────────────┘

extractAllGroupsHorizontal

使用 pattern 正则表达式匹配 haystack 字符串的所有组。返回一个二维数组，其中第一个数组包含与第一个组匹配的所有片段，第二个数组包含与第二个组匹配的片段，依此类推。

此函数比 extractAllGroupsVertical 慢。

语法

extractAllGroupsHorizontal(haystack, pattern)

参数

haystack — 输入字符串。 String.
pattern — 使用 re2 正则表达式语法的正则表达式。必须包含组，每个组用括号括起来。如果 pattern 不包含组，则会抛出异常。 String.

返回值

匹配项的二维数组。 Array.

注意

如果 haystack 不匹配 pattern 正则表达式，则返回一个空二维数组。

示例

SELECT extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)');

结果

┌─extractAllGroupsHorizontal('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','def','ghi'],['111','222','333']]                                                │
└──────────────────────────────────────────────────────────────────────────────────────────┘

extractGroups

使用给定的正则表达式匹配给定输入字符串的所有组，返回一个匹配项的二维数组。

语法

extractGroups(haystack, pattern)

参数

haystack — 输入字符串。 String.
pattern — 使用 re2 正则表达式语法的正则表达式。必须包含组，每个组用括号括起来。如果 pattern 不包含组，则会抛出异常。 String.

返回值

匹配项的二维数组。 Array.

示例

SELECT extractGroups('hello abc=111 world', '("[^"]+"|\\w+)=("[^"]+"|\\w+)') AS result;

结果

┌─result────────┐
│ ['abc','111'] │
└───────────────┘

extractAllGroupsVertical

使用 pattern 正则表达式匹配 haystack 字符串的所有组。返回一个二维数组，其中每个数组包含来自每个组的匹配片段。片段按其在 haystack 中出现的顺序分组。

语法

extractAllGroupsVertical(haystack, pattern)

参数

haystack — 输入字符串。 String.
pattern — 使用 re2 正则表达式语法的正则表达式。必须包含组，每个组用括号括起来。如果 pattern 不包含组，则会抛出异常。 String.

返回值

匹配项的二维数组。 Array.

注意

如果 haystack 不匹配 pattern 正则表达式，则返回一个空数组。

示例

SELECT extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)');

结果

┌─extractAllGroupsVertical('abc=111, def=222, ghi=333', '("[^"]+"|\\w+)=("[^"]+"|\\w+)')─┐
│ [['abc','111'],['def','222'],['ghi','333']]                                            │
└────────────────────────────────────────────────────────────────────────────────────────┘

like

返回字符串 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（运算符）

notLike

类似于 like，但否定结果。

别名：haystack NOT LIKE pattern（运算符）

ilike

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

别名：haystack ILIKE pattern（运算符）

notILike

类似于 ilike，但否定结果。

别名：haystack NOT ILIKE pattern（运算符）

ngramDistance

计算haystack 字符串和needle 字符串之间的 4-gram 距离。为此，它计算两个 4-gram 多重集之间的对称差集，并通过其基数之和进行归一化。返回一个介于 0 和 1 之间的Float32。结果越小，字符串越相似。

函数 ngramDistanceCaseInsensitive，ngramDistanceUTF8，ngramDistanceCaseInsensitiveUTF8 提供了该函数的不区分大小写和/或 UTF-8 变体。

语法

ngramDistance(haystack, needle)

参数

haystack：第一个比较字符串。字符串文字
needle：第二个比较字符串。字符串文字

返回值

介于 0 和 1 之间的值，表示两个字符串之间的相似度。 Float32

实现细节

如果常量 needle 或 haystack 参数的大小超过 32Kb，则此函数将抛出异常。如果任何非常量 haystack 或 needle 参数的大小超过 32Kb，则距离始终为 1。

示例

两个字符串越相似，结果越接近 0（相同）。

查询

SELECT ngramDistance('ClickHouse','ClickHouse!');

结果

0.06666667

两个字符串越不相似，结果就越大。

查询

SELECT ngramDistance('ClickHouse','House');

结果

0.5555556

ngramDistanceCaseInsensitive

提供 ngramDistance 的不区分大小写变体。

语法

ngramDistanceCaseInsensitive(haystack, needle)

参数

haystack：第一个比较字符串。字符串文字
needle：第二个比较字符串。字符串文字

返回值

介于 0 和 1 之间的值，表示两个字符串之间的相似度。 Float32

示例

使用 ngramDistance 时，大小写差异会影响相似度值

查询

SELECT ngramDistance('ClickHouse','clickhouse');

结果

0.71428573

使用 ngramDistanceCaseInsensitive 时，大小写将被忽略，因此两个仅大小写不同的相同字符串现在将返回一个较低的相似度值

查询

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse');

结果

ngramDistanceUTF8

提供 ngramDistance 的 UTF-8 变体。假设 needle 和 haystack 字符串是 UTF-8 编码的字符串。

语法

ngramDistanceUTF8(haystack, needle)

参数

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

返回值

介于 0 和 1 之间的值，表示两个字符串之间的相似度。 Float32

示例

查询

SELECT ngramDistanceUTF8('abcde','cde');

结果

0.5

ngramDistanceCaseInsensitiveUTF8

提供 ngramDistanceUTF8 的不区分大小写变体。

语法

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

介于 0 和 1 之间的值，表示两个字符串之间的相似度。 Float32

示例

查询

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE');

结果

0.5

ngramSearch

类似于 ngramDistance，但计算needle 字符串和haystack 字符串之间的非对称差集，即 needle 中的 n-gram 数量减去共同的 n-gram 数量，然后除以 needle n-gram 的数量。返回一个介于 0 和 1 之间的Float32。结果越大，needle 在 haystack 中的可能性就越大。此函数可用于模糊字符串搜索。另请参见函数 soundex。

函数 ngramSearchCaseInsensitive，ngramSearchUTF8，ngramSearchCaseInsensitiveUTF8 提供了该函数的不区分大小写和/或 UTF-8 变体。

语法

ngramSearch(haystack, needle)

参数

haystack：第一个比较字符串。字符串文字
needle：第二个比较字符串。字符串文字

返回值

介于 0 和 1 之间的值，表示 needle 在 haystack 中的可能性。 Float32

实现细节

注意

UTF-8 变体使用 3-gram 距离。这些不是完全公平的 n-gram 距离。我们使用 2 字节哈希来哈希 n-gram，然后计算这些哈希表之间的（非）对称差集 - 可能会发生冲突。对于 UTF-8 不区分大小写格式，我们不使用公平的 tolower 函数 - 我们将每个代码点字节的第 5 位（从零开始）以及字节大于 1 时第一个字节的第 0 位清零 - 这适用于拉丁文，并且大部分适用于所有西里尔字母。

示例

查询

SELECT ngramSearch('Hello World','World Hello');

结果

0.5

ngramSearchCaseInsensitive

提供 ngramSearch 的不区分大小写变体。

语法

ngramSearchCaseInsensitive(haystack, needle)

参数

haystack：第一个比较字符串。字符串文字
needle：第二个比较字符串。字符串文字

返回值

介于 0 和 1 之间的值，表示 needle 在 haystack 中的可能性。 Float32

结果越大，needle 在 haystack 中的可能性就越大。

示例

查询

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

结果

ngramSearchUTF8

提供 ngramSearch 的 UTF-8 变体，其中 needle 和 haystack 被认为是 UTF-8 编码的字符串。

语法

ngramSearchUTF8(haystack, needle)

参数

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

返回值

介于 0 和 1 之间的值，表示 needle 在 haystack 中的可能性。 Float32

结果越大，needle 在 haystack 中的可能性就越大。

示例

查询

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

结果

0.5

ngramSearchCaseInsensitiveUTF8

提供 ngramSearchUTF8 的不区分大小写变体，其中 needle 和 haystack。

语法

ngramSearchCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

介于 0 和 1 之间的值，表示 needle 在 haystack 中的可能性。 Float32

结果越大，needle 在 haystack 中的可能性就越大。

示例

查询

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

结果

0.57142854

countSubstrings

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

函数 countSubstringsCaseInsensitive 和 countSubstringsCaseInsensitiveUTF8 分别提供了该函数的不区分大小写和不区分大小写 + UTF-8 变体。

语法

countSubstrings(haystack, needle[, start_pos])

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。字符串.
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

返回子字符串 needle 在字符串 haystack 中出现的次数。忽略大小写。

语法

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

参数

haystack - 执行搜索的字符串。字符串.
needle - 要搜索的子字符串。字符串.
start_pos - haystack 中搜索开始的（从 1 开始的）位置。 UInt。可选。

返回值

出现的次数。 UInt64。

示例

查询

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

结果

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

带有start_pos 参数的示例

查询

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

结果

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

countSubstringsCaseInsensitiveUTF8

返回子字符串 needle 在字符串 haystack 中出现的次数。忽略大小写并假设 haystack 是一个 UTF8 字符串。

语法

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

haystack - 执行搜索的 UTF-8 字符串。字符串.
needle - 要搜索的子字符串。字符串.
start_pos - haystack 中搜索开始的（从 1 开始的）位置。 UInt。可选。

返回值

出现的次数。 UInt64。

示例

查询

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

结果

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

带有start_pos 参数的示例

查询

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

结果

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

countMatches

返回 haystack 中 pattern 的正则表达式匹配次数。

语法

countMatches(haystack, pattern)

参数

haystack — 要搜索的字符串。字符串。
pattern — 使用re2 正则表达式语法的正则表达式。字符串。

返回值

匹配次数。 UInt64。

示例

SELECT countMatches('foobar.com', 'o+');

结果

┌─countMatches('foobar.com', 'o+')─┐
│                                2 │
└──────────────────────────────────┘

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

结果

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

countMatchesCaseInsensitive

返回 haystack 中 pattern 的正则表达式匹配次数，类似于 countMatches，但不区分大小写匹配。

语法

countMatchesCaseInsensitive(haystack, pattern)

参数

haystack — 要搜索的字符串。字符串。
pattern — 使用re2 正则表达式语法的正则表达式。字符串。

返回值

匹配次数。 UInt64。

示例

查询

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

结果

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

regexpExtract

提取 haystack 中与正则表达式模式匹配的第一个字符串，并对应于正则表达式组索引。

语法

regexpExtract(haystack, pattern[, index])

别名：REGEXP_EXTRACT(haystack, pattern[, index])。

参数

haystack — 字符串，将在其中匹配正则表达式模式。字符串。
pattern — 字符串，正则表达式，必须是常量。字符串。
index – 一个大于或等于 0 的整数，默认值为 1。它表示要提取哪个正则表达式组。 UInt 或 Int。可选。

返回值

pattern 可能包含多个正则表达式组，index 指示要提取哪个正则表达式组。索引 0 表示匹配整个正则表达式。字符串。

示例

SELECT
    regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
    regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
    regexpExtract('100-200', '(\\d+)-(\\d+)');

结果

┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┐
│ 100                                          │ 200                                          │ 100-200                                      │ 100                                       │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘

hasSubsequence

如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。字符串的子序列是可以从给定字符串中删除零个或多个元素而不会改变剩余元素的顺序而得到的序列。

语法

hasSubsequence(haystack, needle)

参数

haystack - 执行搜索的字符串。字符串.
needle — 要搜索的子序列。字符串。

返回值

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

示例

查询

SELECT hasSubsequence('garbage', 'arg');

结果

┌─hasSubsequence('garbage', 'arg')─┐
│                                1 │
└──────────────────────────────────┘

hasSubsequenceCaseInsensitive

类似于 hasSubsequence，但不区分大小写搜索。

语法

hasSubsequenceCaseInsensitive(haystack, needle)

参数

haystack - 执行搜索的字符串。字符串.
needle — 要搜索的子序列。字符串。

返回值

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

示例

查询

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

结果

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

hasSubsequenceUTF8

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

语法

hasSubsequenceUTF8(haystack, needle)

参数

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

返回值

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

查询

示例

select hasSubsequenceUTF8('ClickHouse - столбцовая система управления базами данных', 'система');

结果

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

hasSubsequenceCaseInsensitiveUTF8

类似于 hasSubsequenceUTF8，但不区分大小写搜索。

语法

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

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

示例

查询

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

结果

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

hasToken

如果给定的标记存在于 haystack 中，则返回 1，否则返回 0。

语法

hasToken(haystack, token)

参数

haystack: 执行搜索的字符串。字符串。
token: 两个非字母数字 ASCII 字符（或 haystack 的边界）之间的最大长度子字符串。

返回值

如果标记存在于 haystack 中，则为 1，否则为 0。 UInt8。

实现细节

标记必须是常量字符串。由 tokenbf_v1 索引特殊化支持。

示例

查询

SELECT hasToken('Hello World','Hello');

hasTokenOrNull

如果给定标记存在，则返回 1；如果不存在，则返回 0；如果标记格式错误，则返回 null。

语法

hasTokenOrNull(haystack, token)

参数

haystack: 执行搜索的字符串。字符串。
token: 两个非字母数字 ASCII 字符（或 haystack 的边界）之间的最大长度子字符串。

返回值

如果标记在目标字符串中存在，则返回 1；如果不存在，则返回 0；如果标记格式错误，则返回 null。

实现细节

标记必须是常量字符串。由 tokenbf_v1 索引特殊化支持。

示例

对于格式错误的标记，hasToken 会抛出错误，而 hasTokenOrNull 会返回 null。

查询

SELECT hasTokenOrNull('Hello World','Hello,World');

null

hasTokenCaseInsensitive

如果给定标记在目标字符串中存在，则返回 1；否则返回 0。忽略大小写。

语法

hasTokenCaseInsensitive(haystack, token)

参数

haystack: 执行搜索的字符串。字符串。
token: 两个非字母数字 ASCII 字符（或 haystack 的边界）之间的最大长度子字符串。

返回值

如果标记存在于 haystack 中，则为 1，否则为 0。 UInt8。

实现细节

标记必须是常量字符串。由 tokenbf_v1 索引特殊化支持。

示例

查询

SELECT hasTokenCaseInsensitive('Hello World','hello');

hasTokenCaseInsensitiveOrNull

如果给定标记在目标字符串中存在，则返回 1；否则返回 0。忽略大小写，如果标记格式错误，则返回 null。

语法

hasTokenCaseInsensitiveOrNull(haystack, token)

参数

haystack: 执行搜索的字符串。字符串。
token: 两个非字母数字 ASCII 字符（或 haystack 的边界）之间的最大长度子字符串。

返回值

如果标记在目标字符串中存在，则返回 1；如果不存在，则返回 0；否则如果标记格式错误，则返回 null。 UInt8.

实现细节

标记必须是常量字符串。由 tokenbf_v1 索引特殊化支持。

示例

对于格式错误的标记，hasTokenCaseInsensitive 会抛出错误，而 hasTokenCaseInsensitiveOrNull 会返回 null。

查询

SELECT hasTokenCaseInsensitiveOrNull('Hello World','hello,world');

null

字符串搜索函数

position​

locate​

positionCaseInsensitive​

positionUTF8​

positionCaseInsensitiveUTF8​

multiSearchAllPositions​

multiSearchAllPositionsCaseInsensitive​

multiSearchAllPositionsUTF8​

multiSearchAllPositionsCaseInsensitiveUTF8​

multiSearchFirstPosition​

multiSearchFirstPositionCaseInsensitive​

multiSearchFirstPositionUTF8​

multiSearchFirstPositionCaseInsensitiveUTF8​

multiSearchFirstIndex​

multiSearchFirstIndexCaseInsensitive​

multiSearchFirstIndexUTF8​

multiSearchFirstIndexCaseInsensitiveUTF8​

multiSearchAny​

multiSearchAnyCaseInsensitive​

multiSearchAnyUTF8​

multiSearchAnyCaseInsensitiveUTF8​

match​

multiMatchAny​

multiMatchAnyIndex​

multiMatchAllIndices​

multiFuzzyMatchAny​

multiFuzzyMatchAnyIndex​

multiFuzzyMatchAllIndices​

extract​

extractAll​

extractAllGroupsHorizontal​

extractGroups​

extractAllGroupsVertical​

like​

notLike​

ilike​

notILike​

ngramDistance​

ngramDistanceCaseInsensitive​

ngramDistanceUTF8​

ngramDistanceCaseInsensitiveUTF8​

ngramSearch​

ngramSearchCaseInsensitive​

ngramSearchUTF8​

ngramSearchCaseInsensitiveUTF8​

countSubstrings​

countSubstringsCaseInsensitive​

countSubstringsCaseInsensitiveUTF8​

countMatches​

countMatchesCaseInsensitive​

regexpExtract​

hasSubsequence​

hasSubsequenceCaseInsensitive​

hasSubsequenceUTF8​

hasSubsequenceCaseInsensitiveUTF8​

hasToken​

hasTokenOrNull​

hasTokenCaseInsensitive​

hasTokenCaseInsensitiveOrNull​

position

locate

positionCaseInsensitive

positionUTF8

positionCaseInsensitiveUTF8

multiSearchAllPositions

multiSearchAllPositionsCaseInsensitive

multiSearchAllPositionsUTF8

multiSearchAllPositionsCaseInsensitiveUTF8

multiSearchFirstPosition

multiSearchFirstPositionCaseInsensitive

multiSearchFirstPositionUTF8

multiSearchFirstPositionCaseInsensitiveUTF8

multiSearchFirstIndex

multiSearchFirstIndexCaseInsensitive

multiSearchFirstIndexUTF8

multiSearchFirstIndexCaseInsensitiveUTF8

multiSearchAny

multiSearchAnyCaseInsensitive

multiSearchAnyUTF8

multiSearchAnyCaseInsensitiveUTF8

match

multiMatchAny

multiMatchAnyIndex

multiMatchAllIndices

multiFuzzyMatchAny

multiFuzzyMatchAnyIndex

multiFuzzyMatchAllIndices

extract

extractAll

extractAllGroupsHorizontal

extractGroups

extractAllGroupsVertical

like

notLike

ilike

notILike

ngramDistance

ngramDistanceCaseInsensitive

ngramDistanceUTF8

ngramDistanceCaseInsensitiveUTF8

ngramSearch

ngramSearchCaseInsensitive

ngramSearchUTF8

ngramSearchCaseInsensitiveUTF8

countSubstrings

countSubstringsCaseInsensitive

countSubstringsCaseInsensitiveUTF8

countMatches

countMatchesCaseInsensitive

regexpExtract

hasSubsequence

hasSubsequenceCaseInsensitive

hasSubsequenceUTF8

hasSubsequenceCaseInsensitiveUTF8

hasToken

hasTokenOrNull

hasTokenCaseInsensitive

hasTokenCaseInsensitiveOrNull