文档中心

ByteHouse云数仓版

函数参考

字符串函数

CHARACTER_LENGTH

返回字符串的长度（以 Unicode 代码点为单位，而不是以字符为单位），假设字符串string包含一组组成 UTF-8 编码文本的字节。如果不满足此假设，则返回一些结果（不会引发异常）。
语法

CHARACTER_LENGTH(string)

参数

string– 字符串。

返回值

Char的长度。

类型：UInt64
示例

select CHARACTER_LENGTH('abcdef123')

结果：

┌─CHARACTER_LENGTH('abcdef123')─┐
│ 9                             │
└───────────────────────────────┘

CHAR_LENGTH

CHAR_LENGTH(s)

参数

s– 字符串。

返回值

字符的长度。

类型：UInt64
示例

SELECT CHAR_LENGTH('abcdef123')

结果：

┌─CHAR_LENGTH('abcdef123')─┐
│ 9                        │
└──────────────────────────┘

ASCII

说明

MySQL兼容语法，推荐在相关方言下使用

返回字符或者字符串最左边字符对应的ASCII值。
语法

SELECT ascii('2');

参数

varchar - 字符串

返回值

bigint

示例

SELECT ascii('dx');

+-------------+
| ascii('dx') |
+-------------+
|         100 |
+-------------+

bin

说明

MySQL兼容语法，推荐在相关方言下使用

返回N的二进制字符串。如果N为null，则返回结果为NULL。
语法

SELECT bin(12);

参数

BIGINT

返回值

VARCHAR

alphaTokens

从范围 az 和 AZ 中选择连续字节的子字符串。返回子字符串数组。
语法

alphaTokens(string)

参数

string– 字符串。

返回值

子字符串数组。

示例

SELECT alphaTokens('abca1abc');

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

appendTrailingCharIfAbsent

如果非空且末尾string不包含，则将附加到末尾。charactercharacter
语法

appendTrailingCharIfAbsent(string, character)

参数

string– 字符串。
character - 字符。

返回值

附加到字符串的字符。

类型：string
示例

appendTrailingCharIfAbsent('abc', '2');

结果：

┌─appendTrailingCharIfAbsent('abc', '2')─┐
│ abc2                                   │
└────────────────────────────────────────┘

arrayStringConcat

将数组中列出的字符串与分隔符连接起来。separator是一个可选参数：一个常量字符串，默认设置为空字符串。
语法

arrayStringConcat(array[, separator])

参数

array– 数组。
separator– 可选，分隔符。

返回值

连接的字符串。

类型：string
示例

SELECT arrayStringConcat(['abc','123']);

结果：

┌─arrayStringConcat(['abc', '123'])─┐
│ abc123                            │
└───────────────────────────────────┘

其他示例

SELECT arrayStringConcat(['abc', '123'], ',')

结果：

┌─arrayStringConcat(['abc', '123'], ',')─┐
│ abc,123                                │
└────────────────────────────────────────┘

base64Decode

将 base64 编码解码string为原始字符串。如果失败则会引发异常。
别名：FROM_BASE64。
语法

base64Decode(string)

参数

string– 字符串。

返回值

解码后的字符串。

类型：string
示例

SELECT base64Decode('SGVsbG8gQmFzZTY0');

结果：

┌─base64Decode('SGVsbG8gQmFzZTY0')─┐
│ Hello Base64                     │
└──────────────────────────────────┘

base64Encode

编码string为 base64
别名：TO_BASE64。
语法

base64Encode(string)

参数

string– 字符串。

返回值

编码的字符串。

类型：string
示例

SELECT base64Encode('Hello Base64')

结果：

┌─base64Encode('Hello Base64')─┐
│ SGVsbG8gQmFzZTY0             │
└──────────────────────────────┘

bit_length

说明

MySQL兼容语法，推荐在相关方言下使用

以位为单位返回字符串str的长度。
语法

bit_length(str)

参数

VARCHAR

返回值

BIGINT

示例

SELECT bit_length('text');

+--------------------+
| bit_length('text') |
+--------------------+
|                 32 |
+--------------------+

char

说明

MySQL兼容语法，推荐在相关方言下使用

返回N1、N2等整数对应的十进制ASCII码组成的字符串。
语法

char(N1, N2, ...)

参数

BIGINT

返回值

VARBINARY

示例

SELECT char(97,110,97,108,121,116,105,99);

┌─char(97, 110, 97, 108, 121, 116, 105, 99)─┐
│ analytic                                  │
└───────────────────────────────────────────┘

concat

连接参数中列出的字符串，不带分隔符。
语法

concat(s1, s2, ...)

参数

s1, s2... – 字符串或固定字符串类型的值。

返回值

连接参数后生成的字符串。

如果任何参数值为NULL，concat则返回NULL。
示例

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

结果：

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

concat_ws

字符串连接操作，第一个参数separator是其余参数的分隔符，连接时会跳过任何为null值的字符串。
语法

concat_ws(separator, str 1, …, str n)

参数

VARCHAR

返回值

VARCHAR

示例

SELECT concat_ws(',', 'First name', 'Second name', 'Last Name')AS result;

┌─result───────────────────────────┐
│ First name,Second name,Last Name │
└──────────────────────────────────┘

concatAssumeInjective

与concat类似，不同之处在于你需要确保是concat(s1, s2, ...) → sn可注入的，它将用于 GROUP BY 的优化。
如果函数对于不同的参数值总是返回不同的结果，则该函数被称为“单射”。换句话说：不同的参数永远不会产生相同的结果。
语法

concatAssumeInjective(s1, s2, ...)

参数

s1, s2... – 字符串或固定字符串类型的值。

返回值

连接参数后得到的字符串。

注意：如果任何参数值为NULL，concatAssumeInjective则返回NULL。
示例1

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

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

示例2

SELECT concat(key1, key2), sum(value) FROM test.key_val GROUP BY concatAssumeInjective(key1, key2);

┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello,World        │ 3          │
│ Hello,World!       │ 3          │
│ Hello, World!      │ 2          │
└────────────────────┴────────────┘

convertCharset

返回string从的编码转换from为的编码的to。
语法

convertCharset(s, from, to)

参数

string– 字符串。
from– 从字符编码类型解码。
to– 编码为字符编码类型。

返回值

to字符编码类型。

示例

SELECT base64Encode(toString(convertCharset('abc', 'Unicode', 'UTF-8')))

结果：

┌─base64Encode(toString(convertCharset('abc', 'Unicode', 'UTF-8')))─┐
│ 5oWi77+9                                                          │
└───────────────────────────────────────────────────────────────────┘

count

计算行数或非 NULL 值的数量。
语法
CNCH 支持以下语法count：

count(expr)或者COUNT(DISTINCT expr)。
count()或者COUNT(*)。

参数
该函数可以采取：

零参数。
零表达式。

返回值

如果调用该函数时没有参数，它会计算行数。
如果传递了表达式，则函数会计算此表达式返回非空值的次数。如果表达式返回Nullable类型的值，则结果count保持为 not 。如果表达式对所有行都Nullable返回，则函数返回 0 。NULL
在两种情况下，返回值的类型都是UInt64。

细节
CNCH 支持该COUNT(DISTINCT ...)语法。此构造的行为取决于count_distinct_implementation设置。它定义使用哪个uniq*函数来执行操作。默认是uniqExact函数。
该SELECT count() FROM table查询未经过优化，因为表中的条目数未单独存储。它从表中选择一小列并计算其中的值数量。
但是可以通过启用optimize_functions_to_subcolumnsSELECT count(nullable_column) FROM table设置来优化查询。使用该函数仅读取空子列，而不是读取和处理整个列数据。查询转换为。optimize_functions_to_subcolumns = 1SELECT count(n) FROM tableSELECT sum(NOT n.null) FROM table
示例
示例 1：

CREATE TABLE test.test_count (id Int32) ENGINE = CnchMergeTree ORDER BY id;
INSERT INTO test.test_count(id) VALUES(1),(2),(3),(4),(5),(5);
select count() from test.test_count;

┌─count()─┐
│ 6       │
└─────────┘

示例 2：

SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation'
sql

┌─name──────────────────────────┬─value─────┐
│ count_distinct_implementation │ uniqExact │
└───────────────────────────────┴───────────┘

select count(distinct(id)) from test.test_count

┌─uniqExact(id)─┐
│ 5             │
└───────────────┘

此例表示按照设定值count(DISTINCT num)执行的功能。uniqExactcount_distinct_implementation

e

返回接近数字 e 的 Float64 数字。
语法

e()

参数

不适用

返回值

返回接近数字 e 的 Float64 数字。

类型：Float64
示例

SELECT e();

结果：

┌─e()───────────────────┐
│ 2.718281828459045e+00 │
└───────────────────────┘

elt

说明

MySQL兼容语法，推荐在相关方言下使用

返回第N个字符串。
语法

elt(N, str 1, ...,str n);

参数

N为BIGINT类型，str为VARCHAR类型。

返回值

VARCHAR

示例

SELECT elt(4, 'Aa', 'Bb', 'Cc', 'Dd');

┌─ELT(4, 'Aa', 'Bb', 'Cc', 'Dd')─┐
│ Dd                             │
└────────────────────────────────┘

empty

对于空字符串返回 1，对于非空字符串返回 0。
如果字符串至少包含一个字节，即使该字节是空格或空字节，也被视为非空。
此函数也适用于数组。
语法

empty(string)

参数

string– 字符串。

返回值

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

类型：UInt8
示例

SELECT empty('');

结果：

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

其他示例

SELECT empty('test')

结果：

┌─empty('12312')─┐
│ 0              │
└────────────────┘

endsWith

返回是否以指定的后缀结尾。如果string以指定的结尾，则返回 1 suffix，否则返回 0。
语法

endsWith(string, suffix)

参数

string– 字符串。
suffix– 后缀，测试是否s以指定的后缀结尾。

返回值

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

类型：UInt8
示例

SELECT endsWith('test_end_with','with');

结果：

┌─endsWith('test_end_with', 'with')─┐
│ 1                                 │
└───────────────────────────────────┘

其他示例

SELECT endsWith('test_end_with','error');

结果：

┌─endsWith('test_end_with', 'error')─┐
│ 0                                  │
└────────────────────────────────────┘

export_set

说明

MySQL兼容语法，推荐在相关方言下使用

将bits转换为二进制值。其中：

系统会从右到左检查二进制值，如果二进制值为1，则会被替换为onstr值；如果二进制值为0，则会被替换为offstr值。
返回值之间由separator分隔。
number_of_bits指定了检查位数，默认值为64。如果指定number_of_bits大于64，则会被裁剪到64位；如果指定number_of_bits为-1，则检查位数仍默认为64。

语法

export_set(bits, onstr, offstr [, separator[,number_of_bits]]);

参数

bits和number_of_bits均为BIGINT类型，onstr、offstr和separator均为VARCHAR类型。

返回值

VARCHAR

示例

SELECT export_set(5,'a','b',',',2);

┌─export_set(5, 'a', 'b', ',', 2)─┐
│ a,b                             │
└─────────────────────────────────┘

extract

使用正则表达式提取字符串的片段。如果string不匹配pattern正则表达式，则返回空字符串。如果正则表达式不包含子模式，则提取与整个正则表达式匹配的片段。否则，提取与第一个子模式匹配的片段。
语法

extract(haystack, pattern)

参数

string– 字符串。
pattern– 正则表达式模式

返回值

匹配的字符串。

类型：string
示例

SELECT extract('abc<regex1>abc<regex2>abc','<.*?>');

结果：

┌─extract('abc<regex1>abc<regex2>', '<.*?>')─┐
│ <regex1>                                   │
└────────────────────────────────────────────┘

extractAll

使用正则表达式提取字符串的所有片段。如果string不匹配pattern正则表达式，则返回空字符串。返回由所有匹配正则表达式的字符串组成的字符串数组。一般而言，其行为与函数相同extract（它采用第一个子模式，如果没有子模式，则采用整个表达式）。
语法

extractAll(string, pattern)

参数

string– 字符串。
pattern– 正则表达式模式

返回值

匹配的字符串。

类型：string
示例

SELECT extractAll('abc<regex1>abc<regex2>abc','<.*?>');

结果：

┌─extractAll('abc<regex1>abc<regex2>abc', '<.*?>')─┐
│ [<regex1>, <regex2>]                             │
└──────────────────────────────────────────────────┘

field

说明

MySQL兼容语法，推荐在相关方言下使用

返回str在str 1、str 2、str n列表中的索引位置。如果未找到str，则返回0。
语法

FIELD(str, str 1, str 2,..., str n);

参数

VARCHAR

返回值

BIGINT

示例

SELECT FIELD('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff');

┌─field('Bb', 'Aa', 'Bb', 'Cc', 'Dd', 'Ff')─┐
│                                         2 │
└───────────────────────────────────────────┘

find_in_set

说明

MySQL兼容语法，推荐在相关方言下使用

返回str在列表strlist中的位置。
如果str不在strlist中或者strlist是空字符串，返回结果为0。
如果str、strlist任一参数为null，返回结果为null。
语法

find_in_set(str, strlist)

参数

str和strlist均为VARCHAR类型。

返回值

BIGINT

示例

SELECT find_in_set('b','a,b,c,d');

┌─find_in_set('b', 'a,b,c,d')─┐
│                           2 │
└─────────────────────────────┘

from_base64

说明

MySQL兼容语法，推荐在相关方言下使用

解码Base64编码的参数x并返回结果
语法

from_base64(x)

参数

VARCHAR

返回值

VARCHAR

示例

SELECT from_base64('Q2hpbmE=');

┌─FROM_BASE64('Q2hpbmE=')─┐
│ China                   │
└─────────────────────────┘

from_utf8

说明

MySQL兼容语法，推荐在相关方言下使用

from_utf8(x)：解码UTF-8编码的x并返回结果。
from_utf8(x, y)：解码非UTF-8编码的参数x，并将其替换为指定的非法字符。

语法

from_utf8(x)
from_utf8(x, y)

参数

VARCHAR

返回值

VARCHAR

示例

SELECT from_utf8(to_utf8('hello'));

┌─FROM_UTF8(TO_UTF8('hello'))─┐
│ hello                       │
└─────────────────────────────┘

hex

说明

MySQL兼容语法，推荐在相关方言下使用

将参数x转换为其所对应的十六进制格式的字符串。
语法

hex(x)

参数

BIGINT/VARCHAR

返回值

VARCHAR

示例

SELECT hex(16);

┌─hex(16)─┐
│ 10      │
└─────────┘

instr

说明

MySQL兼容语法，推荐在相关方言下使用

返回字符串str中子字符串substr首次出现的位置。
语法

instr(str, substr)

参数

str和substr均为VARCHAR类型。

返回值

BIGINT

示例

SELECT instr('foobarbar', 'bar');

┌─positionCaseInsensitive('foobarbar', 'bar')─┐
│                                           4 │
└─────────────────────────────────────────────┘

lcase

将 ASCII 拉丁符号转换为string小写。
语法

lcase(string)

参数

string– 字符串。

返回值

小写字母的字符串。

类型：string
示例

SELECT lcase('ABCdef');

结果：

┌─lcase('ABCdef')─┐
│ abcdef          │
└─────────────────┘

length

以整数形式返回字符串的长度，该函数也适用于数组。
语法

length(x)

参数

x– 字符串或数组。

返回值

字符串或数组的长度。

类型：UInt64
示例

SELECT length('Hello');

结果：

┌─length('Hello')─┐
│ 5               │
└─────────────────┘

其他示例

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

结果：

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

lengthUTF8

返回字符串的长度（以整数表示），假设字符串包含一组组成 UTF-8 编码文本的字节。如果不满足此假设，则返回一些结果（不会引发异常）。
语法

lengthUTF8(x)

参数

x– 字符串或数组。

返回值

字符串或数组的长度。

类型：UInt64
示例
将 'Hello test' 编码为 UTF-8，我们可以得到\x48\x65\x6C\x6C\x6F\x20\x74\x65\x73\x74

SELECT lengthUTF8('\x48\x65\x6C\x6C\x6F\x20\x74\x65\x73\x74');

结果：

┌─lengthUTF8('Hello test')─┐
│ 10                       │
└──────────────────────────┘

like

like(string, pattern)，string LIKE 模式运算符检查字符串是否与简单正则表达式匹配。
语法

like(string, pattern)
string LIKE pattern

参数

string– 字符串。
pattern– 该字符串与简单正则表达式匹配。

正则表达式可以包含元符号%和_。
%表示任意数量的任意字节（包括零字符）。
_表示任意一个字节。
使用反斜杠 ( \) 来转义元符号。请参阅“match”函数描述中有关转义的注释。
对于像这样的正则表达式%needle%，代码更加优化，并且与position函数一样快。
对于其他正则表达式，代码与“match”函数相同。
返回值

1 或 0。

类型：UInt8
示例

SELECT like('abc','ab')

类型
结果：

┌─like('abc', 'ab')─┐
│ 0                 │
└───────────────────┘

其他示例

SELECT 'abc' LIKE 'ab%'

结果：

┌─like('abc', 'ab%')─┐
│ 1                  │
└────────────────────┘

locate

locate() 函数返回子字符串在中第一次出现的位置string。
position(string, substring）的别名
语法

locate(string, substring[, start_pos]) .

参数

string– 要搜索子字符串的字符串。字符串。
substring– 要搜索的子字符串。字符串
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

字符串中子字符串第一次出现的位置。

类型：UInt64
示例

SELECT locate('Hello World', 'Wor')

结果：

┌─locate('Hello World', 'Wor')─┐
│ 7                            │
└──────────────────────────────┘

lower

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

lower(string)

参数

string– 字符串。

返回值

小写字母的字符串。

类型：string
示例

SELECT lower('ABCdef');

结果：

┌─lower('ABCdef')─┐
│ abcdef          │
└─────────────────┘

lowerUTF8

将字符串转换为小写，假设该字符串包含一组构成 UTF-8 编码文本的字节。
注意：它不检测语言。因此对于土耳其语，结果可能不完全正确。
如果某个代码点的大写和小写的 UTF-8 字节序列的长度不同，则该代码点的结果可能不正确。
如果字符串包含一组非 UTF-8 的字节，则行为未定义。
语法

lowerUTF8(s)

参数

s– 字符串。

返回值

小写字母的字符串。

类型：string
示例
将'Hello test'编码为UTF-8，我们可以得到'\x48\x65\x6C\x6C\x6F\x20\x74\x65\x73\x74'。

SELECT lowerUTF8('\x48\x65\x6C\x6C\x6F\x20\x74\x65\x73\x74');

结果：

┌─lowerUTF8('Hello test')─┐
│ hello test              │
└─────────────────────────┘

lpad

说明

MySQL兼容语法，推荐在相关方言下使用

将字符串str左边拼接padstr直到长度达到len，并返回拼接后的字符串。
如果str长于len，则返回值将缩短为len个字符。
语法

lpad(str, len, padstr)

参数

str和padstr均为VARCHAR类型，len为BIGINT类型

返回值

VARCHAR

示例

SELECT lpad('Aliyun',9,'#');

┌─leftPad('Aliyun', 9, '#')─┐
│ ###Aliyun                 │
└───────────────────────────┘

ltrim

说明

MySQL兼容语法，推荐在相关方言下使用

删除字符串str所有前导空格。
语法

ltrim(str)

参数

VARCHAR

返回值

VARCHAR

示例

SELECT ltrim('  abc');

┌─trimLeft('  abc')─┐
│ abc               │
└───────────────────┘

make_set

说明

MySQL兼容语法，推荐在相关方言下使用

返回一个设置值（包含由字符分隔的子字符串的字符串），其中包含具有相应位设置的字符串。
语法

make_set(bits, str 1, str 2,...);

参数

bits为BIGINT类型，str为VARCHAR类型

返回值

VARCHAR

示例

SELECT make_set(5,'hello','nice','world');

┌─make_set(5, 'hello', 'nice', 'world')─┐
│ hello,world                           │
└───────────────────────────────────────┘

match

检查字符串是否与pattern正则表达式匹配。re2正则表达式。正则表达式的语法re2比 Perl 正则表达式的语法更受限制。
请注意，反斜杠符号 ( \) 用于正则表达式中的转义。相同的符号也用于字符串文字中的转义。因此，为了在正则表达式中转义符号，必须在字符串文字中写入两个反斜杠 ()。
正则表达式将字符串视为一组字节。正则表达式不能包含空字节。
对于在字符串中搜索子字符串的模式，最好使用 LIKE 或“position”，因为它们的工作速度更快。
语法

match(string, pattern)

参数

string– 字符串。
pattern– 匹配的模式

返回值

如果不匹配则返回 0，如果匹配则返回 1。

类型：UInt8
示例

SELECT match('abc<regex1>abc<regex2>abc','<.*?>');

结果：

┌─match('abc<regex1>abc<regex2>abc', '<.*?>')─┐
│ 1                                           │
└─────────────────────────────────────────────┘

mid

返回从“offset”索引开始、长度为“length”的子字符串。字符索引从一开始（与标准 SQL 一样）。“offset”和“length”参数必须是常量。
语法

mid(s, offset, length)

参数

s– 字符串。
offset– 子字符串的起始偏移量。
length– 子字符串的长度。

返回值

子字符串。

类型：string
示例

SELECT mid('Hello CNCH',7,4);

结果：

┌─mid('Hello CNCH', 7, 4)─┐
│ CNCH                    │
└─────────────────────────┘

multiFuzzyMatchAny

与相同，但如果任何模式在恒定编辑距离multiMatchAny内与字符串匹配，则返回 1。此功能也处于实验模式，速度可能非常慢。有关更多信息，请参阅hyperscan 文档。
语法

multiFuzzyMatchAny(string, distance, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
distance– 整数，请参考编辑距离。
pattern– 模糊匹配中使用的模式。

返回值

如果任何模式与字符串匹配则返回 1，否则返回 0。

类型：UInt8
示例

SELECT multiFuzzyMatchAny('123ab12cdef',2,['abcd']);

结果：

┌─multiFuzzyMatchAny('123ab12cdef', 2, ['abcd'])─┐
│ 1                                              │
└────────────────────────────────────────────────┘

multiFuzzyMatchAnyIndex

与相同multiFuzzyMatchAny，但返回在恒定编辑距离内与字符串匹配的任何索引。
语法

multiFuzzyMatchAnyIndex(string, distance, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
distance– 整数，请参考编辑距离。
pattern– 模糊匹配中使用的模式。

返回值

返回与字符串匹配的任何索引。

类型：UInt64
示例

SELECT multiFuzzyMatchAnyIndex('111333444CN1CH',1,['abc','def','CNCH']);

结果：

┌─multiFuzzyMatchAnyIndex('111333444CN1CH', 1, ['abc', 'def', 'CNCH'])─┐
│ 3                                                                    │
└──────────────────────────────────────────────────────────────────────┘

multiMatchAny

multiMatchAny(haystack，[pattern_1，pattern_2，…，pattern_n]）
与相同match，但如果没有匹配的正则表达式则返回 0，如果匹配任何模式则返回 1。它使用hyperscan库。对于在字符串中搜索子字符串的模式，最好使用，multiSearchAny因为它运行速度更快。
注意：任何字符串的长度haystack必须小于 2 (32)字节，否则会抛出异常。此限制是由于 hyperscan API 造成的。
语法

multiMatchAny(string, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
pattern– 匹配的模式

返回值

如果不匹配则返回 0，如果匹配则返回 1。

类型：UInt8
示例

SELECT multiMatchAny('abc<regex1>abc<regex2>abc',['<.*?>','error_patten']);

结果：

┌─multiMatchAny('abc<regex1>abc<regex2>abc', ['<.*?>', 'error_patten'])─┐
│ 1                                                                     │
└───────────────────────────────────────────────────────────────────────┘

multiMatchAnyIndex

与相同multiMatchAny，但返回与字符串匹配的任何索引。
语法

multiMatchAnyIndex(string, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
pattern– 匹配的模式

返回值

返回与字符串匹配的任何索引。

类型：UInt64
示例

SELECT multiMatchAnyIndex('abc<regex1>abc<regex2>abc',['error_patten', '<.*?>']);

结果：

┌─multiMatchAnyIndex('abc<regex1>abc<regex2>abc', ['error_patten', '<.*?>'])─┐
│ 2                                                                          │
└────────────────────────────────────────────────────────────────────────────┘

multiSearchAllPositions

与position相同，但返回Array在字符串中找到的相应子字符串的位置。位置索引从 0 开始。
搜索是针对字节序列进行的，与字符串编码和排序无关。

对于不区分大小写的 ASCII 搜索，请使用函数multiSearchAllPositionsCaseInsensitive。
若要以 UTF-8 进行搜索，请使用函数multiSearchAllPositionsUTF8。
对于不区分大小写的 UTF-8 搜索，请使用函数 multiSearchAllPositionsCaseInsensitiveUTF8。

语法

multiSearchAllPositions(string, [substring_1, substring_2, ..., Substring_n])

参数

string— 要搜索子字符串的字符串。字符串。
substring— 要搜索的子字符串。字符串。

返回值

如果找到相应的子字符串，则为起始位置的数组（从 1 开始计数），如果未找到，则为 0。

类型：Array(UInt64)
示例

SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world']);

结果：

┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐
│ [0, 13, 0]                                                        │
└───────────────────────────────────────────────────────────────────┘

multiSearchAllPositionsUTF8

请参阅multiSearchAllPositions。## multiSearchAny
如果至少有一个字符串needle_istring与该字符串匹配，则返回 1，否则返回 0。
对于不区分大小写的搜索或/和 UTF-8 格式，请使用函数multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8。

说明

注意：在所有函数中，由于实施规范，multiSearch*模式的数量应该小于 2 (8 。)

语法

multiSearchAny(string, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
pattern– 匹配的模式

返回值

如果至少有一个模式与字符串匹配，则返回 1，string否则返回 0。

类型：UInt8
示例

SELECT multiSearchAny('can_you_find_CNCH?',['abc','CNCH']);

结果：

┌─multiSearchAny('can_you_find_CNCH?', ['abc', 'CNCH'])─┐
│ 1                                                     │
└───────────────────────────────────────────────────────┘

multiSearchFirstIndex

返回在最左边找到的 pattern_i 的索引i（从 1 开始），string否则返回 0。
对于不区分大小写的搜索或/和 UTF-8 格式，请使用函数multiSearchFirstIndexCaseInsensitive, multiSearchFirstIndexUTF8, multiSearchFirstIndexCaseInsensitiveUTF8。
语法

multiSearchFirstIndex(string, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
pattern– 匹配的模式

返回值

返回在最左边找到的 pattern_i 的索引i（从 1 开始），string否则返回 0。

类型：UInt8
示例

SELECT multiSearchFirstIndex('which_pattern_matchs_CNCH?',['abc','CNCH']);

结果：

┌─multiSearchFirstIndex('which_pattern_matchs_CNCH?', ['abc', 'CNCH'])─┐
│ 2                                                                    │
└──────────────────────────────────────────────────────────────────────┘

multiSearchFirstPosition

与相同，position但返回与某些子字符串匹配的字符串的最左边的偏移量。
对于不区分大小写的搜索或/和 UTF-8 格式，请使用函数multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8, multiSearchFirstPositionCaseInsensitiveUTF8。
语法

multiSearchFirstPosition(string, [pattern_1, pattern_2, …, pattern_n])

参数

string– 字符串。
substring– 需要匹配的子字符串。

返回值

返回在最左边找到的 pattern_i 的索引i（从 1 开始），string否则返回 0。

类型：UInt8
示例

SELECT multiSearchFirstPosition('123_abc_abc_CNCH?',['abc','CNCH']);

结果：

┌─multiSearchFirstPosition('123_abc_abc_CNCH?', ['abc', 'CNCH'])─┐
│ 5                                                              │
└────────────────────────────────────────────────────────────────┘

ngramDistance

string计算和之间的 4 元语法距离substring：计算两个 4 元语法多集之间的对称差异，并通过它们的基数总和对其进行规范化。返回 0 到 1 之间的浮点数 - 越接近零，字符串彼此越相似。如果常量substring或substring超过 32Kb，则抛出异常。如果某些非常量substring或substring字符串超过 32Kb，则距离始终为 1。
对于不区分大小写的搜索或/和 UTF-8 格式，请使用函数ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8。
语法

ngramDistance(string, [substring_1, substring_2, …, substring_n]) 
sql

参数

string– 字符串。
substring– 需要匹配的子字符串。

返回值

返回在最左边找到的 substring_i 的索引i（从 1 开始），string否则返回 0。

类型：Float32
示例

SELECT ngramDistance('abc123ascCNCH_83q','CNCH'):

结果：

┌─ngramDistance('abc123ascCNCH_83q', 'CNCH')─┐
│ 8.666667e-01                               │
└────────────────────────────────────────────┘

not

计算值的逻辑非的结果。对应于逻辑非运算符。
语法

not(val);
sql

参数

val— 值。Int 、UInt 、 Float或Nullable 。

返回值

1，如果val是0。
0，如果val为非零值。
NULL，如果val是一个NULL值。

类型：UInt8或Nullable ( UInt8。
示例

SELECT NOT(1);

结果：

┌─not(1)─┐
│ 0      │
└────────┘

notEmpty

如果为空则返回 0 string，如果为非空则返回 1 string。
此函数也适用于数组。
语法

notEmpty(string)

参数

s– 字符串。

返回值

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

类型：UInt8
示例

SELECT notEmpty('test');

结果：

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

其他示例

SELECT notEmpty('')

结果：

┌─notEmpty('')─┐
│ 0            │
└──────────────┘

notLike

notLike(string, pattern)，字符串不像模式运算符。
与“like”意思相同，但是是否定形式。
语法

notLike(string, pattern)

参数

string– 字符串。
pattern– 匹配的模式。

返回值

如果不匹配则返回 0，如果匹配则返回 1。

类型：UInt8
示例

SELECT notLike('test1','test2');

结果：

┌─notLike('test1', 'test2')─┐
│ 1                         │
└───────────────────────────┘

oct

说明

MySQL兼容语法，推荐在相关方言下使用

返回整数N的八进制字符串表示形式。
语法

oct(N)

参数

BIGINT

返回值

VARCHAR

示例

SELECT oct(12);

┌─oct(12)─┐
│ 14      │
└─────────┘

ord

说明

MySQL兼容语法，推荐在相关方言下使用

如果字符串x最左边的字符是多字节字符，则返回该字符的代码。
语法

ord(x)

参数

VARCHAR

返回值

BIGINT

示例

SELECT ord('China');

┌─ord('China')─┐
│           67 │
└──────────────┘

position

substring在中搜索string。
返回字符串中找到的子字符串的位置，从 1 开始。
注意：搜索默认区分大小写，对于不区分大小写的搜索，请使用函数positionCaseInsensitive。
语法

position(substring IN string)
position(string, substring[, start_pos])

别名：locate(string, substring[, start_pos])。
注意：的语法position(substring IN string)提供 SQL 兼容性，该函数的工作方式与相同position(string, substring)。
参数

string– 要搜索子字符串的字符串。字符串。
substring– 要搜索的子字符串。字符串
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

返回字符串中找到的子字符串的位置，从 1 开始。

类型：Integer
示例1
短语“Hello, world!”包含一组表示单字节编码文本的字节。该函数返回一些预期结果：

SELECT position('Hello, world!', '!');

结果：

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

示例2

SELECT position('Hello, world!', 'o', 1),position('Hello, world!', 'o', 7);

┌─position('Hello, world!', 'o', 1)─┬─position('Hello, world!', 'o', 7)─┐
│                                 5 │                                 9 │
└───────────────────────────────────┴───────────────────────────────────┘

俄语中的同一短语包含无法使用单个字节表示的字符。该函数返回了一些意外结果（对多字节编码文本使用positionUTF8函数）：

SELECT position('Привет, мир!', '!');

结果：

┌─position('Привет, мир!', '!')─┐
│                            21 │
└───────────────────────────────┘

position(substring IN string) 语法示例

SELECT 3 = position('c' IN 'abc');

结果：

┌─equals(3, position('abc', 'c'))─┐
│                               1 │
└─────────────────────────────────┘

示例：

SELECT 6 = position('/' IN s) FROM (SELECT 'Hello/World' AS s);

结果：

┌─equals(6, position(s, '/'))─┐
│                           1 │
└─────────────────────────────┘

positionCaseInsensitive

与position相同，返回字符串中找到的子字符串的位置，从 1 开始。使用该函数进行不区分大小写的搜索。
假设字符串包含一组表示单字节编码文本的字节。如果不满足此假设，并且字符无法使用单个字节表示，则该函数不会抛出异常并返回一些意外结果。如果字符可以使用两个字节表示，它将使用两个字节，依此类推。
语法

positionCaseInsensitive(string, substring[, start_pos])

参数

string– 要搜索子字符串的字符串。字符串。
substring– 要搜索的子字符串。字符串
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

如果找到子字符串，则以字节为单位的起始位置（从 1 开始计算）。
如果未找到子字符串，则为 0。

类型：Integer。
示例

SELECT positionCaseInsensitive('Hello, world!', 'hello');

结果：

┌─positionCaseInsensitive('Hello, world!', 'hello')─┐
│ 1                                                 │
└───────────────────────────────────────────────────┘

positionCaseInsensitiveUTF8

与positionUTF8相同，但不区分大小写。返回substring在中找到的的位置（以 Unicode 点为单位）string，从 1 开始。
在假设字符串包含一组表示 UTF-8 编码文本的字节的情况下工作。如果不满足此假设，则该函数不会抛出异常并返回一些意外结果。如果字符可以使用两个 Unicode 点表示，它将使用两个，依此类推。
语法

positionCaseInsensitiveUTF8(string, substring[, start_pos])

参数

string– 要搜索子字符串的字符串。字符串。
substring– 要搜索的子字符串。字符串
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

如果找到子字符串，则以 Unicode 点为单位的起始位置（从 1 开始计算）。
如果未找到子字符串，则为 0。

类型：Integer。
示例
询问：

SELECT positionCaseInsensitiveUTF8('Привет, мир!', 'Мир');

结果：

┌─positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')─┐
│ 9                                                  │
└────────────────────────────────────────────────────┘

positionUTF8

substring返回在中找到的的位置（以 Unicode 点为单位）string，从 1 开始。
在假设字符串包含一组表示 UTF-8 编码文本的字节的情况下工作。如果不满足此假设，则该函数不会抛出异常并返回一些意外结果。如果字符可以使用两个 Unicode 点表示，它将使用两个，依此类推。
对于不区分大小写的搜索，请使用函数positionCaseInsensitiveUTF8。
语法

positionUTF8(string, substring[, start_pos])

参数

string– 要搜索子字符串的字符串。字符串。
substring– 要搜索的子字符串。字符串
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

如果找到子字符串，则以 Unicode 点为单位的起始位置（从 1 开始计算）。
如果未找到子字符串，则为 0。

类型：Integer。
示例

SELECT positionUTF8('Привет, мир!', '!') as example

短语“Hello, world!”包含一组表示单点编码文本的 Unicode 点。该函数返回一些预期结果：
结果：

┌─example─┐
│ 12      │
└─────────┘

regexpExtract

regexpExtract 函数会从目标字符串（haystack）中提取首个与正则表达式（regexp）模式匹配，且对应正则分组索引（group index）的字符串。
语法

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

regexpQuoteMeta

该函数在中的一些预定义字符前添加反斜杠string。
预定义字符：\0，，，，，，，，，，，，，，，，，。|()^$.[]?*+{:-
此实现与 re2::RE2::QuoteMeta 稍有不同。它将零字节转义为\0而不是，\x00并且仅转义必需的字符。
语法

regexpQuoteMeta(string)

参数

string– 字符串。

返回值

字符串。

类型：string
示例

SELECT regexpQuoteMeta(' | , ( , ) , ^ , $ , . , [ , ] , ? ,');

结果：

┌─regexpQuoteMeta(' | , ( , ) , ^ , $ , . , [ , ] , ? ,')─┐
│  \| , \( , \) , \^ , \$ , \. , \[ , \] , \? ,           │
└─────────────────────────────────────────────────────────┘

regexp/rlike

说明

MySQL兼容语法，推荐在相关方言下使用。

将字符串expression与pattern进行正则匹配，匹配成功返回1，否则返回0。
语法

expression RLIKE pattern;
expression REGEXP pattern;

参数

VARCHAR

返回值

BOOLEAN

示例

SELECT 'Michael!' REGEXP '.*';

┌─rlike('Michael!', '.*')─┐
│                       1 │
└─────────────────────────┘

rpad

说明

MySQL兼容语法，推荐在相关方言下使用

将字符串str右边拼接padstr直到长度达到len，并返回拼接后的字符串。
语法

rpad(str, len, padstr)

参数

str和padstr均为VARCHAR类型，len为BIGINT类型。

返回值

VARCHAR

示例

SELECT rpad('abc',9,'#');

┌─rightPad('abc', 9, '#')─┐
│ abc######               │
└─────────────────────────┘

repeat

说明

MySQL兼容语法，推荐在相关方言下使用

返回由字符串str重复count次数组成的字符串。
语法

repeat(str, count);

参数

str为VARCHAR类型，count为BIGINT类型。

返回值

VARCHAR

示例

SELECT repeat('a', 3);

┌─repeat('a', 3)─┐
│ aaa            │
└────────────────┘

replace

将substring中的所有替换为。stringreplacement
replaceAll 的别名
语法

replace(string, substring, replacement)

参数

string— 要搜索子字符串的字符串。
substring— 要搜索的子字符串。
replacement— 使用替换字符串来替换匹配的子字符串。

返回值

将substring中的所有替换为。stringreplacement

类型：string
示例

SELECT replace('test target_string test','target_string','CNCH');

结果：

┌─replace('test target_string test', 'target_string', 'CNCH')─┐
│ test CNCH test                                              │
└─────────────────────────────────────────────────────────────┘

replaceAll

将substring中的所有替换为。stringreplacement
请参阅 replac

replaceOne

如果存在的话，将中的第一次出现位置替换substring为。stringreplacement
语法

replaceOne(string, substring, replacement)

参数

string– 要搜索子字符串的字符串。string。
substring– 要搜索的子字符串。string
start_pos– 可选参数，字符串中第一个字符的位置，用于开始搜索。UInt

返回值

用替换内容替换字符串中第一次出现的子字符串。

类型：string
示例

SELECT replaceOne('test target_string test target_string','target_string','CNCH');

结果：

┌─replaceOne('test target_string test target_string', 'target_string', 'CNCH')─┐
│ test CNCH test target_string                                                 │
└──────────────────────────────────────────────────────────────────────────────┘

replaceRegexpAll

这与replaceAll 的作用相同，但使用正则表达式。

可以将模式指定为“替换”。此模式可以包含替换\0-\9。
替换\0包括整个正则表达式。替换\1-\9对应于子模式编号。要\在模板中使用该字符，请使用对其进行转义\。

说明

注意：使用 re2 正则表达式进行替换。

语法

replaceRegexpAll(string, pattern, replacement)

参数

string– 字符串。
pattern– 匹配的模式。
replacement— 使用替换字符串来替换匹配的子字符串。

返回值

用替换内容替换字符串中所有出现的子字符串。

类型：string
示例

SELECT replaceRegexpAll('Hello, World!', '.', '\\0\\0');

┌─replaceRegexpAll('Hello, World!', '.', '\\0\\0')─┐
│ HHeelllloo,,  WWoorrlldd!!                       │
└──────────────────────────────────────────────────┘

例外的是，如果正则表达式对空子字符串起作用，则不会进行多次替换。
示例：

SELECT replaceRegexpAll('Hello, World!', '^', 'here: ');

┌─replaceRegexpAll('Hello, World!', '^', 'here: ')─┐
│ here: Hello, World!                              │
└──────────────────────────────────────────────────┘

replaceRegexpOne

如果存在，则仅替换第一个匹配项。
注意：使用模式正则表达式进行替换。re2 正则表达式。
可以将模式指定为“替换”。此模式可以包含替换\0-\9。
替换\0包括整个正则表达式。替换\1-\9对应于子模式编号。要\在模板中使用该字符，请使用对其进行转义\。
还请记住，字符串文字需要额外的转义。
语法

replaceRegexpOne(string, pattern, replacement)

参数

string– 字符串。
pattern– 匹配的模式。
replacement— 使用替换字符串来替换匹配的子字符串。

返回值

用替换内容替换字符串中第一次出现的子字符串。

类型：string
示例

SELECT replaceRegexpOne('test <target_string> test <target_string>','<.*?>','CNCH');

结果：

┌─replaceRegexpOne('test <target_string> test <target_string>', '<.*?>', 'CNCH')─┐
│ test CNCH test <target_string>                                                 │
└────────────────────────────────────────────────────────────────────────────────┘

其他示例
例 1. 将日期转换为美国格式：

select '2014-03-17', replaceRegexpOne(toString('2014-03-17'), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1')

┌─'2014-03-17'─┬─replaceRegexpOne(toString('2014-03-17'), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1')─┐
│ 2014-03-17   │ 03/17/2014                                                                            │
└──────────────┴───────────────────────────────────────────────────────────────────────────────────────┘

示例 2. 复制字符串十次：

SELECT replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0');

结果：

┌─replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0')──────────────────────────────────────────────────────────┐
│ Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World! │
└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘

reverse

反转字符串（作为字节序列）。
语法

reverse(string)

参数

string– 字符串。

返回值

反转的字符串。

类型：string
示例

SELECT reverse('abcd1234')

结果：

┌─reverse('abcd1234')─┐
│ 4321dcba            │
└─────────────────────┘

reverseUTF8

反转 Unicode 代码点序列，假设字符串包含一组表示 UTF-8 文本的字节。否则，它会执行其他操作（不会引发异常）。
语法

reverseUTF8(string)

参数

string– UTF8 字符串。

返回值

反转的字符串。

类型：string
示例

SELECT reverseUTF8('\x61\x62\x63\x64\x31\x32\x33\x34')

说明

注意：'\x61\x62\x63\x64\x31\x32\x33\x34' 在 UTF8 格式中是'abcd1234'。

结果：

┌─reverseUTF8('abcd1234')─┐
│ 4321dcba                │
└─────────────────────────┘

size

以字节为单位（不是以字符为单位，也不是以代码点为单位）返回字符串的长度。

注意：该函数也适用于数组。

length的别名
语法

size(x)

参数

x– 字符串或数组。

返回值

字符串或数组的长度。

类型：UInt64
示例

SELECT size('Hello');

结果：

┌─size('Hello')─┐
│ 5             │
└───────────────┘

其他示例

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

结果：

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

splitByChar

将字符串拆分为由指定字符分隔的子字符串。它使用一个separator由一个字符组成的常量字符串。
返回选定子字符串的数组。如果分隔符出现在字符串的开头或结尾，或者存在多个连续的分隔符，则可能会选择空子字符串。
语法

splitByChar(separator, string)
sql

参数

separator— 分隔符应恰好包含一个字符。字符串。
string— 要拆分的字符串。字符串。

返回值
返回选定子字符串的数组。在以下情况下，可能会选择空子字符串：

分隔符出现在字符串的开始或结束处；
有多个连续的分隔符；
原始字符串string为空。

类型：array
示例

SELECT splitByChar(',', '1,2,3,abcde');
sql

结果：

┌─splitByChar(',', '1,2,3,abcde')─┐
│ [1, 2, 3, abcde]                │
└─────────────────────────────────┘
纯文本

splitByString

将字符串拆分为由字符串分隔的子字符串。它使用separator多个字符的常量字符串作为分隔符。如果字符串separator为空，它将拆分string为单个字符的数组。
语法

splitByString(separator, string)

参数

separator— 应包含字符串的分隔符。字符串。
string— 要拆分的字符串。字符串。

返回值
返回选定子字符串的数组。在以下情况下，可能会选择空子字符串：

分隔符出现在字符串的开始或结束处；
有多个连续的分隔符；
原始字符串string为空。

类型：array
示例

SELECT splitByString('test', 'abctestCNCHtestdef')

结果：

┌─splitByString('test', 'abctestCNCHtestdef')─┐
│ [abc, CNCH, def]                            │
└─────────────────────────────────────────────┘

startsWith

string是否以指定的开头返回 1 prefix，否则返回 0。
语法

startsWith(string, prefix)

参数

string— 字符串。
prefix— 匹配的前缀。

返回值

1，如果字符串以指定的前缀开头。
0，如果字符串不以指定的前缀开头。

类型：UInt8
示例

SELECT startsWith('Hello, world!', 'He');

结果：

┌─startsWith('Hello, world!', 'He')─┐
│ 1                                 │
└───────────────────────────────────┘

strcmp

说明

MySQL兼容语法，推荐在相关方言下使用

如果字符串str 1、str 2相同，返回结果为0。如果str 1根据当前排序顺序小于str 2，返回结果为-1，否则返回结果为1。
语法

strcmp(str 1, str 2);

参数

str 1和str 2均为VARCHAR类型。

返回值

BIGINT

示例

SELECT strcmp('text', 'text2');

┌─strcmp('text', 'text2')─┐
│                      -1 │
└─────────────────────────┘

substr

请参阅substring
返回以索引中的字节开头的子字符串，长度offset为length字节。字符索引从一开始（与标准 SQL 一样）。
注意：offset和length参数必须是常量。
语法

substring(string, offset, length)

参数

string– 字符串。
offset– 子字符串的起始偏移量。
length– 子字符串的长度。

返回值

子字符串。

类型：string
示例

SELECT substring('Hello CNCH', 7, 4)

结果：

┌─substr('Hello CNCH', 7, 4)─┐
│ CNCH                       │
└────────────────────────────┘

substringUTF8

与substring相同，但针对的是 Unicode 代码点。假设字符串包含一组表示 UTF-8 编码文本的字节。

说明

注意：如果不满足此假设，它将返回一些结果（不会引发异常）。

语法

substringUTF8(string, offset, length)

参数

string– 字符串。
offset– 子字符串的起始偏移量。
length– 子字符串的长度。

返回值

子字符串。

类型：string
示例

SELECT substringUTF8('\x48\x65\x6c\x6c\x6f\x20\x43\x4e\x43\x48H', 7, 4)

结果：

┌─substringUTF8('Hello CNCHH', 7, 4)─┐
│ CNCH                               │
└────────────────────────────────────┘

trimBoth

删除字符串两端所有连续出现的常见空格（ASCII 字符 32）。它不会删除其他类型的空格字符（制表符、不间断空格等）。
语法

trimBoth(string)

别名：trim(string)。
参数

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

返回值

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

类型：String
示例

SELECT trimBoth('     Hello, world!     ') as a;

结果：

┌─a─────────────┐
│ Hello, world! │
└───────────────┘

trimLeft

从字符串开头删除所有连续出现的常见空格（ASCII 字符 32）。它不会删除其他类型的空格字符（制表符、不间断空格等）。
语法

trimLeft(string)

别名：trim(string)。
参数

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

返回值

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

类型：String
示例

SELECT trimLeft('     Hello, world!     ') as example

结果：

┌─example────────────┐
│ Hello, world!      │
└────────────────────┘

trimRight

从字符串末尾删除所有连续出现的常见空格（ASCII 字符 32）。它不会删除其他类型的空格字符（制表符、不间断空格等）。
语法

trimRight(string)

别名：trim(string)。
参数

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

返回值

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

类型：String
示例

SELECT trimRight('     Hello, world!     ');

结果：

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

tryBase64Decode

与 base64Decode 类似，但如果发生错误，则会返回空字符串。
语法

tryBase64Decode(string)

参数

string– base64 编码的字符串。

返回值

解码后的字符串。

类型：string
示例

SELECT tryBase64Decode('SGVsbG8gV29ybGQh');

说明

注意：'SGVsbG8gV29ybGQh' 是 'Hello World! ' 的编码 base64 格式

结果：

┌─tryBase64Decode('SGVsbG8gV29ybGQh')─┐
│ Hello World!                        │
└─────────────────────────────────────┘

ucase

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

ucase(string)

参数

string– 字符串。

返回值

大写字母的字符串。

类型：string
示例

SELECT ucase('ABCdef');

结果：

┌─ucase('ABCdef')─┐
│ ABCDEF          │
└─────────────────┘

upper

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

upper(string)

参数

string– 字符串。

返回值

大写字母的字符串。

类型：string
示例

SELECT upper('ABCdef');

结果：

┌─upper('ABCdef')─┐
│ ABCDEF          │
└─────────────────┘

upperUTF8

将字符串转换为大写，假设该字符串包含一组构成 UTF-8 编码文本的字节。

它不检测语言。因此对于土耳其语，结果可能不完全正确。
如果某个代码点的大写和小写的 UTF-8 字节序列的长度不同，则该代码点的结果可能不正确。
如果字符串包含一组非 UTF-8 的字节，则行为未定义。

语法

upperUTF8(string)

参数

string– UTF8 字符串。

返回值

大写字母的字符串。

类型：string
示例
将 'hello world！' 编码为 UTF8 '\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x20\xef\xbc\x81'

SELECT upperUTF8('\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64\x20\xef\xbc\x81');

结果：

┌─upperUTF8('hello world ！')─┐
│ HELLO WORLD ！                │
└──────────────────────────────┘

最近更新时间：2025.11.17 18:54:05

这个页面对您有帮助吗？

有用

无用

ByteHouse云数仓版

CHARACTER_LENGTH #

CHAR_LENGTH #

ASCII #

bin #

alphaTokens #

appendTrailingCharIfAbsent #

arrayStringConcat #

base64Decode #

base64Encode #

bit_length #

char #

concat #

concat_ws #

concatAssumeInjective #

convertCharset #

count #

e #

elt #

empty #

endsWith #

export_set #

extract #

extractAll #

field #

find_in_set #

from_base64 #

from_utf8 #

hex #

instr #

lcase #

length #

lengthUTF8 #

like #

locate #

lower #

lowerUTF8 #

lpad #

ltrim #

make_set #

match #

mid #

multiFuzzyMatchAny #

multiFuzzyMatchAnyIndex #

multiMatchAny #

multiMatchAnyIndex #

multiSearchAllPositions #

multiSearchAllPositionsUTF8 #

multiSearchFirstIndex #

multiSearchFirstPosition #

ngramDistance #

not #

notEmpty #

notLike #

oct #

ord #

position #

positionCaseInsensitive #

positionCaseInsensitiveUTF8 #

positionUTF8 #

regexpExtract #

regexpQuoteMeta #

regexp/rlike #

rpad #

repeat #

replace #

replaceAll #

replaceOne #

replaceRegexpAll #

replaceRegexpOne #

reverse #

reverseUTF8 #

size #

splitByChar #

splitByString #

startsWith #

strcmp #

substr #

substringUTF8 #

trimBoth #

CHARACTER_LENGTH

CHAR_LENGTH

ASCII

bin

alphaTokens

appendTrailingCharIfAbsent

arrayStringConcat

base64Decode

base64Encode

bit_length

char

concat

concat_ws

concatAssumeInjective

convertCharset

count

e

elt

empty

endsWith

export_set

extract

extractAll

field

find_in_set

from_base64

from_utf8

hex

instr

lcase

length

lengthUTF8

like

locate

lower

lowerUTF8

lpad

ltrim

make_set

match

mid

multiFuzzyMatchAny

multiFuzzyMatchAnyIndex

multiMatchAny

multiMatchAnyIndex

multiSearchAllPositions

multiSearchAllPositionsUTF8

multiSearchFirstIndex

multiSearchFirstPosition

ngramDistance

not

notEmpty

notLike

oct

ord

position

positionCaseInsensitive

positionCaseInsensitiveUTF8

positionUTF8

regexpExtract

regexpQuoteMeta

regexp/rlike

rpad

repeat

replace

replaceAll

replaceOne

replaceRegexpAll

replaceRegexpOne

reverse

reverseUTF8

size

splitByChar

splitByString

startsWith

strcmp

substr

substringUTF8

trimBoth

trimLeft