Skip to content
ClickHouse Docs
ClickHouse DocsClickHouse Docs
49.6kGet Started

字符串搜索函数

View as MarkdownEdit this pageReport an issueSet up docs MCP

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

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

通用字符串函数 和 字符串替换函数 将单独介绍。

countMatches

引入版本：v21.1.0

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

语法

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.0

与 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.0

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

语法

countSubstrings(haystack, needle[, start_pos])

参数

  • haystack — 要在其中执行搜索的 String。String 或 枚举。 - 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.0

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

语法

countSubstringsCaseInsensitive(haystack, needle[, start_pos])

参数

  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。在 haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*

返回值

返回 needle 在 haystack 中出现的次数。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

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

示例

使用示例

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

使用 start_pos 参数

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

extract

Introduced in：v1.1.0

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

此函数使用 RE2 regular expression 库。支持的语法请参阅 re2。

如果正则表达式包含 捕获组 (子模式) ，则函数会返回输入字符串中与第一个 捕获组 匹配的内容。

Syntax

extract(haystack, pattern)

参数

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

返回值

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

示例

从电子邮件地址中提取域名

SELECT extract('test@clickhouse.com', '.*@(.*)$')
┌─extract('test@clickhouse.com', '.*@(.*)$')─┐
│ clickhouse.com                             │
└────────────────────────────────────────────┘

未匹配时返回空字符串

SELECT extract('test@clickhouse.com', 'no_match')
┌─extract('test@clickhouse.com', 'no_match')─┐
│                                            │
└────────────────────────────────────────────┘

extractAll

引入于：v1.1.0

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

如果正则表达式包含捕获组 (子模式) ，则该函数会针对第一个捕获组匹配输入字符串。

语法

extractAll(haystack, pattern)

参数

  • haystack — 要从中提取片段的 String。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('test@example.com, user@domain.org', '([a-zA-Z0-9]+)@')
┌─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))

示例

用法示例

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

Introduced in: v20.5.0

从正则表达式匹配到的第一个子串中提取捕获组。要从所有匹配结果中提取捕获组，请使用 extractAllGroupsHorizontal 或 extractAllGroupsVertical。

Syntax

extractGroups(s, regexp)

参数

返回值

如果正则表达式匹配，则返回一个数组，包含首次匹配中捕获的各组 (1 到 N，其中 N 为 regexp 中捕获组的数量) 。如果没有匹配，则返回空数组。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 extractGroups(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
['Server','nginx']

hasAllTokens

引入版本：v25.10.0

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

在搜索之前，该函数会对文本进行分词处理

  • input 参数 (始终如此) 以及
  • needle 参数 (如果为 String) 会使用为文本索引指定的分词器进行处理。 如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。 如果 needle 参数的类型为 Array(String)，则数组中的每个元素都会被视为一个标记——不会再进行额外的标记化。 如果文本索引配置了预处理器表达式，则会在标记化之前将预处理器应用到 needle (如果其类型为 String) 。 如果文本索引配置了后处理器表达式，则会将后处理器应用到 needle 标记和 input 标记 (即两者都在标记化之后处理) 。

重复的标记将被忽略。 例如，needles = ['ClickHouse', 'ClickHouse'] 与 ['ClickHouse'] 等效。

语法

hasAllTokens(input, needles[, tokenizer])

别名: hasAllToken

参数

返回值

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

示例

使用字符串 needle 的基本用法

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAllTokens(msg, 'a\\d()');
┌─count()─┐
│       1 │
└─────────┘

指定要在数组中按 AS-IS (不分词) 方式搜索的 needles

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAllTokens(msg, ['a', 'd']);
┌─count()─┐
│       1 │
└─────────┘

使用 tokens 函数生成 needles

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAllTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       1 │
└─────────┘

通过第 3 个参数指定自定义分词器

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

数组列和 Map 列的使用示例

DROP TABLE IF EXISTS log;

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

数组列示例

DROP TABLE IF EXISTS log;

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 的示例

DROP TABLE IF EXISTS log;

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(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       1 │
└─────────┘

mapValues 示例

DROP TABLE IF EXISTS log;

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(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       0 │
└─────────┘

hasAnyTokens

引入版本：v25.10.0

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

在搜索之前，该函数会对文本进行分词处理

  • input 参数 (始终如此) ，以及
  • needle 参数 (如果其类型为 String) 会使用为文本索引指定的分词器进行分词。 如果该列未定义文本索引，则会改用 splitByNonAlpha 分词器。 如果 needle 参数的类型为 Array(String)，则会将数组中的每个元素视为一个标记——不会再进行额外标记化。 如果文本索引配置了 预处理器 表达式，则会在标记化前将预处理器应用于 needle (如果其类型为 String)。 如果文本索引配置了 后处理器 表达式，则会在标记化后将后处理器应用于 needle 标记和 input 标记 (即两者都会应用)。

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

语法

hasAnyTokens(input, needles[, tokenizer])

别名: hasAnyToken

参数

返回值

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

示例

使用字符串 needle 的基本示例

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, 'a\\d()');
┌─count()─┐
│       3 │
└─────────┘

指定要在数组中按原样搜索的 needle (不进行分词) 

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, ['a', 'd']);
┌─count()─┐
│       3 │
└─────────┘

使用 tokens 函数生成 needles

DROP TABLE IF EXISTS doc;

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

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

SELECT count() FROM doc WHERE hasAnyTokens(msg, tokens('a()d', 'splitByString', ['()', '\\']));
┌─count()─┐
│       3 │
└─────────┘

数组列和 Map 列的使用示例

DROP TABLE IF EXISTS log;

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

数组列示例

DROP TABLE IF EXISTS log;

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 的示例

DROP TABLE IF EXISTS log;

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(mapKeys(attributes), ['address', 'log_level']);
┌─count()─┐
│       2 │
└─────────┘

使用 mapValues 的示例

DROP TABLE IF EXISTS log;

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(mapValues(attributes), ['192.0.0.1', 'DEBUG']);
┌─count()─┐
│       2 │
└─────────┘

hasPhrase

引入版本：v26.4.0

检查 input 是否按连续顺序包含 phrase 中的所有标记。

搜索前，该函数会使用为 文本索引 指定的分词器，对 input 和 phrase 参数进行标记化。 如果该列未定义 文本索引，则改用 splitByNonAlpha 分词器——除非通过可选的第三个参数提供了分词器。 tokenizer 参数必须是 splitByNonAlpha、splitByString、splitByRegexp、ngrams、asciiCJK 或 icu 之一。 请注意，当 文本索引 还定义了后处理器时，hasPhrase 不支持 splitByRegexp。

与 hasToken、hasAnyTokens 和 hasAllTokens 不同，hasPhrase 要求这些标记按相同顺序连续出现， 中间不能有任何其他标记。例如，hasPhrase('the quick brown fox', 'quick fox') 返回 0， 因为 "brown" 出现在 "quick" 和 "fox" 之间。

语法

hasPhrase(input, phrase[, tokenizer])

别名：matchPhrase

参数

返回值

如果找到该短语对应的连续标记序列，则返回 1；否则返回 0。UInt8

示例

短语匹配

SELECT hasPhrase('the quick brown fox jumps', 'quick brown')
┌─hasPhrase('the quick brown fox jumps', 'quick brown')─┐
│                                                     1 │
└───────────────────────────────────────────────────────┘

不连续标记

SELECT hasPhrase('the quick brown fox jumps', 'quick fox')
┌─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

示例

基本的子序列检查

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

未找到子序列

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

hasSubsequenceCaseInsensitive

引入版本：v23.7.0

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

语法

hasSubsequenceCaseInsensitive(haystack, needle)

参数

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

返回值

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

示例

使用示例

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

hasSubsequenceCaseInsensitiveUTF8

引入版本：v23.7.0

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

语法

hasSubsequenceCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

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

示例

使用示例

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

hasSubsequenceUTF8

引入版本：v23.7.0

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

语法

hasSubsequenceUTF8(haystack, needle)

参数

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

返回值

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

示例

用法示例

SELECT hasSubsequenceUTF8('картошка', 'кошка');
┌─hasSubsequenceUTF8('картошка', 'кошка')─┐
│                                       1 │
└─────────────────────────────────────────┘

不匹配子序列

SELECT hasSubsequenceUTF8('картошка', 'апельсин');
┌─hasSubsequenceUTF8('картошка', 'апельсин')─┐
│                                          0 │
└────────────────────────────────────────────┘

hasToken

引入版本：v20.1.0

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

使用 splitByNonAlpha 作为分词器，也就是说，标记被定义为由连续字符 [0-9A-Za-z_] (数字、ASCII 字符和下划线) 构成的最长子序列。

语法

hasToken(haystack, token)

参数

返回值

如果找到该标记，则返回 1；否则返回 0。UInt8

示例

标记搜索

SELECT hasToken('clickhouse test', 'test')
┌─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)

示例

使用示例

SELECT hasTokenOrNull('apple banana cherry', 'ban ana');
┌─hasTokenOrNull('apple banana cherry', '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

示例

基本高亮

SELECT highlight('The quick brown fox', ['quick', 'fox'])
┌─highlight('The quick brown fox', ['quick', 'fox'])─┐
│ The <em>quick</em> brown <em>fox</em>              │
└────────────────────────────────────────────────────┘

自定义标签

SELECT highlight('Hello World', ['hello'], '<b>', '</b>')
┌─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

示例

使用示例

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

like

引入版本：v1.1.0

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

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

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

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

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

不会自动执行 Unicode 规范化；你可以使用 normalizeUTF8* 函数来完成此操作。

要匹配字面量 %、_ 和 \ (它们是 LIKE 元字符) ，请在它们前面加上反斜杠：\%、\_ 和 \\。 如果反斜杠后面的字符不是 %、_ 或 \，则反斜杠会失去其特殊含义 (即按字面量解释) 。

对于形如 %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

示例

用法示例

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

单字符通配符

SELECT like('ClickHouse', 'Click_ouse');
┌─like('ClickHouse', 'Click_ouse')─┐
│                                1 │
└──────────────────────────────────┘

不匹配模式

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

ESCAPE 子句

SELECT '50%off' LIKE '50#%off' ESCAPE '#';
┌─like('50%off', '50#%off', '#')─┐
│                              1 │
└────────────────────────────────┘

locate

引入版本：v18.16.0

与 position 类似，但参数 haystack 和 locate 的顺序互换了。

语法

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.0

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

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

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

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

模式 不会自动加上锚点。若要匹配整个字符串，请自行使用 ^ 和 $ 对 模式 加锚。

如果你只是想搜索子字符串，可以改用函数 like 或 position，它们的速度比此函数快得多。

可选的运算符语法：haystack REGEXP pattern 或 haystack ~ pattern (PostgreSQL 风格) 。

语法

match(haystack, pattern)

别名: REGEXP_MATCHES

参数

  • haystack — 在其中搜索模式的 String。String
  • pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值

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

示例

基本模式匹配

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

模式不匹配

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

匹配子串

SELECT match('abcde', 'b.*d'), match('abcde', '^b.*d$')
┌─match('abcde', 'b.*d')─┬─match('abcde', '^b.*d$')─┐
│                      1 │                        0 │
└────────────────────────┴──────────────────────────┘

matchCaseInsensitive

引入版本：v26.8.0

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

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

可选的运算符语法：haystack ~* pattern (PostgreSQL 风格) 。

语法

matchCaseInsensitive(haystack, pattern)
-- haystack ~* pattern

参数

  • haystack — 在其中搜索模式的 String。String
  • pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值

如果不区分大小写地匹配该模式，则返回 1，否则返回 0。UInt8

示例

使用示例

SELECT matchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' ~
┌─matchCaseInsensitive('Hello World', 'hello.*')─┬─matchCaseInsensitive('Hello World', 'HELLO.*')─┐
│                                              1 │                                              1 │
└────────────────────────────────────────────────┴────────────────────────────────────────────────┘

multiFuzzyMatchAllIndices

引入版本：v20.1.0

与 multiFuzzyMatchAny 类似，但会返回在固定编辑距离内与 haystack 匹配的所有索引组成的数组，顺序不限。

语法

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

参数

  • haystack — 执行搜索的 String。String
  • distance — 模糊匹配允许的最大编辑距离。UInt8
  • pattern — 要匹配的模式数组。Array(String)

返回值

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

示例

使用示例

SELECT multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House']);
┌─multiFuzzyMatchAllIndices('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose', 'House'])─┐
│ [3,1,4,2]                                                                                     │
└───────────────────────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAny

引入版本：v20.1.0

与 multiMatchAny 类似，但如果任意模式在固定的编辑距离内匹配 haystack，则返回 1。 此函数依赖 hyperscan 库的 Experimental 功能，在某些边缘情况下可能较慢。 其性能取决于编辑距离的取值和所使用的模式，但与非模糊变体相比，开销始终更高。

语法

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

参数

  • haystack — 执行搜索的 String。String
  • distance — 模糊匹配 的最大编辑距离。UInt8
  • pattern — 可选。用于匹配的模式数组。Array(String)

返回值

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

示例

使用示例

SELECT multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose']);
┌─multiFuzzyMatchAny('ClickHouse', 2, ['ClickHouse', 'ClckHouse', 'ClickHose'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

multiFuzzyMatchAnyIndex

引入于：v20.1.0

与 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']);
┌─multiFuzzyMatchAnyIndex('ClickHouse', 2, ['ClckHouse', 'ClickHose', 'ClickHouse'])─┐
│                                                                                  2 │
└────────────────────────────────────────────────────────────────────────────────────┘

multiMatchAllIndices

引入版本：v20.1.0

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

语法

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

参数

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

返回值

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

示例

使用示例

SELECT multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse']);
┌─multiMatchAllIndices('ClickHouse', ['[0-9]', 'House', 'Click', 'ouse'])─┐
│ [3,2,4]                                                                 │
└─────────────────────────────────────────────────────────────────────────┘

multiMatchAny

引入版本：v20.1.0

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

如果你只想在一个字符串中搜索多个子字符串，可以改用函数 multiSearchAny——它的速度比此函数快得多。

语法

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

参数

  • haystack — 在其中搜索模式的 String。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.0

与 multiMatchAny 类似，但会返回任意一个与 haystack 匹配的索引。

语法

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

参数

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

返回值

返回第一个匹配 pattern 的索引 (从 1 开始) ；如果未找到匹配项，则返回 0。UInt64

示例

使用示例

SELECT multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', 'Click']);
┌─multiMatchAnyIndex('ClickHouse', ['[0-9]', 'House', '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 搜索

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])
┌─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)

示例

不区分大小写的多重搜索

SELECT multiSearchAllPositionsCaseInsensitive('ClickHouse',['c','h'])
┌─multiSearchAllPositionsCaseInsensitive('ClickHouse', ['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 搜索

SELECT multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР']);
┌─multiSearchAllPositionsCaseInsensitiveUTF8('Здравствуй, мир!', ['здравствуй', 'МИР'])─┐
│ [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 多重搜索

SELECT multiSearchAllPositionsUTF8('ClickHouse',['C','H'])
┌─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

示例

任意匹配查找

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

multiSearchAnyCaseInsensitive

引入版本：v20.1.0

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

语法

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

参数

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

返回值

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

示例

不区分大小写的搜索

SELECT multiSearchAnyCaseInsensitive('ClickHouse',['c','h'])
┌─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 字符串 'Здравствуйте'，检查是否包含字符 'з' (小写) 

SELECT multiSearchAnyCaseInsensitiveUTF8('Здравствуйте',['з'])
┌─multiSearchAnyCaseInsensitiveUTF8('Здравствуйте', ['з'])─┐
│                                                        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') ，检查该字符串中是否包含字符 你 或 界

SELECT multiSearchAnyUTF8('你好，世界', ['你', '界']) AS result
┌─result─┐
│      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

示例

用法示例

SELECT multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['Click', 'Database', 'Server'])─┐
│                                                                             1 │
└───────────────────────────────────────────────────────────────────────────────┘

区分大小写

SELECT multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server']);
┌─multiSearchFirstIndex('ClickHouse Database', ['CLICK', 'Database', 'Server'])─┐
│                                                                             2 │
└───────────────────────────────────────────────────────────────────────────────┘

未找到匹配项

SELECT multiSearchFirstIndex('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndex('Hello World', ['goodbye', '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

示例

使用示例

SELECT multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', 'Hello']);
┌─multiSearchFirstIndexCaseInsensitive('hElLo WoRlD', ['World', '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

示例

用法示例

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('ClickHouse Database', ['CLICK', 'data', 'server'])─┐
│                                                                                            1 │
└──────────────────────────────────────────────────────────────────────────────────────────────┘

UTF-8 字母大小写处理

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Привет Мир', ['мир', 'ПРИВЕТ'])─┐
│                                                                         1 │
└───────────────────────────────────────────────────────────────────────────┘

未找到匹配结果

SELECT multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', 'test']);
┌─multiSearchFirstIndexCaseInsensitiveUTF8('Hello World', ['goodbye', '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

示例

使用示例

SELECT multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте']);
┌─multiSearchFirstIndexUTF8('Здравствуйте мир', ['мир', 'здравствуйте'])─┐
│                                                                      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

示例

搜索首个位置

SELECT multiSearchFirstPosition('Hello World',['llo', 'Wor', 'ld'])
┌─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

示例

大小写不敏感的第一个位置

SELECT multiSearchFirstPositionCaseInsensitive('HELLO WORLD',['wor', 'ld', 'ello'])
┌─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 中任意一个匹配的最左侧偏移量

SELECT multiSearchFirstPositionCaseInsensitiveUTF8('Здравствуй, мир', ['МИР', 'вст', 'Здра'])
┌─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 匹配的最左侧偏移量

SELECT multiSearchFirstPositionUTF8('Здравствуй, мир',['мир', 'вст', 'авст'])
┌─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 距离

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

ngramDistanceCaseInsensitive

引入版本：v20.1.0

提供 ngramDistance 的不区分大小写 Variant。 计算两个字符串之间的 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.0

提供 ngramDistance 的不区分大小写 UTF-8 Variant。 假定 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.0

提供 ngramDistance 的 UTF-8 Variant。 假定 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.0

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

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

语法

ngramSearch(haystack, needle)

参数

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

返回值

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

示例

使用 4-gram 进行搜索

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

ngramSearchCaseInsensitive

引入版本：v20.1.0

提供 ngramSearch 的不区分大小写 Variant。 计算 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 的不区分大小写搜索

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

ngramSearchCaseInsensitiveUTF8

引入版本：v20.1.0

提供 ngramSearch 的不区分大小写 UTF-8 Variant。 假定 haystack 和 needle 为 UTF-8 字符串，并且不区分大小写。 检查两个 UTF-8 字符串之间的 3-gram 距离是否小于或等于给定阈值，且不区分大小写。

语法

ngramSearchCaseInsensitiveUTF8(haystack, needle)

参数

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

返回值

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

示例

使用 3-gram 的不区分大小写 UTF-8 搜索

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

ngramSearchUTF8

引入版本：v20.1.0

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

语法

ngramSearchUTF8(haystack, needle)

参数

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

返回值

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

示例

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

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

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

示例

用法示例

SELECT notILike('ClickHouse', '%house%');
┌─notILike('ClickHouse', '%house%')─┐
│                                 0 │
└───────────────────────────────────┘

notLike

Introduced in：v1.1.0

与 like 类似，但会返回相反的结果。支持可选的 ESCAPE 子句 (参见 like) 。

语法

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

示例

使用示例

SELECT notLike('ClickHouse', '%House%');
┌─notLike('ClickHouse', '%House%')─┐
│                                0 │
└──────────────────────────────────┘

不匹配的模式

SELECT notLike('ClickHouse', '%SQL%');
┌─notLike('ClickHouse', '%SQL%')─┐
│                              1 │
└────────────────────────────────┘

notMatch

引入版本：v26.8.0

与 match 类似，但会对结果取反：检查字符串是否不匹配正则表达式模式。

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

可选的运算符语法：haystack !~ pattern (PostgreSQL 风格) 。

语法

notMatch(haystack, pattern)
-- haystack !~ pattern

参数

  • haystack — 在其中搜索模式的 String。String
  • pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值

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

示例

使用示例

SELECT notMatch('Hello World', 'Hello.*'), 'Hello World' !
┌─notMatch('Hello World', 'Hello.*')─┬─notMatch('Hello World', 'goodbye.*')─┐
│                                  0 │                                    1 │
└────────────────────────────────────┴──────────────────────────────────────┘

notMatchCaseInsensitive

引入版本：v26.8.0

与 matchCaseInsensitive 类似，但会对结果取反：检查字符串是否不与正则表达式模式进行不区分大小写的匹配。

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

可选的运算符语法：haystack !~* pattern (PostgreSQL 风格) 。

语法

notMatchCaseInsensitive(haystack, pattern)
-- haystack !~* pattern

参数

  • haystack — 在其中搜索模式的 String。String
  • pattern — 正则表达式模式。可以是常量，也可以来自列。String

返回值

如果不区分大小写地匹配该模式，则返回 0，否则返回 1。UInt8

示例

使用示例

SELECT notMatchCaseInsensitive('Hello World', 'hello.*'), 'Hello World' !
┌─notMatchCaseInsensitive('Hello World', 'hello.*')─┬─notMatchCaseInsensitive('Hello World', 'GOODBYE.*')─┐
│                                                 0 │                                                   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

示例

基本用法

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.0

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

语法

positionCaseInsensitive(haystack, needle[, start_pos])

别名: instr

参数

  • haystack — 执行搜索的字符串。String 或 枚举
  • needle — 要搜索的子串。String
  • start_pos — 可选。haystack 中开始搜索的位置 (从 1 开始计数) 。UInt*

返回值

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

示例

不区分大小写的搜索

SELECT positionCaseInsensitive('Hello, world!', 'hello')
┌─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 搜索

SELECT positionCaseInsensitiveUTF8('Привет мир', 'МИР')
┌─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 字符计数

SELECT positionUTF8('Motörhead', 'r')
┌─positionUTF8('Motörhead', 'r')─┐
│                              5 │
└────────────────────────────────┘
Navigation