Zeichenfolgenfunktionen (reguläre Ausdrücke)¶

Liste der Regex-Funktionen¶

Allgemeine Nutzungshinweise¶

Unter diesen Themen bezieht sich „Subjekt“ auf das zu bearbeitende Element und „Muster“ auf den regulären Ausdruck:

• Das Subjekt ist typischerweise eine variable Spalte, während das Muster typischerweise eine Konstante ist, aber das ist nicht erforderlich. Jedes Argument für eine Funktion mit regulärem Ausdruck kann entweder eine Konstante oder eine Variable sein.

• Muster unterstützen die vollständige POSIX ERE (Extended Regular Expression)-Syntax. Weitere Informationen dazu finden Sie im Abschnitt Grundfunktionen und erweiterte Funktionen für POSIX (in Wikipedia).

• Muster unterstützen auch die folgenden Perl-Backslash-Sequenzen:

  • \d: Dezimalstelle (0–9).

  • \D: keine Dezimalstelle.

  • \s: Leerzeichen.

  • \S: kein Leerzeichen.

  • \w: „Wort“-Zeichen (a–z, A–Z, Unterstrich („_“) oder Dezimalziffer).

  • \W: kein Wortzeichen.

  • \b: Wortgrenze.

  • \B: keine Wortgrenze.

  Weitere Informationen dazu finden Sie im Abschnitt Zeichenklassen (in Wikipedia) oder im Abschnitt Backslash-Sequenzen (in der Perl-Dokumentation).

  Bemerkung

  Bei Zeichenfolgenkonstanten in einfachen Anführungszeichen müssen Sie das Backslash-Zeichen in der Backslash-Sequenz mit einem Escapezeichen versehen. Um beispielsweise \d anzugeben, verwenden Sie \\d. Weitere Details dazu finden Sie unter Angeben von regulären Ausdrücken in Zeichenfolgenkonstante in einfachen Anführungszeichen (unter diesem Thema).

  Sie müssen keine Backslashes zu verwenden, wenn Sie die Zeichenfolge mit Paaren von Dollarzeichen ($$) abtrennen (anstelle von einfachen Anführungszeichen).

• Standardmäßig behandelt das POSIX-Platzhalterzeichen . (im Muster) Neue-Zeile-Zeichen \n (im Subjekt) nicht als Übereinstimmungen.

  Um auch Zeilenumbrüche abzugleichen, ersetzen Sie entweder . durch (.|\n) im Argument pattern, oder verwenden Sie den Parameter s im Argument parameters (unten beschrieben).

• Alle Funktionen des regulären Ausdrucks unterstützen Unicode. Ein einzelnes Unicode-Zeichen zählt immer als ein Zeichen (d. h. das POSIX-Metazeichen . entspricht genau einem Unicode-Zeichen), unabhängig von der Bytelänge der entsprechenden binären Darstellung dieses Zeichens. Auch für Funktionen, die Subjektverschiebungen vornehmen oder zurückgeben, zählt ein einzelnes Unicode-Zeichen als 1.

Angeben der Parameter für reguläre Ausdrücke¶

Die meisten Funktionen für reguläre Ausdrücke unterstützen ein optionales parameters Argument. Das Argument parameters ist eine VARCHAR-Zeichenfolge, die die Verhaltensweise der Funktion für reguläre Ausdrücke angibt. Die folgenden Parameter werden unterstützt:

Die voreingestellte Zeichenfolge lautet c, was Folgende festlegt:

• Abgleich, bei dem zwischen Groß- und Kleinschreibung unterschieden wird

• Einzeiliger Modus.

• Keine Extraktion untergeordneter Übereinstimmung, mit Ausnahme von REGEXP_REPLACE, das immer eine Extraktion untergeordneter Übereinstimmungen vornimmt.

• Das POSIX-Platzhalterzeichen . stimmt nicht mit \n-Zeilenumbrüchen überein.

Wenn Sie mehrere Parameter angeben, geben Sie die Zeichenfolge ohne Leerzeichen oder Trennzeichen ein. So gibt beispielsweise ims an, dass im mehrzeiligen Modus der POSIX-Platzhalterabgleich ohne Berücksichtigung der Groß-/Kleinschreibung erfolgt.

Wenn sowohl c als auch i in der Zeichenfolge parameters enthalten sind, bestimmt der zuletzt in der Zeichenfolge auftretende Wert, ob die Funktion ein Matching, bei dem zwischen Groß- und Kleinschreibung unterschieden wird, berücksichtigt oder nicht. Bei ci beispielsweise wird die Groß- und Kleinschreibung nicht berücksichtigt, da i in der Zeichenfolge als letztes vorkommt.

Das folgende Beispiel zeigt, wie unterschiedlich die Ergebnisse beim Abgleich zwischen Groß- und Kleinschreibung sein können. Die Funktion REGEXP_COUNT gibt keine Übereinstimmungen für snow und SNOW bei Berücksichtigung der Groß- und Kleinschreibung zurück (Parameter c, der Standartwert) und eine Übereinstimmung bei Nichtberücksichtigung der Groß- und Kleinschreibung (Parameter i):

SELECT REGEXP_COUNT('snow', 'SNOW', 1, 'c') AS case_sensitive_matching,
       REGEXP_COUNT('snow', 'SNOW', 1, 'i') AS case_insensitive_matching;

+-------------------------+---------------------------+
| CASE_SENSITIVE_MATCHING | CASE_INSENSITIVE_MATCHING |
|-------------------------+---------------------------|
|                       0 |                         1 |
+-------------------------+---------------------------+

Verwenden Sie die Funktion REGEXP_SUBSTR mit dem Parameter e, um nach dem Wort Release zu suchen, gefolgt von einem oder mehreren Nicht-Wort-Zeichen, gefolgt von einer oder mehreren Ziffern, und dann die Teilzeichenkette zurückzugeben, die mit den Ziffern übereinstimmt:

SELECT REGEXP_SUBSTR('Release 24', 'Release\\W+(\\d+)', 1, 1, 'e') AS release_number;

+----------------+
| RELEASE_NUMBER |
|----------------|
| 24             |
+----------------+

Weitere Beispiele für die Verwendung von Parametern finden Sie unter REGEXP_INSTR, REGEXP_LIKE, REGEXP_SUBSTR, REGEXP_SUBSTR_ALL und [ NOT ] RLIKE.

Übereinstimmende Zeichen, die Metazeichen sind¶

In regulären Ausdrücken werden einige Zeichen als Metazeichen behandelt, die eine bestimmte Bedeutung haben. Beispiel:

• . ist ein Metazeichen, das mit jedem Einzelzeichen übereinstimmt.

• * ist ein Quantifizierer, der mit null oder mehr Instanzen des vorangehenden Elements übereinstimmt. Beispielsweise stimmt BA* mit B, BA, BAA, usw. überein.

• ? ist ein Quantifizierer, der mit null oder einer Instanz des vorangehenden Elements übereinstimmt.

Um das eigentliche Zeichen (z. B. einen Punkt, ein Sternchen oder ein Fragezeichen) zu finden, müssen Sie das Metazeichen mit einem Backslash (z. B. \., \*, \? usw.) als Escapezeichen versehen.

Angenommen, Sie suchen in einer Zeichenfolge nach einer öffnenden Klammer ((). Eine Möglichkeit, dies anzugeben, ist die Verwendung eines Backslashs, um das Zeichen im Muster zu entwerten (zum Beispiel \().

Wenn Sie den regulären Ausdruck als eine Zeichenfolgenkonstante in einfachen Anführungszeichen angeben, müssen Sie auch für den Backslash einen zweiten Backslash als Escapezeichen verwenden.

Das folgende Muster stimmt mit einer Sequenz von alphanumerischen Zeichen überein, die innerhalb von Klammern stehen (z. B. (NY)):

SELECT REGEXP_SUBSTR('Customers - (NY)','\\([[:alnum:]]+\\)') AS location;

+----------+
| LOCATION |
|----------|
| (NY)     |
+----------+

Weitere Beispiele finden Sie unter Beispiel für Verwendung von Metazeichen in einer Zeichenfolgenkonstante in einfachen Anführungszeichen.

Beachten Sie, dass das Backslash-Zeichen nicht mit Escapezeichen versehen werden muss, wenn Sie eine Zeichenfolgenkonstante in Dollarzeichen verwenden:

SELECT REGEXP_SUBSTR('Customers - (NY)',$$\([[:alnum:]]+\)$$) AS location;

+----------+
| LOCATION |
|----------|
| (NY)     |
+----------+

Verwenden von Rückverweisen¶

Snowflake unterstützt keine Rückverweise in Mustern für reguläre Ausdrücke (in der Theorie formaler Sprachen als „Quadrate“ bekannt). Rückverweise werden jedoch in der Ersetzungszeichenfolge der REGEXP_REPLACE-Funktion unterstützt.

Angeben eines leeren Musters¶

In den meisten regexp-Funktionen stimmt ein leeres Muster (d. h. '') mit nichts überein, nicht einmal mit einem leeren Subjekt..

Die Ausnahme sind REGEXP_LIKE und seine Aliasse [ NOT ] REGEXP und [ NOT ] RLIKE, bei denen das leere Muster mit dem leeren Subjekt übereinstimmt, weil das Muster an beiden Enden implizit verankert ist, d. h. '' wird automatisch zu '^$'.

Eine leere Gruppe (d. h.) der Unterausdruck () stimmt mit dem Zwischenraum zwischen den Zeichen überein, einschließlich Anfang und Ende des Subjekts.

Angeben von regulären Ausdrücken in Zeichenfolgenkonstante in Dollarzeichen¶

Wenn Sie eine Zeichenfolgenkonstante verwenden, um den regulären Ausdruck für eine Funktion anzugeben, können Sie eine Zeichenfolgenkonstante in Dollarzeichen verwenden, um zu vermeiden, dass Sie die Backslash-Zeichen im regulären Ausdruck mit Escapezeichen versehen müssen. (Wenn Sie Zeichenfolgenkonstanten in einfachen Anführungszeichen verwenden, müssen Sie die Backslashes mit Escapezeichen versehen).

Der Inhalt einer in Dollarzeichen eingeschlossenen Zeichenfolgenkonstante wird immer literal interpretiert.

Wenn Sie zum Beispiel ein Metazeichen mit Escapezeichen versehen müssen, ist nur ein einzelner Backslash erforderlich:

SELECT w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, $$\?$$);

Wenn Sie einen Rückverweis verwenden, ist nur ein einzelner Backslash erforderlich:

SELECT w2, REGEXP_REPLACE(w2, '(.old)', $$very \1$$)
  FROM wildcards
  ORDER BY w2;

Angeben von regulären Ausdrücken in Zeichenfolgenkonstante in einfachen Anführungszeichen¶

Wenn Sie den regulären Ausdruck in einer Zeichenfolgenkonstante in einfachen Anführungszeichen verwenden, müssen Sie für jeden Backslash in Backslash-Sequenzen einen zweiten Backslash als Escapezeichen verwenden.

Beispiel:

• Wenn Sie ein Metazeichen mit Escapezeichen versehen und dabei einen Backslash verwenden, müssen Sie den Backslash mit einem zweiten Backslash als Escapezeichen versehen. Siehe Beispiel für Verwendung von Metazeichen in einer Zeichenfolgenkonstante in einfachen Anführungszeichen.

• Wenn Sie eine Backslash-Sequenz verwenden, müssen Sie den Backslash in der Sequenz mit einem Escapezeichen versehen.

• Wenn Sie einen Rückverweis verwenden, müssen Sie den Backslash in dem Rückverweis mit einem Escapezeichen versehen. Siehe Beispiel für Verwendung von Rückverweisen in einer Zeichenfolgenkonstante in einfachen Anführungszeichen.

CREATE OR REPLACE TABLE wildcards (w VARCHAR, w2 VARCHAR);
INSERT INTO wildcards (w, w2) VALUES ('\\', '?');

SELECT w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, '\\?');

+----+
| W2 |
|----|
| ?  |
+----+

SELECT w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, '\\' || '?');

+----+
| W2 |
|----|
| ?  |
+----+

SELECT w, w2, w || w2 AS escape_sequence, w2
  FROM wildcards
  WHERE REGEXP_LIKE(w2, w || w2);

+---+----+-----------------+----+
| W | W2 | ESCAPE_SEQUENCE | W2 |
|---+----+-----------------+----|
| \ | ?  | \?              | ?  |
+---+----+-----------------+----+

INSERT INTO wildcards (w, w2) VALUES (NULL, 'When I am cold, I am bold.');

SELECT w2, REGEXP_REPLACE(w2, '(.old)', 'very \\1')
  FROM wildcards
  ORDER BY w2;

+----------------------------+------------------------------------------+
| W2                         | REGEXP_REPLACE(W2, '(.OLD)', 'VERY \\1') |
|----------------------------+------------------------------------------|
| ?                          | ?                                        |
| When I am cold, I am bold. | When I am very cold, I am very bold.     |
+----------------------------+------------------------------------------+