跳至主要内容
跳至主要内容
编辑此页

字符串搜索函数

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

注意

不区分大小写的搜索遵循英语的大小写规则。例如，英语中的大写字母 i 是 I，而在土耳其语中是 İ - 对于非英语语言的结果可能出乎意料。

本节中的函数还假定搜索的字符串（在本节中称为 haystack）和搜索字符串（在本节中称为 needle）都是单字节编码的文本。如果违反了此假设，则不会引发异常，结果未定义。通常，使用单独的函数变体提供 UTF-8 编码字符串的搜索。同样，如果使用了 UTF-8 函数变体，而输入字符串不是 UTF-8 编码的文本，则不会引发异常，结果未定义。请注意，不执行自动 Unicode 规范化，但是可以使用 normalizeUTF8*() 函数进行规范化。

单独描述了 通用字符串函数 和 字符串替换函数。

注意

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

countMatches​

引入于：v21.1

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

版本依赖行为

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

  • 在 v25.6 之前的版本中，即使模式匹配成功，该函数也会在第一个空匹配处停止计数。
  • 在 >= 25.6 的版本中，当发生空匹配时，该函数将继续执行。可以使用设置 count_matches_stop_at_empty_match = true 来恢复旧行为；

语法

countMatches(haystack, pattern)

参数

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

返回值

返回找到的匹配数量。 UInt64

示例

统计数字序列

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

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

countMatchesCaseInsensitive​

引入于：v21.1

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

语法

countMatchesCaseInsensitive(haystack, pattern)

参数

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

返回值

返回找到的匹配数量。 UInt64

示例

不区分大小写的计数

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

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

countSubstrings​

引入于：v21.1

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

语法

countSubstrings(haystack, needle[, start_pos])

参数

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

返回值

出现的次数。 UInt64

示例

使用示例

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

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

带有 start_pos 参数

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

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

countSubstringsCaseInsensitive​

引入于：v21.1

类似于 countSubstrings，但以不区分大小写的方式计数。

语法

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

参数

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

返回值

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

示例

使用示例

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

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

带有 start_pos 参数

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

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

countSubstringsCaseInsensitiveUTF8​

引入于：v21.1

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

语法

countSubstringsCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

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

返回值

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

示例

使用示例

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

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

带有 start_pos 参数

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

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

extract​

引入于：v1.1

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

此函数使用 RE2 正则表达式库。请参阅 re2 以获取支持的语法。

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

语法

extract(haystack, pattern)

参数

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

返回值

返回提取的片段作为字符串。 String

示例

从电子邮件中提取域名

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

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

未匹配返回空字符串

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

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

extractAll​

引入于：v1.1

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

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

语法

extractAll(haystack, pattern)

参数

  • haystack — 要提取片段的字符串。 String
  • pattern — 可选地包含捕获组的正则表达式。 const String

返回值

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

示例

提取所有数字

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

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

使用捕获组提取

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

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

extractAllGroupsHorizontal​

引入于：v20.5

使用提供的正则表达式匹配字符串的所有组，并返回一个数组的数组，其中每个数组包含来自相同捕获组的所有捕获项，按组号组织。

语法

extractAllGroupsHorizontal(s, regexp)

参数

返回值

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

示例

使用示例

WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsHorizontal(s, '< ([\\w\\-]+): ([^\\r\\n]+)');

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

extractGroups​

引入于：v20.5

提取由正则表达式匹配的非重叠子字符串中的所有组。

语法

extractAllGroups(s, regexp)

参数

返回值

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

示例

使用示例

WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');

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

hasAllTokens​

引入于: v25.10

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

注意

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

在搜索之前，该函数会标记化

  • input 参数（始终），以及
  • needle 参数（如果作为 String 提供）使用文本索引指定的标记化器。如果该列未定义文本索引，则使用 splitByNonAlpha 标记化器。如果 needle 参数的类型为 Array(String)，则每个数组元素被视为一个标记 - 不进行额外的标记化。

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

语法

hasAllTokens(input, needles)

别名：hasAllToken

参数

返回值

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

示例

使用字符串针的基本用法

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

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

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

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

以数组形式指定要搜索的针（不进行标记化）

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

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

使用 tokens 函数生成针

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

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

通过第 3 个参数使用自定义标记化器

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

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

数组和映射列的用法示例

CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});

使用数组列的示例

SELECT count() FROM log WHERE hasAllTokens(tags, 'clickhouse');

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

mapKeys 的示例

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

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

mapValues 的示例

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

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

hasAnyTokens​

引入于: v25.10

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

注意

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

在搜索之前，该函数会标记化

  • input 参数（始终），以及
  • needle 参数（如果作为 String 提供）使用文本索引指定的标记化器。如果该列未定义文本索引，则使用 splitByNonAlpha 标记化器。如果 needle 参数的类型为 Array(String)，则每个数组元素被视为一个标记 - 不进行额外的标记化。

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

语法

hasAnyTokens(input, needles)

别名：hasAnyToken

参数

返回值

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

示例

使用字符串针的基本用法

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

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

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

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

以数组形式指定要搜索的针（不进行标记化）

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

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

使用 tokens 函数生成针

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

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

数组和映射列的用法示例

CREATE TABLE log (
    id UInt32,
    tags Array(String),
    attributes Map(String, String),
    INDEX idx_tags (tags) TYPE text(tokenizer = splitByNonAlpha),
    INDEX idx_attributes_keys mapKeys(attributes) TYPE text(tokenizer = array),
    INDEX idx_attributes_vals mapValues(attributes) TYPE text(tokenizer = array)
)
ENGINE = MergeTree
ORDER BY id;

INSERT INTO log VALUES
    (1, ['clickhouse', 'clickhouse cloud'], {'address': '192.0.0.1', 'log_level': 'INFO'}),
    (2, ['chdb'], {'embedded': 'true', 'log_level': 'DEBUG'});

使用数组列的示例

SELECT count() FROM log WHERE hasAnyTokens(tags, 'clickhouse');

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

mapKeys 的示例

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

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

mapValues 的示例

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

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

hasSubsequence​

引入于: v23.7

检查针是否是 haystack 的子序列。字符串的子序列是可以通过删除另一个字符串中的一些或没有字符而不更改剩余字符的顺序而派生的序列。

语法

hasSubsequence(haystack, needle)

参数

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

返回值

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

示例

基本子序列检查

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

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

未找到子序列

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

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

hasSubsequenceCaseInsensitive​

引入于: v23.7

类似于 hasSubsequence，但以不区分大小写的方式搜索。

语法

hasSubsequenceCaseInsensitive(haystack, needle)

参数

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

返回值

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

示例

使用示例

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

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

hasSubsequenceCaseInsensitiveUTF8​

引入于: v23.7

类似于 hasSubsequenceUTF8，但以不区分大小写的方式搜索。

语法

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

参数

  • haystack — 要在其中执行搜索的 UTF8 编码字符串。 String
  • needle — 要搜索的 UTF8 编码的子字符串。 String

返回值

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

示例

使用示例

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

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

hasSubsequenceUTF8​

引入于: v23.7

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

语法

hasSubsequenceUTF8(haystack, needle)

参数

  • haystack — 要搜索的字符串。 String
  • needle — 要搜索的子序列。 String

返回值

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

示例

使用示例

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

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

不匹配的子序列

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

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

hasToken​

引入于: v20.1

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

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

语法

hasToken(haystack, token)

参数

  • haystack — 要搜索的字符串。 String
  • token — 要搜索的 token。 const String

返回值

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

示例

Token 搜索

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

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

hasTokenCaseInsensitive​

引入于：v

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

语法

参数

  • 无。

返回值

示例

hasTokenCaseInsensitiveOrNull​

引入于：v

使用 tokenbf_v1 索引执行 haystack 中 needle 的不区分大小写查找。 如果 needle 格式不正确，则返回 null。

语法

参数

  • 无。

返回值

示例

hasTokenOrNull​

引入于: v20.1

类似于 hasToken，但如果 token 格式不正确，则返回 null。

语法

hasTokenOrNull(haystack, token)

参数

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

返回值

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

示例

使用示例

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

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

ilike​

引入于：v20.6

类似于 like，但以不区分大小写的方式搜索。

语法

ilike(haystack, pattern)
-- haystack ILIKE pattern

参数

返回值

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

示例

使用示例

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

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

like​

引入于：v1.1

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

LIKE 表达式可以包含普通字符和以下元符号

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

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

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

不执行自动 Unicode 归一化，可以使用 normalizeUTF8* 函数进行归一化。

要匹配字面量 %、_ 和 \（这些是 LIKE 元字符），请在它们前面加上反斜杠：\%、\_ 和 \\。 如果反斜杠前面紧跟的字符不是 %、_ 或 \，则反斜杠将失去其特殊含义（即按字面意义解释）。

注意

ClickHouse 要求字符串中的反斜杠 也用引号括起来，因此实际上需要编写 \\%、\\_ 和 \\\\。

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

语法

like(haystack, pattern)
-- haystack LIKE pattern

参数

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

返回值

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

示例

使用示例

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

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

单字符通配符

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

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

不匹配的模式

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

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

locate​

引入于: v18.16

类似于 position，但参数 haystack 和 locate 互换。

版本依赖行为

此函数行为取决于 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

示例

基本用法

SELECT locate('ca', 'abcabc')

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

match​

引入于：v1.1

检查提供的字符串是否匹配提供的正则表达式模式。

此函数使用 RE2 正则表达式库。请参阅 re2 以获取支持的语法。

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

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

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

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

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

语法

match(haystack, pattern)

别名：REGEXP_MATCHES

参数

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

返回值

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

示例

基本模式匹配

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

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

模式不匹配

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

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

multiFuzzyMatchAllIndices​

引入于: v20.1

类似于 multiFuzzyMatchAny，但以任何顺序返回匹配 haystack 的所有索引，编辑距离恒定。

语法

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

参数

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

返回值

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

示例

使用示例

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

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

multiFuzzyMatchAny​

引入于: v20.1

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

注意

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

语法

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

参数

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

返回值

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

示例

使用示例

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

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

multiFuzzyMatchAnyIndex​

引入于: v20.1

类似于 multiFuzzyMatchAny，但返回在恒定 编辑距离 内匹配 haystack 的任何索引。

语法

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

参数

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

返回值

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

示例

使用示例

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

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

multiMatchAllIndices​

引入于: v20.1

类似于 multiMatchAny，但以任何顺序返回匹配 haystack 的所有索引。

语法

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

参数

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

返回值

以任何顺序返回所有匹配 haystack 的索引。 如果未找到匹配项，则返回一个空数组。 Array(UInt64)

示例

使用示例

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

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

multiMatchAny​

引入于: v20.1

检查多个正则表达式模式中的至少一个是否匹配 haystack。

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

语法

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

参数

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

返回值

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

示例

多模式匹配

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

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

没有匹配的模式

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

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

multiMatchAnyIndex​

引入于: v20.1

类似于 multiMatchAny，但返回匹配 haystack 的任何索引。

语法

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

参数

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

返回值

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

示例

使用示例

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

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

multiSearchAllPositions​

引入于: v20.1

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

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

语法

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

参数

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

返回值

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

示例

多 needle 搜索

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

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

multiSearchAllPositionsCaseInsensitive​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

不区分大小写的多 needle 搜索

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

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

multiSearchAllPositionsCaseInsensitiveUTF8​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

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

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

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

multiSearchAllPositionsUTF8​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

UTF-8 多 needle 搜索

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

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

multiSearchAny​

引入于: v20.1

检查 haystack 字符串是否至少匹配多个 needle 字符串中的一个。

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

语法

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

参数

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

返回值

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

示例

任意匹配搜索

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

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

multiSearchAnyCaseInsensitive​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

不区分大小写的搜索

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

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

multiSearchAnyCaseInsensitiveUTF8​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

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

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

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

multiSearchAnyUTF8​

引入于: v20.1

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

语法

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

参数

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

返回值

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

示例

给定 '你好，世界' ('Hello, world') 作为 UTF-8 字符串，检查字符串中是否存在任何 你 或 界 字符

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

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

multiSearchFirstIndex​

引入于: v20.1

在 haystack 字符串中搜索多个 needle 字符串（区分大小写），并返回找到的第一个 needle 的从 1 开始的索引。

语法

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

参数

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

返回值

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

示例

使用示例

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

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

区分大小写行为

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

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

未找到匹配项

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

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

multiSearchFirstIndexCaseInsensitive​

引入于: v20.1

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

语法

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

参数

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

返回值

返回 leftmost needle 的索引（从 1 开始）。否则，如果未找到匹配项，则返回 0。 UInt8

示例

使用示例

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

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

multiSearchFirstIndexCaseInsensitiveUTF8​

引入于: v20.1

在 haystack 字符串中搜索多个 needle 字符串，以不区分大小写的方式支持 UTF-8 编码，并返回找到的第一个 needle 的从 1 开始的索引。

语法

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

参数

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

返回值

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

示例

使用示例

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

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

UTF-8 大小写处理

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

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

未找到匹配项

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

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

multiSearchFirstIndexUTF8​

引入于: v20.1

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

语法

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

参数

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

返回值

返回 leftmost needle 的索引（从 1 开始）。否则，如果未找到匹配项，则返回 0。 UInt8

示例

使用示例

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

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

multiSearchFirstPosition​

引入于: v20.1

类似于 position，但返回 haystack 字符串中与多个 needle 字符串中的任何一个匹配的 leftmost offset。

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

语法

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

参数

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

返回值

返回 haystack 字符串中与多个 needle 字符串中的任何一个匹配的 leftmost offset，否则如果未找到匹配项，则返回 0。 UInt64

示例

第一个位置搜索

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

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

multiSearchFirstPositionCaseInsensitive​

引入于: v20.1

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

语法

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

参数

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

返回值

返回 haystack 字符串中与多个 needle 字符串中的任何一个匹配的 leftmost offset。如果未找到匹配项，则返回 0。 UInt64

示例

不区分大小写的第一个位置

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

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

multiSearchFirstPositionCaseInsensitiveUTF8​

引入于: v20.1

类似于 multiSearchFirstPosition，但假定 haystack 和 needle 是 UTF-8 字符串并忽略大小写。

语法

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

参数

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

返回值

返回 haystack 字符串中与多个 needle 字符串中的任何一个匹配的 leftmost offset，忽略大小写。如果未找到匹配项，则返回 0。 UInt64

示例

查找 UTF-8 字符串 'Здравствуй, мир' ('Hello, world') 中与给定 needle 中的任何一个匹配的 leftmost offset

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

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

multiSearchFirstPositionUTF8​

引入于: v20.1

类似于 multiSearchFirstPosition，但假定 haystack 和 needle 是 UTF-8 字符串。

语法

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

参数

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

返回值

haystack 字符串中与多个 needle 字符串中的任何一个匹配的 leftmost offset。如果未找到匹配项，则返回 0。 UInt64

示例

查找 UTF-8 字符串 'Здравствуй, мир' ('Hello, world') 中与给定 needle 中的任何一个匹配的 leftmost offset

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

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

ngramDistance​

引入于: v20.1

计算两个字符串之间的 4-gram 距离。为此，它计算两个多重集 4-gram 之间的对称差，并将其标准化为基数之和。返回的值越小，字符串越相似。

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

语法

ngramDistance(haystack, needle)

参数

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

返回值

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

示例

计算 4-gram 距离

SELECT ngramDistance('ClickHouse', 'ClickHouses')

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

ngramDistanceCaseInsensitive​

引入于: v20.1

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

语法

ngramDistanceCaseInsensitive(haystack, needle)

参数

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

返回值

返回介于 0 和 1 之间的 Float32 数字。 Float32

示例

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

SELECT ngramDistanceCaseInsensitive('ClickHouse','clickhouse')

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

ngramDistanceCaseInsensitiveUTF8​

引入于: v20.1

提供了一个不区分大小写的 UTF-8 变体，用于 ngramDistance。假定 needle 和 haystack 字符串是 UTF-8 编码的字符串，并且忽略大小写。计算两个 UTF-8 字符串之间的 3-gram 距离，忽略大小写。返回值越小，字符串越相似。

语法

ngramDistanceCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

返回介于 0 和 1 之间的 Float32 数字。 Float32

示例

不区分大小写的 UTF-8 3-gram 距离

SELECT ngramDistanceCaseInsensitiveUTF8('abcde','CDE')

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

ngramDistanceUTF8​

引入于: v20.1

提供了一个 UTF-8 变体，用于 ngramDistance。假定 needle 和 haystack 字符串是 UTF-8 编码的字符串。计算两个 UTF-8 字符串之间的 3-gram 距离。返回值越小，字符串越相似。

语法

ngramDistanceUTF8(haystack, needle)

参数

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

返回值

返回介于 0 和 1 之间的 Float32 数字。 Float32

示例

UTF-8 3-gram 距离

SELECT ngramDistanceUTF8('abcde','cde')

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

ngramSearch​

引入于: v20.1

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

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

语法

ngramSearch(haystack, needle)

参数

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

返回值

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

示例

使用 4-grams 进行搜索

SELECT ngramSearch('ClickHouse', 'Click')

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

ngramSearchCaseInsensitive​

引入于: v20.1

提供了一个不区分大小写的 ngramSearch 变体。计算 needle 字符串和 haystack 字符串之间的非对称差异，即 needle 中的 n-grams 数量减去共同的 n-grams 数量，并归一化为 needle n-grams 的数量。检查两个字符串之间的 4-gram 距离是否小于或等于给定的阈值，忽略大小写。

语法

ngramSearchCaseInsensitive(haystack, needle)

参数

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

返回值

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

示例

不区分大小写地使用 4-grams 进行搜索

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

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

ngramSearchCaseInsensitiveUTF8​

引入于: v20.1

提供了一个不区分大小写的 UTF-8 变体，用于 ngramSearch。假定 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-grams 进行 UTF-8 搜索

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

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

ngramSearchUTF8​

引入于: v20.1

提供了一个 UTF-8 变体，用于 ngramSearch。假定 haystack 和 needle 是 UTF-8 字符串。检查两个 UTF-8 字符串之间的 3-gram 距离是否小于或等于给定的阈值。

语法

ngramSearchUTF8(haystack, needle)

参数

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

返回值

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

示例

使用 3-grams 进行 UTF-8 搜索

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

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

notILike​

引入于：v20.6

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

语法

notILike(haystack, pattern)

参数

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

返回值

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

示例

使用示例

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

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

notLike​

引入于：v1.1

类似于 like，但否定了结果。

语法

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

参数

返回值

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

示例

使用示例

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

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

不匹配的模式

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

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

position​

引入于：v1.1

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

如果子字符串 needle 为空，则适用以下规则：

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

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

语法

position(haystack, needle[, start_pos])

参数

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

返回值

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

示例

基本用法

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

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

带有 start_pos 参数

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

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

Needle IN haystack 语法

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

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

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

positionCaseInsensitive​

引入于：v1.1

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

语法

positionCaseInsensitive(haystack, needle[, start_pos])

别名：instr

参数

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

返回值

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

示例

不区分大小写的搜索

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

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

positionCaseInsensitiveUTF8​

引入于：v1.1

类似于 positionUTF8，但以不区分大小写的方式搜索。

语法

positionCaseInsensitiveUTF8(haystack, needle[, start_pos])

参数

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

返回值

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

示例

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

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

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

positionUTF8​

引入于：v1.1

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

语法

positionUTF8(haystack, needle[, start_pos])

参数

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

返回值

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

示例

UTF-8 字符计数

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

┌─position('Motörhead', 'r')─┐
│                          5 │
└────────────────────────────┘
    © . This site is unofficial and not affiliated with ClickHouse, Inc.