SnowConvert: Redshift 조건¶
BETWEEN¶
설명¶
BETWEEN 조건은 BETWEEN 및 AND 키워드를 사용하여 식이 값 범위에 포함되는지 테스트합니다. (Redshift SQL Language Reference BETWEEN 조건)
문법 구문¶
expression [ NOT ] BETWEEN expression AND expression
이 함수는 Snowflake 에서 완전하게 지원됩니다.
샘플 소스 패턴
설정 테이블
CREATE TABLE sales (
id INTEGER IDENTITY(1,1),
price FLOAT,
departmentId INTEGER,
saleDate DATE
);
INSERT INTO sales (price, departmentId, saleDate) VALUES
(5000, 1, '2008-01-01'),
(8000, 1, '2018-01-01'),
(5000, 2, '2010-01-01'),
(7000, 3, '2010-01-01'),
(5000, 1, '2018-01-01'),
(4000, 4, '2010-01-01'),
(3000, 4, '2018-01-01'),
(9000, 5, '2008-01-01'),
(7000, 5, '2018-01-01'),
(6000, 5, '2006-01-01'),
(5000, 5, '2008-01-01'),
(5000, 4, '2018-01-01'),
(8000, 3, '2006-01-01'),
(7000, 3, '2016-01-01'),
(2000, 2, '2018-01-01');
CREATE TABLE sales (
id INTEGER IDENTITY(1,1) ORDER,
price FLOAT,
departmentId INTEGER,
saleDate DATE
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/08/2025", "domain": "test" }}';
INSERT INTO sales (price, departmentId, saleDate) VALUES
(5000, 1, '2008-01-01'),
(8000, 1, '2018-01-01'),
(5000, 2, '2010-01-01'),
(7000, 3, '2010-01-01'),
(5000, 1, '2018-01-01'),
(4000, 4, '2010-01-01'),
(3000, 4, '2018-01-01'),
(9000, 5, '2008-01-01'),
(7000, 5, '2018-01-01'),
(6000, 5, '2006-01-01'),
(5000, 5, '2008-01-01'),
(5000, 4, '2018-01-01'),
(8000, 3, '2006-01-01'),
(7000, 3, '2016-01-01'),
(2000, 2, '2018-01-01');
입력 코드:
SELECT COUNT(*) FROM sales
WHERE departmentId BETWEEN 2 AND 4;
SELECT * FROM sales
WHERE departmentId BETWEEN 4 AND 2;
SELECT * FROM sales
WHERE departmentId NOT BETWEEN 4 AND 2;
SELECT * FROM sales
WHERE departmentId BETWEEN 2 AND 4
AND saleDate BETWEEN '2010-01-01' and '2016-01-01';
select 'some ' between c_start and c_end
from( select 'same' as c_start, 'some' as c_end );
카운트 |
|---|
8 |
id |
price |
departmentid |
saledate |
|---|---|---|---|
id |
price |
departmentid |
saledate |
|---|---|---|---|
1 |
5000 |
1 |
2008-01-01 |
2 |
8000 |
1 |
2018-01-01 |
3 |
5000 |
2 |
2010-01-01 |
4 |
7000 |
3 |
2010-01-01 |
5 |
5000 |
1 |
2018-01-01 |
6 |
4000 |
4 |
2010-01-01 |
7 |
3000 |
4 |
2018-01-01 |
8 |
9000 |
5 |
2008-01-01 |
9 |
7000 |
5 |
2018-01-01 |
10 |
6000 |
5 |
2006-01-01 |
11 |
5000 |
5 |
2008-01-01 |
12 |
5000 |
4 |
2018-01-01 |
13 |
8000 |
3 |
2006-01-01 |
14 |
7000 |
3 |
2016-01-01 |
15 |
2000 |
2 |
2018-01-01 |
id |
price |
departmentid |
saledate |
|---|---|---|---|
3 |
5000 |
2 |
2010-01-01 |
4 |
7000 |
3 |
2010-01-01 |
6 |
4000 |
4 |
2010-01-01 |
14 |
7000 |
3 |
2016-01-01 |
출력 코드:
SELECT COUNT(*) FROM
sales
WHERE departmentId BETWEEN 2 AND 4;
SELECT * FROM
sales
WHERE departmentId BETWEEN 4 AND 2;
SELECT * FROM
sales
WHERE departmentId NOT BETWEEN 4 AND 2;
SELECT * FROM
sales
WHERE departmentId BETWEEN 2 AND 4
AND saleDate BETWEEN '2010-01-01' and '2016-01-01';
select
RTRIM( 'some ') between c_start and c_end
from( select 'same' as c_start, 'some' as c_end );
카운트 |
|---|
8 |
id |
price |
departmentid |
saledate |
|---|---|---|---|
id |
price |
departmentid |
saledate |
|---|---|---|---|
1 |
5000 |
1 |
2008-01-01 |
2 |
8000 |
1 |
2018-01-01 |
3 |
5000 |
2 |
2010-01-01 |
4 |
7000 |
3 |
2010-01-01 |
5 |
5000 |
1 |
2018-01-01 |
6 |
4000 |
4 |
2010-01-01 |
7 |
3000 |
4 |
2018-01-01 |
8 |
9000 |
5 |
2008-01-01 |
9 |
7000 |
5 |
2018-01-01 |
10 |
6000 |
5 |
2006-01-01 |
11 |
5000 |
5 |
2008-01-01 |
12 |
5000 |
4 |
2018-01-01 |
13 |
8000 |
3 |
2006-01-01 |
14 |
7000 |
3 |
2016-01-01 |
15 |
2000 |
2 |
2018-01-01 |
id |
price |
departmentid |
saledate |
|---|---|---|---|
3 |
5000 |
2 |
2010-01-01 |
4 |
7000 |
3 |
2010-01-01 |
6 |
4000 |
4 |
2010-01-01 |
14 |
7000 |
3 |
2016-01-01 |
알려진 문제
문제가 발견되지 않았습니다.
관련 EWIs
관련 EWIs 없음.
비교 조건
Description
비교 조건은 두 값 사이의 논리적 관계를 나타냅니다. 모든 비교 조건은 부울 반환 타입을 가진 이진 연산자입니다. (RedShift SQL Language Reference 비교 조건)
Grammar Syntax
Redshift는 다음 테이블에 설명된 비교 연산자를 지원합니다.
| Operator | Syntax | Description |
|---|---|---|
| < | a < b | Value a is less than value b. |
| > | a > b | Value a is greater than value b. |
| <= | a <= b | Value a is less than or equal to value b. |
| >= | a >= b | Value a is greater than or equal to value b. |
| = | a = b | Value a is equal to value b. |
| <> | != | a <> b | a != b | Value a is not equal to value b. |
| ANY | SOME | a = ANY(subquery) | Value a is equal to any value returned by the subquery. |
| ALL | a <> ALL or != ALL (subquery) | Value a is not equal to any value returned by the subquery. |
| IS TRUE | FALSE | UNKNOWN | a IS TRUE | Value a is Boolean TRUE. |
문자열에 비교 연산자 사용
Redshift에서 문자열의 비교 연산자는 후행 공백을 무시한다는 점에 유의해야 합니다. Snowflake에서 이 동작을 복제하기 위해 변환은 RTRIM 함수를 적용하여 후행 공백을 제거하여 동등한 기능을 보장합니다. 자세한 내용: 후행 공백의 중요성
변환 테이블
대부분의 연산자는 Snowflake에서 직접 지원되지만 다음 연산자는 변환이 필요합니다.
| Redshift | Snowflake | Comments |
|---|---|---|
| (expression) IS TRUE | expression | Condition is TRUE. |
| (expression) IS FALSE | NOT (expression) | Condition is FALSE. |
| (expression) IS UNKNOWN | expression IS NULL | Expression evaluates to NULL (same as UNKNOWN). |
Sample Source Patterns
Input Code:
CREATE TABLE example_data (
id INT,
value INT,
status BOOLEAN,
category VARCHAR(10)
);
INSERT INTO example_data (id, value, status, category) VALUES
(1, 50, TRUE, 'A'),
(2, 30, FALSE, 'B'),
(3, 40, NULL, 'C'),
(4, 70, TRUE, 'A '),
(5, 60, FALSE, 'B');
SELECT *
FROM example_data
WHERE value < 60 AND value > 40;
SELECT *
FROM example_data
WHERE value <= 60 AND value >= 40;
SELECT *
FROM example_data
WHERE category = 'A';
SELECT *
FROM example_data
WHERE category != 'A' AND category <> 'B';
SELECT *
FROM example_data
WHERE category = ANY(SELECT category FROM example_data WHERE value > 60); --SOME
SELECT *
FROM example_data
WHERE value <> ALL (SELECT value FROM example_data WHERE status = TRUE);
SELECT *
FROM example_data
WHERE status IS TRUE;
SELECT *
FROM example_data
WHERE status IS FALSE;
SELECT *
FROM example_data
WHERE status IS UNKNOWN;
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
3 |
40 |
Null |
C |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
3 |
40 |
Null |
C |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
2 |
30 |
false |
B |
4 |
40 |
Null |
C |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
2 |
30 |
false |
B |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
4 |
40 |
Null |
C |
출력 코드:
CREATE TABLE example_data (
id INT,
value INT,
status BOOLEAN,
category VARCHAR(10)
);
INSERT INTO example_data (id, value, status, category) VALUES
(1, 50, TRUE, 'A'),
(2, 30, FALSE, 'B'),
(3, 40, NULL, 'C'),
(4, 70, TRUE, 'A '),
(5, 60, FALSE, 'B');
SELECT *
FROM example_data
WHERE value < 60 AND value > 40;
SELECT *
FROM example_data
WHERE value <= 60 AND value >= 40;
SELECT *
FROM example_data
WHERE RTRIM(category) = RTRIM('A ');
SELECT *
FROM example_data
WHERE RTRIM( category) != RTRIM( 'A') AND RTRIM( category) <> RTRIM( 'B');
SELECT *
FROM example_data
WHERE category = ANY(SELECT category FROM example_data WHERE value > 60); --SOME
SELECT *
FROM example_data
WHERE value <> ALL (SELECT value FROM example_data WHERE status = TRUE);
SELECT *
FROM example_data
WHERE status;
SELECT *
FROM example_data
WHERE NOT status;
SELECT *
FROM example_data
WHERE status IS NULL;
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
3 |
40 |
Null |
C |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
3 |
40 |
Null |
C |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
2 |
30 |
false |
B |
4 |
40 |
Null |
C |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
값 |
status |
카테고리 |
|---|---|---|---|
2 |
30 |
false |
B |
5 |
60 |
false |
B |
id |
값 |
status |
카테고리 |
|---|---|---|---|
4 |
40 |
Null |
C |
Known Issues
문제가 발견되지 않았습니다.
Related EWIs
알려진 문제는 없습니다.
EXISTS
Description
EXISTS 조건은 하위 쿼리에 행이 있는지 테스트하고 하위 쿼리가 1개 이상의 행을 반환하면 true을 반환합니다. NOT 을 지정하면 하위 쿼리가 행을 반환하지 않으면 조건은 true을 반환합니다. (Redshift SQL Language Reference EXISTS 조건)
Grammar Syntax
[ NOT ] EXISTS (table_subquery)
이 함수는 Snowflake 에서 완전하게 지원됩니다.
샘플 소스 패턴¶
설정 테이블¶
CREATE TABLE ExistsTest (
id INTEGER,
name VARCHAR(30),
lastname VARCHAR(30)
);
INSERT INTO ExistsTest (id, name, lastname) VALUES
(1, 'name1', 'lastname1'),
(2, 'name2', NULL),
(3, 'name3', 'lastname3'),
(4, 'name4', NULL);
CREATE TABLE ExistsTest (
id INTEGER,
name VARCHAR(30),
lastname VARCHAR(30)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/08/2025", "domain": "test" }}'
INSERT INTO ExistsTest (id, name, lastname) VALUES
(1, 'name1', 'lastname1'),
(2, 'name2', NULL),
(3, 'name3', 'lastname3'),
(4, 'name4', NULL);
입력 코드:¶
SELECT * FROM ExistsTest
WHERE EXISTS (
SELECT 1 FROM ExistsTest
WHERE lastname = 'lastname1'
)
ORDER BY id;
ID |
NAME |
LASTNAME |
|---|---|---|
1 |
name1 |
lastname1 |
2 |
name2 |
NULL |
3 |
name3 |
lastname3 |
4 |
name4 |
NULL |
출력 코드:¶
SELECT * FROM
ExistsTest
WHERE EXISTS (
SELECT 1 FROM
ExistsTest
WHERE lastname = 'lastname1'
)
ORDER BY id;
ID |
NAME |
LASTNAME |
|---|---|---|
1 |
name1 |
lastname1 |
2 |
name2 |
NULL |
3 |
name3 |
lastname3 |
4 |
name4 |
NULL |
관련 EWIs¶
관련 EWIs 없음.
알려진 문제 ¶
문제가 발견되지 않았습니다.
IN¶
설명¶
IN 조건은 값 세트 또는 하위 쿼리에서 값의 멤버 자격을 테스트합니다. (Redshift SQL Language Reference IN 조건)
문법 구문¶
expression [ NOT ] IN (expr_list | table_subquery)
이 함수는 Snowflake 에서 완전하게 지원됩니다.
Sample Source Patterns
Setup Table
CREATE TABLE sales (
id INTEGER IDENTITY(1,1),
price FLOAT,
saleDate DATE
);
INSERT INTO sales (price, saleDate) VALUES
(5000, '12/19/2024'),
(4000, '12/18/2024'),
(2000, '12/17/2024'),
(1000, '11/11/2024'),
(7000, '10/10/2024'),
(7000, '05/12/2024');
CREATE TABLE InTest (
col1 Varchar(20) COLLATE CASE_INSENSITIVE,
col2 Varchar(30) COLLATE CASE_SENSITIVE,
d1 date,
num integer,
idx integer);
INSERT INTO InTest values ('A', 'A', ('2012-03-02'), 4,6);
INSERT INTO InTest values ('a', 'a', ('2014-01-02'), 41,7);
CREATE TABLE InTest (
id INTEGER IDENTITY(1,1) ORDER,
price FLOAT,
saleDate DATE
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/09/2025", "domain": "test" }}';
INSERT INTO InTest (price, saleDate) VALUES
(5000, '12/19/2024'),
(4000, '12/18/2024'),
(2000, '12/17/2024'),
(1000, '11/11/2024'),
(7000, '10/10/2024'),
(7000, '05/12/2024');
CREATE TABLE InTest (
col1 Varchar(20) COLLATE 'en-ci',
col2 Varchar(30) COLLATE 'en-cs',
d1 date,
num integer,
idx integer)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/16/2025", "domain": "test" }}';
INSERT INTO InTest
values ('A', 'A', ('2012-03-02'), 4,6);
INSERT INTO InTest
values ('a', 'a', ('2014-01-02'), 41,7);
Input Code:
SELECT * FROM sales
WHERE id IN (2,3);
SELECT 5 IN (
SELECT id FROM sales
WHERE price = 7000
) AS ValidId;
select t.col1 in ('a ','b','c') as r1, t.col2 in ('a ','b','c') as r2 from InTest t order by t.idx;
ID |
PRICE |
SALEDATE |
|---|---|---|
2 |
4000 |
2024-12-18 |
3 |
2000 |
2024-12-17 |
VALIDID |
|---|
TRUE |
R1 |
R2 |
|---|---|
TRUE |
FALSE |
TRUE |
TRUE |
Output Code:
SELECT * FROM
sales
WHERE id IN (2,3);
SELECT 5 IN (
SELECT id FROM
sales
WHERE price = 7000
) AS ValidId;
select t.col1 in (RTRIM('a '), RTRIM('b'), RTRIM('c')) as r1, t.col2 in (RTRIM('a '), RTRIM('b'), RTRIM('c')) as r2 from
InTest t order by t.idx;
ID |
PRICE |
SALEDATE |
|---|---|---|
2 |
4000 |
2024-12-18 |
3 |
2000 |
2024-12-17 |
VALIDID |
|---|
TRUE |
R1 |
R2 |
|---|---|
TRUE |
FALSE |
TRUE |
TRUE |
Related EWIs
관련 EWIs 없음.
Known Issues
문제가 발견되지 않았습니다.
논리적 조건
Description
논리적 조건은 두 조건의 결과를 결합하여 1개의 결과를 생성합니다. 모든 논리 조건은 부울 반환 유형을 가진 이진 연산자입니다. (Redshift SQL Language Reference 논리 조건).
이 문법은 Snowflake 에서 완전히 지원됩니다.
문법 구문 ¶
expression
{ AND | OR }
expression
NOT expression
E1 |
E2 |
E1 AND E2 |
E1 OR E2 |
NOT E2 |
|---|---|---|---|---|
TRUE |
TRUE |
TRUE |
TRUE |
FALSE |
TRUE |
FALSE |
FALSE |
TRUE |
TRUE |
TRUE |
UNKNOWN |
UNKNOWN |
TRUE |
UNKNOWN |
FALSE |
TRUE |
FALSE |
TRUE |
|
FALSE |
FALSE |
FALSE |
FALSE |
|
FALSE |
UNKNOWN |
FALSE |
UNKNOWN |
|
UNKNOWN |
TRUE |
UNKNOWN |
TRUE |
|
UNKNOWN |
FALSE |
FALSE |
UNKNOWN |
|
UNKNOWN |
UNKNOWN |
UNKNOWN |
UNKNOWN |
샘플 소스 패턴¶
설정 데이터¶
CREATE TABLE employee (
employee_id INT,
active BOOLEAN,
department VARCHAR(100),
hire_date DATE,
salary INT
);
INSERT INTO employee (employee_id, active, department, hire_date, salary) VALUES
(1, TRUE, 'Engineering', '2021-01-15', 70000),
(2, FALSE, 'HR', '2020-03-22', 50000),
(3, NULL, 'Marketing', '2019-05-10', 60000),
(4, TRUE, 'Engineering', NULL, 65000),
(5, TRUE, 'Sales', '2018-11-05', NULL);
입력 코드:¶
SELECT
employee_id,
(active AND department = 'Engineering') AS is_active_engineering,
(department = 'HR' OR salary > 60000) AS hr_or_high_salary,
NOT active AS is_inactive,
(hire_date IS NULL) AS hire_date_missing,
(salary IS NULL OR salary < 50000) AS low_salary_or_no_salary
FROM employee;
| EMPLOYEE_ID | IS_ACTIVE_ENGINEERING | HR_OR_HIGH_SALARY | IS_INACTIVE | HIRE_DATE_MISSING | LOW_SALARY_OR_NO_SALARY |
|---|---|---|---|---|---|
| 1 | TRUE | TRUE | FALSE | FALSE | FALSE |
| 2 | FALSE | TRUE | TRUE | FALSE | FALSE |
| 3 | FALSE | FALSE | NULL | FALSE | FALSE |
| 4 | TRUE | TRUE | FALSE | TRUE | FALSE |
| 5 | FALSE | NULL | FALSE | FALSE | TRUE |
출력 코드:
SELECT
employee_id,
(active AND department = 'Engineering') AS is_active_engineering,
(department = 'HR' OR salary > 60000) AS hr_or_high_salary,
NOT active AS is_inactive,
(hire_date IS NULL) AS hire_date_missing,
(salary IS NULL OR salary < 50000) AS low_salary_or_no_salary
FROM
employee;
| EMPLOYEE_ID | IS_ACTIVE_ENGINEERING | HR_OR_HIGH_SALARY | IS_INACTIVE | HIRE_DATE_MISSING | LOW_SALARY_OR_NO_SALARY |
|---|---|---|---|---|---|
| 1 | TRUE | TRUE | FALSE | FALSE | FALSE |
| 2 | FALSE | TRUE | TRUE | FALSE | FALSE |
| 3 | FALSE | FALSE | NULL | FALSE | FALSE |
| 4 | TRUE | TRUE | FALSE | TRUE | FALSE |
| 5 | FALSE | NULL | FALSE | FALSE | TRUE |
Known Issues¶
문제가 발견되지 않았습니다.
관련 EWIs¶
알려진 문제는 없습니다.
NULL¶
설명¶
Null 조건은 값이 누락되었거나 알 수 없는 경우 null을 테스트합니다. (Redshift SQL Language Reference NULL 조건)
문법 구문¶
expression IS [ NOT ] NULL
이 함수는 Snowflake 에서 완전하게 지원됩니다.
Sample Source Patterns
Setup Table
CREATE TABLE NullTest (
id INTEGER,
name VARCHAR(30),
lastname VARCHAR(30)
);
INSERT INTO NullTest (id, name, lastname) VALUES
(1, 'name1', 'lastname1'),
(2, 'name2', NULL),
(3, 'name3', 'lastname3'),
(4, 'name4', NULL);
CREATE TABLE NullTest (
id INTEGER,
name VARCHAR(30),
lastname VARCHAR(30)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/08/2025", "domain": "test" }}';
INSERT INTO NullTest (id, name, lastname) VALUES
(1, 'name1', 'lastname1'),
(2, 'name2', NULL),
(3, 'name3', 'lastname3'),
(4, 'name4', NULL);
Input Code:
SELECT * FROM nulltest
WHERE lastname IS NULL;
ID |
NAME |
LASTNAME |
|---|---|---|
2 |
name2 |
NULL |
4 |
name4 |
NULL |
Output Code:
SELECT * FROM
nulltest
WHERE lastname IS NULL;
ID |
NAME |
LASTNAME |
|---|---|---|
2 |
name2 |
NULL |
4 |
name4 |
NULL |
Known Issues
문제가 발견되지 않았습니다.
Related EWIs
관련 EWIs 없음.
패턴 매칭 조건
Description
패턴 일치 연산자는 조건 식에 지정된 패턴을 문자열에서 검색하고 일치 여부에 따라 true 또는 false을 반환합니다. Amazon Redshift는 패턴 매칭에 세 가지 방법을 사용합니다.
LIKE 식 LIKE 연산자는 열 이름과 같은 문자열 식을 와일드카드 문자
%(퍼센트) 및_(밑줄)을 사용하는 패턴과 비교합니다. LIKE 패턴 일치는 항상 전체 문자열을 대상으로 합니다. LIKE 는 대/소문자 구분 일치를 수행하고, ILIKE 는 대/소문자를 구분하지 않는 일치를 수행합니다.SIMILAR TO 정규식 SIMILAR TO 연산자는 문자열 식을 SQL 표준 정규식 패턴과 일치시키며, LIKE 연산자가 지원하는 두 가지를 포함하는 패턴 일치 메타문자 세트를 포함할 수 있습니다. SIMILAR TO 는 전체 문자열을 일치시키고 대/소문자 구분 일치를 수행합니다.
POSIX 스타일 정규식 POSIX 정규식은 LIKE 및 SIMILAR TO 연산자보다 더 강력한 패턴 매칭 수단을 제공합니다. POSIX 정규식 패턴은 문자열의 모든 부분을 일치시킬 수 있으며 대/소문자 구분 일치를 수행합니다. (Redshift SQL Language Reference 패턴 일치 조건).
Known Issues
Snowflake에서 열이 유형이 CHAR 인 경우 (
LIKE,SIMILARTO,POSIX 연산자)와 같은 시나리오의 동작이 달라질 수 있습니다. 예:
CREATE TEMPORARY TABLE pattern_matching_sample (
col1 CHAR(10),
col2 VARCHAR(10)
);
INSERT INTO pattern_matching_sample VALUES ('1','1');
INSERT INTO pattern_matching_sample VALUES ('1234567891','1234567891');
INSERT INTO pattern_matching_sample VALUES ('234567891','234567891');
SELECT
col1 LIKE '%1' as "like(CHAR(10))",
COL2 LIKE '%1' as "like(VARCHAR(10))"
FROM
pattern_matching_sample;
like(CHAR(10)) |
like(VARCHAR(10)) |
|---|---|
FALSE |
TRUE |
TRUE |
TRUE |
FALSE |
TRUE |
like(CHAR(10)) |
like(VARCHAR(10)) |
|---|---|
TRUE |
TRUE |
TRUE |
TRUE |
TRUE |
TRUE |
CHAR(10)은 ‘수정 길이’이므로 ‘%1’ 패턴이 CHAR(10) 열의 10번째 위치에 있는 ‘1’과 일치해야 한다고 가정합니다. 그러나 Snowflake에서는 문자열에 ‘1’이 존재하고 그 앞에 0 이상의 문자가 포함된 시퀀스가 있으면 일치합니다.
LIKE
Description
LIKE 연산자는 열 이름과 같은 문자열 식을 와일드카드 문자 %(퍼센트) 및 _(밑줄)을 사용하는 패턴과 비교합니다. LIKE 패턴 일치는 항상 전체 문자열을 대상으로 합니다. 문자열 내에서 시퀀스를 일치시키려면 패턴이 퍼센트 기호로 시작하고 퍼센트 기호로 끝나야 합니다. (Redshift SQL Language Reference LIKE).
이 문법은 Snowflake 에서 완전히 지원됩니다.
참고
Snowflake에서 이스케이프 문자가 제공되지 않는 경우, 기본 Redshift 이스케이프 문자 '\\' 가 추가되어 완전히 동일하게 표시됩니다.
문법 구문 ¶
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
샘플 소스 패턴¶
설정 데이터¶
CREATE TABLE like_ex(name VARCHAR(20));
INSERT INTO like_ex VALUES
('John Dddoe'),
('Joe Doe'),
('Joe Doe '),
(' Joe Doe '),
(' Joe \n Doe '),
('John_down'),
('Joe down'),
('Elaine'),
(''),
(null),
('1000 times'),
('100%');
Like¶
입력 코드:¶
SELECT name
FROM like_ex
WHERE name LIKE '%Jo%oe%'
ORDER BY name;
NAME |
|---|
Joe Doe |
Joe Doe |
Joe Doe |
Joe Doe |
John Dddoe |
출력 코드:
SELECT name
FROM like_ex
WHERE name LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
NAME |
|---|
Joe Doe |
Joe Doe |
Joe Doe |
Joe Doe |
John Dddoe |
Not like¶
입력 코드:¶
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%'
ORDER BY name;
NAME |
|---|
100% |
1000회 |
Elaine |
Joe down |
John_down |
dd
출력 코드:
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
NAME |
|---|
100% |
1000회 |
Elaine |
Joe down |
John_down |
이스케이프 문자¶
입력 코드:¶
SELECT name
FROM like_ex
WHERE name LIKE '%J%h%^_do%' ESCAPE '^'
ORDER BY name;
SELECT name
FROM like_ex
WHERE name LIKE '100\\%'
ORDER BY 1;
NAME |
|---|
John_down |
NAME |
|---|
100% |
출력 코드:
SELECT name
FROM like_ex
WHERE name LIKE '%J%h%^_do%' ESCAPE '^'
ORDER BY name;
SELECT name
FROM like_ex
WHERE name LIKE '100\\%' ESCAPE '\\'
ORDER BY 1;
NAME |
|---|
John_down |
NAME |
|---|
100% |
ILike¶
입력 코드:¶
SELECT 'abc' LIKE '_B_' AS r1,
'abc' ILIKE '_B_' AS r2;
R1 |
R2 |
|---|---|
FALSE |
TRUE |
출력 코드:
SELECT 'abc' LIKE '_B_' ESCAPE '\\' AS r1,
'abc' ILIKE '_B_' ESCAPE '\\' AS r2;
R1 |
R2 |
|---|---|
FALSE |
TRUE |
연산자¶
다음 연산자는 다음과 같이 변환됩니다.
Redshift |
Snowflake |
|---|---|
~~ |
LIKE |
!~~ |
NOT LIKE |
~~* |
ILIKE |
!~~* |
NOT ILIKE |
입력 코드:¶
SELECT 'abc' ~~ 'abc' AS r1,
'abc' !~~ 'a%' AS r2,
'abc' ~~* '_B_' AS r3,
'abc' !~~* '_B_' AS r4;
R1 |
R2 |
R3 |
R4 |
|---|---|---|---|
TRUE |
FALSE |
TRUE |
FALSE |
출력 코드:
SELECT 'abc' LIKE 'abc' ESCAPE '\\' AS r1,
'abc' NOT LIKE 'a%' ESCAPE '\\' AS r2,
'abc' ILIKE '_B_' ESCAPE '\\' AS r3,
'abc' NOT ILIKE '_B_' ESCAPE '\\' AS r4;
R1 |
R2 |
R3 |
R4 |
|---|---|---|---|
TRUE |
FALSE |
TRUE |
FALSE |
Known Issues¶
수정된 문자 유형의 동작은 다를 수 있습니다. 자세한 내용은 여기에서 확인할 수 있습니다.
관련 EWIs¶
알려진 문제는 없습니다.
POSIX 연산자¶
설명 ¶
POSIX 정규식은 일치 패턴을 지정하는 문자 시퀀스입니다. 문자열이 정규식으로 설명된 정규식 세트의 멤버인 경우 정규식과 일치합니다. POSIX 정규식 패턴은 문자열의 모든 부분과 일치할 수 있습니다. (Redshift SQL Language ReferencePOSIX 연산자).
경고
이 문법은 Snowflake 에서 부분적으로 지원됩니다. POSIX 연산자는 Snowflake에서 REGEXP_COUNT 로 변환됩니다.
문법 구문 ¶
expression [ ! ] ~ pattern
POSIX 패턴 일치 메타문자¶
POSIX 패턴 일치는 다음 메타문자를 지원합니다(모든 대/소문자는 Snowflake에서 지원됨).
POSIX |
설명 |
|---|---|
. |
임의의 문자 1개와 일치합니다. |
|
발생 횟수가 0개 이상 일치합니다. |
|
1개 이상의 발생과 일치합니다. |
|
0 또는 1개의 발생과 일치합니다. |
|
대체 일치 항목을 지정합니다. |
|
라인의 시작 문자와 일치합니다. |
|
라인 끝 문자와 일치합니다. |
|
문자열의 끝을 일치시킵니다. |
[ ] |
괄호는 일치하는 목록을 지정하며, 목록에서 1개의 식과 일치해야 합니다. |
|
괄호는 항목을 1개의 논리적 항목으로 그룹화합니다. |
|
이전 항목을 정확히 _m_회 반복합니다. |
|
이전 항목을 _m_회 이상 반복합니다. |
|
이전 항목을 최소 _m_회 이상 _n_회 이하로 반복합니다. |
|
POSIX 문자 클래스 내의 모든 문자와 일치합니다. |
매개 변수 ‘m’(여러 라인 모드 활성화) 및 ‘s’(POSIX 와일드카드 문자 . 가 새 라인과 일치하도록 허용)는 Snowflake에서 완전한 동등성을 달성하는 데 사용됩니다. 자세한 내용은 Snowflake에서 정규식에 매개 변수 지정하기 섹션을 참조하십시오.
샘플 소스 패턴¶
설정 데이터¶
CREATE TABLE posix_test_table (
id INT,
column_name VARCHAR(255)
);
INSERT INTO posix_test_table (id, column_name)
VALUES
(1, 'abc123\nhello world'),
(2, 'test string\nwith multiple lines\nin this entry'),
(3, '123abc\nanother line\nabc123'),
(4, 'line1\nline2\nline3'),
(5, 'start\nmiddle\nend'),
(6, 'a@b#c!\nmore text here'),
(7, 'alpha\nbeta\ngamma'),
(8, 'uppercase\nlowercase'),
(9, 'line1\nline2\nline3\nline4'),
(10, '1234567890\nmore digits'),
(11, 'abc123\nabc456\nabc789'),
(12, 'start\nend\nmiddle'),
(13, 'this is the first line\nthis is the second line'),
(14, 'special characters\n!@#$%^&*()');
.: 모든 문자와 일치합니다¶
입력 코드:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ 'a.c';
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
11 |
abc123 abc456 abc789 |
출력 코드:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a.c', 1, 'ms') > 0;
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
11 |
abc123 abc456 abc789 |
*: 발생 횟수가 0개 이상 일치합니다.¶
입력 코드:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ 'a*b';
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
6 |
a@b#c! 여기에 텍스트 추가 |
7 |
alpha beta gamma |
11 |
abc123 abc456 abc789 |
출력 코드:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a*b', 1, 'ms') > 0;
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
6 |
a@b#c! 여기에 텍스트 추가 |
7 |
alpha beta gamma |
11 |
abc123 abc456 abc789 |
? : 0 또는 1개 발생과 일치합니다.¶
입력 코드:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ 'a?b';
ID |
COLUMN_NAME |
|---|---|
2 |
이 항목에 여러 라인이 있는 문자열을 테스트합니다 |
4 |
line1 line2 line3 |
5 |
start middle end |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 자릿수 더 보기 |
12 |
start end middle |
13 |
이것은 첫 번째 라인입니다. 이것은 두 번째 라인입니다 |
14 |
특수 문자 !@#$%^&*() |
출력 코드:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a?b', 1, 'ms') = 0;
ID |
COLUMN_NAME |
|---|---|
2 |
이 항목에 여러 라인이 있는 문자열을 테스트합니다 |
4 |
line1 line2 line3 |
5 |
start middle end |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 자릿수 더 보기 |
12 |
start end middle |
13 |
이것은 첫 번째 라인입니다. 이것은 두 번째 라인입니다 |
14 |
특수 문자 !@#$%^&*() |
^ : 라인의 시작 문자와 일치합니다¶
입력 코드:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ '^abc';
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
11 |
abc123 abc456 abc789 |
출력 코드:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, '^abc', 1, 'ms') > 0;
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc 다른 라인 abc123 |
11 |
abc123 abc456 abc789 |
$ : 문자열의 끝과 일치합니다.¶
입력 코드:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ '123$';
ID |
COLUMN_NAME |
|---|---|
2 |
이 항목에 여러 라인이 있는 문자열을 테스트합니다 |
4 |
line1 line2 line3 |
5 |
start middle end |
6 |
a@b#c! 여기에 텍스트 추가 |
7 |
alpha beta gamma |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 자릿수 더 보기 |
12 |
start end middle |
13 |
이것은 첫 번째 라인입니다. 이것은 두 번째 라인입니다 |
14 |
특수 문자 !@#$%^&*() |
출력 코드:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, '123$', 1, 'ms') = 0;
ID |
COLUMN_NAME |
|---|---|
2 |
이 항목에 여러 라인이 있는 문자열을 테스트합니다 |
4 |
line1 line2 line3 |
5 |
start middle end |
6 |
a@b#c! 여기에 텍스트 추가 |
7 |
alpha beta gamma |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 자릿수 더 보기 |
12 |
start end middle |
13 |
이것은 첫 번째 라인입니다. 이것은 두 번째 라인입니다 |
14 |
특수 문자 !@#$%^&*() |
데이터 정렬 열 사용법¶
COLLATE 사양의 인자는 현재 RLIKE 함수에서 지원되지 않습니다. 따라서 이 함수를 사용하려면 COLLATE 절을 비활성화해야 합니다. 그러나 이로 인해 결과에 차이가 발생할 수 있습니다.
입력 코드:¶
CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE CASE_INSENSITIVE,
col2 VARCHAR(30) COLLATE CASE_SENSITIVE);
INSERT INTO collateTable values ('HELLO WORLD!', 'HELLO WORLD!');
SELECT
col1 ~ 'Hello.*' as ci,
col2 ~ 'Hello.*' as cs
FROM collateTable;
CI |
CS |
|---|---|
TRUE |
FALSE |
출력 코드:
CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE 'en-ci',
col2 VARCHAR(30) COLLATE 'en-cs'
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/16/2025", "domain": "test" }}';
INSERT INTO collateTable
values ('HELLO WORLD!', 'HELLO WORLD!');
SELECT
REGEXP_COUNT(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col1, ''), 'Hello.*', 1, 'ms') > 0 as ci,
REGEXP_COUNT(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col2, ''), 'Hello.*', 1, 'ms') > 0 as cs
FROM
collateTable;
CI |
CS |
|---|---|
FALSE |
FALSE |
이러한 시나리오에 대한 동등성이 요구되는 경우 함수에 다음 매개 변수를 수동으로 추가하여 기능적 동등성을 달성할 수 있습니다.
매개 변수 |
설명 |
|---|---|
|
대/소문자를 구분하는 일치 |
|
대/소문자를 구분하지 않는 일치 |
Known Issues¶
Known Issues¶
수정된 문자 유형의 동작은 다를 수 있습니다. 자세한 내용은 여기에서 확인할 수 있습니다.
COLLATE 사양의 인자는 현재 REGEXP_COUNT 함수에서 지원되지 않습니다.
관련 EWIs¶
SSC-FDM-PG0011: 이 패턴 일치 조건에 대해 COLLATE 열 제약 조건의 사용은 비활성화되었습니다.
SIMILAR TO¶
설명 ¶
SIMILAR TO 연산자는 열 이름과 같은 문자열 표현식을 SQL 표준 정규식 패턴과 일치시킵니다. SQL 정규식 패턴에는 LIKE 연산자가 지원하는 두 가지를 포함하여 패턴을 일치시키는 메타문자 집합이 포함될 수 있습니다. (Redshift SQL Language Reference SIMILAR TO).
문법 구문 ¶
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
패턴 일치 메타문자¶
| Redshift | Snowflake | Notes |
|---|---|---|
| ```{code} sql :force: % ``` | ```{code} sql :force: .* ``` | Matches any sequence of zero or more characters. To achieve full equivalence in Snowflake, we need to replace the '%' operator with '.*' in the pattern. |
| ```{code} sql :force: _ ``` | ```{code} sql :force: . ``` | Matches any single character. To achieve full equivalence in Snowflake, we need to replace the _ operator with . and add the s parameter to enable the POSIX wildcard character . to match newline characters. |
| ```{code} sql :force: | ``` | ```{code} sql :force: | ``` | Denotes alternation. This case is fully supported in Snowflake. |
| ```{code} sql :force: * ``` | ```{code} sql :force: * ``` | Repeat the previous item zero or more times. This can have a different behavior when newline characters are included. |
| ```{code} sql :force: + ``` | ```{code} sql :force: + ``` | Repeat the previous item one or more times. This can have a different behavior when newline characters are included. |
| ```{code} sql :force: ? ``` | ```{code} sql :force: ? ``` | Repeat the previous item zero or one time. This can have a different behavior when newline characters are included. |
| ```{code} sql :force: {m} ``` | ```{code} sql :force: {m} ``` | Repeat the previous item exactly m times and it is fully supported in Snowflake. |
| ```{code} sql :force: {m,} ``` | ```{code} sql :force: {m,} ``` | Repeat the previous item at least m and not more than n times and it is fully supported in Snowflake. |
| ```{code} sql :force: {m,n} ``` | ```{code} sql :force: {m,n} ``` | Repeat the previous item m or more times and it is fully supported in Snowflake. |
| ```{code} sql :force: () ``` | ```{code} sql :force: () ``` | Parentheses group items into a single logical item and it is fully supported in Snowflake. |
| ```{code} sql :force: [...] ``` | ```{code} sql :force: [...] ``` | A bracket expression specifies a character class, just as in POSIX regular expressions. |
샘플 소스 패턴¶
설정 데이터¶
CREATE TABLE similar_table_ex (
column_name VARCHAR(255)
);
INSERT INTO similar_table_ex (column_name)
VALUES
('abc_123'),
('a_cdef'),
('bxyz'),
('abcc'),
('start_hello'),
('apple'),
('banana'),
('xyzabc'),
('abc\ncccc'),
('\nabccc'),
('abc%def'),
('abc_xyz'),
('abc_1_xyz'),
('applepie'),
('start%_abc'),
('ab%_xyz'),
('abcs_123_xyz'),
('aabc123'),
('xyzxyz'),
('123abc\nanother line\nabc123');
% : Matches any sequence of zero or more characters¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '%abc%';
COLUMN_NAME |
|---|
abc_123 |
abcc |
xyzabc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
start%_abc |
abcs_123_xyz |
aabc123 |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '.*abc.*', 's');
COLUMN_NAME |
|---|
abc_123 |
abcc |
xyzabc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
start%_abc |
abcs_123_xyz |
aabc123 |
_ : 단일 문자와 일치합니다¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a_c%';
COLUMN_NAME |
|---|
abc_123 |
a_cdef |
abcc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
abcs_123_xyz |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a.c.*', 's');
COLUMN_NAME |
|---|
abc_123 |
a_cdef |
abcc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
abcs_123_xyz |
| : 대안을 나타냄¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a|b%';
COLUMN_NAME |
|---|
bxyz |
banana |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a|b.*', 's');
COLUMN_NAME |
|---|
bxyz |
banana |
{m, n} : 이전 항목을 정확히 _m_회 반복합니다.¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc{2,4}';
COLUMN_NAME |
|---|
abcc |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc{2,4}', 's');
COLUMN_NAME |
|---|
abcc |
+ : Repeat the previous item one or more times¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc+';
COLUMN_NAME |
|---|
abcc |
abc cccc |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc+', 's');
COLUMN_NAME |
|---|
abcc |
* : 이전 항목을 0회 이상 반복합니다¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc*c';
COLUMN_NAME |
|---|
abcc |
abc cccc |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc*c', 's');
COLUMN_NAME |
|---|
abcc |
? : 이전 항목을 0 또는 한 번 반복합니다¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc?c';
COLUMN_NAME |
|---|
abcc |
abc ccc |
출력 코드:
SELECT column_name
FROM
similar_table_ex
WHERE
RLIKE( column_name, 'abc?c', 's');
COLUMN_NAME |
|---|
abcc |
() : 괄호는 항목을 단일 논리 항목으로 그룹화합니다¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '(abc|xyz)%';
COLUMN_NAME |
|---|
abc_123 |
abcc |
xyzabc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
abcs_123_xyz |
xyzxyz |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '(abc|xyz).*', 's');
COLUMN_NAME |
|---|
abc_123 |
abcc |
xyzabc |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
abcs_123_xyz |
xyzxyz |
[…] : 문자 클래스를 지정합니다¶
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '[a-c]%';
COLUMN_NAME |
|---|
abc_123 |
a_cdef |
bxyz |
abcc |
apple |
banana |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
applepie |
ab%_xyz |
abcs_123_xyz |
aabc123 |
출력 코드:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '[a-c].*', 's');
COLUMN_NAME |
|---|
abc_123 |
a_cdef |
bxyz |
abcc |
apple |
banana |
abc cccc |
abc%def |
abc_xyz |
abc_1_xyz |
applepie |
ab%_xyz |
abcs_123_xyz |
aabc123 |
이스케이프 문자¶
다음 문자가 패턴에 나타나고 이스케이프 문자가 아닌 경우 이스케이프됩니다.
.
$
^
입력 코드:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '%abc^_%' ESCAPE '^';
SELECT '$0.87' SIMILAR TO '$[0-9]+(.[0-9][0-9])?' r1;
COLUMN_NAME |
|---|
abc_123 |
abc_xyz |
abc_1_xyz |
R1 |
|---|
TRUE |
출력 코드:
SELECT column_name
FROM
similar_table_ex
WHERE
RLIKE( column_name, '.*abc\\_.*', 's');
SELECT
RLIKE( '$0.87', '\\$[0-9]+(\\.[0-9][0-9])?', 's') r1;
COLUMN_NAME |
|---|
abc_123 |
abc_xyz |
abc_1_xyz |
R1 |
|---|
TRUE |
변수에 저장된 패턴¶
이러한 패턴을 변수에 저장하면 동등성을 위해 필수 조정이 적용되지 않습니다. 이 문서의 초반부에 작성된 테이블 에 명시된 권장 사항을 참고하여 추가적인 동등성 지침을 확인할 수 있습니다.
입력 코드:¶
WITH pattern AS (
SELECT '%abc%'::VARCHAR AS search_pattern
)
SELECT column_name
FROM similar_table_ex, pattern
WHERE column_name SIMILAR TO pattern.search_pattern;
COLUMN_NAME |
|---|
abc_123 |
abcc |
xyzabc |
abc cccc |
abccc |
abc%def |
abc_xyz |
abc_1_xyz |
start%_abc |
abcs_123_xyz |
aabc123 |
123abc 다른 라인 abc123 |
출력 코드:
WITH pattern AS (
SELECT '%abc%'::VARCHAR AS search_pattern
)
SELECT column_name
FROM
similar_table_ex,
pattern
WHERE
RLIKE( column_name,
--** SSC-FDM-0032 - PARAMETER 'search_pattern' IS NOT A LITERAL VALUE, TRANSFORMATION COULD NOT BE FULLY APPLIED **
pattern.search_pattern, 's');
COLUMN_NAME |
|---|
쿼리 결과가 없습니다 |
데이터 정렬 열 사용법¶
COLLATE 사양의 인자는 현재 RLIKE 함수에서 지원되지 않습니다. 따라서 이 함수를 사용하려면 COLLATE 절을 비활성화해야 합니다. 그러나 이로 인해 결과에 차이가 발생할 수 있습니다.
입력 코드:¶
CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE CASE_INSENSITIVE,
col2 VARCHAR(30) COLLATE CASE_SENSITIVE);
INSERT INTO collateTable values ('HELLO WORLD!', 'HELLO WORLD!');
SELECT
col1 SIMILAR TO 'Hello%' as ci,
col2 SIMILAR TO 'Hello%' as cs
FROM collateTable;
CI |
CS |
|---|---|
TRUE |
FALSE |
출력 코드:
CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE 'en-ci',
col2 VARCHAR(30) COLLATE 'en-cs'
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/16/2025", "domain": "test" }}';
INSERT INTO collateTable
values ('HELLO WORLD!', 'HELLO WORLD!');
SELECT
RLIKE(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col1, ''), 'Hello.*', 's') as ci,
RLIKE(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col2, ''), 'Hello.*', 's') as cs
FROM
collateTable;
CI |
CS |
|---|---|
FALSE |
FALSE |
이러한 시나리오에 대한 동등성이 요구되는 경우 함수에 다음 매개 변수를 수동으로 추가하여 기능적 동등성을 달성할 수 있습니다.
매개 변수 |
설명 |
|---|---|
|
대/소문자를 구분하는 일치 |
|
대/소문자를 구분하지 않는 일치 |
Known Issues¶
수정된 문자 유형의 동작은 다를 수 있습니다.
RLIKE함수는 POSIX 확장 정규식을 사용하므로, 특정 경우 특히 라인 바꿈이 포함된 경우 동작이 달라질 수 있습니다. 문자열에 라인 바꿈이 있고 한 라인에서 일치 항목이 발생하면 문자열 전체가 아닌 한 라인에서만 일치 항목이 발생하더라도 전체 문자열에 대해 긍정적인 결과를 반환하는 것으로 보입니다. 예:
CREATE TABLE table1 (
col1 VARCHAR(20)
);
INSERT INTO table1 values ('abcccc'), ('abc\neab'), ('abc\nccc');
SELECT col1
FROM table1
WHERE col1 SIMILAR TO 'abc*c';
CREATE TABLE table1 (
col1 VARCHAR(20)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "01/14/2025", "domain": "test" }}';
INSERT INTO table1
values ('abcccc'), ('abc\neab'), ('abc\nccc');
SELECT col1
FROM
table1
WHERE
RLIKE( col1, 'abc*c', 's');
COL1 |
|---|
abcccc |
abc eab |
abc ccc |
COL1 |
|---|
abcccc |
최대한의 동등성을 달성하기 위해 패턴 연산자를 일부 수정했습니다.
이러한 패턴이 변수에 저장된 경우 SnowConvert 는 동등성을 위해 필요한 조정을 적용하지 않습니다.
COLLATE 사양의 인자는 현재 RLIKE 함수에서 지원되지 않습니다.
관련 EWIs¶
SSC-FDM-0032: 매개 변수가 리터럴 값이 아니므로 변환을 완전히 적용할 수 없습니다.
SSC-FDM-PG0011: 이 패턴 일치 조건에 대해 COLLATE 열 제약 조건의 사용은 비활성화되었습니다.