用于在字符串中进行搜索和替换的函数将在其他章节中单独介绍。
以下文档由 system.functions 系统表自动生成。
0xffffffff (zlib 实现) 计算字符串的 CRC32 校验和。
语法
参数
返回值
返回该字符串的 CRC32 校验和。UInt32
示例
使用示例
SELECT CRC32('ClickHouse')
┌─CRC32('ClickHouse')─┐
│ 1538217360 │
└─────────────────────┘
s — 用于计算 CRC32 的 String。String
返回值
返回该字符串的 CRC32 校验和。UInt32
示例
使用示例
SELECT CRC32IEEE('ClickHouse');
┌─CRC32IEEE('ClickHouse')─┐
│ 3089448422 │
└─────────────────────────┘
UInt64
示例
使用示例
SELECT CRC64('ClickHouse');
┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘
appendTrailingCharIfAbsent
s 非空且末尾不是字符 c，则在其末尾追加字符 c。
语法
appendTrailingCharIfAbsent(s, c)
s 不以字符 c 结尾，则返回在其末尾追加了字符 c 的字符串。String
示例
使用示例
SELECT appendTrailingCharIfAbsent('https://example.com', '/');
┌─appendTraili⋯.com', '/')─┐
│ https://example.com/ │
└──────────────────────────┘
s 中第一个字符的 ASCII 码点，返回类型为 Int32。
语法
参数
返回值
返回第一个字符的 ASCII 码点。如果 s 为空，结果为 0。如果第一个字符不是 ASCII 字符，或者不在 UTF-16 的 Latin-1 补充范围内，则结果未定义。Int32
示例
使用示例
┌─ascii('234')─┐
│ 50 │
└──────────────┘
encoded — String 类型的列或常量。String
返回值
返回一个字符串，其中包含该参数解码后的值。String
示例
使用示例
SELECT base32Decode('IVXGG33EMVSA====');
┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└──────────────────────────────────┘
String 或 FixedString
示例
使用示例
SELECT base32Encode('Encoded')
┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA==== │
└─────────────────────────┘
expected_size，以选择经过优化的固定大小解码器。
目前支持的值为 32 和 64。对于其他值，会使用通用解码器。
当选择了优化解码器，但输入无法被解码为恰好对应字节数时，
该函数会抛出异常 (对于 tryBase58Decode，则返回空字符串) 。
语法
base58Decode(encoded[, expected_size])
String
示例
使用示例
SELECT base58Decode('JxF12TrwUP45BMd');
┌─base58Decode⋯rwUP45BMd')─┐
│ Hello World │
└──────────────────────────┘
String
示例
使用示例
SELECT base58Encode('ClickHouse');
┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx │
└────────────────────────────┘
FROM_BASE64
参数
encoded — 要解码的 String 类型列或常量。如果该字符串不是有效的 Base64 编码，则会抛出异常。String
返回值
返回解码后的字符串。String
示例
使用示例
SELECT base64Decode('Y2xpY2tob3VzZQ==')
┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└──────────────────────────────────┘
TO_BASE64
参数
返回值
返回包含该参数编码值的字符串。String
示例
使用示例
SELECT base64Encode('clickhouse')
┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ== │
└────────────────────────────┘
encoded — 要进行编码的 String 类型列或常量。如果该字符串不是有效的 Base64 编码字符串，则会抛出异常。String
返回值
返回一个包含该参数解码后值的字符串。String
示例
用法示例
SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
┌─base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└───────────────────────────────────────────────────┘
base64URLEncode(plaintext)
String
示例
使用示例
SELECT base64URLEncode('https://clickhouse.com')
┌─base64URLEncode('https://clickhouse.com')─┐
│ aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ │
└───────────────────────────────────────────┘
String
示例
从 Unix 路径中提取文件名
SELECT 'some/long/path/to/file' AS a, basename(a)
┌─a──────────────────────┬─basename('some/long/path/to/file')─┐
│ some/long/path/to/file │ file │
└────────────────────────┴────────────────────────────────────┘
SELECT 'some\\long\\path\\to\\file' AS a, basename(a)
┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐
│ some\long\path\to\file │ file │
└────────────────────────┴────────────────────────────────────────┘
SELECT 'some-file-name' AS a, basename(a)
┌─a──────────────┬─basename('some-file-name')─┐
│ some-file-name │ some-file-name │
└────────────────┴────────────────────────────┘
byteHammingDistance(s1, s2)
mismatches
参数
返回值
返回这两个字符串之间的 Hamming 距离。UInt64
示例
使用示例
SELECT byteHammingDistance('karolin', 'kathrin')
┌─byteHammingDistance('karolin', 'kathrin')─┐
│ 3 │
└───────────────────────────────────────────┘
ffi 这样的某些连字仍会被分解，因为 Unicode 大小写折叠本身就会将其展开。
Syntax
参数
返回值
进行大小写折叠后的 UTF-8 字符串。String
示例
基本的大小写折叠
SELECT caseFoldUTF8('Straße')
┌─caseFoldUTF8('Straße')─┐
│ strasse │
└─────────────────────────┘
compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)
s1 — 要比较的第一个字符串。Strings2 — 要比较的第二个字符串。Strings1_offset — 在 s1 中开始比较的位置 (从零开始) 。UInt*s2_offset — 在 s2 中开始比较的位置 (索引从零开始) 。UInt*num_bytes — 两个字符串中参与比较的最大字节数。如果 s1_offset (或 s2_offset) + num_bytes 超过输入字符串末尾，num_bytes 会相应减小。UInt*
返回值
返回：
- 如果
s1[s1_offset : s1_offset + num_bytes] < s2[s2_offset : s2_offset + num_bytes]，则返回 -1。
- 如果
s1[s1_offset : s1_offset + num_bytes] = s2[s2_offset : s2_offset + num_bytes]，则返回 0。
- 如果
s1[s1_offset : s1_offset + num_bytes] > s2[s2_offset : s2_offset + num_bytes]，则返回 1。
Int8
示例
使用示例
SELECT compareSubstrings('Saxony', 'Anglo-Saxon', 0, 6, 5) AS result
┌─result─┐
│ 0 │
└────────┘
String 或 FixedString 类型的参数，会使用其默认序列化方式转换为字符串。
由于这会降低性能，因此不建议使用非 String/FixedString 参数。
语法
参数
s1, s2, ... — 任意数量、任意类型的值。Any
返回值
返回将这些参数连接后生成的 String。如果任一参数为 NULL，函数将返回 NULL。如果没有参数，则返回空字符串。Nullable(String)
示例
字符串拼接
SELECT concat('Hello, ', 'World!')
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
┌─concat(42, 144)─┐
│ 42144 │
└─────────────────┘
concat 类似，但假定 concat(s1, s2, ...) → sn 是单射，
也就是说，对于不同的参数会返回不同的结果。
可用于优化 GROUP BY。
Syntax
concatAssumeInjective([s1, s2, ...])
NULL，函数返回 NULL。如果未传入任何参数，则返回空字符串。String
示例
Group By 优化
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2)
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└────────────────────┴────────────┘
concatWithSeparator(sep[, exp1, exp2, ...])
concat_ws
参数
sep — 使用的分隔符。const String 或 const FixedStringexp1, exp2, ... — 要拼接的表达式。不属于 String 或 FixedString 类型的参数会通过其默认序列化转换为字符串。由于这会降低性能，因此不建议使用非 String/FixedString 参数。Any
返回值
返回由拼接这些参数得到的 String。如果任一参数值为 NULL，函数将返回 NULL。String
示例
使用示例
SELECT concatWithSeparator('a', '1', '2', '3', '4')
┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4 │
└──────────────────────────────────────────────┘
concatWithSeparatorAssumeInjective
concatWithSeparator 类似，但假定 concatWithSeparator(sep[,exp1, exp2, ... ]) → result 是单射。
如果一个函数对不同参数返回不同结果，则称该函数为单射函数。
可用于优化 GROUP BY。
语法
concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ... ])
NULL，则函数返回 NULL。String
示例
使用示例
CREATE TABLE user_data (
user_id UInt32,
first_name String,
last_name String,
score UInt32
)
ENGINE = MergeTree
ORDER BY tuple();
INSERT INTO user_data VALUES
(1, 'John', 'Doe', 100),
(2, 'Jane', 'Smith', 150),
(3, 'John', 'Wilson', 120),
(4, 'Jane', 'Smith', 90);
SELECT
concatWithSeparatorAssumeInjective('-', first_name, last_name) as full_name,
sum(score) as total_score
FROM user_data
GROUP BY concatWithSeparatorAssumeInjective('-', first_name, last_name);
┌─full_name───┬─total_score─┐
│ Jane-Smith │ 240 │
│ John-Doe │ 100 │
│ John-Wilson │ 120 │
└─────────────┴─────────────┘
conv(number, from_base, to_base)
number — 要转换的数字。可以是字符串或数值类型。 - from_base — 源进制 (2-36) 。必须是整数。 - to_base — 目标进制 (2-36) 。必须是整数。
返回值
该数字在目标进制中的字符串表示形式。
示例
将十进制转换为二进制
将十六进制转换为十进制
SELECT conv('FF', 16, 10)
SELECT conv('-1', 10, 16)
SELECT conv('1010', 2, 8)
s 从编码 from 转换为编码 to 后的结果。
语法
convertCharset(s, from, to)
s 从编码 from 转换为编码 to 后的结果。String
示例
用法示例
SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');
┌─convertChars⋯SO-8859-1')─┐
│ Caf� │
└──────────────────────────┘
damerauLevenshteinDistance
damerauLevenshteinDistance(s1, s2)
UInt64
示例
使用示例
SELECT damerauLevenshteinDistance('clickhouse', 'mouse')
┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│ 6 │
└───────────────────────────────────────────────────┘
s — 包含要解码的 HTML 实体的 String。String
返回值
返回将 HTML 实体解码后的字符串。String
示例
使用示例
SELECT decodeHTMLComponent('<div>Hello & "World"</div>')
┌─decodeHTMLComponent('<div>Hello & "World"</div>')─┐
│ <div>Hello & "World"</div> │
└─────────────────────────────────────────────────────────────────────────────┘
s — 包含待解码 XML 实体的 String。String
返回值
返回对所提供字符串中的 XML 实体解码后的结果。String
示例
使用示例
SELECT decodeXMLComponent('<tag>Hello & World</tag>')
┌─decodeXMLCom⋯;/tag>')─┐
│ <tag>Hello & World</tag> │
└──────────────────────────┘
levenshteinDistance
参数
返回值
返回这两个字符串之间的编辑距离。UInt64
示例
使用示例
SELECT editDistance('clickhouse', 'mouse')
┌─editDistance('clickhouse', 'mouse')─┐
│ 6 │
└─────────────────────────────────────┘
levenshteinDistanceUTF8
参数
返回值
返回两个 UTF8 字符串之间的编辑距离。UInt64
示例
用法示例
SELECT editDistanceUTF8('我是谁', '我是我')
┌─editDistanceUTF8('我是谁', '我是我')──┐
│ 1 │
└─────────────────────────────────────┘
String
示例
用法示例
SELECT
'<tag>Hello & "World"</tag>' AS original,
encodeXMLComponent('<tag>Hello & "World"</tag>') AS xml_encoded;
┌─original───────────────────┬─xml_encoded──────────────────────────────────────────┐
│ <tag>Hello & "World"</tag> │ <tag>Hello & "World"</tag> │
└────────────────────────────┴──────────────────────────────────────────────────────┘
s 以 suffix 结尾，则返回 1；否则返回 0。UInt8
示例
用法示例
SELECT endsWith('ClickHouse', 'House');
┌─endsWith('Cl⋯', 'House')─┐
│ 1 │
└──────────────────────────┘
endsWithCaseInsensitive(s, suffix)
s 以不区分大小写的 suffix 结尾，则返回 1，否则返回 0。UInt8
示例
用法示例
SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');
┌─endsWithCaseInsensitive('Cl⋯', 'HOUSE')─┐
│ 1 │
└─────────────────────────────────────────┘
endsWithCaseInsensitiveUTF8
s 是否以不区分大小写的 suffix 结尾。
假定该字符串包含有效的 UTF-8 编码文本。
如果不满足这一假定，不会抛出异常，结果未定义。
语法
endsWithCaseInsensitiveUTF8(s, suffix)
s 以不区分大小写的 suffix 结尾，则返回 1；否则返回 0。UInt8
示例
使用示例
SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');
┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│ 1 │
└─────────────────────────────────────────────┘
s 是否以 suffix 结尾。
假定该字符串包含有效的 UTF-8 编码文本。
如果不满足这一假定，不会抛出异常，结果未定义。
语法
参数
返回值
如果 s 以 suffix 结尾，则返回 1，否则返回 0。UInt8
示例
使用示例
SELECT endsWithUTF8('данных', 'ых');
┌─endsWithUTF8('данных', 'ых')─┐
│ 1 │
└──────────────────────────────┘
- 移除所有 HTML/XML 标签
- 移除注释 (
{/* */})
- 移除 script 和 style 元素及其内容
- 处理 CDATA 区段 (按原样复制)
- 正确处理并规范化空白字符
注意：HTML 实体不会被解码，如有需要，应使用单独的函数处理。
Syntax
extractTextFromHTML(html)
html — 包含要从中提取文本的 HTML 内容的 String。String
返回值
返回提取出的文本内容，其中空白字符会被归一化。String
示例
使用示例
SELECT extractTextFromHTML('
<html>
<head><title>Page Title</title></head>
<body>
<p>Hello <b>World</b>!</p>
<script>alert("test");</script>
<!-- comment -->
</body>
</html>
');
┌─extractTextFromHTML('<html><head>...')─┐
│ Page Title Hello World! │
└────────────────────────────────────────┘
String
示例
用法示例
SELECT firstLine('foo\\nbar\\nbaz')
┌─firstLine('foo\nbar\nbaz')─┐
│ foo │
└────────────────────────────┘
idnaEncode() 和 idnaDecode() 后，返回的结果不一定是原始字符串。
语法
参数
返回值
根据输入值的 IDNA 机制，返回输入字符串的 Unicode (UTF-8) 形式。String
示例
用法示例
SELECT idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')
┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de │
└───────────────────────────────────────────────┘
不会执行百分号解码，也不会去除制表符、空格或控制字符。
String
示例
用法示例
SELECT idnaEncode('straße.münchen.de')
┌─idnaEncode('straße.münchen.de')─────┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
由于 initcap 只会将每个单词的首字母转换为大写，因此对于包含撇号或大写字母的单词，结果可能不符合预期。
这是已知行为，目前暂无修复计划。
s 中每个单词的首字母转换为大写后的结果。String
示例
使用示例
SELECT initcap('building for fast')
┌─initcap('building for fast')─┐
│ Building For Fast │
└──────────────────────────────┘
SELECT initcap('John''s cat won''t eat.');
┌─initcap('Joh⋯n\'t eat.')─┐
│ John'S Cat Won'T Eat. │
└──────────────────────────┘
initcap 类似，initcapUTF8 会将每个单词的首字母转换为大写，其余字母转换为小写。
假定该字符串包含有效的 UTF-8 编码文本。
如果不满足这一假设，不会抛出异常，结果未定义。
此函数不会检测语言，例如对于土耳其语，结果可能并不完全正确 (i/İ 与 i/I) 。
如果某个码点的大写和小写形式对应的 UTF-8 字节序列长度不同，则该码点的结果可能不正确。
s 中每个单词的首字母转换为大写后的结果。String
示例
用法示例
SELECT initcapUTF8('не тормозит')
┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит │
└────────────────────────────┘
isASCII
参数
返回值
示例
isValidASCII
SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii
s — 要检查是否为有效 UTF-8 编码的字符串。String
返回值
如果该字节序列构成有效的 UTF-8 编码文本，则返回 1；否则返回 0。UInt8
示例
使用示例
SELECT isValidUTF8('\\xc3\\xb1') AS valid, isValidUTF8('\\xc3\\x28') AS invalid
┌─valid─┬─invalid─┐
│ 1 │ 0 │
└───────┴─────────┘
Float64
示例
使用示例
SELECT jaroSimilarity('clickhouse', 'click')
┌─jaroSimilarity('clickhouse', 'click')─┐
│ 0.8333333333333333 │
└───────────────────────────────────────┘
jaroWinklerSimilarity(s1, s2)
Float64
示例
使用示例
SELECT jaroWinklerSimilarity('clickhouse', 'click')
┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│ 0.8999999999999999 │
└──────────────────────────────────────────────┘
s 中从左侧按指定 offset 开始的子串。
语法
参数
返回值
返回：
- 当
offset 为正数时，返回从字符串左侧开始、长度为 offset 字节的 s 的子串。
- 当
offset 为负数时，返回从字符串左侧开始、长度为 length(s) - |offset| 字节的 s 的子串。
- 如果
length 为 0，则返回空字符串。
String
示例
正偏移量
SELECT left('Hello World', 5)
SELECT left('Hello World', -6)
length。
语法
leftPad(string, length[, pad_string])
lpad
参数
string — 要进行填充的输入字符串。Stringlength — 结果字符串的长度。如果该值小于输入字符串的长度，则输入字符串会被截断为 length 个字符。(U)Int*pad_string — 可选。用于填充输入字符串的字符串。如果未指定，则使用空格对输入字符串进行填充。String
返回值
返回一个左侧填充到指定长度的字符串。String
示例
用法示例
SELECT leftPad('abc', 7, '*'), leftPad('def', 7)
┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc │ def │
└────────────────────────┴───────────────────┘
leftPad，此处的字符串长度按码点计算。
语法
leftPadUTF8(string, length[, pad_string])
string — 需要填充的输入字符串。Stringlength — 结果字符串的长度。如果该值小于输入字符串的长度，则输入字符串会被截短为 length 个字符。(U)Int*pad_string — 可选。用于填充输入字符串的字符串。如果未指定，则使用空格填充输入字符串。String
返回值
返回一个左侧填充到给定长度的字符串。String
示例
用法示例
SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7)
┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг │ дежз │
└─────────────────────────────┴────────────────────────┘
s 中从左侧开始、指定 offset 的子串。
语法
参数
返回值
返回：
- 当
offset 为正数时，返回 s 的子串，长度为 offset 个字节，从字符串左侧开始。\n”
- 当
offset 为负数时，返回 s 的子串，长度为 length(s) - |offset| 个字节，从字符串左侧开始。\n”
- 如果
length 为 0，则返回空字符串。
String
示例
正偏移量
SELECT leftUTF8('Привет', 4)
SELECT leftUTF8('Привет', -4)
CHARACTER_LENGTH, CHAR_LENGTH
参数
s — 包含有效 UTF-8 编码文本的 String。String
返回值
字符串 s 的长度 (以 Unicode 码点数计) 。UInt64
示例
使用示例
SELECT lengthUTF8('Здравствуй, мир!')
┌─lengthUTF8('Здравствуй, мир!')─┐
│ 16 │
└────────────────────────────────┘
lcase
参数
返回值
返回将 s 转换为小写后的字符串。String
示例
用法示例
SELECT lower('CLICKHOUSE')
┌─lower('CLICKHOUSE')─┐
│ clickhouse │
└─────────────────────┘
String
示例
第一个
SELECT lowerUTF8('München') as Lowerutf8;
NATURAL_SORT_KEY
参数
返回值
返回由 s 转换得到的自然排序键字符串。String
示例
使用示例
SELECT s FROM t ORDER BY naturalSortKey(s)
┌─s───┐
│ a1 │
| a02 │
└─────┘
String
示例
用法示例
SELECT
'é' AS original, -- e + 组合尖音符 (U+0065 + U+0301)
length(original),
normalizeUTF8NFC('é') AS nfc_normalized, -- é (U+00E9)
length(nfc_normalized);
┌─original─┬─length(original)─┬─nfc_normalized─┬─length(nfc_normalized)─┐
│ é │ 2 │ é │ 2 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
String
示例
使用示例
SELECT
'é' AS original, -- é (U+00E9)
length(original),
normalizeUTF8NFD('é') AS nfd_normalized, -- e + 组合重音符（U+0065 + U+0301）
length(nfd_normalized);
┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é │ 2 │ é │ 3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘
String
示例
使用示例
SELECT
'① ② ③' AS original, -- 带圆圈的数字字符
normalizeUTF8NFKC('① ② ③') AS nfkc_normalized; -- 转换为 1 2 3
┌─original─┬─nfkc_normalized─┐
│ ① ② ③ │ 1 2 3 │
└──────────┴─────────────────┘
normalizeUTF8NFKCCasefold
normalizeUTF8NFKCCasefold(str)
String
示例
使用示例
SELECT
'Ä ① Hello' AS original,
normalizeUTF8NFKCCasefold('Ä ① Hello') AS nfkc_cf_normalized;
┌─original───┬─nfkc_cf_normalized─┐
│ Ä ① Hello │ ä 1 hello │
└────────────┴────────────────────┘
String
示例
使用示例
SELECT
'H₂O²' AS original, -- H + 下标 2 + O + 上标 2
normalizeUTF8NFKD('H₂O²') AS nfkd_normalized; -- 转换为 H 2 O 2
┌─original─┬─nfkd_normalized─┐
│ H₂O² │ H2O2 │
└──────────┴─────────────────┘
String
示例
用法示例
SELECT punycodeDecode('Mnchen-3ya')
┌─punycodeDecode('Mnchen-3ya')─┐
│ München │
└──────────────────────────────┘
String
示例
使用示例
SELECT punycodeEncode('München')
┌─punycodeEncode('München')─┐
│ Mnchen-3ya │
└───────────────────────────┘
haystack 中提取第一个匹配正则表达式 pattern 且对应指定正则分组索引的字符串。
语法
regexpExtract(haystack, pattern[, index])
REGEXP_EXTRACT
参数
haystack — String，待进行正则表达式模式匹配的字符串。Stringpattern — String，正则表达式。pattern 可以包含多个正则分组，index 指定要提取的正则分组。索引为 0 表示匹配整个正则表达式。const Stringindex — 可选。一个大于或等于 0 的整数，默认值为 1。表示要提取的正则分组。(U)Int*
返回值
返回匹配到的字符串。String
示例
使用示例
SELECT
regexpExtract('100-200', '(\\d+)-(\\d+)', 1),
regexpExtract('100-200', '(\\d+)-(\\d+)', 2),
regexpExtract('100-200', '(\\d+)-(\\d+)', 0),
regexpExtract('100-200', '(\\d+)-(\\d+)');
┌─regexpExtract('100-200', '(\\d+)-(\\d+)', 1)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 2)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)', 0)─┬─regexpExtract('100-200', '(\\d+)-(\\d+)')─┐
│ 100 │ 200 │ 100-200 │ 100 │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘
pattern 在 haystack 中第 occurrence 次匹配的字节位置 (从 1 开始) ，搜索从字节位置 position 开始。
如果 return_option 为 0 (默认值) ，则返回匹配结果第一个字节的位置；如果为 1，则返回匹配结束后第一个字节的位置。
如果 subexpression 大于 0，则返回相应捕获组的位置，而不是整个匹配的位置。
如果未找到匹配，或所请求的捕获组未参与匹配，则返回 0。
此函数用于兼容 PostgreSQL 的 regexp_instr (也以该别名提供) 。请注意，这里的位置按字节计算，与其他 ClickHouse 正则函数一致；而 PostgreSQL 的 regexp_instr 按字符计算。
语法
regexpPosition(haystack, pattern[, position[, occurrence[, return_option[, flags[, subexpression]]]]])
regexpInstr, regexp_instr
参数
haystack — 待搜索的字符串。Stringpattern — 正则表达式模式。const Stringposition — 可选。开始搜索的字节位置，从 1 开始计数。默认值：1。(U)Int*occurrence — 可选。返回第几个匹配项。默认值：1。(U)Int*return_option — 可选。0 返回匹配的起始位置，1 返回匹配结束后紧接着的位置。默认值：0。(U)Int*flags — 可选。正则标志。支持：i (不区分大小写) 、c (区分大小写) 、m/n (多行锚点) 、s (点号匹配换行符) 。默认值：空字符串。const Stringsubexpression — 可选。要返回其位置的捕获组索引。0 表示整个匹配。默认值：0。(U)Int*
返回值
返回匹配的字节位置；如果未找到，则返回 0。UInt64
示例
基本用法
SELECT
regexpPosition('hello world', 'world'),
regexpPosition('aXbXcXd', 'X', 1, 2),
regexpPosition('aXbXcXd', 'X', 1, 2, 1),
regexpPosition('Hello WORLD', 'world', 1, 1, 0, 'i'),
regexpPosition('foo123bar456', '([a-z]+)([0-9]+)', 1, 2, 0, '', 2);
┌─...─┬─...─┬─...─┬─...─┬─...─┐
│ 7 │ 4 │ 5 │ 7 │ 10 │
└─────┴─────┴─────┴─────┴─────┘
removeDiacriticsUTF8(str)
removeAccentsUTF8
参数
返回值
移除变音符号后的 UTF-8 字符串。String
示例
基本重音去除
SELECT removeDiacriticsUTF8('café résumé naïve')
┌─removeDiacriticsUTF8('café résumé naïve')─┐
│ cafe resume naive │
└────────────────────────────────────────────┘
s 重复 n 次后得到的字符串。如果 n 为负数，函数将返回空字符串。String
示例
用法示例
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
s — 包含有效 UTF-8 编码文本的 String。String
返回值
返回一个将 Unicode 码点序列倒序后的字符串。String
示例
使用示例
SELECT reverseUTF8('ClickHouse')
s 中从右侧开始、以指定 offset 为起点的子串。
语法
参数
返回值
返回：
- 当
offset 为正数时，返回从字符串右侧开始、长度为 offset 字节的 s 的子串。
- 当
offset 为负数时，返回从字符串右侧开始、长度为 length(s) - |offset| 字节的 s 的子串。
- 如果
length 为 0，则返回空字符串。
String
示例
正偏移量
负偏移
SELECT right('Hello', -3)
length。
语法
rightPad(string, length[, pad_string])
rpad
参数
string — 需要填充的输入字符串。Stringlength — 结果字符串的长度。如果该值小于输入字符串的长度，则输入字符串会被截断为 length 个字符。(U)Int*pad_string — 可选。用于填充输入字符串的字符串。若未指定，则使用空格填充输入字符串。String
返回值
返回一个右侧填充到给定长度的字符串。String
示例
用法示例
SELECT rightPad('abc', 7, '*'), rightPad('abc', 7)
┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc**** │ abc │
└─────────────────────────┴────────────────────┘
rightPad，这里的字符串长度按码点计算。
语法
rightPadUTF8(string, length[, pad_string])
string — 需要填充的输入字符串。Stringlength — 结果字符串的长度。如果该值小于输入字符串的长度，则输入字符串会被截断为 length 个字符。(U)Int*pad_string — 可选。用于填充输入字符串的字符串。如果未指定，则使用空格填充输入字符串。String
返回值
返回一个右侧填充至给定长度的字符串。String
示例
使用示例
SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7)
┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг*** │ абвг │
└──────────────────────────────┴─────────────────────────┘
s 中从右侧开始、指定 offset 的子串。
语法
参数
返回值
返回：
- 当
offset 为正数时，返回 s 的一个子串，长度为 offset 字节，从字符串右侧开始截取。
- 当
offset 为负数时，返回 s 的一个子串，长度为 length(s) - |offset| 字节，从字符串右侧开始截取。
- 如果
length 为 0，则返回空字符串。
String
示例
正偏移量
SELECT rightUTF8('Привет', 4)
SELECT rightUTF8('Привет', -4)
String
示例
用法示例
┌─soundex('aksel')─┐
│ A240 │
└──────────────────┘
) 。
语法
参数
返回值
返回一个由 n 个空格组成的字符串。如果 n <= 0，函数将返回空字符串。String
示例
用法示例
SELECT space(3) AS res, length(res);
┌─res─┬─length(res)─┐
│ │ 3 │
└─────┴─────────────┘
n 的子字符串，
其中该子字符串边界上的 (n-1)-gram 的哈希值
严格大于其内部任意 (n-1)-gram 的哈希值。
使用 CRC32 作为哈希函数。
语法
sparseGrams(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
s — 输入的字符串。Stringmin_ngram_length — 可选。提取的 ngram 的最小长度。默认值和最小值均为 3。UInt*max_ngram_length — 可选。提取的 ngram 的最大长度。默认值为 100。不得小于 min_ngram_length。UInt*min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-grams。默认值与 min_ngram_length 相同。不得小于 min_ngram_length，也不得大于 max_ngram_length。UInt*
返回值
返回所选子字符串的数组。Array(String)
示例
使用示例
SELECT sparseGrams('alice', 3)
┌─sparseGrams('alice', 3)────────────┐
│ ['ali','lic','lice','ice'] │
└────────────────────────────────────┘
n 的子字符串的哈希值，
其中该子字符串边界上的 (n-1)-gram 的哈希值
严格大于该子字符串内部任意 (n-1)-gram 的哈希值。
使用 CRC32 作为哈希函数。
语法
sparseGramsHashes(s[, min_ngram_length, max_ngram_length])
s — 输入字符串。Stringmin_ngram_length — 可选。提取的 ngram 的最小长度。默认值和最小值均为 3。UInt*max_ngram_length — 可选。提取的 ngram 的最大长度。默认值为 100。不应小于 min_ngram_length。UInt*min_cutoff_length — 可选。若指定，则仅返回长度大于或等于 min_cutoff_length 的 n-grams。默认值与 min_ngram_length 相同。不应小于 min_ngram_length，也不应大于 max_ngram_length。UInt*
返回值
返回由选定子字符串的 CRC32 哈希值组成的数组。Array(UInt32)
示例
使用示例
SELECT sparseGramsHashes('alice', 3)
┌─sparseGramsHashes('alice', 3)──────────────────────┐
│ [1481062250,2450405249,4012725991,1918774096] │
└────────────────────────────────────────────────────┘
n 的子字符串的哈希值，其中该子字符串边界上的 (n-1)-gram 的哈希值严格大于其内部任意 (n-1)-gram 的哈希值。
该函数要求输入为 UTF-8 字符串；如果 UTF-8 序列无效，则会抛出异常。
使用 CRC32 作为哈希函数。
Syntax
sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])
s — 输入字符串。Stringmin_ngram_length — 可选。提取的 ngram 的最小长度。默认值和最小值均为 3。UInt*max_ngram_length — 可选。提取的 ngram 的最大长度。默认值为 100。不能小于 min_ngram_length。UInt*min_cutoff_length — 可选。如果指定，则仅返回长度大于等于 min_cutoff_length 的 n-grams。默认值与 min_ngram_length 相同。不能小于 min_ngram_length，也不能大于 max_ngram_length。UInt*
返回值
返回所选 UTF-8 子字符串的 CRC32 哈希数组。Array(UInt32)
示例
使用示例
SELECT sparseGramsHashesUTF8('алиса', 3)
┌─sparseGramsHashesUTF8('алиса', 3)─┐
│ [4178533925,3855635300,561830861] │
└───────────────────────────────────┘
n 的子字符串，其中该子字符串边界处的 (n-1)-gram 的哈希值严格大于其内部任意 (n-1)-gram 的哈希值。
该函数接受一个 UTF-8 字符串；如果 UTF-8 序列无效，则会抛出异常。
使用 CRC32 作为哈希函数。
Syntax
sparseGramsUTF8(s[, min_ngram_length[, max_ngram_length[, min_cutoff_length]]])
s — 输入字符串。Stringmin_ngram_length — 可选。提取的 ngram 的最小长度。默认值和最小值均为 3。UInt*max_ngram_length — 可选。提取的 ngram 的最大长度。默认值为 100。不得小于 min_ngram_length。UInt*min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-grams。默认值与 min_ngram_length 相同。不得小于 min_ngram_length，也不得大于 max_ngram_length。UInt*
返回值
返回由选定的 UTF-8 子字符串组成的数组。Array(String)
示例
使用示例
SELECT sparseGramsUTF8('алиса', 3)
┌─sparseGramsUTF8('алиса', 3)─┐
│ ['али','лис','иса'] │
└─────────────────────────────┘
s 以 prefix 开头，则返回 1；否则返回 0。UInt8
示例
使用示例
SELECT startsWith('ClickHouse', 'Click');
┌─startsWith('⋯', 'Click')─┐
│ 1 │
└──────────────────────────┘
startsWithCaseInsensitive
startsWithCaseInsensitive(s, prefix)
s 以不区分大小写的 prefix 开头，则返回 1，否则返回 0。UInt8
示例
使用示例
SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');
┌─startsWithCaseInsensitive('⋯', 'CLICK')─┐
│ 1 │
└─────────────────────────────────────────┘
startsWithCaseInsensitiveUTF8
startsWithCaseInsensitiveUTF8(s, prefix)
s 以不区分大小写的 prefix 开头，则返回 1，否则返回 0。UInt8
示例
使用示例
SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
startsWithUTF8(s, prefix)
s 以 prefix 开头，则返回 1；否则返回 0。UInt8
示例
使用示例
SELECT startsWithUTF8('приставка', 'при')
┌─startsWithUT⋯ка', 'при')─┐
│ 1 │
└──────────────────────────┘
Float64
示例
用法示例
SELECT stringBytesEntropy('Hello, world!')
┌─stringBytesEntropy('Hello, world!')─┐
│ 3.07049960 │
└─────────────────────────────────────┘
UInt16
示例
用法示例
SELECT stringBytesUniq('Hello')
┌─stringBytesUniq('Hello')─┐
│ 4 │
└──────────────────────────┘
stringJaccardIndex(s1, s2)
Float64
示例
使用示例
SELECT stringJaccardIndex('clickhouse', 'mouse')
┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│ 0.4 │
└───────────────────────────────────────────┘
stringJaccardIndex 类似，但适用于 UTF-8 编码的字符串。
语法
stringJaccardIndexUTF8(s1, s2)
Float64
示例
使用示例
SELECT stringJaccardIndexUTF8('我爱你', '我也爱你')
┌─stringJaccardIndexUTF8('我爱你', '我也爱你')─┐
│ 0.75 │
└─────────────────────────────────────────────┘
s 中从指定字节索引 offset 开始的子串。
字节计数从 1 开始，规则如下：
- 如果
offset 为 0，则返回空字符串。
- 如果
offset 为负数，则子串从字符串末尾向前数 |offset| 个字符处开始，而不是从开头开始。
可选参数 length 用于指定返回子串的最大字节数。
语法
substring(s, offset[, length])
byteSlice, mid, substr
参数
返回值
返回 s 中从索引 offset 开始、长度为 length 字节的子串。String
示例
基本用法
SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)
┌─db───────┬─substring('database', 5)─┬─substring('database', 5, 1)─┐
│ database │ base │ b │
└──────────┴──────────────────────────┴─────────────────────────────┘
s 中位于分隔符 delim 第 count 次出现之前的子串，与 Spark 或 MySQL 中的行为一致。
语法
substringIndex(s, delim, count)
SUBSTRING_INDEX
参数
s — 要从中提取子串的字符串。Stringdelim — 用于分割的字符。Stringcount — 提取子串前要计数的分隔符出现次数。如果 count 为正，则返回从左开始计数的最后一个分隔符左侧的所有内容。如果 count 为负，则返回从右开始计数的最后一个分隔符右侧的所有内容。UInt 或 Int
返回值
返回 s 中 delim 出现 count 次之前的子串。String
示例
用法示例
SELECT substringIndex('www.clickhouse.com', '.', 2)
┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse │
└──────────────────────────────────────────────┘
s 中位于分隔符 delim 出现 count 次之前的子串，按 Unicode 码点处理。
假定该字符串包含有效的 UTF-8 编码文本。
如果不满足这一假定，不会抛出异常，结果未定义。
语法
substringIndexUTF8(s, delim, count)
s — 要从中提取子串的字符串。Stringdelim — 用于分割的字符。Stringcount — 提取子串前需要计数的分隔符出现次数。如果 count 为正，则返回最后一个分隔符左侧的所有内容 (从左开始计数) 。如果 count 为负，则返回最后一个分隔符右侧的所有内容 (从右开始计数) 。UInt 或 Int
返回值
返回 s 中第 count 次出现 delim 之前的子串。String
示例
UTF8 示例
SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)
s 中从指定码点索引 offset 开始的子串。
码点从 1 开始计数，规则如下：
- 如果
offset 为 0，则返回空字符串。
- 如果
offset 为负数，则子串从字符串末尾向前数 offset 个码点处开始，而不是从开头开始。
可选参数 length 指定返回子串可包含的最大码点数。
该函数假定字符串包含有效的 UTF-8 编码文本。
如果这一假设不成立，不会抛出异常，结果未定义。
substringUTF8(s, offset[, length])
offset 开始、长度为 length 个码点的 s 的子串。String
示例
用法示例
SELECT 'Täglich grüßt das Murmeltier.' AS str, substringUTF8(str, 9), substringUTF8(str, 9, 5)
Täglich grüßt das Murmeltier. grüßt das Murmeltier. grüßt
� (U+FFFD) 。
如果存在多个连续的无效字符，它们会合并为一个替换字符。
语法
参数
s — 以 String 数据类型对象表示的任意字节序列。String
返回值
返回有效的 UTF-8 字符串。String
示例
使用示例
SELECT toValidUTF8('\\x61\\xF0\\x80\\x80\\x80b')
c
┌─toValidUTF8('a����b')─┐
│ a�b │
└───────────────────────┘
trimBoth(s[, trim_characters])
trim
参数
s — 要去除首尾字符的 String。Stringtrim_characters — 可选。要去除的字符。如果未指定，则会移除常见的空白字符。String
返回值
返回去除两端指定字符后的字符串。String
示例
使用示例
SELECT trimBoth('$$ClickHouse$$', '$')
┌─trimBoth('$$⋯se$$', '$')─┐
│ ClickHouse │
└──────────────────────────┘
trimLeft(input[, trim_characters])
ltrim
参数
input — 要裁剪的字符串。Stringtrim_characters — 可选。要裁剪的字符。如果未指定，则会移除常见的空白字符。String
返回值
返回从左侧裁剪掉指定字符后的字符串。String
示例
使用示例
SELECT trimLeft('ClickHouse', 'Click');
┌─trimLeft('Cl⋯', 'Click')─┐
│ House │
└──────────────────────────┘
trimRight(s[, trim_characters])
rtrim
参数
s — 要修剪的字符串。Stringtrim_characters — 可选，要修剪的字符。如果未指定，则会移除常见的空白字符。String
返回值
返回从右侧修剪掉指定字符后的字符串。String
示例
用法示例
SELECT trimRight('ClickHouse','House');
┌─trimRight('C⋯', 'House')─┐
│ Click │
└──────────────────────────┘
encoded — 要解码的 String 类型列或常量。如果该字符串不是有效的 Base32 编码，则在出错时返回空字符串。String
返回值
返回一个包含参数解码后值的字符串。String
示例
使用示例
SELECT tryBase32Decode('IVXGG33EMVSA====');
┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded │
└─────────────────────────────────────┘
base58Decode 类似，但发生错误时会返回空字符串。
语法
tryBase58Decode(encoded[, expected_size])
String
示例
使用示例
SELECT tryBase58Decode('3dc8KtHrwM') AS res, tryBase58Decode('invalid') AS res_invalid;
┌─res─────┬─res_invalid─┐
│ Encoded │ │
└─────────┴─────────────┘
base64Decode 类似，但发生错误时会返回空字符串。
语法
参数
encoded — 要解码的 String 类型列或常量。如果字符串不是有效的 Base64 编码，发生错误时将返回空字符串。String
返回值
返回一个包含该参数解码后值的字符串。String
示例
使用示例
SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')
┌─tryBase64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse │
└─────────────────────────────────────┘
base64URLDecode 类似，但发生错误时返回空字符串。
语法
tryBase64URLDecode(encoded)
encoded — 要解码的 String 类型列或常量。如果该字符串不是有效的 Base64 编码，出错时返回空字符串。String
返回值
返回一个字符串，其中包含该参数解码后的值。String
示例
用法示例
SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')
┌─tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')─┐
│ https://clickhouse.com │
└──────────────────────────────────────────────────────┘
String
示例
使用示例
SELECT tryIdnaEncode('straße.münchen.de')
┌─tryIdnaEncode('straße.münchen.de')──┐
│ xn--strae-oqa.xn--mnchen-3ya.de │
└─────────────────────────────────────┘
punycodeDecode 类似，但如果给定的字符串不是有效的 Punycode 编码字符串，则返回空字符串。
语法
参数
返回值
返回输入值的明文；如果输入无效，则返回空字符串。String
示例
使用示例
SELECT tryPunycodeDecode('Mnchen-3ya')
┌─tryPunycodeDecode('Mnchen-3ya')─┐
│ München │
└─────────────────────────────────┘
ucase
参数
返回值
返回将 s 转换为大写后的字符串。String
示例
使用示例
SELECT upper('clickhouse')
┌─upper('clickhouse')─┐
│ CLICKHOUSE │
└─────────────────────┘
此函数不会检测语言，例如对于土耳其语，结果可能并不完全正确 (i/İ 与 i/I) 。
如果某个代码点的大写和小写形式的 UTF-8 字节序列长度不同 (例如 ẞ 和 ß) ，则该代码点的转换结果可能不正确。
String
示例
使用示例
SELECT upperUTF8('München') AS Upperutf8
┌─Upperutf8─┐
│ MÜNCHEN │
└───────────┘
