文本函数 – DuckDB 数据库

搜索快捷键 cmd + k | ctrl + k

文档 / SQL / 函数

文本函数

文本函数和运算符

本节介绍用于检查和操作STRING值的函数和运算符。

名称	描述
`string[index]`	使用（基于1的）索引提取单个字符。
`string[begin:end]`	使用类似于Python的切片约定提取字符串。缺失的`begin`或`end`参数分别被解释为列表的开头或结尾。接受负值。
`string LIKE target`	如果`string`与like说明符匹配（参见模式匹配），则返回`true`。
`string SIMILAR TO regex`	如果`string`与`regex`匹配（参见模式匹配），则返回`true`。
`string ^@ search_string`	如果`string`以`search_string`开头，则返回`true`。
`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)`	将`blob`转换为base64编码的字符串。
`bin(string)`	将`string`转换为二进制表示。
`bit_length(string)`	`string`中的位数。
`char_length(string)`	`string`中的字符数。
`character_length(string)`	`string`中的字符数。
`chr(code_point)`	返回一个与ASCII码值或Unicode码点对应的字符。
`concat(value, ...)`	连接多个字符串、列表或blob。`NULL`输入将被跳过。另请参见运算符`\|\|`。
`concat_ws(separator, string, ...)`	连接多个字符串，以`separator`分隔。`NULL`输入将被跳过。
`contains(string, search_string)`	如果`search_string`在`string`中找到，则返回`true`。请注意，不支持排序规则。
`ends_with(string, search_string)`	如果`string`以`search_string`结尾，则返回`true`。
`format(format, ...)`	使用fmt语法格式化字符串。
`formatReadableDecimalSize(integer)`	将`integer`转换为使用10的幂（KB、MB、GB等）作为单位的人类可读表示。
`formatReadableSize(integer)`	将`integer`转换为使用2的幂（KiB、MiB、GiB等）作为单位的人类可读表示。
`format_bytes(integer)`	将`integer`转换为使用2的幂（KiB、MiB、GiB等）作为单位的人类可读表示。
`from_base64(string)`	将base64编码的`string`转换为字符字符串（`BLOB`）。
`from_binary(value)`	将`value`从二进制表示转换为blob。
`from_hex(value)`	将`value`从十六进制表示转换为blob。
`greatest(arg1, ...)`	返回按字典顺序的最大值。请注意，小写字符被认为比大写字符大，且不支持排序规则。
`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)`	将`string`转换为小写。
`least(arg1, ...)`	返回按字典顺序的最小值。请注意，大写字符被认为比小写字符小，且不支持排序规则。
`left(string, count)`	提取最左边的count个字符。
`left_grapheme(string, count)`	提取最左边的count个字素簇。
`len(string)`	`string`中的字符数。
`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`个字符。如果`string`的字符数超过`count`，则在右侧截断。
`ltrim(string[, characters])`	从`string`的左侧移除`characters`中任何字符的任何出现。 `characters`默认为`space`。
`md5(string)`	以`VARCHAR`形式返回`string`的MD5哈希值。
`md5_number(string)`	以`HUGEINT`形式返回`string`的MD5哈希值。
`md5_number_lower(string)`	以`UBIGINT`形式返回`string`的MD5哈希值的低64位段。
`md5_number_upper(string)`	以`UBIGINT`形式返回`string`的MD5哈希值的高64位段。
`nfc_normalize(string)`	将`string`转换为Unicode NFC规范化字符串。如果文本数据混合了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)`	返回一个`INTEGER`，表示`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。
`prefix(string, search_string)`	如果`string`以`search_string`开头，则返回`true`。
`printf(format, ...)`	使用printf语法格式化`string`。
`read_text(source)`	以`VARCHAR`形式返回`source`（文件名、文件名列表或glob模式）的内容。文件内容首先被验证为有效的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])`	沿`regex`分割`string`。可以设置一组可选的正则表达式`options`。
`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`个字符。如果`string`的字符数超过`count`，则在右侧截断。
`rtrim(string[, characters])`	从`string`的右侧移除`characters`中任何字符的任何出现。 `characters`默认为`space`。
`sha1(value)`	返回包含`value`的SHA-1哈希值的`VARCHAR`。
`sha256(value)`	返回包含`value`的SHA-256哈希值的`VARCHAR`
`split(string, separator)`	沿`separator`分割`string`。
`split_part(string, separator, index)`	沿`separator`分割`string`，并返回列表中（基于1的）`index`处的数据。如果`index`超出列表范围，则返回空字符串（以匹配PostgreSQL的行为）。
`starts_with(string, search_string)`	如果`string`以`search_string`开头，则返回`true`。
`str_split(string, separator)`	沿`separator`分割`string`。
`str_split_regex(string, regex[, options])`	沿`regex`分割`string`。可以设置一组可选的正则表达式`options`。
`string_split(string, separator)`	沿`separator`分割`string`。
`string_split_regex(string, regex[, options])`	沿`regex`分割`string`。可以设置一组可选的正则表达式`options`。
`string_to_array(string, separator)`	沿`separator`分割`string`。
`strip_accents(string)`	从`string`中去除重音符号。
`strlen(string)`	`string`中的字节数。
`strpos(string, search_string)`	返回`search_string`在`string`中第一次出现的位置，从1开始计数。如果没有找到匹配项，则返回0。
`substr(string, start[, length])`	提取从字符`start`开始到字符串末尾的子字符串。如果设置了可选参数`length`，则提取`length`个字符的子字符串。请注意，`start`值为`1`表示`string`的第一个字符。
`substring(string, start[, length])`	提取从字符`start`开始到字符串末尾的子字符串。如果设置了可选参数`length`，则提取`length`个字符的子字符串。请注意，`start`值为`1`表示`string`的第一个字符。
`substring_grapheme(string, start[, length])`	提取从字素簇`start`开始到字符串末尾的子字符串。如果设置了可选参数`length`，则提取`length`个字素簇的子字符串。请注意，`start`值为`1`表示`string`的`first`个字符。
`suffix(string, search_string)`	如果`string`以`search_string`结尾，则返回`true`。
`to_base(number, radix[, min_length])`	将`number`转换为给定基数`radix`的字符串，可选择用前导零填充到`min_length`。
`to_base64(blob)`	将`blob`转换为base64编码的字符串。
`to_binary(string)`	将`string`转换为二进制表示。
`to_hex(string)`	将`string`转换为十六进制表示。
`translate(string, from, to)`	将`string`中与`from`集合中的字符匹配的每个字符替换为`to`集合中对应的字符。如果`from`比`to`长，则删除`from`中多余字符的出现。
`trim(string[, characters])`	从`string`的两侧移除`characters`中任何字符的任何出现。 `characters`默认为`space`。
`ucase(string)`	将`string`转换为大写。
`unbin(value)`	将`value`从二进制表示转换为blob。
`unhex(value)`	将`value`从十六进制表示转换为blob。
`unicode(string)`	返回一个`INTEGER`，表示`string`中第一个字符的`unicode`码点。
`upper(string)`	将`string`转换为大写。
`url_decode(string)`	使用百分号编码从表示形式解码URL。
`url_encode(string)`	使用百分号编码将URL编码为表示形式。

`string[index]`

描述	使用（基于1的）索引提取单个字符。
示例	`'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`

`string ^@ search_string`

描述	如果`string`以`search_string`开头，则返回`true`。
示例	`'abc' ^@ 'a'`
结果	`true`
别名	`starts_with`

`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)`
结果	`██▌`

`base64(blob)`

描述	将`blob`转换为base64编码的字符串。
示例	`base64('A'::BLOB)`
结果	`QQ==`
别名	`to_base64`

`bin(string)`

描述	将`string`转换为二进制表示。
示例	`bin('Aa')`
结果	`0100000101100001`
别名	`to_binary`

`bit_length(string)`

描述	`string`中的位数。
示例	`bit_length('abc')`
结果	`24`

`char_length(string)`

描述	`string`中的字符数。
示例	`char_length('Hello🦆')`
结果	`6`
别名	`character_length`, `len`, `length`

`character_length(string)`

描述	`string`中的字符数。
示例	`character_length('Hello🦆')`
结果	`6`
别名	`char_length`, `len`, `length`

`chr(code_point)`

描述	返回一个与ASCII码值或Unicode码点对应的字符。
示例	`chr(65)`
结果	`A`

`concat(value, ...)`

描述	连接多个字符串、列表或blob。`NULL`输入将被跳过。另请参见运算符`\|\|`。
示例	`concat('Hello', ' ', 'World')`
结果	`Hello World`

`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`

`ends_with(string, search_string)`

描述	如果`string`以`search_string`结尾，则返回`true`。请注意，不支持排序规则。
示例	`ends_with('abc', 'bc')`
结果	`true`
别名	`suffix`

`format(format, ...)`

描述	使用fmt语法格式化字符串。
示例	`format('Benchmark "{}" took {} seconds', 'CSV', 42)`
结果	`Benchmark "CSV" took 42 seconds`

`formatReadableDecimalSize(integer)`

描述	将`integer`转换为使用10的幂（KB、MB、GB等）作为单位的人类可读表示。
示例	`formatReadableDecimalSize(16_000)`
结果	`16.0 kB`

`formatReadableSize(integer)`

描述	将`integer`转换为使用2的幂（KiB、MiB、GiB等）作为单位的人类可读表示。
示例	`formatReadableSize(16_000)`
结果	`15.6 KiB`
别名	`format_bytes`

`format_bytes(integer)`

描述	将`integer`转换为使用2的幂（KiB、MiB、GiB等）作为单位的人类可读表示。
示例	`format_bytes(16_000)`
结果	`15.6 KiB`
别名	`formatReadableSize`

`from_base64(string)`

描述	将base64编码的`string`转换为字符字符串（`BLOB`）。
示例	`from_base64('QQ==')`
结果	`A`

`from_binary(value)`

描述	将`value`从二进制表示转换为blob。
示例	`from_binary('0110')`
结果	`\x06`
别名	`unbin`

`from_hex(value)`

描述	将`value`从十六进制表示转换为blob。
示例	`from_hex('2A')`
结果	`*`
别名	`unhex`

`greatest(arg1, ...)`

描述	返回按字典顺序的最大值。请注意，小写字符被认为比大写字符大，且不支持排序规则。
示例 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`

`lcase(string)`

描述	将`string`转换为小写。
示例	`lcase('Hello')`
结果	`hello`
别名	`lower`

`least(arg1, ...)`

描述	返回按字典顺序的最小值。请注意，大写字符被认为比小写字符小，且不支持排序规则。
示例 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个字素簇。
示例	`left_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1)`
结果	`🤦🏼‍♂️`

`len(string)`

描述	`string`中的字符数。
示例	`length('Hello🦆')`
结果	`6`
别名	`char_length`, `character_length`, `len`

`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`个字符。如果`string`的字符数超过`count`，则在右侧截断。
示例	`lpad('hello', 8, '>')`
结果	`>>>hello`

`ltrim(string[, characters])`

描述	从`string`的左侧移除`characters`中任何字符的任何出现。 `characters`默认为`space`。
示例 1	`ltrim(' test ')`
结果	`test`
示例 2	`ltrim('>>>>test<<', '><')`
结果	`test<<`

`md5(string)`

描述	以`VARCHAR`形式返回`string`的MD5哈希值。
示例	`md5('abc')`
结果	`900150983cd24fb0d6963f7d28e17f72`

`md5_number(string)`

描述	以`HUGEINT`形式返回`string`的MD5哈希值。
示例	`md5_number('abc')`
结果	`152195979970564155685860391459828531600`

`md5_number_lower(string)`

描述	以`UBIGINT`形式返回`string`的MD5哈希值的低64位段。
示例	`md5_number_lower('abc')`
结果	`8250560606382298838`

`md5_number_upper(string)`

描述	以`UBIGINT`形式返回`string`的MD5哈希值的高64位段。
示例	`md5_number_upper('abc')`
结果	`12704604231530709392`

`nfc_normalize(string)`

描述	将`string`转换为Unicode NFC规范化字符串。如果文本数据混合了NFC规范化和非NFC规范化，则对于比较和排序很有用。
示例	`nfc_normalize('ardè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`

`ord(string)`

描述	返回一个`INTEGER`，表示`string`中第一个字符的`unicode`码点。
示例	`[unicode('âbcd'), unicode('â'), unicode(''), unicode(NULL)]`
结果	`[226, 226, -1, NULL]`
别名	`unicode`

`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)`

描述	以`VARCHAR`形式返回`source`（文件名、文件名列表或glob模式）的内容。文件内容首先被验证为有效的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_array(string, regex[, options])`

描述	沿`regex`分割`string`。可以设置一组可选的正则表达式`options`。
示例	`regexp_split_to_array('hello world; 42', ';? ')`
结果	`[hello, world, 42]`
别名	`str_split_regex`, `string_split_regex`

`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`个字符。如果`string`的字符数超过`count`，则在右侧截断。
示例	`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(string, separator)`

描述	沿`separator`分割`string`。
示例	`split('hello-world', '-')`
结果	`[hello, world]`
别名	`str_split`, `string_split`, `string_to_array`

`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`
别名	`^@`

`str_split(string, separator)`

描述	沿`separator`分割`string`。
示例	`str_split('hello-world', '-')`
结果	`[hello, world]`
别名	`split`, `string_split`, `string_to_array`

`str_split_regex(string, regex[, options])`

描述	沿`regex`分割`string`。可以设置一组可选的正则表达式`options`。
示例	`str_split_regex('hello world; 42', ';? ')`
结果	`[hello, world, 42]`
别名	`regexp_split_to_array`, `string_split_regex`

`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`

`string_to_array(string, separator)`

描述	沿`separator`分割`string`。
示例	`string_to_array('hello-world', '-')`
结果	`[hello, world]`
别名	`split`, `str_split`, `string_split`

`strip_accents(string)`

描述	从`string`中去除重音符号。
示例	`strip_accents('mühleisen')`
结果	`muhleisen`

`strlen(string)`

描述	`string`中的字节数。
示例	`strlen('🦆')`
结果	`4`

`strpos(string, search_string)`

描述	返回`search_string`在`string`中第一次出现的位置，从1开始计数。如果没有找到匹配项，则返回0。
示例	`strpos('test test', 'es')`
结果	`2`
别名	`instr`, `position`

`substr(string, start[, length])`

描述	提取从字符`start`开始到字符串末尾的子字符串。如果设置了可选参数`length`，则提取`length`个字符的子字符串。请注意，`start`值为`1`表示`string`的第一个字符。
示例 1	`substring('Hello', 2)`
结果	`ello`
示例 2	`substring('Hello', 2, 2)`
结果	`el`
别名	`substring`

`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`的`first`个字符。
示例 1	`substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3)`
结果	`🤦🏽‍♀️🦆`
示例 2	`substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3, 2)`
结果	`🤦🏽‍♀️🦆`

`suffix(string, search_string)`

描述	如果`string`以`search_string`结尾，则返回`true`。
示例	`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`

`to_binary(string)`

描述	将`string`转换为二进制表示。
示例	`to_binary('Aa')`
结果	`0100000101100001`
别名	`bin`

`to_hex(string)`

描述	将`string`转换为十六进制表示。
示例	`to_hex('Hello')`
结果	`48656C6C6F`
别名	`hex`

`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`

`ucase(string)`

描述	将`string`转换为大写。
示例	`ucase('Hello')`
结果	`HELLO`
别名	`upper`

`unbin(value)`

描述	将`value`从二进制表示转换为blob。
示例	`unbin('0110')`
结果	`\x06`
别名	`from_binary`

`unhex(value)`

描述	将`value`从十六进制表示转换为blob。
示例	`unhex('2A')`
结果	`*`
别名	`from_hex`

`unicode(string)`

描述	返回一个`INTEGER`，表示`string`中第一个字符的`unicode`码点。
示例	`[unicode('âbcd'), unicode('â'), unicode(''), unicode(NULL)]`
结果	`[226, 226, -1, NULL]`
别名	`ord`

`upper(string)`

描述	将`string`转换为大写。
示例	`upper('Hello')`
结果	`HELLO`
别名	`ucase`

`url_decode(string)`

描述	使用百分号编码从表示形式解码URL。
示例	`url_decode('https%3A%2F%2Fduckdb.org%2Fwhy_duckdb%23portable')`
结果	`https://duckdb.net.cn/why_duckdb#portable`

`url_encode(string)`

描述	使用百分号编码将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)`	将一个字符串更改为另一个字符串所需的最小单字符编辑（插入、删除或替换）次数。不同大小写的字符（例如，`a`和`A`）被认为是不同的。
`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)`	两个字符串之间的汉明距离，即两个等长字符串中不同字符位置的数量。字符串长度必须相等。不同大小写的字符（例如，`a`和`A`）被认为是不同的。

`damerau_levenshtein(s1, s2)`

描述	Levenshtein距离的扩展，也包括相邻字符的转置作为允许的编辑操作。换句话说，将一个字符串更改为另一个字符串所需的最小编辑操作数（插入、删除、替换或转置）。不同大小写的字符（例如，`a`和`A`）被认为是不同的。
示例	`damerau_levenshtein('duckdb', 'udckbd')`
结果	`2`

`editdist3(s1, s2)`

描述	将一个字符串更改为另一个字符串所需的最小单字符编辑（插入、删除或替换）次数。不同大小写的字符（例如，`a`和`A`）被认为是不同的。
示例	`editdist3('duck', 'db')`
结果	`3`
别名	`levenshtein`

`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`

`mismatches(s1, s2)`

描述	两个字符串之间的汉明距离，即两个等长字符串中不同字符位置的数量。字符串长度必须相等。不同大小写的字符（例如，`a`和`A`）被认为是不同的。
示例	`mismatches('duck', 'luck')`
结果	`1`
别名	`hamming`

格式化器

`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}`	浮点数	`4.560000`
`{:o}`	八进制	`2375761`
`{:s}`	字符串	`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语法格式化字符串。