本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 字串函數
字串函數處理和操作字元字串，或評估為字元字串的表達式。當這些函數中的 *string* 引數是常值時，必須以單引號括住。支援的資料類型包括 CHAR 和 VARCHAR。
下節提供所支援函數的函數名稱、語法及描述。字串的所有偏移都是以一開始。
**Topics**
+ [\$1\$1 (串連) 運算子](concat_op.md)
+ [BTRIM 函數](BTRIM.md)
+ [CONCAT 函數](CONCAT.md)
+ [FORMAT\$1STRING 函數](FORMAT_STRING.md)
+ [LEFT 和 RIGHT 函數](LEFT.md)
+ [LENGTH 函數](LENGTH.md)
+ [LOWER 函數](LOWER.md)
+ [LPAD 和 RPAD 函數](LPAD.md)
+ [LTRIM 函數](LTRIM.md)
+ [POSITION 函數](POSITION.md)
+ [REGEXP\$1COUNT 函數](REGEXP_COUNT.md)
+ [REGEXP\$1INSTR 函數](REGEXP_INSTR.md)
+ [REGEXP\$1REPLACE 函數](REGEXP_REPLACE.md)
+ [REGEXP\$1SUBSTR 函數](REGEXP_SUBSTR.md)
+ [REPEAT 函數](REPEAT.md)
+ [REPLACE 函數](REPLACE.md)
+ [REVERSE 函數](REVERSE.md)
+ [RTRIM 函數](RTRIM.md)
+ [SPLIT 函數](split.md)
+ [SPLIT\$1PART 函數](SPLIT_PART.md)
+ [SUBSTRING 函數](SUBSTRING.md)
+ [TRANSLATE 函數](TRANSLATE.md)
+ [TRIM 函數](TRIM.md)
+ [UPPER 函數](UPPER.md)
+ [UUID 函數](UUID.md)
# \$1\$1 (串連) 運算子
串連 \$1\$1 符號兩側的兩個運算式，並傳回串連後的運算式。
串連運算子類似於 [CONCAT 函數](CONCAT.md)。
**注意**
對於 CONCAT 函數和串連運算子，如果一個或兩個運算式為 Null，則串連的結果為 Null。
## 語法
```
expression1 || expression2
```
## 引數
*expression1*、*expression2*
兩個引數都可以是固定長度或可變長度的字元字串或表達式。
## 傳回類型
\$1\$1 運算子傳回字串。字串的類型與輸入引數相同。
## 範例
下列範例串連 USERS 資料表中的 FIRSTNAME 和 LASTNAME 欄位：
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
若要串連可能包含 Null 的欄，請使用 [NVL 和 COALESCE 函數](NVL_function.md)表達式。下列範例使用 NVL，只要遇到 NULL 就傳回 0。
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# BTRIM 函數
BTRIM 函數修剪字串，包括移除開頭和結尾空格，或移除符合選用指定字串的開頭和結尾字元。
## 語法
```
BTRIM(string [, trim_chars ] )
```
## 引數
*string*
要修剪的輸入 VARCHAR 字串。
*trim\$1chars*
包含要比對之字元的 VARCHAR 字串。
## 傳回類型
BTRIM 函數傳回 VARCHAR 字串。
## 範例
下列範例從字串 `' abc '` 中修剪開頭和結尾空格：
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
下列範例從字串 `'xyzaxyzbxyzcxyz'` 中移除開頭和結尾 `'xyz'` 字串。開頭和結尾的 `'xyz'` 已移除，但出現在字串內的部分則未移除。
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
下列範例會從符合 *trim \$1chars* 清單 `'tes'` 中任何字元的字串 `'setuphistorycassettes'` 中移除開頭和結尾部分。任何出現在輸入字串開頭或結尾的 *trim\$1chars* 清單中另一個字元前的 `t`、`e` 或 `s` 都會被移除。
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# CONCAT 函數
CONCAT 函數會串連兩個運算式，並傳回產生的運算式。若要串連兩個以上的運算式，請使用巢狀 CONCAT 函數。兩個運算式之間的串連運算子 (`||`) 產生與 CONCAT 函數相同的結果。
**注意**
對於 CONCAT 函數和串連運算子，如果一個或兩個運算式為 Null，則串連的結果為 Null。
## 語法
```
CONCAT ( expression1, expression2 )
```
## 引數
*expression1*、*expression2*
這兩個引數都可以是固定長度的字元字串、可變長度字串、二進位運算式或計算結果為這些輸入之一的運算式。
## 傳回類型
CONCAT 傳回一個運算式。運算式的資料類型與輸入引數的類型相同。
如果輸入表達式的類型不同， 會 AWS Clean Rooms 嘗試隱含輸入轉換其中一個表達式。如果無法轉換數值，系統會傳回一個錯誤。
## 範例
下列範例串連兩個字元常值：
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
下列查詢 (使用 `||` 運算子，而不是 CONCAT) 產生相同的結果：
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
下列範例使用兩個 CONCAT 函數來串連三個字元字串：
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
若要串連可能包含 Null 的欄，請使用 [NVL 和 COALESCE 函數](NVL_function.md)。下列範例使用 NVL，只要遇到 NULL 就傳回 0。
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
下列查詢串連 VENUE 資料表中的 CITY 和 STATE 值：
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
下列查詢使用巢狀 CONCAT 函數。此查詢串連 VENUE 資料表中的 CITY 和 STATE 值，但以逗號和空格來分隔產生的字串：
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# FORMAT\$1STRING 函數
FORMAT\$1STRING 函數會以提供的引數取代範本字串中的預留位置，以建立格式化字串。它會從 printf 格式格式字串傳回格式化字串。
FORMAT\$1STRING 函數的運作方式是將範本字串中的預留位置取代為以引數傳遞的對應值。當您需要動態建構包含靜態文字和動態資料的字串時，例如產生輸出訊息、報告或其他類型的資訊性文字時，這種類型的字串格式很有用。FORMAT\$1STRING 函數提供簡潔且可讀取的方式來建立這些類型的格式化字串，讓您更輕鬆地維護和更新產生輸出的程式碼。
## 語法
```
format_string(strfmt, obj, ...)
```
## 引數
*strfmt*
STRING 表達式。
*obj*
STRING 或數值表達式。
## 傳回類型
FORMAT\$1STRING 會傳回 STRING。
## 範例
下列範例包含一個範本字串，其中包含兩個預留位置：`%d`十進位 （整數） 值，以及`%s`字串值。`%d` 預留位置會取代為小數 （整數） 值 (`100`)，而 %s 預留位置則會取代為字串值 (`"days"`)。輸出是範本字串，預留位置由提供的引數取代：`"Hello World 100 days"`。
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# LEFT 和 RIGHT 函數
這些函數從字元字串最左邊或最右邊傳回指定的字元數。
數目以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。
## 語法
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## 引數
*string*
任何字元字串，或任何評估為字元字串的表達式。
*integer*
正整數。
## 傳回類型
LEFT 和 RIGHT 傳回 VARCHAR 字串。
## 範例
下列範例從 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
(6 rows)
```
# LENGTH 函數
# LOWER 函數
將字串轉換成小寫。LOWER 支援 UTF-8 多位元組字元，每個字元最多 4 個位元組。
## 語法
```
LOWER(string)
```
## 引數
*string*
輸入參數是 VARCHAR 字串 （或任何其他資料類型，例如 CHAR，可隱含轉換為 VARCHAR)。
## 傳回類型
LOWER 函數會傳回與輸入字串相同資料類型的字元字串。
## 範例
下列範例將 CATNAME 欄位轉換為小寫：
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# LPAD 和 RPAD 函數
這些函數根據指定的長度，將字元附加到字串的前面或後面。
## 語法
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## 引數
*string1*
字元字串或評估為字元字串的表達式，例如字元欄的名稱。
*長度*
整數，定義函數結果的長度。字串長度以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。如果 *string1* 比指定的長度更長，則會截斷 (從右邊)。如果 *length* 是負數，則函數結果為空字串。
*string2*
附加到 *string1* 前面或後面的一或多個字元。此為選用引數；如果不指定，則使用空格。
## 傳回類型
這些函數傳回 VARCHAR 資料類型。
## 範例
將一組指定的活動名稱截斷至 20 個字元，並在較短名稱的前面附加空格：
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
將同一組活動名稱截斷至 20 個字元，但在較短名稱的後面附加 `0123456789`。
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# LTRIM 函數
從字串開頭修剪字元。刪除只包含在修剪字元清單中的字元的最長字串。當修剪字元未出現在輸入字串中時，修剪即完成。
## 語法
```
LTRIM( string [, trim_chars] )
```
## 引數
*string*
要修剪的字串資料行、運算式或字串常值。
*trim\$1chars*
字串欄、運算式或字串常值，代表要從 *string* 開頭修剪的字元。如果未指定，則會使用空格作為修剪字元。
## 傳回類型
LTRIM 函數會傳回與輸入 *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
```
# POSITION 函數
傳回指定子字串在一個字串內的位置。
## 語法
```
POSITION(substring IN string )
```
## 引數
*substring*
在 *string* 內要搜尋的子字串。
*string*
要搜尋的字串或欄。
## 傳回類型
POSITION 函數傳回對應於子字串位置的整數 (以 1 開始，不是以零開始)。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。
## 使用須知
如果在字串內找不到子字串，POSITION 會傳回 0：
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## 範例
下列範例顯示字串 `fish` 在單字 `dogfish` 內的位置：
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
下列範例從 SALES 資料表中傳回 COMMISSION 超過 999.00 的銷售交易次數：
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# REGEXP\$1COUNT 函數
在字串中搜尋規則表達式模式，並傳回整數指出此模式出現在字串中的次數。如果找不到相符項目，則函數會傳回 0。
## 語法
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## 引數
*source\$1string*
要搜尋的字串表達式，例如欄名。
*pattern*
代表規則運算式模式的字串常值。
*position*
正整數，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設為 1。如果 *position* 小於 1，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為 0。
*參數*
一或多個字串常值，表示函數如何比對模式。可能值如下：
+ c - 進行區分大小寫比對。預設是使用區分大小寫比對。
+ i - 進行不區分大小寫比對。
+ p - 使用 Perl 相容規則運算式 (PCRE) 方言解釋此模式。
## 傳回類型
Integer
## 範例
下列範例計算三字母序列出現的次數。
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
下列範例計算頂層網域名稱為 `org` 或 `edu` 的次數。
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
下列範例會使用不區分大小寫的比對`FOX`，來計算字串 的出現次數。
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會計算此類字詞的出現次數，並使用區分大小寫的比對。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的內涵。此範例會計算此類字詞的出現次數，但與前一個範例不同，因為它使用不區分大小寫的比對。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# REGEXP\$1INSTR 函數
在字串中搜尋規則表達式模式，並傳回整數指出相符子字串的開始位置或結尾位置。如果找不到相符項目，則函數會傳回 0。REGEXP\$1INSTR 類似於 [POSITION](POSITION.md) 函數，但可讓您在字串中搜尋規則表達式模式。
## 語法
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 引數
*source\$1string*
要搜尋的字串表達式，例如欄名。
*pattern*
代表規則運算式模式的字串常值。
*position*
正整數，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設為 1。如果 *position* 小於 1，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為 0。
*occurrence*
正整數，表示要使用哪一個出現的模式。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) 方言解釋此模式。
## 傳回類型
Integer
## 範例
下列範例搜尋網域名稱開頭的 `@`，並傳回第一個相符項目的開始位置。
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
下列範例搜尋單字 `Center` 的變體，並傳回第一個相符項目的開始位置。
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
下列範例會使用不區分大小寫的比對邏輯`FOX`，尋找字串 第一次出現的開始位置。
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
下列範例使用以 PCRE 方言編寫的模式來尋找包含至少一個數字和一個小寫字母的單字。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會尋找第二個此類字詞的開始位置。
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
下列範例使用以 PCRE 方言編寫的模式來尋找包含至少一個數字和一個小寫字母的單字。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會尋找第二個這類字詞的開始位置，但與前一個範例不同，因為它使用不區分大小寫的比對。
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# REGEXP\$1REPLACE 函數
在字串中搜尋規則表達式模式，並以指定的字串取代每一個出現的模式。REGEXP\$1REPLACE 類似於 [REPLACE 函數](REPLACE.md)，但可讓您在字串中搜尋規則表達式模式。
REGEXP\$1REPLACE 類似於 [TRANSLATE 函數](TRANSLATE.md) 和 [REPLACE 函數](REPLACE.md)，但 TRANSLATE 會進行多次單一字元替換，REPLACE 會將一整個字串替換成另一個字串，而 REGEXP\$1REPLACE 可讓您在字串中搜尋規則表達式模式。
## 語法
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 引數
*source\$1string*
要搜尋的字串表達式，例如欄名。
*pattern*
代表規則運算式模式的字串常值。
*replace\$1string*
字串表達式 (例如欄名)，用於搜尋每一個出現的模式。預設為空字串 ( "" )。
*position*
正整數，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設為 1。如果 *position* 小於 1，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為 *source\$1string*。
*參數*
一或多個字串常值，表示函數如何比對模式。可能值如下：
+ c - 進行區分大小寫比對。預設是使用區分大小寫比對。
+ i - 進行不區分大小寫比對。
+ p - 使用 Perl 相容規則運算式 (PCRE) 方言解釋此模式。
## 傳回類型
VARCHAR
如果 *pattern* 或 *replace\$1string* 為 NULL，則結果為 NULL。
## 範例
下列範例從電子郵件地中刪除 `@` 和網域名稱。
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
下列範例會將電子郵件地址的網域名稱取代為此值：`internal.company.com`。
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
下列範例會使用不區分大小寫的比對`quick brown fox`，取代值 `FOX`內出現的所有字串。
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會將這類單字的每個出現次數取代為值 `[hidden]`。
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會將這類單字的每次出現取代為值 `[hidden]`，但與先前的範例不同，因為它使用不區分大小寫的比對。
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# REGEXP\$1SUBSTR 函數
搜尋規則運算式模式，傳回字串中的字元。REGEXP\$1SUBSTR 類似於 [SUBSTRING 函數](SUBSTRING.md) 函數，但可讓您在字串中搜尋規則表達式模式。如果函數不能比對規則運算式與字串中的任何字元，則傳回一個空字串。
## 語法
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 引數
*source\$1string*
要搜尋的字串運算式。
*pattern*
代表規則運算式模式的字串常值。
*position*
正整數，表示在 *source\$1string* 內開始搜尋的位置。位置以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。預設為 1。如果 *position* 小於 1，則從 *source\$1string* 的第一個字元開始搜尋。如果 *position* 大於 *source\$1string* 中的字元數，則結果為空字串 ("")。
*occurrence*
正整數，表示要使用哪一個出現的模式。REGEXP\$1SUBSTR 略過前 *occurrence* -1 個相符項目。預設為 1。如果 *occurrence* 小於 1 或大於 *source\$1string* 中的字元數，則忽略搜尋，且結果為 NULL。
*參數*
一或多個字串常值，表示函數如何比對模式。可能值如下：
+ 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) 方言解釋此模式。
## 傳回類型
VARCHAR
## 範例
下列範例傳回電子郵件地址在 @ 和網域域名之間的部分。
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
下列範例使用不區分大小寫的比對`FOX`，傳回與字串 第一次出現對應的輸入部分。
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
下列範例會傳回以小寫字母開頭之輸入的第一部分。這在函數上與沒有 `c` 參數的相同 SELECT 陳述式完全相同。
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會傳回對應於第二個這類字詞的輸入部分。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
下列範例會使用 PCRE 方言撰寫的模式來尋找至少包含一個數字和一個小寫字母的字詞。它使用 `?=` 運算子，該運算子在 PCRE 中具有特定的前瞻內涵。此範例會傳回與第二個此類字詞對應的輸入部分，但與前一個範例不同，因為它使用不區分大小寫的比對。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
下列範例會使用子運算式，使用不區分大小寫的比對來尋找符合模式 `'this is a (\\w+)'` 的第二個字串。它傳回括號內的子運算式。
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# REPEAT 函數
將字串重複指定的次數。如果輸入參數是數值，REPEAT 會將輸入參數視為字串。
## 語法
```
REPEAT(string, integer)
```
## 引數
*string*
第一個輸入參數是要重複的字串。
*integer*
第二個參數是整數，表示字串重複的次數。
## 傳回類型
REPEAT 函數傳回字串。
## 範例
下列範例將 CATEGORY 資料表中 CATID 欄的值重複三次：
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# REPLACE 函數
以其他指定的字元取代一組字元在現有字串內出現的所有地方。
REPLACE 類似於 [TRANSLATE 函數](TRANSLATE.md) 和 [REGEXP\$1REPLACE 函數](REGEXP_REPLACE.md)，但 TRANSLATE 會進行多次單一字元替換，REGEXP\$1REPLACE 可讓您在字串中搜尋規則表達式模式，而 REPLACE 會將一整個字串替換成另一個字串。
## 語法
```
REPLACE(string1, old_chars, new_chars)
```
## 引數
*string*
要搜尋的 CHAR 或 VARCHAR 字串
*old\$1chars*
要取代的 CHAR 或 VARCHAR 字串。
*new\$1chars*
新的 CHAR 或 VARCHAR 字串，用來取代 *old\$1string*。
## 傳回類型
VARCHAR
如果 *old\$1chars* 或 *new\$1chars* 為 NULL，則結果為 NULL。
## 範例
下列範例將 CATGROUP 欄位中的字串 `Shows` 轉換為 `Theatre`：
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# REVERSE 函數
REVERSE 函數操作字串並傳回相反順序的字元。例如，`reverse('abcde')` 傳回 `edcba`。此函數適用於數值和日期資料類型，以及字元資料類型；不過，在大部分情況下，字元字串有實用值。
## 語法
```
REVERSE ( expression )
```
## 引數
*運算式*
具有字元、日期、時間戳記或數值資料類型的運算式，代表字元反轉的目標。所有表達式都隱含地轉換為可變長度的字元字串。忽略固定長度字元字串中的結尾空格。
## 傳回類型
REVERSE 傳回 VARCHAR。
## 範例
從 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
(5 rows)
```
選取五個銷售 ID 及其對應的反轉 ID (轉換為字元字串)：
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# RTRIM 函數
RTRIM 函數從字串結尾修剪一組指定的字元。移除只包含修剪字元清單中字元的最長字串。當修剪字元未出現在輸入字串中時，修剪即完成。
## 語法
```
RTRIM( string, trim_chars )
```
## 引數
*string*
要修剪的字串資料行、運算式或字串常值。
*trim\$1chars*
字串欄、運算式或字串常值，代表要從 *string* 結尾修剪的字元。如果未指定，則會使用空格作為修剪字元。
## 傳回類型
與 *string* 引數的資料類型相同的字串。
## 範例
下列範例從字串 `' abc '` 中修剪開頭和結尾空格：
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
下列範例從字串 `'xyzaxyzbxyzcxyz'` 中移除結尾 `'xyz'` 字串。結尾的 `'xyz'` 已移除，但出現在字串內的部分則未移除。
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
下列範例會從符合 *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 會移除這些字元。
# SPLIT 函數
SPLIT 函數可讓您從較大的字串擷取子字串，並將其用作陣列。當您需要根據特定分隔符號或模式將字串分解為個別元件時，SPLIT 函數非常有用。
## 語法
```
split(str, regex, limit)
```
## 引數
*str*
要分割的字串運算式。
*regex*
代表規則表達式的字串。*regex* 字串應該是 Java 規則表達式。
*limit*
整數表達式，可控制套用 *regex* 的次數。
+ 限制 > 0：產生的陣列長度不會超過限制，且產生的陣列最後一個項目將包含超過最後一個相符 *regex* 的所有輸入。
+ limit <= 0：*regex* 將盡可能套用多次，且產生的陣列可以是任何大小。
## 傳回類型
SPLIT 函數會傳回 ARRAY。
如果 `limit > 0`：產生的陣列長度不會超過限制，且產生的陣列最後一個項目將包含超過最後一個相符 regex 的所有輸入。
如果 `limit <= 0`：regex 將盡可能套用多次，而產生的陣列可以是任何大小。
## 範例
在此範例中，SPLIT 函數會在遇到字元 `'A'`、 `'B'`或 `'C'`（如規則表達式模式 所指定） `'oneAtwoBthreeC'`時分割輸入字串`'[ABC]'`。產生的輸出是四個元素的陣列：`"one"`、`"three"`、 `"two"`和空字串 `""`。
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# 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
```
# SUBSTRING 函數
根據指定的開始位置傳回字串的子集。
如果輸入是字串，則提取的開始位置和字元數是以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。如果輸入是二進位運算式，則開始位置和提取的子字串是以位元組為基礎。您不能指定負長度，但可以指定負的開始位置。
## 語法
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## 引數
*特徵化*
供進行搜尋的字串。非字元資料類型視為字串。
*start\$1position*
在字串內要開始擷取的位置，從 1 開始。*start\$1position* 以字元數為基礎，而不是位元組，所以多位元組字元視為單一字元。這可以是負數。
*numbecharacters*
要擷取的字元數 (子字串的長度)。*numbecharacters* 是根據字元數而非位元組數，因此多位元組字元會計為單一字元。這不能是負數。
*start\$1byte*
在二進位運算式內要開始擷取的位置，從 1 開始。這可以是負數。
*numbebyte*
要擷取的位元組數，即子字串的長度。此數字不可以是負數。
## 傳回類型
VARCHAR
## 字元字串的使用備註
下列範例傳回從第六個字元開始的四個字元的字串。
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
如果 *start\$1position* \$1 *numbecharacters* 超過*字串*的長度，SUBSTRING 會從 *start\$1position* 傳回子字串，直到字串結束。例如：
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
如果 `start_position` 是負數或 0，SUBSTRING 函數會傳回從字串第一個字元開始且長度為 `start_position` \$1 `numbecharacters` -1 的子字串。例如：
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
如果 `start_position` \$1 `numbecharacters` -1 小於或等於零，SUBSTRING 會傳回空字串。例如：
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## 範例
下列範例從 LISTING 資料表的 LISTTIME 字串中傳回月份：
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
下列範例同上，但使用 FROM...FOR 選項：
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
如果字串可能包含雙位元組字元，則您無法使用 SUBSTRING 來肯定地擷取字串的字首，因為您需要根據位元組數來指定雙位元組字串的長度，而不是字元數。若要根據位元組長度來擷取字串的開頭部分，您可以將字串 CAST 成為 VARCHAR(*byte\$1length*) 以截斷字串，其中 *byte\$1length* 是所需的長度。下列範例從 `'Fourscore and seven'` 字串中擷取前 5 個位元組。
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
下列範例會傳回輸入字串 `Silva, Ana` 中最後一個空格之後出現的名字 `Ana`。
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# TRANSLATE 函數
對於給定的表達式，以指定的替換值取代所有出現的指定字元。現有字元依位置映射至 *characters\$1to\$1replace* 和 *characters\$1to\$1substitute* 引數中的替換字元。如果 *characters\$1to\$1replace* 引數中指定的字元數比 *characters\$1to\$1substitute* 引數更多，傳回值中會省略 *characters\$1to\$1replace* 引數中額外的字元。
TRANSLATE 類似於 [REPLACE 函數](REPLACE.md) 和 [REGEXP\$1REPLACE 函數](REGEXP_REPLACE.md)，但 REPLACE 會將一整個字串替換成另一個字串，REGEXP\$1REPLACE 可讓您在字串中搜尋規則表達式模式，而 TRANSLATE 會進行多次單一字元替換。
如果任何引數為 Null，則傳回值為 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
```
下列範例對某欄的所有值，以點取代 at 符號 (@)：
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
下列範例對某欄的所有值，以點底線取代空格並剔除點：
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# TRIM 函數
修剪字串，包括移除開頭和結尾空格，或移除符合選用指定字串的字元。
## 語法
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## 引數
*trim\$1chars*
(選用) 要從字串中修剪的字元。如果省略此參數，則會修剪空格。
*string*
要修剪的字串。
## 傳回類型
TRIM 函數傳回 VARCHAR 或 CHAR 字串。如果您搭配 SQL 命令使用 TRIM 函數， 會 AWS Clean Rooms 隱含地將結果轉換為 VARCHAR。如果您在 SQL 函數的 SELECT 清單中使用 TRIM 函數， AWS Clean Rooms 不會隱含地轉換結果，而且您可能需要執行明確轉換，以避免資料類型不相符錯誤。如需明確轉換的相關資訊，請參閱 [CAST 函數](CAST_function.md)函數。
## 範例
下列範例從字串 `' abc '` 中修剪開頭和結尾空格：
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
下列範例會移除字串 周圍的雙引號`"dog"`：
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
當任何字元出現在*字串*開頭時，TRIM 會移除 *trim\$1chars* 中的任何字元。下列範例修剪 VENUENAME (這是 VARCHAR 欄) 開頭出現的 'C'、'D' 和 'G' 字元。
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# UPPER 函數
將字串轉換成大寫。UPPER 支援 UTF-8 多位元組字元，每個字元最多 4 個位元組。
## 語法
```
UPPER(string)
```
## 引數
*string*
輸入參數是 VARCHAR 字串 （或任何其他資料類型，例如 CHAR，可隱含轉換為 VARCHAR)。
## 傳回類型
UPPER 函數傳回與輸入字串的資料類型相同的字元字串。
## 範例
下列範例將 CATNAME 欄位轉換為大寫：
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# UUID 函數
UUID 函數會產生全域唯一識別符 (UUID)。
UUIDs是全域唯一識別符，通常用於為各種目的提供唯一識別符，例如：
+ 識別資料庫記錄或其他資料實體。
+ 產生檔案、目錄或其他資源的唯一名稱或金鑰。
+ 跨分散式系統追蹤和關聯資料。
+ 為網路封包、軟體元件或其他數位資產提供唯一識別符。
UUID 函數會產生具有極高機率的唯一 UUID 值，即使在分散式系統和長時間內也是如此。UUIDs通常使用目前時間戳記、電腦網路地址和其他隨機或虛擬隨機資料的組合產生，以確保每個產生的 UUID 都非常不可能與任何其他 UUID 衝突。
在 SQL 查詢的內容中，UUID 函數可用來為插入資料庫的新記錄產生唯一識別符，或為資料分割、索引或其他需要唯一識別符的目的提供唯一索引鍵。
**注意**
UUID 函數是非確定性的。
## 語法
```
uuid()
```
## 引數
UUID 函數不採用任何引數。
## 傳回類型
UUID 傳回通用唯一識別符 (UUID) 字串。值會以正式 UUID 36 字元字串傳回。
## 範例
下列範例會產生通用唯一識別符 (UUID)。輸出是代表全域唯一識別符的 36 個字元字串。
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```