SnowConvert: Redshiftの条件¶
BETWEEN¶
説明¶
BETWEEN 条件は、キーワード BETWEEN と AND を使用して、値の範囲に式が含まれるかどうかをテストします。(Redshift SQL 言語リファレンス 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 );
count |
|---|
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 );
count |
|---|
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
比較条件は、2つの値の論理的な関係を示します。すべての比較条件はバイナリ演算子で、戻り値はブール型です。(RedShift SQL 言語リファレンス比較条件)
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 |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
3 |
40 |
null |
C |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
3 |
40 |
null |
C |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
2 |
30 |
false |
B |
4 |
40 |
null |
C |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
2 |
30 |
false |
B |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
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 |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
3 |
40 |
null |
C |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
3 |
40 |
null |
C |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
2 |
30 |
false |
B |
4 |
40 |
null |
C |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
|---|---|---|---|
2 |
30 |
false |
B |
5 |
60 |
false |
B |
id |
value |
status |
category |
|---|---|---|---|
4 |
40 |
null |
C |
Known Issues
問題は見つかりませんでした。
Related EWIs
既知の問題はありません。
EXISTS
Description
EXISTS 条件はサブクエリ内の行の存在をテストし、サブクエリが少なくとも1つの行を返す場合にtrueを返します。NOT が指定された場合、条件はサブクエリが行を返さない場合にtrueを返します。(Redshift SQL 言語リファレンス 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 言語リファレンス 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
論理的条件は、2つの条件の結果を組み合わせて1つの結果を生成します。すべての論理的条件はバイナリ演算子で、戻り値はブール型です。(Redshift SQL 言語リファレンス論理的条件)。
この文法は 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 |
既知の問題¶
問題は見つかりませんでした。
関連 EWIs¶
既知の問題はありません。
NULL¶
説明¶
null条件は、値がない、または不明な場合にnullをテストします。(Redshift SQL 言語リファレンス 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はパターンマッチングに3つの方法を使用します。
LIKE 式 LIKE 演算子は、列名などの文字列式と、ワイルドカード文字
%（パーセント）および_（アンダースコア）を使ったパターンを比較します。LIKE パターンマッチングは常に文字列全体をカバーします。LIKE は大文字と小文字を区別してマッチし、 ILIKE は大文字と小文字を区別しないでマッチします。SIMILAR TO 正規表現 SIMILAR TO 演算子は文字列式を SQL 標準正規表現パターンにマッチさせます。このパターンには LIKE 演算子がサポートする2つのパターンを含むパターンマッチングメタキャラクタのセットを含めることができます。SIMILAR TO は文字列全体にマッチし、大文字と小文字を区別します。
POSIX スタイル正規表現 POSIX 正規表現は LIKE や SIMILAR TO 演算子よりも強力なパターンマッチの手段を提供します。POSIX 正規表現パターンは文字列のどの部分にもマッチし、大文字と小文字を区別してマッチングを行います。(Redshift SQL 言語リファレンスパターンマッチング条件)。
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 言語リファレンス 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 |
|---|
ジョー・ドウ |
ジョー・ドウ |
ジョー・ドウ |
ジョー・ドウ |
ジョン・ドッドー |
出力コード:
SELECT name
FROM like_ex
WHERE name LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
NAME |
|---|
ジョー・ドウ |
ジョー・ドウ |
ジョー・ドウ |
ジョー・ドウ |
ジョン・ドッドー |
Not like¶
入力コード:¶
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%'
ORDER BY name;
NAME |
|---|
100% |
1000回 |
エレーン |
ジョー・ダウン |
John_down |
dd
出力コード:
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
NAME |
|---|
100% |
1000回 |
エレーン |
ジョー・ダウン |
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 |
既知の問題¶
固定文字タイプは動作が異なる場合があります。詳細は こちらをクリックしてください。
関連 EWIs¶
既知の問題はありません。
POSIX 演算子¶
説明¶
POSIX 正規表現は、マッチパターンを指定する文字列です。文字列が正規表現にマッチするのは、その文字列が正規表現で記述された正規セットのメンバーである場合です。POSIX 正規表現パターンは文字列のどの部分にもマッチします。(Redshift SQL 言語リファレンス POSIX 演算子)。
警告
この文法は Snowflake で部分的にサポートされています。POSIX 演算子はSnowflakeで REGEXP_COUNT に変換されます。
文法構文¶
expression [ ! ] ~ pattern
POSIX パターンマッチングメタ文字¶
POSIX パターンマッチングは以下のメタ文字をサポートしています（Snowflakeではすべてのケースがサポートされています）。
POSIX |
説明 |
|---|---|
. |
任意の1文字に一致します。 |
|
0回以上の出現に一致します。 |
|
1回以上の出現に一致します。 |
|
0回または1回の出現に一致します。 |
|
代替マッチを指定します。 |
|
行頭文字に一致します。 |
|
行末文字に一致します。 |
|
文字列の末尾に一致します。 |
[ ] |
括弧は、リスト内の1つの式にマッチするマッチングリストを指定します。 |
|
括弧は、項目を1つの論理項目にグループ化します。 |
|
前項目を正確に m 回繰り返します。 |
|
前項目を m 回以上繰り返します。 |
|
前項目を少なくとも m 回、最大 n 回繰り返します。 |
|
POSIX 文字クラス内の任意の文字に一致します。以下の文字クラスにおいて、Amazon RedshiftはSnowflakeと同様に ASCII 文字のみをサポートしています: |
パラメーター「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 another line 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 another line 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 another line abc123 |
6 |
a@b#c! more text here |
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 another line abc123 |
6 |
a@b#c! more text here |
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 more digits |
12 |
start end middle |
13 |
this is the first line this is the second line |
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 more digits |
12 |
start end middle |
13 |
this is the first line this is the second line |
14 |
特殊文字 !@#$%^&*() |
^ : 行頭文字に一致します¶
入力コード:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ '^abc';
ID |
COLUMN_NAME |
|---|---|
1 |
abc123 hello world |
3 |
123abc another line 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 another line 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! more text here |
7 |
alpha beta gamma |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 more digits |
12 |
start end middle |
13 |
this is the first line this is the second line |
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! more text here |
7 |
alpha beta gamma |
8 |
uppercase lowercase |
9 |
line1 line2 line3 line4 |
10 |
1234567890 more digits |
12 |
start end middle |
13 |
this is the first line this is the second line |
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 |
これらのシナリオで等価性が必要な場合は、以下のパラメーターを手動で関数に追加することで、機能的な等価性を得ることができます。
パラメーター |
説明 |
|---|---|
|
大文字と小文字を区別する一致 |
|
大文字と小文字を区別しない一致 |
既知の問題¶
既知の問題¶
固定文字タイプは動作が異なる場合があります。詳細は こちらをクリックしてください。
COLLATE 指定の引数は、現在 REGEXP_COUNT 関数ではサポートされていません。
関連 EWIs¶
SSC-FDM-PG0011: このパターンマッチング条件では、 COLLATE 列制約の使用が無効になっています。
SIMILAR TO¶
説明¶
SIMILAR TO 演算子は、列名などの文字列式を SQL 標準正規表現パターンに一致させます。SQL 正規表現パターンには、 LIKE 演算子でサポートされている2つのメタ文字を含む、パターンマッチングメタ文字のセットを含めることができます。(Redshift SQL 言語リファレンス 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 |
_ : 任意の1文字に一致します¶
入力コード:¶
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回または1回繰り返します¶
入力コード:¶
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 |
() : 括弧は項目を1つの論理項目にグループ化します¶
入力コード:¶
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 another line 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 |
これらのシナリオで等価性が必要な場合は、以下のパラメーターを手動で関数に追加することで、機能的な等価性を得ることができます。
パラメーター |
説明 |
|---|---|
|
大文字と小文字を区別する一致 |
|
大文字と小文字を区別しない一致 |
既知の問題¶
固定文字タイプは動作が異なる場合があります。
RLIKE関数は POSIX 拡張正規表現を使用するため、特に改行が含まれる場合など、特定のケースで動作が異なることがあります。文字列中に改行があり、1行で一致した場合、文字列全体ではなく1行で一致したにもかかわらず、文字列全体に対して肯定的な結果が返されるようです。例:
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 列制約の使用が無効になっています。