字符串函数

有关在字符串中搜索和替换的函数在单独的部分进行了描述。

empty

检查输入字符串是否为空。如果字符串包含至少一个字节，即使该字节是空格或空字节，也认为该字符串不为空。

此函数也可用于数组和UUID。

语法

empty(x)

参数

x — 输入值。字符串。

返回值

对于空字符串返回 1，对于非空字符串返回 0。 UInt8。

示例

SELECT empty('');

结果

┌─empty('')─┐
│         1 │
└───────────┘

notEmpty

检查输入字符串是否非空。如果字符串包含至少一个字节，即使该字节是空格或空字节，也认为该字符串不为空。

此函数也可用于数组和UUID。

语法

notEmpty(x)

参数

x — 输入值。字符串。

返回值

对于非空字符串返回 1，对于空字符串返回 0。 UInt8。

示例

SELECT notEmpty('text');

结果

┌─notEmpty('text')─┐
│                1 │
└──────────────────┘

length

返回字符串的字节长度，而不是字符或 Unicode 代码点数。此函数也适用于数组。

别名：OCTET_LENGTH

语法

length(s)

参数

s — 输入字符串或数组。字符串/数组。

返回值

字符串或数组 s 的字节长度。 UInt64。

示例

查询

SELECT length('Hello, world!');

结果

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

查询

SELECT length([1, 2, 3, 4]);

结果

┌─length([1, 2, 3, 4])─┐
│                    4 │
└──────────────────────┘

lengthUTF8

返回字符串的 Unicode 代码点数，而不是字节或字符。它假设字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

别名

CHAR_LENGTH
CHARACTER_LENGTH

语法

lengthUTF8(s)

参数

s — 包含有效 UTF-8 编码文本的字符串。字符串。

返回值

字符串 s 的 Unicode 代码点数。 UInt64。

示例

查询

SELECT lengthUTF8('Здравствуй, мир!');

结果

┌─lengthUTF8('Здравствуй, мир!')─┐
│                             16 │
└────────────────────────────────┘

left

返回字符串 s 的子字符串，指定从左侧开始的 offset。

语法

left(s, offset)

参数

s — 要从中计算子字符串的字符串。字符串或 FixedString。
offset — 偏移量的字节数。 UInt*。

返回值

对于正数 offset：从字符串左侧开始的 offset 个字节的 s 的子字符串。
对于负数 offset：从字符串左侧开始的 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则为空字符串。

示例

查询

SELECT left('Hello', 3);

结果

Hel

查询

SELECT left('Hello', -3);

结果

He

leftUTF8

返回 UTF-8 编码字符串 s 的子字符串，指定从左侧开始的 offset。

语法

leftUTF8(s, offset)

参数

s — 要从中计算子字符串的 UTF-8 编码字符串。字符串或 FixedString。
offset — 偏移量的字节数。 UInt*。

返回值

对于正数 offset：从字符串左侧开始的 offset 个字节的 s 的子字符串。
对于负数 offset：从字符串左侧开始的 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则为空字符串。

示例

查询

SELECT leftUTF8('Привет', 4);

结果

Прив

查询

SELECT leftUTF8('Привет', -4);

结果

Пр

leftPad

在字符串左侧用空格或指定的字符串（如果需要，多次）填充，直到结果字符串达到指定的 length。

语法

leftPad(string, length[, pad_string])

别名：LPAD

参数

string — 应该填充的输入字符串。字符串。
length — 结果字符串的长度。 UInt 或 Int。如果该值小于输入字符串长度，则输入字符串将缩短到 length 个字符。
pad_string — 用于填充输入字符串的字符串。字符串。可选。如果未指定，则用空格填充输入字符串。

返回值

给定长度的左填充字符串。字符串。

示例

SELECT leftPad('abc', 7, '*'), leftPad('def', 7);

结果

┌─leftPad('abc', 7, '*')─┬─leftPad('def', 7)─┐
│ ****abc                │     def           │
└────────────────────────┴───────────────────┘

leftPadUTF8

在字符串左侧用空格或指定的字符串（如果需要，多次）填充，直到结果字符串达到给定的长度。与 leftPad 以字节为单位测量字符串长度不同，字符串长度以代码点为单位测量。

语法

leftPadUTF8(string, length[, pad_string])

参数

string — 应该填充的输入字符串。字符串。
length — 结果字符串的长度。 UInt 或 Int。如果该值小于输入字符串长度，则输入字符串将缩短到 length 个字符。
pad_string — 用于填充输入字符串的字符串。字符串。可选。如果未指定，则用空格填充输入字符串。

返回值

给定长度的左填充字符串。字符串。

示例

SELECT leftPadUTF8('абвг', 7, '*'), leftPadUTF8('дежз', 7);

结果

┌─leftPadUTF8('абвг', 7, '*')─┬─leftPadUTF8('дежз', 7)─┐
│ ***абвг                     │    дежз                │
└─────────────────────────────┴────────────────────────┘

right

返回字符串 s 的子字符串，指定从右侧开始的 offset。

语法

right(s, offset)

参数

s — 要从中计算子字符串的字符串。字符串或 FixedString。
offset — 偏移量的字节数。 UInt*。

返回值

对于正数 offset：从字符串右侧开始的 offset 个字节的 s 的子字符串。
对于负数 offset：从字符串右侧开始的 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则为空字符串。

示例

查询

SELECT right('Hello', 3);

结果

llo

查询

SELECT right('Hello', -3);

结果

lo

rightUTF8

返回 UTF-8 编码字符串 s 的子字符串，指定从右侧开始的 offset。

语法

rightUTF8(s, offset)

参数

s — 要从中计算子字符串的 UTF-8 编码字符串。字符串或 FixedString。
offset — 偏移量的字节数。 UInt*。

返回值

对于正数 offset：从字符串右侧开始的 offset 个字节的 s 的子字符串。
对于负数 offset：从字符串右侧开始的 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则为空字符串。

示例

查询

SELECT rightUTF8('Привет', 4);

结果

ивет

查询

SELECT rightUTF8('Привет', -4);

结果

ет

rightPad

在字符串右侧用空格或指定的字符串（如果需要，多次）填充，直到结果字符串达到指定的 length。

语法

rightPad(string, length[, pad_string])

别名：RPAD

参数

string — 应该填充的输入字符串。字符串。
length — 结果字符串的长度。 UInt 或 Int。如果该值小于输入字符串长度，则输入字符串将缩短到 length 个字符。
pad_string — 用于填充输入字符串的字符串。字符串。可选。如果未指定，则用空格填充输入字符串。

返回值

给定长度的左填充字符串。字符串。

示例

SELECT rightPad('abc', 7, '*'), rightPad('abc', 7);

结果

┌─rightPad('abc', 7, '*')─┬─rightPad('abc', 7)─┐
│ abc****                 │ abc                │
└─────────────────────────┴────────────────────┘

rightPadUTF8

在字符串右侧用空格或指定的字符串（如果需要，多次）填充，直到结果字符串达到给定的长度。与 rightPad 以字节为单位测量字符串长度不同，字符串长度以代码点为单位测量。

语法

rightPadUTF8(string, length[, pad_string])

参数

string — 应该填充的输入字符串。字符串。
length — 结果字符串的长度。 UInt 或 Int。如果该值小于输入字符串长度，则输入字符串将缩短到 length 个字符。
pad_string — 用于填充输入字符串的字符串。字符串。可选。如果未指定，则用空格填充输入字符串。

返回值

给定长度的右填充字符串。字符串。

示例

SELECT rightPadUTF8('абвг', 7, '*'), rightPadUTF8('абвг', 7);

结果

┌─rightPadUTF8('абвг', 7, '*')─┬─rightPadUTF8('абвг', 7)─┐
│ абвг***                      │ абвг                    │
└──────────────────────────────┴─────────────────────────┘

lower

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

*语法**

lower(input)

别名：lcase

参数

input：字符串类型字符串。

返回值

字符串数据类型值。

示例

查询

SELECT lower('CLICKHOUSE');

┌─lower('CLICKHOUSE')─┐
│ clickhouse          │
└─────────────────────┘

upper

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

语法

upper(input)

别名：ucase

参数

input — 字符串类型字符串。

返回值

字符串数据类型值。

示例

查询

SELECT upper('clickhouse');

┌─upper('clickhouse')─┐
│ CLICKHOUSE          │
└─────────────────────┘

lowerUTF8

将字符串转换为小写，假设字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

注意

不检测语言，例如对于土耳其语，结果可能不完全正确 (i/İ 与 i/I)。如果 UTF-8 字节序列的长度对于代码点的上下文中不同（例如 ẞ 和 ß），则此代码点的结果可能不正确。

语法

lowerUTF8(input)

参数

input — 字符串类型字符串。

返回值

字符串数据类型值。

示例

查询

SELECT lowerUTF8('MÜNCHEN') as Lowerutf8;

结果

┌─Lowerutf8─┐
│ münchen   │
└───────────┘

upperUTF8

将字符串转换为大写，假设字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

注意

语法

upperUTF8(input)

参数

input — 字符串类型字符串。

返回值

字符串数据类型值。

示例

查询

SELECT upperUTF8('München') as Upperutf8;

结果

┌─Upperutf8─┐
│ MÜNCHEN   │
└───────────┘

isValidUTF8

如果字节集构成有效的 UTF-8 编码文本，则返回 1，否则返回 0。

语法

isValidUTF8(input)

参数

input — 字符串类型字符串。

返回值

如果字节集构成有效的 UTF-8 编码文本，则返回 1，否则返回 0。

查询

SELECT isValidUTF8('\xc3\xb1') AS valid, isValidUTF8('\xc3\x28') AS invalid;

结果

┌─valid─┬─invalid─┐
│     1 │       0 │
└───────┴─────────┘

toValidUTF8

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

语法

toValidUTF8(input_string)

参数

input_string — 任何以字符串数据类型对象表示的字节集。

返回值

有效的 UTF-8 字符串。

示例

SELECT toValidUTF8('\x61\xF0\x80\x80\x80b');

┌─toValidUTF8('a����b')─┐
│ a�b                   │
└───────────────────────┘

repeat

将字符串自身连接指定次数。

语法

repeat(s, n)

别名：REPEAT

参数

s — 要重复的字符串。字符串。
n — 重复字符串的次数。 UInt 或 Int。

返回值

包含字符串 s 重复 n 次的结果字符串。如果 n <= 0，则函数返回空字符串。字符串。

示例

SELECT repeat('abc', 10);

结果

┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘

space

将空格 ( ) 自身连接指定次数。

语法

space(n)

别名：SPACE。

参数

n — 重复空格的次数。 UInt 或 Int。

返回值

包含字符串重复 n 次的结果字符串。如果 n <= 0，则函数返回空字符串。字符串。

示例

查询

SELECT space(3);

结果

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

reverse

反转字符串中字节的顺序。

reverseUTF8

反转字符串中 Unicode 代码点的顺序。假设字符串包含有效的 UTF-8 编码文本。如果此假设被违反，则不会抛出异常，结果未定义。

concat

连接给定的参数。

语法

concat(s1, s2, ...)

参数

任意类型的值。

不是字符串或 FixedString 类型的参数将使用其默认序列化转换为字符串。由于这会降低性能，因此不建议使用非字符串/FixedString 参数。

返回值

通过连接参数创建的字符串。

如果任何参数为 NULL，则函数返回 NULL。

示例

查询

SELECT concat('Hello, ', 'World!');

结果

┌─concat('Hello, ', 'World!')─┐
│ Hello, World!               │
└─────────────────────────────┘

查询

SELECT concat(42, 144);

结果

┌─concat(42, 144)─┐
│ 42144           │
└─────────────────┘

concatAssumeInjective

类似于 concat，但假设 concat(s1, s2, ...) → sn 是单射的。可用于优化 GROUP BY。

如果一个函数对于不同的参数返回不同的结果，则称该函数为单射的。换句话说：不同的参数永远不会产生相同的结果。

语法

concatAssumeInjective(s1, s2, ...)

参数

字符串或 FixedString 类型的值。

返回值

通过连接参数创建的字符串。

如果任何参数值为 NULL，则函数返回 NULL。

示例

输入表

CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog;
INSERT INTO key_val VALUES ('Hello, ','World',1), ('Hello, ','World',2), ('Hello, ','World!',3), ('Hello',', World!',2);
SELECT * from key_val;

┌─key1────┬─key2─────┬─value─┐
│ Hello,  │ World    │     1 │
│ Hello,  │ World    │     2 │
│ Hello,  │ World!   │     3 │
│ Hello   │ , World! │     2 │
└─────────┴──────────┴───────┘

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

使用给定的分隔符连接给定的字符串。

语法

concatWithSeparator(sep, expr1, expr2, expr3...)

别名：concat_ws

参数

sep — 分隔符。常量字符串或 FixedString。
exprN — 要连接的表达式。不是字符串或 FixedString 类型的参数将使用其默认序列化转换为字符串。由于这会降低性能，因此不建议使用非字符串/FixedString 参数。

返回值

通过连接参数创建的字符串。

如果任何参数值为 NULL，则函数返回 NULL。

示例

SELECT concatWithSeparator('a', '1', '2', '3', '4')

结果

┌─concatWithSeparator('a', '1', '2', '3', '4')─┐
│ 1a2a3a4                                      │
└──────────────────────────────────────────────┘

concatWithSeparatorAssumeInjective

类似于 concatWithSeparator，但假设 concatWithSeparator(sep, expr1, expr2, expr3...) → result 是单射的。可用于优化 GROUP BY。

如果一个函数对于不同的参数返回不同的结果，则称该函数为单射的。换句话说：不同的参数永远不会产生相同的结果。

substring

返回字符串 s 的子字符串，该子字符串从指定的字节索引 offset 开始。字节计数从 1 开始。如果 offset 为 0，则返回空字符串。如果 offset 为负数，则子字符串从字符串末尾开始 pos 个字符，而不是从开头开始。可选参数 length 指定返回的子字符串的最大字节数。

语法

substring(s, offset[, length])

别名

substr
mid
byteSlice

参数

s — 要从中计算子字符串的字符串。字符串、FixedString 或枚举
offset — 子字符串在 s 中的起始位置。 (U)Int*。
length — 子字符串的最大长度。 (U)Int*。可选。

返回值

从索引 offset 开始，包含 length 个字节的 s 的子字符串。字符串。

示例

SELECT 'database' AS db, substr(db, 5), substr(db, 5, 1)

结果

┌─db───────┬─substring('database', 5)─┬─substring('database', 5, 1)─┐
│ database │ base                     │ b                           │
└──────────┴──────────────────────────┴─────────────────────────────┘

substringUTF8

返回字符串 s 的子字符串，该子字符串从指定的字节索引 offset 开始，用于 Unicode 代码点。字节计数从 1 开始。如果 offset 为 0，则返回空字符串。如果 offset 为负数，则子字符串从字符串末尾开始 pos 个字符，而不是从开头开始。可选参数 length 指定返回的子字符串的最大字节数。

假设字符串包含有效的 UTF-8 编码文本。如果此假设被违反，则不会抛出异常，结果未定义。

语法

substringUTF8(s, offset[, length])

参数

s — 要从中计算子字符串的字符串。字符串、FixedString 或枚举
offset — 子字符串在 s 中的起始位置。 (U)Int*。
length — 子字符串的最大长度。 (U)Int*。可选。

返回值

从索引 offset 开始，包含 length 个字节的 s 的子字符串。

实现细节

假设字符串包含有效的 UTF-8 编码文本。如果此假设被违反，则不会抛出异常，结果未定义。

示例

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

substringIndex

返回 s 在分隔符 delim 出现的 count 次之前之前的子字符串，如 Spark 或 MySQL 中一样。

语法

substringIndex(s, delim, count)

别名：SUBSTRING_INDEX

参数

s — 要从中提取子字符串的字符串。字符串。
delim — 要分割的字符。字符串。
count — 在提取子字符串之前要计算的分隔符出现的次数。如果 count 为正，则返回最终分隔符（从左侧开始计数）左侧的所有内容。如果 count 为负，则返回最终分隔符（从右侧开始计数）右侧的所有内容。 UInt 或 Int

示例

SELECT substringIndex('www.clickhouse.com', '.', 2)

结果

┌─substringIndex('www.clickhouse.com', '.', 2)─┐
│ www.clickhouse                               │
└──────────────────────────────────────────────┘

substringIndexUTF8

返回 s 在分隔符 delim 出现的 count 次之前之前的子字符串，专门用于 Unicode 代码点。

假设字符串包含有效的 UTF-8 编码文本。如果此假设被违反，则不会抛出异常，结果未定义。

语法

substringIndexUTF8(s, delim, count)

参数

s — 要从中提取子字符串的字符串。字符串。
delim — 要分割的字符。字符串。
count — 在提取子字符串之前要计算的分隔符出现的次数。如果 count 为正，则返回最终分隔符（从左侧开始计数）左侧的所有内容。如果 count 为负，则返回最终分隔符（从右侧开始计数）右侧的所有内容。 UInt 或 Int

返回值

s 在 delim 出现的 count 次之前之前的子字符串字符串。

实现细节

假设字符串包含有效的 UTF-8 编码文本。如果此假设被违反，则不会抛出异常，结果未定义。

示例

SELECT substringIndexUTF8('www.straßen-in-europa.de', '.', 2)

www.straßen-in-europa

appendTrailingCharIfAbsent

如果 s 不为空且不以字符 c 结尾，则将字符 c 附加到字符串 s。

语法

appendTrailingCharIfAbsent(s, c)

convertCharset

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

语法

convertCharset(s, from, to)

base58Encode

使用 Base58 中的“比特币”字母表对字符串进行编码。

语法

base58Encode(plaintext)

参数

plaintext — 字符串列或常量。

返回值

包含参数编码值的字符串。字符串。

示例

SELECT base58Encode('Encoded');

结果

┌─base58Encode('Encoded')─┐
│ 3dc8KtHrwM              │
└─────────────────────────┘

base58Decode

接受一个字符串并使用 Base58 编码方案使用“比特币”字母表对其进行解码。

语法

base58Decode(encoded)

参数

encoded — 字符串列或常量。如果字符串不是有效的 Base58 编码值，则会抛出异常。

返回值

包含参数解码值的字符串。字符串。

示例

SELECT base58Decode('3dc8KtHrwM');

结果

┌─base58Decode('3dc8KtHrwM')─┐
│ Encoded                    │
└────────────────────────────┘

tryBase58Decode

类似于 base58Decode，但在发生错误时返回空字符串。

语法

tryBase58Decode(encoded)

参数

encoded: 字符串列或常量。如果字符串不是有效的 Base58 编码值，则在发生错误时返回空字符串。

返回值

包含参数解码值的字符串。

示例

查询

SELECT tryBase58Decode('3dc8KtHrwM') as res, tryBase58Decode('invalid') as res_invalid;

┌─res─────┬─res_invalid─┐
│ Encoded │             │
└─────────┴─────────────┘

base64Encode

根据 RFC 4648 将字符串或 FixedString 编码为 base64。

别名：TO_BASE64。

语法

base64Encode(plaintext)

参数

plaintext — 字符串列或常量。

返回值

包含参数编码值的字符串。

示例

SELECT base64Encode('clickhouse');

结果

┌─base64Encode('clickhouse')─┐
│ Y2xpY2tob3VzZQ==           │
└────────────────────────────┘

base64URLEncode

根据 RFC 4648 将 URL（字符串或 FixedString）编码为带有 URL 特定修改的 base64。

语法

base64URLEncode(url)

参数

url — 字符串列或常量。

返回值

包含参数编码值的字符串。

示例

SELECT base64URLEncode('https://clickhouse.ac.cn');

结果

┌─base64URLEncode('https://clickhouse.ac.cn')─┐
│ aHR0cDovL2NsaWNraG91c2UuY29t              │
└───────────────────────────────────────────┘

base64Decode

接受一个字符串并根据 RFC 4648 从 base64 解码它。如果发生错误，则会抛出异常。

别名：FROM_BASE64。

语法

base64Decode(encoded)

参数

encoded — 字符串列或常量。如果字符串不是有效的 Base64 编码值，则会抛出异常。

返回值

包含参数解码值的字符串。

示例

SELECT base64Decode('Y2xpY2tob3VzZQ==');

结果

┌─base64Decode('Y2xpY2tob3VzZQ==')─┐
│ clickhouse                       │
└──────────────────────────────────┘

base64URLDecode

接受一个 base64 编码的 URL 并根据 RFC 4648 从带有 URL 特定修改的 base64 解码它。如果发生错误，则会抛出异常。

语法

base64URLDecode(encodedUrl)

参数

encodedURL — 字符串列或常量。如果字符串不是有效的带有 URL 特定修改的 Base64 编码值，则会抛出异常。

返回值

包含参数解码值的字符串。

示例

SELECT base64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t');

结果

┌─base64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t')─┐
│ https://clickhouse.ac.cn                          │
└─────────────────────────────────────────────────┘

tryBase64Decode

类似于 base64Decode，但在发生错误时返回空字符串。

语法

tryBase64Decode(encoded)

参数

encoded — 字符串列或常量。如果字符串不是有效的 Base64 编码值，则返回空字符串。

返回值

包含参数解码值的字符串。

示例

查询

SELECT tryBase64Decode('RW5jb2RlZA==') as res, tryBase64Decode('invalid') as res_invalid;

┌─res────────┬─res_invalid─┐
│ clickhouse │             │
└────────────┴─────────────┘

tryBase64URLDecode

类似于 base64URLDecode，但在发生错误时返回空字符串。

语法

tryBase64URLDecode(encodedUrl)

参数

encodedURL — 字符串列或常量。如果字符串不是有效的带有 URL 特定修改的 Base64 编码值，则返回空字符串。

返回值

包含参数解码值的字符串。

示例

查询

SELECT tryBase64URLDecode('aHR0cDovL2NsaWNraG91c2UuY29t') as res, tryBase64Decode('aHR0cHM6Ly9jbGlja') as res_invalid;

┌─res────────────────────┬─res_invalid─┐
│ https://clickhouse.ac.cn │             │
└────────────────────────┴─────────────┘

endsWith

返回字符串 str 是否以 suffix 结尾。

语法

endsWith(str, suffix)

endsWithUTF8

返回字符串 str 是否以 suffix 结尾，endsWithUTF8 和 endsWith 之间的区别在于 endsWithUTF8 通过 UTF-8 字符匹配 str 和 suffix。

语法

endsWithUTF8(str, suffix)

示例

SELECT endsWithUTF8('中国', '\xbd'), endsWith('中国', '\xbd')

结果

┌─endsWithUTF8('中国', '½')─┬─endsWith('中国', '½')─┐
│                        0 │                    1 │
└──────────────────────────┴──────────────────────┘

startsWith

返回字符串str是否以prefix开头。

语法

startsWith(str, prefix)

示例

SELECT startsWith('Spider-Man', 'Spi');

startsWithUTF8

在版本中可用23.8及更高版本

返回字符串str是否以prefix开头，startsWithUTF8和startsWith的区别在于startsWithUTF8使用UTF-8字符匹配str和suffix。

示例

SELECT startsWithUTF8('中国', '\xe4'), startsWith('中国', '\xe4')

结果

┌─startsWithUTF8('中国', '⥩─┬─startsWith('中国', '⥩─┐
│                          0 │                      1 │
└────────────────────────────┴────────────────────────┘

trim

删除字符串开头或结尾的指定字符。如果未另行指定，则该函数将删除空格（ASCII 字符 32）。

语法

trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string)

参数

trim_character — 指定用于修剪的字符。字符串。
input_string — 用于修剪的字符串。字符串。

返回值

没有前导和/或尾随指定字符的字符串。字符串。

示例

SELECT trim(BOTH ' ()' FROM '(   Hello, world!   )');

结果

┌─trim(BOTH ' ()' FROM '(   Hello, world!   )')─┐
│ Hello, world!                                 │
└───────────────────────────────────────────────┘

trimLeft

删除字符串开头连续出现的空格（ASCII 字符 32）。

语法

trimLeft(input_string)

别名：ltrim(input_string)。

参数

input_string — 要修剪的字符串。字符串。

返回值

没有前导空格的字符串。字符串。

示例

SELECT trimLeft('     Hello, world!     ');

结果

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

trimRight

删除字符串结尾连续出现的空格（ASCII 字符 32）。

语法

trimRight(input_string)

别名：rtrim(input_string)。

参数

input_string — 要修剪的字符串。字符串。

返回值

没有尾随空格的字符串。字符串。

示例

SELECT trimRight('     Hello, world!     ');

结果

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

trimBoth

删除字符串两端连续出现的空格（ASCII 字符 32）。

语法

trimBoth(input_string)

别名：trim(input_string)。

参数

input_string — 要修剪的字符串。字符串。

返回值

没有前导和尾随空格的字符串。字符串。

示例

SELECT trimBoth('     Hello, world!     ');

结果

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

CRC32

使用 CRC-32-IEEE 802.3 多项式和初始值0xffffffff（zlib 实现）返回字符串的 CRC32 校验和。

结果类型为 UInt32。

CRC32IEEE

返回字符串的 CRC32 校验和，使用 CRC-32-IEEE 802.3 多项式。

结果类型为 UInt32。

CRC64

返回字符串的 CRC64 校验和，使用 CRC-64-ECMA 多项式。

结果类型为 UInt64。

normalizeQuery

用占位符?替换文字、文字序列和复杂别名（包含空格、超过两位数字或至少 36 字节长的字符串，例如 UUID）。

语法

normalizeQuery(x)

参数

x — 字符序列。字符串。

返回值

包含占位符的字符序列。字符串。

示例

查询

SELECT normalizeQuery('[1, 2, 3, x]') AS query;

结果

┌─query────┐
│ [?.., x] │
└──────────┘

normalizeQueryKeepNames

用占位符?替换文字、文字序列，但不替换复杂别名（包含空格、超过两位数字或至少 36 字节长的字符串，例如 UUID）。这有助于更好地分析复杂的查询日志。

语法

normalizeQueryKeepNames(x)

参数

x — 字符序列。字符串。

返回值

包含占位符的字符序列。字符串。

示例

查询

SELECT normalizeQuery('SELECT 1 AS aComplexName123'), normalizeQueryKeepNames('SELECT 1 AS aComplexName123');

结果

┌─normalizeQuery('SELECT 1 AS aComplexName123')─┬─normalizeQueryKeepNames('SELECT 1 AS aComplexName123')─┐
│ SELECT ? AS `?`                               │ SELECT ? AS aComplexName123                            │
└───────────────────────────────────────────────┴────────────────────────────────────────────────────────┘

normalizedQueryHash

对于类似的查询，返回相同的 64 位哈希值，但不包含文字的值。可以帮助分析查询日志。

语法

normalizedQueryHash(x)

参数

x — 字符序列。字符串。

返回值

哈希值。 UInt64。

示例

查询

SELECT normalizedQueryHash('SELECT 1 AS `xyz`') != normalizedQueryHash('SELECT 1 AS `abc`') AS res;

结果

┌─res─┐
│   1 │
└─────┘

normalizedQueryHashKeepNames

与 normalizedQueryHash 一样，它返回相同的 64 位哈希值，但不包含类似查询的文字值，但它不会在哈希之前用占位符替换复杂别名（包含空格、超过两位数字或至少 36 字节长的字符串，例如 UUID）。可以帮助分析查询日志。

语法

normalizedQueryHashKeepNames(x)

参数

x — 字符序列。字符串。

返回值

哈希值。 UInt64。

示例

SELECT normalizedQueryHash('SELECT 1 AS `xyz123`') != normalizedQueryHash('SELECT 1 AS `abc123`') AS normalizedQueryHash;
SELECT normalizedQueryHashKeepNames('SELECT 1 AS `xyz123`') != normalizedQueryHashKeepNames('SELECT 1 AS `abc123`') AS normalizedQueryHashKeepNames;

结果

┌─normalizedQueryHash─┐
│                   0 │
└─────────────────────┘
┌─normalizedQueryHashKeepNames─┐
│                            1 │
└──────────────────────────────┘

normalizeUTF8NFC

将字符串转换为 NFC 规范化形式，假设字符串是有效的 UTF8 编码文本。

语法

normalizeUTF8NFC(words)

参数

words — UTF8 编码的输入字符串。字符串。

返回值

转换为 NFC 规范化形式的字符串。字符串。

示例

SELECT length('â'), normalizeUTF8NFC('â') AS nfc, length(nfc) AS nfc_len;

结果

┌─length('â')─┬─nfc─┬─nfc_len─┐
│           2 │ â   │       2 │
└─────────────┴─────┴─────────┘

normalizeUTF8NFD

将字符串转换为 NFD 规范化形式，假设字符串是有效的 UTF8 编码文本。

语法

normalizeUTF8NFD(words)

参数

words — UTF8 编码的输入字符串。字符串。

返回值

转换为 NFD 规范化形式的字符串。字符串。

示例

SELECT length('â'), normalizeUTF8NFD('â') AS nfd, length(nfd) AS nfd_len;

结果

┌─length('â')─┬─nfd─┬─nfd_len─┐
│           2 │ â   │       3 │
└─────────────┴─────┴─────────┘

normalizeUTF8NFKC

将字符串转换为 NFKC 规范化形式，假设字符串是有效的 UTF8 编码文本。

语法

normalizeUTF8NFKC(words)

参数

words — UTF8 编码的输入字符串。字符串。

返回值

转换为 NFKC 规范化形式的字符串。字符串。

示例

SELECT length('â'), normalizeUTF8NFKC('â') AS nfkc, length(nfkc) AS nfkc_len;

结果

┌─length('â')─┬─nfkc─┬─nfkc_len─┐
│           2 │ â    │        2 │
└─────────────┴──────┴──────────┘

normalizeUTF8NFKD

将字符串转换为 NFKD 规范化形式，假设字符串是有效的 UTF8 编码文本。

语法

normalizeUTF8NFKD(words)

参数

words — UTF8 编码的输入字符串。字符串。

返回值

转换为 NFKD 规范化形式的字符串。字符串。

示例

SELECT length('â'), normalizeUTF8NFKD('â') AS nfkd, length(nfkd) AS nfkd_len;

结果

┌─length('â')─┬─nfkd─┬─nfkd_len─┐
│           2 │ â    │        3 │
└─────────────┴──────┴──────────┘

encodeXMLComponent

转义 XML 中具有特殊含义的字符，以便之后可以将其放置到 XML 文本节点或属性中。

替换以下字符：<、&、>、"、'。另请参阅 XML 和 HTML 字符实体引用列表。

语法

encodeXMLComponent(x)

参数

x — 输入字符串。字符串。

返回值

转义后的字符串。字符串。

示例

SELECT encodeXMLComponent('Hello, "world"!');
SELECT encodeXMLComponent('<123>');
SELECT encodeXMLComponent('&clickhouse');
SELECT encodeXMLComponent('\'foo\'');

结果

Hello, &quot;world&quot;!
&lt;123&gt;
&amp;clickhouse
&apos;foo&apos;

decodeXMLComponent

取消转义 XML 中具有特殊含义的子字符串。这些子字符串为：" & ' > <

此函数还将数字字符引用替换为 Unicode 字符。支持十进制（如✓）和十六进制（✓）形式。

语法

decodeXMLComponent(x)

参数

x — 输入字符串。字符串。

返回值

取消转义后的字符串。字符串。

示例

SELECT decodeXMLComponent('&apos;foo&apos;');
SELECT decodeXMLComponent('&lt; &#x3A3; &gt;');

结果

'foo'
< Σ >

decodeHTMLComponent

取消转义 HTML 中具有特殊含义的子字符串。例如：&hbar; > &diamondsuit; &heartsuit; < 等。

此函数还将数字字符引用替换为 Unicode 字符。支持十进制（如✓）和十六进制（✓）形式。

语法

decodeHTMLComponent(x)

参数

x — 输入字符串。字符串。

返回值

取消转义后的字符串。字符串。

示例

SELECT decodeHTMLComponent(''CH');
SELECT decodeHTMLComponent('I&heartsuit;ClickHouse');

结果

'CH'
I♥ClickHouse'

extractTextFromHTML

此函数从 HTML 或 XHTML 中提取纯文本。

它不完全符合 HTML、XML 或 XHTML 规范，但实现相当准确且快速。规则如下

跳过注释。例如：。注释必须以-->结尾。不允许嵌套注释。注意：之类的结构在 HTML 中不是有效的注释，但它们会被其他规则跳过。
逐字粘贴 CDATA。注意：CDATA 是 XML/XHTML 特定的，并且基于“尽力而为”的基础进行处理。
script和style元素及其所有内容都被删除。注意：假设结束标签不能出现在内容内部。例如，在 JS 字符串文字中必须转义为"<\/script>"。注意：注释和 CDATA 可能在script或style内部 - 然后在 CDATA 内部不搜索结束标签。例如：<script><![CDATA[</script>]]></script>。但它们仍在注释内部搜索。有时会变得复杂：<script>var x = ""; alert(x + y);</script> 注意：script和style可以是 XML 命名空间的名称 - 然后它们不被视为普通的script或style元素。例如：<script:a>Hello</script:a>。注意：在结束标签名称后可能存在空格：</script >，但在之前不存在：< / script>。
跳过其他标签或类似标签的元素，不包含内部内容。例如：<a>.</a> 注意：预计此 HTML 非法：<a test=">"></a> 注意：它还跳过类似标签的内容：<>、<!>等。注意：没有结束的标签会被跳过到输入的末尾：<hello
HTML 和 XML 实体不会被解码。它们必须由单独的函数处理。
文本中的空格会根据特定规则折叠或插入。
- 开头和结尾的空格将被删除。
- 连续的空格将被折叠。
- 但是，如果文本由其他元素分隔并且没有空格，则会插入空格。
- 这可能会导致不自然的示例：Hello<b>world</b>、Helloworld - HTML 中没有空格，但该函数会插入空格。另请考虑：Hello<p>world</p>、Hello<br>world。此行为对于数据分析是合理的，例如将 HTML 转换为词袋。
另请注意，正确处理空格需要支持<pre></pre>和 CSS display和white-space属性。

语法

extractTextFromHTML(x)

参数

x — 输入文本。字符串。

返回值

提取的文本。字符串。

示例

第一个示例包含多个标签和一个注释，还显示了空格处理。第二个示例显示了CDATA和script标签处理。在第三个示例中，从 url 函数接收到的完整 HTML 响应中提取文本。

SELECT extractTextFromHTML(' <p> A text <i>with</i><b>tags</b>. <!-- comments --> </p> ');
SELECT extractTextFromHTML('<![CDATA[The content within <b>CDATA</b>]]> <script>alert("Script");</script>');
SELECT extractTextFromHTML(html) FROM url('http://www.donothingfor2minutes.com/', RawBLOB, 'html String');

结果

A text with tags .
The content within <b>CDATA</b>
Do Nothing for 2 Minutes 2:00 &nbsp;

ascii

返回字符串s第一个字符的 ASCII 代码点（作为 Int32）。

如果s为空，则结果为 0。如果第一个字符不是 ASCII 字符或不是 UTF-16 的 Latin-1 补充范围的一部分，则结果未定义。

语法

ascii(s)

soundex

返回字符串的 Soundex 代码。

语法

soundex(val)

参数

val — 输入值。字符串

返回值

输入值的 Soundex 代码。字符串

示例

select soundex('aksel');

结果

┌─soundex('aksel')─┐
│ A240             │
└──────────────────┘

punycodeEncode

返回字符串的 Punycode 表示形式。字符串必须是 UTF8 编码的，否则行为未定义。

语法

punycodeEncode(val)

参数

val — 输入值。字符串

返回值

输入值的 Punycode 表示形式。字符串

示例

select punycodeEncode('München');

结果

┌─punycodeEncode('München')─┐
│ Mnchen-3ya                │
└───────────────────────────┘

punycodeDecode

返回 Punycode 编码字符串的 UTF8 编码纯文本。如果未提供有效的 Punycode 编码字符串，则抛出异常。

语法

punycodeEncode(val)

参数

val — Punycode 编码字符串。字符串

返回值

输入值的纯文本。字符串

示例

select punycodeDecode('Mnchen-3ya');

结果

┌─punycodeDecode('Mnchen-3ya')─┐
│ München                      │
└──────────────────────────────┘

tryPunycodeDecode

类似于 punycodeDecode，但如果未提供有效的 Punycode 编码字符串，则返回空字符串。

idnaEncode

根据应用程序中的国际化域名 (IDNA) 机制，返回域名对应的 ASCII 表示形式（ToASCII 算法）。输入字符串必须是 UTF 编码的并且可以转换为 ASCII 字符串，否则会抛出异常。注意：不执行百分比解码或修剪制表符、空格或控制字符。

语法

idnaEncode(val)

参数

val — 输入值。字符串

返回值

根据 IDNA 机制对输入值进行 ASCII 表示。字符串

示例

select idnaEncode('straße.münchen.de');

结果

┌─idnaEncode('straße.münchen.de')─────┐
│ xn--strae-oqa.xn--mnchen-3ya.de     │
└─────────────────────────────────────┘

tryIdnaEncode

类似于 idnaEncode，但在发生错误时返回空字符串而不是抛出异常。

idnaDecode

根据应用程序中的国际化域名 (IDNA) 机制，返回域名对应的 Unicode（UTF-8）表示形式（ToUnicode 算法）。如果发生错误（例如，因为输入无效），则返回输入字符串。请注意，由于大小写规范化，重复应用 idnaEncode() 和 idnaDecode() 不一定会返回原始字符串。

语法

idnaDecode(val)

参数

val — 输入值。字符串

返回值

根据 IDNA 机制对输入值进行 Unicode（UTF-8）表示。字符串

示例

select idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de');

结果

┌─idnaDecode('xn--strae-oqa.xn--mnchen-3ya.de')─┐
│ straße.münchen.de                             │
└───────────────────────────────────────────────┘

byteHammingDistance

计算两个字节字符串之间的汉明距离。

语法

byteHammingDistance(string1, string2)

示例

SELECT byteHammingDistance('karolin', 'kathrin');

结果

┌─byteHammingDistance('karolin', 'kathrin')─┐
│                                         3 │
└───────────────────────────────────────────┘

别名：mismatches

stringJaccardIndex

计算两个字节字符串之间的 Jaccard 相似度指数。

语法

stringJaccardIndex(string1, string2)

示例

SELECT stringJaccardIndex('clickhouse', 'mouse');

结果

┌─stringJaccardIndex('clickhouse', 'mouse')─┐
│                                       0.4 │
└───────────────────────────────────────────┘

stringJaccardIndexUTF8

类似于 stringJaccardIndex，但适用于 UTF8 编码的字符串。

editDistance

计算两个字节字符串之间的编辑距离。

语法

editDistance(string1, string2)

示例

SELECT editDistance('clickhouse', 'mouse');

结果

┌─editDistance('clickhouse', 'mouse')─┐
│                                   6 │
└─────────────────────────────────────┘

别名：levenshteinDistance

editDistanceUTF8

计算两个 UTF8 字符串之间的编辑距离。

语法

editDistanceUTF8(string1, string2)

示例

SELECT editDistanceUTF8('我是谁', '我是我');

结果

┌─editDistanceUTF8('我是谁', '我是我')──┐
│                                   1 │
└─────────────────────────────────────┘

别名：levenshteinDistanceUTF8

damerauLevenshteinDistance

计算两个字节字符串之间的 Damerau-Levenshtein 距离。

语法

damerauLevenshteinDistance(string1, string2)

示例

SELECT damerauLevenshteinDistance('clickhouse', 'mouse');

结果

┌─damerauLevenshteinDistance('clickhouse', 'mouse')─┐
│                                                 6 │
└───────────────────────────────────────────────────┘

jaroSimilarity

计算两个字节字符串之间的 Jaro 相似度。

语法

jaroSimilarity(string1, string2)

示例

SELECT jaroSimilarity('clickhouse', 'click');

结果

┌─jaroSimilarity('clickhouse', 'click')─┐
│                    0.8333333333333333 │
└───────────────────────────────────────┘

jaroWinklerSimilarity

计算两个字节字符串之间的 Jaro-Winkler 相似度。

语法

jaroWinklerSimilarity(string1, string2)

示例

SELECT jaroWinklerSimilarity('clickhouse', 'click');

结果

┌─jaroWinklerSimilarity('clickhouse', 'click')─┐
│                           0.8999999999999999 │
└──────────────────────────────────────────────┘

initcap

将每个单词的第一个字母转换为大写，其余字母转换为小写。单词是由非字母数字字符分隔的字母数字字符序列。

注意

因为 initCap 只将每个单词的第一个字母转换为大写，所以您可能会观察到包含撇号或大写字母的单词出现意外行为。例如

SELECT initCap('mother''s daughter'), initCap('joe McAdam');

将返回

┌─initCap('mother\'s daughter')─┬─initCap('joe McAdam')─┐
│ Mother'S Daughter             │ Joe Mcadam            │
└───────────────────────────────┴───────────────────────┘

这是一个已知行为，目前没有计划修复它。

语法

initcap(val)

参数

val — 输入值。字符串。

返回值

val，其中每个单词的第一个字母已转换为大写。字符串。

示例

查询

SELECT initcap('building for fast');

结果

┌─initcap('building for fast')─┐
│ Building For Fast            │
└──────────────────────────────┘

initcapUTF8

类似于 initcap，initcapUTF8 将每个单词的第一个字母转换为大写，其余字母转换为小写。假设字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

注意

此函数不检测语言，例如对于土耳其语，结果可能不完全正确（i/İ 与 i/I）。如果 UTF-8 字节序列的长度对于某个代码点的上下大小写不同，则该代码点的结果可能不正确。

语法

initcapUTF8(val)

参数

val — 输入值。字符串。

返回值

val，其中每个单词的第一个字母已转换为大写。字符串。

示例

查询

SELECT initcapUTF8('не тормозит');

结果

┌─initcapUTF8('не тормозит')─┐
│ Не Тормозит                │
└────────────────────────────┘

firstLine

从多行字符串中返回第一行。

语法

firstLine(val)

参数

val — 输入值。字符串

返回值

输入值的第一行，如果不存在换行符，则为整个值。字符串

示例

select firstLine('foo\nbar\nbaz');

结果

┌─firstLine('foo\nbar\nbaz')─┐
│ foo                        │
└────────────────────────────┘

字符串函数

empty​

notEmpty​

length​

lengthUTF8​

left​

leftUTF8​

leftPad​

leftPadUTF8​

right​

rightUTF8​

rightPad​

rightPadUTF8​

lower​

upper​

lowerUTF8​

upperUTF8​

isValidUTF8​

toValidUTF8​

repeat​

space​

reverse​

reverseUTF8​

concat​

concatAssumeInjective​

concatWithSeparator​

concatWithSeparatorAssumeInjective​

substring​

substringUTF8​

substringIndex​

substringIndexUTF8​

appendTrailingCharIfAbsent​

convertCharset​

base58Encode​

base58Decode​

tryBase58Decode​

base64Encode​

base64URLEncode​

base64Decode​

base64URLDecode​

tryBase64Decode​

tryBase64URLDecode​

endsWith​

endsWithUTF8​

startsWith​

startsWithUTF8​

trim​

trimLeft​

trimRight​

trimBoth​

CRC32​

CRC32IEEE​

CRC64​

normalizeQuery​

normalizeQueryKeepNames​

normalizedQueryHash​

normalizedQueryHashKeepNames​

normalizeUTF8NFC​

normalizeUTF8NFD​

normalizeUTF8NFKC​

normalizeUTF8NFKD​

encodeXMLComponent​

decodeXMLComponent​

decodeHTMLComponent​

extractTextFromHTML​

ascii​

soundex​

punycodeEncode​

punycodeDecode​

tryPunycodeDecode​

idnaEncode​

tryIdnaEncode​

idnaDecode​

byteHammingDistance​

stringJaccardIndex​

stringJaccardIndexUTF8​

editDistance​

editDistanceUTF8​

damerauLevenshteinDistance​

jaroSimilarity​

empty

notEmpty

length

lengthUTF8

left

leftUTF8

leftPad

leftPadUTF8

right

rightUTF8

rightPad

rightPadUTF8

lower

upper

lowerUTF8

upperUTF8

isValidUTF8

toValidUTF8

repeat

space

reverse

reverseUTF8

concat

concatAssumeInjective

concatWithSeparator

concatWithSeparatorAssumeInjective

substring

substringUTF8

substringIndex

substringIndexUTF8

appendTrailingCharIfAbsent

convertCharset

base58Encode

base58Decode

tryBase58Decode

base64Encode

base64URLEncode

base64Decode

base64URLDecode

tryBase64Decode

tryBase64URLDecode

endsWith

endsWithUTF8

startsWith

startsWithUTF8

trim

trimLeft

trimRight

trimBoth

CRC32

CRC32IEEE

CRC64

normalizeQuery

normalizeQueryKeepNames

normalizedQueryHash

normalizedQueryHashKeepNames

normalizeUTF8NFC

normalizeUTF8NFD

normalizeUTF8NFKC

normalizeUTF8NFKD

encodeXMLComponent

decodeXMLComponent

decodeHTMLComponent

extractTextFromHTML

ascii

soundex

punycodeEncode

punycodeDecode

tryPunycodeDecode

idnaEncode

tryIdnaEncode

idnaDecode

byteHammingDistance

stringJaccardIndex

stringJaccardIndexUTF8

editDistance

editDistanceUTF8

damerauLevenshteinDistance

jaroSimilarity

jaroWinklerSimilarity