从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 Python UDF 将继续正常运行至 2026 年 6 月 30 日。有关更多信息，请参阅[博客文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
# 字符串函数
**Topics**
+ [\$1\$1（串联）运算符](r_concat_op.md)
+ [ASCII 函数](r_ASCII.md)
+ [BPCHARCMP 函数](r_BPCHARCMP.md)
+ [BTRIM 函数](r_BTRIM.md)
+ [BTTEXT\$1PATTERN\$1CMP 函数](r_BTTEXT_PATTERN_CMP.md)
+ [CHAR\$1LENGTH 函数](r_CHAR_LENGTH.md)
+ [CHARACTER\$1LENGTH 函数](r_CHARACTER_LENGTH.md)
+ [CHARINDEX 函数](r_CHARINDEX.md)
+ [CHR 函数](r_CHR.md)
+ [COLLATE 函数](r_COLLATE.md)
+ [CONCAT 函数](r_CONCAT.md)
+ [CRC32 函数](crc32-function.md)
+ [DIFFERENCE 函数](DIFFERENCE.md)
+ [INITCAP 函数](r_INITCAP.md)
+ [LEFT 和 RIGHT 函数](r_LEFT.md)
+ [LEN 函数](r_LEN.md)
+ [LENGTH 函数](r_LENGTH.md)
+ [LOWER 函数](r_LOWER.md)
+ [LPAD 和 RPAD 函数](r_LPAD.md)
+ [LTRIM 函数](r_LTRIM.md)
+ [OCTETINDEX 函数](OCTETINDEX.md)
+ [OCTET\$1LENGTH 函数](r_OCTET_LENGTH.md)
+ [POSITION 函数](r_POSITION.md)
+ [QUOTE\$1IDENT 函数](r_QUOTE_IDENT.md)
+ [QUOTE\$1LITERAL 函数](r_QUOTE_LITERAL.md)
+ [REGEXP\$1COUNT 函数](REGEXP_COUNT.md)
+ [REGEXP\$1INSTR 函数](REGEXP_INSTR.md)
+ [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)
+ [REGEXP\$1SUBSTR 函数](REGEXP_SUBSTR.md)
+ [REPEAT 函数](r_REPEAT.md)
+ [REPLACE 函数](r_REPLACE.md)
+ [REPLICATE 函数](r_REPLICATE.md)
+ [REVERSE 函数](r_REVERSE.md)
+ [RTRIM 函数](r_RTRIM.md)
+ [SOUNDEX 函数](SOUNDEX.md)
+ [SPLIT\$1PART 函数](SPLIT_PART.md)
+ [STRPOS 函数](r_STRPOS.md)
+ [STRTOL 函数](r_STRTOL.md)
+ [SUBSTRING 函数](r_SUBSTRING.md)
+ [TEXTLEN 函数](r_TEXTLEN.md)
+ [TRANSLATE 函数](r_TRANSLATE.md)
+ [TRIM 函数](r_TRIM.md)
+ [UPPER 函数](r_UPPER.md)
字符串函数用于处理和操作字符串或计算结果为字符串的表达式。当这些函数中的 *string* 参数为文本值时，该参数必须括在单引号中。支持的数据类型包括 CHAR 和 VARCHAR。
以下部分提供了支持的函数的函数名称、语法和描述。对字符串的所有偏移都从 1 开始。
**弃用的仅领导节点函数**
以下字符串函数因为仅在领导节点上运行而遭到弃用。有关更多信息，请参阅[仅领导节点函数](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1（串联）运算符
联接位于 `||` 符号的任意一侧的两个表达式并返回联接后的表达式。
与 [CONCAT 函数](r_CONCAT.md)相似。
**注意**
如果一个表达式为 Null，或两个表达式都为 Null，则联接的结果为 `NULL`。
## 语法
```
expression1 || expression2
```
## 参数
*expression1*
`CHAR` 字符串、`VARCHAR` 字符串、二进制表达式或者其计算结果为这些类型之一的表达式。
*expression2*
`CHAR` 字符串、`VARCHAR` 字符串、二进制表达式或者其计算结果为这些类型之一的表达式。
## 返回类型
字符串的返回类型与输入参数的类型相同。例如，联接两个类型为 `VARCHAR` 的字符串会返回一个类型为 `VARCHAR` 的字符串。
## 示例
以下示例使用 TICKIT 示例数据库中的 USERS 表和 VENUE 表。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要联接示例数据库的 USERS 表中的 FIRSTNAME 和 LASTNAME 字段，请使用以下示例。
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
要联接可能包含 null 值的列，请使用 [NVL 和 COALESCE 函数](r_NVL_function.md) 表达式。以下示例使用 NVL 以在遇到 `NULL` 时返回 `0`。
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
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 |
+-------------------------------------+
```
# ASCII 函数
ASCII 函数返回指定字符串中第一个字符的 ASCII 代码或 Unicode 代码点。如果字符串为空，该函数返回 `0`。如果字符串为 null，则返回 `NULL`。
## 语法
```
ASCII('string')
```
## 参数
*string*
`CHAR` 字符串或 `VARCHAR` 字符串。
## 返回类型
INTEGER
## 示例
要返回 `NULL`，请使用以下示例。如果两个参数相同，NULLIF 函数将返回 `NULL`，因此 ASCII 函数的输入参数为 `NULL`。有关更多信息，请参阅 [NULLIF 函数](r_NULLIF_function.md)。
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
要返回 ASCII 代码 0，请使用以下示例。
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
要返回单词 amazon 的第一个字母的 ASCII 代码 97，请使用以下示例。
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
要返回单词 Amazon 的第一个字母的 ASCII 代码 65，请使用以下示例。
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# BPCHARCMP 函数
比较两个字符串的值并返回整数。如果字符串相同，此函数返回 `0`。如果按字母顺序，第一个字符串更靠后，则函数返回 `1`。如果第二个字符串较大，则函数返回 `-1`。
对于多字节字符，该比较基于字节编码。
[BTTEXT\$1PATTERN\$1CMP 函数](r_BTTEXT_PATTERN_CMP.md)的同义词。
## 语法
```
BPCHARCMP(string1, string2)
```
## 参数
*string1*
`CHAR` 字符串或 `VARCHAR` 字符串。
*string2*
`CHAR` 字符串或 `VARCHAR` 字符串。
## 返回类型
INTEGER
## 示例
以下示例使用 TICKIT 示例数据库中的 USERS 表。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要确定 USERS 表中前十个条目的用户的名字在字母顺序上是否比其姓氏更靠后，请使用以下示例。对于 FIRSTNAME 的字符串在字母顺序上比 LASTNAME 的字符串更靠后的条目，函数返回 `1`。如果 LASTNAME 在字母顺序上比 FIRSTNAME 更靠后，此函数将返回 `-1`。
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
要返回 USERS 表中该函数返回 `0` 的所有条目，请使用以下示例。当 FIRSTNAME 与 LASTNAME 相同时，该函数返回 `0`。
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 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
```
# BTTEXT\$1PATTERN\$1CMP 函数
BPCHARCMP 函数的同义词。
有关更多信息，请参阅 [BPCHARCMP 函数](r_BPCHARCMP.md)。
# CHAR\$1LENGTH 函数
LEN 函数的同义词。
请参阅 [LEN 函数](r_LEN.md)。
# CHARACTER\$1LENGTH 函数
LEN 函数的同义词。
请参阅 [LEN 函数](r_LEN.md)。
# CHARINDEX 函数
返回指定子字符串在字符串中的位置。
有关类似的函数，请参阅[POSITION 函数](r_POSITION.md)和[STRPOS 函数](r_STRPOS.md)。
## 语法
```
CHARINDEX( substring, string )
```
## 参数
*substring*
要在 *string* 中搜索的子字符串。
*string*
要搜索的字符串或列。
## 返回类型
INTEGER
CHARINDEX 函数返回与子字符串的位置对应的 `INTEGER`（从 1 开始，而不是从 0 开始）。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。如果在字符串未找到子字符串，CHARINDEX 将返回 `0`。
## 示例
要显示字符串 `fish` 在单词 `dog` 中的位置，请使用以下示例。
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
要显示字符串 `fish` 在单词 `dogfish` 中的位置，请使用以下示例。
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
以下示例使用 TICKIT 示例数据库中的 SALES 表。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回 SALES 表中佣金超过 999.00 的不同销售交易的数量，请使用以下示例。此命令通过检查小数点距离佣金值开头是否超过 4 位数来计算大于 999.00 的佣金。
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# CHR 函数
CHR 函数返回与输入参数指定的 ASCII 码位值匹配的字符。
## 语法
```
CHR(number)
```
## 参数
*number*
输入参数是表示 ASCII 码位值的 `INTEGER`。
## 返回类型
CHAR
如果 ASCII 字符与输入值匹配，CHR 函数将返回 `CHAR` 字符串。如果输入数值没有匹配的 ASCII 字符，该函数将返回 `NULL`。
## 示例
要返回与 ASCII 码位 0 对应的字符，请使用以下示例。请注意，对于输入 `0`，CHR 函数会返回 `NULL`。
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
要返回与 ASCII 码位 65 对应的字符，请使用以下示例。
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
要返回以大写字母 A（ASCII 码位 65）开头的独特的事件名称，请使用以下示例。以下示例使用 TICKIT 示例数据库中的 EVENT 表。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# COLLATE 函数
COLLATE 函数覆盖字符串列或表达式的排序规则。
有关如何使用数据库排序规则创建表的信息，请参阅[CREATE TABLE](r_CREATE_TABLE_NEW.md)。
有关如何使用数据库排序规则创建数据库的信息，请参阅[CREATE DATABASE](r_CREATE_DATABASE.md)。
## 语法
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## 参数
*string*
要覆盖的字符串列或表达式。
*'case\$1sensitive'* \$1 *'cs'* \$1 *'case\$1insensitive'* \$1 *'ci'*
排序规则名称的字符串常量。Amazon Redshift 对此参数仅支持以下值：
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *ci*
*case\$1sensitive* 和 *cs* 可以互换，生成的结果相同。同样，*case\$1insensitive* 和 *ci* 可以互换，生成的结果相同。
## 返回类型
COLLATE 函数根据第一个输入表达式类型返回 `VARCHAR`、`CHAR` 或 `SUPER`。此函数仅更改第一个输入参数的排序规则，不会更改其输出值。
## 示例
要创建表 T 并将表 T 中的 col1 定义为 `case_sensitive`，请使用以下示例。
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
当您运行第一个查询时，Amazon Redshift 仅返回 `john`。在 col1 上运行 COLLATE 函数后，排序规则变成 `case_insensitive`。第二个查询同时返回 `john` 和 `JOHN`。
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
要创建表 A 并将表 A 中的 col1 定义为 `case_insensitive`，请使用以下示例。
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
当您运行第一个查询时，Amazon Redshift 同时返回 `john` 和 `JOHN`。在 col1 上运行 COLLATE 函数后，排序规则变成 `case_sensitive`。第二个查询仅返回 `john`。
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# CONCAT 函数
CONCAT 函数将联接两个表达式并返回生成的表达式。要联接两个以上的表达式，请使用嵌套 CONCAT 函数。在两个表达式之间使用联接运算符（`||`）将生成与 CONCAT 函数相同的结果。
## 语法
```
CONCAT ( expression1, expression2 )
```
## 参数
*expression1*、*expression2*
两个参数可以是固定长度字符串、可变长度字符串、二进制表达式或计算结果为其中一个输入的表达式。
## 返回类型
CONCAT 返回一个表达式。表达式的数据类型与输入参数的数据类型相同。
如果输入表达式的类型不同，Amazon Redshift 会尝试隐式转换其中一个表达式类型。如果值无法转换，则会返回一个错误。
## 使用说明
+ 对于 CONCAT 函数和联接运算符，如果一个或多个表达式为 null，则联接的结果也为 null。
## 示例
以下示例联接两个字符文本：
```
SELECT CONCAT('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
以下查询（使用 `||` 运算符而不是 CONCAT）将生成相同的结果：
```
SELECT 'December 25, '||'2008';
?column?
-------------------
December 25, 2008
(1 row)
```
以下示例使用一个 CONCAT 函数中的另一个嵌套 CONCAT 函数来串联三个字符串：
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
要串联可能包含 NULL 的列，请使用 [NVL 和 COALESCE 函数](r_NVL_function.md)，它会在遇到 NULL 时返回给定值。以下示例使用 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)
```
以下示例联接了两个二进制表达式。其中 `abc` 是一个二进制值（具有一个 `616263` 的十六进制表示形式），`def` 是一个二进制值（具有一个 `646566` 的十六进制表示形式）。结果会自动显示为二进制值的十六进制表示形式。
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 函数
CRC32 是一个用于错误检测的函数。此函数使用 CRC32 算法来检测源数据和目标数据之间的变化。CRC32 函数会将长度可变的字符串转换为以 32 位二进制序列的十六进制值的文本表示形式表示的 8 字符字符串。要检测源数据和目标数据之间的变化，请对源数据使用 CRC32 函数并存储输出。然后，对目标数据使用 CRC32 函数，并将该输出与来自源数据的输出进行比较。如果数据未经修改，则输出将相同；如果修改了数据，则输出将有所不同。
## 语法
```
CRC32(string)
```
## 参数
*string*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
## 返回类型
CRC32 函数返回以 32 位二进制序列的十六进制值的文本表示形式表示的 8 字符字符串。Amazon Redshift CRC32 函数基于 CRC-32C 多项式。
## 示例
显示字符串 `Amazon Redshift` 的 8 位值。
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# DIFFERENCE 函数
DIFFERENCE 函数比较两个字符串的美国 Soundex 代码。该函数返回 `INTEGER`，以指示 Soundex 代码之间匹配的字符数。
Soundex 代码是一个长度为四个字符的字符串。Soundex 代码表示单词的发音方式，而不是其拼写方式。例如，`Smith` 和 `Smyth` 具有相同的 Soundex 代码。
## 语法
```
DIFFERENCE(string1, string2)
```
## 参数
*string1*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
*string2*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
## 返回类型
INTEGER
DIFFERENCE 函数返回 0–4 之间的一个 `INTEGER` 值，该值计算两个字符串的美国 Soundex 代码中匹配字符的数量。Soundex 代码具有 4 个字符，因此，当字符串的所有 4 个字符的美国 Soundex 代码值都相同时，DIFFERENCE 函数返回 `4`。如果两个字符串中有一个为空，则 DIFFERENCE 返回 `0`。如果两个字符串都不包含有效字符，则此函数返回 `1`。DIFFERENCE 函数仅转换英文字母小写或大写 ASCII 字符，包括 a–z 和 A–Z。DIFFERENCE 将忽略其他字符。
## 示例
要比较字符串 `%` 和 `@` 的 Soundex 值，请使用以下示例。因为这两个字符串都不包含有效字符，所以此函数返回 `1`。
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
要比较 `Amazon` 和一个空字符串的 Soundex 值，请使用以下示例。因为两个字符串中有一个是空的，所以该函数返回 `0`。
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
要比较字符串 `Amazon` 和 `Ama` 的 Soundex 值，请使用以下示例。因为字符串的 Soundex 值中有 2 个字符是相同的，所以该函数返回 `2`。
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
要比较字符串 `Amazon` 和 `+-*/%Amazon` 的 Soundex 值，请使用以下示例。因为字符串的 Soundex 值中所有 4 个字符都是相同的，所以该函数返回 `4`。请注意，该函数会忽略第二个字符串中的无效字符 `+-*/%`。
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
要比较字符串 `AC/DC` 和 `Ay See Dee See` 的 Soundex 值，请使用以下示例。因为字符串的 Soundex 值中所有 4 个字符都是相同的，所以该函数返回 `4`。
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# INITCAP 函数
将指定字符串中的每个单词的第一个字母大写。INITCAP 支持 UTF-8 多字节字符，并且每个字符最多可以有 4 个字节。
## 语法
```
INITCAP(string)
```
## 参数
*string*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
## 返回类型
VARCHAR
## 使用说明
INITCAP 函数会将字符串中的每个单词的第一个字母大写，并将所有后续字母小写。因此，务必了解哪些字符（空格字符除外）充当分隔符。*文字分隔符* 字符是任何非字母数字字符，包括标点符号、普通符号和控制字符。所有以下字符都是文字分隔符：
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
制表符、换行符、换页符和回车也是文字分隔符。
## 示例
以下示例使用 TICKIT 示例数据库的 CATEGORY 表和 USERS 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要使 CATDESC 列中每个单词的首字母大写，请使用以下示例。
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
要显示在大写字符不作为单词的首字母时 INITCAP 函数不保留这些字符，请使用以下示例。例如，字符串 `MLB` 变成 `Mlb`。
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
要显示除空格以外的非字母数字字符用作单词分隔符，请使用以下示例。每个字符串中的几个字母将为大写。
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# LEFT 和 RIGHT 函数
这些函数返回指定数量的位于字符串最左侧或最右侧的字符。
该数量基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。
## 语法
```
LEFT( string, integer )
RIGHT( string, integer )
```
## 参数
*string*
`CHAR` 字符串、`VARCHAR` 字符串或任何计算为 `CHAR` 或 `VARCHAR` 字符串的表达式。
*integer*
一个正整数。
## 返回类型
VARCHAR
## 示例
以下示例使用 TICKIT 示例数据库的 EVENT 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回事件 ID 在 1000 和 1005 之间的事件名称中最左侧的 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 |
+---------+----------------+--------+---------+
```
# LEN 函数
以字符数形式返回指定字符串的长度。
## 语法
LEN 是 [LENGTH 函数](r_LENGTH.md)、[CHAR\$1LENGTH 函数](r_CHAR_LENGTH.md)、[CHARACTER\$1LENGTH 函数](r_CHARACTER_LENGTH.md)和 [TEXTLEN 函数](r_TEXTLEN.md)的同义词。
```
LEN(expression)
```
## 参数
*expression*
`CHAR` 字符串、`VARCHAR` 字符串、`VARBYTE` 表达式或隐式计算为 `CHAR`、`VARCHAR` 或 `VARBYTE` 类型的表达式。
## 返回类型
INTEGER
LEN 函数返回一个整数，表示输入字符串中的字符的数量。
如果输入的是字符串，LEN 函数将返回多字节字符串中的字符的实际数量，而不是字节的数量。例如，存储 3 个 4 字节中文字符需要 `VARCHAR(12)` 列。LEN 函数将对同一字符串返回 `3`。要获取字符串长度（以字节为单位），请使用 [OCTET\$1LENGTH](r_OCTET_LENGTH.md) 函数。
## 使用说明
如果 *expression* 为 `CHAR` 字符串，则不计算尾随空格。
如果 *expression* 为 `VARCHAR` 字符串，则计算尾随空格。
## 示例
要返回字符串 `français` 中的字节数和字符数，请使用以下示例。
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
要在不使用 OCTET\$1LENGTH 函数的情况下返回字符串 `français` 中的字节数和字符数，请使用以下示例。有关更多信息，请参阅[CAST 函数](r_CAST_function.md)。
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
要返回字符串 `cat`（没有尾随空格）、`cat `（有三个尾随空格）、`cat `（有三个尾随空格，强制转换为长度为 6 的 `CHAR`）以及 `cat `（有三个尾随空格，强制转换为长度为 6 的 `VARCHAR`）中的字符数，请使用以下示例。请注意，该函数不计算 `CHAR` 字符串的尾随空格，但的确计算 `VARCHAR` 字符串的尾随空格。
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
以下示例使用 TICKIT 示例数据库的 VENUE 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回 VENUE 表中最长的 10 个场地名称，请使用以下示例。
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# LENGTH 函数
LEN 函数的同义词。
请参阅 [LEN 函数](r_LEN.md)。
# LOWER 函数
将字符串转换为小写。LOWER 支持 UTF-8 多字节字符，并且每个字符最多可以有 4 个字节。
## 语法
```
LOWER(string)
```
## 参数
*string*
`VARCHAR` 字符串或任何计算结果为 `VARCHAR` 类型的表达式。
## 返回类型
字符串
LOWER 函数返回与输入字符串具有相同数据类型的字符串。例如，如果输入是 `CHAR` 字符串，该函数将返回 `CHAR` 字符串。
## 示例
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要将 CATNAME 列中的 `VARCHAR` 字符串转换为小写，请使用以下示例。
```
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 |
+-----------+-----------+
```
# LPAD 和 RPAD 函数
这些函数根据指定长度在字符串前面或后面追加字符。
## 语法
```
LPAD(string1, length, [ string2 ])
```
```
RPAD(string1, length, [ string2 ])
```
## 参数
*string1*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
*length*
一个用于定义函数结果的长度的整数。字符串的长度基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。如果 *string1* 的长度超过指定长度，它将被截断（在右侧）。如果 *length* 为零或负数，则函数的结果将为空字符串。
*string2*
（可选）追加到 *string1* 前面或后面的一个或多个字符。如果未指定此参数，则使用空格。
## 返回类型
VARCHAR
## 示例
以下示例使用 TICKIT 示例数据库的 EVENT 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要将指定的一组事件名称截断到 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 |
+-----------------------+
```
要将相同的一组事件名称截断到 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 |
+----------------------+
```
# 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
```
# OCTETINDEX 函数
OCTETINDEX 函数以字节数形式返回子字符串在字符串中的位置。
## 语法
```
OCTETINDEX(substring, string)
```
## 参数
*substring*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
*字符串*
`CHAR` 字符串、`VARCHAR` 字符串或隐式计算为 `CHAR` 或 `VARCHAR` 类型的表达式。
## 返回类型
INTEGER
OCTETINDEX 函数以字节数的形式返回一个 `INTEGER` 值，该值与 *substring* 在 *string* 中的位置相对应，其中 *string* 中的第一个字符被计数为 1。如果 *string* 不包含多字节字符，则结果等于 CHARINDEX 函数的结果。如果 *string* 不包含 *substring*，则该函数返回 `0`。如果 *substring* 为空，该函数返回 `1`。
## 示例
要返回字符串 `Amazon Redshift` 中子字符串 `q` 的位置，请使用以下示例。因为 *substring* 不在 *string* 中，所以此示例返回 `0`。
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
要返回空子字符串在字符串 `Amazon Redshift` 中的位置，请使用以下示例。因为 *substring* 为空，所以此示例返回 `1`。
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
要返回字符串 `Amazon Redshift` 中子字符串 `Redshift` 的位置，请使用以下示例。因为 *substring* 从 *string* 的第八个字节开始，所以此示例返回 `8`。
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
要返回字符串 `Amazon Redshift` 中子字符串 `Redshift` 的位置，请使用以下示例。因为 *string* 的前六个字符是双字节字符，所以此示例返回 `21`。
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# OCTET\$1LENGTH 函数
以字节数形式返回指定字符串的长度。
## 语法
```
OCTET_LENGTH(expression)
```
## 参数
*expression*
`CHAR` 字符串、`VARCHAR` 字符串、`VARBYTE` 表达式或隐式计算为 `CHAR`、`VARCHAR` 或 `VARBYTE` 类型的表达式。
## 返回类型
INTEGER
OCTET\$1LENGTH 函数返回一个整数，表示输入字符串中的字节数。
如果输入的是字符串，[LEN](r_LEN.md) 函数将返回多字节字符串中字符的实际数量，而不是字节的数量。例如，存储 3 个 4 字节中文字符需要 `VARCHAR(12)` 列。OCTET\$1LENGTH 函数对于该字符串将返回 `12`，而 LEN 函数将对于该同一个字符串将返回 `3`。
## 使用说明
如果 *expression* 是 `CHAR` 字符串，则此函数返回 `CHAR` 字符串的长度。例如，`CHAR(6)` 输入的输出为 `CHAR(6)`。
如果 *expression* 为 `VARCHAR` 字符串，则计算尾随空格。
## 示例
当带有三个尾随空格的字符串 `francais` 强制转换为 `CHAR` 和 `VARCHAR` 类型时，要返回字节数，请使用以下示例。有关更多信息，请参阅[CAST 函数](r_CAST_function.md)。
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
要返回字符串 `français` 中的字节数和字符数，请使用以下示例。
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
要在字符串 `français` 强制转换为 `VARBYTE` 时返回字节数，请使用以下示例。
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# POSITION 函数
返回指定子字符串在字符串中的位置。
有关类似的函数，请参阅[CHARINDEX 函数](r_CHARINDEX.md)和[STRPOS 函数](r_STRPOS.md)。
## 语法
```
POSITION(substring IN string )
```
## 参数
*substring*
要在 *string* 中搜索的子字符串。
*string*
要搜索的字符串或列。
## 返回类型
POSITION 函数返回与子字符串的位置对应的 `INTEGER`（从 1 开始，而不是从 0 开始）。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。如果在字符串中未找到子字符串，POSITION 将返回 `0`。
## 示例
要显示字符串 `fish` 在单词 `dog` 中的位置，请使用以下示例。
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
要显示字符串 `fish` 在单词 `dogfish` 中的位置，请使用以下示例。
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
以下示例使用 TICKIT 示例数据库中的 SALES 表。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回 SALES 表中佣金超过 999.00 的不同销售交易的数量，请使用以下示例。此命令通过检查小数点距离佣金值开头是否超过 4 位数来计算大于 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 |
+-----------+-------+
```
# QUOTE\$1IDENT 函数
QUOTE\$1IDENT 函数将指定的字符串作为一个带前导双引号和尾随双引号的字符串返回。此函数输出可用作 SQL 语句中的标识符。此函数适当地在任何嵌入式双引号之外再加上一对双引号。
QUOTE\$1IDENT 仅在需要时（当字符串包含非标识符字符或会转换为小写时）添加双引号，从而创建有效的标识符。要始终返回一个单引号字符串，请使用 [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md)。
## 语法
```
QUOTE_IDENT(string)
```
## 参数
*string*
`CHAR` 或 `VARCHAR` 字符串。
## 返回类型
QUOTE\$1IDENT 函数返回与输入 *string* 相同类型的字符串。
## 示例
要返回带双引号的字符串 `"CAT"`，请使用以下示例。
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回用引号括起的 CATNAME 列，请使用以下示例。
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# QUOTE\$1LITERAL 函数
QUOTE\$1LITERAL 函数以单引号字符串的形式返回指定字符串，以便此字符串可用作 SQL 语句中的字符串文本。如果输入参数为数字，则 QUOTE\$1LITERAL 会将其视为字符串。请适当地在任何嵌入式单引号和反斜杠之外再加上一对双引号。
## 语法
```
QUOTE_LITERAL(string)
```
## 参数
*string*
`CHAR` 或 `VARCHAR` 字符串。
## 返回类型
QUOTE\$1LITERAL 函数返回与输入 *string* 相同数据类型的 `CHAR` 或 `VARCHAR` 字符串。
## 示例
要返回带单引号的字符串 `''CAT''`，请使用以下示例。
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回用单引号括起的 CATNAME 列，请使用以下示例。
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
要返回用单引号括起的 CATID 列，请使用以下示例。
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# REGEXP\$1COUNT 函数
在字符串中搜索正则表达式模式，并返回指示指定模式在字符串中出现的次数的整数。如果未找到匹配项，此函数将返回 `0`。有关正则表达式的更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)和 Wikipedia 中的 [Regular expression](https://en.wikipedia.org/wiki/Regular_expression)。
## 语法
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## 参数
*source\$1string*
`CHAR` 或 `VARCHAR` 字符串。
* 模式*
表示正则表达式模式的 UTF-8 字符串文本。有关更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)。
*position*
（可选）指示在 *source\$1string* 中开始搜索的位置的正 `INTEGER`。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 `1`。如果 *position* 小于 `1`，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中字符的数量，则结果为 `0`。
*参数*
（可选）一个或多个字符串文本，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。有关 PCRE 的更多信息，请参阅 Wikipedia 中的 [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 返回类型
INTEGER
## 示例
要计算三个字母序列出现的次数，请使用以下示例。
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
要使用不区分大小写的匹配计算字符串 `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 |
+--------------+
```
以下示例使用 TICKIT 示例数据库的 USERS 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要计算顶级域名为 `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 |
+-----------------------------------------------+--------------+
```
# REGEXP\$1INSTR 函数
在字符串中搜索正则表达式模式并返回指示匹配子字符串的开始位置的整数。如果未找到匹配项，此函数将返回 `0`。REGEXP\$1INSTR 与 [ 函数相似，只不过前者可让您在字符串中搜索正则表达式模式。](r_POSITION.md)有关正则表达式的更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)和 Wikipedia 中的 [Regular expression](https://en.wikipedia.org/wiki/Regular_expression)。
## 语法
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式（如列名称）。
*pattern*
表示正则表达式模式的 UTF-8 字符串文本。有关更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)。
*position*
（可选）指示在 *source\$1string* 中开始搜索的位置的正 `INTEGER`。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 `1`。如果 *position* 小于 `1`，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中字符的数量，则结果为 `0`。
*出现*
（可选）一个正 `INTEGER`，指示要使用的模式的哪一次出现。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) 方言解释模式。有关 PCRE 的更多信息，请参阅 Wikipedia 中的 [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 返回类型
整数
## 示例
以下示例使用 TICKIT 示例数据库的 USERS 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要搜索作为域名开头的 `@` 字符并返回第一个匹配项的开始位置，请使用以下示例。
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 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 函数](r_REPLACE.md)相似，只不过前者可让您在字符串中搜索正则表达式模式。有关正则表达式的更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)和 Wikipedia 中的 [Regular expression](https://en.wikipedia.org/wiki/Regular_expression)。
REGEXP\$1REPLACE 与 [TRANSLATE 函数](r_TRANSLATE.md)和 [REPLACE 函数](r_REPLACE.md)相似，只不过 TRANSLATE 进行多次单字符替换，REPLACE 一次性将整个字符串替换为其他字符串，而 REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式。
## 语法
```
REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 参数
*source\$1string*
要搜索的 `CHAR` 或 `VARCHAR` 字符串表达式（如列名称）。
* 模式*
表示正则表达式模式的 UTF-8 字符串文本。有关更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)。
*replace\$1string*
（可选）将替换模式的每次出现的 `CHAR` 或 `VARCHAR` 字符串表达式（如列名称）。默认值是空字符串 ("")。
*position*
（可选）指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 `1`。如果 *position* 小于 `1`，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中的字符数量，则结果为 *source\$1string*。
*参数*
（可选）一个或多个字符串文本，指示函数与模式的匹配方式。可能的值包括：
+ c – 执行区分大小写的匹配。默认情况下，使用区分大小写的匹配。
+ i – 执行不区分大小写的匹配。
+ p – 使用 Perl 兼容正则表达式 (PCRE) 方言解释模式。有关 PCRE 的更多信息，请参阅 Wikipedia 中的 [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 返回类型
VARCHAR
如果 *pattern* 或 *replace\$1string* 为 `NULL`，则返回 `NULL`。
## 示例
要使用不区分大小写的匹配替换字符串 `FOX` 在值 `quick brown 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] |
+----------------------------------+
```
以下示例使用 TICKIT 示例数据库的 USERS 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要删除电子邮件地址中的 `@` 和域名，请使用以下示例。
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# REGEXP\$1SUBSTR 函数
通过在字符串中搜索正则表达式模式，返回字符串中的字符。REGEXP\$1SUBSTR 与 [SUBSTRING 函数](r_SUBSTRING.md) 函数相似，只不过前者可让您在字符串中搜索正则表达式模式。如果函数无法将正则表达式与字符串中的任何字符匹配，则返回一个空字符串。有关正则表达式的更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)和 Wikipedia 中的 [Regular expression](https://en.wikipedia.org/wiki/Regular_expression)。
## 语法
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 参数
*source\$1string*
要搜索的字符串表达式。
* 模式*
表示正则表达式模式的 UTF-8 字符串文本。有关更多信息，请参阅 [POSIX 运算符](pattern-matching-conditions-posix.md)。
*position*
指示在 *source\$1string* 中开始搜索的位置的正整数。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。默认值为 1。如果 *position* 小于 1，则搜索从 *source\$1string* 的第一个字符开始。如果 *position* 大于 *source\$1string* 中的字符数量，则结果为空字符串 ("")。
*出现*
一个正整数，指示要使用的模式的匹配项。REGEXP\$1SUBSTR 会跳过第一个 *occurrence* -1 匹配项。默认值是 1。如果 *occurrence* 小于 1 或大于 *source\$1string* 中的字符串，则会忽略搜索，并且结果为空。
*参数*
一个或多个字符串，指示函数与模式的匹配方式。可能的值包括：
+ 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) 方言解释模式。有关 PCRE 的更多信息，请参阅 Wikipedia 中的 [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 返回类型
VARCHAR
## 示例
以下示例返回电子邮件地址中 @ 字符和域扩展名之间的部分。所查询的 `users` 数据来自 Amazon Redshift 示例数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
以下示例使用不区分大小写的匹配返回与字符串 `FOX` 的第一次出现相对应的输入部分。
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
以下示例使用不区分大小写的匹配返回与字符串 `FOX` 的第二次出现相对应的输入部分。结果为空（非 null，长度为 0），因为没有第二次出现。
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
以下示例返回以小写字母开头的输入的第一部分。这在功能上与不带 `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 会将其视为字符串。
[REPLICATE 函数](r_REPLICATE.md)的同义词。
## 语法
```
REPEAT(string, integer)
```
## 参数
*string*
第一个输入参数是要重复的字符串。
*integer*
第二个参数是指示字符串重复次数的 `INTEGER`。
## 返回类型
VARCHAR
## 示例
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要重复 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 |
+-------+--------+
```
以下示例演示如何生成最多 1600 万个字节的字符串：
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# REPLACE 函数
将现有字符串中一组字符的所有匹配项替换为其他指定字符。
REPLACE 与 [TRANSLATE 函数](r_TRANSLATE.md)和 [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)相似，只不过 TRANSLATE 进行多次单字符替换，REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式，而 REPLACE 一次性将整个字符串替换为其他字符串。
## 语法
```
REPLACE(string, old_chars, new_chars)
```
## 参数
*string*
要搜索的 `CHAR` 或 `VARCHAR` 字符串
*old\$1chars*
要替换的 `CHAR` 或 `VARCHAR` 字符串。
*new\$1chars*
用于替换 *old\$1string* 的新 `CHAR` 或 `VARCHAR` 字符串。
## 返回类型
VARCHAR
如果 *old\$1chars* 或 *new\$1chars* 为 `NULL`，则将返回 `NULL`。
## 示例
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要将 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 |
+-------+----------+----------+
```
# REPLICATE 函数
REPEAT 函数的同义词。
请参阅 [REPEAT 函数](r_REPEAT.md)。
# REVERSE 函数
REVERSE 函数对字符串运行并以反向顺序返回字符。例如，`reverse('abcde')` 将返回 `edcba`。此函数适用于数字和日期数据类型以及字符数据类型；但在大多数情况下，它对于字符串具有实用价值。
## 语法
```
REVERSE( expression )
```
## 参数
*expression*
一个表达式，带有表示字符反转目标的字符、日期、时间戳或数字数据类型。所有表达式都隐式转换为 `VARCHAR` 字符串。`CHAR` 字符串中的尾部空白会被忽略：
## 返回类型
VARCHAR
## 示例
以下示例使用 TICKIT 示例数据库的 USERS 表和 SALES 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要从 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 个销售 ID 及其对应的反转 ID（已强制转换为字符串），请使用以下示例。
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# 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 都会予以删除。
# SOUNDEX 函数
SOUNDEX 函数返回美国 Soundex 值，其中包括输入字符串的第一个字母，后跟一个 3 位数字的声音编码，该编码表示您指定的字符串的英语发音。例如，`Smith` 和 `Smyth` 具有相同的 Soundex 值。
## 语法
```
SOUNDEX(string)
```
## 参数
*string*
您可以指定要转换为美国 Soundex 代码值的 `CHAR` 或 `VARCHAR` 字符串。
## 返回类型
VARCHAR(4)
## 使用说明
SOUNDEX 函数仅转换英文字母小写或大写 ASCII 字符，包括 a–z 和 A–Z。SOUNDEX 将忽略其他字符。对于由空格分隔的多个单词组成的字符串，SOUNDEX 返回单个 Soundex 值。
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
如果输入字符串不包含任何英文字母，SOUNDEX 将返回一个空字符串。
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## 示例
要返回 `Amazon` 的 Soundex 值，请使用以下示例。
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
要返回 `smith` 和 `smyth` 的 Soundex 值，请使用以下示例。请注意，Soundex 值是相同的。
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# 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
```
# STRPOS 函数
返回子字符串在指定字符串中的位置。
有关类似的函数，请参阅[CHARINDEX 函数](r_CHARINDEX.md)和[POSITION 函数](r_POSITION.md)。
## 语法
```
STRPOS(string, substring )
```
## 参数
*string*
第一个输入参数是要在其中进行搜索的 `CHAR` 或 `VARCHAR` 字符串。
*substring*
第二个参数是要在 *string* 中搜索的子字符串。
## 返回类型
INTEGER
STRPOS 函数返回与 *substring* 的位置对应的 `INTEGER`（从 1 开始，而不是从 0 开始）。此位置基于字符数而不是字节数，这是为了将多字节字符作为单字符计数。
## 使用说明
如果在 *string* 中未找到 *substring*，STRPOS 将返回 `0`。
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## 示例
要显示 `fish` 在 `dogfish` 内的位置，请使用以下示例。
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
以下示例使用 TICKIT 示例数据库的 SALES 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要返回 SALES 表中 COMMISSION 超过 999.00 的销售交易的数量，请使用以下示例。
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# STRTOL 函数
将由一些指定基数组成的字符串表达式转换为等效的整数值。已转换的值必须在有符号 64 位范围中。
## 语法
```
STRTOL(num_string, base)
```
## 参数
*num\$1string*
要转换的数字的字符串表达式。如果 *num\$1string* 为空（`''`）或以 null 字符（`'\0'`）开头，则转换后的值为 `0`。如果 *num\$1string* 是包含 NULL 值的列，STRTOL 将返回 `NULL`。字符串能够以任意数量的空格开头，也可以后跟加号“`+`”或减号“`-`”以表示正负。默认值为“`+`”。如果 *base* 为 `16`，则字符串可以“`0x`”开头。
*base*
`INTEGER` 介于 2 和 36 之间。
## 返回类型
BIGINT
如果 *num\$1string* 为 null，则函数返回 `NULL`。
## 示例
要将字符串和基数值对转换为整数，请使用以下示例。
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# SUBSTRING 函数
按指定的开始位置返回子字符串子集。
如果输入的是字符串，字符的开始位置和数量基于字符数而不是字节数，这是为了将多字节字符作为单个字符计数。如果输入的是二进制表达式，则开始位置和提取的子字符串基于字节。您无法指定负长度，但可指定负开始位置。
## 语法
```
SUBSTRING(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## 参数
*character\$1string*
要搜索的字符串。非字符数据类型将视为字符串。
*start\$1position*
字符串中开始提取的位置，从 1 开始。*start\$1position* 基于字符数而不是字节数，这是为了将多字节字符作为单个字符计数。此数字可以为负。
*number\$1characters*
要提取的字符的数量（子字符串的长度）。*number\$1characters* 基于字符数而不是字节数，这是为了将多字节字符作为单个字符计数。此数字不能为负。
*binary\$1expression*
要搜索的数据类型为 VARBYTE 的 binary\$1expression。
*start\$1byte*
二进制表达式中开始提取的位置，从 1 开始。此数字可以为负。
*number\$1bytes*
要提取的字节的数量（子字符串的长度）。此数字不能为负。
## 返回类型
根据输入选择 VARCHAR 或 VARBYTE。
## 使用说明
以下是一些示例，说明如何使用 *start\$1position* 和 *number\$1characters* 从字符串的不同位置提取子字符串。
以下示例返回以第 6 个字符开头的 4 字符字符串。
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
如果 *start\$1position* \$1 *number\$1characters* 超过 *string* 的长度，SUBSTRING 将返回从 *start\$1position* 开始到此字符串末尾的子字符串。例如：
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
如果 `start_position` 为负或 0，SUBSTRING 函数将返回从长度为 `start_position` \$1 `number_characters` -1 的字符串的第一个字符开始的子字符串。例如：
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
如果 `start_position` \$1 `number_characters` -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
```
以下示例显示了二进制值 `abc` 的负开始位置。由于开始位置为 -3，所以子字符串从二进制值的开头进行提取。结果会自动显示为二进制子字符串的十六进制表示形式。
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
以下示例显示二进制值 `abc` 的开始位置为 1。因为没有指定长度，所以将字符串从字符串开始位置提取到末尾。结果会自动显示为二进制子字符串的十六进制表示形式。
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
以下示例显示二进制值 `abc` 的开始位置为 3。因为没有指定长度，所以将字符串从字符串开始位置提取到末尾。结果会自动显示为二进制子字符串的十六进制表示形式。
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
以下示例显示二进制值 `abc` 的开始位置为 2。字符串从开始位置提取到位置 10，但字符串的末尾位于位置 3。结果会自动显示为二进制子字符串的十六进制表示形式。
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
以下示例显示二进制值 `abc` 的开始位置为 2。字符串从开始位置提取 1 个字节。结果会自动显示为二进制子字符串的十六进制表示形式。
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
以下示例返回出现在输入字符串 `Silva, Ana` 中最后一个空格之后的名字 `Ana`。
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# TEXTLEN 函数
LEN 函数的同义词。
请参阅 [LEN 函数](r_LEN.md)。
# TRANSLATE 函数
对于给定表达式，将指定字符的所有匹配项替换为指定替代项。现有字符将按其在 *characters\$1to\$1replace* 和 *characters\$1to\$1substitute* 参数中的位置映射到替换字符。如果在 *characters\$1to\$1replace* 参数中指定的字符多于在 *characters\$1to\$1substitute* 参数中指定的字符，返回值中将省略 *characters\$1to\$1replace* 参数中的额外字符。
TRANSLATE 与 [REPLACE 函数](r_REPLACE.md)和 [REGEXP\$1REPLACE 函数](REGEXP_REPLACE.md)相似，只不过 REPLACE 将整个字符串替换为其他字符串，REGEXP\$1REPLACE 可让您在字符串中搜索正则表达式模式，而 TRANSLATE 进行多次单字符替换。
如果任何参数为 null，则返回 `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 |
+-----------+
```
以下示例使用 TICKIT 示例数据库的 USERS 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要将列中所有值的 at（@）符号替换为句点，请使用以下示例。
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
要将空格替换为下划线并去掉列中所有值的句点，请使用以下示例。
```
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 | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## 参数
BOTH \$1 LEADING \$1 TRAILING
（可选）指定从何处剪裁字符。使用 BOTH 会删除前导和尾随字符，使用 LEADING 仅删除前导字符，使用 TRAILING 仅删除尾随字符。如果省略此参数，则会同时剪裁前导字符和尾随字符。
*trim\$1chars*
（可选）要从字符串剪裁的字符数。如果忽略此参数，则剪裁空白区域。
*string*
要剪裁的字符串。
## 返回类型
TRIM 函数返回 `VARCHAR` 或 `CHAR` 字符串。如果您将 TRIM 函数与 SQL 命令结合使用，Amazon Redshift 会将结果隐式转换为 `VARCHAR`。如果您在 SQL 函数的 SELECT 列表中使用 TRIM 函数，Amazon Redshift 不会隐式转换结果，您可能需要执行显式转换以避免数据类型不匹配错误。有关显式转换的信息，请参阅 [CAST 函数](r_CAST_function.md)和 [CONVERT 函数](r_CONVERT_function.md) 函数。
## 示例
要从字符串 ` dog ` 中剪裁前导和尾随空格，请使用以下示例。
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
要从字符串 ` dog ` 中剪裁前导和尾随空格，请使用以下示例。
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
要从字符串 `"dog"` 中删除前导双引号，请使用以下示例。
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
要从字符串 `"dog"` 中删除尾随双引号，请使用以下示例。
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
当 *trim\$1chars* 中的任意字符出现在 *string* 的开头或结尾时，TRIM 都会予以删除。以下示例在字符“C”、“D”和“G”出现在 VENUENAME（即 `VARCHAR` 列）的开头或结尾时对其进行剪裁。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T 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 函数返回与输入字符串具有相同数据类型的字符串。例如，如果输入是 `VARCHAR` 字符串，该函数将返回 `VARCHAR` 字符串。
## 示例
以下示例使用 TICKIT 示例数据库的 CATEGORY 表中的数据。有关更多信息，请参阅 [示例数据库](c_sampledb.md)。
要将 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 |
+-----------+-----------+
```