跳转到主要内容
以下文档根据 system.functions 系统表生成。

​
alphaTokens

引入版本：v1.1.0 从 a-z 和 A-Z 范围内选取连续字节组成的子字符串，并返回由这些子字符串构成的数组。 语法 
alphaTokens(s[, max_substrings])
别名: splitByAlpha 参数
  • s — 要拆分的字符串。String
  • max_substrings — 可选。当 max_substrings > 0 时，返回的子字符串数量不超过 max_substrings；否则，函数会返回尽可能多的子字符串。Int64
返回值 返回由 s 拆分得到的子字符串数组。Array(String) 示例 使用示例
Query
SELECT alphaTokens('abca1abc');
Response
┌─alphaTokens('abca1abc')─┐
│ ['abca','abc']          │
└─────────────────────────┘

​
arrayStringConcat

引入版本：v1.1.0 将数组中列出的各个值的字符串表示形式用提供的分隔符连接起来；分隔符为可选参数，默认为空字符串。 语法 
arrayStringConcat(arr[, separator])
别名: array_to_string 参数
  • arr — 要拼接的数组。Array(T)
  • separator — 可选。分隔符字符串。默认为空字符串。const String
返回值 返回拼接后的字符串。String 示例 用法示例
Query
SELECT arrayStringConcat(['12/05/2021', '12:50:00'], ' ') AS DateString;
Response
┌─DateString──────────┐
│ 12/05/2021 12:50:00 │
└─────────────────────┘

​
extractAllGroupsVertical

引入版本：v20.5.0 使用正则表达式匹配字符串中的所有分组，并返回一个嵌套数组，其中每个内部数组都包含各分组的匹配片段，并按它们在输入字符串中的出现顺序排列。 语法 
extractAllGroupsVertical(s, regexp)
别名: extractAllGroups 参数 返回值 返回一个嵌套数组，其中每个内部数组都包含一次匹配所捕获的分组。每次匹配都会生成一个数组，其元素对应正则表达式中的各个捕获组 (第 1 组、第 2 组等) 。如果未找到匹配项，则返回空数组。Array(Array(String)) 示例 使用示例
Query
WITH '< Server: nginx
< Date: Tue, 22 Jan 2019 00:26:14 GMT
< Content-Type: text/html; charset=UTF-8
< Connection: keep-alive
' AS s
SELECT extractAllGroupsVertical(s, '< ([\\w\\-]+): ([^\\r\\n]+)');
Response
[['Server','nginx'],['Date','Tue, 22 Jan 2019 00:26:14 GMT'],['Content-Type','text/html; charset=UTF-8'],['Connection','keep-alive']]

​
ngrams

引入版本：v21.11.0 将 UTF-8 字符串拆分为长度为 N 的 n-gram。 语法 
ngrams(s, N)
参数 返回值 返回一个包含 n-gram 的数组。 Array(String) 示例 用法示例
Query
SELECT ngrams('ClickHouse', 3);
Response
['Cli','lic','ick','ckH','kHo','Hou','ous','use']

​
reverseBySeparator

引入于：v26.2.0 将字符串中按指定分隔符分隔的子字符串顺序反转。 此函数会按分隔符拆分字符串，反转得到的各部分顺序， 然后再使用相同的分隔符将它们拼接起来。它适用于解析域名、 文件路径或其他层级结构数据，即需要反转各组成部分顺序的场景。 示例：
  • reverseBySeparator(‘www.google.com’) 返回 ‘com.google.www’
  • reverseBySeparator(‘a/b/c’, ’/’) 返回 ‘c/b/a’
  • reverseBySeparator(‘x::y::z’, ’::’) 返回 ‘z::y::x’
语法 
reverseBySeparator(string[, separator])
参数
  • string — 要反转各部分顺序的输入字符串。String
  • separator — 用于识别各部分的分隔字符串。如果未提供，则使用 ’.’ (点号) 。默认值：’.’ String
返回值 返回一个字符串，其中各子字符串相对于原始字符串按从右到左的顺序排列，并使用相同的分隔符连接。String 示例 基础版域名反转
Query
SELECT reverseBySeparator('www.google.com')
Response
'com.google.www'
路径反转
Query
SELECT reverseBySeparator('a/b/c', '/')
Response
'c/b/a'
自定义分隔符
Query
SELECT reverseBySeparator('x::y::z', '::')
Response
'z::y::x'
点号的特殊情况
Query
SELECT reverseBySeparator('.a.b.', '.')
Response
'.b.a.'
单个元素
Query
SELECT reverseBySeparator('single')
Response
'single'
空分隔符
Query
SELECT reverseBySeparator('abcde', '')
Response
'edcba'

​
splitByChar

引入版本：v1.1.0 将由指定常量字符串 separator (长度必须恰好为 1 个字符) 分隔的字符串拆分为子字符串数组。 如果分隔符出现在字符串的开头或结尾，或者存在多个连续的分隔符，则结果中可能会包含空子字符串。
设置 splitby_max_substrings_includes_remaining_string (默认值：0) 用于控制当参数 max_substrings > 0 时，是否将剩余字符串包含在结果数组的最后一个元素中。
在以下情况下，结果中可能会包含空子字符串：
  • 分隔符出现在字符串的开头或结尾
  • 存在多个连续的分隔符
  • 原始字符串 s 为空
语法 
splitByChar(separator, s[, max_substrings])
参数
  • separator — 分隔符必须是单字节字符。String
  • s — 要拆分的字符串。String
  • max_substrings — 可选。如果 max_substrings > 0，返回的数组最多包含 max_substrings 个子字符串；否则，函数会返回尽可能多的子字符串。默认值为 0。Int64
返回值 返回拆分得到的子字符串数组。Array(String) 示例 用法示例
Query
SELECT splitByChar(',', '1,2,3,abcde');
Response
┌─splitByChar(⋯2,3,abcde')─┐
│ ['1','2','3','abcde']    │
└──────────────────────────┘

​
splitByNonAlpha

引入版本：v21.9.0 将以空白字符和标点符号分隔的字符串拆分为子字符串数组。
设置 splitby_max_substrings_includes_remaining_string (默认值：0) 用于控制当参数 max_substrings > 0 时，是否将剩余字符串包含在结果数组的最后一个元素中。
语法 
splitByNonAlpha(s[, max_substrings])
参数
  • s — 要拆分的字符串。String
  • max_substrings — 可选。当 max_substrings > 0 时，返回的子字符串数量最多为 max_substrings；否则，函数会返回尽可能多的子字符串。默认值：0。Int64
返回值 返回由 s 拆分得到的子字符串数组。Array(String) 示例 用法示例
Query
SELECT splitByNonAlpha('user@domain.com');
Response
['user','domain','com']

​
splitByRegexp

Introduced in: v21.6.0 将按给定正则表达式分隔的字符串拆分为子字符串数组。 如果给定的正则表达式为空，则会将字符串拆分为单个字符组成的数组。 如果未找到与该正则表达式匹配的内容，则不会拆分该字符串。 在以下情况下，结果中可能会包含空子字符串：
  • 非空正则表达式的匹配出现在字符串开头或结尾
  • 存在多个连续的非空正则表达式匹配
  • 原始字符串为空，而正则表达式非空。
设置 splitby_max_substrings_includes_remaining_string (默认值：0) 用于控制当参数 max_substrings > 0 时，是否将剩余字符串包含在结果数组的最后一个元素中。
Syntax 
splitByRegexp(regexp, s[, max_substrings])
参数
  • regexp — 正则表达式。常量。String 或 FixedString
  • s — 要拆分的字符串。String
  • max_substrings — 可选。当 max_substrings > 0 时，返回的子字符串数量不会超过 max_substrings；否则，该函数会返回尽可能多的子字符串。默认值：0。Int64
返回值 返回由 s 分割得到的子字符串数组。Array(String) 示例 使用示例
Query
SELECT splitByRegexp('\\d+', 'a12bc23de345f');
Response
┌─splitByRegex⋯c23de345f')─┐
│ ['a12bc23de345f']        │
└──────────────────────────┘
空的正则表达式
Query
SELECT splitByRegexp('', 'abcde');
Response
┌─splitByRegexp('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

​
splitByString

引入版本：v1.1.0 使用由多个字符组成的常量 separator 将字符串拆分为子字符串数组。 如果字符串 separator 为空，则会将字符串 s 拆分为由单个字符组成的数组。 在以下情况下，结果中可能会包含空子字符串：
  • 非空分隔符出现在字符串的开头或结尾
  • 存在多个连续的非空分隔符
  • 原始字符串 s 为空，而分隔符不为空
设置 splitby_max_substrings_includes_remaining_string (默认值：0) 用于控制：当参数 max_substrings > 0 时，是否将剩余字符串包含在结果数组的最后一个元素中。
语法 
splitByString(separator, s[, max_substrings])
参数
  • separator — 分隔符。String
  • s — 要拆分的字符串。String
  • max_substrings — 可选。当 max_substrings > 0 时，返回的子字符串数量最多为 max_substrings；否则，函数会返回尽可能多的子字符串。默认值：0。Int64
返回值 返回由 s 拆分得到的子字符串数组 Array(String) 示例 使用示例
Query
SELECT splitByString(', ', '1, 2 3, 4,5, abcde');
Response
┌─splitByStrin⋯4,5, abcde')─┐
│ ['1','2 3','4,5','abcde'] │
└───────────────────────────┘
空字符串分隔符
Query
SELECT splitByString('', 'abcde');
Response
┌─splitByString('', 'abcde')─┐
│ ['a','b','c','d','e']      │
└────────────────────────────┘

​
splitByWhitespace

引入版本：v21.9.0 将按空白字符分隔的字符串拆分为子字符串数组。
设置 splitby_max_substrings_includes_remaining_string (默认值：0) 用于控制当参数 max_substrings > 0 时，是否将剩余字符串包含在结果数组的最后一个元素中。
语法 
splitByWhitespace(s[, max_substrings])
参数
  • s — 要拆分的字符串。String
  • max_substrings — 可选。当 max_substrings > 0 时，返回的子字符串数量不超过 max_substrings；否则，函数会返回尽可能多的子字符串。默认值：0。Int64
返回值 返回由 s 拆分得到的子字符串组成的数组。Array(String) 示例 使用示例
Query
SELECT splitByWhitespace('  1!  a,  b.  ');
Response
['1!','a,','b.']

​
tokens

版本引入：v21.11.0 使用给定的分词器将字符串拆分为标记。 可用的分词器：
  • splitByNonAlpha 按非 ASCII 字母数字字符拆分字符串 (另请参见函数 splitByNonAlpha) 。
  • splitByString(S) 按用户定义的分隔符字符串 S 拆分字符串 (另请参见函数 splitByString) 。这些分隔符可通过可选参数指定，例如 tokens(value, 'splitByString', [', ', '; ', '\n', '\\'])。请注意，每个分隔符字符串都可以由多个字符组成 (如示例中的 ', ') 。如果未显式指定，则默认分隔符列表为单个空格 [' ']。
  • asciiCJK 使用 Unicode 单词边界规则 (类似于 UAX #29) 将字符串拆分为标记。ASCII 字母数字字符和下划线会与连接符一起组成标记 (字母使用 :，同类字符使用 . 和 ') 。非 ASCII Unicode 字符会成为单字符标记。
  • ngrams(N) 将字符串拆分为等长的 N-gram (另请参见函数 ngrams) 。可通过 1 到 8 之间的可选整数参数指定 ngram 长度，例如 tokens(value, 'ngrams', 3)。如果未显式指定，则默认 ngram 长度为 3。
  • sparseGrams(min_length, max_length, min_cutoff_length) 将字符串拆分为可变长度的 n-gram，长度最短为 min_length、最长为 max_length (含边界) (另请参见函数 sparseGrams) 。除非显式指定，否则 min_length 和 max_length 默认为 3 和 100。如果提供了参数 min_cutoff_length，则只返回长度大于或等于 min_cutoff_length 的 n-gram。与 ngrams(N) 相比，sparseGrams 分词器会生成可变长度的 N-gram，从而更灵活地表示原始文本。例如，tokens(value, 'sparseGrams', 3, 5, 4) 会在内部基于输入字符串生成 3-、4-、5-gram，但只返回 4- 和 5-gram。
  • array 不执行分词，即每一行的值都是一个标记 (另请参见函数 array) 。
对于 splitByString 分词器，如果这些分隔符不构成前缀码，通常会希望匹配时优先使用更长的分隔符。 为此，请按长度降序传入这些分隔符。 例如，当 separators = ['%21', '%'] 时，字符串 %21abc 会被分词为 ['abc']；而当 separators = ['%', '%21'] 时，则会被分词为 ['21ac'] (这很可能不是你想要的结果) 。 语法 
tokens(value) -- 'splitByNonAlpha' 分词器
tokens(value, 'splitByNonAlpha')
tokens(value, 'splitByString'[, separators])
tokens(value, 'asciiCJK')
tokens(value, 'ngrams'[, n])
tokens(value, 'sparseGrams'[, min_length, max_length[, min_cutoff_length]])
tokens(value, 'array')
参数
  • value — 输入字符串。String 或 FixedString
  • tokenizer — 要使用的分词器。有效参数包括 splitByNonAlpha、splitByString、asciiCJK、ngrams、sparseGrams 和 array。该参数可选；如果未显式设置，则默认为 splitByNonAlpha。const String
  • n — 仅当参数 tokenizer 为 ngrams 时适用：可选参数，用于定义 ngrams 的长度。如果未显式设置，则默认为 3。const UInt8
  • separators — 仅当参数 tokenizer 为 split 时适用：可选参数，用于定义分隔符字符串。如果未显式设置，则默认为 [' ']。const Array(String)
  • min_length — 仅当参数 tokenizer 为 sparseGrams 时适用：可选参数，用于定义最小 gram 长度，默认为 3。const UInt8
  • max_length — 仅当参数 tokenizer 为 sparseGrams 时适用：可选参数，用于定义最大 gram 长度，默认为 100。const UInt8
  • min_cutoff_length — 仅当参数 tokenizer 为 sparseGrams 时适用：可选参数，用于定义最小截断长度。const UInt8
返回值 返回由输入字符串生成的标记数组。Array 示例 默认分词器
Query
SELECT tokens('test1,;\\\\ test2,;\\\\ test3,;\\\\   test4') AS tokens;
Response
['test1','test2','test3','test4']
Ngram 分词器
Query
SELECT tokens('abc def', 'ngrams', 3) AS tokens;
Response
['abc','bc ','c d',' de','def']

​
tokensForLikePattern

引入版本：v26.3.0 使用指定的分词器将 LIKE 模式字符串拆分为标记。 与 tokens 函数不同，此函数能够识别 LIKE 模式的语义 (例如前导和尾随通配符) ，并应用分词器特有的规则， 提取用于模式匹配的有效标记。 它支持与 tokens 函数相同的参数集；tokenizer 之后的其他 参数会根据所选分词器来解释 (例如，ngrams 的 n、splitByString 的 separators， 以及 sparseGrams 的 min_length / max_length [/ min_cutoff_length]) 。 此函数主要用于调试和测试， 并在内部用于分析 LIKE 模式的分词行为。 语法 
tokensForLikePattern(value[, tokenizer[, tokenizer_specific_arguments...]])
参数
  • value — 输入字符串。String 或 FixedString
  • tokenizer — 要使用的分词器。有效参数包括 splitByNonAlpha、splitByString、asciiCJK、ngrams、sparseGrams 和 array。可选；如果未显式设置，则默认为 splitByNonAlpha。const String
  • n — 仅当参数 tokenizer 为 ngrams 时才相关：一个可选参数，用于定义 ngram 的长度。如果未显式设置，则默认为 3。const UInt8
  • separators — 仅当参数 tokenizer 为 split 时才相关：一个可选参数，用于定义分隔符字符串。如果未显式设置，则默认为 [' ']。const Array(String)
  • min_length — 仅当参数 tokenizer 为 sparseGrams 时才相关：一个可选参数，用于定义最小 gram 长度，默认为 3。const UInt8
  • max_length — 仅当参数 tokenizer 为 sparseGrams 时才相关：一个可选参数，用于定义最大 gram 长度，默认为 100。const UInt8
  • min_cutoff_length — 仅当参数 tokenizer 为 sparseGrams 时才相关：一个可选参数，用于定义最小截断长度。const UInt8
返回值 返回从输入字符串生成的标记数组。Array 示例 默认分词器
Query
SELECT tokensForLikePattern('%test1,test2,test3%') AS tokens;
Response
['test2']
最后修改于 2026年6月10日