字符串搜索函数
默认情况下，本节中的所有函数都区分大小写地搜索。不区分大小写的搜索通常由单独的函数变体提供。
不区分大小写的搜索遵循英语的大小写规则。例如，英语中大写的 i 是 I，而在土耳其语中是 İ - 对于英语以外的语言，结果可能出乎意料。
本节中的函数还假定被搜索的字符串（在本节中称为 haystack）和搜索字符串（在本节中称为 needle）是单字节编码的文本。如果此假设被违反，则不会抛出异常，并且结果是未定义的。UTF-8 编码字符串的搜索通常由单独的函数变体提供。同样，如果使用 UTF-8 函数变体，但输入字符串不是 UTF-8 编码的文本，则不会抛出异常，并且结果是未定义的。请注意，不执行自动 Unicode 规范化，但是您可以使用 normalizeUTF8*() 函数来实现。
通用字符串函数 和 用于替换字符串的函数 将单独描述。
position
返回子字符串 needle 在字符串 haystack 中的位置（以字节为单位，从 1 开始）。
语法
position(haystack, needle[, start_pos])
别名
position(needle IN haystack)
参数
haystack— 执行搜索的字符串。 String 或 Enum。needle— 要搜索的子字符串。 String。start_pos– 在haystack中开始搜索的位置（从 1 开始）。 UInt。 可选。
返回值
如果子字符串 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*() 函数仅支持最多 28 个 needle。
语法
multiSearchAllPositions(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果找到子字符串，则返回起始位置数组（以字节为单位，从 1 开始计数）。
- 如果未找到子字符串，则返回 0。
示例
查询
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world']);
结果
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0] │
└───────────────────────────────────────────────────────────────────┘
multiSearchAllPositionsCaseInsensitive
类似于 multiSearchAllPositions，但不区分大小写。
语法
multiSearchAllPositionsCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果找到子字符串，则返回起始位置数组（以字节为单位，从 1 开始计数）。
- 如果未找到子字符串，则返回 0。
示例
查询
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h']);
结果
["1","6"]
multiSearchAllPositionsUTF8
类似于 multiSearchAllPositions，但假定 haystack 和 needle 子字符串是 UTF-8 编码的字符串。
语法
multiSearchAllPositionsUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果找到子字符串，则返回起始位置数组（以字节为单位，从 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])
参数
返回值
- 如果找到子字符串，则返回起始位置数组（以字节为单位，从 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字符串中的任何一个匹配。- 如果没有匹配项，则返回 0。
示例
查询
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld']);
结果
3
multiSearchFirstPositionCaseInsensitive
类似于 multiSearchFirstPosition，但不区分大小写。
语法
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
返回值
haystack字符串中最左侧的偏移量，该偏移量与多个needle字符串中的任何一个匹配。- 如果没有匹配项，则返回 0。
示例
查询
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello']);
结果
2
multiSearchFirstPositionUTF8
类似于 multiSearchFirstPosition，但假定 haystack 和 needle 是 UTF-8 字符串。
语法
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
haystack字符串中最左侧的偏移量，该偏移量与多个needle字符串中的任何一个匹配。- 如果没有匹配项，则返回 0。
示例
在 UTF-8 字符串 hello world 中查找与任何给定 needle 匹配的最左侧偏移量。
查询
SELECT multiSearchFirstPositionUTF8('\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64',['wor', 'ld', 'ello']);
结果
2
multiSearchFirstPositionCaseInsensitiveUTF8
类似于 multiSearchFirstPosition，但假定 haystack 和 needle 是 UTF-8 字符串，并且不区分大小写。
语法
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
haystack字符串中最左侧的偏移量，该偏移量与多个needle字符串中的任何一个匹配，忽略大小写。- 如果没有匹配项，则返回 0。
示例
在 UTF-8 字符串 HELLO WORLD 中查找与任何给定 needle 匹配的最左侧偏移量。
查询
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('\x48\x45\x4c\x4c\x4f\x20\x57\x4f\x52\x4c\x44',['wor', 'ld', 'ello']);
结果
2
multiSearchFirstIndex
返回在字符串 haystack 中找到的最左侧 needlei 的索引 i（从 1 开始），否则返回 0。
函数 multiSearchFirstIndexCaseInsensitive、multiSearchFirstIndexUTF8 和 multiSearchFirstIndexCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。
语法
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 找到的最左侧 needle 的索引（从 1 开始）。如果没有匹配项，则返回 0。 UInt8。
示例
查询
SELECT multiSearchFirstIndex('Hello World',['World','Hello']);
结果
1
multiSearchFirstIndexCaseInsensitive
返回在字符串 haystack 中找到的最左侧 needlei 的索引 i（从 1 开始），否则返回 0。忽略大小写。
语法
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 找到的最左侧 needle 的索引（从 1 开始）。如果没有匹配项，则返回 0。 UInt8。
示例
查询
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD',['World','Hello']);
结果
1
multiSearchFirstIndexUTF8
返回在字符串 haystack 中找到的最左侧 needlei 的索引 i（从 1 开始），否则返回 0。假定 haystack 和 needle 是 UTF-8 编码的字符串。
语法
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 找到的最左侧 needle 的索引（从 1 开始）。如果没有匹配项，则返回 0。 UInt8。
示例
给定 Hello World 作为 UTF-8 字符串，查找 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']);
结果
1
multiSearchFirstIndexCaseInsensitiveUTF8
返回在字符串 haystack 中找到的最左侧 needlei 的索引 i（从 1 开始），否则返回 0。假定 haystack 和 needle 是 UTF-8 编码的字符串。忽略大小写。
语法
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 找到的最左侧 needle 的索引（从 1 开始）。如果没有匹配项，则返回 0。 UInt8。
示例
给定 HELLO WORLD 作为 UTF-8 字符串，查找 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']);
结果
1
multiSearchAny
如果至少一个字符串 needlei 与字符串 haystack 匹配，则返回 1，否则返回 0。
函数 multiSearchAnyCaseInsensitive、multiSearchAnyUTF8 和 multiSearchAnyCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。
语法
multiSearchAny(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果至少有一个匹配项，则返回 1。
- 如果没有至少一个匹配项，则返回 0。
示例
查询
SELECT multiSearchAny('ClickHouse',['C','H']);
结果
1
multiSearchAnyCaseInsensitive
类似于 multiSearchAny，但不区分大小写。
语法
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果至少有一个不区分大小写的匹配项，则返回 1。
- 如果没有至少一个不区分大小写的匹配项，则返回 0。
示例
查询
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h']);
结果
1
multiSearchAnyUTF8
类似于 multiSearchAny，但假定 haystack 和 needle 子字符串是 UTF-8 编码的字符串。
语法*
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果至少有一个匹配项，则返回 1。
- 如果没有至少一个匹配项，则返回 0。
示例
给定 ClickHouse 作为 UTF-8 字符串，检查单词中是否有任何 C ('\x43') 或 H ('\x48') 字母。
查询
SELECT multiSearchAnyUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x43','\x48']);
结果
1
multiSearchAnyCaseInsensitiveUTF8
类似于 multiSearchAnyUTF8，但不区分大小写。
语法*
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
返回值
- 如果至少有一个不区分大小写的匹配项，则返回 1。
- 如果没有至少一个不区分大小写的匹配项，则返回 0。
示例
给定 ClickHouse 作为 UTF-8 字符串，检查单词中是否包含字母 h(\x68)，忽略大小写。
查询
SELECT multiSearchAnyCaseInsensitiveUTF8('\x43\x6c\x69\x63\x6b\x48\x6f\x75\x73\x65',['\x68']);
结果
1
match
返回字符串 haystack 是否与 re2 正则表达式语法 中的正则表达式 pattern 匹配。
匹配基于 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 字符串的长度必须小于 232 字节。
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 库的实验性功能，并且在某些极端情况下可能会很慢。性能取决于编辑距离值和使用的模式，但始终比非模糊变体更昂贵。
由于 hyperscan 的限制，multiFuzzyMatch*() 函数系列不支持 UTF-8 正则表达式（它将它们视为字节序列）。
语法
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 正则表达式语法 的正则表达式。
返回值
示例
查询
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)
参数
返回值
- 介于 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)
参数
返回值
- 介于 0 和 1 之间的值，表示两个字符串之间的相似度。Float32
示例
使用 ngramDistance 时，大小写差异会影响相似度值
查询
SELECT ngramDistance('ClickHouse','clickhouse');
结果
0.71428573
使用 ngramDistanceCaseInsensitive 时，大小写将被忽略，因此仅大小写不同的两个相同字符串现在将返回较低的相似度值
查询
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse');
结果
0
ngramDistanceUTF8
提供 ngramDistance 的 UTF-8 变体。假定 needle 和 haystack 字符串是 UTF-8 编码的字符串。
语法
ngramDistanceUTF8(haystack, needle)
参数
返回值
- 介于 0 和 1 之间的值，表示两个字符串之间的相似度。Float32
示例
查询
SELECT ngramDistanceUTF8('abcde','cde');
结果
0.5
ngramDistanceCaseInsensitiveUTF8
提供 ngramDistanceUTF8 的不区分大小写变体。
语法
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
参数
返回值
- 介于 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)
参数
返回值
- 介于 0 和 1 之间的值，表示
needle在haystack中出现的可能性。Float32
实现细节
UTF-8 变体使用 3-gram 距离。这些不是完全公平的 n-gram 距离。我们使用 2 字节哈希来哈希 n-gram，然后计算这些哈希表之间的（非）对称差 - 可能会发生冲突。对于 UTF-8 不区分大小写的格式，我们不使用公平的 tolower 函数 - 我们将每个代码点字节的第 5 位（从零开始）和第一个字节的第 0 位（如果字节超过一个）置零 - 这适用于拉丁字母，并且主要适用于所有西里尔字母。
示例
查询
SELECT ngramSearch('Hello World','World Hello');
结果
0.5
ngramSearchCaseInsensitive
提供 ngramSearch 的不区分大小写变体。
语法
ngramSearchCaseInsensitive(haystack, needle)
参数
返回值
- 介于 0 和 1 之间的值，表示
needle在haystack中出现的可能性。Float32
结果越大，needle 在 haystack 中出现的可能性就越高。
示例
查询
SELECT ngramSearchCaseInsensitive('Hello World','hello');
结果
1
ngramSearchUTF8
提供 ngramSearch 的 UTF-8 变体，其中假定 needle 和 haystack 是 UTF-8 编码的字符串。
语法
ngramSearchUTF8(haystack, needle)
参数
返回值
- 介于 0 和 1 之间的值，表示
needle在haystack中出现的可能性。Float32
结果越大，needle 在 haystack 中出现的可能性就越高。
示例
查询
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд');
结果
0.5
ngramSearchCaseInsensitiveUTF8
提供 ngramSearchUTF8 的不区分大小写变体，其中 needle 和 haystack。
语法
ngramSearchCaseInsensitiveUTF8(haystack, needle)
参数
返回值
- 介于 0 和 1 之间的值，表示
needle在haystack中出现的可能性。Float32
结果越大，needle 在 haystack 中出现的可能性就越高。
示例
查询
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз');
结果
0.57142854
countSubstrings
返回子字符串 needle 在字符串 haystack 中出现的频率。
函数 countSubstringsCaseInsensitive 和 countSubstringsCaseInsensitiveUTF8 分别提供了此函数的不区分大小写和不区分大小写 + UTF-8 变体。
语法
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
返回子字符串 needle 在字符串 haystack 中出现的频率。忽略大小写。
语法
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
参数
haystack— 在其中执行搜索的字符串。String 或 Enum。needle— 要搜索的子字符串。 String。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 字符串。String 或 Enum。needle— 要搜索的子字符串。 String。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— 要搜索的字符串。String。pattern— 具有 re2 正则表达式语法 的正则表达式。String。
返回值
- 匹配数。UInt64。
示例
SELECT countMatches('foobar.com', 'o+');
结果
┌─countMatches('foobar.com', 'o+')─┐
│ 2 │
└──────────────────────────────────┘
SELECT countMatches('aaaa', 'aa');
结果
┌─countMatches('aaaa', 'aa')────┐
│ 2 │
└───────────────────────────────┘
countMatchesCaseInsensitive
返回像 countMatches 一样，在 haystack 中模式的正则表达式匹配数，但匹配忽略大小写。
语法
countMatchesCaseInsensitive(haystack, pattern)
参数
haystack— 要搜索的字符串。String。pattern— 具有 re2 正则表达式语法 的正则表达式。String。
返回值
- 匹配数。UInt64。
示例
查询
SELECT countMatchesCaseInsensitive('AAAA', 'aa');
结果
┌─countMatchesCaseInsensitive('AAAA', 'aa')────┐
│ 2 │
└──────────────────────────────────────────────┘
regexpExtract
提取 haystack 中与正则表达式模式匹配并对应于正则表达式组索引的第一个字符串。
语法
regexpExtract(haystack, pattern[, index])
别名：REGEXP_EXTRACT(haystack, pattern[, index])。
参数
haystack— 字符串，将在其中匹配正则表达式模式。String。pattern— 字符串，正则表达式，必须是常量。String。index– 大于或等于 0 的整数，默认值为 1。它表示要提取哪个正则表达式组。UInt 或 Int。可选。
返回值
pattern 可能包含多个正则表达式组，index 指示要提取哪个正则表达式组。索引 0 表示匹配整个正则表达式。String。
示例
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)
参数
返回值
- 1，如果 needle 是 haystack 的子序列，否则为 0。UInt8。
示例
查询
SELECT hasSubsequence('garbage', 'arg');
结果
┌─hasSubsequence('garbage', 'arg')─┐
│ 1 │
└──────────────────────────────────┘
hasSubsequenceCaseInsensitive
类似于 hasSubsequence，但搜索不区分大小写。
语法
hasSubsequenceCaseInsensitive(haystack, needle)
参数
返回值
- 1，如果 needle 是 haystack 的子序列，否则为 0。UInt8。
示例
查询
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
结果
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│ 1 │
└─────────────────────────────────────────────────┘
hasSubsequenceUTF8
类似于 hasSubsequence，但假定 haystack 和 needle 是 UTF-8 编码的字符串。
语法
hasSubsequenceUTF8(haystack, needle)
参数
返回值
- 1，如果 needle 是 haystack 的子序列，否则为 0。UInt8。
查询
示例
select hasSubsequenceUTF8('ClickHouse - столбцовая система управления базами данных', 'система');
结果
┌─hasSubsequenceUTF8('ClickHouse - столбцовая система управления базами данных', 'система')─┐
│ 1 │
└───────────────────────────────────────────────────────────────────────────────────────────┘
hasSubsequenceCaseInsensitiveUTF8
类似于 hasSubsequenceUTF8，但搜索不区分大小写。
语法
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
参数
返回值
- 1，如果 needle 是 haystack 的子序列，否则为 0。UInt8。
示例
查询
select hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
结果
┌─hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА')─┐
│ 1 │
└──────────────────────────────────────────────────────────────────────────────────────────────────────────┘
hasToken
如果给定的 token 存在于 haystack 中，则返回 1，否则返回 0。
语法
hasToken(haystack, token)
参数
返回值
- 1，如果 token 存在于 haystack 中，否则为 0。UInt8。
实现细节
Token 必须是常量字符串。tokenbf_v1 索引 specialization 支持。
示例
查询
SELECT hasToken('Hello World','Hello');
1
hasTokenOrNull
如果给定的 token 存在，则返回 1；如果不存在，则返回 0；如果 token 格式不正确，则返回 null。
语法
hasTokenOrNull(haystack, token)
参数
返回值
- 1，如果 token 存在于 haystack 中；如果不存在，则为 0；如果 token 格式不正确，则为 null。
实现细节
Token 必须是常量字符串。tokenbf_v1 索引 specialization 支持。
示例
如果 hasToken 会为格式不正确的 token 抛出错误，则 hasTokenOrNull 会为格式不正确的 token 返回 null。
查询
SELECT hasTokenOrNull('Hello World','Hello,World');
null
hasTokenCaseInsensitive
如果给定的 token 存在于 haystack 中，则返回 1，否则返回 0。忽略大小写。
语法
hasTokenCaseInsensitive(haystack, token)
参数
返回值
- 1，如果 token 存在于 haystack 中，否则为 0。UInt8。
实现细节
Token 必须是常量字符串。tokenbf_v1 索引 specialization 支持。
示例
查询
SELECT hasTokenCaseInsensitive('Hello World','hello');
1
hasTokenCaseInsensitiveOrNull
如果给定的 token 存在于 haystack 中，则返回 1，否则返回 0。忽略大小写，如果 token 格式不正确，则返回 null。
语法
hasTokenCaseInsensitiveOrNull(haystack, token)
参数
返回值
实现细节
Token 必须是常量字符串。tokenbf_v1 索引 specialization 支持。
示例
如果 hasTokenCaseInsensitive 会为格式不正确的 token 抛出错误，则 hasTokenCaseInsensitiveOrNull 会为格式不正确的 token 返回 null。
查询
SELECT hasTokenCaseInsensitiveOrNull('Hello World','hello,world');
null