Kategorien:

Zeichenfolgenfunktionen (reguläre Ausdrücke)

[ NOT ] REGEXP

Führt einen Vergleich aus, um festzustellen, ob eine Zeichenfolge mit einem angegebenen Muster übereinstimmt oder nicht. Beide Eingaben müssen Textausdrücke sein.

REGEXP ähnelt der Funktion [ NOT ] LIKE, bietet jedoch erweiterte reguläre POSIX-Ausdrücke anstelle von SQL LIKE-Mustersyntax. Unterstützt komplexere Abgleichsbedingungen als LIKE.

Tipp

Sie können den Suchoptimierungsdienst verwenden, um die Leistung von Abfragen zu verbessern, die diese Funktion aufrufen. Weitere Details dazu finden Sie unter Suchoptimierungsdienst.

Aliasse:

[ NOT ] RLIKE (2. Syntax)

Siehe auch: Zeichenfolgenfunktionen (reguläre Ausdrücke)

Syntax

<subject> [ NOT ] REGEXP <pattern>
Copy

Argumente

Benötigt:

subject

Abzugleichendes Subjekt.

pattern

Abzugleichendes Muster.

Rückgabewerte

Gibt einen BOOLEAN-Wert oder NULL zurück.

  • Wenn REGEXP angegeben ist und eine Übereinstimmung vorliegt, ist der Wert TRUE. Andernfalls wird FALSE zurückgegeben.

  • Wenn NOT REGEXP angegeben ist und keine Übereinstimmung vorliegt, ist der Wert TRUE. Andernfalls wird FALSE zurückgegeben.

  • Wenn entweder REGEXP oder NOT REGEXP angegeben ist, wird NULL zurückgegeben, wenn ein Argument NULL ist.

Nutzungshinweise

Sortierungsdetails

Arguments with collation specifications are currently not supported.

Beispiele

Das folgende Beispiel zeigt, wie REGEXP mit einem einfachen Platzhalterausdruck verwendet wird:

Erstellen Sie zuerst die Tabelle, und laden Sie die Daten in die Tabelle.

CREATE OR REPLACE TABLE strings (v VARCHAR(50));
INSERT INTO strings (v) VALUES
    ('San Francisco'),
    ('San Jose'),
    ('Santa Clara'),
    ('Sacramento');
Copy

Verwenden Sie Platzhalter, um nach einem Muster zu suchen:

SELECT v
    FROM strings
    WHERE v REGEXP 'San* [fF].*'
    ORDER BY v;
Copy
+---------------+
| V             |
|---------------|
| San Francisco |
+---------------+

Das Backslash-Zeichen \ ist das Escape-Zeichen in regulären Ausdrücken und gibt Sonderzeichen oder Zeichengruppen an. Beispielsweise ist \s der reguläre Ausdruck für Leerzeichen.

Der Snowflake-Zeichenfolgenparser, der Zeichenfolgenliterale analysiert, behandelt auch Backslash als Escape-Zeichen. Beispielsweise wird ein Backslash als Teil der Zeichenfolge verwendet, die ein Tabulatorzeichen angibt. Um eine Zeichenfolge zu erstellen, die einen einzelnen Backslash enthält, müssen Sie zwei Backslashes angeben. Vergleichen Sie beispielsweise die Zeichenfolge in der folgenden Eingabeanweisung mit der entsprechenden Zeichenfolge in der Ausgabe:

INSERT INTO strings (v) VALUES
    ('Contains embedded single \\backslash')
    ;
Copy
SELECT * 
    FROM strings
    ORDER BY v;
Copy
+-------------------------------------+
| V                                   |
|-------------------------------------|
| Contains embedded single \backslash |
| Sacramento                          |
| San Francisco                       |
| San Jose                            |
| Santa Clara                         |
+-------------------------------------+

Dieses Beispiel zeigt, wie nach Zeichenfolgen gesucht wird, die mit „San“ beginnen, wobei „San“ ein vollständiges Wort ist (z. B. nicht Teil von „Santa“). \b ist die Escape-Sequenz für eine Wortgrenze.

SELECT v, v regexp 'San\\b.*' AS MATCHES
    FROM strings
    ORDER BY v;
Copy
+-------------------------------------+---------+
| V                                   | MATCHES |
|-------------------------------------+---------|
| Contains embedded single \backslash | False   |
| Sacramento                          | False   |
| San Francisco                       | True    |
| San Jose                            | True    |
| Santa Clara                         | False   |
+-------------------------------------+---------+

Dieses Beispiel zeigt, wie Sie nach einem Leerzeichen suchen, gefolgt von einem Backslash. Beachten Sie, dass der einzelne gesuchte Backslash durch vier Backslashes unten dargestellt wird. Damit REGEXP nach einem literalen Backslash suchen kann, muss dieser Backslash von Escape-Zeichen umschlossen werden, sodass Sie also zwei Backslashes benötigen. Der Zeichenfolgenparser erfordert, dass jeder dieser Backslashes maskiert wird. Daher enthält der Ausdruck vier Backslashes, um den einen Backslash darzustellen, nach dem der Ausdruck sucht:

SELECT v, v regexp '.*\\s\\\\.*' AS MATCHES
    FROM strings
    ORDER BY v;
Copy
+-------------------------------------+---------+
| V                                   | MATCHES |
|-------------------------------------+---------|
| Contains embedded single \backslash | True    |
| Sacramento                          | False   |
| San Francisco                       | False   |
| San Jose                            | False   |
| Santa Clara                         | False   |
+-------------------------------------+---------+

Das folgende Beispiel ist das gleiche wie im vorherigen Beispiel, außer dass $$ als Zeichenfolgenbegrenzer verwendet wird, um dem Zeichenfolgenparser mitzuteilen, dass die Zeichenfolge ein Literal ist und dass Backslashes nicht als Escapesequenzen interpretiert werden sollten. (Die Backslashes werden von REGEXP weiterhin als Escapesequenzen interpretiert.)

SELECT v, v regexp $$.*\s\\.*$$ AS MATCHES
    FROM strings
    ORDER BY v;
Copy
+-------------------------------------+---------+
| V                                   | MATCHES |
|-------------------------------------+---------|
| Contains embedded single \backslash | True    |
| Sacramento                          | False   |
| San Francisco                       | False   |
| San Jose                            | False   |
| Santa Clara                         | False   |
+-------------------------------------+---------+
Sprache: Deutsch