文本函数和运算符
本节介绍用于检查和操作 STRING 值的函数和运算符。
| 函数 | 描述 |
|---|---|
string[index] |
使用（从 1 开始的）index 提取单个字符。 |
string[begin:end] |
使用类似于 Python 的切片约定提取字符串。缺失的 begin 或 end 参数分别被解释为列表的开头或结尾。允许使用负值。 |
string LIKE target |
如果 string 匹配 like 指定符（请参阅模式匹配），则返回 true。 |
string SIMILAR TO regex |
如果 string 匹配 regex（请参阅模式匹配），则返回 true。 |
string ^@ search_string |
starts_with 的别名。 |
arg1 || arg2 |
连接两个字符串、列表或 BLOB。任何 NULL 输入都会导致结果为 NULL。另请参阅 concat(arg1, arg2, ...) 和 list_concat(list1, list2, ...)。 |
array_extract(string, index) |
使用（从 1 开始的）index 从 string 中提取单个字符。 |
array_slice(list, begin, end) |
使用切片约定提取子列表或子字符串。允许使用负值。 |
ascii(string) |
返回表示 string 中第一个字符的 Unicode 码位的整数。 |
bar(x, min, max[, width]) |
绘制一个条形图，其宽度与 (x - min) 成比例，当 x = max 时，宽度等于 width 个字符。width 默认为 80。 |
base64(blob) |
to_base64 的别名。 |
bin(string) |
将 string 转换为二进制表示形式。 |
bit_length(string) |
string 中的位数。 |
char_length(string) |
length 的别名。 |
character_length(string) |
length 的别名。 |
chr(code_point) |
返回与 ASCII 码值或 Unicode 码位对应的字符。 |
concat(value, ...) |
连接多个字符串或列表。NULL 输入将被跳过。另请参阅运算符 ||。
|
concat_ws(separator, string, ...) |
连接多个字符串，并以 separator 分隔。NULL 输入将被跳过。
|
contains(string, search_string) |
如果 search_string 存在于 string 中，则返回 true。请注意，不支持排序规则 (collations)。 |
ends_with(string, search_string) |
suffix 的别名。
|
format(format, ...) |
使用 fmt 语法格式化字符串。 |
formatReadableDecimalSize(integer) |
将 integer 转换为人类可读的表示形式，使用基于 10 的幂的单位（KB、MB、GB 等）。
|
format_bytes(integer) |
将 integer 转换为人类可读的表示形式，使用基于 2 的幂的单位（KiB、MiB、GiB 等）。
|
from_base64(string) |
将 base64 编码的 string 转换为字符字符串 (BLOB)。
|
from_binary(value) |
unbin 的别名。
|
from_hex(value) |
unhex 的别名。
|
greatest(arg1, ...) |
按字典顺序返回最大值。请注意，小写字符被认为比大写字符大，且不支持排序规则 (collations)。 |
hash(value, ...) |
返回一个包含 value 哈希值的 UBIGINT。请注意，这不是加密哈希。
|
hex(string) |
将 string 转换为十六进制表示形式。
|
ilike_escape(string, like_specifier, escape_character) |
如果 string 使用不区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 true。escape_character 用于搜索 string 中的通配符。
|
instr(string, search_string) |
返回 search_string 在 string 中第一次出现的位置，从 1 开始计数。如果没有找到匹配项，则返回 0。
|
lcase(string) |
lower 的别名。
|
least(arg1, ...) |
按字典顺序返回最小值。请注意，大写字符被认为比小写字符小，且不支持排序规则 (collations)。 |
left(string, count) |
提取最左侧的 count 个字符。 |
left_grapheme(string, count) |
提取最左侧的 count 个字位簇 (grapheme clusters)。 |
len(string) |
length 的别名。 |
length(string) |
string 中的字符数。
|
length_grapheme(string) |
string 中的字位簇数。
|
like_escape(string, like_specifier, escape_character) |
如果 string 使用区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 true。escape_character 用于搜索 string 中的通配符。
|
lower(string) |
将 string 转换为小写。
|
lpad(string, count, character) |
在 string 左侧填充 character，直到其长度达到 count。如果长度超过 count，则会从右侧截断 string。
|
ltrim(string[, characters]) |
从 string 的左侧删除所有出现的 characters。characters 默认为 space（空格）。
|
md5(string) |
返回 string 的 MD5 哈希值，作为 VARCHAR。
|
md5_number(string) |
返回 string 的 MD5 哈希值，作为 HUGEINT。
|
md5_number_lower(string) |
返回 string MD5 哈希值的低 64 位部分，作为 UBIGINT。
|
md5_number_upper(string) |
返回 string MD5 哈希值的高 64 位部分，作为 UBIGINT。
|
nfc_normalize(string) |
将 string 转换为 Unicode NFC 标准化字符串。如果文本数据在 NFC 标准化与非标准化之间混合，则该函数对比较和排序很有用。
|
not_ilike_escape(string, like_specifier, escape_character) |
如果 string 使用不区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 false。escape_character 用于搜索 string 中的通配符。
|
not_like_escape(string, like_specifier, escape_character) |
如果 string 使用区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 false。escape_character 用于搜索 string 中的通配符。
|
ord(string) |
unicode 的别名。
|
parse_dirname(path[, separator]) |
返回给定 path 的顶级目录名称。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
parse_dirpath(path[, separator]) |
返回 path 的头部（直到最后一个斜杠之前的路径名），类似于 Python 的 os.path.dirname。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
parse_filename(string[, trim_extension][, separator]) |
返回 path 的最后一个组件，类似于 Python 的 os.path.basename 函数。如果 trim_extension 为 true，则会删除文件扩展名（默认为 false）。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
parse_path(path[, separator]) |
返回 path 中的组件列表（目录和文件名），类似于 Python 的 pathlib.parts 函数。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
position(search_string IN string) |
返回 search_string 在 string 中第一次出现的位置，从 1 开始计数。如果没有找到匹配项，则返回 0。
|
position(string, search_string) |
instr 的别名。
|
prefix(string, search_string) |
如果 string 以 search_string 开头，则返回 true。
|
printf(format, ...) |
使用 printf 语法格式化 string。
|
read_text(source) |
将 source（文件名、文件名列表或 glob 模式）中的内容作为 VARCHAR 返回。文件内容首先被验证是否为有效的 UTF-8。如果 read_text 尝试读取具有无效 UTF-8 的文件，则会抛出错误，建议改用 read_blob。更多详细信息，请参阅 read_text 指南。
|
regexp_escape(string) |
转义特殊模式以将 string 转换为正则表达式，类似于 Python 的 re.escape 函数。
|
regexp_extract(string, regex[, group][, options]) |
如果 string 包含 regex 模式，则返回由可选参数 group 指定的捕获组；否则返回空字符串。group 必须是常量值。如果未给定 group，则默认为 0。可以设置一组可选的 正则表达式 options。
|
regexp_extract(string, regex, name_list[, options]) |
如果 string 包含 regex 模式，则返回捕获组作为具有来自 name_list 对应名称的结构体；否则返回一个具有相同键且值为空字符串的结构体。可以设置一组可选的 正则表达式 options。
|
regexp_extract_all(string, regex[, group][, options]) |
在 string 中查找 regex 的非重叠匹配项，并返回对应捕获 group 的值。可以设置一组可选的 正则表达式 options。
|
regexp_full_match(string, regex[, col2]) |
如果整个 string 匹配 regex，则返回 true。可以设置一组可选的 正则表达式 options。
|
regexp_matches(string, regex[, options]) |
如果 string 包含 regex，则返回 true，否则返回 false。可以设置一组可选的 正则表达式 options。
|
regexp_replace(string, regex, replacement[, options]) |
如果 string 包含 regex，则将匹配部分替换为 replacement。可以设置一组可选的 正则表达式 options。
|
regexp_split_to_array(string, regex[, options]) |
string_split_regex 的别名。
|
regexp_split_to_table(string, regex) |
沿 regex 分割 string，并为每个部分返回一行。
|
repeat(string, count) |
将 string 重复 count 次。
|
replace(string, source, target) |
在 string 中将所有出现的 source 替换为 target。
|
reverse(string) |
反转 string。
|
right(string, count) |
提取最右侧的 count 个字符。
|
right_grapheme(string, count) |
提取最右侧的 count 个字位簇。
|
rpad(string, count, character) |
在 string 右侧填充 character，直到其长度达到 count。如果长度超过 count，则会从右侧截断 string。
|
rtrim(string[, characters]) |
从 string 的右侧删除所有出现的 characters。characters 默认为 space（空格）。
|
sha1(value) |
返回 value 的 SHA-1 哈希值作为 VARCHAR。
|
sha256(value) |
返回 value 的 SHA-256 哈希值作为 VARCHAR。
|
split(string, separator) |
string_split 的别名。
|
split_part(string, separator, index) |
沿 separator 分割 string，并返回列表中（从 1 开始的）index 的数据。如果 index 超出了列表范围，则返回空字符串（与 PostgreSQL 的行为保持一致）。
|
starts_with(string, search_string) |
如果 string 以 search_string 开头，则返回 true。
|
str_split(string, separator) |
string_split 的别名。
|
str_split_regex(string, regex[, options]) |
string_split_regex 的别名。
|
string_split(string, separator) |
沿 separator 分割 string。
|
string_split_regex(string, regex[, options]) |
沿 regex 分割 string。可以设置一组可选的 正则表达式 options。
|
string_to_array(string, separator) |
string_split 的别名。
|
strip_accents(string) |
从 string 中去除变音符号。
|
strlen(string) |
string 中的字节数。
|
strpos(string, search_string) |
instr 的别名。
|
substr(string, start[, length]) |
substring 的别名。
|
substring(string, start[, length]) |
提取从字符 start 开始到字符串末尾的子字符串。如果设置了可选参数 length，则提取长度为 length 个字符的子字符串。请注意，start 值为 1 指的是 string 的第一个字符。
|
substring_grapheme(string, start[, length]) |
提取从字位簇 start 开始到字符串末尾的子字符串。如果设置了可选参数 length，则提取长度为 length 个字位簇的子字符串。请注意，start 值为 1 指的是 string 的 第一个字符。
|
suffix(string, search_string) |
如果 string 以 search_string 结尾，则返回 true。请注意，不支持排序规则 (collations)。
|
to_base(number, radix[, min_length]) |
将 number 转换为给定基数 radix 的字符串，并可选择在前面补零至 min_length。
|
to_base64(blob) |
将 blob 转换为 base64 编码的字符串。
|
to_binary(string) |
bin 的别名。
|
to_hex(string) |
hex 的别名。
|
translate(string, from, to) |
将 string 中匹配 from 集合中字符的每个字符替换为 to 集合中对应的字符。如果 from 比 to 长，则删除 from 中多出的字符。
|
trim(string[, characters]) |
从 string 的任一侧删除所有出现的 characters。characters 默认为 space（空格）。
|
ucase(string) |
upper 的别名。
|
unbin(value) |
将 value 从二进制表示形式转换为 blob。
|
unhex(value) |
将 value 从十六进制表示形式转换为 blob。
|
unicode(string) |
返回一个表示 string 中第一个字符的 unicode 码位的 INTEGER。
|
upper(string) |
将 string 转换为大写。
|
url_decode(string) |
使用 百分号编码 (Percent-Encoding) 对 URL 进行解码。 |
url_encode(string) |
使用 百分号编码 (Percent-Encoding) 对 URL 进行编码。 |
string[index]
| 描述 | 使用（从 1 开始的）index 提取单个字符。 |
| 示例 | 'DuckDB'[4] |
| 结果 | k |
| 别名 | array_extract |
string[begin:end]
| 描述 | 使用类似于 Python 的切片约定提取字符串。缺失的 begin 或 end 参数分别被解释为列表的开头或结尾。允许使用负值。 |
| 示例 | 'DuckDB'[:4] |
| 结果 | Duck |
| 别名 | array_slice |
string LIKE target
| 描述 | 如果 string 匹配 like 指定符（请参阅模式匹配），则返回 true。 |
| 示例 | 'hello' LIKE '%lo' |
| 结果 | true |
string SIMILAR TO regex
| 描述 | 如果 string 匹配 regex（请参阅模式匹配），则返回 true。 |
| 示例 | 'hello' SIMILAR TO 'l+' |
| 结果 | false |
| 别名 | regexp_full_match |
arg1 || arg2
| 描述 | 连接两个字符串、列表或 BLOB。任何 NULL 输入都会导致结果为 NULL。另请参阅 concat(arg1, arg2, ...) 和 list_concat(list1, list2, ...)。 |
| 示例 1 | 'Duck' || 'DB' |
| 结果 | DuckDB |
| 示例 2 | [1, 2, 3] || [4, 5, 6] |
| 结果 | [1, 2, 3, 4, 5, 6] |
| 示例 3 | '\xAA'::BLOB || '\xBB'::BLOB |
| 结果 | \xAA\xBB |
array_extract(string, index)
| 描述 | 使用（从 1 开始的）index 从 string 中提取单个字符。 |
| 示例 | array_extract('DuckDB', 2) |
| 结果 | u |
array_slice(list, begin, end)
| 描述 | 使用切片约定提取子列表或子字符串。允许使用负值。 |
| 示例 1 | array_slice('DuckDB', 3, 4) |
| 结果 | ck |
| 示例 2 | array_slice('DuckDB', 3, NULL) |
| 结果 | NULL |
| 示例 3 | array_slice('DuckDB', 0, -3) |
| 结果 | Duck |
| 别名 | list_slice |
ascii(string)
| 描述 | 返回表示 string 中第一个字符的 Unicode 码位的整数。 |
| 示例 | ascii('Ω') |
| 结果 | 937 |
bar(x, min, max[, width])
| 描述 | 绘制一个条形图，其宽度与 (x - min) 成比例，当 x = max 时，宽度等于 width 个字符。width 默认为 80。 |
| 示例 | bar(5, 0, 20, 10) |
| 结果 | ██▌ |
bin(string)
| 描述 | 将 string 转换为二进制表示形式。 |
| 示例 | bin('Aa') |
| 结果 | 0100000101100001 |
| 别名 | to_binary |
bit_length(string)
| 描述 | string 中的位数。 |
| 示例 | bit_length('abc') |
| 结果 | 24 |
chr(code_point)
| 描述 | 返回与 ASCII 码值或 Unicode 码位对应的字符。 |
| 示例 | chr(65) |
| 结果 | A |
concat(value, ...)
| 描述 | 连接多个字符串或列表。NULL 输入将被跳过。另请参阅运算符 ||。
|
| 示例 1 | concat('Hello', ' ', 'World') |
| 结果 | Hello World |
| 示例 2 | concat([1, 2, 3], NULL, [4, 5, 6]) |
| 结果 | [1, 2, 3, 4, 5, 6] |
concat_ws(separator, string, ...)
| 描述 | 连接多个字符串，并以 separator 分隔。NULL 输入将被跳过。
|
| 示例 | concat_ws(', ', 'Banana', 'Apple', 'Melon') |
| 结果 | Banana, Apple, Melon |
contains(string, search_string)
| 描述 | 如果 search_string 存在于 string 中，则返回 true。
|
| 示例 | contains('abc', 'a') |
| 结果 | true |
format(format, ...)
| 描述 | 使用 fmt 语法格式化字符串。 |
| 示例 | format('Benchmark "{}" took {} seconds', 'CSV', 42) |
| 结果 | Benchmark "CSV" took 42 seconds |
formatReadableDecimalSize(integer)
| 描述 | 将 integer 转换为人类可读的表示形式，使用基于 10 的幂的单位（KB、MB、GB 等）。
|
| 示例 | formatReadableDecimalSize(16000) |
| 结果 | 16.0 kB |
format_bytes(integer)
| 描述 | 将 integer 转换为人类可读的表示形式，使用基于 2 的幂的单位（KiB、MiB、GiB 等）。
|
| 示例 | format_bytes(16_000) |
| 结果 | 15.6 KiB |
| 别名 | formatReadableSize, pg_size_pretty
|
from_base64(string)
| 描述 | 将 base64 编码的 string 转换为字符字符串 (BLOB)。
|
| 示例 | from_base64('QQ==') |
| 结果 | A |
greatest(arg1, ...)
| 描述 | 按字典顺序返回最大值。请注意，小写字符被认为比大写字符大，且不支持排序规则 (collations)。 |
| 示例 1 | greatest(42, 84) |
| 结果 | 84 |
| 示例 2 | greatest('abc', 'bcd', 'cde', 'EFG') |
| 结果 | cde |
hash(value, ...)
| 描述 | 返回一个包含 value 哈希值的 UBIGINT。请注意，这不是加密哈希。
|
| 示例 | hash('🦆') |
| 结果 | 4164431626903154684 |
hex(string)
| 描述 | 将 string 转换为十六进制表示形式。
|
| 示例 | hex('Hello') |
| 结果 | 48656C6C6F |
| 别名 | to_hex |
ilike_escape(string, like_specifier, escape_character)
| 描述 | 如果 string 使用不区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 true。escape_character 用于搜索 string 中的通配符。
|
| 示例 | ilike_escape('A%c', 'a$%C', '$') |
| 结果 | true |
instr(string, search_string)
| 描述 | 返回 search_string 在 string 中第一次出现的位置，从 1 开始计数。如果没有找到匹配项，则返回 0。
|
| 示例 | instr('test test', 'es') |
| 结果 | 2 |
| 别名 | position, strpos
|
least(arg1, ...)
| 描述 | 按字典顺序返回最小值。请注意，大写字符被认为比小写字符小，且不支持排序规则 (collations)。 |
| 示例 1 | least(42, 84) |
| 结果 | 42 |
| 示例 2 | least('abc', 'bcd', 'cde', 'EFG') |
| 结果 | EFG |
left(string, count)
| 描述 | 提取最左侧的 count 个字符。 |
| 示例 | left('Hello🦆', 2) |
| 结果 | He |
left_grapheme(string, count)
| 描述 | 提取最左侧的 count 个字位簇 (grapheme clusters)。 |
| 示例 | left_grapheme('🤦🏼♂️🤦🏽♀️', 1) |
| 结果 | 🤦🏼♂️ |
length(string)
| 描述 | string 中的字符数。
|
| 示例 | length('Hello🦆') |
| 结果 | 6 |
| 别名 | char_length, character_length, len
|
length_grapheme(string)
| 描述 | string 中的字位簇数。
|
| 示例 | length_grapheme('🤦🏼♂️🤦🏽♀️') |
| 结果 | 2 |
like_escape(string, like_specifier, escape_character)
| 描述 | 如果 string 使用区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 true。escape_character 用于搜索 string 中的通配符。
|
| 示例 | like_escape('a%c', 'a$%c', '$') |
| 结果 | true |
lower(string)
| 描述 | 将 string 转换为小写。
|
| 示例 | lower('Hello') |
| 结果 | hello |
| 别名 | lcase |
lpad(string, count, character)
| 描述 | 在 string 左侧填充 character，直到其长度达到 count。如果长度超过 count，则会从右侧截断 string。
|
| 示例 | lpad('hello', 8, '>') |
| 结果 | >>>hello |
ltrim(string[, characters])
| 描述 | 从 string 的左侧删除所有出现的 characters。characters 默认为 space（空格）。
|
| 示例 1 | ltrim(' test ') |
| 结果 | test |
| 示例 2 | ltrim('>>>>test<<', '><') |
| 结果 | test<< |
md5(string)
| 描述 | 返回 string 的 MD5 哈希值，作为 VARCHAR。
|
| 示例 | md5('abc') |
| 结果 | 900150983cd24fb0d6963f7d28e17f72 |
md5_number(string)
| 描述 | 返回 string 的 MD5 哈希值，作为 HUGEINT。
|
| 示例 | md5_number('abc') |
| 结果 | 152195979970564155685860391459828531600 |
md5_number_lower(string)
| 描述 | 返回 string MD5 哈希值的低 64 位部分，作为 UBIGINT。
|
| 示例 | md5_number_lower('abc') |
| 结果 | 8250560606382298838 |
md5_number_upper(string)
| 描述 | 返回 string MD5 哈希值的高 64 位部分，作为 UBIGINT。
|
| 示例 | md5_number_upper('abc') |
| 结果 | 12704604231530709392 |
nfc_normalize(string)
| 描述 | 将 string 转换为 Unicode NFC 标准化字符串。如果文本数据在 NFC 标准化与非标准化之间混合，则该函数对比较和排序很有用。
|
| 示例 | nfc_normalize('ardèch') |
| 结果 | ardèch |
not_ilike_escape(string, like_specifier, escape_character)
| 描述 | 如果 string 使用不区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 false。escape_character 用于搜索 string 中的通配符。
|
| 示例 | not_ilike_escape('A%c', 'a$%C', '$') |
| 结果 | false |
not_like_escape(string, like_specifier, escape_character)
| 描述 | 如果 string 使用区分大小写的匹配方式匹配 like_specifier（请参阅模式匹配），则返回 false。escape_character 用于搜索 string 中的通配符。
|
| 示例 | not_like_escape('a%c', 'a$%c', '$') |
| 结果 | false |
parse_dirname(path[, separator])
| 描述 | 返回给定 path 的顶级目录名称。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
| 示例 | parse_dirname('path/to/file.csv', 'system') |
| 结果 | path |
parse_dirpath(path[, separator])
| 描述 | 返回 path 的头部（直到最后一个斜杠之前的路径名），类似于 Python 的 os.path.dirname。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
| 示例 | parse_dirpath('path/to/file.csv', 'forward_slash') |
| 结果 | path/to |
parse_filename(string[, trim_extension][, separator])
| 描述 | 返回 path 的最后一个组件，类似于 Python 的 os.path.basename 函数。如果 trim_extension 为 true，则会删除文件扩展名（默认为 false）。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
| 示例 | parse_filename('path/to/file.csv', true, 'forward_slash') |
| 结果 | 文件 |
parse_path(path[, separator])
| 描述 | 返回 path 中的组件列表（目录和文件名），类似于 Python 的 pathlib.parts 函数。separator 选项：system、both_slash（默认）、forward_slash、backslash。
|
| 示例 | parse_path('path/to/file.csv', 'system') |
| 结果 | [path, to, file.csv] |
position(search_string IN string)
| 描述 | 返回 search_string 在 string 中第一次出现的位置，从 1 开始计数。如果没有找到匹配项，则返回 0。
|
| 示例 | position('b' IN 'abc') |
| 结果 | 2 |
| 别名 | instr, strpos
|
prefix(string, search_string)
| 描述 | 如果 string 以 search_string 开头，则返回 true。
|
| 示例 | prefix('abc', 'ab') |
| 结果 | true |
printf(format, ...)
| 描述 | 使用 printf 语法格式化 string。
|
| 示例 | printf('Benchmark "%s" took %d seconds', 'CSV', 42) |
| 结果 | Benchmark "CSV" took 42 seconds |
read_text(source)
| 描述 | 将 source（文件名、文件名列表或 glob 模式）中的内容作为 VARCHAR 返回。文件内容首先被验证是否为有效的 UTF-8。如果 read_text 尝试读取具有无效 UTF-8 的文件，则会抛出错误，建议改用 read_blob。更多详细信息，请参阅 read_text 指南。
|
| 示例 | read_text('hello.txt') |
| 结果 | hello\n |
regexp_escape(string)
| 描述 | 转义特殊模式以将 string 转换为正则表达式，类似于 Python 的 re.escape 函数。
|
| 示例 | regexp_escape('https://duckdb.net.cn') |
| 结果 | https\:\/\/duckdb\.org |
regexp_extract(string, regex[, group][, options])
| 描述 | 如果 string 包含 regex 模式，则返回由可选参数 group 指定的捕获组；否则返回空字符串。group 必须是常量值。如果未给定 group，则默认为 0。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_extract('ABC', '([a-z])(b)', 1, 'i') |
| 结果 | A |
regexp_extract(string, regex, name_list[, options])
| 描述 | 如果 string 包含 regex 模式，则返回捕获组作为具有来自 name_list 对应名称的结构体；否则返回一个具有相同键且值为空字符串的结构体。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_extract('John Doe', '([a-z]+) ([a-z]+)', ['first_name', 'last_name'], 'i') |
| 结果 | {'first_name': John, 'last_name': Doe} |
regexp_extract_all(string, regex[, group][, options])
| 描述 | 在 string 中查找 regex 的非重叠匹配项，并返回对应捕获 group 的值。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_extract_all('Peter: 33, Paul:14', '(\w+):\s*(\d+)', 2) |
| 结果 | [33, 14] |
regexp_full_match(string, regex[, col2])
| 描述 | 如果整个 string 匹配 regex，则返回 true。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_full_match('anabanana', '(an)*') |
| 结果 | false |
regexp_matches(string, regex[, options])
| 描述 | 如果 string 包含 regex，则返回 true，否则返回 false。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_matches('anabanana', '(an)*') |
| 结果 | true |
regexp_replace(string, regex, replacement[, options])
| 描述 | 如果 string 包含 regex，则将匹配部分替换为 replacement。可以设置一组可选的 正则表达式 options。
|
| 示例 | regexp_replace('hello', '[lo]', '-') |
| 结果 | he-lo |
regexp_split_to_table(string, regex)
| 描述 | 沿 regex 分割 string，并为每个部分返回一行。
|
| 示例 | regexp_split_to_table('hello world; 42', ';? ') |
| 结果 | 多行：'hello', 'world', '42'
|
repeat(string, count)
| 描述 | 将 string 重复 count 次。
|
| 示例 | repeat('A', 5) |
| 结果 | AAAAA |
replace(string, source, target)
| 描述 | 在 string 中将所有出现的 source 替换为 target。
|
| 示例 | replace('hello', 'l', '-') |
| 结果 | he--o |
reverse(string)
| 描述 | 反转 string。
|
| 示例 | reverse('hello') |
| 结果 | olleh |
right(string, count)
| 描述 | 提取最右侧的 count 个字符。
|
| 示例 | right('Hello🦆', 3) |
| 结果 | lo🦆 |
right_grapheme(string, count)
| 描述 | 提取最右侧的 count 个字位簇。
|
| 示例 | right_grapheme('🤦🏼♂️🤦🏽♀️', 1) |
| 结果 | 🤦🏽♀️ |
rpad(string, count, character)
| 描述 | 在 string 右侧填充 character，直到其长度达到 count。如果长度超过 count，则会从右侧截断 string。
|
| 示例 | rpad('hello', 10, '<') |
| 结果 | hello<<<<< |
rtrim(string[, characters])
| 描述 | 从 string 的右侧删除所有出现的 characters。characters 默认为 space（空格）。
|
| 示例 1 | rtrim(' test ') |
| 结果 | test |
| 示例 2 | rtrim('>>>>test<<', '><') |
| 结果 | >>>>test |
sha1(value)
| 描述 | 返回 value 的 SHA-1 哈希值作为 VARCHAR。
|
| 示例 | sha1('🦆') |
| 结果 | 949bf843dc338be348fb9525d1eb535d31241d76 |
sha256(value)
| 描述 | 返回 value 的 SHA-256 哈希值作为 VARCHAR。
|
| 示例 | sha256('🦆') |
| 结果 | d7a5c5e0d1d94c32218539e7e47d4ba9c3c7b77d61332fb60d633dde89e473fb |
split_part(string, separator, index)
| 描述 | 沿 separator 分割 string，并返回列表中（从 1 开始的）index 的数据。如果 index 超出了列表范围，则返回空字符串（与 PostgreSQL 的行为保持一致）。
|
| 示例 | split_part('a;b;c', ';', 2) |
| 结果 | b |
starts_with(string, search_string)
| 描述 | 如果 string 以 search_string 开头，则返回 true。
|
| 示例 | starts_with('abc', 'a') |
| 结果 | true |
| 别名 | ^@ |
string_split(string, separator)
| 描述 | 沿 separator 分割 string。
|
| 示例 | string_split('hello-world', '-') |
| 结果 | [hello, world] |
| 别名 | split, str_split, string_to_array
|
string_split_regex(string, regex[, options])
| 描述 | 沿 regex 分割 string。可以设置一组可选的 正则表达式 options。
|
| 示例 | string_split_regex('hello world; 42', ';? ') |
| 结果 | [hello, world, 42] |
| 别名 | regexp_split_to_array, str_split_regex
|
strip_accents(string)
| 描述 | 从 string 中去除变音符号。
|
| 示例 | strip_accents('mühleisen') |
| 结果 | muhleisen |
strlen(string)
| 描述 | string 中的字节数。
|
| 示例 | strlen('🦆') |
| 结果 | 4 |
substring(string, start[, length])
| 描述 | 提取从字符 start 开始到字符串末尾的子字符串。如果设置了可选参数 length，则提取长度为 length 个字符的子字符串。请注意，start 值为 1 指的是 string 的第一个字符。
|
| 示例 1 | substring('Hello', 2) |
| 结果 | ello |
| 示例 2 | substring('Hello', 2, 2) |
| 结果 | el |
| 别名 | substr |
substring_grapheme(string, start[, length])
| 描述 | 提取从字位簇 start 开始到字符串末尾的子字符串。如果设置了可选参数 length，则提取长度为 length 个字位簇的子字符串。请注意，start 值为 1 指的是 string 的 第一个字符。
|
| 示例 1 | substring_grapheme('🦆🤦🏼♂️🤦🏽♀️🦆', 3) |
| 结果 | 🤦🏽♀️🦆 |
| 示例 2 | substring_grapheme('🦆🤦🏼♂️🤦🏽♀️🦆', 3, 2) |
| 结果 | 🤦🏽♀️🦆 |
suffix(string, search_string)
| 描述 | 如果 string 以 search_string 结尾，则返回 true。请注意，不支持排序规则 (collations)。
|
| 示例 | suffix('abc', 'bc') |
| 结果 | true |
| 别名 | ends_with |
to_base(number, radix[, min_length])
| 描述 | 将 number 转换为给定基数 radix 的字符串，并可选择在前面补零至 min_length。
|
| 示例 | to_base(42, 16, 5) |
| 结果 | 0002A |
to_base64(blob)
| 描述 | 将 blob 转换为 base64 编码的字符串。
|
| 示例 | to_base64('A'::BLOB) |
| 结果 | QQ== |
| 别名 | base64 |
translate(string, from, to)
| 描述 | 将 string 中匹配 from 集合中字符的每个字符替换为 to 集合中对应的字符。如果 from 比 to 长，则删除 from 中多出的字符。
|
| 示例 | translate('12345', '143', 'ax') |
| 结果 | a2x5 |
trim(string[, characters])
| 描述 | 从 string 的任一侧删除所有出现的 characters。characters 默认为 space（空格）。
|
| 示例 1 | trim(' test ') |
| 结果 | test |
| 示例 2 | trim('>>>>test<<', '><') |
| 结果 | test |
unbin(value)
| 描述 | 将 value 从二进制表示形式转换为 blob。
|
| 示例 | unbin('0110') |
| 结果 | \x06 |
| 别名 | from_binary |
unhex(value)
| 描述 | 将 value 从十六进制表示形式转换为 blob。
|
| 示例 | unhex('2A') |
| 结果 | * |
| 别名 | from_hex |
unicode(string)
| 描述 | 返回一个表示 string 中第一个字符的 unicode 码位的 INTEGER。
|
| 示例 | [unicode('âbcd'), unicode('â'), unicode(''), unicode(NULL)] |
| 结果 | [226, 226, -1, NULL] |
| 别名 | ord |
upper(string)
| 描述 | 将 string 转换为大写。
|
| 示例 | upper('Hello') |
| 结果 | HELLO |
| 别名 | ucase |
url_decode(string)
| 描述 | 使用 百分号编码 (Percent-Encoding) 对 URL 进行解码。 |
| 示例 | url_decode('https%3A%2F%2Fduckdb.org%2Fwhy_duckdb%23portable') |
| 结果 | https://duckdb.net.cn/why_duckdb#portable |
url_encode(string)
| 描述 | 使用 百分号编码 (Percent-Encoding) 对 URL 进行编码。 |
| 示例 | url_encode('this string has/ special+ characters>') |
| 结果 | this%20string%20has%2F%20special%2B%20characters%3E |
文本相似度函数
这些函数用于使用各种相似度度量来衡量两个字符串的相似度。
| 函数 | 描述 |
|---|---|
damerau_levenshtein(s1, s2) |
Levenshtein 距离的扩展，还包括将相邻字符的转置作为允许的编辑操作。换句话说，是将一个字符串更改为另一个字符串所需的最少编辑操作次数（插入、删除、替换或转置）。不同大小写的字符（例如 a 和 A）被视为不同。
|
editdist3(s1, s2) |
levenshtein 的别名。
|
hamming(s1, s2) |
两个字符串之间的汉明距离，即两个等长字符串中字符不同的位置数量。字符串必须等长。不同大小写的字符（例如 a 和 A）被视为不同。
|
jaccard(s1, s2) |
两个字符串之间的 Jaccard 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。
|
jaro_similarity(s1, s2[, score_cutoff]) |
两个字符串之间的 Jaro 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。对于相似度 < score_cutoff 的情况，返回 0。score_cutoff 默认为 0。
|
jaro_winkler_similarity(s1, s2[, score_cutoff]) |
两个字符串之间的 Jaro-Winkler 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。对于相似度 < score_cutoff 的情况，返回 0。score_cutoff 默认为 0。
|
levenshtein(s1, s2) |
将一个字符串更改为另一个字符串所需的最少单字符编辑（插入、删除或替换）次数。不同大小写的字符（例如 a 和 A）被视为不同。
|
mismatches(s1, s2) |
hamming 的别名。
|
damerau_levenshtein(s1, s2)
| 描述 | Levenshtein 距离的扩展，还包括将相邻字符的转置作为允许的编辑操作。换句话说，是将一个字符串更改为另一个字符串所需的最少编辑操作次数（插入、删除、替换或转置）。不同大小写的字符（例如 a 和 A）被视为不同。
|
| 示例 | damerau_levenshtein('duckdb', 'udckbd') |
| 结果 | 2 |
hamming(s1, s2)
| 描述 | 两个字符串之间的汉明距离，即两个等长字符串中字符不同的位置数量。字符串必须等长。不同大小写的字符（例如 a 和 A）被视为不同。
|
| 示例 | hamming('duck', 'luck') |
| 结果 | 1 |
| 别名 | mismatches |
jaccard(s1, s2)
| 描述 | 两个字符串之间的 Jaccard 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。
|
| 示例 | jaccard('duck', 'luck') |
| 结果 | 0.6 |
jaro_similarity(s1, s2[, score_cutoff])
| 描述 | 两个字符串之间的 Jaro 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。对于相似度 < score_cutoff 的情况，返回 0。score_cutoff 默认为 0。
|
| 示例 | jaro_similarity('duck', 'duckdb') |
| 结果 | 0.8888888888888888 |
jaro_winkler_similarity(s1, s2[, score_cutoff])
| 描述 | 两个字符串之间的 Jaro-Winkler 相似度。不同大小写的字符（例如 a 和 A）被视为不同。返回 0 到 1 之间的数字。对于相似度 < score_cutoff 的情况，返回 0。score_cutoff 默认为 0。
|
| 示例 | jaro_winkler_similarity('duck', 'duckdb') |
| 结果 | 0.9333333333333333 |
levenshtein(s1, s2)
| 描述 | 将一个字符串更改为另一个字符串所需的最少单字符编辑（插入、删除或替换）次数。不同大小写的字符（例如 a 和 A）被视为不同。
|
| 示例 | levenshtein('duck', 'db') |
| 结果 | 3 |
| 别名 | editdist3 |
格式化程序
fmt 语法
format(format, parameters...) 函数用于格式化字符串，大致遵循 {fmt} 开源格式化库的语法。
不带额外参数的格式化
SELECT format('Hello world'); -- Hello world
使用 {} 格式化字符串
SELECT format('The answer is {}', 42); -- The answer is 42
使用位置参数格式化字符串
SELECT format('I''d rather be {1} than {0}.', 'right', 'happy'); -- I'd rather be happy than right.
格式指定符
| 说明符 | 描述 | 示例 |
|---|---|---|
{:d} |
整数 | 654321 |
{:E} |
科学计数法 | 3.141593E+00 |
{:f} |
float | 4.560000 |
{:o} |
八进制 | 2375761 |
{:s} |
string | asd |
{:x} |
十六进制 | 9fbf1 |
{:tX} |
整数，X 是千位分隔符
| 654 321 |
格式化类型
整数
SELECT format('{} + {} = {}', 3, 5, 3 + 5); -- 3 + 5 = 8
布尔值
SELECT format('{} != {}', true, false); -- true != false
格式化日期时间值
SELECT format('{}', DATE '1992-01-01'); -- 1992-01-01
SELECT format('{}', TIME '12:01:00'); -- 12:01:00
SELECT format('{}', TIMESTAMP '1992-01-01 12:01:00'); -- 1992-01-01 12:01:00
格式化 BLOB
SELECT format('{}', BLOB '\x00hello'); -- \x00hello
用 0 填充整数
SELECT format('{:04d}', 33); -- 0033
目前填充不能与千位分隔符规范结合使用。
从整数创建时间戳
SELECT format('{:02d}:{:02d}:{:02d} {}', 12, 3, 16, 'AM'); -- 12:03:16 AM
转换为十六进制
SELECT format('{:x}', 123_456_789); -- 75bcd15
转换为二进制
SELECT format('{:b}', 123_456_789); -- 111010110111100110100010101
打印带千位分隔符的数字
整数
SELECT format('{:,}', 123_456_789); -- 123,456,789
SELECT format('{:t.}', 123_456_789); -- 123.456.789
SELECT format('{:''}', 123_456_789); -- 123'456'789
SELECT format('{:_}', 123_456_789); -- 123_456_789
SELECT format('{:t }', 123_456_789); -- 123 456 789
SELECT format('{:tX}', 123_456_789); -- 123X456X789
浮点数、双精度数和十进制数
SELECT format('{:,f}', 123456.789); -- 123,456.78900
SELECT format('{:,.2f}', 123456.789); -- 123,456.79
SELECT format('{:t..2f}', 123456.789); -- 123.456,79
printf 语法
printf(format, parameters...) 函数使用 printf 语法格式化字符串。
不带额外参数的格式化
SELECT printf('Hello world');
Hello world
使用给定顺序的参数格式化字符串
SELECT printf('The answer to %s is %d', 'life', 42);
The answer to life is 42
使用位置参数 %position$formatter 格式化字符串，例如，作为字符串的第二个参数被编码为 %2$s
SELECT printf('I''d rather be %2$s than %1$s.', 'right', 'happy');
I'd rather be happy than right.
格式指定符
| 说明符 | 描述 | 示例 |
|---|---|---|
%c |
字符代码转字符 | a |
%d |
整数 | 654321 |
%Xd |
带有千位分隔符 X 的整数（支持 ,, ., '', _）
| 654_321 |
%E |
科学计数法 | 3.141593E+00 |
%f |
float | 4.560000 |
%hd |
整数 | 654321 |
%hhd |
整数 | 654321 |
%lld |
整数 | 654321 |
%o |
八进制 | 2375761 |
%s |
string | asd |
%x |
十六进制 | 9fbf1 |
格式化类型
整数
SELECT printf('%d + %d = %d', 3, 5, 3 + 5); -- 3 + 5 = 8
布尔值
SELECT printf('%s != %s', true, false); -- true != false
格式化日期时间值
SELECT printf('%s', DATE '1992-01-01'); -- 1992-01-01
SELECT printf('%s', TIME '12:01:00'); -- 12:01:00
SELECT printf('%s', TIMESTAMP '1992-01-01 12:01:00'); -- 1992-01-01 12:01:00
格式化 BLOB
SELECT printf('%s', BLOB '\x00hello'); -- \x00hello
用 0 填充整数
SELECT printf('%04d', 33); -- 0033
从整数创建时间戳
SELECT printf('%02d:%02d:%02d %s', 12, 3, 16, 'AM'); -- 12:03:16 AM
转换为十六进制
SELECT printf('%x', 123_456_789); -- 75bcd15
转换为二进制
SELECT printf('%b', 123_456_789); -- 111010110111100110100010101
千位分隔符
整数
SELECT printf('%,d', 123_456_789); -- 123,456,789
SELECT printf('%.d', 123_456_789); -- 123.456.789
SELECT printf('%''d', 123_456_789); -- 123'456'789
SELECT printf('%_d', 123_456_789); -- 123_456_789
浮点数、双精度数和十进制数
SELECT printf('%,f', 123456.789); -- 123,456.789000
SELECT printf('%,.2f', 123456.789); -- 123,456.79