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.

Aliasse

RLIKE (2. Syntax)

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

Syntax

<subject> REGEXP <pattern>

Nutzungshinweise

  • Die Funktion verankert implizit ein Muster an beiden Enden (d. h. '' wird automatisch zu '^$' und 'ABC' automatisch zu '^ABC$'). Um beispielsweise eine beliebige Zeichenfolge, die mit ABC beginnt, abzugleichen, wäre das Muster 'ABC.*' erforderlich.

  • Weitere Hinweise zur Verwendung der Funktionen für reguläre Ausdrücke finden Sie unter Allgemeine 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 Escape-Sequenzen interpretiert werden sollten. (Die Backslashes werden von REGEXP weiterhin als Escape-Sequenzen 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   |
+-------------------------------------+---------+