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(연결) 연산자
`||` 기호의 양쪽으로 두 표현식을 연결하여 연결된 표현식을 반환합니다.
[CONCAT 함수](r_CONCAT.md)와 유사합니다.
**참고**
표현식 중 하나 또는 둘 모두가 null인 경우 연결 결과는 `NULL`입니다.
## 구문
```
expression1 || expression2
```
## 인수
*expression1*
`CHAR` 문자열, `VARCHAR` 문자열, 이진 표현식 또는 이러한 형식 중 하나로 평가되는 표현식입니다.
*expression2*
`CHAR` 문자열, `VARCHAR` 문자열, 이진 표현식 또는 이러한 형식 중 하나로 평가되는 표현식입니다.
## 반환 타입
문자열의 반환 형식은 입력 인수의 형식과 동일합니다. 두 개의 `VARCHAR` 형식의 문자열을 연결하면 `VARCHAR` 형식의 문자열이 반환됩니다.
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 및 VENUE 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
샘플 데이터베이스의 USERS 테이블에서 FIRSTNAME 및 LASTNAME 필드를 연결하려면 다음 예제를 사용합니다.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
NULL 값이 포함되었을 수도 있는 열을 연결하려면 [NVL 및 COALESCE 함수](r_NVL_function.md) 표현식을 사용해야 합니다. 다음 예제에서는 NVL을 사용하여 `NULL`이 발생할 때마다 `0`을 반환합니다.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
FROM venue
WHERE venuestate = 'NV' or venuestate = 'NC'
ORDER BY 1
LIMIT 10;
+-------------------------------------+
| seating |
+-------------------------------------+
| Ballys Hotel seats 0 |
| Bank of America Stadium seats 73298 |
| Bellagio Hotel seats 0 |
| Caesars Palace seats 0 |
| Harrahs Hotel seats 0 |
| Hilton Hotel seats 0 |
| Luxor Hotel seats 0 |
| Mandalay Bay Hotel seats 0 |
| Mirage Hotel seats 0 |
| New York New York seats 0 |
+-------------------------------------+
```
# ASCII 함수
ASCII 함수는 지정한 문자열에서 첫 번째 문자의 ASCII 코드나 유니코드 코드 포인트를 반환합니다. 이 함수는 문자열이 비어 있으면 `0`을 반환합니다. 문자열이 null이면 `NULL`을 반환합니다.
## 구문
```
ASCII('string')
```
## 인수
*문자열*()
`CHAR` 문자열 또는 `VARCHAR` 문자열입니다.
## 반환 타입
INTEGER
## 예제
`NULL`을 반환하려면 다음 예제를 사용합니다. NULLIF 함수는 두 인수가 동일한 경우 `NULL`을 반환하므로 ASCII 함수의 입력 인수는 `NULL`입니다. 자세한 내용은 [NULLIF 함수](r_NULLIF_function.md) 섹션을 참조하세요.
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
ASCII 코드 0을 반환하려면 다음 예제를 사용합니다.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
amazon이라는 단어의 첫 글자에 대한 ASCII 코드 97을 반환하려면 다음 예제를 사용합니다.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
amazon이라는 단어의 첫 글자에 대한 ASCII 코드 65를 반환하려면 다음 예제를 사용합니다.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# BPCHARCMP 함수
두 문자열의 값을 비교한 후 정수를 반환합니다. 문자열이 서로 동일한 경우에는 함수가 `0`을 반환합니다. 첫 번째 문자열이 알파벳 순으로 더 큰 경우에는 함수가 `1`을 반환합니다. 두 번째 문자열이 더 크면 함수가 `-1`을 반환합니다.
멀티바이트 문자일 때는 바이트 인코딩을 기준으로 비교합니다.
[BTTEXT\$1PATTERN\$1CMP 함수](r_BTTEXT_PATTERN_CMP.md)의 동의어입니다.
## 구문
```
BPCHARCMP(string1, string2)
```
## 인수
*string1*
`CHAR` 문자열 또는 `VARCHAR` 문자열입니다.
*string2*
`CHAR` 문자열 또는 `VARCHAR` 문자열입니다.
## 반환 타입
INTEGER
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
USERS 테이블의 처음 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 ] )
```
## 인수
*문자열*()
잘라낼 입력 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* 내에서 검색할 하위 문자열입니다.
*문자열*()
검색할 문자열 또는 열입니다.
## 반환 타입
INTEGER
CHARINDEX 함수는 하위 문자열의 위치에 해당하는 `INTEGER`를 반환합니다(0이 아닌 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 이상의 수수료를 받는 고유 판매 거래 수를 반환하려면 다음 예제를 사용합니다. 이 명령은 커미션 값의 시작 부분에서 소수점이 4자리 이상인지 확인하여 999.00보다 큰 커미션을 계산합니다.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# CHR 함수
CHR 함수는 입력 파라미터에서 지정하는 ASCII 코드 포인트 값과 일치하는 문자를 반환합니다.
## 구문
```
CHR(number)
```
## 인수
*number*
입력 파라미터는 ASCII 코드 포인트 값을 나타내는 `INTEGER`입니다.
## 반환 타입
CHAR
ASCII 문자가 입력 값과 일치하면 `CHAR` 함수가 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) 섹션을 참조하세요.
데이터베이스 데이터 정렬을 사용하여 데이터베이스를 생성하는 방법에 대한 자세한 내용은 [데이터베이스 생성](r_CREATE_DATABASE.md) 섹션을 참조하세요.
## 구문
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## 인수
*문자열*()
재정의하려는 문자열 열 또는 표현식입니다.
*'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`만 반환합니다. COLLATE 함수가 col1에서 실행되면 데이터 정렬이 `case_insensitive`가 됩니다. 두 번째 쿼리는 `john`과 `JOHN`을 모두 반환합니다.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
A 테이블을 만들고 A 테이블의 col1을 `case_insensitive`로 정의하려면 다음 예제를 사용합니다
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
첫 번째 쿼리를 실행하면 Amazon Redshift는 `john`과 `JOHN`을 모두 반환합니다. COLLATE 함수가 col1에서 실행되면 데이터 정렬이 `case_sensitive`가 됩니다. 두 번째 쿼리는 `john`만 반환합니다.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# CONCAT 함수
CONCAT 함수는 두 표현식을 연결하고 결과 표현식을 반환합니다. 2개 이상의 표현식을 연결하려면 CONCAT 함수를 중첩시켜 사용합니다. 두 표현식 사이의 연결 연산자(`||`)는 CONCAT 함수와 동일한 결과를 반환합니다.
## 구문
```
CONCAT ( expression1, expression2 )
```
## 인수
*expression1*, *expression2*
두 인수 모두 고정 길이 문자열, 가변 길이 문자열, 2진 표현식 또는 이러한 입력 중 하나로 평가되는 표현식이 될 수 있습니다.
## 반환 타입
CONCAT는 표현식을 반환합니다. 표현식의 데이터 유형은 입력 인수와 동일합니다.
입력 표현식의 유형이 다른 경우 Amazon Redshift는 표현식 중 하나의 유형 캐스팅을 암시적으로 시도합니다. 값을 캐스팅할 수 없는 경우 오류가 반환됩니다.
## 사용 노트
+ 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 함수를 사용하여 세 개의 문자열을 연결합니다.
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
NULL을 포함할 수 있는 열을 연결하려면 NULL이 발생할 경우 지정된 값을 반환하는 [NVL 및 COALESCE 함수](r_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)
```
다음 예에서는 2개의 이진 표현식을 연결합니다. 여기서 `abc`는 이진 값(`616263`의 16진수 표현)이고 `def`는 이진 값(`646566`의 16진수 표현)입니다. 결과는 이진 값의 16진수 표현으로 자동으로 표시됩니다.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 함수
CRC32는 오류 감지에 사용되는 함수입니다. 이 함수는 CRC32 알고리즘을 사용하여 원본 데이터와 대상 데이터 간의 변경 사항을 감지합니다. CRC32 함수는 가변 길이 문자열을 32비트 이진 시퀀스인 16진수 값을 텍스트로 표현한 8자 문자열로 변환합니다. 원본 데이터와 대상 데이터 간의 변경 사항을 감지하려면 원본 데이터에서 CRC32 함수를 사용하여 출력을 저장합니다. 그런 다음 대상 데이터에서 CRC32 함수를 사용하여 해당 출력을 원본 데이터의 출력과 비교합니다. 데이터가 수정되지 않은 경우 출력이 동일하고 데이터가 수정된 경우 출력이 달라집니다.
## 구문
```
CRC32(string)
```
## 인수
*문자열*()
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
## 반환 타입
CRC32 함수는 32비트 이진 시퀀스의 16진수 값을 텍스트로 표현한 8자 문자열을 반환합니다. Amazon Redshift CRC32 함수는 CRC-32C 다항식을 기반으로 합니다.
## 예제
`Amazon Redshift` 문자열의 8비트 값을 표시하려면 다음 예제를 사용합니다.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# DIFFERENCE 함수
DIFFERENCE 함수는 두 문자열의 미국 Soundex 코드를 비교합니다. 이 함수는 Soundex 코드 간에 일치하는 문자 수를 나타내는 `INTEGER`를 반환합니다.
Soundex 코드는 4자 길이의 문자열입니다. Soundex 코드는 단어의 철자보다는 단어가 어떻게 들리는지를 나타냅니다. 예를 들어 `Smith`와 `Smyth`의 Soundex 코드는 동일합니다.
## 구문
```
DIFFERENCE(string1, string2)
```
## 인수
*string1*
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
*string2*
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
## 반환 타입
INTEGER
DIFFERENCE 함수는 두 문자열의 미국 Soundex 코드에서 일치하는 문자의 수를 세는 0\$14 사이의 `INTEGER` 값을 반환합니다. Soundex 코드는 4문자로 구성되므로 문자열의 미국 Soundex 코드 값 중 4문자가 모두 같으면 DIFFERENCE 함수는 `4`를 반환합니다. 두 문자열 중 하나가 비어 있으면 DIFFERENCE는 `0`을 반환합니다. 두 문자열 모두 유효한 문자를 포함하지 않으면 `1`을 반환합니다. DIFFERENCE 함수는 a\$1z 및 A\$1Z를 포함하여 영어 알파벳 소문자 또는 대문자 ASCII 문자만 변환합니다. DIFFERENCE는 다른 문자를 무시합니다.
## 예제
문자열 `%` 및 `@`의 Soundex 값을 비교하려면 다음 예제를 사용합니다. 두 문자열 모두 유효한 문자를 포함하지 않으므로 함수는 `1`을 반환합니다.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
`Amazon`과 빈 문자열의 Soundex 값을 비교하려면 다음 예제를 사용합니다. 이 함수는 두 문자열 중 하나가 비어 있기 때문에 `0`을 반환합니다.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
문자열 `Amazon` 및 `Ama`의 Soundex 값을 비교하려면 다음 예제를 사용합니다. 이 함수는 문자열의 Soundex 값 중 두 문자가 동일하므로 `2`를 반환합니다.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
문자열 `Amazon` 및 `+-*/%Amazon`의 Soundex 값을 비교하려면 다음 예제를 사용합니다. 이 함수는 문자열의 Soundex 값 4개 문자가 모두 동일하기 때문에 `4`를 반환합니다. 이 함수는 두 번째 문자열의 유효하지 않은 문자 `+-*/%`를 무시한다는 점에 유의하세요.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
문자열 `AC/DC` 및 `Ay See Dee See`의 Soundex 값을 비교하려면 다음 예제를 사용합니다. 이 함수는 문자열의 Soundex 값 4개 문자가 모두 동일하기 때문에 `4`를 반환합니다.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# INITCAP 함수
지정한 문자열에서 각 단어의 첫 번째 글자를 대문자로 변경합니다. INITCAP은 UTF-8 멀티바이트 문자를 지원하여 문자당 최대 4바이트까지 가능합니다.
## 구문
```
INITCAP(string)
```
## 인수
*문자열*()
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
## 반환 타입
VARCHAR
## 사용 노트
INITCAP 함수는 문자열에 속한 각 단어의 첫 글자를 대문자로 변경하고 이후 글자는 소문자로 변경하거나 또는 남겨둡니다. 따라서 공백 문자를 제외하고 어떤 문자가 단어 구분자의 역할을 하는지 알아야 합니다. *단어 구분자* 문자는 구두점, 기호, 제어 문자 등 알파벳을 제외한 모든 문자를 가리킵니다. 다음 문자는 모두 단어 구분자입니다.
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
그 밖에 탭, 줄 바꿈 문자, 폼 피드, 라인 피드, 캐리지 리턴 등도 단어 구분자에 속합니다.
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 및 USERS 테이블 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
CATDESC 열에 있는 각 단어의 첫 글자를 대문자로 사용하려면 다음 예제를 사용합니다.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
대문자가 단어의 첫머리가 아닐 때 INITCAP 함수가 대문자를 유지하지 않는다는 것을 보여 주려면 다음 예제를 사용합니다. 예를 들어 `MLB` 문자열은 `Mlb`가 됩니다.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
공백 이외의 영숫자가 아닌 문자가 단어 구분 기호로 기능한다는 것을 보여 주려면 다음 예제를 사용합니다. 각 문자열의 여러 문자가 대문자로 표시됩니다.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# LEFT 및 RIGHT 함수
이 두 함수는 문자열의 가장 왼쪽 또는 가장 오른쪽에서 지정한 만큼 문자 수를 반환합니다.
반환되는 문자 수는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다.
## 구문
```
LEFT( string, integer )
RIGHT( string, integer )
```
## 인수
*문자열*()
`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 함수는 바이트 수가 아닌 멀티바이트 문자열의 실제 문자 수를 반환합니다. 예를 들어 `VARCHAR(12)` 열에 4바이트 중국 문자 3개가 저장되어야 한다고 가정했을 때 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 `, 길이 6의 `CHAR`로 캐스팅된 후행 공백이 3개인 `cat `, 길이 6의 `VARCHAR`로 캐스팅된 후행 공백이 3개인 `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 테이블에서 가장 긴 10개 장소 이름을 반환하려면 다음 예제를 사용합니다.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# LENGTH 함수
LEN 함수의 동의어입니다.
[LEN 함수](r_LEN.md)을(를) 참조하세요.
# LOWER 함수
문자열을 소문자로 변환합니다. LOWER는 UTF-8 멀티바이트 문자를 지원하여 문자당 최대 4바이트까지 가능합니다.
## 구문
```
LOWER(string)
```
## 인수
*문자열*()
`VARCHAR` 문자열 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
## 반환 타입
문자열
LOWER 함수는 입력 문자열과 데이터 형식이 동일한 문자열을 반환합니다. 예를 들어 입력이 `CHAR` 문자열인 경우 함수는 `CHAR` 문자열을 반환합니다.
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
CATNAME 열의 `VARCHAR` 문자열을 소문자로 변환하려면 다음 예제를 사용합니다.
```
SELECT catname, LOWER(catname) FROM category ORDER BY 1,2;
+-----------+-----------+
| catname | lower |
+-----------+-----------+
| Classical | classical |
| Jazz | jazz |
| MLB | mlb |
| MLS | mls |
| Musicals | musicals |
| NBA | nba |
| NFL | nfl |
| NHL | nhl |
| Opera | opera |
| Plays | plays |
| Pop | pop |
+-----------+-----------+
```
# LPAD 및 RPAD 함수
이 두 함수는 지정한 길이에 따라 문자열에 문자를 추가 또는 첨부합니다.
## 구문
```
LPAD(string1, length, [ string2 ])
```
```
RPAD(string1, length, [ string2 ])
```
## 인수
*string1*
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
*length*
함수의 결과 길이를 정의하는 정수입니다. 문자열의 길이는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. *string1*이 지정한 길이보다 길면 오른쪽에서 절사됩니다. **length가 0이거나 음수면 함수 결과로 빈 문자열이 반환됩니다.
*string2*
(선택) **string1에 추가 또는 첨부되는 1개 이상의 문자입니다. 이 인수를 지정하지 않으면 공백이 사용됩니다.
## 반환 타입
VARCHAR
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 EVENT 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
지정된 이벤트 이름 집합을 20자로 자르고 더 짧은 이름 앞에 공백을 추가하려면 다음 예제를 사용합니다.
```
SELECT LPAD(eventname, 20) FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+---------------------+
| lpad |
+---------------------+
| Salome |
| Il Trovatore |
| Boris Godunov |
| Gotterdammerung |
|La Cenerentola (Cind |
+-----------------------+
```
동일한 이벤트 이름 집합을 20자로 줄이되 더 짧은 이름에 `0123456789`을 추가하려면 다음 예제를 사용합니다.
```
SELECT RPAD(eventname, 20,'0123456789') FROM event
WHERE eventid BETWEEN 1 AND 5 ORDER BY 1;
+----------------------+
| rpad |
+----------------------+
| Boris Godunov0123456 |
| Gotterdammerung01234 |
| Il Trovatore01234567 |
| La Cenerentola (Cind |
| Salome01234567890123 |
+----------------------+
```
# ltrim 함수
문자열의 시작 부분부터 문자를 잘라냅니다. 잘라낸 문자 목록에서 문자만 포함하는 가장 긴 문자열을 제거합니다. 잘라내기 문자가 입력 문자열에 나타나지 않으면 잘라내기가 완료된 것입니다.
## 구문
```
LTRIM( string [, trim_chars] )
```
## 인수
*문자열*()
잘라낼 문자열 열, 표현식 또는 문자열 리터럴입니다.
*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*의 문자가 *string*의 첫 문자이면 모두 제거합니다. 다음은 'C', 'D', 'G' 문자가 VARCHAR 열인 VENUENAME의 첫 문자일 때 각 문자를 잘라내는 예입니다.
```
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
```
다음 예제에서는 기본 공백 잘라내기 문자를 사용하여 문자열의 시작 부분부터 두 개의 공백을 잘라냅니다.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# OCTETINDEX 함수
OCTETINDEX 함수는 문자열 내의 하위 문자열 위치를 바이트 수로 반환합니다.
## 구문
```
OCTETINDEX(substring, string)
```
## 인수
*substring*
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
*문자열*()
`CHAR` 문자열, `VARCHAR` 문자열 또는 암시적으로 `CHAR` 또는 `VARCHAR` 형식으로 평가되는 표현식입니다.
## 반환 타입
INTEGER
OCTETINDEX 함수는 *문자열* 내 *하위 문자열*의 위치에 해당하는 `INTEGER` 값을 바이트 수로 반환하며, 여기서 *문자열*의 첫 번째 문자는 1로 계산됩니다. **문자열에 멀티바이트 문자가 포함되어 있지 않으면 결과는 CHARINDEX 함수의 결과와 같습니다. **문자열에 **하위 문자열이 포함되어 있지 않으면 함수는 `0`을 반환하고 **하위 문자열이 비어 있으면 함수는 `1`을 반환합니다.
## 예제
`q` 문자열에서 하위 문자열 `Amazon Redshift`의 위치를 반환하려면 다음 예제를 사용합니다. 이 예제에서는 **하위 문자열이 **문자열에 없으므로 `0`을 반환합니다.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
문자열 `Amazon Redshift`에서 비어 있는 하위 문자열의 위치를 반환하려면 다음 예제를 사용합니다. 이 예에서는 **하위 문자열이 비어 있으므로 `1`을 반환합니다.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
`Redshift` 문자열에서 하위 문자열 `Amazon Redshift`의 위치를 반환하려면 다음 예제를 사용합니다. 이 예제에서는 **하위 문자열이 **문자열의 8번째 바이트에서 시작하므로 `8`을 반환합니다.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
`Redshift` 문자열에서 하위 문자열 `Amazon Redshift`의 위치를 반환하려면 다음 예제를 사용합니다. 이 예제에서는 **문자열의 처음 6자가 더블바이트 문자이므로 `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) 함수는 바이트 수가 아닌 멀티바이트 문자열의 실제 문자 수를 반환합니다. 예를 들어 `VARCHAR(12)` 열에 4바이트 중국 문자 3개가 저장되어야 한다고 가정했을 때 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* 내에서 검색할 하위 문자열입니다.
*문자열*()
검색할 문자열 또는 열입니다.
## 반환 타입
POSITION 함수는 하위 문자열의 위치에 해당하는 `INTEGER`를 반환합니다(0이 아닌 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 이상의 수수료를 받는 고유 판매 거래 수를 반환하려면 다음 예제를 사용합니다. 이 명령은 커미션 값의 시작 부분에서 소수점이 4자리 이상인지 확인하여 999.00보다 큰 커미션을 계산합니다.
```
SELECT DISTINCT POSITION('.' IN commission), COUNT (POSITION('.' IN commission))
FROM sales
WHERE POSITION('.' IN commission) > 4
GROUP BY POSITION('.' IN commission)
ORDER BY 1,2;
+-----------+-------+
| position | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# QUOTE\$1IDENT 함수
QUOTE\$1IDENT 함수는 지정된 문자열을 선행 큰따옴표와 후행 큰따옴표가 있는 문자열로 반환합니다. 함수 출력은 SQL 문에서 식별자로 사용할 수 있습니다. 함수는 포함된 큰 따옴표를 적절하게 두 배로 늘립니다.
QUOTE\$1IDENT는 문자열에 식별자가 아닌 문자가 포함되어 있거나 그렇지 않으면 소문자로 변환될 때 유효한 식별자를 생성하는 데 필요한 경우에만 큰따옴표를 추가합니다. 항상 작은 따옴표로 묶인 문자열을 반환하려면 [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md)을 사용합니다.
## 구문
```
QUOTE_IDENT(string)
```
## 인수
*문자열*()
`CHAR` 또는 `VARCHAR` 문자열입니다.
## 반환 타입
QUOTE\$1IDENT 함수는 입력 **문자열과 동일한 형식의 문자열을 반환합니다.
## 예제
큰따옴표로 묶은 문자열 `"CAT"`을 반환하려면 다음 예제를 사용합니다.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
따옴표로 묶인 CATNAME 열을 반환하려면 다음 예제를 사용합니다.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# QUOTE\$1LITERAL 함수
QUOTE\$1LITERAL 함수는 지정한 문자열을 SQL 문에서 문자열 리터럴로 사용할 수 있도록 작은 따옴표로 묶인 문자열로 반환합니다. 입력 파라미터가 숫자라고 해도 QUOTE\$1LITERAL은 이를 문자열로 처리합니다. 작은따옴표와 백슬래시 모두 되풀이하여 두 번 사용됩니다.
## 구문
```
QUOTE_LITERAL(string)
```
## 인수
*문자열*()
`CHAR` 또는 `VARCHAR` 문자열입니다.
## 반환 타입
QUOTE\$1LITERAL 함수는 입력 문자열(`CHAR` 또는 `VARCHAR`)과 데이터 형식이 동일한 **문자열을 반환합니다.
## 예제
작은 따옴표로 묶은 문자열 `''CAT''`을 반환하려면 다음 예제를 사용합니다.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
다음은 CATNAME 열을 작은 따옴표로 묶어서 반환하는 예입니다.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
다음은 CATID 열을 작은 따옴표로 묶어서 반환하는 예입니다.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# REGEXP\$1COUNT 함수
문자열에서 정규 표현식 패턴을 검색한 후 해당 패턴 발생 횟수를 나타내는 정수를 반환합니다. 일치하는 결과가 발견되지 않으면 함수가 `0`을 반환합니다. 정규 표현식에 관한 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션 및 Wikipedia의 [정규 표현식](https://en.wikipedia.org/wiki/Regular_expression)을 참조하세요.
## 구문
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## 인수
*source\$1string*
`CHAR` 또는 `VARCHAR` 문자열입니다.
*pattern*
정규 표현식 패턴을 나타내는 UTF-8 문자열 리터럴입니다. 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션을 참조하세요.
*position*
(선택) 검색을 시작할 **source\$1string 내 위치를 나타내는 양수 `INTEGER`입니다. 이 위치는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 기본값은 `1`입니다. **position이 `1`보다 작으면 검색이 **source\$1string의 첫 문자부터 시작됩니다. **position이 **source\$1string의 문자 수보다 크면 결과는 `0`이 됩니다.
*parameters*
(선택) 함수가 패턴과 일치하는 방법을 나타내는 하나 이상의 문자열 리터럴입니다. 가능한 값은 다음과 같습니다.
+ c - 대/소문자를 구분하여 일치시킵니다. 기본값은 대/소문자 구분 일치를 사용하는 것입니다.
+ i - 대/소문자를 구분하지 않고 일치시킵니다.
+ p – PCRE(Perl Compatible Regular Expression) 방언으로 패턴을 해석합니다. PCRE에 관한 자세한 내용은 Wikipedia의 [펄 호환 정규 표현식](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 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾으려면 다음 예제를 사용합니다. 이 예에서는 `?=` 연산자를 사용하는데, 이 연산자는 PCRE에서 특정 앞을 내다보는 의미를 갖습니다. 이 예에서는 대/소문자를 구분하여 일치하는 단어의 발생 횟수를 계산합니다.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
+--------------+
| regexp_count |
+--------------+
| 2 |
+--------------+
```
PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾으려면 다음 예제를 사용합니다. PCRE에서 특정한 의미를 지닌 `?=` 연산자가 사용됩니다. 이 예는 이러한 단어의 발생 횟수를 계산하지만 대/소문자를 구분하지 않는 일치를 사용한다는 점에서 이전 예와 다릅니다.
```
SELECT REGEXP_COUNT('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
+--------------+
| regexp_count |
+--------------+
| 3 |
+--------------+
```
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 테이블 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
최상위 도메인 이름이 `org` 또는 `edu`인 횟수를 계산하려면 다음 예제를 사용합니다.
```
SELECT email, REGEXP_COUNT(email,'@[^.]*\.(org|edu)') FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_count |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1 |
| Suspendisse.tristique@nonnisiAenean.edu | 1 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 0 |
| sed@lacusUtnec.ca | 0 |
+-----------------------------------------------+--------------+
```
# REGEXP\$1INSTR 함수
문자열에서 정규 표현식 패턴을 검색하여 일치하는 하위 문자열의 시작 위치 또는 종료 위치를 나타내는 정수를 반환합니다. 일치하는 결과가 발견되지 않으면 함수가 `0`을 반환합니다. REGEXP\$1INSTR은 [POSITION](r_POSITION.md) 함수와 비슷하지만 문자열에서 정규 표현식 패턴을 검색할 수 있습니다. 정규 표현식에 관한 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션 및 Wikipedia의 [정규 표현식](https://en.wikipedia.org/wiki/Regular_expression)을 참조하세요.
## 구문
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## 인수
*source\$1string*
열 이름 같이 검색할 문자열 표현식입니다.
*pattern*
정규 표현식 패턴을 나타내는 UTF-8 문자열 리터럴입니다. 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션을 참조하세요.
*position*
(선택) 검색을 시작할 **source\$1string 내 위치를 나타내는 양수 `INTEGER`입니다. 이 위치는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 기본값은 `1`입니다. **position이 `1`보다 작으면 검색이 **source\$1string의 첫 문자부터 시작됩니다. **position이 **source\$1string의 문자 수보다 크면 결과는 `0`이 됩니다.
*발생*
(선택) 사용할 패턴 발생을 나타내는 양의 `INTEGER`수입니다. REGEXP\$1INSTR은 첫 번째 일치 항목 `occurrence-1`을 건너뜁니다. 기본값은 `1`입니다. **occurrence가 `1`보다 작거나 **source\$1string에 있는 문자 수보다 클 경우 검색이 무시되고 결과가 `0`이 됩니다.
*옵션*
(선택) 일치하는 항목의 첫 번째 문자 위치(`0`)를 반환할지 일치하는 항목의 끝 다음에 나오는 첫 번째 문자의 위치(`1`)를 반환할지 여부를 나타내는 값입니다. 0이 아닌 값은 `1`과 같습니다. 기본값은 `0`입니다.
*parameters*
(선택) 함수가 패턴과 일치하는 방법을 나타내는 하나 이상의 문자열 리터럴입니다. 가능한 값은 다음과 같습니다.
+ c - 대/소문자를 구분하여 일치시킵니다. 기본값은 대/소문자 구분 일치를 사용하는 것입니다.
+ i - 대/소문자를 구분하지 않고 일치시킵니다.
+ e - 하위 표현식을 사용하여 하위 문자열을 추출합니다.
*패턴*에 하위 표현식이 포함되어 있을 경우 REGEXP\$1INSTR은 *패턴*의 첫 번째 하위 표현식을 사용하여 하위 문자열과 일치시킵니다. REGEXP\$1INSTR은 첫 번째 하위 표현식만 고려하며 추가 하위 표현식은 무시됩니다. 패턴에 하위 표현식이 없으면 REGEXP\$1INSTR이 'e' 파라미터를 무시합니다.
+ p – PCRE(Perl Compatible Regular Expression) 방언으로 패턴을 해석합니다. PCRE에 관한 자세한 내용은 Wikipedia의 [펄 호환 정규 표현식](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)을 참조하세요.
## 반환 타입
Integer
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
도메인 이름을 시작하는 `@` 문자를 검색하고 첫 번째 일치 항목의 시작 위치를 반환하려면 다음 예제를 사용합니다.
```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------+
| email | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
`Center`라는 단어의 변형을 검색하고 첫 번째 일치 항목의 시작 위치를 반환하려면 다음 예제를 사용합니다.
```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
+-----------------------+--------------+
| venuename | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center | 16 |
| Izod Center | 6 |
| Wachovia Center | 10 |
| Air Canada Centre | 12 |
+-----------------------+--------------+
```
대소문자를 구분하지 않는 일치 논리를 사용하여 문자열 `FOX`의 첫 번째 발생 위치를 찾으려면 다음 예제를 사용합니다.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾으려면 다음 예제를 사용합니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 이 예에서는 두 번째 단어의 시작 위치를 찾습니다.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
+--------------+
| regexp_instr |
+--------------+
| 21 |
+--------------+
```
PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾으려면 다음 예제를 사용합니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 이 예는 두 번째 단어의 시작 위치를 찾지만 대/소문자를 구분하지 않는 일치를 사용한다는 점에서 이전 예와 다릅니다.
```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
+--------------+
| regexp_instr |
+--------------+
| 15 |
+--------------+
```
# REGEXP\$1REPLACE 함수
문자열에서 정규 표현식 패턴을 검색한 후 발견되는 모든 패턴을 지정한 문자열로 변경합니다. REGEXP\$1REPLACE는 [REPLACE 함수](r_REPLACE.md)과 비슷하지만 문자열에서 정규 표현식 패턴을 검색할 수 있습니다. 정규 표현식에 관한 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션 및 Wikipedia의 [정규 표현식](https://en.wikipedia.org/wiki/Regular_expression)을 참조하세요.
REGEXP\$1REPLACE는 [TRANSLATE 함수](r_TRANSLATE.md) 및 [REPLACE 함수](r_REPLACE.md)과 비슷합니다. 단, TRANSLATE는 단일 문자를 여러 차례 변경하고, REPLACE는 전체 문자열 하나를 다른 문자열로 변경하는 반면 REGEXP\$1REPLACE는 문자열에서 정규 표현식 패턴을 검색할 수 있습니다.
## 구문
```
REGEXP_REPLACE( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## 인수
*source\$1string*
검색할 열 이름과 같은 `CHAR` 또는 `VARCHAR` 문자열 표현식입니다.
*pattern*
정규 표현식 패턴을 나타내는 UTF-8 문자열 리터럴입니다. 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션을 참조하세요.
*replace\$1string*
(선택) 발견되는 패턴을 각각 변경할 `CHAR` 또는 `VARCHAR` 문자열 표현식(열 이름 등)입니다. 기본값은 빈 문자열입니다( "" ).
*position*
(선택) **source\$1string 내에서 검색을 시작할 위치를 나타내는 양의 정수입니다. 이 위치는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 기본값은 `1`입니다. **position이 `1`보다 작으면 검색이 **source\$1string의 첫 문자부터 시작됩니다. *position*이 *source\$1string*의 문자 수보다 크면 결과는 *source\$1string*이 됩니다.
*parameters*
(선택) 함수가 패턴과 일치하는 방법을 나타내는 하나 이상의 문자열 리터럴입니다. 가능한 값은 다음과 같습니다.
+ c - 대/소문자를 구분하여 일치시킵니다. 기본값은 대/소문자 구분 일치를 사용하는 것입니다.
+ i - 대/소문자를 구분하지 않고 일치시킵니다.
+ p – PCRE(Perl Compatible Regular Expression) 방언으로 패턴을 해석합니다. PCRE에 관한 자세한 내용은 Wikipedia의 [펄 호환 정규 표현식](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)을 참조하세요.
## 반환 타입
VARCHAR
**pattern 또는 **replace\$1string이 `NULL`이면 결과도 `NULL`이 됩니다.
## 예제
대소문자를 구분하지 않는 일치를 사용하여 값 `quick brown fox` 내에서 문자열 `FOX`를 모두 바꾸려면 다음 예제를 사용합니다.
```
SELECT REGEXP_REPLACE('the fox', 'FOX', 'quick brown fox', 1, 'i');
+---------------------+
| regexp_replace |
+---------------------+
| the quick brown fox |
+---------------------+
```
다음 예에서는 PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾습니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 해당 단어가 나타날 때마다 값 `[hidden]`으로 바꾸려면 다음 예제를 사용합니다.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
+-------------------------------+
| regexp_replace |
+-------------------------------+
| [hidden] plain A1234 [hidden] |
+-------------------------------+
```
다음 예에서는 PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾습니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 대소문자를 구분하지 않는 일치를 사용한다는 점에서 이전 예제와 다르지만 이러한 단어의 각 발생을 `[hidden]` 값으로 바꾸려면 다음 예제를 사용합니다.
```
SELECT REGEXP_REPLACE('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
+----------------------------------+
| regexp_replace |
+----------------------------------+
| [hidden] plain [hidden] [hidden] |
+----------------------------------+
```
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
이메일 주소에서 `@` 및 도메인 주소를 삭제하려면 다음 예제를 사용합니다.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+-----------------------+
| email | regexp_replace |
+-----------------------------------------------+-----------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut |
| sed@lacusUtnec.ca | sed |
+-----------------------------------------------+-----------------------+
```
이메일 주소의 도메인 이름을 값 `internal.company.com`으로 바꾸려면 다음 예제를 사용합니다.
```
SELECT email, REGEXP_REPLACE(email, '@.*\\.[[:alpha:]]{2,3}','@internal.company.com')
FROM users
ORDER BY userid LIMIT 4;
+-----------------------------------------------+--------------------------------------------+
| email | regexp_replace |
+-----------------------------------------------+--------------------------------------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com |
| Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com |
| amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com |
| sed@lacusUtnec.ca | sed@internal.company.com |
+-----------------------------------------------+--------------------------------------------+
```
# REGEXP\$1SUBSTR 함수
문자열에서 정규 표현식 패턴을 검색하여 문자를 반환합니다. REGEXP\$1SUBSTR은 [SUBSTRING 함수](r_SUBSTRING.md) 함수와 비슷하지만 문자열에서 정규 표현식 패턴을 검색할 수 있습니다. 함수에서 정규 표현식이 문자열의 어떤 문자와도 일치하지 않는 경우 빈 문자열이 반환됩니다. 정규 표현식에 관한 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션 및 Wikipedia의 [정규 표현식](https://en.wikipedia.org/wiki/Regular_expression)을 참조하세요.
## 구문
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## 인수
*source\$1string*
검색할 문자열 표현식입니다.
*pattern*
정규 표현식 패턴을 나타내는 UTF-8 문자열 리터럴입니다. 자세한 내용은 [POSIX 연산자](pattern-matching-conditions-posix.md) 섹션을 참조하세요.
*position*
*source\$1string* 내에서 검색을 시작할 위치를 나타내는 양의 정수입니다. 이 위치는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 기본값은 1입니다. *position*이 1보다 작으면 검색이 *source\$1string*의 첫 문자부터 시작됩니다. *position*이 *source\$1string*의 문자 수보다 크면 결과는 빈 문자열("")이 됩니다.
*발생*
사용할 패턴 발생을 나타내는 양의 정수입니다. REGEXP\$1SUBSTR은 첫 번째 *발생*에서 1을 뺀 개수의 일치하는 항목을 건너뜁니다. 기본값은 1입니다. *발생*이 1보다 작거나 *source\$1string*에 있는 문자 수보다 클 경우 검색이 무시되고 빈 결과가 반환됩니다.
*parameters*
함수가 패턴과 일치하는 방법을 나타내는 하나 이상의 문자열 리터럴입니다. 가능한 값은 다음과 같습니다.
+ c - 대/소문자를 구분하여 일치시킵니다. 기본값은 대/소문자 구분 일치를 사용하는 것입니다.
+ i - 대/소문자를 구분하지 않고 일치시킵니다.
+ e - 하위 표현식을 사용하여 하위 문자열을 추출합니다.
*패턴*에 하위 표현식이 포함되어 있을 경우 REGEXP\$1SUBSTR은 *패턴*의 첫 번째 하위 표현식을 사용하여 하위 문자열과 일치시킵니다. 하위 표현식은 괄호로 묶인 패턴 내 표현식입니다. 예를 들어 `'This is a (\\w+)'` 패턴은 첫 번째 표현식과 뒤에 단어가 오는 `'This is a '` 문자열을 일치시킵니다. `e` 매개 변수가 있는 REGEXP\$1SUBSTR은 패턴**을 반환하는 대신 하위 표현식 내의 문자열만 반환합니다.
REGEXP\$1SUBSTR은 첫 번째 하위 표현식만 고려하며 추가 하위 표현식은 무시됩니다. 패턴에 하위 표현식이 없으면 REGEXP\$1SUBSTR이 'e' 파라미터를 무시합니다.
+ p – PCRE(Perl Compatible Regular Expression) 방언으로 패턴을 해석합니다. PCRE에 관한 자세한 내용은 Wikipedia의 [펄 호환 정규 표현식](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions)을 참조하세요.
## 반환 타입
VARCHAR
## 예제
다음은 @ 문자와 도메인 확장자 사이의 이메일 주소 구간을 반환하는 예입니다. 쿼리된 `users` 데이터는 Amazon Redshift 샘플 데이터에서 가져온 것입니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
다음 예에서는 대/소문자를 구분하지 않는 일치를 사용하여 문자열 `FOX`의 첫 번째 발생에 해당하는 입력 부분을 반환합니다.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
다음 예에서는 대/소문자를 구분하지 않는 일치를 사용하여 문자열 `FOX`의 두 번째 발생에 해당하는 입력 부분을 반환합니다. 두 번째 발생이 없기 때문에 결과는 비어 있음(Null이 아님, 길이 0)입니다.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
다음 예제에서는 소문자로 시작하는 입력의 첫 번째 부분을 반환합니다. 이는 `c` 파라미터가 없는 동일한 SELECT 문과 기능적으로 동일합니다.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
다음 예에서는 PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾습니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 이 예에서는 두 번째 단어에 해당하는 입력 부분을 반환합니다.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
다음 예에서는 PCRE 방언으로 작성된 패턴을 사용하여 하나 이상의 숫자와 하나의 소문자가 포함된 단어를 찾습니다. PCRE에서 특정 미리 보기 의미가 있는 `?=` 연산자가 사용됩니다. 이 예는 두 번째 단어에 해당하는 입력 부분을 반환하지만 대/소문자를 구분하지 않는 일치를 사용한다는 점에서 이전 예와 다릅니다.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
다음 예에서는 하위 표현식을 사용하여 `'this is a (\\w+)'` 패턴과 일치하는 두 번째 문자열을 찾습니다. 괄호를 친 하위 표현식을 반환합니다.
```
SELECT regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# REPEAT 함수
문자열을 지정한 횟수만큼 반복합니다. 입력 파라미터가 숫자라고 해도 REPEAT는 이를 문자열로 처리합니다.
[REPLICATE 함수](r_REPLICATE.md)의 동의어입니다.
## 구문
```
REPEAT(string, integer)
```
## 인수
*문자열*()
첫 번째 입력 파라미터는 반복할 문자열입니다.
*(정수*)
두 번째 파라미터는 문자열을 반복할 횟수를 나타내는 `INTEGER`입니다.
## 반환 타입
VARCHAR
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
CATEGORY 테이블에서 CATID 열의 값을 세 번 반복하려면 다음 예제를 사용합니다.
```
SELECT catid, REPEAT(catid,3)
FROM category
ORDER BY 1,2;
+-------+--------+
| catid | repeat |
+-------+--------+
| 1 | 111 |
| 2 | 222 |
| 3 | 333 |
| 4 | 444 |
| 5 | 555 |
| 6 | 666 |
| 7 | 777 |
| 8 | 888 |
| 9 | 999 |
| 10 | 101010 |
| 11 | 111111 |
+-------+--------+
```
다음 예제에서는 최대 16,000,000바이트의 문자열을 생성하는 방법을 보여줍니다.
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# REPLACE 함수
기존 문자열에서 발견되는 모든 문자 집합을 다른 지정 문자로 변경합니다.
REPLACE는 [TRANSLATE 함수](r_TRANSLATE.md) 및 [REGEXP\$1REPLACE 함수](REGEXP_REPLACE.md)과 비슷합니다. 단, TRANSLATE는 단일 문자를 여러 차례 변경하고, REGEXP\$1REPLACE는 문자열에서 정규 표현식 패턴을 검색하는 반면 REPLACE는 전체 문자열 하나를 다른 문자열로 변경합니다.
## 구문
```
REPLACE(string, old_chars, new_chars)
```
## 인수
*문자열*()
검색할 `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 )
```
## 인수
*문자열*()
잘라낼 문자열 열, 표현식 또는 문자열 리터럴입니다.
*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
```
다음은 VENUENAME의 끝에서 있는 경우에 한해 문자 'Park'를 잘라내는 예입니다.
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
위 예를 보면 `P`, `a`, `r` 또는 `k`가 VENUENAME의 끝에 있을 경우 RTRIM이 각 문자를 모두 제거한 것을 알 수 있습니다.
# SOUNDEX 함수
SOUNDEX 함수는 입력 문자열의 첫 글자와 지정한 문자열의 영어 발음을 나타내는 소리의 3자리 인코딩으로 구성된 미국 Soundex 값을 반환합니다. 예를 들어 `Smith` 및 `Smyth`의 Soundex 코드는 동일합니다.
## 구문
```
SOUNDEX(string)
```
## 인수
*문자열*()
American Soundex 코드 값으로 변환하려는 `CHAR` 또는 `VARCHAR` 문자열을 지정합니다.
## 반환 타입
VARCHAR(4)
## 사용 노트
SOUNDEX 함수는 a\$1z 및 A\$1Z를 포함하여 영어 알파벳 소문자와 대문자 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)
```
## 인수
*문자열*()
분할할 문자열 열, 표현식 또는 문자열 리터럴입니다. 문자열은 CHAR 또는 VARCHAR가 될 수 있습니다.
*delimiter*
입력 *문자열*의 섹션을 나타내는 구분자 문자열입니다.
*delimiter*가 리터럴이면 작은따옴표로 묶어야 합니다.
*position*
반환할 *문자열* 구간의 위치입니다(1부터 시작). 반드시 0보다 큰 정수이어야 합니다. *position*이 문자열 구간의 수보다 크면 SPLIT\$1PART가 빈 문자열을 반환합니다. *string*에서 *delimiter*를 찾을 수 없는 경우 반환된 값에는 전체 *string* 또는 빈 값이 될 수 있는 지정된 부분의 내용이 포함됩니다.
## 반환 타입
*string* 파라미터와 동일한 CHAR 또는 VARCHAR 문자열입니다.
## 예제
다음 예제에서는 `$` 구분 기호를 사용하여 문자열 리터럴을 여러 부분으로 분할하고 두 번째 부분을 반환합니다.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
다음 예제에서는 `$` 구분 기호를 사용하여 문자열 리터럴을 여러 부분으로 분할합니다. `4` 부분을 찾을 수 없기 때문에 빈 문자열이 반환됩니다.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
다음 예제에서는 `#` 구분 기호를 사용하여 문자열 리터럴을 여러 부분으로 분할합니다. 이 구분 기호를 찾을 수 없기 때문에 첫 번째 부분인 전체 문자열이 반환됩니다.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
다음은 타임스탬프 필드인 LISTTIME을 년, 월, 일 요소로 분할하는 예입니다.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
다음은 LISTTIME 타임스탬프 필드를 선택하고, `'-'` 문자를 기준으로 필드를 분할하여 월(LISTTIME 문자열의 두 번째 구간)을 가져온 다음 각 월의 항목 수를 계산하는 예입니다.
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# STRPOS 함수
지정한 문자열 내에서 하위 문자열의 위치를 반환합니다.
유사한 함수는 [CHARINDEX 함수](r_CHARINDEX.md) 및 [POSITION 함수](r_POSITION.md) 섹션을 참조하세요.
## 구문
```
STRPOS(string, substring )
```
## 인수
*문자열*()
첫 번째 입력 파라미터는 검색 대상인 `CHAR` 또는 `VARCHAR` 문자열입니다.
*substring*
두 번째 파라미터는 *string* 내에서 검색할 하위 문자열입니다.
## 반환 타입
INTEGER
STRPOS 함수는 **하위 문자열의 위치에 해당하는 `INTEGER`를 반환합니다(0이 아닌 1부터 시작). 이 위치는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다.
## 사용 노트
**문자열 내에서 **하위 문자열을 찾을 수 없는 경우 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`을 반환합니다. 문자열은 크기의 제한 없이 공백으로 시작할 수 있으며, 그 뒤에 더하기 '`+`' 또는 빼기 '`-`' 기호를 옵션으로 추가하여 양수 또는 음수를 나타냅니다. 기본값은 '`+`'입니다. 예를 들어 *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 함수
지정된 시작 위치를 기반으로 문자열의 하위 집합을 반환합니다.
입력이 문자열인 경우 추출된 문자의 시작 위치와 수는 바이트가 아닌 문자를 기준으로 하므로 멀티바이트 문자는 단일 문자로 계산됩니다. 입력이 이진 표현식인 경우 시작 위치와 추출된 하위 문자열은 바이트를 기반으로 합니다. 음의 길이는 지정할 수 없지만 음의 시작 위치는 지정 가능합니다.
## 구문
```
SUBSTRING(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## 인수
*character\$1string*
검색 대상의 문자열입니다. 문자가 아닌 데이터 형식도 문자열로 처리됩니다.
*start\$1position*
문자열 내에서 추출을 시작할 위치이며, 1부터 시작됩니다. *start\$1position*은 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 이 수는 음의 값이 될 수 있습니다.
*number\$1characters*
추출할 문자 수(하위 문자열의 길이)입니다. *number\$1characters*는 바이트가 아닌 문자 수를 기준으로 하기 때문에 멀티바이트 문자도 단일 문자로 계산됩니다. 이 수는 음의 값이 될 수 없습니다.
*binary\$1expression*
검색할 데이터 유형 VARBYTE의 binary\$1expression입니다.
*start\$1byte*
1에서 시작하여 추출을 시작할 이진 표현식 내의 위치입니다. 이 수는 음의 값이 될 수 있습니다.
*number\$1bytes*
추출할 바이트 수, 즉 하위 문자열의 길이입니다. 이 수는 음의 값이 될 수 없습니다.
## 반환 타입
입력에 따라 VARCHAR 또는 VARBYTE입니다.
## 사용 관련 참고 사항
다음은 **start\$1position 및 **number\$1characters를 사용하여 문자열의 다양한 위치에서 하위 문자열을 추출하는 방법에 대한 몇 가지 예입니다.
다음은 6번째 문자부터 4자의 문자열을 반환하는 예입니다.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*start\$1position* \$1 *number\$1characters*가 *문자열*의 길이를 초과하면, 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*)로 변환하여 절사할 수 있습니다. 여기에서 *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
```
다음 예에서는 입력 문자열 `Silva, Ana`의 마지막 공백 뒤에 나타나는 첫 번째 이름 `Ana`를 반환합니다.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# TEXTLEN 함수
LEN 함수의 동의어입니다.
[LEN 함수](r_LEN.md) 섹션을 참조하세요.
# TRANSLATE 함수
임의의 표현식에서 발견되는 모든 지정 문자를 지정한 대체 문자로 변경합니다. 기존 문자는 *characters\$1to\$1replace*의 문자 위치와 *characters\$1to\$1substitute* 인수에 따라 변환 문자로 매핑됩니다. *characters\$1to\$1replace* 인수에서 지정하는 문자 수가 *characters\$1to\$1substitute* 인수에서 지정하는 문자 수보다 많으면 *characters\$1to\$1replace* 인수의 추가 문자가 반환 값에서 생략됩니다.
TRANSLATE는 [REPLACE 함수](r_REPLACE.md) 및 [REGEXP\$1REPLACE 함수](REGEXP_REPLACE.md)과 비슷합니다. 단, REPLACE는 전체 문자열 하나를 다른 문자열로 변경하고, REGEXP\$1REPLACE는 문자열에서 정규 표현식 패턴을 검색하는 반면 TRANSLATE는 단일 문자를 여러 차례 변경합니다.
인수가 NULL이면 반환되는 값도 `NULL`입니다.
## 구문
```
TRANSLATE( expression, characters_to_replace, characters_to_substitute )
```
## 인수
* expression*
변환 대상인 표현식입니다.
*characters\$1to\$1replace*
변경 대상인 문자가 포함된 문자열입니다.
*characters\$1to\$1substitute*
대체할 문자가 포함된 문자열입니다.
## 반환 타입
VARCHAR
## 예제
문자열에서 여러 문자를 바꾸려면 다음 예제를 사용합니다.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
다음 예제에서는 TICKIT 샘플 데이터베이스의 USERS 테이블을 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
열의 모든 값에 대해 at 기호(@)를 마침표로 바꾸려면 다음 예제를 사용합니다.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
열의 모든 값에 대해 공백을 밑줄로 바꾸고 마침표를 제거하려면 다음 예제를 사용합니다.
```
SELECT city, TRANSLATE(city, ' .', '_')
FROM users
WHERE city LIKE 'Sain%' OR city LIKE 'St%'
GROUP BY city
ORDER BY city;
+----------------+---------------+
| city | translate |
+----------------+---------------+
| Saint Albans | Saint_Albans |
| Saint Cloud | Saint_Cloud |
| Saint Joseph | Saint_Joseph |
| Saint Louis | Saint_Louis |
| Saint Paul | Saint_Paul |
| St. George | St_George |
| St. Marys | St_Marys |
| St. Petersburg | St_Petersburg |
| Stafford | Stafford |
| Stamford | Stamford |
| Stanton | Stanton |
| Starkville | Starkville |
| Statesboro | Statesboro |
| Staunton | Staunton |
| Steubenville | Steubenville |
| Stevens Point | Stevens_Point |
| Stillwater | Stillwater |
| Stockton | Stockton |
| Sturgis | Sturgis |
+----------------+---------------+
```
# TRIM 함수
공백 또는 지정된 문자로 문자열을 자릅니다.
## 구문
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## 인수
BOTH \$1 LEADING \$1 TRAILING
(선택 사항) 문자를 잘라낼 위치를 지정합니다. 선행 및 후행 문자를 모두 제거하려면 BOTH를 사용하고, 선행 문자만 제거하려면 LEADING을 사용하며, 후행 문자만 제거하려면 TRAILING을 사용합니다. 이 파라미터를 생략하면 선행 및 후행 문자가 모두 잘립니다.
*trim\$1chars*
(옵션) 문자열에서 잘라낼 문자입니다. 이 파라미터를 생략하면 공백이 잘립니다.
*문자열*()
자르기 대상이 되는 문자열입니다.
## 반환 타입
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의 첫 문자 또는 끝 문자이면 모두 제거합니다. 다음 예제에서는 `VARCHAR`열인 VENUENAME의 시작 또는 끝에 나타나는 문자 'C', 'D' 및 'G'를 잘라냅니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T Park |
| 109 | Citizens Bank Park | itizens Bank Park |
| 102 | Comerica Park | omerica Park |
| 9 | Dick's Sporting Goods Park | ick's Sporting Goods Park |
| 97 | Fenway Park | Fenway Park |
| 112 | Great American Ball Park | reat American Ball Park |
| 114 | Miller Park | Miller Park |
+---------+----------------------------+---------------------------+
```
# UPPER 함수
문자열을 소문자로 변환합니다. UPPER는 UTF-8 멀티바이트 문자를 지원하여 문자당 최대 4바이트까지 가능합니다.
## 구문
```
UPPER(string)
```
## 인수
*문자열*()
입력 파라미터는 `VARCHAR` 문자열 또는 `VARCHAR`로 암시적으로 변환될 수 있는 `CHAR`와 같은 기타 데이터 형식입니다.
## 반환 타입
UPPER 함수는 입력 문자열과 데이터 형식이 동일한 문자열을 반환합니다. 예를 들어 입력이 `VARCHAR` 문자열인 경우 함수는 `VARCHAR` 문자열을 반환합니다.
## 예제
다음 예제에서는 TICKIT 샘플 데이터베이스의 CATEGORY 테이블에 있는 데이터를 사용합니다. 자세한 내용은 [샘플 데이터베이스](c_sampledb.md) 섹션을 참조하세요.
CATNAME 필드를 대문자로 변환하려면 다음을 사용합니다.
```
SELECT catname, UPPER(catname)
FROM category
ORDER BY 1,2;
+-----------+-----------+
| catname | upper |
+-----------+-----------+
| Classical | CLASSICAL |
| Jazz | JAZZ |
| MLB | MLB |
| MLS | MLS |
| Musicals | MUSICALS |
| NBA | NBA |
| NFL | NFL |
| NHL | NHL |
| Opera | OPERA |
| Plays | PLAYS |
| Pop | POP |
+-----------+-----------+
```