Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 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。
下節提供所支援函數的函數名稱、語法及描述。字串的所有偏移都是以一開始。
**已取代的僅限領導節點函數**
下列字串函數已棄用，因為它們只在領導者節點上執行。如需詳細資訊，請參閱[僅限領導節點函數](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1 (串連) 運算子
串連 `||` 符號兩側的兩個運算式，並傳回串連後的運算式。
類似於 [CONCAT 函數](r_CONCAT.md)。
**注意**
如果其中一個或兩個運算式都為 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`。
## 語法
```
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
```
下列範例會從符合 *trim \$1chars* 清單 `'tes'` 中任何字元的字串 `'setuphistorycassettes'` 中移除開頭和結尾部分。任何出現在輸入字串開頭或結尾的 *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 開始，不是以零開始)。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。如果在字串內找不到子字串，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 對應的字元，請使用下列範例。請注意，CHR 函數會針對輸入 `0` 傳回 `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 函數將可變長度字串轉換為 8 個字元的字串，此為 32 位元二進位序列之十六進位值的文字表示法。若要偵測來源與目標資料之間的變更，請在來源資料上使用 CRC32 函數並儲存輸出。然後，在目標資料上使用 CRC32 函數，並將該輸出與來源資料的輸出進行比較。如果資料沒有被修改，輸出將是相同的，如果資料被修改，輸出將不同。
## 語法
```
CRC32(string)
```
## 引數
*string*
`CHAR` 字串、`VARCHAR` 字串或隱含評估為 `CHAR` 或 `VARCHAR` 類型的運算式。
## 傳回類型
CRC32 函數傳回 8 個字元的字串，此為 32 位元二進位序列之十六進位值的文字表示法。Amazon Redshift CRC32 函數以 CRC-32C 多項式為基礎。
## 範例
為了顯示字串 `Amazon Redshift` 的 8 位值。
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# DIFFERENCE 函數
DIFFERENCE 函數比較兩個字串的 American 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` 值，用於計算兩個字串的 American Soundex 代碼中比對字元的數量。Soundex 代碼有 4 個字元，因此當字串的 American Soundex 代碼值的所有 4 個字元都相同時，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 值，請使用下列範例。該函數傳回 `2`，因為字串的 Soundex 值的 2 個字元是相同的。
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
若要比較字串 `Amazon` 和 `+-*/%Amazon` 的 Soundex 值，請使用下列範例。該函數傳回 `4`，因為字串的 Soundex 值的所有 4 個字元都是相同的。請注意，函數會忽略第二個字串中的無效字元 `+-*/%`。
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
若要比較字串 `AC/DC` 和 `Ay See Dee See` 的 Soundex 值，請使用下列範例。函數傳回 `4`，因為字串的 Soundex 值的所有 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 函數將字串中每個單字的第一個字母變成大寫，而後續任何字母都變成 (或保持) 小寫。因此，必須了解哪些字元 (除了空白字元) 做為單字分隔符號。*單字分隔符號*字元是任何非英數字元，包括標點符號、記號及控制字元。以下所有字元都是單字分隔符號：
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Tab、新行字元、換頁、換行及歸位也是單字分隔符號。
## 範例
下列範例會使用 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)
```
## 引數
*表達式*
`CHAR` 字串、`VARCHAR` 字串、`VARBYTE` 運算式或隱含評估為 `CHAR`、`VARCHAR` 或 `VARBYTE` 類型的運算式。
## 傳回類型
INTEGER
LEN 函數傳回整數，表示輸入字串中的字元數。
如果輸入字串是字串，則 LEN 函數會傳回多位元組字串中的實際字元數，而不是位元組數。例如，需要 `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 資料表中前十個最長的會場名稱，請使用下列範例。
```
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` 字串或運算式。
## 傳回類型
string
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` 類型的運算式。
*長度*
整數，定義函數結果的長度。字串長度以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。如果 *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 函數會傳回與輸入 *string* 的資料類型相同的字元字串 (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
```
下列範例使用修剪字元 `2`，這是從 `venueid` 欄擷取的。
```
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` 類型的運算式。
*string*
`CHAR` 字串、`VARCHAR` 字串或隱含評估為 `CHAR` 或 `VARCHAR` 類型的運算式。
## 傳回類型
INTEGER
OCTETINDEX 函式會傳回與 *string* 中 *substring* 位置相對應的 `INTEGER` 值作為位元組數目，其中 *string* 中的第一個字元會計算為 1。如果 *string* 不包含多位元組字元，結果會等於 CHARINDEX 函數的結果。如果 *string* 不包含 *substring*，則函數會傳回 `0`。如果 *substring* 為空，則函數會傳回 `1`。
## 範例
若要傳回字串 `q` 中子字串的位置`Amazon Redshift`，請使用下列範例。此範例會傳回 `0`，因為 *substring* 不在 *string* 中。
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
若要傳回字串 中空子字串的位置`Amazon Redshift`，請使用下列範例。這個範例會傳回 `1`，因為 *substring* 是空的。
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
若要傳回字串 `Redshift` 中子字串的位置`Amazon Redshift`，請使用下列範例。這個範例會傳回 `8`，因為 *substring* 是從 *string* 的第八個位元組開始。
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
若要傳回字串 `Redshift` 中子字串的位置`Amazon Redshift`，請使用下列範例。這個範例會傳回 `21`，因為 *string* 的前六個字元是雙位元組字元。
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# OCTET\$1LENGTH 函數
傳回指定字串的長度 (以位元組為單位)。
## 語法
```
OCTET_LENGTH(expression)
```
## 引數
*表達式*
`CHAR` 字串、`VARCHAR` 字串、`VARBYTE` 運算式或隱含評估為 `CHAR`、`VARCHAR` 或 `VARBYTE` 類型的運算式。
## 傳回類型
INTEGER
OCTET\$1LENGTH 函數傳回整數，表示輸入字串中的位元組數。
如果輸入字串是字元字串，則 [LEN](r_LEN.md) 函數會傳回多位元組字串中的實際字元數，而不是位元組數。例如，需要 `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 開始，不是以零開始)。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。如果在字串內找不到子字串，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 函數傳回與輸入*字串*相同類型的字串。
## 範例
若要傳回含雙引號的字串 `"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 函數傳回與輸入*字串*的資料類型相同的 `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) 和維基百科中的[規則表達式](https://en.wikipedia.org/wiki/Regular_expression)。
## 語法
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## 引數
*source\$1string*
`CHAR` 或 `VARCHAR` 字串。
*pattern*
代表規則表達式模式的 UTF-8 字串常值。如需詳細資訊，請參閱[POSIX 運算子](pattern-matching-conditions-posix.md)。
*position*
(選用) 正 `INTEGER`，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設值為 `1`。如果 *position* 小於 `1`，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為 `0`。
*參數*
(選用) 一或多個字串常值，表示函數如何比對模式。可能值如下：
+ c - 進行區分大小寫比對。預設是使用區分大小寫比對。
+ i - 進行不區分大小寫比對。
+ p - 使用 Perl 相容規則運算式 (PCRE) 方言解釋此模式。如需 PCRE 的詳細資訊，請參閱維基百科中的 [Perl 相容規則表達式](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 類似於 [POSITION](r_POSITION.md) 函數，但可讓您在字串中搜尋規則表達式模式。如需規則表達式的詳細資訊，請參閱 [POSIX 運算子](pattern-matching-conditions-posix.md) 和維基百科中的[規則表達式](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*
(選用) 正 `INTEGER`，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設值為 `1`。如果 *position* 小於 `1`，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為 `0`。
*occurrence*
(選用) 正 `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 的詳細資訊，請參閱維基百科中的 [Perl 相容規則表達式](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 傳回類型
Integer
## 範例
下列範例使用 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) 和維基百科中的[規則表達式](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` 字串運算式，例如欄名。
*pattern*
代表規則表達式模式的 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 的詳細資訊，請參閱維基百科中的 [Perl 相容規則表達式](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)。
## 傳回類型
VARCHAR
如果 *pattern* 或 *replace\$1string* 為 `NULL`，函數會傳回 `NULL`。
## 範例
若要使用不區分大小寫的比對取代值 `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] |
+----------------------------------+
```
下列範例使用 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) 和維基百科中的[規則表達式](https://en.wikipedia.org/wiki/Regular_expression)。
## 語法
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 引數
*source\$1string*
要搜尋的字串運算式。
*pattern*
代表規則表達式模式的 UTF-8 字串常值。如需詳細資訊，請參閱[POSIX 運算子](pattern-matching-conditions-posix.md)。
*position*
正整數，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設為 1。如果 *position* 小於 1，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為空字串 ("")。
*occurrence*
正整數，表示要使用哪一個出現的模式。REGEXP\$1SUBSTR 略過前 *occurrence* -1 個相符項目。預設為 1。如果 *occurrence* 小於 1 或大於 *source\$1string* 中的字元數，則會忽略搜尋且結果為空白。
*參數*
一或多個字串常值，表示函數如何比對模式。可能值如下：
+ c - 進行區分大小寫比對。預設是使用區分大小寫比對。
+ i - 進行不區分大小寫比對。
+ e - 使用子運算式擷取子字串。
如果 *pattern* 包含子表達式，REGEXP\$1SUBSTR 使用 *pattern* 中的第一個子表達式來比對子字串。子運算式是用括號括起來的模式中的運算式。例如，對於模式 `'This is a '`，會比對第一個運算式和字串 `'This is a (\\w+)'` 後跟一個單詞。具有 `e` 參數的 REGEXP\$1SUBSTR 不會傳回 *pattern*，而是僅傳回子運算式內的字串。
REGEXP\$1SUBSTR 只考慮第一個子表達式；忽略其他子表達式。如果模式沒有子表達式，REGEXP\$1SUBSTR 會忽略 'e' 參數。
+ p - 使用 Perl 相容規則運算式 (PCRE) 方言解釋此模式。如需 PCRE 的詳細資訊，請參閱維基百科中的 [Perl 相容規則表達式](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 |
+-------+--------+
```
下列範例示範產生最多 16，000，000 個位元組的字串：
```
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*
新的 `CHAR` 或 `VARCHAR` 字串，用來取代 *old\$1string*。
## 傳回類型
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 )
```
## 引數
*表達式*
具有字元、日期、時間戳記或數值資料類型的運算式，代表字元反轉的目標。所有運算式都會隱含轉換為 `VARCHAR` 字串。`CHAR` 字串中的結尾空格會遭到忽略。
## 傳回類型
VARCHAR
## 範例
下列範例使用來自 TICKIT 範例資料庫中 USERS 和 SALES 資料表的資料。如需詳細資訊，請參閱[範本資料庫](c_sampledb.md)。
若要從 USERS 資料表中選取五個不同城市名稱及其對應的反轉名稱，請使用下列範例。
```
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 |
+----------+----------+
```
若要選取五個銷售 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
```
下列範例會從符合 *trim \$1chars* 清單 `'tes'` 中任何字元的字串 `'setuphistorycassettes'` 中移除結尾部分。任何出現在輸入字串結尾的 *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 函數傳回 American Soundex 值，該值由輸入字串的第一個字母後面跟著代表您指定字串的英文發音的 3 位元發音編碼組成。例如，`Smith` 和 `Smyth` 具有相同的 Soundex 值。
## 語法
```
SOUNDEX(string)
```
## 引數
*string*
您可以指定要轉換為 American 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 值，請使用下列範例。請注意，聲音值是相同的。
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# SPLIT\$1PART 函數
在指定分隔符號之處分割字串，並傳回指定位置的部分。
## 語法
```
SPLIT_PART(string, delimiter, position)
```
## 引數
*string*
要分割的字串資料欄、運算式或字串常值。字串可以是 CHAR 或 VARCHAR。
*delimiter*
分隔符號字串，表示輸入 *string* 的部分。
如果 *delimiter* 是常值，請以單引號括住。
*position*
要傳回之*字串*部分的位置 (從 1 起算)。必須是大於 0 的整數。如果 *position* 大於字串部分的數目，SPLIT\$1PART 會傳回空字串。如果在 *string* 中找不到 *delimiter*，則傳回的值包含指定部分的內容，這可能是整個 *string* 或空值。
## 傳回類型
CHAR 或 VARCHAR 字串，與*字串*參數相同。
## 範例
下列範例會使用 `$` 分隔符號將字串常值分割成多個部分，並傳回第二部分。
```
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 函數傳回對應於*子字串*位置的 `INTEGER` (以 1 開始，不是以零開始)。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。
## 使用須知
如果在 *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`。
## 範例
若要將字串和基值對轉換為整數，請使用下列範例。
```
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* 從字串中的各個位置提取子字串的一些範例。
下列範例傳回從第六個字元開始的四個字元的字串。
```
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 來肯定地擷取字串的字首，因為您需要根據位元組數來指定雙位元組字串的長度，而不是字元數。若要根據位元組長度來擷取字串的開頭部分，您可以將字串 CAST 成為 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
```
下列範例顯示 1 作為二進位值 `abc` 的開始位置。因為沒有指定長度，所以字串從開始位置提取到字串的結尾。結果自動顯示為二進位子字串的十六進位表示形式。
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
下列範例顯示 3 作為二進位值 `abc` 的開始位置。因為沒有指定長度，所以字串是從開始位置提取到字串的結尾。結果自動顯示為二進位子字串的十六進位表示形式。
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
下列範例顯示 2 作為二進位值 `abc` 的開始位置。字串從開始位置提取到位置 10，但字串的結尾位於位置 3。結果自動顯示為二進位子字串的十六進位表示形式。
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
下列範例顯示 2 作為二進位值 `abc` 的開始位置。字串從開始位置提取 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 )
```
## 引數
*表達式*
要轉換的表達式。
*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` 字串。如果您搭配 SQL 命令來使用 TRIM 函數，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 會移除這些字元。下列範例修剪 VENUENAME (這是 `VARCHAR` 欄) 開頭或結尾出現的 'C'、'D' 和 'G' 字元。如需詳細資訊，請參閱[範本資料庫](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` 字串或任何其他資料類型，例如 `CHAR`，可以隱含轉換為 `VARCHAR`。
## 傳回類型
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 |
+-----------+-----------+
```