本文属于机器翻译版本。若本译文内容与英语原文存在差异，则一律以英文原文为准。
# 字符串函数
字符串函数用于处理和操作字符串或计算结果为字符串的表达式。当这些函数中的 *string* 参数为文本值时，该参数必须括在单引号中。支持的数据类型包括 CHAR 和 VARCHAR。
以下部分提供了支持的函数的函数名称、语法和描述。对字符串的所有偏移都从 1 开始。
**Topics**
+ [\$1\$1（串联）运算符](concat_op.md)
+ [BTRIM 函数](BTRIM.md)
+ [CONCAT 函数](CONCAT.md)
+ [格式字符串函数](FORMAT_STRING.md)
+ [LEFT 和 RIGHT 函数](LEFT.md)
+ [LENGTH 函数](LENGTH.md)
+ [LOWER 函数](LOWER.md)
+ [LPAD 和 RPAD 函数](LPAD.md)
+ [LTRIM 函数](LTRIM.md)
+ [POSITION 函数](POSITION.md)
+ [REGEXP\$1COUNT 函数](REGEXP_COUNT.md)
+ [REGEXP\$1INSTR 函数](REGEXP_INSTR.md)
+ [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)
+ [REGEXP\$1SUBSTR 函数](REGEXP_SUBSTR.md)
+ [REPEAT 函数](REPEAT.md)
+ [REPLACE 函数](REPLACE.md)
+ [REVERSE 函数](REVERSE.md)
+ [RTRIM 函数](RTRIM.md)
+ [分割功能](split.md)
+ [SPLIT\$1PART 函数](SPLIT_PART.md)
+ [SUBSTRING 函数](SUBSTRING.md)
+ [TRANSLATE 函数](TRANSLATE.md)
+ [TRIM 函数](TRIM.md)
+ [UPPER 函数](UPPER.md)
+ [UUID 函数](UUID.md)
# \$1\$1（串联）运算符
联接位于 \$1\$1 符号的任意一侧的两个表达式并返回联接后的表达式。
串联运算符类似于 [CONCAT 函数](CONCAT.md)。
**注意**
对于 CONCAT 函数和联接运算符，如果一个或多个表达式为 null，则联接的结果也为 null。
## 语法
```
expression1 || expression2
```
## 参数
*expression1*、*expression2*
两个参数都可以是长度固定或长度可变的字符串或表达式。
## 返回类型
\$1\$1 运算符返回字符串。字符串的类型与输入参数的类型相同。
## 示例
以下示例将 USERS 表中的 FIRSTNAME 和 LASTNAME 字段联接：
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
要联接可能包含 null 值的列，请使用 [NVL 和 COALESCE 函数](NVL_function.md) 表达式。以下示例使用 NVL 在遇到 NULL 时返回 0。
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# BTRIM 函数
BTRIM 函数通过删除前导空格和尾随空格或删除与可选的指定字符串匹配的前导字符和尾随字符来剪裁字符串。
## 语法
```
BTRIM(string [, trim_chars ] )
```
## 参数
*string*
要剪裁的输入 VARCHAR 字符串。
*trim\$1chars*
该 VARCHAR 字符串包含要匹配的字符。
## 返回类型
BTRIM 函数返回 VARCHAR 字符串。
## 示例
以下示例从字符串 `' abc '` 中剪裁前导和尾随空格：
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
以下示例从字符串 `'xyzaxyzbxyzcxyz'` 中删除前导和尾随 `'xyz'` 字符串。将删除前导和尾随的 `'xyz'`，但不会删除字符串内部的匹配字符。
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
以下示例从字符串 `'setuphistorycassettes'` 中删除与 *trim\$1chars* 列表 `'tes'` 中的任何字符相匹配的开头和结尾部分。在输入字符串开头或结尾部分，在 *trim\$1chars* 列表中未包含的其他字符之前出现的任何 `t`、`e` 或 `s` 都将被删除。
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# CONCAT 函数
CONCAT 函数将联接两个表达式并返回生成的表达式。要联接两个以上的表达式，请使用嵌套 CONCAT 函数。在两个表达式之间使用联接运算符（`||`）将生成与 CONCAT 函数相同的结果。
**注意**
对于 CONCAT 函数和联接运算符，如果一个或多个表达式为 null，则联接的结果也为 null。
## 语法
```
CONCAT ( expression1, expression2 )
```
## 参数
*expression1*、*expression2*
两个参数可以是固定长度字符串、可变长度字符串、二进制表达式或计算结果为其中一个输入的表达式。
## 返回类型
CONCAT 返回一个表达式。表达式的数据类型与输入参数的数据类型相同。
如果输入表达式的类型不同，则 AWS Clean Rooms 尝试对其中一个表达式进行隐式类型转换。如果值无法转换，则会返回一个错误。
## 示例
以下示例联接两个字符文本：
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
以下查询（使用 `||` 运算符而不是 CONCAT）将生成相同的结果：
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
以下示例使用两个 CONCAT 函数联接三个字符串：
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
要联接可能包含 null 值的列，请使用 [NVL 和 COALESCE 函数](NVL_function.md)。以下示例使用 NVL 在遇到 NULL 时返回 0。
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
以下查询联接 VENUE 表中的 CITY 和 STATE 值：
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
以下查询使用嵌套 CONCAT 函数。该查询将联接 VENUE 表中的 CITY 和 STATE 值，但会使用逗号和空格分隔生成的字符串：
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# 格式字符串函数
FORMAT\$1STRING 函数通过使用提供的参数替换模板字符串中的占位符来创建格式化字符串。它从 printf 样式的格式字符串中返回格式化字符串。
FORMAT\$1STRING 函数的工作原理是将模板字符串中的占位符替换为作为参数传递的相应值。当您需要动态构造包含静态文本和动态数据的字符串时，例如在生成输出消息、报告或其他类型的信息文本时，这种类型的字符串格式可能很有用。FORMAT\$1STRING 函数提供了一种简洁易读的方式来创建这些类型的格式化字符串，从而更易于维护和更新生成输出的代码。
## 语法
```
format_string(strfmt, obj, ...)
```
## Arguments
*strfmt*
一个字符串表达式。
*obj*
字符串或数字表达式。
## 返回类型
FORMAT\$1STRING 返回一个字符串。
## 示例
以下示例包含包含两个占位符的模板字符串：`%d`十进制（整数）值和`%s`字符串值。`%d`占位符被十进制（整数）值 (`100`) 替换，%s 占位符替换为字符串值 (`"days"`)。输出是一个模板字符串，占位符由提供的参数替换:`"Hello World 100 days"`.
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# LEFT 和 RIGHT 函数
这些函数返回指定数量的位于字符串最左侧或最右侧的字符。
该数量基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。
## 语法
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## 参数
*string*
任何字符串或计算结果为字符串的任何表达式。
*integer*
一个正整数。
## 返回类型
LEFT 和 RIGHT 返回 VARCHAR 字符串。
## 示例
以下示例返回介于 1000 和 1005 IDs 之间的事件名称中最左边的 5 个和最右边的 5 个字符：
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# LENGTH 函数
# LOWER 函数
将字符串转换为小写。LOWER 支持 UTF-8 多字节字符，并且每个字符最多可以有 4 个字节。
## 语法
```
LOWER(string)
```
## 参数
*string*
输入参数是 VARCHAR 字符串（或任何其他可隐式转换为 VARCHAR 的数据类型，如 CHAR）。
## 返回类型
LOWER 函数返回与输入字符串具有相同数据类型的字符串。
## 示例
以下示例将 CATNAME 字段转换为小写：
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# LPAD 和 RPAD 函数
这些函数根据指定长度在字符串前面或后面追加字符。
## 语法
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## 参数
*string1*
一个字符串或计算结果为字符串的表达式，如字符列的名称。
*length*
一个用于定义函数结果的长度的整数。字符串的长度基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。如果 *string1* 的长度超过指定长度，它将被截断（在右侧）。如果 *length* 为负数，函数的结果将为空字符串。
*string2*
追加到 *string1* 前面或后面的一个或多个字符。此参数是可选的；如果未指定它，则使用空格。
## 返回类型
这些函数返回 VARCHAR 数据类型。
## 示例
将指定的一组事件名称截断到 20 个字符并在短于此长度的名称前面追加空格：
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
将指定的一组事件名称截断到 20 个字符但在短于此长度的名称后面追加 `0123456789`。
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# LTRIM 函数
从字符串的开头剪裁几个字符。删除只包含剪裁字符列表中的字符的最长字符串。当修剪字符未出现在输入字符串中时，修剪即告完成。
## 语法
```
LTRIM( string [, trim_chars] )
```
## 参数
*string*
要剪裁的字符串列、表达式或字符串文本。
*trim\$1chars*
表示要从 *string* 的开头剪裁的字符的字符串列、表达式或字符串文本。如果未指定，则使用空格作为剪裁字符。
## 返回类型
LTRIM 函数返回与输入*字符串*（CHAR 或 VARCHAR）具有相同数据类型的字符串。
## 示例
以下示例从 `listime` 列中剪裁掉年份。字符串文本中的剪裁字符 `'2008-'` 表示要从左侧剪裁的字符。如果您使用剪裁字符 `'028-'`，则会获得相同的结果。
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
当 *trim\$1chars* 中的任意字符出现在 *string* 的开头时，LTRIM 都会予以删除。以下示例从 VENUENAME（VARCHAR 列）的开头剪裁字符“C”、“D”和“G”。
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
以下示例使用从 `venueid` 列中检索到的剪裁字符 `2`。
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
以下示例不剪裁任何字符，因为在 `'0'` 剪裁字符之前找到了 `2`。
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
以下示例使用默认的空格剪裁字符，从字符串的开头剪裁掉两个空格。
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# POSITION 函数
返回指定子字符串在字符串中的位置。
## 语法
```
POSITION(substring IN string )
```
## 参数
*substring*
要在 *string* 中搜索的子字符串。
*string*
要搜索的字符串或列。
## 返回类型
POSITION 函数返回与子字符串的位置对应的整数（从 1 开始，而不是从 0 开始）。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。
## 使用说明
如果在字符串中未找到子字符串，POSITION 将返回 0：
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## 示例
以下示例显示字符串 `fish` 在单词 `dogfish` 中的位置：
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
以下示例返回 SALES 表中 COMMISSION 超过 999.00 的销售交易的数量：
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# REGEXP\$1COUNT 函数
在字符串中搜索正则表达式模式并返回指示该模式在字符串中出现的次数的整数。如果未找到匹配项，此函数将返回 0。
## 语法
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式（如列名称）。
*pattern*
表示正则表达式模式的字符串文本。
*position*
指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 1。如果 *position* 小于 1，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中字符的数量，则结果为 0。
* 参数*
一个或多个字符串，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。
## 返回类型
整数
## 示例
以下示例计算三个字母序列出现的次数。
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
以下示例计算顶级域名为 `org` 或 `edu` 的次数。
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
下面的示例计算字符串 `FOX` 的出现次数，使用不区分大小写的匹配。
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例使用区分大小写的匹配计算此类单词的出现次数。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的含义。此示例计算此类单词的出现次数，但与前面的示例不同，因为它使用了不区分大小写的匹配。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# REGEXP\$1INSTR 函数
在字符串中搜索正则表达式模式并返回指示匹配子字符串的开始位置的整数。如果未找到匹配项，此函数将返回 0。REGEXP\$1INSTR 与 [ 函数相似，只不过前者可让您在字符串中搜索正则表达式模式。](POSITION.md)
## 语法
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式（如列名称）。
*pattern*
表示正则表达式模式的字符串文本。
*position*
指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 1。如果 *position* 小于 1，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中字符的数量，则结果为 0。
*出现*
一个正整数，指示要使用的模式的匹配项。REGEXP\$1INSTR 会跳过第一个 *occurrence* -1 匹配项。默认值为 1。如果 *occurrence* 小于 1 或大于 *source\$1string* 中的字符串，则会忽略搜索，并且结果为 0。
*option*
一个值，指示是否返回匹配项的第一个字符的位置 (`0`) ，或匹配项结尾后第一个字符的位置 (`1`)。非零值与 1 相同。默认值是 0。
* 参数*
一个或多个字符串，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ e – 使用子表达式提取子字符串。
如果 *pattern* 包含一个子表达式，REGEXP\$1INSTR 会使用 *pattern* 中的第一个子表达式来匹配子字符串。REGEXP\$1INSTR 仅考虑第一个子表达式；其他子表达式会被忽略。如果模式没有子表达式，REGEXP\$1INSTR 会忽略“e”参数。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。
## 返回类型
整数
## 示例
以下示例搜索作为域名的开头的 `@` 字符并返回第一个匹配项的开始位置。
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
以下示例搜索单词 `Center` 的变体并返回第一个匹配项的开始位置。
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
以下示例使用不区分大小写的匹配逻辑找到字符串 `FOX` 第一次出现的起始位置。
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例查找第二个此类单词的起始位置。
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。本示例查找第二个此类单词的起始位置，但与前面的示例不同，因为它使用了不区分大小写的匹配。
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# REGEXP\$1REPLACE 函数
在字符串中搜索正则表达式模式并将该模式的每个匹配项替换为指定字符串。REGEXP\$1REPLACE 与 [REPLACE 函数](REPLACE.md)相似，只不过前者可让您在字符串中搜索正则表达式模式。
REGEXP\$1REPLACE 与 [TRANSLATE 函数](TRANSLATE.md)和 [REPLACE 函数](REPLACE.md)相似，只不过 TRANSLATE 进行多次单字符替换，REPLACE 一次性将整个字符串替换为其他字符串，而 REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式。
## 语法
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式（如列名称）。
*pattern*
表示正则表达式模式的字符串文本。
*replace\$1string*
将替换模式的每个匹配项的字符串表达式（如列名称）。默认值是空字符串 ("")。
*position*
指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 1。如果 *position* 小于 1，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中的字符数量，则结果为 *source\$1string*。
* 参数*
一个或多个字符串，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。
## 返回类型
VARCHAR
如果 *pattern* 或 *replace\$1string* 为 NULL，则返回 NULL。
## 示例
以下示例删除电子邮件地址中的 `@` 和域名。
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
以下示例将使用此值替换电子邮件地址的域名：`internal.company.com`。
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
下面的示例使用不区分大小写的匹配替换值 `quick brown fox` 内的字符串 `FOX` 的所有出现次数。
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例将此单词的每次出现替换为值 `[hidden]`。
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例将此单词的每次出现替换为值 `[hidden]`，但与前面的示例不同，它使用不区分大小写的匹配。
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# REGEXP\$1SUBSTR 函数
通过在字符串中搜索正则表达式模式，返回字符串中的字符。REGEXP\$1SUBSTR 与 [SUBSTRING 函数](SUBSTRING.md) 函数相似，只不过前者可让您在字符串中搜索正则表达式模式。如果函数无法将正则表达式与字符串中的任何字符匹配，则返回一个空字符串。
## 语法
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式。
*pattern*
表示正则表达式模式的字符串文本。
*position*
指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 1。如果 *position* 小于 1，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中的字符数量，则结果为空字符串 ("")。
*出现*
一个正整数，指示要使用的模式的匹配项。REGEXP\$1SUBSTR 会跳过第一个 *occurrence* -1 匹配项。默认值为 1。如果 *occurrence* 小于 1 或大于 *source\$1string* 中的字符串，则会忽略搜索，并且结果为 NULL。
* 参数*
一个或多个字符串，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ e – 使用子表达式提取子字符串。
如果 *pattern* 包含一个子表达式，REGEXP\$1SUBSTR 会使用 *pattern* 中的第一个子表达式来匹配子字符串。子表达式是模式中用括号括起的表达式。例如，模式 `'This is a (\\w+)'` 将第一个表达式与字符串 `'This is a '` 后接一个字词进行匹配。此时不返回*模式*，带 `e` 参数的 REGEXP\$1SUBSTR 仅返回子表达式内的字符串。
REGEXP\$1SUBSTR 仅考虑第一个子表达式；其他子表达式会被忽略。如果模式没有子表达式，REGEXP\$1SUBSTR 会忽略“e”参数。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。
## 返回类型
VARCHAR
## 示例
以下示例返回电子邮件地址中 @ 字符和域扩展名之间的部分。
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
以下示例使用不区分大小写的匹配返回与字符串 `FOX` 的第一次出现相对应的输入部分。
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
以下示例返回以小写字母开头的输入的第一部分。这在功能上与不带 `c` 参数的同一 SELECT 语句相同。
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例返回与第二个此类单词相对应的输入部分。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
以下示例使用用 PCRE 方言编写的模式来定位至少包含一个数字和一个小写字母的单词。它使用 `?=` 运算符，它在 PCRE 中具有特定的前瞻含义。此示例返回与第二个此类单词相对应的输入部分，但与前面的示例不同，因为它使用了不区分大小写的匹配。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
以下示例使用子表达式，通过不区分大小写的匹配来查找与模式 `'this is a (\\w+)'` 匹配的第二个字符串。它返回括号内的子表达式。
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# REPEAT 函数
将字符串重复指定的次数。如果输入参数为数字，REPEAT 会将其视为字符串。
## 语法
```
REPEAT(string, integer)
```
## 参数
*string*
第一个输入参数是要重复的字符串。
*integer*
第二个参数是指示字符串重复次数的整数。
## 返回类型
REPEAT 函数返回字符串。
## 示例
以下示例将重复 CATEGORY 表中 CATID 列的值三次：
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# REPLACE 函数
将现有字符串中一组字符的所有匹配项替换为其他指定字符。
REPLACE 与 [TRANSLATE 函数](TRANSLATE.md)和 [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)相似，只不过 TRANSLATE 进行多次单字符替换，REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式，而 REPLACE 一次性将整个字符串替换为其他字符串。
## 语法
```
REPLACE(string1, old_chars, new_chars)
```
## 参数
*string*
要搜索的 CHAR 或 VARCHAR 字符串
*old\$1chars*
要替换的 CHAR 或 VARCHAR 字符串。
*new\$1chars*
用于替换 *old\$1string* 的新 CHAR 或 VARCHAR 字符串。
## 返回类型
VARCHAR
如果 *old\$1chars* 或 *new\$1chars* 为 NULL，则将返回 NULL。
## 示例
以下示例将 CATGROUP 字段中的字符串 `Shows` 转换为 `Theatre`：
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# REVERSE 函数
REVERSE 函数对字符串运行并以反向顺序返回字符。例如，`reverse('abcde')` 将返回 `edcba`。此函数适用于数字和日期数据类型以及字符数据类型；但在大多数情况下，它对于字符串具有实用价值。
## 语法
```
REVERSE ( expression )
```
## 参数
*expression*
一个表达式，带有表示字符反转目标的字符、日期、时间戳或数字数据类型。所有表达式均可隐式转换为可变长度的字符串。将忽略定宽字符串中的尾随空格。
## 返回类型
REVERSE 返回 VARCHAR。
## 示例
从 USERS 表中选择 5 个不同的城市名称及其对应的反转名称：
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
选择五笔销售额 IDs 及其相应的反向 IDs 转换作为字符串：
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# RTRIM 函数
RTRIM 函数从字符串的末尾剪裁指定的一组字符。删除只包含剪裁字符列表中的字符的最长字符串。当修剪字符未出现在输入字符串中时，修剪即告完成。
## 语法
```
RTRIM( string, trim_chars )
```
## 参数
*string*
要剪裁的字符串列、表达式或字符串文本。
*trim\$1chars*
表示要从 *string* 的结尾剪裁的字符的字符串列、表达式或字符串文本。如果未指定，则使用空格作为剪裁字符。
## 返回类型
与 *string* 参数具有相同的数据类型的字符串。
## 示例
以下示例从字符串 `' abc '` 中剪裁前导和尾随空格：
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
以下示例从字符串 `'xyzaxyzbxyzcxyz'` 中删除尾随字符串 `'xyz'`。将删除尾随的 `'xyz'`，但不会删除字符串内部的匹配字符。
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
以下示例从字符串 `'setuphistorycassettes'` 中删除与 *trim\$1chars* 列表 `'tes'` 中的任何字符相匹配的结尾部分。在输入字符串结尾部分，在 *trim\$1chars* 列表中未包含的其他字符之前出现的任何 `t`、`e` 或 `s` 都将被删除。
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
以下示例从 VENUENAME 的末尾剪裁字符“Park”（如果有）：
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
请注意，当字符 `P`、`a`、`r` 或 `k` 中的任意一个出现在 VENUENAME 的末尾时，RTRIM 都会予以删除。
# 分割功能
SPLIT 函数允许您从较大的字符串中提取子字符串并将其作为数组处理。当您需要根据特定的分隔符或模式将字符串分解为单个组件时，SPLIT 函数非常有用。
## 语法
```
split(str, regex, limit)
```
## Arguments
*str*
要拆分的字符串表达式。
*regex*
表示正则表达式的字符串。*正则表达式*字符串应为 Java 正则表达式。
*limit*
一个整数表达式，用于控制应用*正则表达*式的次数。
+ limit > 0：结果数组的长度不会超过限制，并且结果数组的最后一个条目将包含最后一个匹配的*正则表达式*之外的所有输入。
+ limit <= 0：将尽可能多地应用正则*表达式*，并且生成的数组可以是任何大小。
## 返回类型
SPLIT 函数返回一个数组。
If`limit > 0`：结果数组的长度不会超过限制，并且结果数组的最后一个条目将包含最后一个匹配的正则表达式之外的所有输入。
If`limit <= 0`: regex 将尽可能多地被应用，并且生成的数组可以是任何大小。
## 示例
在此示例中，SPLIT 函数会在遇到字符`'A'``'B'`、或`'C'`（由正则表达式模式指定`'[ABC]'`）`'oneAtwoBthreeC'`的任何地方拆分输入字符串。结果输出是一个由四个元素组成的数组：`"one"`、`"two"``"three"`、和一个空字符串`""`。
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# SPLIT\$1PART 函数
用指定的分隔符拆分字符串，并返回指定位置的部分内容。
## 语法
```
SPLIT_PART(string, delimiter, position)
```
## 参数
*string*
要拆分的字符串列、表达式或字符串文本。字符串可以是 CHAR 或 VARCHAR。
*分隔符*
分隔符字符串指示输入 *string* 的部分。
如果 *delimiter* 是文本，则将其括在单引号中。
*position*
要返回的 *string* 部分的位置（从 1 算起）。必须是大于 0 的整数。如果 *position* 大于字符串部分的数量，SPLIT\$1PART 将返回空字符串。如果在*字符串*中未找到*分隔符*，则返回的值包含指定部分的内容，它可能是整个*字符串*或一个空值。
## 返回类型
CHAR 或 VARCHAR 字符串，与 *string* 参数相同。
## 示例
以下示例使用 `$` 分隔符，将字符串文本拆分为多个部分，并返回第二部分。
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
以下示例使用 `$` 分隔符，将字符串文本拆分为多个部分。它返回一个空字符串，因为找不到部分 `4`。
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
以下示例使用 `#` 分隔符，将字符串文本拆分为多个部分。它返回整个字符串，也就是第一部分，因为找不到分隔符。
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
以下示例将时间戳字段 LISTTIME 拆分为年、月和日组成部分。
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
以下示例选择 LISTTIME 时间戳字段并在 `'-'` 字符处拆分它以获取月（LISTTIME 字符串的第二部分），然后计算每个月的条目数：
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# SUBSTRING 函数
按指定的开始位置返回子字符串子集。
如果输入的是字符串，字符的开始位置和数量基于字符数而不是字节数，这是为了将多字节字符作为单个字符计数。如果输入的是二进制表达式，则开始位置和提取的子字符串基于字节。您无法指定负长度，但可指定负开始位置。
## 语法
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## 参数
*字符串*
要搜索的字符串。非字符数据类型将视为字符串。
*start\$1position*
字符串中开始提取的位置，从 1 开始。*start\$1position* 基于字符数而不是字节数，这是为了将多字节字符作为单个字符计数。此数字可以为负。
*数字字符*
要提取的字符的数量（子字符串的长度）。nu *mbecharacters* 基于字符数，而不是字节数，因此多字节字符计为单个字符。此数字不能为负。
*start\$1byte*
二进制表达式中开始提取的位置，从 1 开始。此数字可以为负。
*数字字节*
要提取的字节的数量（子字符串的长度）。此数字不能为负。
## 返回类型
VARCHAR
## 字符串的使用说明
以下示例返回以第 6 个字符开头的 4 字符字符串。
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*如果 *start\$1position \$1 num *becharacters* 超过*字符串*的长度，则 SUBSTRING 会返回一个从起始位置*开始直到字符串结尾的子字符串。*例如：
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
如果 `start_position` 为负或 0，SUBSTRING 函数将返回从长度为 `start_position` \$1 `numbecharacters` -1 的字符串的第一个字符开始的子字符串。例如：
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
如果 `start_position` \$1 `numbecharacters` -1 小于或等于零，SUBSTRING 将返回空字符串。例如：
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## 示例
以下示例返回 LISTING 表的 LISTTIME 字符串中的月份：
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
以下示例与上述示例相同，但使用 FROM...FOR 选项：
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
您无法使用 SUBSTRING 以可预测的方式提取可能包含多字节字符的字符串的前缀，因为您需要根据字节数（而不是字符数）指定多字节字符串的长度。要基于以字节为单位的长度提取字符串的开始部分，您可将字符串强制转换为 VARCHAR(*byte\$1length*) 以截断字符串，其中 *byte\$1length* 是必需长度。以下示例提取字符串 `'Fourscore and seven'` 的前 5 个字节。
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
以下示例返回出现在输入字符串 `Silva, Ana` 中最后一个空格之后的名字 `Ana`。
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# TRANSLATE 函数
对于给定表达式，将指定字符的所有匹配项替换为指定替代项。现有字符将按其在 *characters\$1to\$1replace* 和 *characters\$1to\$1substitute* 参数中的位置映射到替换字符。如果在 *characters\$1to\$1replace* 参数中指定的字符多于在 *characters\$1to\$1substitute* 参数中指定的字符，返回值中将省略 *characters\$1to\$1replace* 参数中的额外字符。
TRANSLATE 与 [REPLACE 函数](REPLACE.md)和 [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)相似，只不过 REPLACE 将整个字符串替换为其他字符串，REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式，而 TRANSLATE 进行多次单字符替换。
如果任何参数为空，则返回 NULL。
## 语法
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## 参数
*expression*
要转换的表达式。
*characters\$1to\$1replace*
一个包含要替换的字符的字符串。
*characters\$1to\$1substitute*
一个字符串，其中包含要替换其他字符的字符。
## 返回类型
VARCHAR
## 示例
以下示例将替换字符串中的多个字符：
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
以下示例将列中的所有值的 at (@) 符号替换为句点：
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
以下示例将空格替换为下划线并去掉列中的所有值的句点：
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# TRIM 函数
通过删除前导空格和尾随空格或删除与可选的指定字符串匹配的前导字符和尾随字符来剪裁字符串。
## 语法
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## 参数
*trim\$1chars*
（可选）要从字符串剪裁的字符数。如果忽略此参数，则剪裁空白区域。
*string*
要剪裁的字符串。
## 返回类型
TRIM 函数返回 VARCHAR 或 CHAR 字符串。如果您将 TRIM 函数与 SQL 命令一起使用，则会将结果 AWS Clean Rooms 隐式转换为 VARCHAR。如果您将 SELECT 列表中的 TRIM 函数用于 SQL 函数，则 AWS Clean Rooms 不会隐式转换结果，并且可能需要执行显式转换以避免出现数据类型不匹配错误。有关显式转换的信息，请参阅[CAST 函数](CAST_function.md)函数。
## 示例
以下示例从字符串 `' abc '` 中剪裁前导和尾随空格：
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
以下示例将删除将字符串 `"dog"` 括起的双引号：
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
当 *trim\$1chars* 中的任意字符出现在 *string* 的开头时，TRIM 都会予以删除。以下示例从 VENUENAME（VARCHAR 列）的开头剪裁字符“C”、“D”和“G”。
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# UPPER 函数
将字符串转换为大写。UPPER 支持 UTF-8 多字节字符，并且每个字符最多可以有 4 个字节。
## 语法
```
UPPER(string)
```
## 参数
*string*
输入参数是 VARCHAR 字符串（或任何其他可隐式转换为 VARCHAR 的数据类型，如 CHAR）。
## 返回类型
UPPER 函数返回与输入字符串具有相同数据类型的字符串。
## 示例
以下示例将 CATNAME 字段转换为大写：
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# UUID 函数
UUID 函数生成通用唯一标识符 (UUID)。
UUIDs 是全球唯一标识符，通常用于为各种目的提供唯一标识符，例如：
+ 识别数据库记录或其他数据实体。
+ 为文件、目录或其他资源生成唯一的名称或密钥。
+ 跨分布式系统跟踪和关联数据。
+ 为网络数据包、软件组件或其他数字资产提供唯一标识符。
UUID 函数生成的 UUID 值是唯一的，而且概率非常高，即使在分布式系统中和长时间内也是如此。 UUIDs 通常使用当前时间戳、计算机的网络地址以及其他随机或伪随机数据的组合生成，从而确保生成的每个 UUID 极不可能与任何其他 UUID 发生冲突。
在 SQL 查询的上下文中，UUID 函数可用于为插入到数据库中的新记录生成唯一标识符，或者为数据分区、索引或其他需要唯一标识符的目的提供唯一密钥。
**注意**
UUID 函数是不确定的。
## 语法
```
uuid()
```
## Arguments
UUID 函数不带任何参数。
## 返回类型
UUID 返回通用唯一标识符 (UUID) 字符串。该值以规范 UUID 的 36 个字符的字符串形式返回。
## 示例
以下示例生成通用唯一标识符 (UUID)。输出是一个 36 个字符的字符串，表示通用唯一标识符。
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```