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   |
+-------------------------------------+---------+

The following example is the same as the preceding example, except that it uses $$ as a string delimiter to tell the string parser that the string is a literal and that backslashes should not be interpreted as escape sequences. (The backslashes are still interpreted as escape sequences by REGEXP.)

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   |
+-------------------------------------+---------+