字符串处理函数

用于在字符串中进行搜索和替换的函数在单独的文档中说明。

注意

下文文档是由 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，则在字符串 s 末尾追加字符 c。

语法

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====')─┐
│ 编码后                            │
└──────────────────────────────────┘

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 版本引入

按照 Base64 表示对字符串进行编码，遵循 RFC 4648 标准。

语法

base64Encode(明文)

别名: 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.com                            │
└───────────────────────────────────────────────────┘

base64URLEncode

自 v18.16 引入

使用 URL 安全字母表，将字符串编码为 Base64（RFC 4648）编码表示。

语法

base64URLEncode(plaintext)

参数

plaintext — 要进行编码的明文列或常量。String

返回值

返回一个包含该参数编码结果的字符串。String

示例

用法示例

SELECT base64URLEncode('https://clickhouse.com')

┌─base64URLEncode('https://clickhouse.com')─┐
│ 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 中开始比较的起始位置（从 0 开始计数）。UInt*
s2_offset — 在 s2 中开始比较的起始位置（从 0 开始计数的索引）。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('你好，', '世界！')

┌─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

示例

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

自 v22.12 版本引入

将提供的字符串用指定的分隔符连接起来。

语法

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

别名: concat_ws

参数

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

返回值

返回由各参数拼接得到的字符串。如果任一参数值为 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 起引入

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

语法

convertCharset(s, from, to)

参数

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

返回值

返回将字符串 s 从 from 编码转换为 to 编码后的结果。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;你好 &amp; &quot;世界&quot;&lt;/div&gt;')

┌─decodeHTMLComponent('&lt;div&gt;你好 &amp; &quot;世界&quot;&lt;/div&gt;')─┐
│ <div>你好 & "世界"</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>你好，世界</tag> │
└──────────────────────────┘

editDistance

自 v23.9 引入

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

语法

编辑距离(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

返回值

返回两个 UTF-8 字符串的编辑距离。UInt64

示例

用法示例

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

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

encodeXMLComponent

首次引入版本：v21.1

对字符串中的字符进行转义，使其可以安全地用于 XML 文本节点或属性中。

语法

encodeXMLComponent(s)

参数

s — 要转义的字符串。String

返回值

返回转义后的字符串。String

示例

使用示例

SELECT
    '&lt;tag&gt;Hello &amp; &quot;World&quot;&lt;/tag&gt;' AS original,
    encodeXMLComponent('&lt;tag&gt;Hello &amp; &quot;World&quot;&lt;/tag&gt;') AS xml_encoded;

┌─原文───────────────────────┬─XML 编码────────────────────────────────────────────┐
│ <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 中引入

检查字符串是否以给定的、大小写不敏感的后缀结尾。

语法

不区分大小写地以指定后缀结尾（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 编码文本。如果这一假设不成立，不会抛出异常，结果是未定义的。

语法

以 UTF-8 结尾吗(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>页面标题</title></head>
    <body>
        <p>你好，<b>世界</b>！</p>
        <script>alert("测试");</script>
        <!-- 注释 -->
    </body>
</html>
');

┌─extractTextFromHTML('<html><head>...')─┐
│ 页面标题：你好，世界！                │
└────────────────────────────────────────┘

firstLine

自 v23.7 起引入

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

语法

首行

参数

s — 输入字符串。String

返回值

返回输入字符串的第一行；如果没有换行符，则返回整个字符串。String

示例

用法示例

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

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

idnaDecode

引入版本：v24.1

根据 Internationalized Domain Names in Applications（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

根据 Internationalized Domain Names in Applications（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 只将每个单词的首字母转换为大写，对于包含撇号或本身带有大写字母的单词，您可能会遇到一些出乎意料的行为。这是已知的行为，目前没有修复计划。

语法

首字母大写(s)

参数

s — 输入字符串。String

返回值

返回将 s 中每个单词的首字母转换为大写后的结果。String

示例

用法示例

SELECT initcap('为速度而构建')

┌─initcap('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。

语法

别名：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 有效, isValidUTF8('\\xc3\\x28') AS 无效

┌─有效─┬─无效─┐
│     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

返回字符串 s 中从左侧偏移量 offset 处开始的子字符串。

语法

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)

你好

负偏移

SELECT left('Hello World', -6)

你好

leftPad

自 v21.8 起引入

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

语法

leftPad(字符串, 长度[, 填充字符串])

别名: 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 引入

从左侧使用空格或指定字符串（如有必要可多次重复）填充 UTF-8 字符串，直到结果字符串达到给定长度。与按字节度量字符串长度的 leftPad 不同，这里的字符串长度按 Unicode 码点计算。

语法

leftPadUTF8(字符串, 长度[, 填充字符串])

参数

string — 需要填充的输入字符串。String
length — 结果字符串的长度。如果该值小于输入字符串的长度，则输入字符串会被截断为 length 个字符。(U)Int*
pad_string — 可选。用于填充输入字符串的字符串。如果未指定，则使用空格对输入字符串进行填充。String

返回值

返回指定长度的左侧填充后的字符串。String

示例

使用示例

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

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

leftUTF8

引入于：v22.1

返回 UTF-8 编码字符串 s 中从左侧偏移量 offset 位置开始的子字符串。

语法

leftUTF8(s, offset)

参数

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

返回值

当 offset 为正数时，返回从字符串左侧开始、长度为 offset 字节的 s 的子字符串。
当 offset 为负数时，返回从字符串左侧开始、长度为 length(s) - |offset| 字节的 s 的子字符串。
当 length 为 0 时，返回空字符串。 String

示例

正偏移量

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

嗨

负偏移

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

Пр

lengthUTF8

自 v1.1 版本引入

返回字符串的长度（以 Unicode 码位为单位），而不是以字节或字符为单位。该函数假定字符串包含有效的 UTF-8 编码文本。如果该假设不成立，则不会抛出异常，且结果未定义。

语法

lengthUTF8(s)

别名：CHAR_LENGTH, CHARACTER_LENGTH

参数

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

返回值

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

示例

使用示例

SELECT lengthUTF8('你好，世界！')

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

lower

首次引入于：v1.1

将 ASCII 字符串转换为小写。

语法

小写(们)

别名: lcase

参数

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

返回值

返回由 s 转换得到的小写字符串。String

示例

用法示例

SELECT lower('CLICKHOUSE')

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

lowerUTF8

引入版本：v1.1

在假定字符串包含有效 UTF-8 编码文本的前提下，将字符串转换为小写。如果该假设不成立，则不会抛出异常，且结果未定义。

语法

lowerUTF8(input)

参数

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

返回值

返回小写字符串。String

示例

第一个

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

慕尼黑

normalizeUTF8NFC

引入版本：v21.11

根据 NFC 规范化形式对 UTF-8 字符串进行规范化。

语法

normalizeUTF8NFC(str)

参数

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

返回值

返回该 UTF-8 字符串的 NFC 标准化形式。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 │
└──────────┴──────────────────┴────────────────┴────────────────────────┘

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 + 组合尖音符（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,                            -- 带圈数字字符
    normalizeUTF8NFKC('① ② ③') AS nfkc_normalized;  -- 规范化为 1 2 3

┌─原始──────┬─NFKC 归一化────┐
│ ① ② ③  │ 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 + 下标 2 + O + 上标 2
    normalizeUTF8NFKD('H₂O²') AS nfkd_normalized;  -- 将其转换为 H 2 O 2

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

punycodeDecode

引入于：v24.1

返回 Punycode 编码字符串对应的 UTF-8 编码明文。如果未提供有效的 Punycode 编码字符串，则会抛出异常。

语法

punycode 解码(s)

参数

s — 经过 Punycode 编码的字符串。String

返回值

返回输入值对应的明文字符串。String

示例

使用示例

SELECT punycodeDecode('Mnchen-3ya')

┌─punycodeDecode('Mnchen-3ya')─┐
│ 慕尼黑                       │
└──────────────────────────────┘

punycodeEncode

自 v24.1 起引入

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

语法

punycodeEncode(s)

参数

s — 输入值。String

返回值

返回输入值的 Punycode 表示。String

示例

使用示例

SELECT punycodeEncode('München')

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

regexpExtract

自 v23.2 起引入

从 haystack 中提取第一个与正则表达式模式匹配且对应指定正则表达式分组索引的字符串。

语法

regexpExtract(haystack, pattern[, index])

别名: REGEXP_EXTRACT

参数

haystack — 进行正则表达式模式匹配的目标字符串。String
pattern — 正则表达式字符串。pattern 可以包含多个正则捕获组，index 指示要提取哪个捕获组。索引为 0 表示匹配整个正则表达式。const String
index — 可选。大于等于 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                                       │
└──────────────────────────────────────────────┴──────────────────────────────────────────────┴──────────────────────────────────────────────┴───────────────────────────────────────────┘

repeat

引入版本：v20.1

按照指定次数，将字符串与其自身重复拼接。

语法

重复(s, n)

参数

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

返回值

由将字符串 s 重复 n 次得到的字符串。如果 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

返回字符串 s 自右侧起按指定 offset 开始的子字符串。

语法

right(s, offset)

参数

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

返回值

当 offset 为正数时，从字符串右侧开始，返回 s 的子字符串，长度为 offset 个字节。
当 offset 为负数时，从字符串右侧开始，返回 s 的子字符串，长度为 length(s) - |offset| 个字节。
当 length 为 0 时，返回空字符串。 String

示例

正偏移

SELECT right('Hello', 3)

嗨

负偏移量

SELECT right('Hello', -3)

嗨

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*

返回值

返回一个由选定的子字符串组成的数组。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 — 可选。提取的 n-gram 的最小长度。默认值和最小值为 3。UInt*
max_ngram_length — 可选。提取的 n-gram 的最大长度。默认值为 100。必须不小于 min_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 — 可选。提取的 n‑gram 的最小长度。默认值且最小值为 3。UInt*
max_ngram_length — 可选。提取的 n‑gram 的最大长度。默认值为 100。不得小于 min_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 — 可选。提取 n-gram 的最小长度。默认值和最小值均为 3。UInt*
max_ngram_length — 可选。提取 n-gram 的最大长度。默认值为 100。其值不得小于 min_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 类似，但用于 UTF-8 编码的字符串。

语法

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 为负值，则子字符串从字符串末尾向前数第 pos 个字符开始，而不是从开头开始。

可选参数 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 个分隔符左侧的所有内容。如果 count 为负数，则返回从右侧数起第 |count| 个分隔符右侧的所有内容。UInt 或 Int

返回值

返回 s 在 delim 第 count 次出现位置处分割得到的子串。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 开始的子串，按 Unicode 码点进行处理。字节计数从 1 开始，遵循以下逻辑：

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

可选参数 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)

土拨鼠每天都来报到。    土拨鼠又来报到。    又来了

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')─┐
│ 房屋                     │
└──────────────────────────┘

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====')─┐
│ 已编码                               │
└─────────────────────────────────────┘

tryBase58Decode

自 v22.10 起引入

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

语法

尝试Base58解码(encoded)

参数

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

返回值

返回一个包含参数解码结果的字符串。String

示例

使用示例

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

┌─res─────┬─res_invalid─┐
│ 编码结果 │             │
└─────────┴─────────────┘

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.com                               │
└──────────────────────────────────────────────────────┘

tryIdnaEncode

引入于：v24.1

根据应用中的国际化域名（IDNA）机制，使用 ToUnicode 算法返回域名的 Unicode（UTF-8）形式。如果发生错误，则返回空字符串，而不是抛出异常。

语法

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')─┐
│ 慕尼黑                          │
└─────────────────────────────────┘

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