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**
+ [구문](#r_conditions-synopsis)
+ [비교 조건](r_comparison_condition.md)
+ [논리 조건](r_logical_condition.md)
+ [패턴 일치 조건](pattern-matching-conditions.md)
+ [BETWEEN 범위 조건](r_range_condition.md)
+ [NULL 조건](r_null_condition.md)
+ [EXISTS 조건](r_exists_condition.md)
+ [IN 조건](r_in_condition.md)
조건이란 1개 이상의 표현식과 true, false 또는 unknown으로 평가되는 논리 연산자로 구성된 하나의 문을 말합니다. 조건은 종종 조건자로 불리기도 합니다.
**참고**
모든 문자열 비교와 LIKE 패턴 일치는 대/소문자를 구분합니다. 예를 들어 'A'와 'a'는 일치하지 않습니다. 하지만 ILIKE 조건자를 사용하면 패턴 일치에서 대/소문자를 구분하지 않을 수도 있습니다.
## 구문
```
comparison_condition
| logical_condition
| range_condition
| pattern_matching_condition
| null_condition
| EXISTS_condition
| IN_condition
```
# 비교 조건
비교 조건이란 두 값의 논리적 관계를 말합니다. 모든 비교 조건은 반환 형식이 부울인 이진 연산자입니다. Amazon Redshift는 다음 표에 설명된 비교 연산자를 지원합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_comparison_condition.html)
## 사용 노트
= ANY \$1 SOME
ANY 및 SOME 키워드는 *IN* 조건과 동의어입니다. 즉, 반환 값이 1개 이상인 하위 쿼리에서 반환되는 값 중에서 1개라도 비교 결과가 true라면 true를 반환합니다. Amazon Redshift는 ANY와 SOME일 때 =(같음) 조건만 지원합니다. 부등식 조건은 지원하지 않습니다.
ALL 조건자는 지원되지 않습니다.
<> ALL
ALL 키워드는 NOT IN([IN 조건](r_in_condition.md) 조건 참조)과 동의어이기 때문에 하위 쿼리 결과에 표현식이 포함되어 있지 않을 때 true를 반환합니다. Amazon Redshift는 ALL일 때 <> 또는 \$1=(같지 않음) 조건만 지원합니다. 기타 비교 조건은 지원하지 않습니다.
IS TRUE/FALSE/UNKNOWN
0이 아닌 값은 TRUE와, 0은 FALSE와, 그리고 NULL은 UNKNOWN과 같습니다. [부울 유형HLLSKETCH 형식](r_Boolean_type.md) 데이터 형식을 참조하세요.
## 예제
다음은 몇 가지 간단한 비교 조건 예입니다.
```
a = 5
a < b
min(x) >= 5
qtysold = any (select qtysold from sales where dateid = 1882
```
다음은 VENUE 테이블에서 좌석 수가 10000석 이상인 장소를 반환하는 쿼리입니다.
```
select venueid, venuename, venueseats from venue
where venueseats > 10000
order by venueseats desc;
venueid | venuename | venueseats
---------+--------------------------------+------------
83 | FedExField | 91704
6 | New York Giants Stadium | 80242
79 | Arrowhead Stadium | 79451
78 | INVESCO Field | 76125
69 | Dolphin Stadium | 74916
67 | Ralph Wilson Stadium | 73967
76 | Jacksonville Municipal Stadium | 73800
89 | Bank of America Stadium | 73298
72 | Cleveland Browns Stadium | 73200
86 | Lambeau Field | 72922
...
(57 rows)
```
다음은 USERS 테이블에서 록 음악을 좋아하는 사용자(USERID)를 선택하는 예입니다.
```
select userid from users where likerock = 't' order by 1 limit 5;
userid
--------
3
5
6
13
16
(5 rows)
```
다음은 USER 테이블에서 록 음악을 좋아하는지 알 수 없는 사용자(USERID)를 선택하는 예입니다.
```
select firstname, lastname, likerock
from users
where likerock is unknown
order by userid limit 10;
firstname | lastname | likerock
----------+----------+----------
Rafael | Taylor |
Vladimir | Humphrey |
Barry | Roy |
Tamekah | Juarez |
Mufutau | Watkins |
Naida | Calderon |
Anika | Huff |
Bruce | Beck |
Mallory | Farrell |
Scarlett | Mayer |
(10 rows
```
## TIME 열이 있는 예
다음 예제 테이블 TIME\$1TEST에는 3개의 값이 삽입된 TIME\$1VAL(TIME 형식) 열이 있습니다.
```
select time_val from time_test;
time_val
---------------------
20:00:00
00:00:00.5550
00:58:00
```
다음 예에서는 각 timetz\$1val에서 시간을 추출합니다.
```
select time_val from time_test where time_val < '3:00';
time_val
---------------
00:00:00.5550
00:58:00
```
다음 예에서는 2개의 시간 리터럴을 비교합니다.
```
select time '18:25:33.123456' = time '18:25:33.123456';
?column?
----------
t
```
## TIMETZ 열이 있는 예
다음 예제 테이블 TIMETZ\$1TEST에는 3개의 값이 삽입된 TIMETZ\$1VAL(TIMETZ 형식) 열이 있습니다.
```
select timetz_val from timetz_test;
timetz_val
------------------
04:00:00+00
00:00:00.5550+00
05:58:00+00
```
다음 예에서는 `3:00:00 UTC`보다 작은 TIMETZ 값만 선택합니다. 값을 UTC로 변환한 후 비교합니다.
```
select timetz_val from timetz_test where timetz_val < '3:00:00 UTC';
timetz_val
---------------
00:00:00.5550+00
```
다음 예에서는 2개의 TIMETZ 리터럴을 비교합니다. 비교를 위해 시간대는 무시됩니다.
```
select time '18:25:33.123456 PST' < time '19:25:33.123456 EST';
?column?
----------
t
```
# 논리 조건
논리 조건은 두 조건 결과를 결합하여 단일 결과를 산출합니다. 모든 논리 조건은 반환 형식이 부울인 이진 연산자입니다.
## 구문
```
expression
{ AND | OR }
expression
NOT expression
```
논리 조건은 값이 3개인 부울 논리를 사용하며, 여기에서 NULL 값은 알 수 없는 관계를 의미합니다. 다음 표는 논리 조건 결과를 설명한 것으로서 `E1`과 `E2`는 표현식을 의미합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_logical_condition.html)
NOT 연산자는 AND 이전에, 그리고 AND 연산자는 OR 이전에 평가됩니다. 하지만 괄호를 사용하면 이러한 기본 평가 순서를 재정의할 수 있습니다.
### 예제
다음은 USERS 테이블에서 Las Vegas와 스포츠를 모두 좋아하는 사용자의 USERID 및 USERNAME을 반환하는 예입니다.
```
select userid, username from users
where likevegas = 1 and likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
67 | TWU10MZT
87 | DUF19VXU
92 | HYP36WEQ
109 | FPL38HZK
120 | DMJ24GUZ
123 | QZR22XGQ
130 | ZQC82ALK
133 | LBN45WCH
144 | UCX04JKN
165 | TEY68OEB
169 | AYQ83HGO
184 | TVX65AZX
...
(2128 rows)
```
다음은 USERS 테이블에서 Las Vegas 또는 스포츠를, 혹은 둘 다 좋아하는 사용자의 USERID 및 USERNAME을 반환하는 예입니다. 이 쿼리는 이전 예의 모든 출력에 더하여 Las Vegas 또는 스포츠만 좋아하는 사용자까지 반환합니다.
```
select userid, username from users
where likevegas = 1 or likesports = 1
order by userid;
userid | username
--------+----------
1 | JSG99FHE
2 | PGL08LJI
3 | IFT66TXU
5 | AEB55QTM
6 | NDQ15VBM
9 | MSD36KVR
10 | WKW41AIW
13 | QTF33MCG
15 | OWU78MTR
16 | ZMG93CDD
22 | RHT62AGI
27 | KOY02CVE
29 | HUH27PKK
...
(18968 rows)
```
다음은 `OR` 조건에 괄호를 사용하여 New York 또는 California에서 Macbeth를 공연한 장소를 찾는 예입니다.
```
select distinct venuename, venuecity
from venue join event on venue.venueid=event.venueid
where (venuestate = 'NY' or venuestate = 'CA') and eventname='Macbeth'
order by 2,1;
venuename | venuecity
----------------------------------------+---------------
Geffen Playhouse | Los Angeles
Greek Theatre | Los Angeles
Royce Hall | Los Angeles
American Airlines Theatre | New York City
August Wilson Theatre | New York City
Belasco Theatre | New York City
Bernard B. Jacobs Theatre | New York City
...
```
위 예에서 괄호를 제거하면 쿼리의 논리 및 결과가 바뀝니다.
다음 예에서는 `NOT` 스크립트를 사용합니다:
```
select * from category
where not catid=1
order by 1;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
...
```
다음은 `NOT` 조건에 이어 `AND` 조건을 사용하는 예입니다.
```
select * from category
where (not catid=1) and catgroup='Sports'
order by catid;
catid | catgroup | catname | catdesc
-------+----------+---------+---------------------------------
2 | Sports | NHL | National Hockey League
3 | Sports | NFL | National Football League
4 | Sports | NBA | National Basketball Association
5 | Sports | MLS | Major League Soccer
(4 rows)
```
# 패턴 일치 조건
**Topics**
+ [LIKE](r_patternmatching_condition_like.md)
+ [SIMILAR TO](pattern-matching-conditions-similar-to.md)
+ [POSIX 연산자](pattern-matching-conditions-posix.md)
패턴 일치 연산자는 조건 표현식에서 지정한 패턴을 문자열에서 검색하여 일치하는 패턴 유무에 따라 true 또는 false를 반환합니다. Amazon Redshift는 패턴 일치에 세 가지 방법을 사용합니다.
+ LIKE 표현식
LIKE 연산자는 열 이름 같은 문자열 표현식과 `%`(퍼센트) 및 `_`(밑줄) 와일드카드 문자의 사용 패턴을 서로 비교합니다. LIKE 패턴 일치는 항상 전체 문자열을 검색합니다. LIKE는 대/소문자를 구분하여 패턴을 일치시키는 반면 ILIKE는 대/소문자를 구분하지 않고 패턴을 일치시킵니다.
+ SIMILAR TO 정규 표현식
SIMILAR TO 연산자는 문자열 표현식과 SQL 표준 정규 표현식 패턴을 일치시킵니다. 여기에는 LIKE 연산자에서 지원하는 문자 2개는 물론이고 패턴 일치 메타 문자까지 포함될 수 있습니다. SIMILAR TO는 전체 문자열을 일치시키며, 대/소문자를 구분합니다.
+ POSIX-스타일 정규 표현식
POSIX 정규 표현식은 LIKE 및 SIMILAR TO 연산자보다 더욱 강력한 패턴 일치 수단을 제공합니다. POSIX 정규 표현식 패턴은 대/소문자를 구분하여 문자열의 어느 구간이든 일치시킬 수 있습니다.
SIMILAR TO 또는 POSIX 연산자를 사용하는 정규 표현식 일치는 계산에 따른 리소스 비용이 높습니다. 따라서 특히 다수의 행을 처리할 때는 최대한 LIKE를 사용하는 것이 좋습니다. 예를 들어 다음 두 쿼리는 기능면에서 동일하지만 LIKE를 사용하는 쿼리의 실행 속도가 정규 표현식을 사용하는 쿼리보다 몇 배 더 빠릅니다.
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
# LIKE
LIKE 연산자는 열 이름 같은 문자열 표현식과 %(퍼센트) 및 \$1(밑줄) 와일드카드 문자의 사용 패턴을 서로 비교합니다. LIKE 패턴 일치는 항상 전체 문자열을 검색합니다. 문자열 내 아무 곳에서나 시퀀스를 일치시키려면 패턴이 퍼센트 기호로 시작해서 끝나야 합니다.
LIKE는 대/소문자를 구분하지만 ILIKE는 대/소문자를 구분하지 않습니다.
## 구문
```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```
## 인수
* expression*
열 이름 같이 유효한 UTF-8 문자 표현식입니다.
LIKE \$1 ILIKE
LIKE는 대/소문자를 구분하여 패턴을 일치시킵니다. ILIKE는 단일 바이트 UTF-8(ASCII) 문자일 때 대/소문자를 구분하지 않고 패턴을 일치시킵니다. 멀티바이트 문자에 대해 대/소문자를 구분하지 않는 패턴 일치를 수행하려면 LIKE 조건이 있는 *expression* 및 *pattern*에 [LOWER](r_LOWER.md) 함수를 사용합니다.
비교 조건자(예: = 및 <>)와 달리 LIKE 및 ILIKE 조건자는 후행 공백을 묵시적으로 무시하지 않습니다. 후행 공백을 무시하려면 RTRIM을 사용하거나 CHAR 열을 VARCHAR로 명시적으로 캐스트합니다.
`~~` 연산자는 LIKE와 동일하며 `~~*`는 ILIKE와 동일합니다. 또한 `!~~` 및 `!~~*` 연산자는 NOT LIKE 및 NOT ILIKE와 동일합니다.
*pattern*
일치시킬 패턴이 포함된, 유효한 UTF-8 문자 표현식입니다.
*escape\$1char*
패턴의 메타 문자를 이스케이프 처리하는 문자 표현식입니다. 기본값은 백슬래시 2개('\$1\$1')입니다.
*pattern*에 메타 문자가 포함되어 있지 않으면 패턴이 문자열 자체만 의미합니다. 이런 경우에는 LIKE가 등호 연산자와 동일한 역할을 합니다.
문자 표현식 중 하나는 CHAR 또는 VARCHAR 데이터 형식이 될 수 있습니다. 데이터 형식이 서로 다른 경우에는 Amazon Redshift가 *pattern*을 *expression*의 데이터 형식으로 변환합니다.
LIKE에서 지원되는 패턴 일치 메타 문자는 다음과 같습니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_patternmatching_condition_like.html)
## 예제
다음 표는 LIKE를 사용한 패턴 일치의 예를 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_patternmatching_condition_like.html)
다음은 이름이 "E"로 시작하는 도시를 모두 찾는 예입니다.
```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```
다음은 성에 "ten"이 포함된 사용자를 찾는 예입니다.
```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```
다음 예제에서는 여러 패턴을 매칭하는 방법을 보여줍니다.
```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```
다음은 세 번째와 네 번째 문자가 "ea"인 도시를 찾는 예입니다. 이 명령에서는 ILIKE를 사용하여 대/소문자를 구분하지 않고 있습니다.
```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```
다음은 기본 이스케이프 문자열(\$1\$1)을 사용하여 'start\$1'(텍스트 `start` 뒤에 밑줄 `_`가 붙음)가 포함된 문자열을 찾는 예입니다.
```
select tablename, "column" from pg_table_def
where "column" like '%start\\_%'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
다음은 '^'을 이스케이프 문자로 지정한 후 이 이스케이프 문자를 사용하여 'start\$1'(텍스트 `start` 뒤에 밑줄 `_`가 붙음)가 포함된 문자열을 찾는 예입니다.
```
select tablename, "column" from pg_table_def
where "column" like '%start^_%' escape '^'
limit 5;
tablename | column
-------------------+---------------
stl_s3client | start_time
stl_tr_conflict | xact_start_ts
stl_undone | undo_start_ts
stl_unload_log | start_time
stl_vacuum_detail | start_row
(5 rows)
```
다음 예시에서는 `~~*` 연산자를 사용하여 'Ag'로 시작하는 도시에 대해 대소문자를 구분하지 않는(ILIKE) 검색을 수행합니다.
```
select distinct city from users where city ~~* 'Ag%' order by city;
city
------------
Agat
Agawam
Agoura Hills
Aguadilla
```
# SIMILAR TO
SIMILAR TO 연산자는 열 이름 같은 문자열 표현식과 SQL 표준 정규 표현식 패턴을 일치시킵니다. SQL 정규 표현식 패턴에는 [LIKE](r_patternmatching_condition_like.md) 연산자에서 지원되는 문자 2개는 물론이고 패턴 일치 문자까지 포함될 수 있습니다.
SIMILAR TO 연산자는 패턴이 문자열 구간과 일치하는 POSIX 정규 표현식과 달리 패턴이 전체 문자열과 일치하는 경우에만 true를 반환합니다.
SIMILAR TO는 대/소문자를 구분하여 패턴을 일치시킵니다.
**참고**
SIMILAR TO를 사용하는 정규 표현식 일치는 계산에 따른 리소스 비용이 높습니다. 따라서 특히 다수의 행을 처리할 때는 최대한 LIKE를 사용하는 것이 좋습니다. 예를 들어 다음 두 쿼리는 기능면에서 동일하지만 LIKE를 사용하는 쿼리의 실행 속도가 정규 표현식을 사용하는 쿼리보다 몇 배 더 빠릅니다.
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## 구문
```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```
## 인수
* expression*
열 이름 같이 유효한 UTF-8 문자 표현식입니다.
SIMILAR TO
SIMILAR TO는 대/소문자를 구분하여 *expression*의 전체 문자열과 패턴을 일치시킵니다.
*pattern*
SQL 표준 정규 표현식 패턴을 나타내는, 유효한 UTF-8 문자 표현식입니다.
*escape\$1char*
패턴의 메타 문자를 이스케이프 처리하는 문자 표현식입니다. 기본값은 백슬래시 2개('\$1\$1')입니다.
*pattern*에 메타 문자가 포함되어 있지 않으면 패턴이 문자열 자체만 의미합니다.
문자 표현식 중 하나는 CHAR 또는 VARCHAR 데이터 형식이 될 수 있습니다. 데이터 형식이 서로 다른 경우에는 Amazon Redshift가 *pattern*을 *expression*의 데이터 형식으로 변환합니다.
SIMILAR TO에서 지원되는 패턴 일치 메타 문자는 다음과 같습니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
## 예제
다음 표는 SIMILAR TO를 사용한 패턴 일치의 예를 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-similar-to.html)
다음은 이름에 "E" 또는 "H"가 포함되는 도시를 찾는 예입니다.
```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
다음은 기본 이스케이프 문자열('`\\`')을 사용하여 "`_`"이 포함된 문자열을 찾는 예입니다.
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
다음은 '`^`'을 이스케이프 문자열로 지정한 후 이 이스케이프 문자열을 사용하여 "`_`"이 포함된 문자열을 찾는 예입니다.
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
# POSIX 연산자
POSIX 정규 표현식은 일치 패턴을 지정하는 일련의 문자입니다. 문자열이 정규 표현식에 설명된 정규 집합의 멤버인 경우 해당 문자열은 정규 표현식과 일치합니다.
POSIX 정규 표현식은 [LIKE](r_patternmatching_condition_like.md) 및 [SIMILAR TO](pattern-matching-conditions-similar-to.md) 연산자보다 더욱 강력한 패턴 일치 수단을 제공합니다. POSIX 정규 표현식은 패턴은 전체 문자열과 일치하는 경우에만 true를 반환하는 SIMILAR TO 연산자와 달리 문자열 구간과 일치시킬 수 있습니다.
**참고**
POSIX 연산자를 사용하는 정규 표현식 일치는 계산에 따른 리소스 비용이 높습니다. 따라서 특히 다수의 행을 처리할 때는 최대한 LIKE를 사용하는 것이 좋습니다. 예를 들어 다음 두 쿼리는 기능면에서 동일하지만 LIKE를 사용하는 쿼리의 실행 속도가 정규 표현식을 사용하는 쿼리보다 몇 배 더 빠릅니다.
```
select count(*) from event where eventname ~ '.*(Ring|Die).*';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## 구문
```
expression [ ! ] ~ pattern
```
## 인수
* expression*
열 이름 같이 유효한 UTF-8 문자 표현식입니다.
\$1
부정 연산자입니다. 정규 표현식과 일치하지 않습니다.
\$1
대/소문자를 구분하여 *expression*의 하위 문자열과 일치시킵니다.
`~~`는 [LIKE](r_patternmatching_condition_like.md)의 동의어입니다.
*pattern*
정규 표현식 패턴을 나타내는 문자열 리터럴입니다.
*pattern*에 와일드카드 문자가 포함되어 있지 않으면 패턴이 문자열 자체만 의미합니다.
‘`. * | ? `‘ 등 메타 문자가 포함된 문자열을 찾으려면 백슬래시 2개('` \\`')를 사용하여 문자를 이스케이프 처리하세요. `SIMILAR TO`나 `LIKE`와 달리 POSIX 정규 표현식 구문은 사용자 정의 이스케이프 문자를 지원하지 않습니다.
문자 표현식 중 하나는 CHAR 또는 VARCHAR 데이터 형식이 될 수 있습니다. 데이터 형식이 서로 다른 경우에는 Amazon Redshift가 *pattern*을 *expression*의 데이터 형식으로 변환합니다.
문자 표현식 모두 CHAR 또는 VARCHAR 데이터 형식이 될 수 있습니다. 표현식의 데이터 형식이 다르면 Amazon Redshift가 *expression*의 데이터 형식으로 변환합니다.
POSIX 패턴 일치에서 지원되는 메타 문자는 다음과 같습니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-posix.html)
다음은 Amazon Redshift에서 지원되는 POSIX 문자 클래스입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-posix.html)
Amazon Redshift는 정규 표현식에서 다음과 같이 Perl의 영향을 받는 연산자를 지원합니다. 이러한 연산자는 백슬래시 2개(‘`\\`’)를 사용하여 이스케이프 처리합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-posix.html)
## 예제
다음 표는 POSIX 연산자를 사용한 패턴 일치의 예를 나타낸 것입니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/pattern-matching-conditions-posix.html)
다음은 이름에 `E` 또는 `H`가 포함된 도시를 찾는 예입니다.
```
SELECT DISTINCT city FROM users
WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
다음 예는 이름에 `E` 또는 `H`가 포함되지 않은 도시를 찾습니다.
```
SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;
city
-----------------
Aberdeen
Abilene
Ada
Agat
Agawam
```
다음은 기본 이스케이프 문자열('`\\`')을 사용하여 "마침표"가 포함된 문자열을 찾는 예입니다.
```
SELECT venuename FROM venue
WHERE venuename ~ '.*\\..*'
ORDER BY venueid;
venuename
------------------------------
St. Pete Times Forum
Jobing.com Arena
Hubert H. Humphrey Metrodome
U.S. Cellular Field
Superpages.com Center
E.J. Nutter Center
Bernard B. Jacobs Theatre
St. James Theatre
```
# BETWEEN 범위 조건
`BETWEEN` 조건은 키워드 `BETWEEN`과 `AND`를 사용하여 값의 범위에 대한 표현식의 포함 여부를 테스트합니다.
## 구문
```
expression [ NOT ] BETWEEN expression AND expression
```
표현식은 숫자, 문자 또는 날짜/시간 데이터 형식이 될 수 있지만 서로 호환 가능해야 합니다. 범위는 모든 값을 포함합니다.
## 예제
다음은 티켓 2장, 3장 또는 4장 중에서 판매가 등록된 티켓의 거래 수를 계산하는 예입니다.
```
select count(*) from sales
where qtysold between 2 and 4;
count
--------
104021
(1 row)
```
범위 조건에는 시작 값과 종료 값이 모두 포함됩니다.
```
select min(dateid), max(dateid) from sales
where dateid between 1900 and 1910;
min | max
-----+-----
1900 | 1910
```
범위 조건에서 첫 번째 표현식은 두 번째 표현식보다 값이 작아야 하고, 두 번째 표현식은 첫 번째 표현식보다 값이 커야 합니다. 다음은 표현식의 값으로 인해 항상 0개의 행을 반환하는 예입니다.
```
select count(*) from sales
where qtysold between 4 and 2;
count
-------
0
(1 row)
```
하지만 NOT 한정자를 적용하면 논리가 반전되어 모든 행의 수를 반환합니다.
```
select count(*) from sales
where qtysold not between 4 and 2;
count
--------
172456
(1 row)
```
다음은 좌석 수가 20,000\$150,000석인 장소 목록을 반환하는 쿼리입니다.
```
select venueid, venuename, venueseats from venue
where venueseats between 20000 and 50000
order by venueseats desc;
venueid | venuename | venueseats
---------+-------------------------------+------------
116 | Busch Stadium | 49660
106 | Rangers BallPark in Arlington | 49115
96 | Oriole Park at Camden Yards | 48876
...
(22 rows)
```
다음 예에서는 날짜 값에 BETWEEN을 사용하는 방법을 보여 줍니다.
```
select salesid, qtysold, pricepaid, commission, saletime
from sales
where eventid between 1000 and 2000
and saletime between '2008-01-01' and '2008-01-03'
order by saletime asc;
salesid | qtysold | pricepaid | commission | saletime
--------+---------+-----------+------------+---------------
65082 | 4 | 472 | 70.8 | 1/1/2008 06:06
110917 | 1 | 337 | 50.55 | 1/1/2008 07:05
112103 | 1 | 241 | 36.15 | 1/2/2008 03:15
137882 | 3 | 1473 | 220.95 | 1/2/2008 05:18
40331 | 2 | 58 | 8.7 | 1/2/2008 05:57
110918 | 3 | 1011 | 151.65 | 1/2/2008 07:17
96274 | 1 | 104 | 15.6 | 1/2/2008 07:18
150499 | 3 | 135 | 20.25 | 1/2/2008 07:20
68413 | 2 | 158 | 23.7 | 1/2/2008 08:12
```
BETWEEN의 범위는 포함되지만 날짜는 기본적으로 00:00:00의 시간 값을 가집니다. 샘플 쿼리에 대해 유일하게 유효한 1월 3일 행은 판매 시간이 `1/3/2008 00:00:00`인 행입니다.
# NULL 조건
NULL 조건은 값이 누락되거나 알 수 없는 경우 NULL 여부를 테스트합니다.
## 구문
```
expression IS [ NOT ] NULL
```
## 인수
* expression*
열 같은 모든 표현식입니다.
IS NULL
표현식의 값이 NULL일 때는 true이고, 표현식에 값이 있을 때는 false입니다.
IS NOT NULL
표현식의 값이 NULL일 때는 false이고, 표현식에 값이 있을 때는 true입니다.
## 예제
다음은 SALES 테이블의 QTYSOLD 필드에 NULL이 포함된 횟수를 나타내는 예입니다.
```
select count(*) from sales
where qtysold is null;
count
-------
0
(1 row)
```
# EXISTS 조건
EXISTS 조건은 하위 쿼리에 대한 행의 존재 유무를 테스트한 후 하위 쿼리에서 행이 1개 이상 존재하면 true를 반환합니다. NOT을 지정하는 경우에는 하위 쿼리에 행이 없을 때 true를 반환합니다.
## 구문
```
[ NOT ] EXISTS (table_subquery)
```
## 인수
exists
*table\$1subquery*가 행을 1개 이상 반환하면 true입니다.
not\$1exists
*table\$1subquery*가 행을 하나도 반환하지 않으면 true입니다.
*table\$1subquery*
열이 1개 이상, 그리고 행이 1개 이상 포함된 테이블로 평가되는 하위 쿼리입니다.
## 예제
다음은 유형에 상관없이 판매가 이루어진 날짜마다 각각 한 번씩 날짜 식별자를 모두 반환하는 예입니다.
```
select dateid from date
where exists (
select 1 from sales
where date.dateid = sales.dateid
)
order by dateid;
dateid
--------
1827
1828
1829
...
```
# IN 조건
IN 조건은 값 집합 또는 하위 쿼리에서 값의 멤버십 여부를 테스트합니다.
## 구문
```
expression [ NOT ] IN (expr_list | table_subquery)
```
## 인수
* expression*
*expr\$1list* 또는 *table\$1subquery*를 대상으로 평가되는 숫자, 문자 또는 날짜/시간 표현식으로서 해당 목록이나 하위 쿼리의 데이터 형식과 호환되어야 합니다.
*expr\$1list*
쉼표로 구분된 표현식 1개 이상, 또는 쉼표로 구분된 표현식 집합 1개 이상이며 괄호로 경계를 표시합니다.
*table\$1subquery*
행이 1개 이상 포함되어 있지만 select 목록의 열은 1개로 제한된 테이블로 평가되는 하위 쿼리입니다.
IN \$1 NOT IN
IN은 표현식이 표현식 목록 또는 쿼리의 멤버일 때 true를 반환합니다. NOT IN은 표현식이 멤버가 아닐 때 true를 반환합니다. IN과 NOT IN은 *expression*이 NULL을 산출하는 경우, 혹은 *expr\$1list* 또는 *table\$1subquery* 값이 하나도 일치하지 않고 두 비교 행 중 적어도 하나가 NULL을 산출하는 경우에는 NULL과 함께 아무런 행도 반환되지 않습니다.
## 예제
다음 조건은 나열된 값일 때만 true로 평가됩니다.
```
qtysold in (2, 4, 5)
date.day in ('Mon', 'Tues')
date.month not in ('Oct', 'Nov', 'Dec')
```
## 대용량 IN 목록의 최적화
값이 10개 이상인 IN 목록은 쿼리 성능의 최적화를 위해 내부에서 스칼라 배열로 평가됩니다. 값이 10개 미만인 IN 목록은 OR 조건자의 연속으로 평가됩니다. 이러한 최적화는 SMALLINT, INTEGER, BIGINT, REAL, DOUBLE PRECISION, BOOLEAN, CHAR, VARCHAR, DATE, TIMESTAMP 및 TIMESTAMPTZ 데이터 형식에서 지원됩니다.
이러한 최적화의 효과는 다음 쿼리에서 EXPLAIN 출력을 보면 알 수 있습니다. 예:
```
explain select * from sales
QUERY PLAN
--------------------------------------------------------------------
XN Seq Scan on sales (cost=0.00..6035.96 rows=86228 width=53)
Filter: (salesid = ANY ('{1,2,3,4,5,6,7,8,9,10,11}'::integer[]))
(2 rows)
```