Kategorien:

Zeichenfolgenfunktionen (reguläre Ausdrücke)

REGEXP

Gibt „true“ zurück, wenn das Subjekt mit dem angegebenen Muster übereinstimmt. Beide Eingaben müssen Textausdrücke sein.

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

Aliasse

RLIKE (2. Syntax)

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

Syntax

<subject> REGEXP <pattern>

Argumente

Benötigt:

Subjekt

Abzugleichendes Subjekt.

Muster

Abzugleichendes Muster.

Rückgabewerte

Der Datentyp des zurückgegebenen Werts ist BOOLEAN.

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

Verwenden Sie Platzhalter, um nach einem Muster zu suchen:

SELECT v
    FROM strings
    WHERE v REGEXP 'San* [fF].*'
    ORDER BY v;
+---------------+
| 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')
    ;
SELECT * 
    FROM strings
    ORDER BY v;
+-------------------------------------+
| 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;
+-------------------------------------+---------+
| 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;
+-------------------------------------+---------+
| 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;
+-------------------------------------+---------+
| V                                   | MATCHES |
|-------------------------------------+---------|
| Contains embedded single \backslash | True    |
| Sacramento                          | False   |
| San Francisco                       | False   |
| San Jose                            | False   |
| Santa Clara                         | False   |
+-------------------------------------+---------+
Zurück zum Anfang