Amazon Redshift は、パッチ 198 以降、新しい Python UDF の作成をサポートしなくなります。既存の Python UDF は、2026 年 6 月 30 日まで引き続き機能します。詳細については、[ブログ記事](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)を参照してください。
# 文字列関数
**Topics**
+ [\$1\$1 (連結）演算子](r_concat_op.md)
+ [ASCII 関数](r_ASCII.md)
+ [BPCHARCMP 関数](r_BPCHARCMP.md)
+ [BTRIM 関数](r_BTRIM.md)
+ [BTTEXT\$1PATTERN\$1CMP 関数](r_BTTEXT_PATTERN_CMP.md)
+ [CHAR\$1LENGTH 関数](r_CHAR_LENGTH.md)
+ [CHARACTER\$1LENGTH 関数](r_CHARACTER_LENGTH.md)
+ [CHARINDEX 関数](r_CHARINDEX.md)
+ [CHR 関数](r_CHR.md)
+ [COLLATE 関数](r_COLLATE.md)
+ [CONCAT 関数](r_CONCAT.md)
+ [CRC32 関数](crc32-function.md)
+ [DIFFERENCE 関数](DIFFERENCE.md)
+ [INITCAP 関数](r_INITCAP.md)
+ [LEFT 関数および RIGHT 関数](r_LEFT.md)
+ [LEN 関数](r_LEN.md)
+ [LENGTH 関数](r_LENGTH.md)
+ [LOWER 関数](r_LOWER.md)
+ [LPAD 関数および RPAD 関数](r_LPAD.md)
+ [LTRIM 関数](r_LTRIM.md)
+ [OCTETINDEX 関数](OCTETINDEX.md)
+ [OCTET\$1LENGTH 関数](r_OCTET_LENGTH.md)
+ [POSITION 関数](r_POSITION.md)
+ [QUOTE\$1IDENT 関数](r_QUOTE_IDENT.md)
+ [QUOTE\$1LITERAL 関数](r_QUOTE_LITERAL.md)
+ [REGEXP\$1COUNT 関数](REGEXP_COUNT.md)
+ [REGEXP\$1INSTR 関数](REGEXP_INSTR.md)
+ [REGEXP\$1REPLACE 関数](REGEXP_REPLACE.md)
+ [REGEXP\$1SUBSTR 関数](REGEXP_SUBSTR.md)
+ [REPEAT 関数](r_REPEAT.md)
+ [REPLACE 関数](r_REPLACE.md)
+ [REPLICATE 関数](r_REPLICATE.md)
+ [REVERSE 関数](r_REVERSE.md)
+ [RTRIM 関数](r_RTRIM.md)
+ [SOUNDEX 関数](SOUNDEX.md)
+ [SPLIT\$1PART 関数](SPLIT_PART.md)
+ [STRPOS 関数](r_STRPOS.md)
+ [STRTOL 関数](r_STRTOL.md)
+ [SUBSTRING 関数](r_SUBSTRING.md)
+ [TEXTLEN 関数](r_TEXTLEN.md)
+ [TRANSLATE 関数](r_TRANSLATE.md)
+ [TRIM 関数](r_TRIM.md)
+ [UPPER 関数](r_UPPER.md)
文字列関数は、文字列、または文字列に評価される式を処理します。これらの関数の *string* 引数がリテラル値である場合は、その値を一重引用符で囲む必要があります。サポートされるデータ型には、CHAR や VARCHAR があります。
次のセクションでは、サポートされる関数の関数名と構文を示し、それらについて説明します。文字列のオフセットはすべて 1 から始まります。
**廃止されたリーダーノード専用の関数**
次の文字列関数は、リーダーノードのみで実行されるため、非推奨となりました。詳細については、「[リーダーノード専用関数](c_SQL_functions_leader_node_only.md)」を参照してください。
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# \$1\$1 (連結）演算子
`||` 記号の両側にある 2 つの式を連結し、連結した式を返します。
[CONCAT 関数](r_CONCAT.md) と同様です。
**注記**
一方または両方の式が null の場合、連結の結果は `NULL` になります。
## 構文
```
expression1 || expression2
```
## 引数
*expression1*
`CHAR` 文字列、`VARCHAR` 文字列、バイナリ式、またはこれらの型のいずれかに評価される式。
*expression2*
`CHAR` 文字列、`VARCHAR` 文字列、バイナリ式、またはこれらの型のいずれかに評価される式。
## 戻り型
文字列の戻り型は、入力引数の型と同じです。例えば、`VARCHAR` 型の 2 つの文字列を連結すると、`VARCHAR` 型の文字列が返されます。
## 例
以下の例では、TICKIT サンプルデータベースの USERS テーブルと VENUE テーブルを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
サンプルデータベースで USERS テーブルの FIRSTNAME フィールドと LASTNAME フィールドを連結するには、次の例を使用します。
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Null を含む可能性がある列を連結するには、[NVL および COALESCE 関数](r_NVL_function.md)式を使用します。次の例は、NVL を使用して、`NULL` が発生するたびに `0` を返します。
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
FROM venue
WHERE venuestate = 'NV' or venuestate = 'NC'
ORDER BY 1
LIMIT 10;
+-------------------------------------+
| seating |
+-------------------------------------+
| Ballys Hotel seats 0 |
| Bank of America Stadium seats 73298 |
| Bellagio Hotel seats 0 |
| Caesars Palace seats 0 |
| Harrahs Hotel seats 0 |
| Hilton Hotel seats 0 |
| Luxor Hotel seats 0 |
| Mandalay Bay Hotel seats 0 |
| Mirage Hotel seats 0 |
| New York New York seats 0 |
+-------------------------------------+
```
# ASCII 関数
ASCII 関数は、指定した文字列の最初の文字の ASCII コード、または Unicode コードポイントを返します。文字列が空の場合、関数は `0` を返します。文字列が null の場合は、`NULL` を返します。
## 構文
```
ASCII('string')
```
## 引数
*string*
`CHAR` 文字列または `VARCHAR` 文字列。
## 戻り型
INTEGER
## 例
`NULL` を返すには、次の例を使用します。2 つの引数が同じである場合、NULLIF 関数は `NULL` を返し、ASCII 関数の入力引数は `NULL` になります。詳細については、「[NULLIF 関数](r_NULLIF_function.md)」を参照してください。
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
ASCII コード 0 を返すには、次の例を使用します。
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
amazon という単語の 1 文字目の ASCII コード 97 を返すには、次の例を使用します。
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Amazon という単語の 1 文字目の ASCII コード 65 を返すには、次の例を使用します。
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# BPCHARCMP 関数
2 つの文字列の値を比較し、整数を返します。文字列が同じである場合、関数は `0` を返します。1 番目の文字列がアルファベット順でより大きい場合、関数は `1` を返します。2 番目の文字列がより大きい場合、関数は `-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 テーブル内の最初の 10 個のエントリについて、ユーザーの名と姓をアルファベット順で比較し、名が姓よりアルファベット順で先になるかどうかを判別するには、次の例を使用します。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 |
+--------+-----------+-----------+-----------+
```
この関数が `0` を返す、USERS テーブル内のすべてのエントリを返すには、次の例を使用します。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 関数は、サブ文字列の位置 (0 ではなく 1 から始まる) に対応する `INTEGER` を返します。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。文字列内でサブ文字列が見つからなかった場合、CHARINDEX は `0` を返します。
## 例
`dog` という語の中での文字列 `fish` の位置を返すには、次の例を使用します。
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
`dogfish` という語の中での文字列 `fish` の位置を返すには、次の例を使用します。
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
以下の例は、TICKIT サンプルデータベースの SALES テーブルを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
SALES テーブル内でコミッションが 999.00 を上回る販売取引の数を返すには、次の例を使用します。このコマンドは、999.00 を超えるコミッションをカウントします。これは、小数点以下の桁数がコミッション値の先頭から 4 桁より大きいかどうかを調べることでカウントされます。
```
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)
```
## 引数
*数値*
入力パラメータは、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` になります。2 番目のクエリは `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` になります。2 番目のクエリは `john` のみを返します。
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# CONCAT 関数
CONCAT 関数は、2 つの式を連結し、結果の表現を返します。3 つ以上の式を連結するには、CONCAT 関数をネストして使用します。2 つの式の間に連結演算子 (`||`) を指定した場合も、CONCAT 関数と同じ結果が返されます。
## 構文
```
CONCAT ( expression1, expression2 )
```
## 引数
*expression1*, *expression2*
どちらの引数にも、固定長文字列、可変長文字列、バイナリ式、またはこれらの入力のいずれかとして評価される式を指定できます。
## 戻り型
CONCAT は式を返します。式のデータ型は、入力引数の型と同じです。
入力式の型が異なる場合、Amazon Redshift はそれらの式の 1 つを暗黙的に型キャストしようとします。値を型キャストできない場合は、エラーが返されます。
## 使用に関する注意事項
+ CONCAT 関数ならびに連結演算子のどちらにおいても、一方または両方の表現が null である場合は、連結の結果も null になります。
## 例
次の例では、2 つの文字リテラルを連結します。
```
SELECT CONCAT('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
次のクエリでは、CONCAT ではなく `||` 演算子を使用しており、同じ結果が返されます。
```
SELECT 'December 25, '||'2008';
?column?
-------------------
December 25, 2008
(1 row)
```
次の例では、ネストされた CONCAT 関数を別の CONCAT 関数の中で使用して 3 つの文字列を連結します。
```
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)
```
次の例では、2 つのバイナリ式を連結します。ここで、`abc`は `616263` の 16 進数表現を含む 2 進数値 であり、`def`は `646566` の 16 進数表現を含む 2 進数値です。結果は、バイナリ値の 16 進数表現として自動的に出力されます。
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 関数
CRC32 はエラー検出に使用される機能です。この関数は、CRC32 アルゴリズムを使用して、ソースデータとターゲットデータの間の変更を検出します。CRC32 関数は、可変長文字列を 8 文字の文字列に変換します。この 8 文字の文字列は、32 ビットバイナリシーケンスの 16 進値をテキストで表記したものです。ソースデータとターゲットデータ間の変更を検出するには、ソースデータに CRC32 関数を使用して出力を保存します。次に、ターゲットデータに CRC32 関数を使用して、その出力をソースデータからの出力と比較します。データが変更されていない場合は出力が同じになり、データが変更されている場合は出力が異なります。
## 構文
```
CRC32(string)
```
## 引数
*string*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 型に暗黙的に評価される式。
## 戻り型
CRC32 関数は、8 文字の文字列を返します。この 8 文字の文字列は、32 ビットバイナリシーケンスの 16 進値をテキストで表記したものです。Amazon Redshift の CRC32 関数は CRC-32C の多項式に基づいています。
## 例
文字列 `Amazon Redshift` の 8 ビット値を表示するには。
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# DIFFERENCE 関数
DIFFERENCE 関数は 2 つの文字列の American Soundex コードを比較します。この関数は `INTEGER` を返し、Soundex コード間で一致する文字の数を示します。
Soundex コードは 4 文字の長さの文字列です。Soundex コードは、単語のスペルではなく発音方法を表します。例えば、`Smith` と `Smyth` は同じ Soundex コードを持ちます。
## 構文
```
DIFFERENCE(string1, string2)
```
## 引数
*string1*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 型に暗黙的に評価される式。
*string2*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 型に暗黙的に評価される式。
## 戻り型
INTEGER
DIFFERENCE 関数は、American Soundex コードで 2 つの文字列内の一致する文字の数をカウントする `INTEGER` 値 0～4 を返します。Soundex コードは 4 文字であるため、文字列の American Soundex コード値の 4 文字すべてが同じ場合、DIFFERENCE 関数は `4` を返します。2 つの文字列のうちの 1 つが空の場合、DIFFERENCE は `0` を返します。この関数は、どちらの文字列にも有効な文字が含まれていない場合、`1` を返します。DIFFERENCE 関数は、a～z および A～Z を含む、英字のアルファベットで小文字または大文字の ASCII 文字のみを変換します。DIFFERENCE 関数は、他の文字を無視します。
## 例
文字列 `%` および `@` の Soundex 値を比較するには、次の例を使用します。この関数は、どちらの文字列にも有効な文字が含まれていないため、`1` を返します。
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
`Amazon` および空の文字列の Soundex 値を比較するには、次の例を使用します。2 つの文字列のうちの 1 つが空であるため、この関数は `0` を返します。
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
文字列 `Amazon` および `Ama` の Soundex 値を比較するには、次の例を使用します。文字列の Soundex 値の 2 文字が同じであるため、この関数は `2` を返します。
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
文字列 `Amazon` および `+-*/%Amazon` の Soundex 値を比較するには、次の例を使用します。文字列の Soundex 値の 4 文字すべてが同じであるため、この関数は `4` を返します。この関数は、2 番目の文字列の無効な文字 `+-*/%` を無視することに注目してください。
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
文字列 `AC/DC` および `Ay See Dee See` の Soundex 値を比較するには、次の例を使用します。文字列の Soundex 値の 4 文字すべてが同じであるため、この関数は `4` を返します。
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# INITCAP 関数
指定された文字列内の各単語の先頭文字を大文字にします。INITCAP は、UTF-8 マルチバイト文字に対応しています (1 文字につき最大で 4 バイトまで)。
## 構文
```
INITCAP(string)
```
## 引数
*string*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 型に暗黙的に評価される式。
## 戻り型
VARCHAR
## 使用に関する注意事項
INITCAP 関数は、文字列内の各単語の先頭文字を大文字にして、2 文字目以降を小文字 (のまま) にします。そのため、単語区切り文字として機能する文字 (スペース文字以外) を理解することが重要です。*単語区切り*文字は、任意の非英数字 (句読点、記号、および制御文字を含む) です。以下の文字はすべて、単語区切り文字です。
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
タブ、改行文字、フォームフィード、ラインフィード、およびキャリッジリターンも単語区切り文字です。
## 例
次の例では、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 関数
これらの関数は、文字列の左端または右端にある指定数の文字を返します。
number はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。
## 構文
```
LEFT( string, integer )
RIGHT( string, integer )
```
## 引数
*string*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 文字列に評価される式。
* (整数*)
正の整数。
## 戻り型
VARCHAR
## 例
次の例では、TICKIT サンプルデータベースの EVENT テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
イベント ID が 1000～1005 であるイベント名の左端 5 文字および右端 5 文字を返すには、次の例を使用します。
```
SELECT eventid, eventname,
LEFT(eventname,5) AS left_5,
RIGHT(eventname,5) AS right_5
FROM event
WHERE eventid BETWEEN 1000 AND 1005
ORDER BY 1;
+---------+----------------+--------+---------+
| eventid | eventname | left_5 | right_5 |
+---------+----------------+--------+---------+
| 1000 | Gypsy | Gypsy | Gypsy |
| 1001 | Chicago | Chica | icago |
| 1002 | The King and I | The K | and I |
| 1003 | Pal Joey | Pal J | Joey |
| 1004 | Grease | Greas | rease |
| 1005 | Chicago | Chica | icago |
+---------+----------------+--------+---------+
```
# LEN 関数
指定された文字列の長さを文字列数として返します。
## 構文
LEN は [LENGTH 関数](r_LENGTH.md)、[CHAR\$1LENGTH 関数](r_CHAR_LENGTH.md)、[CHARACTER\$1LENGTH 関数](r_CHARACTER_LENGTH.md)、および [TEXTLEN 関数](r_TEXTLEN.md) のシノニムです。
```
LEN(expression)
```
## 引数
*expression*
`CHAR` 文字列、`VARCHAR` 文字列、`VARBYTE` 式、あるいは `CHAR`、`VARCHAR`、または `VARBYTE` 型に暗黙的に評価される式。
## 戻り型
INTEGER
LEN 関数は、入力文字列の文字数を示す整数を返します。
入力が文字列の場合、LEN 関数は、マルチバイト文字列のバイト数ではなく、この文字列の実際の文字数を返します。例えば、4 バイトの中国語文字を 3 つ保存するためには、`VARCHAR(12)` 列が必要です。LEN 関数は、その文字列に対して `3` を返します。文字列の長さをバイト単位で取得するには、[OCTET\$1LENGTH](r_OCTET_LENGTH.md)関数を使用します。
## 使用に関する注意事項
*式*が `CHAR` 文字列である場合、末尾のスペースはカウントされません。
*式*が `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`、末尾にスペースが 3 つある `cat `、末尾にスペースが 3 つあり、長さ 6 の `CHAR` にキャストされる `cat `、末尾にスペースが 3 つあり、長さ 6 の `VARCHAR` にキャストされる `cat ` の文字数を返すには、次の例を使用します。この関数は `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 テーブル内で最長の venue 名を 10 個返すには、次の例を使用します。
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# LENGTH 関数
LEN 関数のシノニム。
「[LEN 関数](r_LEN.md)」を参照してください。
# LOWER 関数
文字列を小文字に変換します。LOWER は、UTF-8 マルチバイト文字に対応しています (1 文字につき最大で 4 バイトまで)。
## 構文
```
LOWER(string)
```
## 引数
*string*
`VARCHAR` 型に評価される `VARCHAR` 文字列または式。
## 戻り型
string
LOWER 関数は、入力文字列と同じデータ型の文字列を返します。例えば、入力が `CHAR` 文字列の場合、この関数は `CHAR` 文字列を返します。
## 例
次の例では、TICKIT サンプルデータベースの CATEGORY テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
CATGROUP 列の文字列 `VARCHAR` を小文字に変換するには、次の例を使用します。
```
SELECT catname, LOWER(catname) FROM category ORDER BY 1,2;
+-----------+-----------+
| catname | lower |
+-----------+-----------+
| Classical | classical |
| Jazz | jazz |
| MLB | mlb |
| MLS | mls |
| Musicals | musicals |
| NBA | nba |
| NFL | nfl |
| NHL | nhl |
| Opera | opera |
| Plays | plays |
| Pop | pop |
+-----------+-----------+
```
# LPAD 関数および RPAD 関数
これらの関数は、指定された長さに基づいて、文字列の前または後に文字を付加します。
## 構文
```
LPAD(string1, length, [ string2 ])
```
```
RPAD(string1, length, [ string2 ])
```
## 引数
*string1*
`CHAR` 文字列、`VARCHAR` 文字列、あるいは `CHAR` または `VARCHAR` 型に暗黙的に評価される式。
*length*
関数の結果の長さを定義する整数。文字列の長さはバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。指定された長さより *string1* が長い場合は、(右側が) 切り捨てられます。*length* がゼロまたは負の数値である場合は、関数の結果が空の文字列になります。
*string2*
(オプション) *string1* の前または後に付加する 1 つ以上の文字。この引数が指定されなかった場合は、スペースが使用されます。
## 戻り型
VARCHAR
## 例
次の例では、TICKIT サンプルデータベースの EVENT テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
指定された一連のイベント名を切り捨てて 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 |
+-----------------------+
```
上記と同じ一連のイベント名を切り捨てて 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 |
+----------------------+
```
# 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
```
# 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` を返します。
## 例
文字列 `Amazon Redshift` のサブ文字列 `q` の位置を返すには、次の例を使用します。*substring* は *string* に含まれていないため、この例では `0` を返します。
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
文字列 `Amazon Redshift` の空のサブ文字列の位置を返すには、次の例を使用します。*substring* は空であるため、この例では `1` を返します。
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
文字列 `Amazon Redshift` のサブ文字列 `Redshift` の位置を返すには、次の例を使用します。この例では、*substring* が *string* の 8 バイト目から始まるため、`8` を返します。
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
文字列 `Amazon Redshift` のサブ文字列 `Redshift` の位置を返すには、次の例を使用します。この例では、*string* の最初の 6 文字が 2 バイト文字であるため、`21` を返します。
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# OCTET\$1LENGTH 関数
指定された文字列の長さをバイト数として返します。
## 構文
```
OCTET_LENGTH(expression)
```
## 引数
*expression*
`CHAR` 文字列、`VARCHAR` 文字列、`VARBYTE` 式、あるいは `CHAR`、`VARCHAR`、または `VARBYTE` 型に暗黙的に評価される式。
## 戻り型
INTEGER
OCTET\$1LENGTH 関数は、入力文字列のバイト数を示す整数を返します。
入力が文字列の場合、[LEN](r_LEN.md)関数は、マルチバイト文字列のバイト数ではなく、この文字列の実際の文字数を返します。例えば、4 バイトの中国語文字を 3 つ保存するためには、`VARCHAR(12)` 列が必要です。OCTET\$1LENGTH 関数はその文字の `12` を返し、LEN 関数は同じ文字列に対して `3` を返します。
## 使用に関する注意事項
*式*が `CHAR` 文字列である場合、この関数は `CHAR` 文字列の長さを返します。例えば、`CHAR(6)` 入力の出力は `CHAR(6)` です。
*式*が `VARCHAR` 文字列である場合、末尾のスペースはカウントされます。
## 例
末尾にスペースが 3 つある文字列 `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 関数は、サブ文字列の位置 (0 ではなく 1 から始まる) に対応する `INTEGER` を返します。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。文字列内のサブ文字列がない場合、POSITION は `0` を返します。
## 例
`dog` という語の中での文字列 `fish` の位置を返すには、次の例を使用します。
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
`dogfish` という語の中での文字列 `fish` の位置を返すには、次の例を使用します。
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
以下の例は、TICKIT サンプルデータベースの SALES テーブルを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
SALES テーブル内でコミッションが 999.00 を上回る販売取引の数を返すには、次の例を使用します。このコマンドは、999.00 を超えるコミッションをカウントします。これは、小数点以下の桁数がコミッション値の先頭から 4 桁より大きいかどうかを調べることでカウントされます。
```
SELECT DISTINCT POSITION('.' IN commission), COUNT (POSITION('.' IN commission))
FROM sales
WHERE POSITION('.' IN commission) > 4
GROUP BY POSITION('.' IN commission)
ORDER BY 1,2;
+-----------+-------+
| position | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# QUOTE\$1IDENT 関数
QUOTE\$1IDENT 関数は、指定された文字列の先頭と末尾を二重引用符で囲んだ文字列として返します。この関数の出力は、SQL ステートメントで識別子として使用できます。二重引用符が埋め込まれている場合、この関数は適宜これを二重化します。
QUOTE\$1IDENT は、文字列が非識別子文字あるいは小文字になってしまう場合に、有効な識別子を作成するために必要な場所のみに二重引用符を追加します。いつでも一重引用符の文字列に戻るには、[QUOTE\$1LITERAL](r_QUOTE_LITERAL.md) を使用します。
## 構文
```
QUOTE_IDENT(string)
```
## 引数
*string*
`CHAR` または `VARCHAR` 文字列。
## 戻り型
QUOTE\$1IDENT 関数は、入力 *string* と同じ型を返します。
## 例
二重引用符で囲んで文字列 `"CAT"` を返すには、次の例を使用します。
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
次の例では、TICKIT サンプルデータベースの CATEGORY テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
CATNAME 列を引用符で囲んで返すには、次の例を使用します。
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# QUOTE\$1LITERAL 関数
QUOTE\$1LITERAL 関数は、指定された文字列を一重引用符付き文字列として返します。これにより、SQL ステートメントで文字列リテラルとして使用できます。入力パラメータが数値である場合、QUOTE\$1LITERAL はそれを文字列として扱います。埋め込まれている一重引用符およびバックスラッシュは適宜、二重引用符に変更されます。
## 構文
```
QUOTE_LITERAL(string)
```
## 引数
*string*
`CHAR` または `VARCHAR` 文字列。
## 戻り型
QUOTE\$1LITERAL 関数は、入力 *string* と同じデータ型である `CHAR` または `VARCHAR` の文字列を返します。
## 例
一重引用符を付けて文字列 `''CAT''` を返すには、次の例を使用します。
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
次の例では、TICKIT サンプルデータベースの CATEGORY テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
CATNAME 列を一重引用符で囲んで返すには、次の例を使用します。
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
CATID 列を一重引用符で囲んで返すには、次の例を使用します。
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# REGEXP\$1COUNT 関数
文字列で正規表現パターンを検索し、この指定されたパターンが文字列内に出現する回数を示す整数を返します。一致がない場合、この関数は `0` を返します。正規表現の詳細については、Wikipedia の「[POSIX 演算子](pattern-matching-conditions-posix.md)」と「[正規表現](https://en.wikipedia.org/wiki/Regular_expression)」を参照してください。
## 構文
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## 引数
*source\$1string*
`CHAR` または `VARCHAR` 文字列。
* パターン*
正規表現パターンを表す UTF-8 文字列リテラル。詳細については、「[POSIX 演算子](pattern-matching-conditions-posix.md)」を参照してください。
*position*
(オプション) 検索を開始する *source\$1string* 内の位置を示す正の `INTEGER`。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは `1` です。*position* が `1` より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は `0` になります。
*parameters*
(オプション) 関数がパターンとどのように一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。PCRE の詳細については、Wikipedia の「[Perl 互換の正規表現](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)」を参照してください。
## 戻り型
INTEGER
## 例
3 文字のシーケンスが出現する回数をカウントするには、次の例を使用します。
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
大文字と小文字を区別しない一致を使用して、文字列 `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 |
+--------------+
```
次の例では、TICKIT サンプルデータベースの USERS テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
最上位ドメイン名が `org` または `edu` である回数をカウントするには、次の例を使用します。
```
SELECT email, REGEXP_COUNT(email,'@[^.]*\.(org|edu)') FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_count |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1 |
| Suspendisse.tristique@nonnisiAenean.edu | 1 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 0 |
| sed@lacusUtnec.ca | 0 |
+-----------------------------------------------+--------------+
```
# REGEXP\$1INSTR 関数
文字列で正規表現パターンを検索し、一致するサブ文字列の開始位置を示す整数を返します。一致がない場合、この関数は `0` を返します。REGEXP\$1INSTR は [ 関数に似ていますが、文字列で正規表現パターンを検索することができます。](r_POSITION.md)正規表現の詳細については、Wikipedia の「[POSIX 演算子](pattern-matching-conditions-posix.md)」と「[正規表現](https://en.wikipedia.org/wiki/Regular_expression)」を参照してください。
## 構文
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 引数
*source\$1string*
検索する文字列式 (列名など)。
* パターン*
正規表現パターンを表す UTF-8 文字列リテラル。詳細については、「[POSIX 演算子](pattern-matching-conditions-posix.md)」を参照してください。
*position*
(オプション) 検索を開始する *source\$1string* 内の位置を示す正の `INTEGER`。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは `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` です。
*parameters*
(オプション) 関数がパターンとどのように一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ e – 部分式を使用して部分文字列を抽出します。
*パターン*に部分式が含まれる場合、REGEXP\$1INSTR は最初の部分式を*パターン*で使用して部分文字列を一致させます。REGEXP\$1INSTR は最初の部分式のみを考慮します。追加の部分式は無視されます。パターンに部分式がない場合、REGEXP\$1INSTR は「e」パラメータを無視します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。PCRE の詳細については、Wikipedia の「[Perl 互換の正規表現](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)」を参照してください。
## 戻り型
整数
## 例
次の例では、TICKIT サンプルデータベースの USERS テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
ドメイン名を開始する `@` 文字を検索し、最初の一致の開始位置を返すには、次の例を使用します。
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
`Center` という単語のバリエーションを検索し、最初の一致の開始位置を返すには、次の例を使用します。
```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
+-----------------------+--------------+
| venuename | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center | 16 |
| Izod Center | 6 |
| Wachovia Center | 10 |
| Air Canada Centre | 12 |
+-----------------------+--------------+
```
大文字と小文字を区別しない一致ロジックを使用して、文字列 `FOX` が最初に出現する開始位置を検索するには、次の例を使用します。
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
PCRE 言語で記述されたパターンを使用して、少なくとも 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 関数](r_REPLACE.md) 関数に似ていますが、文字列で正規表現パターンを検索することができます。正規表現の詳細については、Wikipedia の「[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 は 1 つの文字列全体を別の文字列に置換しますが、REGEXP\$1REPLACE を使用すると正規表現パターンの文字列を検索できます。
## 構文
```
REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 引数
*source\$1string*
検索する `CHAR` または `VARCHAR` 文字列式 (列名など)。
* パターン*
正規表現パターンを表す UTF-8 文字列リテラル。詳細については、「[POSIX 演算子](pattern-matching-conditions-posix.md)」を参照してください。
*replace\$1string*
(オプション) パターンのすべての出現に置き換わる列名などの `CHAR` または `VARCHAR` 文字列式。デフォルトは空の文字列 ("") です。
*position*
(オプション) 検索を開始する *source\$1string* 内の位置を示す正の整数。position はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは `1` です。*position* が `1` より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は *source\$1string* になります。
*parameters*
(オプション) 関数がパターンとどのように一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。PCRE の詳細については、Wikipedia の「[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 言語で記述されたパターンを使用して、少なくとも 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] |
+----------------------------------+
```
次の例では、TICKIT サンプルデータベースの USERS テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
E メールアドレスから `@` とドメイン名を削除するには、次の例を使用します。
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# REGEXP\$1SUBSTR 関数
正規表現パターンで検索して、文字列から文字を返します。REGEXP\$1SUBSTR は [SUBSTRING 関数](r_SUBSTRING.md) 関数に似ていますが、文字列で正規表現パターンを検索することができます。この関数が正規表現を文字列内のどの文字とも一致させることができない場合、空の文字列を返します。正規表現の詳細については、Wikipedia の「[POSIX 演算子](pattern-matching-conditions-posix.md)」と「[正規表現](https://en.wikipedia.org/wiki/Regular_expression)」を参照してください。
## 構文
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 引数
*source\$1string*
検索する文字列式。
* パターン*
正規表現パターンを表す UTF-8 文字列リテラル。詳細については、「[POSIX 演算子](pattern-matching-conditions-posix.md)」を参照してください。
*position*
検索を開始する *source\$1string* 内の位置を示す正の整数。位置はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。デフォルトは 1 です。*position* が 1 より小さい場合、*source\$1string* の最初の文字から検索が開始されます。*position* が *source\$1string* の文字数より大きい場合、結果は空の文字列 ("") になります。
*実行*
このパターンのどの出現を使用するかを示す正の整数。REGEXP\$1SUBSTR は、最初の*出現* - 1 一致をスキップします。デフォルトは 1 です。*出現*が 1 未満、または*ソース文字列*の文字数以上の場合、検索は無視され、結果は空となります。
*パラメータ*
関数がパターンと一致するかを示す 1 つ以上のリテラル文字列。取り得る値には以下のものがあります。
+ c – 大文字と小文字を区別する一致を実行します。デフォルトでは大文字と小文字を区別するマッチングを使用します。
+ i – 大文字と小文字を区別しない一致を実行します。
+ e – 部分式を使用して部分文字列を抽出します。
*パターン*に部分式が含まれる場合、REGEXP\$1SUBSTR は最初の部分式を*パターン*で使用して部分文字列を一致させます。部分式は、かっこで囲まれたパターン内の式です。例えば、`'This is a (\\w+)'` というパターンでは、最初の式と `'This is a '` という文字列とそれに続く単語が一致します。`e` パラメータを指定した REGEXP\$1SUBSTR は、*パターン*を返す代わりに、部分式の中の文字列だけを返します。
REGEXP\$1SUBSTR は最初の部分式のみを考慮します。追加の部分式は無視されます。パターンに部分式がない場合、REGEXP\$1SUBSTR は「e」パラメータを無視します。
+ p – Perl 互換正規表現 (PCRE) 言語でパターンを解釈します。PCRE の詳細については、Wikipedia の「[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` の 2 回目の出現に対応する入力部分を返します。2 回目の出現がないため、結果は空 (非 null、長さ 0) になります。
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
次の例では、小文字で始まる入力の最初の部分を返します。これは、同じ 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 はそれを文字列として扱います。
[REPLICATE 関数](r_REPLICATE.md) のシノニム。
## 構文
```
REPEAT(string, integer)
```
## 引数
*string*
最初の入力パラメータは、繰り返す文字列です。
* (整数*)
2 番目のパラメータは、文字列を繰り返す回数を示す `INTEGER` です。
## 戻り型
VARCHAR
## 例
次の例では、TICKIT サンプルデータベースの CATEGORY テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
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 |
+-------+--------+
```
次の例は、最大 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 は 1 つの文字列全体を別の文字列に置換します。
## 構文
```
REPLACE(string, old_chars, new_chars)
```
## 引数
*string*
検索する `CHAR` 型または `VARCHAR` 型の文字列
*old\$1chars*
置き換える `CHAR` または `VARCHAR` 型の文字列。
*new\$1chars*
*old\$1string* を置き換える新しい `CHAR` 型または `VARCHAR` 型の文字列。
## 戻り型
VARCHAR
*old\$1chars* または *new\$1chars* のいずれかが `NULL` の場合、戻り値は `NULL` です。
## 例
次の例では、TICKIT サンプルデータベースの CATEGORY テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
CATGROUP フィールド内の文字列 `Shows` を `Theatre` に変換するには、次の例を使用します。
```
SELECT catid, catgroup, REPLACE(catgroup, 'Shows', 'Theatre')
FROM category
ORDER BY 1,2,3;
+-------+----------+----------+
| catid | catgroup | replace |
+-------+----------+----------+
| 1 | Sports | Sports |
| 2 | Sports | Sports |
| 3 | Sports | Sports |
| 4 | Sports | Sports |
| 5 | Sports | Sports |
| 6 | Shows | Theatre |
| 7 | Shows | Theatre |
| 8 | Shows | Theatre |
| 9 | Concerts | Concerts |
| 10 | Concerts | Concerts |
| 11 | Concerts | Concerts |
+-------+----------+----------+
```
# REPLICATE 関数
REPEAT 関数のシノニム。
「[REPEAT 関数](r_REPEAT.md)」を参照してください。
# REVERSE 関数
REVERSE 関数は、文字列に対して機能し、文字を逆順に返します。たとえば、`reverse('abcde')`は `edcba` を返します。この関数は、数値データ型と日付データ型に加え、文字データ型に対しても機能します。ただしほとんどの場合、文字列に対して実用的な値が生成されます。
## 構文
```
REVERSE( expression )
```
## 引数
*expression*
文字反転のターゲットを表す文字、日付、タイムスタンプ、または数値のデータ型を使用した式。すべての式は、暗黙的に `VARCHAR` 文字列に変換されます。`CHAR` 文字列内の末尾の空白は無視されます。
## 戻り型
VARCHAR
## 例
次の例では、TICKIT サンプルデータベースの USERS テーブルと SALES テーブルを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
USERS テーブルから、5 つの異なる都市名およびそれらに対応する反転した名前を選択するには、次の例を使用します。
```
SELECT DISTINCT city AS cityname, REVERSE(cityname)
FROM users
ORDER BY city LIMIT 5;
+----------+----------+
| cityname | reverse |
+----------+----------+
| Aberdeen | needrebA |
| Abilene | enelibA |
| Ada | adA |
| Agat | tagA |
| Agawam | mawagA |
+----------+----------+
```
文字列として変換された 5 つの販売 ID およびそれらに対応する反転した ID を選択するには、次の例を使用します。
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# RTRIM 関数
RTRIM 関数は、指定された一連の文字を文字列の末尾から切り捨てます。トリム文字リスト内の文字のみを含む最長の文字列を削除します。入力文字列にトリム文字がないときには、トリミングは完了です。
## 構文
```
RTRIM( string, trim_chars )
```
## 引数
*string*
トリミングする文字列列、式、または文字列リテラル。
*trim\$1chars*
*文字列*の末尾から切り捨てる文字を表す、文字列の列、式、または文字列リテラル。指定しなかった場合、スペースがトリム文字として使用されます。
## 戻り型
*string* 引数と同じデータ型の文字列。
## 例
次の例では、文字列 `' 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 の末尾にあるとき、それらをすべて削除することに注意してください。
# SOUNDEX 関数
SOUNDEX 関数は、入力文字列の最初の文字と、指定した文字列の英語の発音を表す音の 3 桁のエンコードで構成される American Soundex 値を返します。例えば、`Smith` と `Smyth` は同じ Soundex 値を持ちます。
## 構文
```
SOUNDEX(string)
```
## 引数
*string*
American Soundex コード値に変換する `CHAR` または `VARCHAR` 文字列を指定します。
## 戻り型
VARCHAR(4)
## 使用に関する注意事項
SOUNDEX 関数は、a～z および A～Z を含む、英字のアルファベットで小文字と大文字の ASCII 文字のみを変換します。SOUNDEX 関数は、他の文字を無視します。SOUNDEX は、スペースで区切られた複数の単語の文字列に対して、単一の Soundex 値を返します。
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX は、入力文字列に英語の文字が含まれていない場合、空の文字列を返します。
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## 例
`Amazon` の Soundex 値を返すには、次の例を使用します。
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
`smith` および `smyth` の Soundex 値を返すには、次の例を使用します。Soundex の値は同じであることに注意してください。
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# SPLIT\$1PART 関数
指定された区切り記号で文字列を分割し、指定された位置にあるパートを返します。
## 構文
```
SPLIT_PART(string, delimiter, position)
```
## 引数
*string*
分割する文字列の列、式、または文字列リテラル。文字列には CHAR 型または VARCHAR 型を指定できます。
*区切り記号*
入力*文字列*のセクションを示す区切り文字列。
*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
```
# STRPOS 関数
指定された文字列内のサブ文字列の位置を返します。
同様の関数については、「[CHARINDEX 関数](r_CHARINDEX.md)」および「[POSITION 関数](r_POSITION.md)」を参照してください。
## 構文
```
STRPOS(string, substring )
```
## 引数
*string*
最初の入力パラメータは、検索する `CHAR` または `VARCHAR` 文字列です。
*substring*
2 番目のパラメータは、*string* 内で検索するサブ文字列です。
## 戻り型
INTEGER
STRPOS 関数は、*substring* の位置に対応する `INTEGER` (0 ではなく 1 から始まる) を返します。位置はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。
## 使用に関する注意事項
*string* 内で *substring* が見つからない場合、STRPOS は `0` を返します。
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## 例
`dogfish` 内の `fish` の位置を示すには、次の例を使用します。
```
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` を返します。文字列の冒頭は任意の数の空白があっても構わず、オプションで正符号 '`+`' または負符号 '`-`' 1 個を後ろに付加して正または負を示すことができます。デフォルトは '`+`' です。*base* が `16` の場合、オプションで文字列の冒頭に '`0x`' を使用できます。
*base*
2～36 の `INTEGER`。
## 戻り型
BIGINT
*num\$1string* が null の場合、この関数は `NULL` を返します。
## 例
文字列と基数のペアを整数に変換するには、次の例を使用します。
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# SUBSTRING 関数
文字列内で、指定された開始位置からの文字列のサブセットを返します。
入力が文字列の場合、抽出される文字の開始位置および文字数はバイト数ではなく文字数に基づきます。つまり、マルチバイト文字は 1 文字としてカウントされます。入力がバイナリ式の場合、開始位置と抽出される部分文字列はバイト数に基づきます。負の長さを指定することはできませんが、開始位置を負に指定することは可能です。
## 構文
```
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* はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。負の数を指定することもできます。
*number\$1characters*
抽出する文字の数 (サブ文字列の長さ)。*number\$1characters* はバイト数ではなく文字数に基づくため、マルチバイト文字は 1 文字としてカウントされます。負の数を指定することはできません。
*binary\$1expression*
検索する VARBYTE データ型の binary\$1expression。
*start\$1byte*
バイナリ表現内の抽出を開始する (先頭を 1 とする) 位置。負の数を指定することもできます。
*number\$1bytes*
抽出するバイト数 (サブ文字列の長さ)。負の数を指定することはできません。
## 戻り型
入力に応じて、VARCHAR 型または VARBYTE 型を取ります。
## 使用に関する注意事項
以下は、*start\$1position* と *number\$1characters* を使用して文字列のさまざまな位置から部分文字列を抽出する方法の例です。
次の例では、6 番目の文字で始まる 4 文字の文字列を返します。
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*start\$1position* ＋ *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 が 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
```
次に、バイナリ値 `abc` の開始位置が負の場合の例を示します。開始位置が -3 であるため、サブ文字列はバイナリ値の先頭から抽出されます。結果は、バイナリ部分文字列の 16 進数表現として自動的に表示されます。
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
次に、バイナリ値 `abc` の開始位置が 1 の場合の例を示します。長さが指定されていないため、文字列の抽出は文字列の開始位置から末尾までを対象に行われます。結果は、バイナリ部分文字列の 16 進数表現として自動的に表示されます。
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
次に、バイナリ値 `abc` の開始位置が 3 の場合の例を示します。長さが指定されていないため、文字列の抽出は文字列の開始位置から末尾までを対象に行われます。結果は、バイナリ部分文字列の 16 進数表現として自動的に表示されます。
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
次に、バイナリ値 `abc` に対して開始位置が 2 の場合の例を示します。文字列は開始位置から位置 10 まで抽出されますが、文字列の末尾は位置 3 になります。結果は、バイナリ部分文字列の 16 進数表現として自動的に表示されます。
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
次に、バイナリ値 `abc` に対して開始位置が 2 の場合の例を示します。文字列は開始位置から 1 バイト分抽出されます。結果は、バイナリ部分文字列の 16 進数表現として自動的に表示されます。
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
次の例では、入力文字列 `Ana` の最後のスペースの後に表示される最初の名前 `Silva, 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 は 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 |
+-----------+
```
次の例では、TICKIT サンプルデータベースの USERS テーブルからのデータを使用します。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
列内のすべての値のアットマーク (@) をピリオドに置き換えるには、次の例を使用します。
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
列内のすべての値のスペースをアンダースコアに置き換え、ピリオドを削除するには、次の例を使用します。
```
SELECT city, TRANSLATE(city, ' .', '_')
FROM users
WHERE city LIKE 'Sain%' OR city LIKE 'St%'
GROUP BY city
ORDER BY city;
+----------------+---------------+
| city | translate |
+----------------+---------------+
| Saint Albans | Saint_Albans |
| Saint Cloud | Saint_Cloud |
| Saint Joseph | Saint_Joseph |
| Saint Louis | Saint_Louis |
| Saint Paul | Saint_Paul |
| St. George | St_George |
| St. Marys | St_Marys |
| St. Petersburg | St_Petersburg |
| Stafford | Stafford |
| Stamford | Stamford |
| Stanton | Stanton |
| Starkville | Starkville |
| Statesboro | Statesboro |
| Staunton | Staunton |
| Steubenville | Steubenville |
| Stevens Point | Stevens_Point |
| Stillwater | Stillwater |
| Stockton | Stockton |
| Sturgis | Sturgis |
+----------------+---------------+
```
# TRIM 関数
空白または指定した文字で文字列を切り捨てます。
## 構文
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## 引数
BOTH \$1 LEADING \$1 TRAILING
(オプション) 文字をどこから切り捨てるかを指定します。先頭と末尾の文字を削除するには BOTH を、先頭の文字のみを削除するには LEADING を、末尾の文字のみを削除するには TRAILING を使用します。このパラメータを省略すると、先頭と末尾の両方の文字が削除されます。
*trim\$1chars*
(オプション) 文字列から切り捨てられる文字。このパラメータを省略すると、空白が切り捨てられます。
*string*
切り捨てる文字列。
## 戻り型
TRIM 関数は、`VARCHAR` 型または `CHAR` 型の文字列を返します。TRIM 関数を SQL コマンドで使用すると、Amazon Redshift が結果を暗黙的に `VARCHAR` に変換します。SQL 関数の SELECT リストで TRIM 関数を使用した場合は、Amazon Redshift が結果を暗黙的に変換しないため、データ型の不一致によるエラーを回避するために、変換の明示的な実行が必要になることがあります。明示的な変換については、[CAST 関数](r_CAST_function.md)および [CONVERT 関数](r_CONVERT_function.md) 関数を参照してください。
## 例
文字列 ` dog ` の先頭および末尾の空白を切り捨てるには、次の例を使用します。
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
文字列 ` dog ` の先頭および末尾の空白を切り捨てるには、次の例を使用します。
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
文字列 `"dog"` から先頭の二重引用符を削除するには、次の例を使用します。
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
文字列 `"dog"` から末尾の二重引用符を削除するには、次の例を使用します。
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM は、*trim\$1chars* のいずれかの文字が *string* の先頭または末尾にある場合、これらの文字をすべて削除します。次の例では、文字 'C'、'D'、および 'G' が VENUENAME の先頭または末尾にある場合 (`VARCHAR` 列)、これらの文字を切り捨てます。詳細については、「[サンプルデータベース](c_sampledb.md)」を参照してください。
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T Park |
| 109 | Citizens Bank Park | itizens Bank Park |
| 102 | Comerica Park | omerica Park |
| 9 | Dick's Sporting Goods Park | ick's Sporting Goods Park |
| 97 | Fenway Park | Fenway Park |
| 112 | Great American Ball Park | reat American Ball Park |
| 114 | Miller Park | Miller Park |
+---------+----------------------------+---------------------------+
```
# UPPER 関数
文字列を大文字に変換します。UPPER は、UTF-8 マルチバイト文字に対応しています (1 文字につき最大で 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 |
+-----------+-----------+
```