跳转到主要内容
本节中的所有函数默认都执行区分大小写的搜索。不区分大小写的搜索通常由单独的函数变体提供。
不区分大小写的搜索遵循英语的大小写转换规则。例如，英语中的小写 i 的大写形式是 I，而土耳其语中则是 İ——对于英语以外的语言，结果可能不符合预期。
本节中的函数还假定被搜索的字符串 (本节中称为 haystack) 和搜索字符串 (本节中称为 needle) 都是单字节编码文本。如果这一假设 不成立，不会抛出异常，结果未定义。对 UTF-8 编码字符串的搜索通常由单独的函数 变体提供。同样，如果使用 UTF-8 函数变体，而输入字符串并非 UTF-8 编码文本，也不会抛出异常，且 结果未定义。请注意，不会自动执行 Unicode 规范化，不过你可以使用 normalizeUTF8*() 函数来实现这一点。 通用字符串函数 和 字符串替换函数 将单独介绍。
以下文档由 system.functions 系统表生成。

​
countMatches

引入版本：v21.1.0 返回字符串中正则表达式的匹配次数。
与版本相关的行为此函数的行为取决于 ClickHouse 版本：
  • 在 < v25.6 的版本中，即使模式能够匹配空字符串，函数也会在第一次空匹配时停止计数。
  • 在 >= 25.6 的版本中，发生空匹配时，函数会继续执行。可使用设置 count_matches_stop_at_empty_match = true 恢复旧版行为；
语法 
countMatches(haystack, pattern)
参数
  • haystack — 要搜索的字符串。String
  • pattern — 正则表达式模式。String
返回值 返回找到的匹配项数量。UInt64 示例 统计数字串的数量
Query
SELECT countMatches('hello 123 world 456 test', '[0-9]+')
Response
┌─countMatches('hello 123 world 456 test', '[0-9]+')─┐
│                                                   2 │
└─────────────────────────────────────────────────────┘

​
countMatchesCaseInsensitive

引入版本：v21.1.0 与 countMatches 类似，但执行不区分大小写的匹配。 语法 
countMatchesCaseInsensitive(haystack, pattern)
参数
  • haystack — 要在其中搜索的字符串。String
  • pattern — 正则表达式模式。const String
返回值 返回找到的匹配次数。UInt64 示例 不区分大小写的计数
Query
SELECT countMatchesCaseInsensitive('Hello HELLO world', 'hello')
Response
┌─countMatchesCaseInsensitive('Hello HELLO world', 'hello')─┐
│                                                         2 │
└───────────────────────────────────────────────────────────┘

​
countSubstrings

引入版本：v21.1.0 返回子串 needle 在字符串 haystack 中出现的频次。 语法 
countSubstrings(haystack, needle[, start_pos])
参数
  • haystack — 要在其中执行搜索的 String。String 或 枚举。 - needle — 要搜索的子串。String。 - start_pos — 在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt。可选。
返回值 出现的次数。UInt64 示例 使用示例
Query
SELECT countSubstrings('aaaa', 'aa');
Response
┌─countSubstrings('aaaa', 'aa')─┐
│                             2 │
└───────────────────────────────┘
使用 start_pos 参数
Query
SELECT countSubstrings('abc___abc', 'abc', 4);
Response
┌─countSubstrings('abc___abc', 'abc', 4)─┐
│                                      1 │
└────────────────────────────────────────┘

​
countSubstringsCaseInsensitive

引入版本：v21.1.0 与 countSubstrings 类似，但按不区分大小写的方式计数。 语法 
countSubstringsCaseInsensitive(haystack, needle[, start_pos])
参数
  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*
返回值 返回 needle 在 haystack 中出现的次数。UInt64 示例 使用示例
Query
SELECT countSubstringsCaseInsensitive('AAAA', 'aa');
Response
┌─countSubstri⋯AAA', 'aa')─┐
│                        2 │
└──────────────────────────┘
使用 start_pos 参数
Query
SELECT countSubstringsCaseInsensitive('abc___ABC___abc', 'abc', 4);
Response
┌─countSubstri⋯, 'abc', 4)─┐
│                        2 │
└──────────────────────────┘

​
countSubstringsCaseInsensitiveUTF8

Introduced in: v21.1.0 与 countSubstrings 类似，但以不区分大小写的方式进行计数，并假定 haystack 为 UTF-8 字符串。 Syntax 
countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])
参数
  • haystack — 执行搜索的 UTF-8 字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始) 。UInt*
返回值 返回 needle 在 haystack 中出现的次数。UInt64 示例 使用示例
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА');
Response
┌─countSubstri⋯шка', 'КА')─┐
│                        4 │
└──────────────────────────┘
使用 start_pos 参数
Query
SELECT countSubstringsCaseInsensitiveUTF8('ложка, кошка, картошка', 'КА', 13);
Response
┌─countSubstri⋯, 'КА', 13)─┐
│                        2 │
└──────────────────────────┘

​
extract

Introduced in：v1.1.0 提取字符串中第一个匹配正则表达式的内容。 如果 ‘haystack’ 与 ‘pattern’ 不匹配，则返回空字符串。 此函数使用 RE2 regular expression 库。支持的语法请参阅 re2。 如果正则表达式包含 capturing group (子模式) ，则函数会返回输入字符串中与第一个 capturing group 匹配的内容。 Syntax 
extract(haystack, pattern)
参数
  • haystack — 要从中提取内容的 String。String
  • pattern — 正则表达式，通常包含一个捕获组。const String
返回值 返回提取出的字符串片段。String 示例 从电子邮件地址中提取域名
Query
SELECT extract('test@clickhouse.com', '.*@(.*)$')
Response
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                            │
└───────────────────────────────────────────┘
未匹配时返回空字符串
Query
SELECT extract('test@clickhouse.com', 'no_match')
Response
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

​
extractAll

引入于：v1.1.0 与 extract 类似，但返回字符串中匹配正则表达式的所有结果组成的数组。 如果 ‘haystack’ 不匹配 ‘pattern’ 正则表达式，则返回空数组。 如果正则表达式包含捕获组 (子模式) ，则该函数会针对第一个捕获组匹配输入字符串。 语法 
extractAll(haystack, pattern)
参数
  • haystack — 要从中提取片段的 String。String
  • pattern — 正则表达式，可包含捕获组。const String
返回值 返回提取出的片段数组。Array(String) 示例 提取所有数字
Query
SELECT extractAll('hello 123 world 456', '[0-9]+')
Response
┌─extractAll('hello 123 world 456', '[0-9]+')─┐
│ ['123','456']                               │
└─────────────────────────────────────────────┘
使用捕获组提取
Query
SELECT extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
Response
┌─extractAll('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')─┐
│ ['test','user']                                                    │
└────────────────────────────────────────────────────────────────────┘

​
extractAllGroupsHorizontal

引入版本：v20.5.0 使用提供的正则表达式匹配字符串中的所有组，并返回一个嵌套数组，其中每个数组包含同一捕获组的所有捕获结果，按组号排列。 语法 
extractAllGroupsHorizontal(s, regexp)
参数 返回值 返回一个嵌套数组，其中每个内部数组都包含某个捕获组在所有匹配结果中的全部捕获内容。第一个内部数组包含第 1 组的所有捕获，第二个包含第 2 组的所有捕获，依此类推。如果未找到匹配项，则返回空数组。Array(Array(String)) 示例 用法示例
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['Server','Date','Content-Type','Connection'],['nginx','Tue, 22 Jan 2019 00:26:14 GMT','text/html; charset=UTF-8','keep-alive']]

​
extractGroups

Introduced in: v20.5.0 从正则表达式匹配到的第一个子串中提取捕获组。要从所有匹配结果中提取捕获组，请使用 extractAllGroupsHorizontal 或 extractAllGroupsVertical。 Syntax 
extractGroups(s, regexp)
参数 返回值 如果正则表达式匹配，则返回一个数组，包含首次匹配中捕获的各组 (1 到 N，其中 N 为 regexp 中捕获组的数量) 。如果没有匹配，则返回空数组。Array(String) 示例 使用示例
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
['Server','nginx']

​
hasAllTokens

引入版本：v25.10.0 与 hasAnyTokens 类似，但仅当 needle 字符串或数组中的所有标记都与 input 字符串匹配时返回 1，否则返回 0。如果 input 是一列，则返回满足此条件的所有行。
为获得最佳性能，列 input 应定义一个文本索引。 如果未定义文本索引，该函数会对该列执行穷举列扫描，其速度比索引查找慢几个数量级。
在搜索之前，该函数会对文本进行标记化处理
  • input 参数 (始终如此) 以及
  • needle 参数 (如果为 String) 会使用为文本索引指定的分词器进行处理。 如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。 如果 needle 参数的类型为 Array(String)，则数组中的每个元素都会被视为一个标记——不会再进行额外的分词。
重复的标记将被忽略。 例如，needles = [‘ClickHouse’, ‘ClickHouse’] 与 [‘ClickHouse’] 等效。
当文本索引定义了一个预处理器 (例如 lowerUTF8) 时，hasAllTokens 会将其应用于 input；如果 needles 是 String，则也会在标记化之前将其应用于 needles。当 needles 是 Array(String) 时，其元素会按原样传递，不会对其应用预处理器。 预处理器仅在文本索引路径上生效，因此，使用文本索引的查询与不使用文本索引的查询，结果可能会有所不同 (例如 SETTINGS use_skip_indexes = 0) 。 为提高全文检索的易用性，这种不一致是可以接受的。
语法 
hasAllTokens(input, needles)
别名: hasAllToken 参数 返回值 如果所有 needle 都匹配，则返回 1；否则返回 0。UInt8 示例 使用字符串 needle 的基本用法
Query
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()');
Response
┌─count()─┐
│       1 │
└─────────┘
指定要在数组中按原样搜索的 needle (不进行标记化)
Query
SELECT count() FROM table WHERE hasAllTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       1 │
└─────────┘
使用 tokens 函数生成 needle
Query
SELECT count() FROM table WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       1 │
└─────────┘
通过第三个参数使用自定义分词器
Query
SELECT hasAllTokens('abcdef', 'abc', 'ngrams(3)');
Response
┌─hasAllTokens('abcdef', 'abc', 'ngrams(3)')─┐
│                                            1 │
└──────────────────────────────────────────────┘
Array 和 Map 列的使用示例
Query
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'});
Response
数组列示例
Query
SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
mapKeys 示例
Query
SELECT count() FROM log WHERE hasAllTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       1 │
└─────────┘
使用 mapValues 的示例
Query
SELECT count() FROM log WHERE hasAllTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       0 │
└─────────┘

​
hasAnyTokens

引入版本：v25.10.0 如果 needle 字符串或数组中至少有一个标记与 input 字符串匹配，则返回 1，否则返回 0。如果 input 是一列，则返回满足此条件的所有行。
列 input 应定义 文本索引，以获得最佳性能。 如果未定义文本索引，该函数会对列执行穷举列扫描，其速度比索引查找慢几个数量级。
在搜索之前，该函数会对文本进行标记化处理
  • input 参数 (始终如此) ，以及
  • needle 参数 (如果其类型为 String) 会使用为文本索引指定的分词器进行分词。 如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。 如果 needle 参数的类型为 Array(String)，则会将数组中的每个元素视为一个标记——不会再进行额外分词。
重复的标记将被忽略。 例如，[‘ClickHouse’, ‘ClickHouse’] 与 [‘ClickHouse’] 的处理方式相同。
当文本索引定义了预处理器 (例如 lowerUTF8) 时，hasAnyTokens 会在分词前将其应用于 input；当 needles 为 String 时，也会将其应用于 needles。当 needles 为 Array(String) 时，其元素会按原样传递，不会对其应用预处理器。 预处理器仅在文本索引路径上应用，因此，使用文本索引的查询与不使用文本索引的查询之间的结果可能不同 (例如 SETTINGS use_skip_indexes = 0) 。 为了提高全文检索的易用性，可以容忍这种不一致性。
语法 
hasAnyTokens(input, needles)
别名: hasAnyToken 参数 返回值 如果至少有一个匹配项，则返回 1，否则返回 0。UInt8 示例 使用字符串 needle 的基本示例
Query
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()');
Response
┌─count()─┐
│       3 │
└─────────┘
指定要在数组中按原样搜索的 needle (不进行标记化)
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, ['a', 'd']);
Response
┌─count()─┐
│       3 │
└─────────┘
使用 tokens 函数生成 needle
Query
SELECT count() FROM table WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
Response
┌─count()─┐
│       3 │
└─────────┘
数组和 map 列的使用示例
Query
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'});
Response
数组列示例
Query
SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');
Response
┌─count()─┐
│       1 │
└─────────┘
使用 mapKeys 的示例
Query
SELECT count() FROM log WHERE hasAnyTokens(mapKeys(attributes), ['address', 'log_level']);
Response
┌─count()─┐
│       2 │
└─────────┘
使用 mapValues 的示例
Query
SELECT count() FROM log WHERE hasAnyTokens(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
Response
┌─count()─┐
│       2 │
└─────────┘

​
hasPhrase

引入版本：v26.4.0 检查 input 是否按连续顺序包含 phrase 中的所有标记。
为获得最佳性能，列 input 应定义 文本索引。 如果未定义 文本索引，该函数会执行穷举列扫描，其速度比索引查找慢几个数量级。
搜索前，该函数会使用为 文本索引 指定的分词器，对 input 和 phrase 参数进行分词。 如果该列未定义 文本索引，则改用 splitByNonAlpha 分词器——除非通过可选的第三个参数提供了分词器。 tokenizer 参数必须是 splitByNonAlpha、splitByString、ngrams 或 asciiCJK 之一。
当 文本索引 定义了 预处理器 (例如 lowerUTF8) 时，hasPhrase 会在分词前将其应用于 input 和 phrase。 预处理器 仅在 文本索引 路径上生效，因此，使用 文本索引 的查询与不使用 文本索引 的查询，结果可能不同 (例如 SETTINGS use_skip_indexes = 0) 。 为了提高 全文检索 的易用性，可以容忍这种不一致。
与 hasToken、hasAnyTokens 和 hasAllTokens 不同，hasPhrase 要求这些标记按相同顺序连续出现， 中间不能有任何其他标记。例如，hasPhrase('the quick brown fox', 'quick fox') 返回 0， 因为 “brown” 出现在 “quick” 和 “fox” 之间。 语法 
hasPhrase(input, phrase[, tokenizer])
别名：matchPhrase 参数 返回值 如果找到该短语对应的连续标记序列，则返回 1；否则返回 0。UInt8 示例 短语匹配
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                      1 │
└────────────────────────────────────────────────────────┘
不连续标记
Query
SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
Response
┌─hasPhrase('the quick brown fox jumps', 'quick fox')─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
hasSubsequence

Introduced in: v23.7.0 检查 needle 是否是 haystack 的子序列。 字符串的子序列，是指在不改变其余字符顺序的前提下，通过删除另一个字符串中的部分字符或不删除任何字符得到的序列。 Syntax 
hasSubsequence(haystack, needle)
参数
  • haystack — 在其中搜索子序列的 String。String
  • needle — 要搜索的子序列。String
返回值 如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8 示例 基本的子序列检查
Query
SELECT hasSubsequence('Hello World', 'HlWrd')
Response
┌─hasSubsequence('Hello World', 'HlWrd')─┐
│                                      1 │
└────────────────────────────────────────┘
未找到子序列
Query
SELECT hasSubsequence('Hello World', 'xyz')
Response
┌─hasSubsequence('Hello World', 'xyz')─┐
│                                    0 │
└──────────────────────────────────────┘

​
hasSubsequenceCaseInsensitive

引入版本：v23.7.0 与 hasSubsequence 类似，但搜索时不区分大小写。 语法 
hasSubsequenceCaseInsensitive(haystack, needle)
参数
  • haystack — 在其中执行搜索的 String。String
  • needle — 要搜索的子序列。String
返回值 如果 needle 是 haystack 的子序列，则返回 1，否则返回 0。UInt8 示例 使用示例
Query
SELECT hasSubsequenceCaseInsensitive('garbage', 'ARG');
Response
┌─hasSubsequenceCaseInsensitive('garbage', 'ARG')─┐
│                                               1 │
└─────────────────────────────────────────────────┘

​
hasSubsequenceCaseInsensitiveUTF8

引入版本：v23.7.0 与 hasSubsequenceUTF8 类似，但搜索时不区分大小写。 语法 
hasSubsequenceCaseInsensitiveUTF8(haystack, needle)
参数
  • haystack — 执行搜索所在的 UTF8 编码字符串。String
  • needle — 要搜索的 UTF8 编码子序列字符串。String
返回值 如果 needle 是 haystack 的子序列，则返回 1；否则返回 0。UInt8 示例 使用示例
Query
SELECT hasSubsequenceCaseInsensitiveUTF8('ClickHouse - столбцовая система управления базами данных', 'СИСТЕМА');
Response
┌─hasSubsequen⋯ 'СИСТЕМА')─┐
│                        1 │
└──────────────────────────┘

​
hasSubsequenceUTF8

引入版本：v23.7.0 与 hasSubsequence 类似，但假设 haystack 和 needle 是以 UTF-8 编码的字符串。 语法 
hasSubsequenceUTF8(haystack, needle)
参数
  • haystack — 要在其中进行搜索的字符串。String
  • needle — 要查找的子序列。String
返回值 如果 needle 是 haystack 的子序列，则返回 1；否则返回 0。UInt8 示例 用法示例
Query
SELECT hasSubsequenceUTF8('картошка', 'кошка');
Response
┌─hasSubsequen⋯', 'кошка')─┐
│                        1 │
└──────────────────────────┘
不匹配子序列
Query
SELECT hasSubsequenceUTF8('картошка', 'апельсин');
Response
┌─hasSubsequen⋯'апельсин')─┐
│                        0 │
└──────────────────────────┘

​
hasToken

引入版本：v20.1.0 检查给定的标记是否存在于 haystack 中。 使用 splitByNonAlpha 作为分词器，也就是说，标记被定义为由连续字符 [0-9A-Za-z_] (数字、ASCII 字符和下划线) 构成的最长子序列。 语法 
hasToken(haystack, token)
参数 返回值 如果找到该标记，则返回 1；否则返回 0。UInt8 示例 标记搜索
Query
SELECT hasToken('clickhouse test', 'test')
Response
┌─hasToken('clickhouse test', 'test')─┐
│                                   1 │
└─────────────────────────────────────┘

​
hasTokenCaseInsensitive

引入版本：v20.1.0 使用 tokenbf_v1 索引在 haystack 中执行对 needle 的不区分大小写查找。 语法 
hasTokenCaseInsensitive(haystack, needle)
参数
  • 无。
返回值 示例

​
hasTokenCaseInsensitiveOrNull

引入版本：v23.1.0 使用 tokenbf_v1 索引在 haystack 中不区分大小写地查找 needle。如果 needle 的格式不合法，则返回 NULL。 语法 
hasTokenCaseInsensitiveOrNull(haystack, needle)
参数
  • 无。
返回值 示例

​
hasTokenOrNull

首次引入版本：v20.1.0 与 hasToken 类似，但如果标记格式不合法，则返回 NULL。 语法 
hasTokenOrNull(haystack, token)
参数
  • haystack — 要搜索的字符串。必须为常量。String
  • token — 要搜索的标记。const String
返回值 如果找到该标记，则返回 1；否则返回 0。如果 token 格式不正确，则返回 NULL。Nullable(UInt8) 示例 使用示例
Query
SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
Response
┌─hasTokenOrNu⋯ 'ban ana')─┐
│                     ᴺᵁᴸᴸ │
└──────────────────────────┘

​
highlight

引入版本：v26.4.0 使用 HTML 标签包裹文本字符串中搜索词的匹配项，从而将其高亮显示。 该函数执行 ASCII 不区分大小写匹配。如果多个搜索词在文本中重叠或彼此相邻，则匹配区域会合并为一个高亮 span。 语法 
highlight(haystack, needles[, open_tag, close_tag])
参数
  • haystack — 要搜索的文本。String 或 FixedString
  • needles — 要高亮显示的搜索词数组。const Array(String)
  • open_tag — 在每个匹配项前插入的起始标签。默认值：<em>。const String
  • close_tag — 在每个匹配项后插入的结束标签。默认值：</em>。const String
返回值 返回将匹配词用指定标签包裹后的输入文本。String 示例 基本高亮
Query
SELECT highlight('The quick brown fox', ['quick', 'fox'])
Response
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘
自定义标签
Query
SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
Response
┌─highlight('Hello World', ['hello'], '<b>', '</b>')─┐
│ <b>Hello</b> World                                 │
└────────────────────────────────────────────────────┘

​
ilike

引入版本：v20.6.0 与 like 类似，但以不区分大小写的方式进行搜索。支持可选的 ESCAPE 子句 (参见 like) 。 语法 
ilike(haystack, pattern[, escape_character])
-- haystack ILIKE pattern [ESCAPE 'escape_character']
参数
  • haystack — 执行搜索的字符串。String 或 FixedString
  • pattern — 用于匹配的 LIKE 模式。String
  • escape_character — 可选的单字符字符串，用作转义字符以替代 \。默认值：\。String
返回值 如果字符串与 LIKE 模式匹配 (不区分大小写) ，则返回 1，否则返回 0。UInt8 示例 使用示例
Query
SELECT ilike('ClickHouse', '%house%');
Response
┌─ilike('ClickHouse', '%house%')─┐
│                              1 │
└────────────────────────────────┘

​
like

引入版本：v1.1.0 返回字符串 haystack 是否匹配 LIKE 表达式 pattern。 LIKE 表达式可以包含普通字符以及以下元符号：
  • % 表示任意数量的任意字符 (包括零个字符) 。
  • _ 表示任意单个字符。
  • \ 用于转义字面量 %、_ 和 \。
匹配基于 UTF-8，例如，_ 可以匹配 Unicode 码点 ¥，该字符在 UTF-8 中用两个字节表示。 如果 haystack 或 LIKE 表达式不是有效的 UTF-8，则其行为未定义。 不会自动执行 Unicode 规范化；你可以使用 normalizeUTF8* 函数来完成此操作。 要匹配字面量 %、_ 和 \ (它们是 LIKE 元字符) ，请在它们前面加上反斜杠：\%、\_ 和 \\。 如果反斜杠后面的字符不是 %、_ 或 \，则反斜杠会失去其特殊含义 (即按字面量解释) 。
ClickHouse 要求字符串中的反斜杠也需要转义，因此实际需要写成 \\%、\\_ 和 \\\\。
对于形如 %needle% 的 LIKE 表达式，该函数的速度与 position 函数一样快。 所有其他 LIKE 表达式在内部都会转换为正则表达式，并以与 match 函数相近的性能执行。

​
ESCAPE 子句

可选的 ESCAPE 子句用于指定自定义转义字符 (必须是单个 ASCII 字符) 。 提供后，自定义转义字符会替代默认的反斜杠，用于转义 % 和 _ 元字符。 转义字符可以转义三种内容：% (字面量百分号) 、_ (字面量下划线) 以及其自身 (字面量转义字符) 。 使用自定义转义字符时，反斜杠不再具有特殊含义，而是按字面量字符处理。 语法 
like(haystack, pattern[, escape_character])
-- haystack LIKE pattern [ESCAPE 'escape_character']
参数
  • haystack — 要在其中执行搜索的 String。String 或 FixedString
  • pattern — 要匹配的 LIKE 模式。可包含 % (匹配任意数量的字符) 、_ (匹配单个字符) 以及用于转义的 \。String
  • escape_character — 可选的单字符字符串，用作 \ 的替代转义字符。默认值：\。String
返回值 如果字符串与 LIKE 模式匹配，则返回 1；否则返回 0。UInt8 示例 用法示例
Query
SELECT like('ClickHouse', '%House');
Response
┌─like('ClickHouse', '%House')─┐
│                            1 │
└──────────────────────────────┘
单字符通配符
Query
SELECT like('ClickHouse', 'Click_ouse');
Response
┌─like('ClickH⋯lick_ouse')─┐
│                        1 │
└──────────────────────────┘
不匹配模式
Query
SELECT like('ClickHouse', '%SQL%');
Response
┌─like('ClickHouse', '%SQL%')─┐
│                           0 │
└─────────────────────────────┘
ESCAPE 子句
Query
SELECT '50%off' LIKE '50#%off' ESCAPE '#';
Response
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

​
locate

引入版本：v18.16.0 与 position 类似，但参数 haystack 和 locate 的顺序互换了。
与版本相关的行为此函数的行为取决于 ClickHouse 的版本：
  • 在 < v24.3 的版本中，locate 是函数 position 的别名，接受参数 (haystack, needle[, start_pos])。
  • 在 >= 24.3 的版本中，locate 是一个独立函数 (为了更好地兼容 MySQL) ，接受参数 (needle, haystack[, start_pos])。 可以通过设置 function_locate_has_mysql_compatible_argument_order = false 恢复之前的行为。
语法 
locate(needle, haystack[, start_pos])
参数
  • needle — 要搜索的子串。String
  • haystack — 要在其中进行搜索的字符串。String 或 Enum
  • start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt
返回值 如果找到子串，则返回其起始位置 (按字节计数，且从 1 开始) ；如果未找到子串，则返回 0。UInt64 示例 基本用法
Query
SELECT locate('ca', 'abcabc')
Response
┌─locate('ca', 'abcabc')─┐
│                      3 │
└────────────────────────┘

​
match

引入版本：v1.1.0 检查给定字符串是否与指定的 正则表达式 模式 匹配。 此函数使用 RE2 正则表达式 库。支持的语法请参阅 re2。 匹配基于 UTF-8 假设进行，例如 ¥ 在内部占用两个字节，但在匹配时会被视为单个码点。 正则表达式 不能包含 NULL 字节。 如果 haystack 或 模式 不是有效的 UTF-8，则其行为未定义。 与 re2 的默认行为不同，. 会匹配换行符。要禁用此行为，请在 模式 前添加 (?-s)。 模式 不会自动加上锚点。若要匹配整个字符串，请自行使用 ^ 和 $ 对 模式 加锚。 如果你只是想搜索子字符串，可以改用函数 like 或 position，它们的速度比此函数快得多。 可选的运算符语法：haystack REGEXP pattern。 语法 
match(haystack, pattern)
别名: REGEXP_MATCHES 参数
  • haystack — 在其中搜索模式的 String。String
  • pattern — 正则表达式模式。可以是常量，也可以来自列。String
返回值 如果匹配该模式，则返回 1，否则返回 0。UInt8 示例 基本模式匹配
Query
SELECT match('Hello World', 'Hello.*')
Response
┌─match('Hello World', 'Hello.*')─┐
│                               1 │
└─────────────────────────────────┘
模式不匹配
Query
SELECT match('Hello World', 'goodbye.*')
Response
┌─match('Hello World', 'goodbye.*')─┐
│                                 0 │
└───────────────────────────────────┘
匹配子串
Query
SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
Response
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                       1 │                         0 │
└─────────────────────────┴───────────────────────────┘

​
multiFuzzyMatchAllIndices

引入版本：v20.1.0 与 multiFuzzyMatchAny 类似，但会返回在固定编辑距离内与 haystack 匹配的所有索引组成的数组，顺序不限。 语法 
multiFuzzyMatchAllIndices(haystack, distance, [pattern1, pattern2, ..., patternN])
参数
  • haystack — 执行搜索的 String。String
  • distance — 模糊匹配允许的最大编辑距离。UInt8
  • pattern — 要匹配的模式数组。Array(String)
返回值 返回一个数组，包含在指定编辑距离内以任意顺序匹配 haystack 的所有索引 (从 1 开始) 。如果未找到匹配项，则返回空数组。Array(UInt64) 示例 使用示例
Query
SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
Response
┌─multiFuzzyMa⋯, 'House'])─┐
│ [3,1,4,2]                │
└──────────────────────────┘

​
multiFuzzyMatchAny

引入版本：v20.1.0 与 multiMatchAny 类似，但如果任意模式在固定的编辑距离内匹配 haystack，则返回 1。 此函数依赖 hyperscan 库的 Experimental 功能，在某些边缘情况下可能较慢。 其性能取决于编辑距离的取值和所使用的模式，但与非模糊变体相比，开销始终更高。
由于 hyperscan 的限制，multiFuzzyMatch*() 函数家族不支持 UTF-8 正则表达式 (会将其视为字节序列) 。
语法 
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternN])
参数
  • haystack — 执行搜索的 String。String
  • distance — fuzzy matching 的最大编辑距离。UInt8
  • pattern — 可选。用于匹配的模式数组。Array(String)
返回值 如果任一模式在指定的 编辑距离 内与 haystack 匹配，则返回 1；否则返回 0。UInt8 示例 使用示例
Query
SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
Response
┌─multiFuzzyMa⋯lickHose'])─┐
│                        1 │
└──────────────────────────┘

​
multiFuzzyMatchAnyIndex

引入于：v20.1.0 与 multiFuzzyMatchAny 类似，但会返回在固定编辑距离内与 haystack 匹配的任意一个索引。 语法 
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn])
参数
  • haystack — 执行搜索的字符串。String
  • distance — 模糊匹配允许的最大编辑距离。UInt8
  • pattern — 用于匹配的模式数组。Array(String)
返回值 返回在指定编辑距离内与 haystack 匹配的任意一个模式的索引 (从 1 开始) ；如果都不匹配，则返回 0。UInt64 示例 使用示例
Query
SELECT multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse']);
Response
┌─multiFuzzyMa⋯ickHouse'])─┐
│                        2 │
└──────────────────────────┘

​
multiMatchAllIndices

引入版本：v20.1.0 与 multiMatchAny 类似，但返回按任意顺序与 haystack 匹配的所有索引组成的数组。 语法 
multiMatchAllIndices(haystack, [pattern1, pattern2, ..., patternn])
参数
  • haystack — 执行搜索的字符串。String
  • pattern — 用于匹配的正则表达式。String
返回值 由按任意顺序与 haystack 匹配的所有索引 (从 1 开始) 组成的数组。如果未找到匹配项，则返回空数组。Array(UInt64) 示例 使用示例
Query
SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
Response
┌─multiMatchAl⋯', 'ouse'])─┐
│ [3, 2, 4]                │
└──────────────────────────┘

​
multiMatchAny

引入版本：v20.1.0 检查多个正则表达式 模式 中是否至少有一个与 haystack 匹配。 如果你只想在一个字符串中搜索多个子字符串，可以改用函数 multiSearchAny——它的速度比此函数快得多。 语法 
multiMatchAny(haystack, pattern1[, pattern2, ...])
参数
  • haystack — 在其中搜索模式的 String。String
  • pattern1[, pattern2, ...] — 包含一个或多个正则表达式模式的数组。Array(String)
返回值 如果任意模式匹配则返回 1，否则返回 0。UInt8 示例 多个模式匹配
Query
SELECT multiMatchAny('Hello World', ['Hello.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['Hello.*', 'foo.*'])─┐
│                                                  1 │
└────────────────────────────────────────────────────┘
没有任何模式匹配
Query
SELECT multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])
Response
┌─multiMatchAny('Hello World', ['goodbye.*', 'foo.*'])─┐
│                                                    0 │
└──────────────────────────────────────────────────────┘

​
multiMatchAnyIndex

引入版本：v20.1.0 与 multiMatchAny 类似，但会返回任意一个与 haystack 匹配的索引。 语法 
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn])
参数
  • haystack — 执行搜索的字符串。String
  • pattern — 用于匹配的正则表达式。Array(String)
返回值 返回第一个匹配 pattern 的索引 (从 1 开始) ；如果未找到匹配项，则返回 0。UInt64 示例 使用示例
Query
SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
Response
┌─multiMatchAn⋯, 'Click'])─┐
│                        3 │
└──────────────────────────┘

​
multiSearchAllPositions

Introduced in: v20.1.0 与 position 类似，但它返回一个位置数组，表示 haystack 字符串中多个 needle 子字符串的位置 (以字节为单位，从 1 开始计数) 。 所有 multiSearch*() 函数最多仅支持 2^8 个 needle。 Syntax 
multiSearchAllPositions(haystack, needle1[, needle2, ...])
参数
  • haystack — 执行搜索的字符串。String
  • needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)
返回值 如果找到子串，则返回由起始位置组成的数组，位置以字节为单位并从 1 开始计数；如果未找到子串，则返回 0。Array(UInt64) 示例 多个 needle 搜索
Query
SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
Response
┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0,13,0]                                                          │
└───────────────────────────────────────────────────────────────────┘

​
multiSearchAllPositionsCaseInsensitive

引入版本：v20.1.0 与 multiSearchAllPositions 类似，但不区分大小写。 语法 
multiSearchAllPositionsCaseInsensitive(haystack, needle1[, needle2, ...])
参数
  • haystack — 要在其中执行搜索的 String。String
  • needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)
返回值 返回一个数组，表示起始位置 (按字节计算，从 1 开始；如果找到了子串) ；如果未找到子串，则返回 0。Array(UInt64) 示例 不区分大小写的多重搜索
Query
SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchA⋯['c', 'h'])─┐
│ [1,6]                    │
└──────────────────────────┘

​
multiSearchAllPositionsCaseInsensitiveUTF8

引入版本：v20.1.0 与 multiSearchAllPositionsUTF8 类似，但不区分大小写。 语法 
multiSearchAllPositionsCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 执行搜索的 UTF-8 编码字符串。String
  • needle — 要搜索的 UTF-8 编码子字符串。Array(String)
返回值 由起始位置组成的数组；位置按字节计算，从 1 开始 (如果找到了子字符串) 。如果未找到子字符串，则返回 0。Array 示例 不区分大小写的 UTF-8 搜索
Query
SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
Response
┌─multiSearchA⋯й', 'МИР'])─┐
│ [1, 13]                  │
└──────────────────────────┘

​
multiSearchAllPositionsUTF8

引入版本：v20.1.0 与 multiSearchAllPositions 类似，但假定 haystack 和 needle 子串均为 UTF-8 编码的字符串。 语法 
multiSearchAllPositionsUTF8(haystack, needle1[, needle2, ...])
参数
  • haystack — 要在其中执行搜索的 UTF-8 编码字符串。String
  • needle1[, needle2, ...] — 要搜索的 UTF-8 编码子字符串数组。Array(String)
返回值 返回一个数组：如果找到子串，则返回其以字节为单位、从 1 开始计数的起始位置；如果未找到子串，则返回 0。Array 示例 UTF-8 多重搜索
Query
SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
Response
┌─multiSearchAllPositionsUTF8('ClickHouse', ['C', 'H'])─┐
│ [1,6]                                                 │
└───────────────────────────────────────────────────────┘

​
multiSearchAny

引入版本：v20.1.0 检查多个 needle 字符串中是否至少有一个与 haystack 字符串匹配。 函数 multiSearchAnyCaseInsensitive、multiSearchAnyUTF8 和 multiSearchAnyCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。 语法 
multiSearchAny(haystack, needle1[, needle2, ...])
参数
  • haystack — 在其中执行搜索的 String。String
  • needle1[, needle2, ...] — 要查找的子字符串数组。Array(String)
返回值 如果至少有一个匹配项，则返回 1；否则返回 0。UInt8 示例 任意匹配查找
Query
SELECT multiSearchAny('ClickHouse',['C','H'])
Response
┌─multiSearchAny('ClickHouse', ['C', 'H'])─┐
│                                        1 │
└──────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitive

引入版本：v20.1.0 与 multiSearchAny 类似，但不区分大小写。 语法 
multiSearchAnyCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 在其中执行搜索的 String。String
  • needle — 要搜索的子字符串。Array(String)
返回值 如果至少有一个不区分大小写的匹配，则返回 1；否则返回 0。UInt8 示例 不区分大小写的搜索
Query
SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
Response
┌─multiSearchAnyCaseInsensitive('ClickHouse', ['c', 'h'])─┐
│                                                       1 │
└─────────────────────────────────────────────────────────┘

​
multiSearchAnyCaseInsensitiveUTF8

首次引入于：v20.1.0 与 multiSearchAnyUTF8 类似，但不区分大小写。 语法 
multiSearchAnyCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 在其中执行搜索的 UTF-8 字符串。String
  • needle — 待搜索的 UTF-8 子字符串。Array(String)
返回值 如果至少有一个不区分大小写的匹配，则返回 1；否则返回 0。UInt8 示例 给定 UTF-8 字符串 ‘Здравствуйте’，检查是否包含字符 ‘з’ (小写)
Query
SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
Response
┌─multiSearchA⋯те', ['з'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchAnyUTF8

引入版本：v20.1.0 与 multiSearchAny 类似，但假定 haystack 和 needle 子串都是 UTF-8 编码的字符串。 语法 
multiSearchAnyUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 执行搜索的 UTF-8 字符串。String
  • needle — 要搜索的 UTF-8 子字符串。Array(String)
返回值 如果至少有一个匹配，则返回 1；否则返回 0。UInt8 示例 给定 UTF-8 字符串 ‘你好，世界’ (‘Hello, world’) ，检查该字符串中是否包含字符 你 或 界
Query
SELECT multiSearchAnyUTF8('你好，世界', ['你', '界'])
Response
┌─multiSearchA⋯你', '界'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndex

引入版本：v20.1.0 在 haystack 字符串中搜索多个 needle 字符串 (区分大小写) ，并返回找到的第一个 needle 的从 1 开始的索引。 语法 
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 要在其中搜索的字符串。String
  • needles — 要查找的字符串数组。Array(String)
返回值 返回在 haystack 中找到的第一个 needle 的从 1 开始的索引 (即其在 needles 数组中的位置) 。如果未找到任何 needle，则返回 0。搜索区分大小写。UInt64 示例 用法示例
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        1 │
└──────────────────────────┘
区分大小写
Query
SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
Response
┌─multiSearchF⋯ 'Server'])─┐
│                        2 │
└──────────────────────────┘
未找到匹配项
Query
SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitive

引入版本：v20.1.0 返回字符串 haystack 中最左侧匹配到的 needle_i 的索引 i (从 1 开始) ，否则返回 0。 不区分大小写。 语法 
multiSearchFirstIndexCaseInsensitive(haystack, [needle1, needle2, ..., needleN]
参数
  • haystack — 执行搜索的 String。String
  • needle — 要搜索的子字符串。Array(String)
返回值 返回最靠左匹配到的 needle 的索引 (从 1 开始) 。如果没有匹配项，则返回 0。UInt8 示例 使用示例
Query
SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
Response
┌─multiSearchF⋯, 'Hello'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstIndexCaseInsensitiveUTF8

引入版本：v20.1.0 在支持 UTF-8 编码的情况下，以不区分大小写的方式在 haystack 字符串中搜索多个 needle 字符串，并返回第一个匹配到的 needle 的从 1 开始的索引。 语法 
multiSearchFirstIndexCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 要搜索的字符串。String
  • needles — 要查找的字符串数组。Array(String)
返回值 返回在 haystack 中找到的第一个 needle 的从 1 开始的索引 (即其在 needles 数组中的位置) 。如果未找到任何 needle，则返回 0。搜索不区分大小写，并遵循 UTF-8 字符编码。UInt64 示例 用法示例
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
Response
┌─multiSearchF⋯ 'server'])─┐
│                        1 │
└──────────────────────────┘
UTF-8 字母大小写处理
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
Response
┌─multiSearchF⋯ 'ПРИВЕТ'])─┐
│                        1 │
└──────────────────────────┘
未找到匹配结果
Query
SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
Response
┌─multiSearchF⋯', 'test'])─┐
│                        0 │
└──────────────────────────┘

​
multiSearchFirstIndexUTF8

引入版本：v20.1.0 返回字符串 haystack 中最靠左匹配到的 needle_i 的索引 i (从 1 开始) ，否则返回 0。 假定 haystack 和 needle 是采用 UTF-8 编码的字符串。 语法 
multiSearchFirstIndexUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 在其中进行搜索的 UTF-8 字符串。String
  • needle — 要搜索的 UTF-8 子字符串数组。Array(String)
返回值 返回最先找到的、最靠左的 needle 的索引 (从 1 开始计数) 。如果没有匹配，则返回 0。UInt8 示例 使用示例
Query
SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
Response
┌─multiSearchF⋯вствуйте'])─┐
│                        1 │
└──────────────────────────┘

​
multiSearchFirstPosition

引入版本：v20.1.0 与 position 类似，但返回 haystack 字符串中与多个 needle 字符串里任意一个匹配的最左偏移量。 函数 multiSearchFirstPositionCaseInsensitive、multiSearchFirstPositionUTF8 和 multiSearchFirstPositionCaseInsensitiveUTF8 提供了此函数的不区分大小写和/或 UTF-8 变体。 语法 
multiSearchFirstPosition(haystack, needle1[, needle2, ...])
参数
  • haystack — 执行搜索的 String。String
  • needle1[, needle2, ...] — 由一个或多个待搜索子字符串组成的数组。Array(String)
返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量；如果没有匹配，则返回 0。UInt64 示例 搜索首个位置
Query
SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
Response
┌─multiSearchFirstPosition('Hello World', ['llo', 'Wor', 'ld'])─┐
│                                                             3 │
└───────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitive

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但不区分大小写。 语法 
multiSearchFirstPositionCaseInsensitive(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 执行搜索的字符串。String
  • needle — 要搜索的子字符串数组。Array(String)
返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量。如果没有匹配，则返回 0。UInt64 示例 大小写不敏感的第一个位置
Query
SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
Response
┌─multiSearchFirstPositionCaseInsensitive('HELLO WORLD', ['wor', 'ld', 'ello'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionCaseInsensitiveUTF8

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但假定 haystack 和 needle 均为 UTF-8 字符串，且不区分大小写。 语法 
multiSearchFirstPositionCaseInsensitiveUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 执行搜索的 UTF-8 字符串。String
  • needle — 要搜索的 UTF-8 子字符串数组。Array(String)
返回值 返回 haystack 字符串中与多个 needle 字符串中的任意一个匹配的最左侧偏移量，忽略大小写。如果没有匹配，则返回 0。UInt64 示例 查找 UTF-8 字符串 ‘Здравствуй, мир’ (‘Hello, world’) 中与给定 needle 中任意一个匹配的最左侧偏移量
Query
SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
Response
┌─multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])─┐
│                                                                                      1 │
└────────────────────────────────────────────────────────────────────────────────────────┘

​
multiSearchFirstPositionUTF8

引入版本：v20.1.0 与 multiSearchFirstPosition 类似，但假设 haystack 和 needle 都是 UTF-8 字符串。 语法 
multiSearchFirstPositionUTF8(haystack, [needle1, needle2, ..., needleN])
参数
  • haystack — 执行搜索的 UTF-8 字符串。String
  • needle — 要搜索的 UTF-8 子字符串数组。Array(String)
返回值 haystack 字符串中与多个 needle 字符串中任意一个匹配的最左侧偏移量。如果没有匹配，则返回 0。UInt64 示例 查找 UTF-8 字符串 ‘Здравствуй, мир’ (‘Hello, world’) 中与给定任意一个 needle 匹配的最左侧偏移量
Query
SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
Response
┌─multiSearchFirstPositionUTF8('Здравствуй, мир', ['мир', 'вст', 'авст'])─┐
│                                                                       4 │
└─────────────────────────────────────────────────────────────────────────┘

​
ngramDistance

引入版本：v20.1.0 计算两个字符串之间的 4-gram 距离。 为此，它会统计两个 4-gram 多重集合之间的对称差，并用它们的基数之和对结果进行归一化。 返回值越小，字符串越相似。 如需进行不区分大小写的搜索和/或使用 UTF8 格式，请使用函数 ngramDistanceCaseInsensitive、ngramDistanceUTF8、ngramDistanceCaseInsensitiveUTF8。 语法 
ngramDistance(haystack, needle)
参数
  • haystack — 用于比较的字符串。String
  • needle — 用于比较的字符串。String
返回值 返回一个介于 0 和 1 之间的 Float32 数值。返回值越小，字符串越相似。Float32 示例 计算 4-gram 距离
Query
SELECT ngramDistance('ClickHouse', 'ClickHouses')
Response
┌─ngramDistance('ClickHouse', 'ClickHouses')─┐
│                                        0.1 │
└────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitive

引入版本：v20.1.0 提供 ngramDistance 的不区分大小写变体。 计算两个字符串之间的 4-gram 距离，忽略大小写。 返回值越小，字符串越相似。 语法 
ngramDistanceCaseInsensitive(haystack, needle)
参数
  • haystack — 第一个比较字符串。String
  • needle — 第二个比较字符串。String
返回值 返回一个介于 0 和 1 之间的 Float32 数值。Float32 示例 不区分大小写的 4-gram 距离
Query
SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')
Response
┌─ngramDistanceCaseInsensitive('ClickHouse','clickhouse')─┐
│                                                       0 │
└─────────────────────────────────────────────────────────┘

​
ngramDistanceCaseInsensitiveUTF8

引入版本：v20.1.0 提供 ngramDistance 的不区分大小写 UTF-8 变体。 假定 needle 和 haystack 字符串均为 UTF-8 编码，并忽略大小写。 计算两个 UTF-8 字符串之间不区分大小写的 3-gram 距离。 返回值越小，字符串越相似。 语法 
ngramDistanceCaseInsensitiveUTF8(haystack, needle)
参数
  • haystack — 第一个采用 UTF-8 编码的比较字符串。String
  • needle — 第二个采用 UTF-8 编码的比较字符串。String
返回值 返回一个介于 0 和 1 之间的 Float32 数值。Float32 示例 不区分大小写的 UTF-8 3-gram 距离
Query
SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')
Response
┌─ngramDistanceCaseInsensitiveUTF8('abcde','CDE')─┐
│                                             0.5 │
└─────────────────────────────────────────────────┘

​
ngramDistanceUTF8

引入版本：v20.1.0 提供 ngramDistance 的 UTF-8 版本。 假定 needle 和 haystack 字符串均为 UTF-8 编码。 计算两个 UTF-8 字符串之间的 3-gram 距离。 返回值越小，字符串越相似。 语法 
ngramDistanceUTF8(haystack, needle)
参数
  • haystack — 第一个 UTF-8 编码的比较字符串。String
  • needle — 第二个 UTF-8 编码的比较字符串。String
返回值 返回 0 到 1 之间的 Float32 数值。Float32 示例 UTF-8 3-gram 距离
Query
SELECT ngramDistanceUTF8('abcde','cde')
Response
┌─ngramDistanceUTF8('abcde','cde')─┐
│                               0.5 │
└───────────────────────────────────┘

​
ngramSearch

引入版本：v20.1.0 检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值。 如需进行不区分大小写的搜索和/或使用 UTF8 格式，请使用函数 ngramSearchCaseInsensitive、ngramSearchUTF8、ngramSearchCaseInsensitiveUTF8。 语法 
ngramSearch(haystack, needle)
参数
  • haystack — 用于比较的字符串。String
  • needle — 用于比较的字符串。String
返回值 如果两个字符串之间的 4-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 4-gram 进行搜索
Query
SELECT ngramSearch('ClickHouse', 'Click')
Response
┌─ngramSearch('ClickHouse', 'Click')─┐
│                                  1 │
└────────────────────────────────────┘

​
ngramSearchCaseInsensitive

引入版本：v20.1.0 提供 ngramSearch 的不区分大小写版本。 计算 needle 字符串与 haystack 字符串之间的非对称差，即用 needle 中的 n-gram 数量减去共有的 n-gram 数量，再按 needle 的 n-gram 数量进行归一化。 检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值，并忽略大小写。 语法 
ngramSearchCaseInsensitive(haystack, needle)
参数
  • haystack — 用于比较的 String。String
  • needle — 用于比较的 String。String
返回值 如果两个字符串之间的 4-gram 距离小于或等于阈值 (默认值为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 4-gram 的不区分大小写搜索
Query
SELECT ngramSearchCaseInsensitive('Hello World','hello')
Response
┌─ngramSearchCaseInsensitive('Hello World','hello')─┐
│                                                  1 │
└────────────────────────────────────────────────────┘

​
ngramSearchCaseInsensitiveUTF8

引入版本：v20.1.0 提供 ngramSearch 的不区分大小写 UTF-8 变体。 假定 haystack 和 needle 为 UTF-8 字符串，并且不区分大小写。 检查两个 UTF-8 字符串之间的 3-gram 距离是否小于或等于给定阈值，且不区分大小写。 语法 
ngramSearchCaseInsensitiveUTF8(haystack, needle)
参数
  • haystack — 用于比较的 UTF-8 字符串。String
  • needle — 用于比较的 UTF-8 字符串。String
返回值 如果两个字符串之间的 3-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 3-gram 的不区分大小写 UTF-8 搜索
Query
SELECT ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')
Response
┌─ngramSearchCaseInsensitiveUTF8('абвГДЕёжз', 'АбвгдЕЁжз')─┐
│                                                        1 │
└──────────────────────────────────────────────────────────┘

​
ngramSearchUTF8

引入版本：v20.1.0 提供 ngramSearch 的 UTF-8 版本。 假定 haystack 和 needle 为 UTF-8 字符串。 检查两个 UTF-8 字符串之间的 3-gram distance 是否小于或等于给定阈值。 语法 
ngramSearchUTF8(haystack, needle)
参数
  • haystack — 用于比较的 UTF-8 字符串。String
  • needle — 用于比较的 UTF-8 字符串。String
返回值 如果两个字符串之间的 3-gram 距离小于或等于阈值 (默认为 1.0) ，则返回 1；否则返回 0。UInt8 示例 使用 3-gram 进行 UTF-8 搜索
Query
SELECT ngramSearchUTF8('абвгдеёжз', 'гдеёзд')
Response
┌─ngramSearchUTF8('абвгдеёжз', 'гдеёзд')─┐
│                                      1 │
└────────────────────────────────────────┘

​
notILike

引入版本：v20.6.0 检查字符串是否不匹配某个模式，且不区分大小写。该模式可包含用于 SQL LIKE 匹配的特殊字符 % 和 _。支持可选的 ESCAPE 子句 (参见 like) 。 语法 
notILike(haystack, pattern[, escape_character])
-- haystack NOT ILIKE pattern [ESCAPE 'escape_character']
参数
  • haystack — 待搜索的输入字符串。String 或 FixedString
  • pattern — 要匹配的 SQL LIKE 模式。% 匹配任意数量的字符 (包括零个) ，_ 恰好匹配一个字符。String
  • escape_character — 可选的单字符字符串，用作转义字符来替代 \。默认值：\。String
返回值 如果字符串与模式不匹配 (不区分大小写) ，则返回 1，否则返回 0。UInt8 示例 用法示例
Query
SELECT notILike('ClickHouse', '%house%');
Response
┌─notILike('Cl⋯ '%house%')─┐
│                        0 │
└──────────────────────────┘

​
notLike

Introduced in：v1.1.0 与 like 类似，但会返回相反的结果。支持可选的 ESCAPE 子句 (参见 like) 。 Syntax 
notLike(haystack, pattern[, escape_character])
-- haystack NOT LIKE pattern [ESCAPE 'escape_character']
参数
  • haystack — 要在其中执行搜索的字符串。String 或 FixedString
  • pattern — 用于匹配的 LIKE 模式。String
  • escape_character — 可选的单字符字符串，用作转义字符，以替代 \。默认值：\。String
返回值 如果字符串与 LIKE 模式不匹配，则返回 1；否则返回 0。UInt8 示例 使用示例
Query
SELECT notLike('ClickHouse', '%House%');
Response
┌─notLike('Cli⋯ '%House%')─┐
│                        0 │
└──────────────────────────┘
不匹配的模式
Query
SELECT notLike('ClickHouse', '%SQL%');
Response
┌─notLike('Cli⋯', '%SQL%')─┐
│                        1 │
└──────────────────────────┘

​
position

引入版本：v1.1.0 返回子串 needle 在字符串 haystack 中的位置 (以字节为单位，从 1 开始计数) 。 如果子串 needle 为空，则适用以下规则：
  • 如果未指定 start_pos：返回 1
  • 如果 start_pos = 0：返回 1
  • 如果 start_pos >= 1 且 start_pos <= length(haystack) + 1：返回 start_pos
  • 否则：返回 0
同样的规则也适用于函数 locate、positionCaseInsensitive、positionUTF8 和 positionCaseInsensitiveUTF8。 语法 
position(haystack, needle[, start_pos])
参数
  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — haystack 中开始搜索的位置 (从 1 开始计数) 。可选。UInt
返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 基本用法
Query
SELECT position('Hello, world!', '!')
Response
┌─position('Hello, world!', '!')─┐
│                             13 │
└────────────────────────────────┘
带有 start_pos 参数
Query
SELECT position('Hello, world!', 'o', 1), position('Hello, world!', 'o', 7)
Response
┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘
Needle IN haystack 语法
Query
SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s)
Response
┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘
空 needle 的子串
Query
SELECT position('abc', ''), position('abc', '', 0), position('abc', '', 1), position('abc', '', 2), position('abc', '', 3), position('abc', '', 4), position('abc', '', 5)
Response
┌─position('abc', '')─┬─position('abc', '', 0)─┬─position('abc', '', 1)─┬─position('abc', '', 2)─┬─position('abc', '', 3)─┬─position('abc', '', 4)─┬─position('abc', '', 5)─┐
│                   1 │                      1 │                      1 │                      2 │                      3 │                      4 │                      0 │
└─────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┴────────────────────────┘

​
positionCaseInsensitive

引入版本：v1.1.0 与 position 类似，但不区分大小写。 语法 
positionCaseInsensitive(haystack, needle[, start_pos])
别名: instr 参数
  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*
返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到子串，则返回 0。UInt64 示例 不区分大小写的搜索
Query
SELECT positionCaseInsensitive('Hello, world!', 'hello')
Response
┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│                                                 1 │
└───────────────────────────────────────────────────┘

​
positionCaseInsensitiveUTF8

引入版本：v1.1.0 与 positionUTF8 类似，但按不区分大小写的方式搜索。 语法 
positionCaseInsensitiveUTF8(haystack, needle[, start_pos])
参数
  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始) 。UInt*
返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 不区分大小写的 UTF-8 搜索
Query
SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
Response
┌─positionCaseInsensitiveUTF8('Привет мир', 'МИР')─┐
│                                                8 │
└──────────────────────────────────────────────────┘

​
positionUTF8

引入版本：v1.1.0 与 position 类似，但假定 haystack 和 needle 为 UTF-8 编码的字符串。 语法 
positionUTF8(haystack, needle[, start_pos])
参数
  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*
返回值 如果找到子串，则返回其起始位置 (以字节为单位，从 1 开始计数) ；如果未找到，则返回 0。UInt64 示例 按 UTF-8 字符计数
Query
SELECT positionUTF8('Motörhead', 'r')
Response
┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
最后修改于 2026年6月25日