处理字符串的函数

在字符串中搜索和在字符串中替换的函数是分别描述的。

注意

以下文档是从 system.functions 系统表生成的。

CRC32

引入于: v20.1

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

语法

CRC32(s)

参数

s — 要计算 CRC32 的字符串。 String

返回值

返回字符串的 CRC32 校验和。 UInt32

示例

使用示例

SELECT CRC32('ClickHouse')

┌─CRC32('ClickHouse')─┐
│          1538217360 │
└─────────────────────┘

CRC32IEEE

引入于: v20.1

使用 CRC-32-IEEE 802.3 多项式计算字符串的 CRC32 校验和。

语法

CRC32IEEE(s)

参数

s — 要计算 CRC32 的字符串。 String

返回值

返回字符串的 CRC32 校验和。 UInt32

示例

使用示例

SELECT CRC32IEEE('ClickHouse');

┌─CRC32IEEE('ClickHouse')─┐
│              3089448422 │
└─────────────────────────┘

CRC64

引入于: v20.1

使用 CRC-64-ECMA 多项式计算字符串的 CRC64 校验和。

语法

CRC64(s)

参数

s — 要计算 CRC64 的字符串。 String

返回值

返回字符串的 CRC64 校验和。 UInt64

示例

使用示例

SELECT CRC64('ClickHouse');

┌──CRC64('ClickHouse')─┐
│ 12126588151325169346 │
└──────────────────────┘

appendTrailingCharIfAbsent

引入于：v1.1

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

语法

appendTrailingCharIfAbsent(s, c)

参数

s — 输入字符串。 String
c — 如果不存在则要追加的字符。 String

返回值

如果 s 不以 c 结尾，则返回附加了字符 c 的字符串 s。 String

示例

使用示例

SELECT appendTrailingCharIfAbsent('https://example.com', '/');

┌─appendTraili⋯.com', '/')─┐
│ https://example.com/     │
└──────────────────────────┘

ascii

引入于：v22.11

以 Int32 的形式返回字符串 s 的第一个字符的 ASCII 码点。

语法

ascii(s)

参数

s — 字符串输入。 String

返回值

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

示例

使用示例

SELECT ascii('234')

┌─ascii('234')─┐
│           50 │
└──────────────┘

base32Decode

引入于: v25.6

解码一个 Base32 (RFC 4648) 字符串。如果字符串不是有效的 Base32 编码，则会抛出异常。

语法

base32Decode(encoded)

参数

encoded — 字符串列或常量。 String

返回值

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

示例

使用示例

SELECT base32Decode('IVXGG33EMVSA====');

┌─base32Decode('IVXGG33EMVSA====')─┐
│ Encoded                          │
└──────────────────────────────────┘

base32Encode

引入于: v25.6

使用 Base32 编码一个字符串。

语法

base32Encode(plaintext)

参数

plaintext — 要编码的纯文本。 String

返回值

返回包含参数编码值的字符串。 String 或 FixedString

示例

使用示例

SELECT base32Encode('Encoded')

┌─base32Encode('Encoded')─┐
│ IVXGG33EMVSA====        │
└─────────────────────────┘

base58Decode

引入于：v22.7

解码一个 Base58 字符串。如果字符串不是有效的 Base58 编码，则会抛出异常。

语法

base58Decode(encoded)

参数

encoded — 要解码的字符串列或常量。 String

返回值

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

示例

使用示例

SELECT base58Decode('JxF12TrwUP45BMd');

┌─base58Decode⋯rwUP45BMd')─┐
│ Hello World              │
└──────────────────────────┘

base58Encode

引入于：v22.7

使用 Base58 编码编码一个字符串。

语法

base58Encode(plaintext)

参数

plaintext — 要编码的纯文本。 String

返回值

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

示例

使用示例

SELECT base58Encode('ClickHouse');

┌─base58Encode('ClickHouse')─┐
│ 4nhk8K7GHXf6zx             │
└────────────────────────────┘

base64Decode

引入于: v18.16

根据 RFC 4648 从 Base64 表示法解码一个字符串。如果出现错误，则抛出异常。

语法

base64Decode(encoded)

别名: FROM_BASE64

参数

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

返回值

返回解码后的字符串。 String

示例

使用示例

SELECT base64Decode('Y2xpY2tob3VzZQ==')

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

base64Encode

引入于: v18.16

根据 RFC 4648 使用 Base64 表示法编码一个字符串。

语法

base64Encode(plaintext)

别名: TO_BASE64

参数

plaintext — 要解码的纯文本列或常量。 String

返回值

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

示例

使用示例

SELECT base64Encode('clickhouse')

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

base64URLDecode

引入于: v24.6

根据 RFC 4648 使用 URL 安全字母从 Base64 表示法解码一个字符串。如果出现错误，则抛出异常。

语法

base64URLDecode(encoded)

参数

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

返回值

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

示例

使用示例

SELECT base64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')

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

base64URLEncode

引入于: v18.16

使用 Base64 (RFC 4648) 表示法使用 URL 安全字母编码一个字符串。

语法

base64URLEncode(plaintext)

参数

plaintext — 要编码的纯文本列或常量。 String

返回值

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

示例

使用示例

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

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

basename

引入于: v20.1

提取字符串在最后一个斜杠或反斜杠之后的尾部。此函数通常用于从路径中提取文件名。

语法

basename(expr)

参数

expr — 一个字符串表达式。必须转义反斜杠。 String

返回值

返回输入字符串在最后一个斜杠或反斜杠之后的尾部。如果输入字符串以斜杠或反斜杠结尾，则该函数返回一个空字符串。如果没有斜杠或反斜杠，则返回原始字符串。 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                               │
└────────────────────────┴────────────────────────────────────┘

从 Windows 路径提取文件名

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

引入于: v23.9

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

语法

byteHammingDistance(s1, s2)

别名: mismatches

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的汉明距离。 UInt64

示例

使用示例

SELECT byteHammingDistance('karolin', 'kathrin')

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

compareSubstrings

引入于: v25.2

词法比较两个字符串。

语法

compareSubstrings(s1, s2, s1_offset, s2_offset, num_bytes)

参数

s1 — 要比较的第一个字符串。 String
s2 — 要比较的第二个字符串。 String
s1_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 │
└────────┘

concat

引入于：v1.1

连接给定的参数。

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

语法

concat([s1, s2, ...])

参数

s1, s2, ... — 任意类型的任意数量的值。 Any

返回值

返回通过连接参数创建的 String。如果任何参数为 NULL，则该函数返回 NULL。如果没有参数，则返回一个空字符串。 Nullable(String)

示例

字符串连接

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

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

数字连接

SELECT concat(42, 144)

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

concatAssumeInjective

引入于：v1.1

类似于 concat，但假定 concat(s1, s2, ...) → sn 是单射的，即，它为不同的参数返回不同的结果。

可用于优化 GROUP BY。

语法

concatAssumeInjective([s1, s2, ...])

参数

s1, s2, ... — 任意类型的任意数量的值。 String 或 FixedString

返回值

返回通过连接参数创建的字符串。如果任何参数值为 NULL，则该函数返回 NULL。如果没有传递参数，则返回一个空字符串。 String

示例

分组优化

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

引入于：v22.12

连接提供的字符串，用指定的分隔符分隔它们。

语法

concatWithSeparator(sep[, exp1, exp2, ...])

别名: concat_ws

参数

sep — 要使用的分隔符。 const String 或 const FixedString
exp1, 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

引入于：v22.12

类似于 concatWithSeparator，但假定 concatWithSeparator(sep[,exp1, exp2, ... ]) → result 是单射的。如果函数对不同的参数返回不同的结果，则称该函数为单射。

可用于优化 GROUP BY。

语法

concatWithSeparatorAssumeInjective(sep[, exp1, exp2, ... ])

参数

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

返回值

返回通过连接参数创建的 String。如果任何参数值为 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

引入于：v1.1

在不同的数字基数之间转换数字。

该函数将数字从一个基数转换为另一个基数。它支持从 2 到 36 的基数。对于大于 10 的基数，使用字母 A-Z（不区分大小写）表示数字 10-35。

此函数与 MySQL 的 CONV() 函数兼容。

语法

conv(number, from_base, to_base)

参数

number — 要转换的数字。可以是字符串或数字类型。 - from_base — 源基数（2-36）。必须是整数。 - to_base — 目标基数（2-36）。必须是整数。

返回值

目标基数中数字的字符串表示形式。

示例

将十进制转换为二进制

SELECT conv('10', 10, 2)

将十六进制转换为十进制

SELECT conv('FF', 16, 10)

使用负数转换

SELECT conv('-1', 10, 16)

FFFFFFFFFFFFFFFF

将二进制转换为八进制

SELECT conv('1010', 2, 8)

convertCharset

引入于：v1.1

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

语法

convertCharset(s, from, to)

参数

s — 输入字符串。 String
from — 源字符编码。 String
to — 目标字符编码。 String

返回值

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

示例

使用示例

SELECT convertCharset('Café', 'UTF-8', 'ISO-8859-1');

┌─convertChars⋯SO-8859-1')─┐
│ Caf�                     │
└──────────────────────────┘

damerauLevenshteinDistance

引入版本: v24.1

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

语法

damerauLevenshteinDistance(s1, s2)

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的 Damerau-Levenshtein 距离。 UInt64

示例

使用示例

SELECT damerauLevenshteinDistance('clickhouse', 'mouse')

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

decodeHTMLComponent

引入于: v23.9

将字符串中的 HTML 实体解码为其对应的字符。

语法

decodeHTMLComponent(s)

参数

s — 包含要解码的 HTML 实体的字符串。 String

返回值

返回已解码 HTML 实体的字符串。 String

示例

使用示例

SELECT decodeHTMLComponent('&lt;div&gt;Hello &amp; &quot;World&quot;&lt;/div&gt;')

┌─decodeHTMLComponent('&lt;div&gt;Hello &amp; &quot;World&quot;&lt;/div&gt;')─┐
│ <div>Hello & "World"</div>                                                  │
└─────────────────────────────────────────────────────────────────────────────┘

decodeXMLComponent

引入于: v21.2

将字符串中的 XML 实体解码为其对应的字符。

语法

decodeXMLComponent(s)

参数

s — 包含要解码的 XML 实体的字符串。 String

返回值

返回已解码 XML 实体的提供的字符串。 String

示例

使用示例

SELECT decodeXMLComponent('&lt;tag&gt;Hello &amp; World&lt;/tag&gt;')

┌─decodeXMLCom⋯;/tag&gt;')─┐
│ <tag>Hello & World</tag> │
└──────────────────────────┘

editDistance

引入于: v23.9

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

语法

editDistance(s1, s2)

别名: levenshteinDistance

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的编辑距离。 UInt64

示例

使用示例

SELECT editDistance('clickhouse', 'mouse')

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

editDistanceUTF8

引入于: v24.6

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

语法

editDistanceUTF8(s1, s2)

别名: levenshteinDistanceUTF8

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个 UTF8 字符串之间的编辑距离。 UInt64

示例

使用示例

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

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

encodeXMLComponent

引入于：v21.1

转义字符以将字符串放置到 XML 文本节点或属性中。

语法

encodeXMLComponent(s)

参数

s — 要转义的字符串。 String

返回值

返回转义后的字符串。 String

示例

使用示例

SELECT
    '<tag>Hello & "World"</tag>' AS original,
    encodeXMLComponent('<tag>Hello & "World"</tag>') AS xml_encoded;

┌─original───────────────────┬─xml_encoded──────────────────────────────────────────┐
│ <tag>Hello & "World"</tag> │ &lt;tag&gt;Hello &amp; &quot;World&quot;&lt;/tag&gt; │
└────────────────────────────┴──────────────────────────────────────────────────────┘

endsWith

引入于：v1.1

检查字符串是否以提供的后缀结尾。

语法

endsWith(s, suffix)

参数

s — 要检查的字符串。 String
suffix — 要检查的后缀。 String

返回值

如果 s 以 suffix 结尾，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT endsWith('ClickHouse', 'House');

┌─endsWith('Cl⋯', 'House')─┐
│                        1 │
└──────────────────────────┘

endsWithCaseInsensitive

引入于: v25.9

检查字符串是否以提供的不区分大小写的后缀结尾。

语法

endsWithCaseInsensitive(s, suffix)

参数

s — 要检查的字符串。 String
suffix — 要检查的不区分大小写的后缀。 String

返回值

如果 s 以不区分大小写的 suffix 结尾，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT endsWithCaseInsensitive('ClickHouse', 'HOUSE');

┌─endsWithCaseInsensitive('Cl⋯', 'HOUSE')─┐
│                                       1 │
└─────────────────────────────────────────┘

endsWithCaseInsensitiveUTF8

引入于: v25.9

返回字符串 s 是否以不区分大小写的 suffix 结尾。假定该字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会引发异常，结果未定义。

语法

endsWithCaseInsensitiveUTF8(s, suffix)

参数

s — 要检查的字符串。 String
suffix — 要检查的不区分大小写的后缀。 String

返回值

如果 s 以不区分大小写的 suffix 结尾，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT endsWithCaseInsensitiveUTF8('данных', 'ых');

┌─endsWithCaseInsensitiveUTF8('данных', 'ых')─┐
│                                           1 │
└─────────────────────────────────────────────┘

endsWithUTF8

引入于：v23.8

返回字符串 s 是否以 suffix 结尾。假定该字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会引发异常，结果未定义。

语法

endsWithUTF8(s, suffix)

参数

s — 要检查的字符串。 String
suffix — 要检查的后缀。 String

返回值

如果 s 以 suffix 结尾，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT endsWithUTF8('данных', 'ых');

┌─endsWithUTF8('данных', 'ых')─┐
│                            1 │
└──────────────────────────────┘

extractTextFromHTML

引入于: v21.3

从 HTML 或 XHTML 中提取文本内容。

此函数删除 HTML 标签、注释和 script/style 元素，仅留下文本内容。它处理

删除所有 HTML/XML 标签
删除注释 ()
删除 script 和 style 元素及其内容
处理 CDATA 部分（逐字复制）
适当的空格处理和规范化

注意：HTML 实体未解码，如果需要，应使用单独的函数进行处理。

语法

extractTextFromHTML(html)

参数

html — 包含要从中提取文本的 HTML 内容的字符串。 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!                │
└────────────────────────────────────────┘

firstLine

引入于: v23.7

返回多行字符串的第一行。

语法

firstLine(s)

参数

s — 输入字符串。 String

返回值

返回输入字符串的第一行，或者如果没有任何行分隔符，则返回整个字符串。 String

示例

使用示例

SELECT firstLine('foo\\nbar\\nbaz')

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

idnaDecode

引入版本: v24.1

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

语法

idnaDecode(s)

参数

s — 输入字符串。 String

返回值

返回根据 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                             │
└───────────────────────────────────────────────┘

idnaEncode

引入版本: v24.1

根据国际域名系统中的应用程序 (IDNA) 机制，返回域名的 ASCII 表示形式（ToASCII 算法）。输入字符串必须是 UTF 编码的并且可以转换为 ASCII 字符串，否则会引发异常。

注意

不执行百分比解码或修剪制表符、空格或控制字符。

语法

idnaEncode(s)

参数

s — 输入字符串。 String

返回值

返回根据 IDNA 机制的输入值的 ASCII 表示形式。 String

示例

使用示例

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

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

initcap

引入于: v23.7

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

注意

由于 initcap 仅将每个单词的第一个字母转换为大写，因此您可能会观察到包含撇号或大写的单词的意外行为。这是已知行为，目前没有计划修复它。

语法

initcap(s)

参数

s — 输入字符串。 String

返回值

返回将每个单词的第一个字母转换为大写的 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.    │
└──────────────────────────┘

initcapUTF8

引入于: v23.7

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

注意

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

语法

initcapUTF8(s)

参数

s — 输入字符串。 String

返回值

返回将每个单词的第一个字母转换为大写的 s。 String

示例

使用示例

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

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

isValidASCII

引入于: v25.9

如果输入 String 或 FixedString 仅包含 ASCII 字节 (0x00–0x7F)，则返回 1，否则返回 0。针对正例（输入是有效的 ASCII）进行了优化。

语法

别名: isASCII

参数

无。

返回值

示例

isValidASCII

SELECT isValidASCII('hello') AS is_ascii, isValidASCII('你好') AS is_not_ascii

isValidUTF8

引入于: v20.1

检查字节集是否构成有效的 UTF-8 编码文本。

语法

isValidUTF8(s)

参数

s — 要检查 UTF-8 编码有效性的字符串。 String

返回值

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

示例

使用示例

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

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

jaroSimilarity

引入版本: v24.1

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

语法

jaroSimilarity(s1, s2)

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的 Jaro 相似度。 Float64

示例

使用示例

SELECT jaroSimilarity('clickhouse', 'click')

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

jaroWinklerSimilarity

引入版本: v24.1

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

语法

jaroWinklerSimilarity(s1, s2)

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的 Jaro-Winkler 相似度。 Float64

示例

使用示例

SELECT jaroWinklerSimilarity('clickhouse', 'click')

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

left

引入于：v22.1

从左侧指定 offset 处返回字符串 s 的子字符串。

语法

left(s, offset)

参数

s — 要计算子字符串的字符串。 String 或 FixedString
offset — 偏移量的字节数。 (U)Int*

返回值

返回值

对于正 offset，从字符串的左侧开始，返回包含 offset 个字节的 s 的子字符串。
对于负 offset，从字符串的左侧开始，返回包含 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则返回一个空字符串。 String

示例

正偏移量

SELECT left('Hello World', 5)

Hello

负偏移量

SELECT left('Hello World', -6)

Hello

leftPad

引入于: v21.8

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

语法

leftPad(string, length[, pad_string])

别名: lpad

参数

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

返回值

返回具有给定长度的左填充字符串。 String

示例

使用示例

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

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

leftPadUTF8

引入于: v21.8

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

语法

leftPadUTF8(string, length[, pad_string])

参数

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

返回值

返回具有给定长度的左填充字符串。 String

示例

使用示例

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

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

leftUTF8

引入于：v22.1

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

语法

leftUTF8(s, offset)

参数

s — 要计算子字符串的 UTF-8 编码字符串。 String 或 FixedString
offset — 偏移量的字节数。 (U)Int*

返回值

返回值

对于正 offset，从字符串的左侧开始，返回包含 offset 个字节的 s 的子字符串。\n
对于负 offset，从字符串的左侧开始，返回包含 length(s) - |offset| 个字节的 s 的子字符串。\n
如果 length 为 0，则返回一个空字符串。 String

示例

正偏移量

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

Прив

负偏移量

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

Пр

lengthUTF8

引入于：v1.1

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

语法

lengthUTF8(s)

别名: CHARACTER_LENGTH, CHAR_LENGTH

参数

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

返回值

字符串 s 的 Unicode 码点长度。 UInt64

示例

使用示例

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

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

lower

引入于：v1.1

将 ASCII 字符串转换为小写。

语法

lower(s)

别名: lcase

参数

s — 要转换为小写的字符串。 String

返回值

返回从 s 转换成小写的字符串。 String

示例

使用示例

SELECT lower('CLICKHOUSE')

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

lowerUTF8

引入于：v1.1

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

语法

lowerUTF8(input)

参数

input — 要转换为小写的输入字符串。 String

返回值

返回小写字符串。 String

示例

first

SELECT lowerUTF8('München') as Lowerutf8;

münchen

normalizeUTF8NFC

引入于：v21.11

根据 NFC 归一化形式归一化 UTF-8 字符串。

语法

normalizeUTF8NFC(str)

参数

str — UTF-8 编码的输入字符串。 String

返回值

返回 UTF-8 字符串的 NFC 归一化形式。 String

示例

使用示例

SELECT
'é' AS original, -- e + combining acute accent (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 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘

normalizeUTF8NFD

引入于：v21.11

根据 NFD 归一化形式归一化 UTF-8 字符串。

语法

normalizeUTF8NFD(str)

参数

str — UTF-8 编码的输入字符串。 String

返回值

返回 UTF-8 字符串的 NFD 归一化形式。 String

示例

使用示例

SELECT
    'é' AS original, -- é (U+00E9)
    length(original),
    normalizeUTF8NFD('é') AS nfd_normalized, -- e + combining acute (U+0065 + U+0301)
    length(nfd_normalized);

┌─original─┬─length(original)─┬─nfd_normalized─┬─length(nfd_normalized)─┐
│ é        │                2 │ é              │                      3 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘

normalizeUTF8NFKC

引入于：v21.11

根据 NFKC 归一化形式归一化 UTF-8 字符串。

语法

normalizeUTF8NFKC(str)

参数

str — UTF-8 编码的输入字符串。 String

返回值

返回 UTF-8 字符串的 NFKC 归一化形式。 String

示例

使用示例

SELECT
    '① ② ③' AS original,                            -- Circled number characters
    normalizeUTF8NFKC('① ② ③') AS nfkc_normalized;  -- Converts to 1 2 3

┌─original─┬─nfkc_normalized─┐
│ ① ② ③  │ 1 2 3           │
└──────────┴─────────────────┘

normalizeUTF8NFKD

引入于：v21.11

根据 NFKD 归一化形式归一化 UTF-8 字符串。

语法

normalizeUTF8NFKD(str)

参数

str — UTF-8 编码的输入字符串。 String

返回值

返回 UTF-8 字符串的 NFKD 归一化形式。 String

示例

使用示例

SELECT
    'H₂O²' AS original,                            -- H + subscript 2 + O + superscript 2
    normalizeUTF8NFKD('H₂O²') AS nfkd_normalized;  -- Converts to H 2 O 2

┌─original─┬─nfkd_normalized─┐
│ H₂O²     │ H2O2            │
└──────────┴─────────────────┘

punycodeDecode

引入版本: v24.1

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

语法

punycodeDecode(s)

参数

s — Punycode 编码的字符串。 String

返回值

返回输入值的纯文本。 String

示例

使用示例

SELECT punycodeDecode('Mnchen-3ya')

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

punycodeEncode

引入版本: v24.1

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

语法

punycodeEncode(s)

参数

s — 输入值。 String

返回值

返回输入值的 Punycode 表示形式。 String

示例

使用示例

SELECT punycodeEncode('München')

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

regexpExtract

引入版本: v23.2

提取 haystack 中与 regexp 模式匹配且对应于 regex 组索引的第一个字符串。

语法

regexpExtract(haystack, pattern[, index])

别名: REGEXP_EXTRACT

参数

haystack — 将匹配 regexp 模式的字符串。 String
pattern — 字符串，regexp 表达式。 pattern 可能包含多个 regexp 组，index 指示要提取哪个 regex 组。索引 0 表示匹配整个正则表达式。 const String
index — 可选。一个大于或等于 0 的整数，默认值为 1。它表示要提取哪个 regex 组。 (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                                       │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘

repeat

引入于: v20.1

将字符串与其自身连接多次，如指定次数。

语法

repeat(s, n)

参数

s — 要重复的字符串。 String
n — 重复字符串的次数。 (U)Int*

返回值

一个包含重复 n 次的字符串 s 的字符串。如果 n 为负数，则该函数返回空字符串。 String

示例

使用示例

SELECT repeat('abc', 10)

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

reverseUTF8

引入于：v1.1

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

语法

reverseUTF8(s)

参数

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

返回值

返回具有反转 Unicode 码点序列的字符串。 String

示例

使用示例

SELECT reverseUTF8('ClickHouse')

esuoHkcilC

right

引入于：v22.1

从右侧指定 offset 处返回字符串 s 的子字符串。

语法

right(s, offset)

参数

s — 要计算子字符串的字符串。 String 或 FixedString
offset — 偏移量的字节数。 (U)Int*

返回值

返回值

对于正 offset，从字符串的右侧开始，返回包含 offset 个字节的 s 的子字符串。
对于负 offset，从字符串的右侧开始，返回包含 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则返回一个空字符串。 String

示例

正偏移量

SELECT right('Hello', 3)

llo

负偏移量

SELECT right('Hello', -3)

lo

rightPad

引入于: v21.8

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

语法

rightPad(string, length[, pad_string])

别名: rpad

参数

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

返回值

返回给定长度的右侧填充字符串。 String

示例

使用示例

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

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

rightPadUTF8

引入于: v21.8

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

语法

rightPadUTF8(string, length[, pad_string])

参数

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

返回值

返回给定长度的右侧填充字符串。 String

示例

使用示例

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

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

rightUTF8

引入于：v22.1

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

语法

rightUTF8(s, offset)

参数

s — 要计算子字符串的 UTF-8 编码字符串。 String 或 FixedString
offset — 偏移量的字节数。 (U)Int*

返回值

返回值

对于正 offset，从字符串的右侧开始，返回包含 offset 个字节的 s 的子字符串。
对于负 offset，从字符串的右侧开始，返回包含 length(s) - |offset| 个字节的 s 的子字符串。
如果 length 为 0，则返回一个空字符串。 String

示例

正偏移量

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

ивет

负偏移量

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

ет

soundex

引入于：v23.4

返回字符串的 Soundex 代码。

语法

soundex(s)

参数

s — 输入字符串。 String

返回值

返回输入字符串的 Soundex 代码。 String

示例

使用示例

SELECT soundex('aksel')

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

space

引入于：v23.5

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

语法

space(n)

参数

n — 重复空格的次数。 (U)Int*

返回值

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

示例

使用示例

SELECT space(3) AS res, length(res);

┌─res─┬─length(res)─┐
│     │           3 │
└─────┴─────────────┘

sparseGrams

引入于：v25.5

查找给定字符串的所有子字符串，其长度至少为 n，其中子字符串边界的 (n-1)-gram 的哈希值严格大于子字符串内部的任何 (n-1)-gram 的哈希值。使用 CRC32 作为哈希函数。

语法

sparseGrams(s[, min_ngram_length, max_ngram_length])

参数

s — 输入字符串。 String
min_ngram_length — 可选。提取 ngram 的最小长度。默认值和最小值是 3。 UInt*
max_ngram_length — 可选。提取 ngram 的最大长度。默认值为 100。不应小于 min_ngram_length。 UInt*
min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-gram。默认值与 min_ngram_length 相同。不应小于 min_ngram_length 且不大于 max_ngram_length。 UInt*

返回值

返回所选子字符串的数组。 Array(String)

示例

使用示例

SELECT sparseGrams('alice', 3)

┌─sparseGrams('alice', 3)────────────┐
│ ['ali','lic','lice','ice']         │
└────────────────────────────────────┘

sparseGramsHashes

引入于：v25.5

查找给定字符串的所有子字符串的哈希值，其长度至少为 n，其中子字符串边界的 (n-1)-gram 的哈希值严格大于子字符串内部的任何 (n-1)-gram 的哈希值。使用 CRC32 作为哈希函数。

语法

sparseGramsHashes(s[, min_ngram_length, max_ngram_length])

参数

s — 输入字符串。 String
min_ngram_length — 可选。提取 ngram 的最小长度。默认值和最小值是 3。 UInt*
max_ngram_length — 可选。提取 ngram 的最大长度。默认值为 100。不应小于 min_ngram_length。 UInt*
min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-gram。默认值与 min_ngram_length 相同。不应小于 min_ngram_length 且不大于 max_ngram_length。 UInt*

返回值

返回所选子字符串的 CRC32 哈希值数组。 Array(UInt32)

示例

使用示例

SELECT sparseGramsHashes('alice', 3)

┌─sparseGramsHashes('alice', 3)──────────────────────┐
│ [1481062250,2450405249,4012725991,1918774096]      │
└────────────────────────────────────────────────────┘

sparseGramsHashesUTF8

引入于：v25.5

查找给定 UTF-8 字符串的所有子字符串的哈希值，其长度至少为 n，其中子字符串边界的 (n-1)-gram 的哈希值严格大于子字符串内部的任何 (n-1)-gram 的哈希值。期望 UTF-8 字符串，如果 UTF-8 序列无效，则抛出异常。使用 CRC32 作为哈希函数。

语法

sparseGramsHashesUTF8(s[, min_ngram_length, max_ngram_length])

参数

s — 输入字符串。 String
min_ngram_length — 可选。提取 ngram 的最小长度。默认值和最小值是 3。 UInt*
max_ngram_length — 可选。提取 ngram 的最大长度。默认值为 100。不应小于 min_ngram_length。 UInt*
min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-gram。默认值与 min_ngram_length 相同。不应小于 min_ngram_length 且不大于 max_ngram_length。 UInt*

返回值

返回所选 UTF-8 子字符串的 CRC32 哈希值数组。 Array(UInt32)

示例

使用示例

SELECT sparseGramsHashesUTF8('алиса', 3)

┌─sparseGramsHashesUTF8('алиса', 3)─┐
│ [4178533925,3855635300,561830861] │
└───────────────────────────────────┘

sparseGramsUTF8

引入于：v25.5

查找给定 UTF-8 字符串的所有子字符串，其长度至少为 n，其中子字符串边界的 (n-1)-gram 的哈希值严格大于子字符串内部的任何 (n-1)-gram 的哈希值。期望 UTF-8 字符串，如果 UTF-8 序列无效，则抛出异常。使用 CRC32 作为哈希函数。

语法

sparseGramsUTF8(s[, min_ngram_length, max_ngram_length])

参数

s — 输入字符串。 String
min_ngram_length — 可选。提取 ngram 的最小长度。默认值和最小值是 3。 UInt*
max_ngram_length — 可选。提取 ngram 的最大长度。默认值为 100。不应小于 min_ngram_length。 UInt*
min_cutoff_length — 可选。如果指定，则仅返回长度大于或等于 min_cutoff_length 的 n-gram。默认值与 min_ngram_length 相同。不应小于 min_ngram_length 且不大于 max_ngram_length。 UInt*

返回值

返回所选 UTF-8 子字符串的数组。 Array(String)

示例

使用示例

SELECT sparseGramsUTF8('алиса', 3)

┌─sparseGramsUTF8('алиса', 3)─┐
│ ['али','лис','иса']         │
└─────────────────────────────┘

startsWith

引入于：v1.1

检查字符串是否以提供的字符串开头。

语法

startsWith(s, prefix)

参数

s — 要检查的字符串。 String
prefix — 要检查的前缀。 String

返回值

如果 s 以 prefix 开头，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT startsWith('ClickHouse', 'Click');

┌─startsWith('⋯', 'Click')─┐
│                        1 │
└──────────────────────────┘

startsWithCaseInsensitive

引入于: v25.9

检查字符串是否以提供的不区分大小写字符串开头。

语法

startsWithCaseInsensitive(s, prefix)

参数

s — 要检查的字符串。 String
prefix — 要检查的不区分大小写的前缀。 String

返回值

如果 s 以不区分大小写的 prefix 开头，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT startsWithCaseInsensitive('ClickHouse', 'CLICK');

┌─startsWithCaseInsensitive('⋯', 'CLICK')─┐
│                                       1 │
└─────────────────────────────────────────┘

startsWithCaseInsensitiveUTF8

引入于: v25.9

检查字符串是否以提供的不区分大小写的前缀开头。假定字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

语法

startsWithCaseInsensitiveUTF8(s, prefix)

参数

s — 要检查的字符串。 String
prefix — 要检查的不区分大小写的前缀。 String

返回值

如果 s 以不区分大小写的 prefix 开头，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT startsWithCaseInsensitiveUTF8('приставка', 'при')

┌─startsWithUT⋯ка', 'при')─┐
│                        1 │
└──────────────────────────┘

startsWithUTF8

引入于：v23.8

检查字符串是否以提供的字符串开头。假定字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

语法

startsWithUTF8(s, prefix)

参数

s — 要检查的字符串。 String
prefix — 要检查的前缀。 String

返回值

如果 s 以 prefix 开头，则返回 1，否则返回 0。 UInt8

示例

使用示例

SELECT startsWithUTF8('приставка', 'при')

┌─startsWithUT⋯ка', 'при')─┐
│                        1 │
└──────────────────────────┘

stringBytesEntropy

引入于: v25.6

计算字符串中字节分布的香农熵。

语法

stringBytesEntropy(s)

参数

s — 要分析的字符串。 String

返回值

返回字符串中字节分布的香农熵。 Float64

示例

使用示例

SELECT stringBytesEntropy('Hello, world!')

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

stringBytesUniq

引入于: v25.6

计算字符串中不同字节的数量。

语法

stringBytesUniq(s)

参数

s — 要分析的字符串。 String

返回值

返回字符串中不同字节的数量。 UInt16

示例

使用示例

SELECT stringBytesUniq('Hello')

┌─stringBytesUniq('Hello')─┐
│                        4 │
└──────────────────────────┘

stringJaccardIndex

引入于: v23.11

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

语法

stringJaccardIndex(s1, s2)

参数

s1 — 第一个输入字符串。 String
s2 — 第二个输入字符串。 String

返回值

返回两个字符串之间的 Jaccard 相似度指数。 Float64

示例

使用示例

SELECT stringJaccardIndex('clickhouse', 'mouse')

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

stringJaccardIndexUTF8

引入于: v23.11

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

语法

stringJaccardIndexUTF8(s1, s2)

参数

s1 — 第一个输入 UTF8 字符串。 String
s2 — 第二个输入 UTF8 字符串。 String

返回值

返回两个 UTF8 字符串之间的 Jaccard 相似度指数。 Float64

示例

使用示例

SELECT stringJaccardIndexUTF8('我爱你', '我也爱你')

┌─stringJaccardIndexUTF8('我爱你', '我也爱你')─┐
│                                       0.75 │
└─────────────────────────────────────────────┘

substring

引入于：v1.1

返回字符串 s 从指定的字节索引 offset 开始的子字符串。字节计数从 1 开始，逻辑如下

如果 offset 为 0，则返回空字符串。
如果 offset 为负数，则子字符串从字符串末尾的 offset 个字符开始，而不是从开头开始。

可选参数 length 指定返回的子字符串的最大字节数。

语法

substring(s, offset[, length])

别名: byteSlice, mid, substr

参数

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

返回值

返回从索引 offset 开始，长度为 length 个字节的 s 的子字符串。 String

示例

基本用法

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

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

substringIndex

引入于: v23.7

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

语法

substringIndex(s, delim, count)

别名: SUBSTRING_INDEX

参数

s — 从中提取子字符串的字符串。 String
delim — 分隔符。 String
count — 分隔符出现的次数，用于提取子字符串。如果 count 为正数，则返回从左数起最后一个分隔符左侧的所有内容。如果 count 为负数，则返回从右数起最后一个分隔符右侧的所有内容。 UInt 或 Int

返回值

返回 s 在 count 次 delim 出现位置之前的子字符串。 String

示例

使用示例

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

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

substringIndexUTF8

引入于: v23.7

返回 s 在分隔符 delim 之前 count 次出现位置的子字符串，专门针对 Unicode 代码点。假定字符串包含有效的 UTF-8 编码文本。如果违反此假设，则不会抛出异常，结果未定义。

语法

substringIndexUTF8(s, delim, count)

参数

s — 从中提取子字符串的字符串。 String
delim — 分隔符。 String
count — 分隔符出现的次数，用于提取子字符串。如果 count 为正数，则返回从左数起最后一个分隔符左侧的所有内容。如果 count 为负数，则返回从右数起最后一个分隔符右侧的所有内容。 UInt 或 Int

返回值

返回 s 在 count 次 delim 出现位置之前的子字符串。 String

示例

UTF8 示例

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

www.straßen-in-europa

substringUTF8

引入于：v1.1

返回字符串 s 从指定的代码点索引 offset 开始的子字符串。代码点计数从 1 开始，逻辑如下

如果 offset 为 0，则返回空字符串。
如果 offset 为负数，则子字符串从字符串末尾的 offset 个代码点开始，而不是从开头开始。

可选参数 length 指定返回的子字符串的最大代码点数。

注意

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

语法

substringUTF8(s, offset[, length])

参数

s — 从中计算子字符串的字符串。 String 或 FixedString 或 Enum
offset — 子字符串在 s 中的起始位置。 Int 或 UInt
length — 子字符串的最大长度。可选。 Int 或 UInt

返回值

返回从代码点索引 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

toValidUTF8

引入于: v20.1

通过将任何无效的 UTF-8 字符替换为替换字符 � (U+FFFD) 将字符串转换为有效的 UTF-8 编码。当发现多个连续的无效字符时，它们将被折叠成单个替换字符。

语法

toValidUTF8(s)

参数

s — 表示 String 数据类型对象的任何字节集。 String

返回值

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

示例

使用示例

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

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

trimBoth

引入于: v20.1

删除字符串开头和结尾的指定字符。默认情况下，删除常见的空白（ASCII）字符。

语法

trimBoth(s[, trim_characters])

别名: trim

参数

s — 要修剪的字符串。 String
trim_characters — 可选。要修剪的字符。如果未指定，则删除常见的空白字符。 String

返回值

返回从两端修剪了指定字符的字符串。 String

示例

使用示例

SELECT trimBoth('$$ClickHouse$$', '$')

┌─trimBoth('$$⋯se$$', '$')─┐
│ ClickHouse               │
└──────────────────────────┘

trimLeft

引入于: v20.1

删除字符串开头的指定字符。默认情况下，删除常见的空白（ASCII）字符。

语法

trimLeft(input[, trim_characters])

别名: ltrim

参数

input — 要修剪的字符串。 String
trim_characters — 可选。要修剪的字符。如果未指定，则删除常见的空白字符。 String

返回值

返回从左侧修剪了指定字符的字符串。 String

示例

使用示例

SELECT trimLeft('ClickHouse', 'Click');

┌─trimLeft('Cl⋯', 'Click')─┐
│ House                    │
└──────────────────────────┘

trimRight

引入于: v20.1

删除字符串结尾的指定字符。默认情况下，删除常见的空白（ASCII）字符。

语法

trimRight(s[, trim_characters])

别名: rtrim

参数

s — 要修剪的字符串。 String
trim_characters — 可选字符要修剪。如果未指定，则删除常见的空白字符。 String

返回值

返回从右侧修剪了指定字符的字符串。 String

示例

使用示例

SELECT trimRight('ClickHouse','House');

┌─trimRight('C⋯', 'House')─┐
│ Click                    │
└──────────────────────────┘

tryBase32Decode

引入于: v25.6

接受一个字符串，并使用 Base32 编码方案对其进行解码。

语法

tryBase32Decode(encoded)

参数

encoded — 要解码的字符串列或常量。如果字符串不是有效的 Base32 编码，则在出错时返回一个空字符串。 String

返回值

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

示例

使用示例

SELECT tryBase32Decode('IVXGG33EMVSA====');

┌─tryBase32Decode('IVXGG33EMVSA====')─┐
│ Encoded                             │
└─────────────────────────────────────┘

tryBase58Decode

引入于：v22.10

类似于 base58Decode，但在出错时返回一个空字符串。

语法

tryBase58Decode(encoded)

参数

encoded — 字符串列或常量。如果字符串不是有效的 Base58 编码，则在出错时返回一个空字符串。 String

返回值

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

示例

使用示例

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

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

tryBase64Decode

引入于: v18.16

类似于 base64Decode，但在出错时返回一个空字符串。

语法

tryBase64Decode(encoded)

参数

encoded — 要解码的字符串列或常量。如果字符串不是有效的 Base64 编码，则在出错时返回一个空字符串。 String

返回值

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

示例

使用示例

SELECT tryBase64Decode('Y2xpY2tob3VzZQ==')

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

tryBase64URLDecode

引入于: v18.16

类似于 base64URLDecode，但在出错时返回一个空字符串。

语法

tryBase64URLDecode(encoded)

参数

encoded — 要解码的字符串列或常量。如果字符串不是有效的 Base64 编码，则在出错时返回一个空字符串。 String

返回值

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

示例

使用示例

SELECT tryBase64URLDecode('aHR0cHM6Ly9jbGlja2hvdXNlLmNvbQ')

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

tryIdnaEncode

引入版本: v24.1

根据国际化域名应用程序 (IDNA) 机制返回域名的 Unicode (UTF-8) 表示形式（ToUnicode 算法）。如果发生错误，它将返回一个空字符串而不是抛出异常。

语法

tryIdnaEncode(s)

参数

s — 输入字符串。 String

返回值

根据 IDNA 机制返回输入的 ASCII 表示形式，或者如果输入无效则返回空字符串。 String

示例

使用示例

SELECT tryIdnaEncode('straße.münchen.de')

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

tryPunycodeDecode

引入版本: v24.1

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

语法

tryPunycodeDecode(s)

参数

s — Punycode 编码的字符串。 String

返回值

返回输入的明文，或者如果输入无效则返回空字符串。 String

示例

使用示例

SELECT tryPunycodeDecode('Mnchen-3ya')

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

upper

引入于：v1.1

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

语法

upper(s)

别名: ucase

参数

s — 要转换为大写的字符串。 String

返回值

从 s 返回一个大写字符串。 String

示例

使用示例

SELECT upper('clickhouse')

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

upperUTF8

引入于：v1.1

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

注意

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

语法

upperUTF8(s)

参数

s — 一种字符串类型。 String

返回值

一种 String 数据类型值。 String

示例

使用示例

SELECT upperUTF8('München') AS Upperutf8

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

CRC32​

CRC32IEEE​

CRC64​

appendTrailingCharIfAbsent​

ascii​

base32Decode​

base32Encode​

base58Decode​

base58Encode​

base64Decode​

base64Encode​

base64URLDecode​

base64URLEncode​

basename​

byteHammingDistance​

compareSubstrings​

concat​

concatAssumeInjective​

concatWithSeparator​

concatWithSeparatorAssumeInjective​

conv​

convertCharset​

damerauLevenshteinDistance​

decodeHTMLComponent​

decodeXMLComponent​

editDistance​

editDistanceUTF8​

encodeXMLComponent​

endsWith​

endsWithCaseInsensitive​

endsWithCaseInsensitiveUTF8​

endsWithUTF8​

extractTextFromHTML​

firstLine​

idnaDecode​

idnaEncode​

initcap​

initcapUTF8​

isValidASCII​

isValidUTF8​

jaroSimilarity​

jaroWinklerSimilarity​

left​

leftPad​

leftPadUTF8​

leftUTF8​

lengthUTF8​

lower​

lowerUTF8​

normalizeUTF8NFC​

normalizeUTF8NFD​

normalizeUTF8NFKC​

normalizeUTF8NFKD​

punycodeDecode​

punycodeEncode​

regexpExtract​

repeat​

reverseUTF8​

right​

rightPad​

rightPadUTF8​

rightUTF8​

soundex​

space​

sparseGrams​

sparseGramsHashes​

sparseGramsHashesUTF8​

sparseGramsUTF8​

startsWith​

startsWithCaseInsensitive​

startsWithCaseInsensitiveUTF8​

startsWithUTF8​

stringBytesEntropy​

stringBytesUniq​

stringJaccardIndex​

stringJaccardIndexUTF8​

substring​

substringIndex​

substringIndexUTF8​

substringUTF8​

CRC32

CRC32IEEE

CRC64

appendTrailingCharIfAbsent

ascii

base32Decode

base32Encode

base58Decode

base58Encode

base64Decode

base64Encode

base64URLDecode

base64URLEncode

basename

byteHammingDistance

compareSubstrings

concat

concatAssumeInjective

concatWithSeparator

concatWithSeparatorAssumeInjective

conv

convertCharset

damerauLevenshteinDistance

decodeHTMLComponent

decodeXMLComponent

editDistance

editDistanceUTF8

encodeXMLComponent

endsWith

endsWithCaseInsensitive

endsWithCaseInsensitiveUTF8

endsWithUTF8

extractTextFromHTML

firstLine

idnaDecode

idnaEncode

initcap

initcapUTF8

isValidASCII

isValidUTF8

jaroSimilarity

jaroWinklerSimilarity

left

leftPad

leftPadUTF8

leftUTF8

lengthUTF8

lower

lowerUTF8

normalizeUTF8NFC

normalizeUTF8NFD

normalizeUTF8NFKC

normalizeUTF8NFKD

punycodeDecode

punycodeEncode

regexpExtract

repeat

reverseUTF8

right

rightPad

rightPadUTF8

rightUTF8

soundex

space

sparseGrams

sparseGramsHashes

sparseGramsHashesUTF8

sparseGramsUTF8

startsWith

startsWithCaseInsensitive

startsWithCaseInsensitiveUTF8

startsWithUTF8

stringBytesEntropy

stringBytesUniq

stringJaccardIndex

stringJaccardIndexUTF8

substring

substringIndex

substringIndexUTF8

substringUTF8