You need to enable JavaScript to run this app.
导航

字符函数

最近更新时间2022.12.19 15:11:00

首次发布时间2022.12.19 15:11:00

splitByChar(separator,s)

将字符串以’separator’拆分成多个子串。’separator’必须为仅包含一个字符的字符串常量。 返回拆分后的子串的数组。 如果分隔符出现在字符串的开头或结尾,或者如果有多个连续的分隔符,则将在对应位置填充空的子串。

splitByString(separator,s)

与上面相同,但它使用多个字符的字符串作为分隔符。 该字符串必须为非空。

arrayStringConcat(arr[,separator])

使用separator将数组中列出的字符串拼接起来。’separator’是一个可选参数:一个常量字符串,默认情况下设置为空字符串。 返回拼接后的字符串。

alphaTokens(s)

从范围a-z和A-Z中选择连续字节的子字符串。返回子字符串数组。
示例:

SELECT alphaTokens('abca1abc')

┌─alphaTokens('abca1abc')─┐
│ ['abca','abc']          │
└─────────────────────────┘

empty

对于空字符串返回1,对于非空字符串返回0。 结果类型是UInt8。 如果字符串包含至少一个字节,则该字符串被视为非空字符串,即使这是一个空格或空字符。 该函数也适用于数组。

notEmpty

对于空字符串返回0,对于非空字符串返回1。 结果类型是UInt8。 该函数也适用于数组。

length

返回字符串的字节长度。 结果类型是UInt64。 该函数也适用于数组。

lengthUTF8

假定字符串以UTF-8编码组成的文本,返回此字符串的Unicode字符长度。如果传入的字符串不是UTF-8编码,则函数可能返回一个预期外的值(不会抛出异常)。 结果类型是UInt64。

char_length,CHAR_LENGTH

假定字符串以UTF-8编码组成的文本,返回此字符串的Unicode字符长度。如果传入的字符串不是UTF-8编码,则函数可能返回一个预期外的值(不会抛出异常)。 结果类型是UInt64。

character_length,CHARACTER_LENGTH

假定字符串以UTF-8编码组成的文本,返回此字符串的Unicode字符长度。如果传入的字符串不是UTF-8编码,则函数可能返回一个预期外的值(不会抛出异常)。 结果类型是UInt64。

lower, lcase

将字符串中的ASCII转换为小写。

upper, ucase

将字符串中的ASCII转换为大写。

lowerUTF8

将字符串转换为小写,函数假设字符串是以UTF-8编码文本的字符集。 同时函数不检测语言。因此对土耳其人来说,结果可能不完全正确。 如果UTF-8字节序列的长度对于代码点的大写和小写不同,则该代码点的结果可能不正确。 如果字符串包含一组非UTF-8的字节,则将引发未定义行为。

upperUTF8

将字符串转换为大写,函数假设字符串是以UTF-8编码文本的字符集。 同时函数不检测语言。因此对土耳其人来说,结果可能不完全正确。 如果UTF-8字节序列的长度对于代码点的大写和小写不同,则该代码点的结果可能不正确。 如果字符串包含一组非UTF-8的字节,则将引发未定义行为。

isValidUTF8

检查字符串是否为有效的UTF-8编码,是则返回1,否则返回0。

toValidUTF8

(U+FFFD)字符替换无效的UTF-8字符。所有连续的无效字符都会被替换为一个替换字符。

toValidUTF8( input_string )

参数:

  • input_string — 任何一个字符串类型的对象。

返回值: 有效的UTF-8字符串。

示例

SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
暂时无法在飞书文档外展示此内容

reverse

反转字符串。

reverseUTF8

以Unicode字符为单位反转UTF-8编码的字符串。如果字符串不是UTF-8编码,则可能获取到一个非预期的结果(不会抛出异常)。

format(pattern, s0, s1, …)

使用常量字符串pattern格式化其他参数。pattern字符串中包含由大括号{}包围的«替换字段»。 未被包含在大括号中的任何内容都被视为文本内容,它将原样保留在返回值中。 如果你需要在文本内容中包含一个大括号字符,它可以通过加倍来转义:{{ '{{' }}{{ '{{' }} '}}' }}。 字段名称可以是数字(从零开始)或空(然后将它们视为连续数字)
SELECT format('{1} {0} {1}', 'World', 'Hello') ┌─format('{1} {0} {1}', 'World', 'Hello')─┐ │ Hello World Hello │ └─────────────────────────────────────────┘ SELECT format('{} {}', 'Hello', 'World') ┌─format('{} {}', 'Hello', 'World')─┐ │ Hello World │ └───────────────────────────────────┘

concat(s1, s2, …)

将参数中的多个字符串拼接,不带分隔符。

concatAssumeInjective(s1, s2, …)

concat相同,区别在于,你需要保证concat(s1, s2, s3) -> s4是单射的,它将用于GROUP BY的优化。

substring(s,offset,length),mid(s,offset,length),substr(s,offset,length) {#substrings-offset-length-mids-offset-length-substrs-offset-length}

以字节为单位截取指定位置字符串,返回以’offset’位置为开头,长度为’length’的子串。’offset’从1开始(与标准SQL相同)。’offset’和’length’参数必须是常量。

substringUTF8(s,offset,length)

与’substring’相同,但其操作单位为Unicode字符,函数假设字符串是以UTF-8进行编码的文本。如果不是则可能返回一个预期外的结果(不会抛出异常)。

appendTrailingCharIfAbsent(s,c)

如果’s’字符串非空并且末尾不包含’c’字符,则将’c’字符附加到末尾。

convertCharset(s,from,to)

返回从’from’中的编码转换为’to’中的编码的字符串’s’。

base64Encode(s)

将字符串’s’编码成base64

base64Decode(s)

使用base64将字符串解码成原始字符串。如果失败则抛出异常。

tryBase64Decode(s)

使用base64将字符串解码成原始字符串。但如果出现错误,将返回空字符串。

endsWith(s, suffix)

返回是否以指定的后缀结尾。如果字符串以指定的后缀结束,则返回1,否则返回0。

startsWith(s,prefix)

返回是否以指定的前缀开头。如果字符串以指定的前缀开头,则返回1,否则返回0。

trimLeft(s)

返回一个字符串,用于删除左侧的空白字符。

trimRight(s)

返回一个字符串,用于删除右侧的空白字符。

trimBoth(s)

返回一个字符串,用于删除任一侧的空白字符。

replaceOne(haystack, pattern, replacement)

用’replacement’子串替换’haystack’中第一次出现的’pattern’子串(如果存在)。 ’pattern’和’replacement’必须是常量。

replaceAll(haystack, pattern, replacement), replace(haystack, pattern, replacement)

用’replacement’子串替换’haystack’中出现的所有的’pattern’子串。

replaceRegexpOne(haystack, pattern, replacement)

使用’pattern’正则表达式的替换。 ‘pattern’可以是任意一个有效的re2正则表达式。 如果存在与’pattern’正则表达式匹配的匹配项,仅替换第一个匹配项。 模式pattern可以指定为‘replacement’。此模式可以包含替代\0-\9。 替代\0包含了整个正则表达式。替代\1-\9对应于子模式编号。要在模板中使用反斜杠\,请使用\将其转义。 另外还请记住,字符串字面值(literal)需要额外的转义。
示例1.将日期转换为美国格式:
SELECT DISTINCT EventDate, replaceRegexpOne(toString(EventDate), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1') AS res FROM test.hitsLIMIT 7 FORMAT TabSeparated

2014-03-17      03/17/2014
2014-03-18      03/18/2014
2014-03-19      03/19/2014
2014-03-20      03/20/2014
2014-03-21      03/21/2014
2014-03-22      03/22/2014
2014-03-23      03/23/2014

示例2.复制字符串十次:
SELECT replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0') AS res

┌─res────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World! │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

replaceRegexpAll(haystack, pattern, replacement)

与replaceRegexpOne相同,但会替换所有出现的匹配项。例如:
SELECT replaceRegexpAll('Hello, World!', '.', '\\0\\0') AS res

┌─res────────────────────────┐
│ HHeelllloo,,  WWoorrlldd!! │
└────────────────────────────┘

作为例外,对于空子字符串,正则表达式只会进行一次替换。 示例:
SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res

┌─res─────────────────┐
│ here: Hello, World! │
└─────────────────────┘

regexpQuoteMeta(s)

该函数用于在字符串中的某些预定义字符之前添加反斜杠。 预定义字符:\0, \\, |, (, ), ^, $, ., [, ], ?, *, +, {, :, -。 这个实现与re2::RE2::QuoteMeta略有不同。它以\0 转义零字节,而不是\x00,并且只转义必需的字符。 有关详细信息,请参阅链接:RE2

下列所有函数在默认的情况下区分大小写。对于不区分大小写的搜索,存在单独的变体。

position(haystack, needle), locate(haystack, needle)

在字符串haystack中搜索子串needle。 返回子串的位置(以字节为单位),从1开始,如果未找到子串,则返回0。
对于不区分大小写的搜索,请使用函数positionCaseInsensitive

positionUTF8(haystack, needle)

position相同,但位置以Unicode字符返回。此函数工作在UTF-8编码的文本字符集中。如非此编码的字符集,则返回一些非预期结果(他不会抛出异常)。
对于不区分大小写的搜索,请使用函数positionCaseInsensitiveUTF8

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

position相同,但函数返回一个数组,其中包含所有匹配needle(我)的位置。
对于不区分大小写的搜索或/和UTF-8格式,使用函数multiSearchAllPositionsCaseInsensitive,multiSearchAllPositionsUTF8,multiSearchAllPositionsCaseInsensitiveUTF8

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

position相同,但返回在haystack中与needles字符串匹配的最左偏移。
对于不区分大小写的搜索或/和UTF-8格式,使用函数multiSearchFirstPositionCaseInsensitive,multiSearchFirstPositionUTF8,multiSearchFirstPositionCaseInsensitiveUTF8

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

返回在字符串haystack中最先查找到的needle 的索引i(从1开始),没有找到任何匹配项则返回0。
对于不区分大小写的搜索或/和UTF-8格式,使用函数multiSearchFirstIndexCaseInsensitive,multiSearchFirstIndexUTF8,multiSearchFirstIndexCaseInsensitiveUTF8

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

如果haystack中至少存在一个needle(我)匹配则返回1,否则返回0。
对于不区分大小写的搜索或/和UTF-8格式,使用函数multiSearchAnyCaseInsensitive,multiSearchAnyUTF8,multiSearchAnyCaseInsensitiveUTF8
!!! note "注意" 在所有multiSearch*函数中,由于实现规范,needles的数量应小于2(8)。

match(haystack, pattern)

检查字符串是否与pattern正则表达式匹配。pattern可以是一个任意的re2正则表达式。 re2正则表达式的语法比Perl正则表达式的语法存在更多限制。
如果不匹配返回0,否则返回1。
请注意,反斜杠符号(\)用于在正则表达式中转义。由于字符串中采用相同的符号来进行转义。因此,为了在正则表达式中转义符号,必须在字符串文字中写入两个反斜杠(\)。
正则表达式与字符串一起使用,就像它是一组字节一样。正则表达式中不能包含空字节。 对于在字符串中搜索子字符串的模式,最好使用LIKE或«position»,因为它们更加高效。

multiMatchAny(haystack, [pattern(1), pattern(2), …, pattern(n)])

match相同,但如果所有正则表达式都不匹配,则返回0;如果任何模式匹配,则返回1。它使用超扫描库。对于在字符串中搜索子字符串的模式,最好使用«multisearchany»,因为它更高效。
!!! note "注意" 任何haystack字符串的长度必须小于2(32</ sup>字节,否则抛出异常。这种限制是因为hyperscan API而产生的。)

multiMatchAnyIndex(haystack, [pattern(1), pattern(2), …, pattern(n)])

multiMatchAny相同,但返回与haystack匹配的任何内容的索引位置。

multiFuzzyMatchAny(haystack, [pattern(1), pattern(2), …, pattern(n)])

multiMatchAny相同,但如果在haystack能够查找到任何模式匹配能够在指定的编辑距离内进行匹配,则返回1。此功能也处于实验模式,可能非常慢。有关更多信息,请参阅hyperscan文档

multiFuzzyMatchAnyIndex(haystack, [pattern(1), pattern(2), …, pattern(n)])

multiFuzzyMatchAny相同,但返回匹配项的匹配能容的索引位置。
!!! note "注意" multiFuzzyMatch*函数不支持UTF-8正则表达式,由于hyperscan限制,这些表达式被按字节解析。
!!! note "注意" 如要关闭所有hyperscan函数的使用,请设置SET allow_hyperscan = 0;

extract(haystack, pattern)

使用正则表达式截取字符串。如果’haystack’与’pattern’不匹配,则返回空字符串。如果正则表达式中不包含子模式,它将获取与整个正则表达式匹配的子串。否则,它将获取与第一个子模式匹配的子串。

extractAllt(haystack, pattern)

使用正则表达式提取字符串的所有片段。如果’haystack’与’pattern’正则表达式不匹配,则返回一个空字符串。否则返回所有与正则表达式匹配的字符串数组。通常,行为与’extract’函数相同(它采用第一个子模式,如果没有子模式,则采用整个表达式)。

like(haystack, pattern), haystack LIKE pattern operator

检查字符串是否与简单正则表达式匹配。 正则表达式可以包含的元符号有_
% 表示任何字节数(包括零字符)。
_ 表示任何一个字节。
可以使用反斜杠(\)来对元符号进行转义。请参阅«match»函数说明中有关转义的说明。
对于像%needle%这样的正则表达式,改函数与position函数一样快。 对于其他正则表达式,函数与’match’函数相同。

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

与’like’函数返回相反的结果。

ngramDistance(haystack, needle)

基于4-gram计算haystackneedle之间的距离:计算两个4-gram集合之间的对称差异,并用它们的基数和对其进行归一化。返回0到1之间的任何浮点数 – 越接近0则表示越多的字符串彼此相似。如果常量的needlehaystack超过32KB,函数将抛出异常。如果非常量的haystackneedle字符串超过32Kb,则距离始终为1。
对于不区分大小写的搜索或/和UTF-8格式,使用函数ngramDistanceCaseInsensitive,ngramDistanceUTF8,ngramDistanceCaseInsensitiveUTF8