Text Functions

Search Shortcut cmd + k | ctrl + k

Documentation / SQL / Functions

Text Functions

文本函数和操作符

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

Name	Description
`string ^@ search_string`	如果 `string` 以 `search_string` 开头，则返回 true。
`string \|\| string`	连接两个字符串。任何NULL输入都会导致NULL。另请参阅`concat(string, ...)`。
`string[index]`	使用（基于1的）索引提取单个字符。
`string[begin:end]`	使用切片约定提取字符串，请参阅切片。
`string LIKE target`	如果 `string` 匹配 like 说明符，则返回 true（参见模式匹配）。
`string SIMILAR TO regex`	如果 `string` 匹配 `regex`，则返回 `true`；与 `regexp_full_match` 相同（参见模式匹配）。
`array_extract(list, index)`	使用（基于1的）索引提取单个字符。
`array_slice(list, begin, end)`	使用切片约定提取字符串。接受负值。
`ascii(string)`	返回一个整数，表示`string`第一个字符的Unicode码点。
`bar(x, min, max[, width])`	绘制一个宽度与 (`x - min`) 成比例的带，当 `x` = `max` 时，宽度等于 `width` 字符。`width` 默认为 80。
`bit_length(string)`	字符串中的位数。
`chr(x)`	返回与ASCII码值或Unicode码点对应的字符。
`concat_ws(separator, string, ...)`	连接多个字符串，用`separator`分隔。NULL输入将被跳过。
`concat(string, ...)`	连接多个字符串。NULL 输入会被跳过。另请参阅 `string \|\| string`。
`contains(string, search_string)`	如果在 `string` 中找到 `search_string`，则返回 true。
`ends_with(string, search_string)`	如果 `string` 以 `search_string` 结尾，则返回 true。
`format_bytes(bytes)`	将字节转换为基于2的幂次方单位（KiB、MiB、GiB等）的人类可读表示形式。
`format(format, parameters, ...)`	使用fmt语法格式化字符串。
`from_base64(string)`	将base64编码的字符串转换为字符串。
`greatest(x1, x2, ...)`	使用字典顺序选择最大值。请注意，小写字符被认为比大写字符“更大”，并且不支持排序规则。
`hash(value)`	返回一个带有`value`哈希值的`UBIGINT`。
`ilike_escape(string, like_specifier, escape_character)`	如果`string`与`like_specifier`匹配（参见模式匹配），则返回true，使用不区分大小写的匹配。`escape_character`用于在`string`中搜索通配符字符。
`instr(string, search_string)`	返回`search_string`在`string`中首次出现的位置，从1开始计数。如果未找到匹配项，则返回0。
`least(x1, x2, ...)`	使用字典顺序选择最小的值。请注意，大写字符被认为比小写字符“更小”，并且不支持排序规则。
`left_grapheme(string, count)`	提取最左侧的字素簇。
`left(string, count)`	提取最左边的count个字符。
`length_grapheme(string)`	`string` 中的字形簇数量。
`length(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`的出现。
`ltrim(string)`	移除`string`左侧的任何空格。
`md5(string)`	返回`string`的MD5哈希值，类型为`VARCHAR`。
`md5_number(string)`	返回`string`的MD5哈希值，作为`HUGEINT`。
`md5_number_lower(string)`	返回`string`的MD5哈希值的低64位段，作为`BIGINT`。
`md5_number_higher(string)`	返回`string`的MD5哈希值的高64位段，作为`BIGINT`。
`nfc_normalize(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)`	返回字符串中最左侧字符的ASCII字符代码。
`parse_dirname(path, separator)`	返回给定路径中的顶级目录名称。`separator` 选项：`system`, `both_slash` (默认), `forward_slash`, `backslash`.
`parse_dirpath(path, separator)`	返回路径的头部（直到最后一个斜杠的路径名），类似于Python的`os.path.dirname`函数。`separator`选项：`system`，`both_slash`（默认），`forward_slash`，`backslash`。
`parse_filename(path, trim_extension, separator)`	返回路径的最后一个组件，类似于Python的`os.path.basename`函数。如果`trim_extension`为true，文件扩展名将被移除（默认为`false`）。`separator`选项：`system`，`both_slash`（默认），`forward_slash`，`backslash`。
`parse_path(path, separator)`	返回路径中的组件（目录和文件名）列表，类似于Python的`pathlib.parts`函数。`separator`选项：`system`，`both_slash`（默认），`forward_slash`，`backslash`。
`position(search_string IN string)`	返回`search_string`在`string`中首次出现的位置，从1开始计数。如果未找到匹配项，则返回0。
`printf(format, parameters...)`	使用printf语法格式化`字符串`。
`read_text(source)`	返回从`source`（文件名、文件名列表或通配符模式）读取的内容作为`VARCHAR`。文件内容首先会被验证为有效的UTF-8。如果`read_text`尝试读取包含无效UTF-8的文件，则会抛出错误，建议使用`read_blob`代替。更多详情请参阅`read_text`指南。
`regexp_escape(string)`	转义特殊模式，将`string`转换为正则表达式，类似于Python的`re.escape`函数。
`regexp_extract(string, pattern[, group = 0])`	如果 `string` 包含正则表达式 `pattern`，则返回由可选参数 `group` 指定的捕获组（参见模式匹配）。
`regexp_extract(string, pattern, name_list)`	如果 `string` 包含正则表达式 `pattern`，则返回捕获组作为结构体，并使用 `name_list` 中的相应名称（参见模式匹配）。
`regexp_extract_all(string, regex[, group = 0])`	将`string`沿着`regex`分割，并提取所有`group`的出现。
`regexp_full_match(string, regex)`	如果整个`string`与`regex`匹配，则返回`true`（参见模式匹配）。
`regexp_matches(string, pattern)`	如果 `string` 包含正则表达式 `pattern`，则返回 `true`，否则返回 `false`（参见模式匹配）。
`regexp_replace(string, pattern, replacement)`	如果 `string` 包含正则表达式 `pattern`，则将匹配部分替换为 `replacement`（参见模式匹配）。
`regexp_split_to_array(string, regex)`	将`string`沿`regex`分割。
`regexp_split_to_table(string, regex)`	将`string`按照`regex`分割，并返回每一部分的行。
`repeat(string, count)`	将 `string` 重复 `count` 次。
`replace(string, source, target)`	将`string`中的`source`替换为`target`。
`reverse(string)`	反转`string`。
`right_grapheme(string, count)`	提取最右边的 `count` 个字形簇。
`right(string, count)`	提取最右边的 `count` 个字符。
`rpad(string, count, character)`	用`character`在`string`的右侧填充，直到它达到`count`个字符。如果`string`的字符数超过`count`，则在右侧截断。
`rtrim(string, characters)`	从`string`的右侧移除任何`characters`的出现。
`rtrim(string)`	移除`string`右侧的任何空格。
`sha256(value)`	Returns a `VARCHAR` with the SHA-256 hash of the `value`.
`split_part(string, separator, index)`	沿着`separator`分割`string`并返回列表中（基于1的）`index`位置的数据。如果`index`超出列表范围，则返回空字符串（以匹配PostgreSQL的行为）。
`starts_with(string, search_string)`	如果 `string` 以 `search_string` 开头，则返回 true。
`str_split_regex(string, regex)`	将`string`沿`regex`分割。
`string_split_regex(string, regex)`	沿`regex`分割`string`。
`string_split(string, separator)`	沿着`separator`分割`string`。
`strip_accents(string)`	去除`string`中的重音符号。
`strlen(string)`	`string` 中的字节数。
`strpos(string, search_string)`	返回 `search_string` 在 `string` 中首次出现的位置，从1开始计数。如果没有找到匹配项，则返回0。
`substring(string, start, length)`	从字符 `start` 开始提取长度为 `length` 的子字符串。注意，`start` 值为 `1` 表示字符串的第一个字符。
`substring_grapheme(string, start, length)`	从字符 `start` 开始提取长度为 `length` 的图形簇子字符串。请注意，`start` 值为 `1` 时表示字符串的 `第一个` 字符。
`to_base64(blob)`	将blob转换为base64编码的字符串。
`trim(string, characters)`	从`string`的任一侧移除任何`characters`的出现。
`trim(string)`	移除`string`两侧的任何空格。
`unicode(string)`	返回 `string` 第一个字符的 Unicode 编码。
`upper(string)`	将 `string` 转换为大写。

`string ^@ search_string`

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

`string || string`

描述	连接两个字符串。任何`NULL`输入都会导致`NULL`。另请参见`concat(string, ...)`。
示例	`'Duck' \|\| 'DB'`
结果	`DuckDB`

`string[index]`

描述	使用（基于1的）索引提取单个字符。
示例	`'DuckDB'[4]`
结果	`k`
别名	`array_extract`

`string[begin:end]`

描述	使用类似于Python的切片约定提取字符串。缺失的`begin`或`end`参数分别被解释为列表的开头或结尾。接受负值。
示例	`'DuckDB'[:4]`
结果	`Duck`
别名	`array_slice`

更多示例：

SELECT
    'abcdefghi' AS str,
    str[3],    -- get char at position 3, 'c'
    str[3:5],  -- substring from position 3 up to and including position 5, 'cde'
    str[6:],   -- substring from position 6 till the end, 'fghi'
    str[:3],   -- substring from the start up to and including position 3, 'abc'
    str[3:-4], -- substring from positio 3 up to and including the 4th position from the end, 'cdef'
;

`string LIKE target`

描述	如果`string`匹配like说明符（参见模式匹配），则返回true。
示例	`'hello' LIKE '%lo'`
Result	`true`

`string SIMILAR TO regex`

描述	如果`string`匹配`regex`，则返回`true`；与`regexp_full_match`相同（参见模式匹配）
示例	`'hello' SIMILAR TO 'l+'`
Result	`false`

`array_extract(list, index)`

Description	Extract a single character using a (1-based) index.
示例	`array_extract('DuckDB', 2)`
结果	`u`
别名	`list_element`, `list_extract`

`array_slice(list, begin, end)`

描述	使用切片约定（如Python中的）提取字符串。接受负值。
示例 1	`array_slice('DuckDB', 3, 4)`
结果	`ck`
示例 2	`array_slice('DuckDB', 3, NULL)`
Result	`NULL`
示例 3	`array_slice('DuckDB', 0, -3)`
结果	`Duck`

`ascii(string)`

描述	返回一个整数，表示`string`的第一个字符的Unicode代码点。
示例	`ascii('Ω')`
结果	`937`

`bar(x, min, max[, width])`

描述	绘制一个宽度与 (`x - min`) 成比例的带子，当 `x` = `max` 时，宽度等于 `width` 字符。`width` 默认为 80。
示例	`bar(5, 0, 20, 10)`
结果	`██▌`

`bit_length(string)`

描述	字符串中的位数。
示例	`bit_length('abc')`
Result	`24`

`chr(x)`

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

`concat_ws(separator, string, ...)`

描述	连接多个字符串，用`separator`分隔。`NULL`输入会被跳过。
示例	`concat_ws(', ', 'Banana', 'Apple', NULL, 'Melon')`
结果	`Banana, Apple, Melon`

`concat(string, ...)`

描述	连接多个字符串。`NULL` 输入会被跳过。另请参阅 `string \|\| string`。
示例	`concat('Hello', ' ', NULL, 'World')`
结果	`Hello World`

`contains(string, search_string)`

描述	如果在`string`中找到`search_string`，则返回true。
示例	`contains('abc', 'a')`
Result	`true`

`ends_with(string, search_string)`

描述	如果`string`以`search_string`结尾，则返回true。
示例	`ends_with('abc', 'c')`
Result	`true`
别名	`suffix`

`format_bytes(bytes)`

描述	将字节转换为基于2的幂次方单位（KiB、MiB、GiB等）的人类可读表示形式。
示例	`format_bytes(16384)`
结果	`16.0 KiB`

`format(format, parameters, ...)`

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

`from_base64(string)`

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

`greatest(x1, x2, ...)`

描述	使用字典顺序选择最大值。请注意，小写字符被认为比大写字符“更大”，并且不支持排序规则。
示例	`greatest('abc', 'bcd', 'cde', 'EFG')`
结果	`'cde'`

`hash(value)`

Description	Returns a `UBIGINT` with the hash of the `value`.
Example	`hash('🦆')`
Result	`2595805878642663834`

`ilike_escape(string, like_specifier, escape_character)`

描述	如果`string`与`like_specifier`匹配（参见模式匹配），则返回true，使用不区分大小写的匹配。`escape_character`用于在`string`中搜索通配符字符。
示例	`ilike_escape('A%c', 'a$%C', '$')`
Result	`true`

`instr(string, search_string)`

描述	返回`search_string`在`string`中首次出现的位置，从1开始计数。如果未找到匹配项，则返回0。
示例	`instr('test test', 'es')`
Result	2

`least(x1, x2, ...)`

描述	使用字典顺序选择最小值。请注意，大写字符被视为“小于”小写字符，并且不支持排序规则。
示例	`least('abc', 'BCD', 'cde', 'EFG')`
结果	`'BCD'`

`left_grapheme(string, count)`

描述	提取最左侧的字素簇。
示例	`left_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1)`
结果	`🤦🏼‍♂️`

`left(string, count)`

描述	提取最左边的count个字符。
示例	`left('Hello🦆', 2)`
结果	`He`

`length_grapheme(string)`

描述	`string` 中的字形簇数量。
示例	`length_grapheme('🤦🏼‍♂️🤦🏽‍♀️')`
Result	`2`

`length(string)`

描述	`string` 中的字符数。
示例	`length('Hello🦆')`
Result	`6`

`like_escape(string, like_specifier, escape_character)`

描述	如果`string`与`like_specifier`匹配（参见模式匹配），则返回true，使用区分大小写的匹配。`escape_character`用于在`string`中搜索通配符字符。
示例	`like_escape('a%c', 'a$%c', '$')`
Result	`true`

`lower(string)`

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

`lpad(string, count, character)`

描述	用`character`在`string`的左侧填充，直到它有`count`个字符。如果`string`的字符数超过`count`，则在右侧截断。
示例	`lpad('hello', 8, '>')`
结果	`>>>hello`

`ltrim(string, characters)`

描述	从`string`的左侧移除任何`characters`的出现。
示例	`ltrim('>>>>test<<', '><')`
结果	`test<<`

`ltrim(string)`

描述	从`string`的左侧移除任何空格。在示例中，`␣`符号表示一个空格字符。
示例	`ltrim('␣␣␣␣test␣␣')`
结果	`test␣␣`

`md5(string)`

Description	Returns the MD5 hash of the `string` as a `VARCHAR`.
Example	`md5('123')`
Result	`202cb962ac59075b964b07152d234b70`

`md5_number(string)`

Description	Returns the MD5 hash of the `string` as a `HUGEINT`.
Example	`md5_number('123')`
Result	`149263671248412135425768892945843956768`

`md5_number_lower(string)`

描述	返回`string`的MD5哈希值，作为`BIGINT`类型。
Example	`md5_number_lower('123')`
Result	`8091599832034528150`

`md5_number_higher(string)`

描述	返回`string`的MD5哈希值，作为`BIGINT`。
Example	`md5_number_higher('123')`
Result	`6559309979213966368`

`nfc_normalize(string)`

描述	将字符串转换为Unicode 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', '$')`
Result	`false`

`not_like_escape(string, like_specifier, escape_character)`

描述	如果`string`与`like_specifier`匹配（参见模式匹配），则返回false，使用不区分大小写的匹配。`escape_character`用于在`string`中搜索通配符字符。
示例	`not_like_escape('a%c', 'a$%c', '$')`
Result	`false`

`ord(string)`

描述	返回字符串中最左边字符的ASCII字符代码。
示例	`ord('ü')`
结果	`252`

`parse_dirname(path, separator)`

描述	从给定路径返回顶级目录名称。`separator` 选项：`system`, `both_slash` (默认), `forward_slash`, `backslash`.
示例	`parse_dirname('path/to/file.csv', 'system')`
结果	`path`

`parse_dirpath(path, separator)`

描述	返回路径的头部（直到最后一个斜杠的路径名），类似于Python的`os.path.dirname`函数。`separator`选项：`system`，`both_slash`（默认），`forward_slash`，`backslash`。
示例	`parse_dirpath('/path/to/file.csv', 'forward_slash')`
结果	`/path/to`

`parse_filename(path, trim_extension, separator)`

描述	返回路径的最后一个组件，类似于Python的`os.path.basename`函数。如果`trim_extension`为true，文件扩展名将被移除（默认为`false`）。`separator`选项：`system`，`both_slash`（默认），`forward_slash`，`backslash`。
示例	`parse_filename('path/to/file.csv', true, 'system')`
结果	`file`

`parse_path(path, separator)`

描述	返回路径中的组件（目录和文件名）列表，类似于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)`

Description	Return location of first occurrence of `search_string` in `string`, counting from 1. Returns 0 if no match found.
示例	`position('b' IN 'abc')`
Result	`2`

`printf(format, parameters...)`

描述	使用printf语法格式化一个`string`。
示例	`printf('Benchmark "%s" took %d seconds', 'CSV', 42)`
Result	`Benchmark "CSV" took 42 seconds`

`read_text(source)`

Description	Returns the content from `source` (a filename, a list of filenames, or a glob pattern) as a `VARCHAR`. The file content is first validated to be valid UTF-8. If `read_text` attempts to read a file with invalid UTF-8 an error is thrown suggesting to use `read_blob` instead. See the `read_text` guide for more details.
Example	`read_text('hello.txt')`
Result	`hello\n`

`regexp_escape(string)`

描述	转义特殊模式，将`string`转换为正则表达式，类似于Python的`re.escape`函数。
示例	`regexp_escape('http://d.org')`
结果	`http\:\/\/d\.org`

`regexp_extract(string, pattern[, group = 0])`

描述	如果 `string` 包含正则表达式 `pattern`，则返回由可选参数 `group` 指定的捕获组（参见模式匹配）。
示例	`regexp_extract('hello_world', '([a-z ]+)_?', 1)`
Result	`hello`

`regexp_extract(string, pattern, name_list)`

描述	如果 `string` 包含正则表达式 `pattern`，则返回捕获组作为具有来自 `name_list` 的相应名称的结构体（参见模式匹配）。
Example	`regexp_extract('2023-04-15', '(\d+)-(\d+)-(\d+)', ['y', 'm', 'd'])`
Result	`{'y':'2023', 'm':'04', 'd':'15'}`

`regexp_extract_all(string, regex[, group = 0])`

描述	沿着`regex`分割`string`并提取所有`group`的出现。
示例	`regexp_extract_all('hello_world', '([a-z ]+)_?', 1)`
结果	`[hello, world]`

`regexp_full_match(string, regex)`

描述	如果整个`string`与`regex`匹配，则返回`true`（参见模式匹配）。
示例	`regexp_full_match('anabanana', '(an)')`
Result	`false`

`regexp_matches(string, pattern)`

描述	如果 `string` 包含正则表达式 `pattern`，则返回 `true`，否则返回 `false`（参见模式匹配）。
示例	`regexp_matches('anabanana', '(an)')`
Result	`true`

`regexp_replace(string, pattern, replacement)`

描述	如果 `string` 包含正则表达式 `pattern`，则将匹配部分替换为 `replacement`（参见模式匹配）。
Example	`regexp_replace('hello', '[lo]', '-')`
Result	`he-lo`

`regexp_split_to_array(string, regex)`

描述	沿着`regex`分割`string`。
Example	`regexp_split_to_array('hello world; 42', ';? ')`
Result	`['hello', 'world', '42']`
别名	`string_split_regex`, `str_split_regex`

`regexp_split_to_table(string, regex)`

描述	沿着`regex`分割`string`，并为每个部分返回一行。
Example	`regexp_split_to_table('hello world; 42', ';? ')`
结果	两行：`'hello'`, `'world'`

`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_grapheme(string, count)`

描述	提取最右边的`count`个字形簇。
示例	`right_grapheme('🤦🏼‍♂️🤦🏽‍♀️', 1)`
结果	`🤦🏽‍♀️`

`right(string, count)`

描述	提取最右边的`count`个字符。
示例	`right('Hello🦆', 3)`
结果	`lo🦆`

`rpad(string, count, character)`

描述	用`character`在`string`的右侧填充，直到它有`count`个字符。如果`string`的字符数超过`count`，则在右侧截断。
示例	`rpad('hello', 10, '<')`
结果	`hello<<<<<`

`rtrim(string, characters)`

描述	从`string`的右侧移除任何`characters`的出现。
示例	`rtrim('>>>>test<<', '><')`
结果	`>>>>test`

`rtrim(string)`

描述	从`string`的右侧移除任何空格。在示例中，`␣`符号表示一个空格字符。
示例	`rtrim('␣␣␣␣test␣␣')`
结果	`␣␣␣␣test`

`sha256(value)`

Description	Returns a `VARCHAR` with the SHA-256 hash of the `value`.
Example	`sha256('🦆')`
Result	`d7a5c5e0d1d94c32218539e7e47d4ba9c3c7b77d61332fb60d633dde89e473fb`

`split_part(string, separator, index)`

描述	沿着`separator`分割`string`并返回列表中（基于1的）`index`位置的数据。如果`index`超出列表的范围，则返回一个空字符串（以匹配PostgreSQL的行为）。
示例	`split_part('a;b;c', ';', 2)`
结果	`b`

`starts_with(string, search_string)`

Description	Return true if `string` begins with `search_string`.
示例	`starts_with('abc', 'a')`
Result	`true`

`str_split_regex(string, regex)`

Description	Splits the `string` along the `regex`.
示例	`str_split_regex('hello world; 42', ';? ')`
Result	`['hello', 'world', '42']`
别名	`string_split_regex`, `regexp_split_to_array`

`string_split_regex(string, regex)`

Description	Splits the `string` along the `regex`.
示例	`string_split_regex('hello world; 42', ';? ')`
Result	`['hello', 'world', '42']`
别名	`str_split_regex`, `regexp_split_to_array`

`string_split(string, separator)`

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

`strip_accents(string)`

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

`strlen(string)`

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

`strpos(string, search_string)`

Description	Return location of first occurrence of `search_string` in `string`, counting from 1. Returns 0 if no match found.
示例	`strpos('test test', 'es')`
Result	2
别名	`instr`

`substring(string, start, length)`

描述	从字符`start`开始提取长度为`length`的子字符串。请注意，`start`值为`1`表示字符串的`第一个`字符。
示例	`substring('Hello', 2, 2)`
结果	`el`
别名	`substr`

`substring_grapheme(string, start, length)`

描述	从字符`start`开始提取长度为`length`的字素簇的子字符串。请注意，`start`值为`1`时指的是字符串的`第一个`字符。
示例	`substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3, 2)`
结果	`🤦🏽‍♀️🦆`

`to_base64(blob)`

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

`trim(string, characters)`

描述	从`string`的两侧移除任何`characters`的出现。
示例	`trim('>>>>test<<', '><')`
结果	`test`

`trim(string)`

描述	移除`string`两侧的任何空格。
示例	`trim(' test ')`
结果	`test`

`unicode(string)`

描述	返回`string`第一个字符的Unicode编码。当`string`为空时返回`-1`，当`string`为`NULL`时返回`NULL`。
示例	`[unicode('âbcd'), unicode('â'), unicode(''), unicode(NULL)]`
结果	`[226, 226, -1, NULL]`

`upper(string)`

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

文本相似度函数

这些函数用于使用各种相似度度量来测量两个字符串的相似度。

Name	Description
`damerau_levenshtein(s1, s2)`	Levenshtein距离的扩展，还包括将相邻字符的转置作为允许的编辑操作。换句话说，将一个字符串更改为另一个字符串所需的最少编辑操作（插入、删除、替换或转置）次数。不同大小写的字符（例如，`a` 和 `A`）被视为不同的字符。
`editdist3(s1, s2)`	为了与SQLite兼容，`levenshtein`的别名。将一个字符串更改为另一个字符串所需的最少单字符编辑（插入、删除或替换）次数。不同大小写的字符（例如，`a` 和 `A`）被视为不同。
`hamming(s1, s2)`	两个字符串之间的汉明距离，即两个等长字符串中不同字符的位置数。字符串必须等长。不同大小写的字符（例如，`a` 和 `A`）被视为不同。
`jaccard(s1, s2)`	两个字符串之间的Jaccard相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
`jaro_similarity(s1, s2)`	两个字符串之间的Jaro相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
`jaro_winkler_similarity(s1, s2)`	两个字符串之间的Jaro-Winkler相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
`levenshtein(s1, s2)`	将一个字符串更改为另一个字符串所需的最少单字符编辑次数（插入、删除或替换）。不同大小写的字符（例如，`a` 和 `A`）被视为不同的字符。
`mismatches(s1, s2)`	`hamming(s1, s2)` 的别名。两个等长字符串中不同字符的位置数。字符串必须等长。不同大小写的字符（例如，`a` 和 `A`）被视为不同。

`damerau_levenshtein(s1, s2)`

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

`editdist3(s1, s2)`

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

`hamming(s1, s2)`

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

`jaccard(s1, s2)`

描述	两个字符串之间的Jaccard相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
示例	`jaccard('duck', 'luck')`
结果	`0.6`

`jaro_similarity(s1, s2)`

描述	两个字符串之间的Jaro相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
示例	`jaro_similarity('duck', 'duckdb')`
结果	`0.88`

`jaro_winkler_similarity(s1, s2)`

描述	两个字符串之间的Jaro-Winkler相似度。不同大小写的字符（例如，`a` 和 `A`）被视为不同。返回一个介于0和1之间的数字。
示例	`jaro_winkler_similarity('duck', 'duckdb')`
结果	`0.93`

`levenshtein(s1, s2)`

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

`mismatches(s1, s2)`

描述	`hamming(s1, s2)` 的别名。两个等长字符串中不同字符的位置数。字符串必须等长。不同大小写的字符（例如，`a` 和 `A`）被视为不同。
示例	`mismatches('duck', 'luck')`
Result	`1`

Formatters

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

Format Specifiers

Specifier	Description	Example
`{:d}`	整数	`123456`
`{:E}`	科学计数法	`3.141593E+00`
`{:f}`	浮点数	`4.560000`
`{:o}`	八进制	`361100`
`{:s}`	字符串	`asd`
`{:x}`	十六进制	`1e240`
`{:tX}`	整数, `X` 是千位分隔符	`123 456`

格式化类型

整数：

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.

Format Specifiers

Specifier	Description	Example
`%c`	字符代码转换为字符	`a`
`%d`	整数	`123456`
`%Xd`	带有千位分隔符的整数 `X` 来自 `,`, `.`, `''`, `_`	`123_456`
`%E`	科学计数法	`3.141593E+00`
`%f`	浮点数	`4.560000`
`%hd`	整数	`123456`
`%hhd`	整数	`123456`
`%lld`	整数	`123456`
`%o`	八进制	`361100`
`%s`	字符串	`asd`
`%x`	十六进制	`1e240`

Formatting Types

整数：

SELECT printf('%d + %d = %d', 3, 5, 3 + 5); -- 3 + 5 = 8