SnowConvert : conditions Redshift¶

BETWEEN¶

Description¶

Une condition BETWEEN teste l’inclusion d’expressions dans une plage de valeurs, à l’aide des mots-clés BETWEEN et AND. (Redshift SQL Référence linguistique condition BETWEEN)

Grammar Syntax¶

 expression [ NOT ] BETWEEN expression AND expression

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources

Table de configuration

 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');

Copy

 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');

Copy

Code d’entrée :

 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 );

Copy

count
8

id	prix	departmentid	saledate

id	prix	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	prix	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

Code de sortie :

 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 );

Copy

count
8

id	prix	departmentid	saledate

id	prix	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	prix	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

Problèmes connus

Aucun problème n’a été constaté.

Pas d’EWIs connexes.

Condition de comparaison

Description

Les conditions de comparaison établissent des relations logiques entre deux valeurs. Toutes les conditions de comparaison sont des opérateurs binaires avec un type de retour booléen. (Référence linguistique RedShift SQL Condition Comparison)

Grammar Syntax

Redshift prend en charge les opérateurs de comparaison décrits dans la table suivante :

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.

Utilisation d’opérateurs de comparaison sur les chaînes

Il est important de noter que dans Redshift, les opérateurs de comparaison sur les chaînes ignorent les espaces vides de fin. Pour répliquer ce comportement dans Snowflake, la transformation applique la fonction RTRIM pour supprimer les espaces de fin, ce qui garantit une fonctionnalité équivalente. Pour plus d’informations : Signification des blancs de fin

Table de conversion

La plupart des opérateurs sont directement pris en charge par Snowflake ; cependant, les opérateurs suivants nécessitent une exigence :

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;

Copy

id	value	status	catégorie
1	50	true	A

id	value	status	catégorie
1	50	true	A
3	40	null	C
5	60	false	B

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
3	40	null	C

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
2	30	false	B
4	40	null	C
5	60	false	B

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
2	30	false	B
5	60	false	B

id	value	status	catégorie
4	40	null	C

Code de sortie :

 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;

Copy

id	value	status	catégorie
1	50	true	A

id	value	status	catégorie
1	50	true	A
3	40	null	C
5	60	false	B

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
3	40	null	C

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
2	30	false	B
4	40	null	C
5	60	false	B

id	value	status	catégorie
1	50	true	A
4	70	true	A

id	value	status	catégorie
2	30	false	B
5	60	false	B

id	value	status	catégorie
4	40	null	C

Known Issues

Aucun problème n’a été constaté.

Related EWIs

Il n’y a pas de problème connu.

EXISTS

Description

Les conditions EXISTS vérifient l’existence de lignes dans une sous-requête et renvoient un résultat positif si une sous-requête renvoie au moins une ligne. Si NOT est spécifié, la condition retourne true si une sous-requête ne retourne aucune ligne. (Référence linguistique Redshift SQL condition EXISTS)

Grammar Syntax

 [ NOT ] EXISTS (table_subquery)

Copy

Cette fonction est entièrement prise en charge par Snowflake.

Modèles d’échantillons de sources¶

Table de configuration¶

 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);

Copy

 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);

Copy

Code d’entrée :¶

 SELECT * FROM ExistsTest
WHERE EXISTS (
SELECT 1 FROM ExistsTest
WHERE lastname = 'lastname1'
)
ORDER BY id;

Copy

ID	NAME	LASTNAME
1	name1	lastname1
2	name2	NULL
3	name3	lastname3
4	name4	NULL

Code de sortie :¶

 SELECT * FROM
ExistsTest
WHERE EXISTS (
SELECT 1 FROM
ExistsTest
WHERE lastname = 'lastname1'
)
ORDER BY id;

Copy

ID	NAME	LASTNAME
1	name1	lastname1
2	name2	NULL
3	name3	lastname3
4	name4	NULL

EWIs connexes¶

Pas d’EWIs connexes.

Problèmes connus ¶

Aucun problème n’a été constaté.

IN¶

Description¶

Une condition IN teste l’appartenance d’une valeur à un ensemble de valeurs ou à une sous-requête. (Référence linguistique Redshift SQL condition IN)

Grammar Syntax¶

 expression [ NOT ] IN (expr_list | table_subquery)

Copy

Cette fonction est entièrement prise en charge par 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);

Copy

 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);

Copy

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;

Copy

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;

Copy

ID	PRICE	SALEDATE
2	4000	2024-12-18
3	2000	2024-12-17

VALIDID
TRUE

R1	R2
TRUE	FALSE
TRUE	TRUE

Related EWIs

Pas d’EWIs connexes.

Known Issues

Aucun problème n’a été constaté.

Conditions logiques

Description

Les conditions logiques combinent le résultat de deux conditions pour produire un seul résultat. Toutes les conditions logiques sont des opérateurs binaires avec un type de retour booléen.(Référence linguistique Redshift SQL Conditions Logical).

Cette grammaire est entièrement prise en charge par Snowflake.

Grammar Syntax ¶

expression
{ AND | OR }
expression
NOT expression 

Copy

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

Modèles d’échantillons de sources¶

Données de configuration¶

 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);

Copy

Code d’entrée :¶

 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;

Copy

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

Code de sortie :

 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;

Copy

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

Problèmes connus¶

Aucun problème n’a été constaté.

EWIs connexes¶

Il n’y a pas de problème connu.

NULL¶

Description¶

La condition null teste la présence de null, lorsqu’une valeur est manquante ou inconnue. (Référence linguistique Redshift SQL condition NULL)

Grammar Syntax¶

 expression IS [ NOT ] NULL

Copy

Cette fonction est entièrement prise en charge par 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);

Copy

 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);

Copy

Input Code:

 SELECT * FROM nulltest
WHERE lastname IS NULL;

Copy

ID	NAME	LASTNAME
2	name2	NULL
4	name4	NULL

Output Code:

 SELECT * FROM
    nulltest
WHERE lastname IS NULL;

Copy

ID	NAME	LASTNAME
2	name2	NULL
4	name4	NULL

Known Issues

Aucun problème n’a été constaté.

Related EWIs

Pas d’EWIs connexes.

Conditions de correspondance des modèles

Description

Un opérateur de recherche de modèles recherche dans une chaîne un modèle spécifié dans l’expression conditionnelle et renvoie true ou false selon qu’il trouve ou non une correspondance. Amazon Redshift utilise trois méthodes pour la recherche de modèles :

Expressions LIKE L’opérateur LIKE compare une expression de chaîne, telle qu’un nom de colonne, avec un modèle qui utilise les caractères génériques % (pourcentage) et_ (trait de soulignement). La correspondance du modèle LIKE couvre toujours la totalité de la chaîne. LIKE effectue une recherche sensible à la casse et ILIKE effectue une recherche insensible à la casse.
Expressions régulières SIMILAR TO L’opérateur SIMILAR TO fait correspondre une expression de chaîne à un modèle d’expression régulière SQL standard, qui peut inclure un ensemble de métacaractères de filtrage comprenant les deux pris en charge par l’opérateur LIKE. SIMILAR TO recherche l’intégralité de la chaîne et effectue une correspondance entre les majuscules et les minuscules.
[Expressions régulières de style POSIX](opérateurs #posix) Les expressions régulières POSIX fournissent un moyen plus puissant pour la recherche de modèles que les opérateurs LIKE et SIMILAR TO. Les modèles d’expression régulière POSIX peuvent correspondre à n’importe quelle partie de la chaîne et effectuent une correspondance sensible à la casse. (Référence linguistique Redshift SQL Conditions de correspondance de modèles).

Known Issues

Dans Snowflake, le comportement pour des scénarios tels que (opérateurs LIKE, SIMILAR TO et POSIX) peut varier lorsque la colonne est de type CHAR. Par exemple :

 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;

Copy

like(CHAR(10))	like(VARCHAR(10))
FALSE	TRUE
TRUE	TRUE
FALSE	TRUE

like(CHAR(10))	like(VARCHAR(10))
TRUE	TRUE
TRUE	TRUE
TRUE	TRUE

Il semble que, parce que CHAR(10) est de « longueur fixe », il suppose que le modèle « %1 » doit correspondre à un « 1 » dans la 10e position d’une colonne CHAR(10). Cependant, dans Snowflake, la correspondance est établie si un « 1 » existe dans la chaîne, avec n’importe quelle séquence de zéro caractère ou plus le précédant.

LIKE

Description

L’opérateur LIKE compare une expression de chaîne, telle qu’un nom de colonne, à un modèle utilisant les caractères génériques % (pourcentage) et _ (trait de soulignement). La correspondance du modèle LIKE couvre toujours la totalité de la chaîne. Pour faire correspondre une séquence n’importe où dans une chaîne, le modèle doit commencer et se terminer par un signe de pourcentage. (Référence linguistique Redshift SQL LIKE).

Cette grammaire est entièrement prise en charge par Snowflake.

Note

Dans Snowflake, dans les cas où le caractère d’échappement n’est pas fourni, le caractère d’échappement par défaut de Redshift '\\' sera ajouté pour une équivalence complète.

Grammar Syntax ¶

 expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]

Copy

Modèles d’échantillons de sources¶

Données de configuration¶

 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%');

Copy

Like¶

Code d’entrée :¶

SELECT name
  FROM like_ex
  WHERE name LIKE '%Jo%oe%'
  ORDER BY name;

Copy

NAME
Joe Doe
Joe Doe
Joe Doe
Joe Doe
John Dddoe

Code de sortie :

 SELECT name
  FROM like_ex
  WHERE name LIKE '%Jo%oe%' ESCAPE '\\'
  ORDER BY name;

Copy

NAME
Joe Doe
Joe Doe
Joe Doe
Joe Doe
John Dddoe

Not like¶

Code d’entrée :¶

 SELECT name
  FROM like_ex
  WHERE name NOT LIKE '%Jo%oe%'
  ORDER BY name;

Copy

NAME

100%
1 000 fois
Elaine
Joe down
John_down

Code de sortie :

 SELECT name
  FROM like_ex
  WHERE name NOT LIKE '%Jo%oe%' ESCAPE '\\'
  ORDER BY name;

Copy

NAME

100%
1 000 fois
Elaine
Joe down
John_down

Caractères d’échappement¶

Code d’entrée :¶

 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;

Copy

NAME
John_down

NAME
100%

Code de sortie :

 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;

Copy

NAME
John_down

NAME
100%

ILike¶

Code d’entrée :¶

 SELECT 'abc' LIKE '_B_' AS r1,
       'abc' ILIKE '_B_' AS r2;

Copy

R1	R2
FALSE	TRUE

Code de sortie :

 SELECT 'abc' LIKE '_B_' ESCAPE '\\' AS r1,
       'abc' ILIKE '_B_' ESCAPE '\\' AS r2;

Copy

R1	R2
FALSE	TRUE

Opérateurs¶

Les opérateurs suivants sont traduits comme suit :

Redshift	Snowflake
~~	LIKE
!~~	NOT LIKE
~~*	ILIKE
!~~*	NOT ILIKE

Code d’entrée :¶

 SELECT 'abc' ~~ 'abc' AS r1,
       'abc' !~~ 'a%' AS r2,
       'abc' ~~* '_B_' AS r3,
       'abc' !~~* '_B_' AS r4;

Copy

R1	R2	R3	R4
TRUE	FALSE	TRUE	FALSE

Code de sortie :

 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;

Copy

R1	R2	R3	R4
TRUE	FALSE	TRUE	FALSE

Problèmes connus¶

Le comportement des types de caractères fixes peut être différent. Cliquez ici pour plus d’informations.

EWIs connexes¶

Il n’y a pas de problème connu.

Opérateurs POSIX¶

Description ¶

Une expression régulière POSIX est une séquence de caractères qui spécifie un modèle de correspondance. Une chaîne correspond à une expression régulière si elle fait partie de l’ensemble régulier décrit par l’expression régulière. Les modèles d’expression régulière POSIX peuvent correspondre à n’importe quelle partie d’une chaîne. (Référence linguistique Redshift SQL opérateurs POSIX).

Avertissement

Cette grammaire est partiellement prise en charge par Snowflake. Les opérateurs POSIX sont transformés en REGEXP_COUNT dans Snowflake.

Grammar Syntax ¶

 expression [ ! ] ~ pattern

Copy

Métacaractères de correspondance de modèles POSIX¶

La correspondance de modèles POSIX prend en charge les métacaractères suivants (tous les cas sont pris en charge dans Snowflake) :

POSIX	Description
.	Correspond à n’importe quel caractère unique.
`*`	Permet de lier zéro ou plusieurs occurrences.
`+`	Permet de lier une ou plusieurs occurrences.
`?`	Correspond à zéro ou une occurrence.
`\|`	Spécifie des correspondances alternatives.
`^`	Correspond au caractère de début de ligne.
`$`	Correspond au caractère de fin de ligne.
`$`	Correspond à la fin de la chaîne.
[ ]	Les parenthèses spécifient une liste de correspondance, qui doit correspondre à une expression de la liste.
`( )`	Les parenthèses regroupent les éléments en un seul élément logique.
`{m}`	Répétez le point précédent exactement m fois.
`{m,}`	Répétez l’élément précédent m ou plusieurs fois.
`{m,n}`	Répétez le point précédent au moins m et pas plus de n fois.
`[: :]`	Correspond à n’importe quel caractère d’une classe de caractères POSIX. Dans les classes de caractères suivantes, Amazon Redshift ne prend en charge que les caractères ASCII, tout comme Snowflake : `[:alnum:]`, `[:alpha:]`, `[:lower:]`, `[:upper:]`

Les paramètres « m » (qui active le mode multiligne) et « s » (qui permet au caractère générique POSIX . de correspondre aux nouvelles lignes) sont utilisés pour obtenir une équivalence complète dans Snowflake. Pour plus d’informations, veuillez vous référer à la section Spécifier les paramètres de l’expression régulière dans Snowflake.

Modèles d’échantillons de sources¶

Données de configuration¶

 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!@#$%^&*()');

Copy

. : correspond à n’importe quel caractère¶

Code d’entrée :¶

 SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ 'a.c';

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
11	abc123 abc456 abc789

Code de sortie :

 SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a.c', 1, 'ms') > 0;

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
11	abc123 abc456 abc789

* : Correspond à zéro ou plusieurs occurrences.¶

Code d’entrée :¶

 SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ 'a*b';

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
6	a@b#c! plus de texte ici
7	alpha beta gamma
11	abc123 abc456 abc789

Code de sortie :

 SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a*b', 1, 'ms') > 0;

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
6	a@b#c! plus de texte ici
7	alpha beta gamma
11	abc123 abc456 abc789

? : correspond à zéro ou une occurrence¶

Code d’entrée :¶

 SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ 'a?b';

Copy

ID	COLUMN_NAME
2	chaîne de test avec plusieurs lignes dans cette entrée
4	ligne1 ligne2 ligne3
5	début milieu fin
8	majuscules minuscules
9	ligne1 ligne2 ligne3 ligne4
10	1234567890 plus de chiffres
12	début fin milieu
13	c’est la première ligne c’est la deuxième ligne
14	caractères spéciaux !@#$%^&*()

Code de sortie :

 SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a?b', 1, 'ms') = 0;

Copy

ID	COLUMN_NAME
2	chaîne de test avec plusieurs lignes dans cette entrée
4	ligne1 ligne2 ligne3
5	début milieu fin
8	majuscules minuscules
9	ligne1 ligne2 ligne3 ligne4
10	1234567890 plus de chiffres
12	début fin milieu
13	c’est la première ligne c’est la deuxième ligne
14	caractères spéciaux !@#$%^&*()

^ : correspond au caractère de début de ligne¶

Code d’entrée :¶

 SELECT id, column_name
FROM posix_test_table
WHERE column_name ~ '^abc';

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
11	abc123 abc456 abc789

Code de sortie :

 SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, '^abc', 1, 'ms') > 0;

Copy

ID	COLUMN_NAME
1	abc123 hello world
3	123abc another line abc123
11	abc123 abc456 abc789

$ : correspond à la fin de la chaîne.¶

Code d’entrée :¶

 SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ '123$';

Copy

ID	COLUMN_NAME
2	chaîne de test avec plusieurs lignes dans cette entrée
4	ligne1 ligne2 ligne3
5	début milieu fin
6	a@b#c! plus de texte ici
7	alpha beta gamma
8	majuscules minuscules
9	ligne1 ligne2 ligne3 ligne4
10	1234567890 plus de chiffres
12	début fin milieu
13	c’est la première ligne c’est la deuxième ligne
14	caractères spéciaux !@#$%^&*()

Code de sortie :

 SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, '123$', 1, 'ms') = 0;

Copy

ID	COLUMN_NAME
2	chaîne de test avec plusieurs lignes dans cette entrée
4	ligne1 ligne2 ligne3
5	début milieu fin
6	a@b#c! plus de texte ici
7	alpha beta gamma
8	majuscules minuscules
9	ligne1 ligne2 ligne3 ligne4
10	1234567890 plus de chiffres
12	début fin milieu
13	c’est la première ligne c’est la deuxième ligne
14	caractères spéciaux !@#$%^&*()

Utilisation des colonnes de classement¶

Les arguments avec des spécifications COLLATE ne sont pas actuellement pris en charge par la fonction RLIKE. Par conséquent, la clause COLLATE doit être désactivée pour utiliser cette fonction. Toutefois, cela peut entraîner des différences dans les résultats.

Code d’entrée :¶

 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;

Copy

CI	CS
TRUE	FALSE

Code de sortie :

 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;

Copy

CI	CS
FALSE	FALSE

Si vous avez besoin d’une équivalence pour ces scénarios, vous pouvez ajouter manuellement les paramètres suivants à la fonction pour obtenir une équivalence fonctionnelle :

Paramètre	Description
`c`	Correspondance sensible à la casse
`i`	Correspondance non sensible à la casse

Problèmes connus¶

Le comportement des types de caractères fixes peut être différent. Cliquez ici pour plus d’informations.
Les arguments avec des spécifications COLLATE ne sont pas actuellement pris en charge par la fonction REGEXP_COUNT.

EWIs connexes¶

SSC-FDM-PG0011 : l’utilisation de la contrainte de colonne COLLATE a été désactivée pour cette condition de correspondance de modèles.

SIMILAR TO¶

Description ¶

L’opérateur SIMILAR TO fait correspondre une expression de chaîne, telle qu’un nom de colonne, à un modèle d’expression régulière standard SQL. Un modèle d’expression régulière SQL peut inclure un ensemble de métacaractères de correspondance, y compris les deux caractères pris en charge par l’opérateur LIKE. (Référence linguistique Redshift SQL SIMILAR TO).

Avertissement

Cette grammaire est partiellement prise en charge par Snowflake. SIMILAR TO est transformé en RLIKE dans Snowflake.

Grammar Syntax ¶

 expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]

Copy

Métacaractères de correspondance de modèles¶

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.

Modèles d’échantillons de sources¶

Données de configuration¶

 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');

Copy

% : Matches any sequence of zero or more characters¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '%abc%';

Copy

COLUMN_NAME
abc_123
abcc
xyzabc
abc cccc
abc%def
abc_xyz
abc_1_xyz
start%_abc
abcs_123_xyz
aabc123

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '.*abc.*', 's');

Copy

COLUMN_NAME
abc_123
abcc
xyzabc
abc cccc
abc%def
abc_xyz
abc_1_xyz
start%_abc
abcs_123_xyz
aabc123

_ : correspond à n’importe quel caractère unique¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a_c%';

Copy

COLUMN_NAME
abc_123
a_cdef
abcc
abc cccc
abc%def
abc_xyz
abc_1_xyz
abcs_123_xyz

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a.c.*', 's'); 

Copy

COLUMN_NAME
abc_123
a_cdef
abcc
abc cccc
abc%def
abc_xyz
abc_1_xyz
abcs_123_xyz

| : indique l’alternance¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a|b%';

Copy

COLUMN_NAME
bxyz
banana

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a|b.*', 's');

Copy

COLUMN_NAME
bxyz
banana

{m, n} : répétez l’élément précédent exactement m fois.¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc{2,4}';

Copy

COLUMN_NAME
abcc

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc{2,4}', 's');

Copy

COLUMN_NAME
abcc

+ : répéter l’élément précédent une ou plusieurs fois¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc+';

Copy

COLUMN_NAME
abcc
abc cccc

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc+', 's');

Copy

COLUMN_NAME
abcc

* : répéter l’élément précédent zéro ou plusieurs fois¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc*c';

Copy

COLUMN_NAME
abcc
abc cccc

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc*c', 's');

Copy

COLUMN_NAME
abcc

? : répéter l’élément précédent zéro ou une fois¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc?c';

Copy

COLUMN_NAME
abcc
abc ccc

Code de sortie :

 SELECT column_name
FROM
similar_table_ex
WHERE
RLIKE( column_name, 'abc?c', 's');

Copy

COLUMN_NAME
abcc

() : les parenthèses regroupent les éléments en un seul élément logique¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '(abc|xyz)%';

Copy

COLUMN_NAME
abc_123
abcc
xyzabc
abc cccc
abc%def
abc_xyz
abc_1_xyz
abcs_123_xyz
xyzxyz

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '(abc|xyz).*', 's');

Copy

COLUMN_NAME
abc_123
abcc
xyzabc
abc cccc
abc%def
abc_xyz
abc_1_xyz
abcs_123_xyz
xyzxyz

[…] : spécifie une classe de caractère¶

Code d’entrée :¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '[a-c]%';

Copy

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

Code de sortie :

 SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, '[a-c].*', 's');

Copy

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

Caractères d’échappement¶

Les caractères suivants seront échappés s’ils apparaissent dans le modèle et ne sont pas le caractère d’échappement lui-même :

Code d’entrée :¶

 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;

Copy

COLUMN_NAME
abc_123
abc_xyz
abc_1_xyz

R1
TRUE

Code de sortie :

 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;

Copy

COLUMN_NAME
abc_123
abc_xyz
abc_1_xyz

R1
TRUE

Modèle stocké dans une variable¶

Si ces modèles sont stockés dans une variable, les exigences d’équivalence ne seront pas appliquées. Vous pouvez vous référer aux recommandations énoncées dans la table au début de ce document pour des directives d’équivalence supplémentaires.

Code d’entrée :¶

 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;

Copy

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

Code de sortie :

 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');

Copy

COLUMN_NAME
La requête n’a donné aucun résultat

Utilisation des colonnes de classement¶

Code d’entrée :¶

 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;

Copy

CI	CS
TRUE	FALSE

Code de sortie :

 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;

Copy

CI	CS
FALSE	FALSE

Si vous avez besoin d’une équivalence pour ces scénarios, vous pouvez ajouter manuellement les paramètres suivants à la fonction pour obtenir une équivalence fonctionnelle :

Paramètre	Description
`c`	Correspondance sensible à la casse
`i`	Correspondance non sensible à la casse

Problèmes connus¶

Le comportement des types de caractères fixes peut être différent.
La fonction RLIKE utilise des expressions régulières étendues POSIX, ce qui peut entraîner un comportement différent dans certains cas, en particulier lorsque des sauts de ligne sont impliqués. Il semble que lorsque des sauts de ligne sont présents dans la chaîne et qu’une correspondance se produit sur une ligne, le résultat soit positif pour l’ensemble de la chaîne, même si la correspondance ne s’est produite que sur une seule ligne et non sur l’ensemble de la chaîne. Par exemple :

 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';

Copy

 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');

Copy

COL1
abcccc
abc eab
abc ccc

COL1
abcccc

Pour obtenir une équivalence maximale, certaines modifications sont apportées aux opérateurs de modèles.
Si ces modèles sont stockés dans une variable, SnowConvert n’applique pas les ajustements nécessaires pour l’équivalence.
Les arguments avec des spécifications COLLATE ne sont pas actuellement pris en charge par la fonction RLIKE.

EWIs connexes¶

SSC-FDM-0032 : le paramètre n’est pas une valeur littérale, la transformation n’a pas pu être entièrement appliquée.
SSC-FDM-PG0011 : l’utilisation de la contrainte de colonne COLLATE a été désactivée pour cette condition de correspondance de modèles.