SnowConvert AI – Redshift – Bedingungen¶

BETWEEN¶

Beschreibung¶

Eine BETWEEN Bedingung testet Ausdrücke mit den Schlüsselwörtern BETWEEN und AND auf die Aufnahme in einen Wertebereich. (Redshift SQL-Referenz: BETWEEN-Bedingung)

Grammatikalische Syntax¶

 expression [ NOT ] BETWEEN expression AND expression

Hinweis

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Tabellenkonfiguration¶

Redshift¶

 CREATE TABLE sales (
    id INTEGER IDENTITY(1,1),
    price FLOAT,
    departmentId INTEGER,
    saleDate DATE
);

INSERT INTO sales (price, departmentId, saleDate) VALUES
(5000, 1, '2008-01-01'),
(8000, 1, '2018-01-01'),
(5000, 2, '2010-01-01'),
(7000, 3, '2010-01-01'),
(5000, 1, '2018-01-01'),
(4000, 4, '2010-01-01'),
(3000, 4, '2018-01-01'),
(9000, 5, '2008-01-01'),
(7000, 5, '2018-01-01'),
(6000, 5, '2006-01-01'),
(5000, 5, '2008-01-01'),
(5000, 4, '2018-01-01'),
(8000, 3, '2006-01-01'),
(7000, 3, '2016-01-01'),
(2000, 2, '2018-01-01');

Snowflake¶

 CREATE TABLE sales (
    id INTEGER IDENTITY(1,1) ORDER,
    price FLOAT,
    departmentId INTEGER,
    saleDate DATE
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/08/2025",  "domain": "test" }}';

INSERT INTO sales (price, departmentId, saleDate) VALUES
(5000, 1, '2008-01-01'),
(8000, 1, '2018-01-01'),
(5000, 2, '2010-01-01'),
(7000, 3, '2010-01-01'),
(5000, 1, '2018-01-01'),
(4000, 4, '2010-01-01'),
(3000, 4, '2018-01-01'),
(9000, 5, '2008-01-01'),
(7000, 5, '2018-01-01'),
(6000, 5, '2006-01-01'),
(5000, 5, '2008-01-01'),
(5000, 4, '2018-01-01'),
(8000, 3, '2006-01-01'),
(7000, 3, '2016-01-01'),
(2000, 2, '2018-01-01');

Eingabecode:¶

Redshift¶

 SELECT COUNT(*) FROM sales
WHERE departmentId BETWEEN 2 AND 4;

SELECT * FROM sales
WHERE departmentId BETWEEN 4 AND 2;

SELECT * FROM sales
WHERE departmentId NOT BETWEEN 4 AND 2;

SELECT * FROM sales
WHERE departmentId BETWEEN 2 AND 4
AND saleDate BETWEEN '2010-01-01' and '2016-01-01';

select 'some ' between c_start and c_end 
from( select 'same' as c_start, 'some' as c_end );

Ergebnisse¶


Anzahl (count)
8


id	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (saledate)


id	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (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	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (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

Ausgabecode:¶

Snowflake¶

 SELECT COUNT(*) FROM
    sales
WHERE departmentId BETWEEN 2 AND 4;

SELECT * FROM
    sales
WHERE departmentId BETWEEN 4 AND 2;

SELECT * FROM
    sales
WHERE departmentId NOT BETWEEN 4 AND 2;

SELECT * FROM
    sales
WHERE departmentId BETWEEN 2 AND 4
AND saleDate BETWEEN '2010-01-01' and '2016-01-01';

select
    RTRIM( 'some ') between c_start and c_end
from( select 'same' as c_start, 'some' as c_end );

Ergebnisse¶


Anzahl (count)
8


id	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (saledate)


id	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (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	Preis (price)	Abteilungs-ID (departmentid)	Verkaufsdatum (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

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Vergleichsbedingung¶

Bedingungen

Beschreibung ¶

Vergleichsbedingungen geben logische Beziehungen zwischen zwei Werten an. Alle Vergleichsbedingungen sind binäre Operatoren mit einem booleschen Rückgabetyp.

(RedShift SQL-Sprachreferenz – Vergleichsbedingung)

Grammatikalische Syntax ¶

Redshift unterstützt die in der folgenden Tabelle beschriebenen Vergleichsoperatoren:

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.

Verwendung von Vergleichsoperatoren für Zeichenfolgen¶

Es ist wichtig zu wissen, dass in Redshift Vergleichsoperatoren für Zeichenfolgen nachstehende Leerzeichen ignorieren. Um diese Verhaltensweise in Snowflake nachzubilden, wendet die Transformation die Funktion RTRIM an, um nachstehende Leerzeichen zu entfernen und so eine gleichwertige Funktionalität zu gewährleisten. Für weitere Informationen: Bedeutung der nachstehenden Leerzeichen

Umrechnungstabelle¶

Die meisten der Operatoren werden direkt von Snowflake unterstützt; die folgenden Operatoren erfordern jedoch eine Transformation:

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`).

Beispielhafte Quellcode-Muster¶

Eingabecode:¶

Redshift¶

 CREATE TABLE example_data (
    id INT,
    value INT,
    status BOOLEAN,
    category VARCHAR(10)
);

INSERT INTO example_data (id, value, status, category) VALUES
(1, 50, TRUE, 'A'),
(2, 30, FALSE, 'B'),
(3, 40, NULL, 'C'),
(4, 70, TRUE, 'A '),
(5, 60, FALSE, 'B');

SELECT *
FROM example_data
WHERE value < 60 AND value > 40;

SELECT *
FROM example_data
WHERE value <= 60 AND value >= 40;

SELECT *
FROM example_data
WHERE category = 'A';

SELECT *
FROM example_data
WHERE category != 'A' AND category <> 'B';

SELECT *
FROM example_data
WHERE category = ANY(SELECT category FROM example_data WHERE value > 60); --SOME

SELECT *
FROM example_data
WHERE value <> ALL (SELECT value FROM example_data WHERE status = TRUE);

SELECT *
FROM example_data
WHERE status IS TRUE;

SELECT *
FROM example_data
WHERE status IS FALSE;

SELECT *
FROM example_data
WHERE status IS UNKNOWN;

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

 CREATE TABLE example_data (
    id INT,
    value INT,
    status BOOLEAN,
    category VARCHAR(10)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "07/11/2025",  "domain": "no-domain-provided" }}';

INSERT INTO example_data (id, value, status, category) VALUES
(1, 50, TRUE, 'A'),
(2, 30, FALSE, 'B'),
(3, 40, NULL, 'C'),
(4, 70, TRUE, 'A '),
(5, 60, FALSE, 'B');

SELECT *
FROM
    example_data
WHERE value < 60 AND value > 40;

SELECT *
FROM
    example_data
WHERE value <= 60 AND value >= 40;

SELECT *
FROM
    example_data
WHERE category = 'A';

SELECT *
FROM
    example_data
WHERE category != 'A' AND category <> 'B';

SELECT *
FROM
    example_data
WHERE category = ANY(SELECT category FROM
            example_data
        WHERE value > 60); --SOME

SELECT *
FROM
    example_data
WHERE value <> ALL (SELECT value FROM
            example_data
        WHERE status = TRUE);

SELECT *
FROM
    example_data
WHERE status;

SELECT *
FROM
    example_data
WHERE
    NOT status;

SELECT *
FROM
    example_data
WHERE status IS NULL;

Ergebnisse¶


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

Bekannte Probleme¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

EXISTS¶

Beschreibung¶

EXISTS-Bedingungen testen auf die Existenz von Zeilen in einer Unterabfrage und geben „true“ zurück, wenn eine Unterabfrage mindestens eine Zeile zurückgibt. Wenn NOT angegeben ist, gibt die Bedingung „true“ zurück, wenn eine Unterabfrage keine Zeilen liefert. (Redshift SQL-Referenz: EXISTS-Bedingung)

Grammatikalische Syntax¶

 [ NOT ] EXISTS (table_subquery)

Hinweis

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Tabellenkonfiguration¶

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

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:¶

Snowflake¶

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

Ergebnisse¶


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

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

IN¶

Beschreibung¶

Eine IN-Bedingung testet einen Wert auf Zugehörigkeit zu einer Gruppe von Werten oder zu einer Unterabfrage. (Redshift SQL-Referenz: IN-Bedingung)

Grammatikalische Syntax¶

 expression [ NOT ] IN (expr_list | table_subquery)

Hinweis

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Tabellenkonfiguration¶

Redshift¶

 CREATE TABLE sales (
    id INTEGER IDENTITY(1,1),
    price FLOAT,
    saleDate DATE
);

INSERT INTO sales (price, saleDate) VALUES
(5000, '12/19/2024'),
(4000, '12/18/2024'),
(2000, '12/17/2024'),
(1000, '11/11/2024'),
(7000, '10/10/2024'),
(7000, '05/12/2024');

CREATE TABLE InTest (
col1 Varchar(20) COLLATE CASE_INSENSITIVE,
col2 Varchar(30) COLLATE CASE_SENSITIVE,
d1 date,
num integer,
idx integer);

INSERT INTO InTest values ('A', 'A', ('2012-03-02'), 4,6);
INSERT INTO InTest values ('a', 'a', ('2014-01-02'), 41,7);

Snowflake¶

 CREATE TABLE InTest (
    id INTEGER IDENTITY(1,1) ORDER,
    price FLOAT,
    saleDate DATE
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/09/2025",  "domain": "test" }}';

INSERT INTO InTest (price, saleDate) VALUES
(5000, '12/19/2024'),
(4000, '12/18/2024'),
(2000, '12/17/2024'),
(1000, '11/11/2024'),
(7000, '10/10/2024'),
(7000, '05/12/2024');

CREATE TABLE InTest (
col1 Varchar(20) COLLATE 'en-ci',
col2 Varchar(30) COLLATE 'en-cs',
d1 date,
num integer,
idx integer)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/16/2025",  "domain": "test" }}';

INSERT INTO InTest
values ('A', 'A', ('2012-03-02'), 4,6);
INSERT INTO InTest
values ('a', 'a', ('2014-01-02'), 41,7);

Eingabecode:¶

Redshift¶

 SELECT * FROM sales
WHERE id IN (2,3);

SELECT 5 IN (
SELECT id FROM sales
WHERE price = 7000
) AS ValidId;

select t.col1 in ('a ','b','c') as r1, t.col2 in ('a ','b','c') as r2 from InTest t order by t.idx;

Ergebnisse¶


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


VALIDID
TRUE


R1	R2
TRUE	FALSE
TRUE	TRUE

Ausgabecode:¶

Snowflake¶

 SELECT * FROM
    sales
WHERE id IN (2,3);

SELECT 5 IN (
SELECT id FROM
 sales
WHERE price = 7000
) AS ValidId;

select t.col1 in (RTRIM('a '), RTRIM('b'), RTRIM('c')) as r1, t.col2 in (RTRIM('a '), RTRIM('b'), RTRIM('c')) as r2 from
InTest t order by t.idx;

Ergebnisse¶


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


VALIDID
TRUE


R1	R2
TRUE	FALSE
TRUE	TRUE

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Logische Bedingungen¶

Beschreibung ¶

Logische Bedingungen kombinieren das Ergebnis von zwei Bedingungen zu einem einzigen Ergebnis. Alle logischen Bedingungen sind binäre Operatoren mit einem booleschen Rückgabetyp. (Redshift SQL-Referenz: Logische Bedingungen).

Hinweis

Diese Grammatik wird in Snowflake vollständig unterstützt.

Grammatikalische Syntax ¶

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

Beispielhafte Quellcode-Muster¶

Datenkonfiguration¶

Redshift¶

 CREATE TABLE employee (
    employee_id INT,
    active BOOLEAN,
    department VARCHAR(100),
    hire_date DATE,
    salary INT
);

INSERT INTO employee (employee_id, active, department, hire_date, salary) VALUES
    (1, TRUE, 'Engineering', '2021-01-15', 70000),
    (2, FALSE, 'HR', '2020-03-22', 50000),
    (3, NULL, 'Marketing', '2019-05-10', 60000),
    (4, TRUE, 'Engineering', NULL, 65000),
    (5, TRUE, 'Sales', '2018-11-05', NULL);

Eingabecode:¶

Redshift¶

 SELECT
    employee_id,
    (active AND department = 'Engineering') AS is_active_engineering,
    (department = 'HR' OR salary > 60000) AS hr_or_high_salary,
    NOT active AS is_inactive,
    (hire_date IS NULL) AS hire_date_missing,
    (salary IS NULL OR salary < 50000) AS low_salary_or_no_salary
FROM employee;

Ergebnisse¶

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

Ausgabecode:

Snowflake¶

 SELECT
    employee_id,
    (active AND department = 'Engineering') AS is_active_engineering,
    (department = 'HR' OR salary > 60000) AS hr_or_high_salary,
    NOT active AS is_inactive,
    (hire_date IS NULL) AS hire_date_missing,
    (salary IS NULL OR salary < 50000) AS low_salary_or_no_salary
FROM
    employee;

Ergebnisse¶

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

Bekannte Probleme¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

NULL¶

Beschreibung¶

Die Null-Bedingung testet auf Nullen, wenn ein Wert fehlt oder unbekannt ist. (Redshift SQL-Referenz: NULL-Bedingung)

Grammatikalische Syntax¶

 expression IS [ NOT ] NULL

Hinweis

Diese Funktion wird von Snowflake vollständig unterstützt.

Beispielhafte Quellcode-Muster¶

Tabellenkonfiguration¶

Redshift¶

 CREATE TABLE NullTest (
    id INTEGER,
    name VARCHAR(30),
    lastname VARCHAR(30)
);

INSERT INTO NullTest (id, name, lastname) VALUES 
 (1, 'name1', 'lastname1'),
 (2, 'name2', NULL),
 (3, 'name3', 'lastname3'),
 (4, 'name4', NULL);

Snowflake¶

 CREATE TABLE NullTest (
    id INTEGER,
    name VARCHAR(30),
    lastname VARCHAR(30)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/08/2025",  "domain": "test" }}';

INSERT INTO NullTest (id, name, lastname) VALUES
 (1, 'name1', 'lastname1'),
 (2, 'name2', NULL),
 (3, 'name3', 'lastname3'),
 (4, 'name4', NULL);

Eingabecode:¶

Redshift¶

 SELECT * FROM nulltest
WHERE lastname IS NULL;

Ergebnisse¶


ID	NAME	LASTNAME
2	name2	NULL
4	name4	NULL

Ausgabecode:¶

Snowflake¶

 SELECT * FROM
    nulltest
WHERE lastname IS NULL;

Ergebnisse¶


ID	NAME	LASTNAME
2	name2	NULL
4	name4	NULL

Bekannte Probleme ¶

Es wurden keine Probleme gefunden.

Zugehörige EWIs¶

Keine zugehörigen EWIs.

Bedingungen für Musterabgleiche¶

Beschreibung ¶

Ein Operator für die Musterabgleiche durchsucht eine Zeichenfolge nach einem im bedingten Ausdruck angegebenen Muster und gibt je nachdem, ob er eine Übereinstimmung findet, „true“ oder „false“ zurück. Amazon Redshift verwendet drei Methoden für den Mustervergleich:

LIKE-Ausdrücke Der Operator LIKE vergleicht einen Zeichenfolgen-Ausdruck, z. B. einen Spaltennamen, mit einem Muster, das die Platzhalterzeichen % (Prozent) und_ (Unterstrich) verwendet. Der LIKE-Musterabgleich deckt immer die gesamte Zeichenfolge ab. LIKE führt einen Abgleich unter Berücksichtigung der Groß- und Kleinschreibung durch und ILIKE einen Abgleich ohne Berücksichtigung der Groß- und Kleinschreibung.
SIMILAR TO-reguläre Ausdrücke Der Operator SIMILAR TO gleicht einen Zeichenfolgenausdruck mit einem SQL-Standardmuster für reguläre Ausdrücke ab, das eine Reihe von Metazeichen für den Musterabgleich enthalten kann, darunter die beiden vom LIKE-Operator unterstützten Zeichen. SIMILAR TO stimmt mit der gesamten Zeichenfolge überein und beachtet dabei die Groß- und Kleinschreibung.
POSIX-konforme reguläre Ausdrücke POSIX-reguläre Ausdrücke bieten eine leistungsfähigere Möglichkeit zum Musterabgleich als die Operatoren LIKE und SIMILAR TO. POSIX-reguläre Ausdrücke können mit jedem Teil der Zeichenfolge übereinstimmen und führen einen Abgleich unter Berücksichtigung der Groß- und Kleinschreibung durch. (Redshift SQL-Referenz: Bedingungen für den Musterabgleich).

Bekannte Probleme¶

In Snowflake kann die Verhaltensweise für Szenarien wie (LIKE, SIMILAR TO, und POSIX-Operatoren) variieren, wenn die Spalte vom Typ CHAR ist. Beispiel:

Code¶

 CREATE TEMPORARY TABLE pattern_matching_sample (
  col1 CHAR(10),
  col2 VARCHAR(10)
);

INSERT INTO pattern_matching_sample VALUES ('1','1');
INSERT INTO pattern_matching_sample VALUES ('1234567891','1234567891');
INSERT INTO pattern_matching_sample VALUES ('234567891','234567891');

SELECT
col1 LIKE '%1' as "like(CHAR(10))",
COL2 LIKE '%1' as "like(VARCHAR(10))"
FROM
pattern_matching_sample;

Redshift-Ergebnisse¶


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

Snowflake-Ergebnisse¶


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

Da CHAR(10) eine „feste Länge“ hat, wird angenommen, dass das Muster „%1“ mit einer „1“ an der 10. Position einer CHAR(10) Spalte übereinstimmen muss. In Snowflake hingegen passt es, wenn eine ‚1‘ in der Zeichenfolge vorhanden ist und eine beliebige Folge von null oder mehr Zeichen davor steht.

LIKE¶

Bedingungen für Musterabgleiche

Beschreibung ¶

Der LIKE-Operator vergleicht einen Zeichenfolgenausdruck, z. B. einen Spaltennamen, mit einem Muster, das die Platzhalterzeichen % (Prozent) und _ (Unterstrich) verwendet. Der LIKE-Musterabgleich deckt immer die gesamte Zeichenfolge ab. Um eine Sequenz an einer beliebigen Stelle innerhalb einer Zeichenfolge zu finden, muss das Muster mit einem Prozentzeichen beginnen und enden. (Redshift SQL-Referenz: LIKE).

Hinweis

Diese Syntax wird in Snowflake voll unterstützt.

Bemerkung

In Snowflake wird in den Fällen, in denen das Escape-Zeichen nicht zur Verfügung gestellt wird, das standardmäßige Redshift Escape-Zeichen '\\' hinzugefügt, um die volle Gleichwertigkeit zu gewährleisten.

Grammatikalische Syntax ¶

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

Beispielhafte Quellcode-Muster¶

Einrichtungsdaten¶

Redshift¶

 CREATE TABLE like_ex(name VARCHAR(20));

INSERT INTO like_ex VALUES
  ('John  Dddoe'),
  ('Joe   Doe'),
  ('Joe   Doe '),
  (' Joe   Doe '),
  (' Joe \n Doe '),
  ('John_down'),
  ('Joe down'),
  ('Elaine'),
  (''),
  (null),
  ('1000 times'),
  ('100%');

Like¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


NAME
Joe Doe
Joe Doe
Joe Doe
Joe Doe
John Doe

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


NAME
Joe Doe
Joe Doe
Joe Doe
Joe Doe
John Doe

Nicht wie¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


NAME

100%
1000 times
Elaine
Joe down
John_down

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


NAME

100%
1000 times
Elaine
Joe down
John_down

Escape-Zeichen¶

Eingabecode:¶

Redshift¶

 SELECT name
  FROM like_ex
  WHERE name LIKE '%J%h%^_do%' ESCAPE '^'
  ORDER BY name;
 
SELECT name
 FROM like_ex
 WHERE name LIKE '100\\%'
 ORDER BY 1;

Ergebnisse¶


NAME
John_down


NAME
100%

Ausgabecode:

Snowflake¶

 SELECT name
  FROM like_ex
  WHERE name LIKE '%J%h%^_do%' ESCAPE '^'
  ORDER BY name;
 
SELECT name
 FROM like_ex
 WHERE name LIKE '100\\%' ESCAPE '\\'
 ORDER BY 1;

Ergebnisse¶


NAME
John_down


NAME
100%

ILike¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


R1	R2
FALSE	TRUE

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


R1	R2
FALSE	TRUE

Operatoren¶

Die folgenden Operatoren werden wie folgt übersetzt:


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

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


R1	R2	R3	R4
TRUE	FALSE	TRUE	FALSE

Ausgabecode:

Snowflake¶

 SELECT 'abc' LIKE 'abc' ESCAPE '\\' AS r1,
       'abc' NOT LIKE 'a%' ESCAPE '\\' AS r2,
       'abc' ILIKE '_B_' ESCAPE '\\' AS r3,
       'abc' NOT ILIKE '_B_' ESCAPE '\\' AS r4;

Ergebnisse¶


R1	R2	R3	R4
TRUE	FALSE	TRUE	FALSE

Bekannte Probleme¶

The behavior of fixed char types may differ. See Known issues for more information.

Zugehörige EWIs¶

Es gibt keine bekannten Probleme.

POSIX-Operatoren¶

Bedingungen für Musterabgleiche

Beschreibung ¶

Ein POSIX-regulärer Ausdruck ist eine Folge von Zeichen, die ein Übereinstimmungsmuster angibt. Eine Zeichenfolge stimmt mit einem regulären Ausdruck überein, wenn sie ein Element des regulären Satzes ist, der durch den regulären Ausdruck beschrieben wird. POSIX-Muster für reguläre Ausdrücke können auf jeden Teil einer Zeichenfolge passen. (Redshift SQL-Referenz: POSIX-Operatoren).

Warnung

Diese Grammatik wird in Snowflake teilweise unterstützt. POSIX-Operatoren werden in Snowflake in REGEXP_COUNT umgewandelt.

Grammatikalische Syntax ¶

 expression [ ! ] ~ pattern

POSIX-musterabgleichende Metazeichen¶

POSIX-Musterabgleich unterstützt die folgenden Metazeichen (alle Fälle werden in Snowflake unterstützt):


POSIX	Beschreibung
.	Stimmt mit jedem beliebigen Einzelzeichen überein.
`*`	Stimmt mit null oder mehr Vorkommen überein.
`+`	Stimmt mit einem oder mehreren Vorkommen überein.
`?`	Passt auf null oder ein Vorkommen.
`\|`	Gibt alternative Treffer an.
`^`	Passt auf das Zeichen für den Zeilenanfang.
`$`	Passt auf das Zeichen für das Zeilenende.
`$`	Stimmt mit dem Ende der Zeichenfolge überein.
[ ]	Klammern geben eine passende Liste an, die auf einen Ausdruck in der Liste passen soll.
`( )`	Klammern fassen Elemente zu einem einzigen logischen Element zusammen.
`{m}`	Wiederholen Sie den vorherigen Punkt genau m Mal.
`{m,}`	Wiederholen Sie den vorherigen Punkt m oder mehre Male.
`{m,n}`	Wiederholen Sie den vorherigen Punkt mindestens m und höchstens n Mal.
`[: :]`	Passt auf jedes Zeichen innerhalb einer POSIX-Zeichenklasse. In den folgenden Zeichenklassen unterstützt Amazon Redshift nur ASCII Zeichen, genau wie Snowflake: `[:alnum:]`, `[:alpha:]`, `[:lower:]`, `[:upper:]`

Die Parameter ‚m‘ (aktiviert den Mehrzeilenmodus) und ‚s‘ (erlaubt das Platzhalterzeichen POSIX . für neue Zeilen) werden verwendet, um eine vollständige Äquivalenz in Snowflake zu erreichen. Weitere Informationen finden Sie unter Festlegen der Parameter für den regulären Ausdruck in Snowflake.

Beispielhafte Quellcode-Muster¶

Einrichtungsdaten¶

Redshift¶

 CREATE TABLE posix_test_table (
    id INT,
    column_name VARCHAR(255)
);

INSERT INTO posix_test_table (id, column_name)
VALUES
    (1, 'abc123\nhello world'),
    (2, 'test string\nwith multiple lines\nin this entry'),
    (3, '123abc\nanother line\nabc123'),
    (4, 'line1\nline2\nline3'),
    (5, 'start\nmiddle\nend'),
    (6, 'a@b#c!\nmore text here'),
    (7, 'alpha\nbeta\ngamma'),
    (8, 'uppercase\nlowercase'),
    (9, 'line1\nline2\nline3\nline4'),
    (10, '1234567890\nmore digits'),
    (11, 'abc123\nabc456\nabc789'),
    (12, 'start\nend\nmiddle'),
    (13, 'this is the first line\nthis is the second line'),
    (14, 'special characters\n!@#$%^&*()');

.: Entspricht einem beliebigen Zeichen¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

*: Stimmt mit null oder mehr Vorkommen überein.¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

? : Matches zero or one occurrence¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

^ : Entspricht dem Zeichen für den Zeilenanfang¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

$ : Passt auf das Ende der Zeichenfolge.¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

Verwendung von Collate-Spalten¶

Argumente mit der Angabe COLLATE werden derzeit von der Funktion RLIKE nicht unterstützt. Daher muss die COLLATE-Klausel deaktiviert werden, um diese Funktion zu verwenden. Dies kann jedoch zu Unterschieden in den Ergebnissen führen.

Eingabecode:¶

Redshift¶

 CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE CASE_INSENSITIVE,
col2 VARCHAR(30) COLLATE CASE_SENSITIVE);

INSERT INTO collateTable values ('HELLO WORLD!', 'HELLO WORLD!');

SELECT
col1 ~ 'Hello.*' as ci,
col2 ~ 'Hello.*' as cs
FROM collateTable;

Ergebnisse¶


CI	CS
TRUE	FALSE

Ausgabecode:

Snowflake¶

 CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE 'en-ci',
col2 VARCHAR(30) COLLATE 'en-cs'
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/16/2025",  "domain": "test" }}';

INSERT INTO collateTable
values ('HELLO WORLD!', 'HELLO WORLD!');

SELECT
REGEXP_COUNT(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col1, ''), 'Hello.*', 1, 'ms') > 0 as ci,
REGEXP_COUNT(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col2, ''), 'Hello.*', 1, 'ms') > 0 as cs
FROM
collateTable;

Ergebnisse¶


CI	CS
FALSE	FALSE

Wenn Sie für diese Szenarien eine Gleichwertigkeit benötigen, können Sie der Funktion manuell die folgenden Parameter hinzufügen, um eine funktionale Gleichwertigkeit zu erreichen:


Parameter	Beschreibung
`c`	Abgleich, bei dem zwischen Groß- und Kleinschreibung unterschieden wird
`i`	Abgleich ohne Berücksichtigung der Groß-/Kleinschreibung

Bekannte Probleme¶

The behavior of fixed char types may differ. See Known issues for more information.
Argumente mit COLLATE-Angaben werden derzeit in der Funktion REGEXP_COUNT nicht unterstützt.

Zugehörige EWIs¶

[SSC-FDM-PG0011](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/postgresqlFDM. md#ssc-fdm-pg0011): Die Verwendung der COLLATE-Spalteneinschränkung wurde für diese Musterabgleichsbedingung deaktiviert.

SIMILAR TO¶

Bedingungen für Musterabgleiche

Beschreibung ¶

Der SIMILAR TO-Operator gleicht einen Zeichenfolgenausdruck, wie z. B. einen Spaltennamen, mit einem SQL Standardmuster für reguläre Ausdrücke ab. Ein Muster für einen regulären Ausdruck SQL kann eine Reihe von Metazeichen für die Musterübereinstimmung enthalten, einschließlich der beiden, die vom LIKE -Operator unterstützt. (Redshift SQL-Referenz: SIMILAR TO).

Warnung

Diese Grammatik wird in Snowflake teilweise unterstützt. SIMILAR TO wird in RLIKE in Snowflake umgewandelt.

Grammatikalische Syntax ¶

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

Musterabgleichende Metazeichen¶

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.

Beispielhafte Quellcode-Muster¶

Einrichtungsdaten¶

Redshift¶

 CREATE TABLE similar_table_ex (
    column_name VARCHAR(255)
);

INSERT INTO similar_table_ex (column_name)
VALUES
    ('abc_123'),
    ('a_cdef'),
    ('bxyz'),
    ('abcc'),
    ('start_hello'),
    ('apple'),
    ('banana'),
    ('xyzabc'),
    ('abc\ncccc'),
    ('\nabccc'),
    ('abc%def'),
    ('abc_xyz'),
    ('abc_1_xyz'),
    ('applepie'),
    ('start%_abc'),
    ('ab%_xyz'),
    ('abcs_123_xyz'),
    ('aabc123'),
    ('xyzxyz'),
    ('123abc\nanother line\nabc123');

% : Matches any sequence of zero or more characters¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

_ : Passt auf jedes einzelne Zeichen¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

| : Bezeichnet Alternation¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
bxyz
banana

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
bxyz
banana

{m, n}: Wiederholen Sie den vorherigen Punkt genau m Mal.¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
abcc

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
abcc

+ : Repeat the previous item one or more times¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
abcc
abc cccc

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
abcc

*: Wiederholen Sie den vorherigen Punkt null oder mehr Mal¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
abcc
abc cccc

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
abcc

? : Wiederholen Sie den vorherigen Punkt null oder einmal¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
abcc
abc ccc

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
abcc

() : Klammern gruppieren Elemente zu einem einzigen logischen Element¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


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

[…] : Gibt eine Zeichenklasse an¶

Eingabecode:¶

Redshift¶

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

Ergebnisse¶


COLUMN_NAME
abc_123
a_cdef
bxyz
abcc
apfel
banana
abc cccc
abc%def
abc_xyz
abc_1_xyz
applepie
ab%_xyz
abcs_123_xyz
aabc123

Ausgabecode:

Snowflake¶

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

Ergebnisse¶


COLUMN_NAME
abc_123
a_cdef
bxyz
abcc
apfel
banana
abc cccc
abc%def
abc_xyz
abc_1_xyz
applepie
ab%_xyz
abcs_123_xyz
aabc123

Escape-Zeichen¶

Die folgenden Zeichen werden als Escape-Zeichen ausgegeben, wenn sie im Muster vorkommen und nicht selbst das Escape-Zeichen sind:

Eingabecode:¶

Redshift¶

 SELECT column_name
FROM similar_table_ex
WHERE column_name SIMILAR TO '%abc^_%' ESCAPE '^';

SELECT '$0.87' SIMILAR TO '$[0-9]+(.[0-9][0-9])?' r1;

Ergebnisse¶


COLUMN_NAME
abc_123
abc_xyz
abc_1_xyz


R1
TRUE

Ausgabecode:

Snowflake¶

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

SELECT
RLIKE( '$0.87', '\\$[0-9]+(\\.[0-9][0-9])?', 's') r1;

Ergebnisse¶


COLUMN_NAME
abc_123
abc_xyz
abc_1_xyz


R1
TRUE

In einer Variablen gespeichertes Muster¶

Wenn diese Muster in einer Variablen gespeichert sind, werden die erforderlichen Anpassungen für die Äquivalenz nicht vorgenommen. Sie können sich auf die Empfehlungen in der Tabelle Pattern-matching metacharacters am Anfang dieses Dokuments beziehen, um weitere Richtlinien zur Äquivalenz zu erhalten.

Eingabecode:¶

Redshift¶

 WITH pattern AS (
    SELECT '%abc%'::VARCHAR AS search_pattern
)
SELECT column_name
FROM similar_table_ex, pattern
WHERE column_name SIMILAR TO pattern.search_pattern;

Ergebnisse¶


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

Ausgabecode:

Snowflake¶

 WITH pattern AS (
    SELECT '%abc%'::VARCHAR AS search_pattern
)
SELECT column_name
FROM
similar_table_ex,
pattern
WHERE
RLIKE( column_name,
                    --** SSC-FDM-0032 - PARAMETER 'search_pattern' IS NOT A LITERAL VALUE, TRANSFORMATION COULD NOT BE FULLY APPLIED **
                    pattern.search_pattern, 's');

Ergebnisse¶


COLUMN_NAME
Abfrage ergab keine Ergebnisse

Verwendung von Collate-Spalten¶

Eingabecode:¶

Redshift¶

 CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE CASE_INSENSITIVE,
col2 VARCHAR(30) COLLATE CASE_SENSITIVE);

INSERT INTO collateTable values ('HELLO WORLD!', 'HELLO WORLD!');

SELECT
col1 SIMILAR TO 'Hello%' as ci,
col2 SIMILAR TO 'Hello%' as cs
FROM collateTable;

Ergebnisse¶


CI	CS
TRUE	FALSE

Ausgabecode:

Snowflake¶

 CREATE TABLE collateTable (
col1 VARCHAR(20) COLLATE 'en-ci',
col2 VARCHAR(30) COLLATE 'en-cs'
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/16/2025",  "domain": "test" }}';

INSERT INTO collateTable
values ('HELLO WORLD!', 'HELLO WORLD!');

SELECT
RLIKE(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col1, ''), 'Hello.*', 's') as ci,
RLIKE(COLLATE(
--** SSC-FDM-PG0011 - THE USE OF THE COLLATE COLUMN CONSTRAINT HAS BEEN DISABLED FOR THIS PATTERN-MATCHING CONDITION. **
col2, ''), 'Hello.*', 's') as cs
FROM
collateTable;

Ergebnisse¶


CI	CS
FALSE	FALSE

Wenn Sie für diese Szenarien eine Gleichwertigkeit benötigen, können Sie der Funktion manuell die folgenden Parameter hinzufügen, um eine funktionale Gleichwertigkeit zu erreichen:


Parameter	Beschreibung
`c`	Abgleich, bei dem zwischen Groß- und Kleinschreibung unterschieden wird
`i`	Abgleich ohne Berücksichtigung der Groß-/Kleinschreibung

Bekannte Probleme¶

Die Verhaltensweise von festen Zeichentypen kann unterschiedlich sein.
Die Funktion RLIKE verwendet POSIX-erweiterte reguläre Ausdrücke, was in bestimmten Fällen zu einer anderen Verhaltensweise führen kann, insbesondere wenn Zeilenumbrüche beteiligt sind. Wenn Zeilenumbrüche in der Zeichenfolge vorhanden sind und eine Übereinstimmung in einer Zeile auftritt, scheint es ein positives Ergebnis für die gesamte Zeichenfolge zu geben, obwohl die Übereinstimmung nur in einer einzigen Zeile und nicht in der gesamten Zeichenfolge auftrat. Beispiel:

Redshift-Code¶

 CREATE TABLE table1 (
col1 VARCHAR(20)
);

INSERT INTO table1 values ('abcccc'), ('abc\neab'), ('abc\nccc');

SELECT col1
FROM table1
WHERE col1 SIMILAR TO 'abc*c';

Snowflake-Code¶

 CREATE TABLE table1 (
col1 VARCHAR(20)
)
COMMENT = '{ "origin": "sf_sc", "name": "snowconvert", "version": {  "major": 0,  "minor": 0,  "patch": "0" }, "attributes": {  "component": "redshift",  "convertedOn": "01/14/2025",  "domain": "test" }}';

INSERT INTO table1
values ('abcccc'), ('abc\neab'), ('abc\nccc');

SELECT col1
FROM
table1
WHERE
RLIKE( col1, 'abc*c', 's');

Redshift-Ergebnisse¶


COL1
abcccc
abc eab
abc ccc

Snowflake-Ergebnisse¶


COL1
abcccc

Um eine maximale Äquivalenz zu erreichen, werden einige Änderungen an den Musteroperatoren vorgenommen.
Wenn diese Muster in einer Variablen gespeichert sind, wendet SnowConvert AI nicht die notwendigen Anpassungen für die Äquivalenz an.
Argumente mit der Angabe COLLATE werden derzeit von der Funktion RLIKE nicht unterstützt.

Zugehörige EWIs¶

[SSC-FDM-0032](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/generalFDM. md#ssc-fdm-0032): Der Parameter ist kein literaler Wert, die Transformation konnte nicht vollständig angewendet werden.
[SSC-FDM-PG0011](../../general/technical-documentation/issues-and-troubleshooting/functional-difference/postgresqlFDM. md#ssc-fdm-pg0011): Die Verwendung der COLLATE-Spalteneinschränkung wurde für diese Musterabgleichsbedingung deaktiviert.