SnowConvert: Condições do Redshift¶
BETWEEN¶
Descrição¶
Uma condição BETWEEN
testa expressões para inclusão em um intervalo de valores, usando as palavras-chave BETWEEN
e AND
. (Condição BETWEEN de referência da linguagem Redshift SQL)
Sintaxe da gramática¶
expression [ NOT ] BETWEEN expression AND expression
Essa função é totalmente suportada pelo Snowflake.
Amostra de padrões da origem
Tabela de configuração
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');
Código de entrada:
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 |
Código de saída:
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 |
Problemas conhecidos
Não foram encontrados problemas.
EWIs relacionados
Sem EWIs relacionados.
Condição de comparação
Description
As condições de comparação estabelecem relações lógicas entre dois valores. Todas as condições de comparação são operadores binários com um tipo de retorno booliano. (Condição de comparação de referência da linguagem RedShift SQL)
Grammar Syntax
O Redshift suporta os operadores de comparação descritos na tabela a seguir:
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. |
Uso de operadores de comparação em cadeias de caracteres
É importante observar que, no Redshift, os operadores de comparação em cadeias de caracteres ignoram os espaços em branco à direita. Para replicar esse comportamento no Snowflake, a transformação aplica a função RTRIM
para remover os espaços finais, garantindo uma funcionalidade equivalente. Para obter mais informações: Significado dos espaços em branco finais
Tabela de conversão
A maioria dos operadores é diretamente suportada pelo Snowflake; no entanto, os operadores a seguir exigem transformação:
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 |
nulo |
C |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
3 |
40 |
nulo |
C |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
2 |
30 |
falso |
B |
4 |
40 |
nulo |
C |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
2 |
30 |
falso |
B |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
4 |
40 |
nulo |
C |
Código de saída:
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 |
nulo |
C |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
3 |
40 |
nulo |
C |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
2 |
30 |
falso |
B |
4 |
40 |
nulo |
C |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
1 |
50 |
true |
A |
4 |
70 |
true |
A |
id |
value |
status |
category |
---|---|---|---|
2 |
30 |
falso |
B |
5 |
60 |
falso |
B |
id |
value |
status |
category |
---|---|---|---|
4 |
40 |
nulo |
C |
Known Issues
Não foram encontrados problemas.
Related EWIs
Não há problemas conhecidos.
EXISTS
Description
Condições EXISTS testam a existência de linhas em uma subconsulta e retornam verdadeiro se uma subconsulta retornar pelo menos uma linha. Se NOT for especificado, a condição retornará verdadeiro se uma subconsulta não retornar nenhuma linha. (Condição EXISTS de referência da linguagem Redshift SQL)
Grammar Syntax
[ NOT ] EXISTS (table_subquery)
Essa função é totalmente suportada pelo Snowflake.
Amostra de padrões da origem¶
Tabela de configuração¶
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);
Código de entrada:¶
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 |
Código de saída:¶
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 relacionados¶
Sem EWIs relacionados.
Problemas conhecidos ¶
Não foram encontrados problemas.
IN¶
Descrição¶
Uma condição IN testa um valor para associação em um conjunto de valores ou em uma subconsulta. (Condição IN de referência da linguagem Redshift SQL)
Sintaxe da gramática¶
expression [ NOT ] IN (expr_list | table_subquery)
Essa função é totalmente suportada pelo 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
Sem EWIs relacionados.
Known Issues
Não foram encontrados problemas.
Condições lógicas
Description
As condições lógicas combinam o resultado de duas condições para produzir um único resultado. Todas as condições lógicas são operadores binários com um tipo de retorno booliano. (Condições lógicas de referência da linguagem Redshift SQL).
Essa gramática é totalmente compatível com o Snowflake.
Sintaxe da gramática ¶
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 |
Amostra de padrões da origem¶
Dados de configuração¶
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);
Código de entrada:¶
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 |
Código de saída:
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 |
Problemas conhecidos¶
Não foram encontrados problemas.
EWIs relacionados¶
Não há problemas conhecidos.
NULL¶
Descrição¶
A condição nula testa a existência de nulos, quando um valor está ausente ou é desconhecido. (Condição NULL de referência da linguagem Redshift SQL)
Sintaxe da gramática¶
expression IS [ NOT ] NULL
Essa função é totalmente suportada pelo 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
Não foram encontrados problemas.
Related EWIs
Sem EWIs relacionados.
Condições de correspondência de padrões
Description
Um operador de correspondência de padrão pesquisa uma cadeia de caracteres em busca de um padrão especificado na expressão condicional e retorna verdadeiro ou falso, dependendo do fato de encontrar uma correspondência. O Amazon Redshift usa três métodos para a correspondência de padrões:
Expressões LIKE O operador LIKE compara uma expressão de cadeia de caracteres, como o nome de uma coluna, com um padrão que usa os caracteres curinga
%
(porcentagem) e_
(sublinhado). A correspondência de padrões LIKE sempre abrange a cadeia de caracteres inteira. LIKE faz uma correspondência que diferencia maiúsculas de minúsculas e ILIKE faz uma correspondência que diferencia minúsculas de minúsculas.Expressões regulares SIMILAR TO O operador SIMILAR TO faz a correspondência de uma expressão de cadeia de caracteres com um padrão de expressão regular padrão SQL, que pode incluir um conjunto de metacaracteres de correspondência de padrões que inclui os dois suportados pelo operador LIKE. SIMILAR TO corresponde a toda a cadeia de caracteres e faz uma correspondência com distinção entre maiúsculas e minúsculas.
POSIX-style regular expressions As expressões regulares POSIX oferecem um meio mais avançado de correspondência de padrões do que os operadores LIKE e SIMILAR TO. Padrões de expressão regular POSIX podem corresponder a qualquer parte da cadeia de caracteres e realizam uma correspondência com distinção entre maiúsculas e minúsculas. (Condições de correspondência de padrões de referência da linguagem Redshift SQL).
Known Issues
No Snowflake, o comportamento de cenários como (
LIKE
,SIMILAR
TO, eoperadores POSIX
) pode variar quando a coluna é do tipo CHAR. Por exemplo:
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 |
Parece que, como CHAR(10) é de «comprimento fixo», ele supõe que o padrão “%1” deve corresponder a um “1” na 10ª posição de uma coluna CHAR(10). No entanto, no Snowflake, ele corresponde se houver um “1” na cadeia de caracteres, com qualquer sequência de zero ou mais caracteres antes dele.
LIKE
Description
O operador LIKE compara uma expressão de cadeia de caracteres, como o nome de uma coluna, com um padrão que usa os caracteres curinga % (porcentagem) e _ (sublinhado). A correspondência de padrões LIKE sempre abrange a cadeia de caracteres inteira. Para corresponder a uma sequência em qualquer lugar de uma cadeia de caracteres, o padrão deve começar e terminar com um sinal de porcentagem. (LIKE de referência da linguagem Redshift SQL).
Essa gramática é totalmente compatível com o Snowflake.
Nota
No Snowflake, nos casos em que o caractere de escape não for fornecido, o caractere de escape padrão do Redshift '\\'
será adicionado para equivalência total.
Sintaxe da gramática ¶
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
Amostra de padrões da origem¶
Dados de configuração¶
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¶
Código de entrada:¶
SELECT name
FROM like_ex
WHERE name LIKE '%Jo%oe%'
ORDER BY name;
NAME |
---|
Joe Doe |
Joe Doe |
Joe Doe |
Joe Doe |
John Dddoe |
Código de saída:
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¶
Código de entrada:¶
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%'
ORDER BY name;
NAME |
---|
100% |
1000 times |
Elaine |
Joe down |
John_down |
dd
Código de saída:
SELECT name
FROM like_ex
WHERE name NOT LIKE '%Jo%oe%' ESCAPE '\\'
ORDER BY name;
NAME |
---|
100% |
1000 times |
Elaine |
Joe down |
John_down |
Caracteres de escape¶
Código de entrada:¶
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% |
Código de saída:
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¶
Código de entrada:¶
SELECT 'abc' LIKE '_B_' AS r1,
'abc' ILIKE '_B_' AS r2;
R1 |
R2 |
---|---|
FALSE |
TRUE |
Código de saída:
SELECT 'abc' LIKE '_B_' ESCAPE '\\' AS r1,
'abc' ILIKE '_B_' ESCAPE '\\' AS r2;
R1 |
R2 |
---|---|
FALSE |
TRUE |
Operadores¶
Os operadores a seguir são convertidos da seguinte forma:
Redshift |
Snowflake |
---|---|
~~ |
LIKE |
!~~ |
NOT LIKE |
~~* |
ILIKE |
!~~* |
NOT ILIKE |
Código de entrada:¶
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 |
Código de saída:
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 |
Problemas conhecidos¶
O comportamento dos tipos de caracteres fixos pode ser diferente. Clique aqui para obter mais informações.
EWIs relacionados¶
Não há problemas conhecidos.
Operadores POSIX¶
Descrição ¶
Uma expressão regular POSIX é uma sequência de caracteres que especifica um padrão de correspondência. Uma cadeia de caracteres corresponde a uma expressão regular se for um membro do conjunto regular descrito pela expressão regular. Padrões de expressão regular POSIX podem corresponder a qualquer parte de uma cadeia de caracteres. (Operadores POSIX de referência da linguagem Redshift SQL).
Aviso
Essa gramática é parcialmente compatível com o Snowflake. Os operadores POSIX são transformados em REGEXP_COUNT no Snowflake.
Sintaxe da gramática ¶
expression [ ! ] ~ pattern
Metacaracteres de correspondência de padrões POSIX¶
A correspondência de padrões POSIX suporta os seguintes metacaracteres (todos os casos são suportados no Snowflake):
POSIX |
Descrição |
---|---|
. |
Corresponde a qualquer caractere único. |
|
Corresponde a zero ou mais ocorrências. |
|
Corresponde a uma ou mais ocorrências. |
|
Corresponde a zero ou uma ocorrência. |
|
Especifica correspondências alternativas. |
|
Corresponde ao caractere de início de linha. |
|
Corresponde ao caractere de fim de linha. |
|
Corresponde ao final da cadeia de caracteres. |
[ ] |
Os colchetes especificam uma lista de correspondência, que deve corresponder a uma expressão da lista. |
|
Os parênteses agrupam itens em um único item lógico. |
|
Repita o item anterior exatamente m vezes. |
|
Repita o item anterior m ou mais vezes. |
|
Repita o item anterior pelo menos m e não mais que n vezes. |
|
Corresponde a qualquer caractere dentro de uma classe de caracteres POSIX. Nas classes de caracteres a seguir, o Amazon Redshift suporta apenas os caracteres ASCII, assim como o Snowflake: |
Os parâmetros “m” (ativa o modo de várias linhas) e “s” (permite que o caractere curinga POSIX .
corresponda a novas linhas) são usados para obter equivalência total no Snowflake. Para obter mais informações, consulte Especificando os parâmetros para a expressão regular no Snowflake.
Amostra de padrões da origem¶
Dados de configuração¶
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!@#$%^&*()');
. : Corresponde a qualquer caractere¶
Código de entrada:¶
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 |
Código de saída:
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 |
* : Corresponde a zero ou mais ocorrências.¶
Código de entrada:¶
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 |
Código de saída:
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 |
? : Corresponde a zero ou uma ocorrência.¶
Código de entrada:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ 'a?b';
ID |
COLUMN_NAME |
---|---|
2 |
test string with multiple lines in this entry |
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 |
caracteres especiais !@#$%^&*() |
Código de saída:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, 'a?b', 1, 'ms') = 0;
ID |
COLUMN_NAME |
---|---|
2 |
test string with multiple lines in this entry |
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 |
caracteres especiais !@#$%^&*() |
^ : Corresponde ao caractere de início de linha¶
Código de entrada:¶
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 |
Código de saída:
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 |
$ : Corresponde ao final da cadeia de caracteres.¶
Código de entrada:¶
SELECT id, column_name
FROM posix_test_table
WHERE column_name !~ '123$';
ID |
COLUMN_NAME |
---|---|
2 |
test string with multiple lines in this entry |
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 |
caracteres especiais !@#$%^&*() |
Código de saída:
SELECT id, column_name
FROM posix_test_table
WHERE REGEXP_COUNT(column_name, '123$', 1, 'ms') = 0;
ID |
COLUMN_NAME |
---|---|
2 |
test string with multiple lines in this entry |
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 |
caracteres especiais !@#$%^&*() |
Uso de colunas de agrupamento¶
Argumentos com especificações COLLATE não são compatíveis atualmente com a função RLIKE. Como resultado, a cláusula COLLATE deve ser desativada para usar essa função. No entanto, isso pode levar a diferenças nos resultados.
Código de entrada:¶
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 |
Código de saída:
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 |
Se precisar de equivalência para esses cenários, poderá adicionar manualmente os seguintes parâmetros à função para obter equivalência funcional:
Parâmetro |
Descrição |
---|---|
|
Correspondência com distinção entre maiúsculas e minúsculas |
|
Correspondência sem distinção entre maiúsculas e minúsculas |
Problemas conhecidos¶
Problemas conhecidos¶
O comportamento dos tipos de caracteres fixos pode ser diferente. Clique aqui para obter mais informações.
Argumentos com especificações COLLATE não são compatíveis no momento com a função REGEXP_COUNT.
EWIs relacionados¶
SSC-FDM-PG0011: O uso da restrição de coluna COLLATE foi desativado para essa condição de correspondência de padrões.
SIMILAR TO¶
Descrição ¶
O operador SIMILAR TO faz a correspondência de uma expressão de cadeia de caracteres, como o nome de uma coluna, com um padrão de expressão regular padrão SQL. Um padrão de expressão regular SQL pode incluir um conjunto de metacaracteres de correspondência de padrões, inclusive os dois suportados pelo operador LIKE. (SIMILAR TO de referência da linguagem Redshift SQL).
Sintaxe da gramática ¶
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
Metacaracteres de correspondência de padrões¶
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. |
Amostra de padrões da origem¶
Dados de configuração¶
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¶
Código de entrada:¶
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 |
Código de saída:
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 |
_ : Corresponde a qualquer caractere único¶
Código de entrada:¶
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 |
Código de saída:
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 |
| : Indica alternância¶
Código de entrada:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'a|b%';
COLUMN_NAME |
---|
bxyz |
banana |
Código de saída:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'a|b.*', 's');
COLUMN_NAME |
---|
bxyz |
banana |
{m, n} : Repete o item anterior exatamente m vezes.¶
Código de entrada:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc{2,4}';
COLUMN_NAME |
---|
abcc |
Código de saída:
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¶
Código de entrada:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc+';
COLUMN_NAME |
---|
abcc |
abc cccc |
Código de saída:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc+', 's');
COLUMN_NAME |
---|
abcc |
* : Repete o item anterior zero ou mais vezes¶
Código de entrada:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc*c';
COLUMN_NAME |
---|
abcc |
abc cccc |
Código de saída:
SELECT column_name
FROM similar_table_ex
WHERE RLIKE (column_name, 'abc*c', 's');
COLUMN_NAME |
---|
abcc |
? : Repete o item anterior zero ou uma vez¶
Código de entrada:¶
SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO 'abc?c';
COLUMN_NAME |
---|
abcc |
abc ccc |
Código de saída:
SELECT column_name
FROM
similar_table_ex
WHERE
RLIKE( column_name, 'abc?c', 's');
COLUMN_NAME |
---|
abcc |
() : Os parênteses agrupam itens em um único item lógico¶
Código de entrada:¶
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 |
Código de saída:
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 |
[…] : Especifica uma classe de caracteres¶
Código de entrada:¶
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 |
Código de saída:
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 |
Caracteres de escape¶
Os caracteres a seguir serão escapados se aparecerem no padrão e não forem o próprio caractere de escape:
.
$
^
Código de entrada:¶
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 |
Código de saída:
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 |
Padrão armazenado em uma variável¶
Se esses padrões forem armazenados em uma variável, os ajustes necessários para equivalência não serão aplicados. Você pode consultar as recomendações descritas na tabela Pattern-matching metacharacters no início deste documento para obter diretrizes adicionais de equivalência.
Código de entrada:¶
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 |
Código de saída:
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 |
---|
A consulta não produziu resultados |
Uso de colunas de agrupamento¶
Argumentos com especificações COLLATE não são compatíveis atualmente com a função RLIKE. Como resultado, a cláusula COLLATE deve ser desativada para usar essa função. No entanto, isso pode levar a diferenças nos resultados.
Código de entrada:¶
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 |
Código de saída:
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 |
Se precisar de equivalência para esses cenários, poderá adicionar manualmente os seguintes parâmetros à função para obter equivalência funcional:
Parâmetro |
Descrição |
---|---|
|
Correspondência com distinção entre maiúsculas e minúsculas |
|
Correspondência sem distinção entre maiúsculas e minúsculas |
Problemas conhecidos¶
O comportamento dos tipos de caracteres fixos pode ser diferente.
A função
RLIKE
usa expressões regulares estendidas POSIX, o que pode resultar em um comportamento diferente em determinados casos, especialmente quando há quebras de linha envolvidas. Parece que, quando há quebras de linha na cadeia de caracteres e ocorre uma correspondência em uma linha, ele retorna um resultado positivo para toda a cadeia, mesmo que a correspondência tenha ocorrido apenas em uma única linha e não em toda a cadeia. Por exemplo:
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 |
Para obter a equivalência máxima, algumas modificações são feitas nos operadores de padrão.
Se esses padrões forem armazenados em uma variável, o SnowConvert não aplicará os ajustes necessários para a equivalência.
Argumentos com especificações COLLATE não são compatíveis atualmente com a função RLIKE.
EWIs relacionados¶
SSC-FDM-0032: O parâmetro não é um valor literal, a transformação não pôde ser totalmente aplicada.
SSC-FDM-PG0011: O uso da restrição de coluna COLLATE foi desativado para essa condição de correspondência de padrões.