SnowConvert AI - Redshift - 조건¶
BETWEEN¶
설명¶
BETWEEN조건은BETWEEN및AND키워드를 사용하여 식이 값 범위에 포함되는지 테스트합니다. (Redshift SQL Language Reference BETWEEN 조건)
문법 구문¶
expression [ NOT ] BETWEEN expression AND expression
참고
이 함수는 Snowflake 에서 완전하게 지원됩니다.
샘플 소스 패턴¶
설정 테이블¶
Redshift¶
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');
Snowflake¶
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');
입력 코드:¶
Redshift¶
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 |
출력 코드:¶
Snowflake¶
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 |
알려진 문제 ¶
문제가 발견되지 않았습니다.
비교 조건¶
조건
설명 ¶
비교 조건은 두 값 간의 논리적 관계를 나타냅니다. 모든 비교 조건은 부울 반환 유형을 가진 이진 연산자입니다.
문법 구문 ¶
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). |
샘플 소스 패턴¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
CREATE TABLE example_data (
id INT,
value INT,
status BOOLEAN,
category VARCHAR(10)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": { "major": 0, "minor": 0, "patch": "0" }, "attributes": { "component": "redshift", "convertedOn": "07/11/2025", "domain": "no-domain-provided" }}';
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;
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¶
문제가 발견되지 않았습니다.
관련 EWIs¶
알려진 문제는 없습니다.
EXISTS¶
설명¶
EXISTS 조건은 하위 쿼리에 행이 있는지 테스트하고 하위 쿼리가 1개 이상의 행을 반환하면 true을 반환합니다. NOT 을 지정하면 하위 쿼리가 행을 반환하지 않으면 조건은 true을 반환합니다. (Redshift SQL Language Reference EXISTS 조건)
문법 구문¶
[ 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);
입력 코드:¶
Redshift¶
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 |
출력 코드:¶
Snowflake¶
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 에서 완전하게 지원됩니다.
샘플 소스 패턴¶
설정 테이블¶
Redshift¶
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);
Snowflake¶
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);
입력 코드:¶
Redshift¶
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 |
출력 코드:¶
Snowflake¶
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 |
관련 EWIs¶
관련 EWIs 없음.
알려진 문제 ¶
문제가 발견되지 않았습니다.
논리적 조건¶
설명 ¶
논리적 조건은 두 조건의 결과를 결합하여 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 |
샘플 소스 패턴¶
설정 데이터¶
Redshift¶
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);
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 에서 완전하게 지원됩니다.
샘플 소스 패턴¶
설정 테이블¶
Redshift¶
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);
Snowflake¶
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);
입력 코드:¶
Redshift¶
SELECT * FROM nulltest
WHERE lastname IS NULL;
결과¶
ID |
NAME |
LASTNAME |
|---|---|---|
2 |
name2 |
NULL |
4 |
name4 |
NULL |
출력 코드:¶
Snowflake¶
SELECT * FROM
nulltest
WHERE lastname IS NULL;
결과¶
ID |
NAME |
LASTNAME |
|---|---|---|
2 |
name2 |
NULL |
4 |
name4 |
NULL |
알려진 문제 ¶
문제가 발견되지 않았습니다.
관련 EWIs¶
관련 EWIs 없음.
패턴 매칭 조건¶
설명 ¶
패턴 일치 연산자는 조건 식에 지정된 패턴을 문자열에서 검색하고 일치 여부에 따라 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;
Redshift 결과¶
like(CHAR(10)) |
like(VARCHAR(10)) |
|---|---|
FALSE |
TRUE |
TRUE |
TRUE |
FALSE |
TRUE |
Snowflake 결과¶
like(CHAR(10)) |
like(VARCHAR(10)) |
|---|---|
TRUE |
TRUE |
TRUE |
TRUE |
TRUE |
TRUE |
CHAR(10)은 ‘수정 길이’이므로 ‘%1’ 패턴이 CHAR(10) 열의 10번째 위치에 있는 ‘1’과 일치해야 한다고 가정합니다. 그러나 Snowflake에서는 문자열에 ‘1’이 존재하고 그 앞에 0 이상의 문자가 포함된 시퀀스가 있으면 일치합니다.
LIKE¶
패턴 매칭 조건
설명 ¶
LIKE 연산자는 열 이름과 같은 문자열 식을 와일드카드 문자 %(퍼센트) 및 _(밑줄)을 사용하는 패턴과 비교합니다. LIKE 패턴 일치는 항상 전체 문자열을 대상으로 합니다. 문자열 내에서 시퀀스를 일치시키려면 패턴이 퍼센트 기호로 시작하고 퍼센트 기호로 끝나야 합니다. (Redshift SQL Language Reference LIKE).
참고
이 문법은 Snowflake에서 완벽하게 지원됩니다.
참고
Snowflake에서 이스케이프 문자가 제공되지 않는 경우, 기본 Redshift 이스케이프 문자 '\\' 가 추가되어 완전히 동일하게 표시됩니다.
문법 구문 ¶
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
샘플 소스 패턴¶
설정 데이터¶
Redshift¶
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¶
입력 코드:¶
Redshift¶
SELECT name
FROM like_ex
WHERE name LIKE '%Jo%oe%'
ORDER BY name;
결과¶
NAME |
|---|
Joe Doe |
Joe Doe |
Joe Doe |
Joe Doe |
John Dddoe |
출력 코드:
Snowflake¶
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¶
입력 코드:¶
Redshift¶
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%'
ORDER BY name;
결과¶
NAME |
|---|
100% |
1000회 |
Elaine |
Joe down |
John_down |
dd
출력 코드:
Snowflake¶
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
결과¶
NAME |
|---|
100% |
1000회 |
Elaine |
Joe down |
John_down |
이스케이프 문자¶
입력 코드:¶
Redshift¶
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% |
출력 코드:
Snowflake¶
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¶
입력 코드:¶
Redshift¶
SELECT 'abc' LIKE '_B_' AS r1,
'abc' ILIKE '_B_' AS r2;
결과¶
R1 |
R2 |
|---|---|
FALSE |
TRUE |
출력 코드:
Snowflake¶
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 |
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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에서 정규식에 매개 변수 지정하기 섹션을 참조하십시오.
샘플 소스 패턴¶
설정 데이터¶
Redshift¶
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!@#$%^&*()');
.: 모든 문자와 일치합니다¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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개 이상 일치합니다.¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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개 발생과 일치합니다.¶
입력 코드:¶
Redshift¶
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 |
특수 문자 !@#$%^&*() |
출력 코드:
Snowflake¶
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 |
특수 문자 !@#$%^&*() |
^ : 라인의 시작 문자와 일치합니다¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
$ : 문자열의 끝과 일치합니다.¶
입력 코드:¶
Redshift¶
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 |
특수 문자 !@#$%^&*() |
출력 코드:
Snowflake¶
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 절을 비활성화해야 합니다. 그러나 이로 인해 결과에 차이가 발생할 수 있습니다.
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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. |
샘플 소스 패턴¶
설정 데이터¶
Redshift¶
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¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
_ : 단일 문자와 일치합니다¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
| : 대안을 나타냄¶
입력 코드:¶
Redshift¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a|b%';
결과¶
COLUMN_NAME |
|---|
bxyz |
banana |
출력 코드:
Snowflake¶
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a|b.*', 's');
결과¶
COLUMN_NAME |
|---|
bxyz |
banana |
{m, n} : 이전 항목을 정확히 _m_회 반복합니다.¶
입력 코드:¶
Redshift¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc{2,4}';
결과¶
COLUMN_NAME |
|---|
abcc |
출력 코드:
Snowflake¶
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¶
입력 코드:¶
Redshift¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc+';
결과¶
COLUMN_NAME |
|---|
abcc |
abc cccc |
출력 코드:
Snowflake¶
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc+', 's');
결과¶
COLUMN_NAME |
|---|
abcc |
* : 이전 항목을 0회 이상 반복합니다¶
입력 코드:¶
Redshift¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc*c';
결과¶
COLUMN_NAME |
|---|
abcc |
abc cccc |
출력 코드:
Snowflake¶
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc*c', 's');
결과¶
COLUMN_NAME |
|---|
abcc |
? : 이전 항목을 0 또는 한 번 반복합니다¶
입력 코드:¶
Redshift¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc?c';
결과¶
COLUMN_NAME |
|---|
abcc |
abc ccc |
출력 코드:
Snowflake¶
SELECT column_name
FROM
similar_table_ex
WHERE
RLIKE( column_name, 'abc?c', 's');
결과¶
COLUMN_NAME |
|---|
abcc |
() : 괄호는 항목을 단일 논리 항목으로 그룹화합니다¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
[…] : 문자 클래스를 지정합니다¶
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
이스케이프 문자¶
다음 문자가 패턴에 나타나고 이스케이프 문자가 아닌 경우 이스케이프됩니다.
.
$
^
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 |
변수에 저장된 패턴¶
이러한 패턴을 변수에 저장하면 동등성을 위해 필수 조정이 적용되지 않습니다. 이 문서의 초반부에 작성된 테이블 에 명시된 권장 사항을 참고하여 추가적인 동등성 지침을 확인할 수 있습니다.
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 절을 비활성화해야 합니다. 그러나 이로 인해 결과에 차이가 발생할 수 있습니다.
입력 코드:¶
Redshift¶
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 |
출력 코드:
Snowflake¶
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 확장 정규식을 사용하므로, 특정 경우 특히 라인 바꿈이 포함된 경우 동작이 달라질 수 있습니다. 문자열에 라인 바꿈이 있고 한 라인에서 일치 항목이 발생하면 문자열 전체가 아닌 한 라인에서만 일치 항목이 발생하더라도 전체 문자열에 대해 긍정적인 결과를 반환하는 것으로 보입니다. 예:
Redshift 코드¶
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';
Snowflake 코드¶
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');
Redshift 결과¶
COL1 |
|---|
abcccc |
abc eab |
abc ccc |
Snowflake 결과¶
COL1 |
|---|
abcccc |
최대 동등성을 달성하기 위해 패턴 연산자가 일부 수정되었습니다.
이러한 패턴이 변수에 저장되면 SnowConvert AI는 동등성을 위해 필요한 조정을 적용하지 않습니다.
COLLATE 사양의 인자는 현재 RLIKE 함수에서 지원되지 않습니다.
관련 EWIs¶
SSC-FDM-0032: 매개 변수가 리터럴 값이 아니므로 변환을 완전히 적용할 수 없습니다.
SSC-FDM-PG0011: 이 패턴 일치 조건에 대해 COLLATE 열 제약 조건의 사용은 비활성화되었습니다.