翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# 文字列関数
文字列関数は、文字列、または文字列に評価される式を処理します。これらの関数の *string* 引数がリテラル値である場合は、その値を一重引用符で囲む必要があります。サポートされるデータ型には、CHAR や VARCHAR があります。
次のセクションでは、サポートされる関数の関数名と構文を示し、それらについて説明します。文字列のオフセットはすべて 1 から始まります。
**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 記号の両側の 2 つの表現を連結し、その結果の表現を返します。
連結演算子は [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 関数は、2 つの式を連結し、結果の表現を返します。3 つ以上の式を連結するには、CONCAT 関数をネストして使用します。2 つの式の間に連結演算子 (`||`) を指定した場合も、CONCAT 関数と同じ結果が返されます。
**注記**
CONCAT 関数ならびに連結演算子のどちらにおいても、一方または両方の表現が null である場合は、連結の結果も null になります。
## 構文
```
CONCAT ( expression1, expression2 )
```
## 引数
*expression1*, *expression2*
どちらの引数にも、固定長文字列、可変長文字列、バイナリ式、またはこれらの入力のいずれかとして評価される式を指定できます。
## 戻り型
CONCAT は式を返します。式のデータ型は、入力引数の型と同じです。
入力式が異なる型である場合、 は暗黙的に型をキャスト AWS Clean Rooms しようとします。値を型キャストできない場合は、エラーが返されます。
## 例
次の例では、2 つの文字リテラルを連結します。
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
次のクエリでは、CONCAT ではなく `||` 演算子を使用しており、同じ結果が返されます。
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
次の例では、2 つの CONCAT 関数を使用して、3 つの文字列を連結します。
```
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 を返します。
## 例
次の例には、2 つのプレースホルダーを含むテンプレート文字列が含まれています。10 進数 (整数) 値`%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 関数
これらの関数は、文字列の左端または右端にある指定数の文字を返します。
number はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。
## 構文
```
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 マルチバイト文字に対応しています (1 文字につき最大で 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*
文字列、または文字列に評価される式 (文字列の列名など)。
*length*
関数の結果の長さを定義する整数。文字列の長さはバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。指定された長さより *string1* が長い場合は、(右側が) 切り捨てられます。*length* が負の数値である場合は、関数の結果が空の文字列になります。
*string2*
*string1* の前または後に付加する 1 つ以上の文字。この引数はオプションです。指定されなかった場合は、スペースが使用されます。
## 戻り型
これらの関数は VARCHAR データ型を返します。
## 例
指定された一連のイベント名を切り捨てて 20 文字にします。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 文字にします。ただし、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*
*文字列*の先頭からトリミングする文字を表す、文字列の列、式、または文字列リテラル。指定しなかった場合、スペースがトリム文字として使用されます。
## 戻り型
LTRIM 関数は、入力*文字列*のデータ型 (CHAR または VARCHAR) と同じデータ型の文字列を返します。
## 例
次の例は、`listime` 列から年をトリミングします。文字列リテラル `'2008-'` のトリム文字は、左からトリミングされる文字を示します。トリム文字 `'028-'` を使用した場合も、同じ結果が得られます。
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM は、*文字列*の先頭にあるとき、*trim\$1chars* の文字をすべて削除します。次の例は、文字 'C'、'D'、および 'G' が VENUENAME の先頭にある場合 (VARCHAR 列) 、これらの文字を切り捨てます。
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
次の例では、`venueid` 列から取得されたしたトリム文字 `2` を使用します。
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
次の例では、`2` が `'0'` トリム文字の前にあるため、文字はトリミングされません。
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
次の例では、デフォルトのスペーストリム文字を使用して、文字列の先頭から 2 つのスペースをトリミングします。
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# POSITION 関数
文字列内の指定されたサブ文字列の位置を返します。
## 構文
```
POSITION(substring IN string )
```
## 引数
*substring*
*string* 内を検索するサブ文字列。
*string*
検索する文字列または列。
## 戻り型
POSITION 関数は、サブ文字列の位置 (0 ではなく 1 から始まる) に対応する整数を返します。位置はバイト数ではなく文字数に基づくため、マルチバイト文字は 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* 内の位置を示す正の整数。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは 1 です。*position* が 1 より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は 0 になります。
*パラメータ*
関数がパターンと一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。
## 戻り型
整数
## 例
次の例は、3 文字のシーケンスが出現する回数をカウントします。
```
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 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、大文字と小文字を区別して、このような単語の出現回数をカウントします。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。これは、PCRE で特定の意味を持つ `?=` 演算子を使用します。この例では、このような単語の出現回数をカウントしますが、大文字と小文字を区別しない一致結果を使用する点で前の例とは異なります。
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# REGEXP\$1INSTR 関数
文字列で正規表現パターンを検索し、一致するサブ文字列の開始位置を示す整数を返します。一致がない場合、この関数は 0 を返します。REGEXP\$1INSTR は [ 関数に似ていますが、文字列で正規表現パターンを検索することができます。](POSITION.md)
## 構文
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 引数
*source\$1string*
検索する文字列式 (列名など)。
*pattern*
正規表現パターンを表す文字列リテラル。
*position*
検索を開始する *source\$1string* 内の位置を示す正の整数。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは 1 です。*position* が 1 より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は 0 になります。
*occurrence*
このパターンのどの出現を使用するかを示す正の整数。REGEXP\$1INSTR は、最初の*出現* - 1 一致をスキップします。デフォルトは 1 です。*出現*が 1 未満、または*ソース文字列*の文字数以上の場合、検索は無視され、結果は 0 となります。
*option*
一致の先頭文字の戻り位置 (`0`)、あるいは続く一致の後尾の最初の文字位置 (`1`) のどちらかを示す値。ゼロ以外の値は 1 と同じです。デフォルト値は 0 です。
*パラメータ*
関数がパターンと一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ e – 部分式を使用して部分文字列を抽出します。
*パターン*に部分式が含まれる場合、REGEXP\$1INSTR は最初の部分式を*パターン*で使用して部分文字列を一致させます。REGEXP\$1INSTR は最初の部分式のみを考慮します。追加の部分式は無視されます。パターンに部分式がない場合、REGEXP\$1INSTR は「e」パラメータを無視します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。
## 戻り型
整数
## 例
次の例は、ドメイン名を開始する `@` 文字を検索し、最初の一致の開始位置を返します。
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
次の例は、`Center`という単語のバリエーションを検索し、最初の一致の開始位置を返します。
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
次の例は、大文字と小文字を区別しない一致ロジックを使用して、文字列 `FOX` が最初に出現する開始位置を検索します。
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、2 番目の単語の開始位置を見つけます。
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、2 番目の単語の開始位置を検索しますが、大文字と小文字を区別しない一致結果を使用する点で前の例とは異なります。
```
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 は 1 つの文字列全体を別の文字列に置換しますが、REGEXP\$1REPLACE を使用すると正規表現パターンの文字列を検索できます。
## 構文
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 引数
*source\$1string*
検索する文字列式 (列名など)。
*pattern*
正規表現パターンを表す文字列リテラル。
*replace\$1string*
パターンのすべての出現に置き換わる列名などの文字列式。デフォルトは空の文字列 ("") です。
*position*
検索を開始する *source\$1string* 内の位置を示す正の整数。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは 1 です。*position* が 1 より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は *source\$1string* になります。
*パラメータ*
関数がパターンと一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ 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
```
次の例は、E メールアドレスのドメイン名を値 `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 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、そのような単語が出現するたびに値 `[hidden]` に置き換えられます。
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。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 文字としてカウントされます。デフォルトは 1 です。*position* が 1 より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は空の文字列 ("") になります。
*occurrence*
このパターンのどの出現を使用するかを示す正の整数。REGEXP\$1SUBSTR は、最初の*出現* - 1 一致をスキップします。デフォルトは 1 です。*出現*が 1 未満、または*ソース文字列*の文字数以上の場合、検索は無視され、結果は NULL となります。
*パラメータ*
関数がパターンと一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ e – 部分式を使用して部分文字列を抽出します。
*パターン*に部分式が含まれる場合、REGEXP\$1SUBSTR は最初の部分式を*パターン*で使用して部分文字列を一致させます。部分式は、かっこで囲まれたパターン内の式です。例えば、`'This is a (\\w+)'` というパターンでは、最初の式と `'This is a '` という文字列とそれに続く単語が一致します。`e` パラメータを指定した REGEXP\$1SUBSTR は、*パターン*を返す代わりに、部分式の中の文字列だけを返します。
REGEXP\$1SUBSTR は最初の部分式のみを考慮します。追加の部分式は無視されます。パターンに部分式がない場合、REGEXP\$1SUBSTR は「e」パラメータを無視します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。
## 戻り型
VARCHAR
## 例
次の例では、メールアドレスの @ 文字とドメイン拡張の間の分が返されます。
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
次の例は、大文字と小文字を区別しない一致を使用して、文字列 `FOX` の最初の出現に対応する入力の部分を返します。
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
次の例では、小文字で始まる入力の最初の部分を返します。これは、同じ SELECT ステートメントで `c` パラメータを指定しない場合と機能的には同じです。
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、2 番目の単語に対応する入力部分を返します。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
次の例では、PCRE 言語で記述されたパターンを使用して、少なくとも 1 つの数字と 1 つの小文字を含む単語を検索します。PCRE で特定の先読みの意味を持つ `?=` 演算子を使用します。この例では、2 番目の単語に対応する入力部分を返しますが、大文字と小文字を区別しない一致結果を使用する点で前の例とは異なります。
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
次の例では、部分式を使用して、大文字と小文字を区別しないマッチングにより、パターン `'this is a (\\w+)'` と一致する 2 番目の文字列を見つけます。かっこ内の部分式を返します。
```
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*
2 番目のパラメータは、文字列を繰り返す回数を示す整数です。
## 戻り型
REPEAT 関数は文字列を返します。
## 例
次の例では、CATEGORY テーブル内の CATID 列の値を 3 回繰り返します。
```
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 は 1 つの文字列全体を別の文字列に置換します。
## 構文
```
REPLACE(string1, old_chars, new_chars)
```
## 引数
*string*
検索する CHAR 型または VARCHAR 型の文字列。
*old\$1chars*
置き換える CHAR 型または VARCHAR 型の文字列。
*new\$1chars*
*old\$1string* を置き換える新しい CHAR 型または VARCHAR 型の文字列。
## 戻り型
VARCHAR
*old\$1chars* または *new\$1chars* のいずれかが NULL の場合、戻り値は NULL です。
## 例
次の例では、CATGROUP フィールド内の文字列 `Shows` を `Theatre` に変換します。
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# REVERSE 関数
REVERSE 関数は、文字列に対して機能し、文字を逆順に返します。たとえば、`reverse('abcde')`は `edcba` を返します。この関数は、数値データ型と日付データ型に加え、文字データ型に対しても機能します。ただしほとんどの場合、文字列に対して実用的な値が生成されます。
## 構文
```
REVERSE ( expression )
```
## 引数
*expression*
文字反転のターゲットを表す文字、日付、タイムスタンプ、または数値のデータ型を使用した式。すべての式は、可変長文字列に暗黙的に変換されます。固定幅文字列の末尾の空白は無視されます。
## 戻り型
REVERSE は VARCHAR を返します。
## 例
USERS テーブルから、5 つの異なる都市名およびそれらに対応する反転した名前を選択します。
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
文字列として変換された 5 つの販売 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* 引数と同じデータ型の文字列。
## 例
次の例では、文字列 `' 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
```
次の例は、文字 'Park' が存在する VENUENAME の末尾から、これらの文字を切り捨てます。
```
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
```
RTRIM は、文字 `P`、`a`、`r`、または `k` が VENUENAME の末尾にあるとき、それらをすべて削除することに注意してください。
# SPLIT 関数
SPLIT 関数を使用すると、より大きな文字列から部分文字列を抽出し、配列として使用できます。SPLIT 関数は、特定の区切り文字またはパターンに基づいて文字列を個々のコンポーネントに分割する必要がある場合に便利です。
## 構文
```
split(str, regex, limit)
```
## 引数
*str*
分割する文字列式。
*[正規表現]*
正規表現を表す文字列。*正規表現*文字列は Java 正規表現である必要があります。
*制限*
*正規表現*が適用される回数を制御する整数式。
+ limit > 0: 結果の配列の長さは制限を超えず、結果の配列の最後のエントリには、最後に一致した*正規表現*を超えるすべての入力が含まれます。
+ limit <= 0: *正規表現*は可能な限り複数回適用され、結果の配列は任意のサイズにすることができます。
## 戻り型
SPLIT 関数は ARRAY を返します。
の場合`limit > 0`: 結果の配列の長さは制限を超えず、結果の配列の最後のエントリには、最後に一致した正規表現を超えるすべての入力が含まれます。
の場合`limit <= 0`: 正規表現は可能な限り複数回適用され、結果の配列は任意のサイズにすることができます。
## 例
この例では、SPLIT 関数は、文字 `'A'`、、`'B'`または `'C'` (正規表現パターン で指定) に遭遇する`'oneAtwoBthreeC'`場所に入力文字列を分割します`'[ABC]'`。結果の出力は、`"one"`、、`"two"`、`"three"`および空の文字列 の 4 つの要素の配列です`""`。
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# SPLIT\$1PART 関数
指定された区切り記号で文字列を分割し、指定された位置にあるパートを返します。
## 構文
```
SPLIT_PART(string, delimiter, position)
```
## 引数
*string*
分割する文字列の列、式、または文字列リテラル。文字列には CHAR 型または VARCHAR 型を指定できます。
*delimiter*
入力*文字列*のセクションを示す区切り文字列。
*delimiter* がリテラルである場合は、それを一重引用符で囲みます。
*position*
返す*文字列*の部分の位置 (1 からカウント)。1 以上の整数である必要があります。*位置*が文字列の部分の数より大きい場合、SPLIT\$1PART は空の文字列を返します。*文字列*で*区切り文字*が見つからない場合、戻り値には指定された部分の内容が含まれます。これは、*文字列*全体または空の値である可能性があります。
## 戻り型
CHAR 文字列または VARCHAR 文字列 (*文字列*パラメータと同じ型)。
## 例
次の例では、`$` 区切り文字を使用して文字列リテラルを複数の部分に分割し、2 番目の部分を返します。
```
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 文字列の 2 番目の部分) を取得してから、各月のエントリ数をカウントします。
```
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 関数
文字列内で、指定された開始位置からの文字列のサブセットを返します。
入力が文字列の場合、抽出される文字の開始位置および文字数はバイト数ではなく文字数に基づきます。つまり、マルチバイト文字は 1 文字としてカウントされます。入力がバイナリ式の場合、開始位置と抽出される部分文字列はバイト数に基づきます。負の長さを指定することはできませんが、開始位置を負に指定することは可能です。
## 構文
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## 引数
*charactestring*
検索する文字列。文字データ型以外のデータ型は、文字列のように扱われます。
*start\$1position*
文字列内で抽出を開始する位置 (1 から始まる)。*start\$1position* はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。負の数を指定することもできます。
*numbecharacters*
抽出する文字の数 (サブ文字列の長さ)。*数値文字*はバイト数ではなく文字数に基づいているため、マルチバイト文字は 1 文字としてカウントされます。負の数を指定することはできません。
*start\$1byte*
バイナリ表現内の抽出を開始する (先頭を 1 とする) 位置。負の数を指定することもできます。
*numbebytes*
抽出するバイト数 (サブ文字列の長さ)。負の数を指定することはできません。
## 戻り型
VARCHAR
## 文字列の使用に関する注意事項
次の例では、6 番目の文字で始まる 4 文字の文字列を返します。
```
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 が 0 以下である場合、SUBSTRING は空の文字列を返します。次に例を示します。
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## 例
次の例は、LISTING テーブル内の LISTTIME 文字列から月を返します。
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
次の例は上記と同じですが、FROM...FOR オプションを使用します。
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
文字列にマルチバイト文字が含まれる可能性がある場合、SUBSTRING を使用して文字列の先頭部分を期待どおりに抽出することはできません。これは、マルチバイト文字列の長さを、文字数ではなくバイト数に基づいて指定する必要があるためです。バイト数での長さに基づいて文字列の最初のセグメントを取得するためには、文字列を VARCHAR(*byte\$1length*) として CAST することで文字列を切り捨てます。このとき、*byte\$1length* は必要な長さとなります。次の例では、文字列 `'Fourscore and seven'` から最初の 5 バイトを抽出します。
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
次の例では、入力文字列 `Ana` の最後のスペースの後に表示される最初の名前 `Silva, 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 は 1 つの文字列全体を別の文字列に置換し、REGEXP\$1REPLACE を使用すると正規表現パターンの文字列を検索できますが、TRANSLATE は複数の単一文字置換を行います。
いずれかの引数が null である場合、戻り値は NULL になります。
## 構文
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## 引数
*expression*
変換する式。
*characters\$1to\$1replace*
置換する文字を含む文字列。
*characters\$1to\$1substitute*
代入する文字を含む文字列。
## 戻り型
VARCHAR
## 例
以下の例では、文字列内の複数の文字が置換されます。
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
次の例では、列内のすべての値のアットマーク (@) がピリオドに置き換えられます。
```
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 関数を使用する場合、 は結果を VARCHAR に AWS Clean Rooms 暗黙的に変換します。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
```
LTRIM は、*文字列*の先頭にあるとき、*trim\$1chars* の文字をすべて削除します。次の例は、文字 'C'、'D'、および 'G' が VENUENAME の先頭にある場合 (VARCHAR 列) 、これらの文字を切り捨てます。
```
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 マルチバイト文字に対応しています (1 文字につき最大で 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 関数は、Universally Unique Identifier (UUID) を生成します。
UUIDsはグローバルに一意の識別子であり、次のようなさまざまな目的で一意の識別子を提供するために一般的に使用されます。
+ データベースレコードまたはその他のデータエンティティの識別。
+ ファイル、ディレクトリ、またはその他のリソースの一意の名前またはキーを生成します。
+ 分散システム全体のデータを追跡し、関連付けます。
+ ネットワークパケット、ソフトウェアコンポーネント、またはその他のデジタルアセットに一意の識別子を提供します。
UUID 関数は、分散システム間および長期間にわたっても、非常に高い確率で一意の UUID 値を生成します。UUIDsは通常、現在のタイムスタンプ、コンピュータのネットワークアドレス、およびその他のランダムまたは擬似ランダムデータの組み合わせを使用して生成され、生成された各 UUID が他の UUID と競合する可能性はほとんどありません。
SQL クエリのコンテキストでは、UUID 関数を使用して、データベースに挿入される新しいレコードの一意の識別子を生成したり、データのパーティショニング、インデックス作成、または一意の識別子が必要なその他の目的で一意のキーを提供したりできます。
**注記**
UUID 関数は非決定的です。
## 構文
```
uuid()
```
## 引数
UUID 関数は引数を取りません。
## 戻り型
UUID は、ユニバーサル一意識別子 (UUID) 文字列を返します。値は正規 UUID 36 文字の文字列として返されます。
## 例
次の例では、Universally Unique Identifier (UUID) を生成します。出力は、Universally Unique Identifier を表す 36 文字の文字列です。
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```