Zeichenfolgenfunktionen (reguläre Ausdrücke)

Diese Zeichenfolgenfunktionen führen Operationen aus, die einem regulären Ausdruck entsprechen.

Unter diesem Thema:

Liste der Regex-Funktionen

Funktion

Anmerkungen

REGEXP

Alias für RLIKE.

REGEXP_COUNT

REGEXP_EXTRACT_ALL

Alias für REGEXP_SUBSTR_ALL.

REGEXP_INSTR

REGEXP_LIKE

Alias für RLIKE.

REGEXP_REPLACE

REGEXP_SUBSTR

REGEXP_SUBSTR_ALL

RLIKE

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 Muster, oder verwenden Sie den Parameter s im Argument Parameter (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 mit regulären Ausdrücken unterstützen ein optionales Argument Parameter als letzten Eingabewert. Das Argument Parameter ist eine VARCHAR-Zeichenfolge, die das Übereinstimmungsverhalten der Funktion für reguläre Ausdrücke spezifiziert. Die folgenden Parameter werden unterstützt:

Parameter

Effekt

c

Ermöglicht einen Abgleich, bei dem zwischen Groß- und Kleinschreibung unterschieden wird.

i

Ermöglicht einen Abgleich, bei dem zwischen Groß- und Kleinschreibung nicht unterschieden wird.

m

Aktiviert den Mehrzeilenmodus (d. h. Metazeichen ^ und $ markieren den Anfang und das Ende einer beliebigen Zeile des Subjekts). Standardmäßig ist der Mehrzeilenmodus deaktiviert (d. h. ^ und $ markieren den Anfang und das Ende des gesamten Subjekts).

e

Extrahiert untergeordnete Übereinstimmungen. Gilt nur für REGEXP_INSTR, REGEXP_SUBSTR, REGEXP_SUBSTR_ALL und die Aliasse dieser Funktionen.

s

Aktiviert, dass das POSIX-Platzhalterzeichen ., um \n zu entsprechen. Standardmäßig ist der Abgleich für Platzhaltererzeichen deaktiviert.

Die Standardzeichenfolge ist einfach c, was Folgendes festlegt:

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

  • Einzeiliger Modus.

  • Keine untergeordnete Matching-Extraktion, mit Ausnahme von REGEXP_REPLACE, das immer eine untergeordnete Matching-Extraktion verwendet.

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

Wenn Sie mehrere Parameter angeben, wird die Zeichenfolge ohne Leerzeichen oder Trennzeichen eingegeben. 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 Parameter enthalten sind, bestimmt der zuletzt in der Zeichenfolge auftretende Wert, ob die Funktion einen Abgleich unter Beachtung der Groß-/Kleinschreibung vornimmt oder nicht. Beispielsweise gibt ci an, dass Groß-/Kleinschreibung beim Abgleich nicht beachtet werden soll, da das „i“ als letztes Zeichen der Zeichenfolge vorkommt.

Ü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.

Bemerkung

Wenn Sie den regulären Ausdruck in einer Zeichenfolgenkonstante in einfachen Anführungszeichen verwenden, müssen Sie für den Backslash einen zweiten Backslash als Escapezeichen verwenden (z. B. \\., \\*, \\? usw.). Weitere Details dazu finden Sie unter Angeben von regulären Ausdrücken in Zeichenfolgenkonstante in einfachen Anführungszeichen

Angenommen, Sie suchen in einer Zeichenfolge nach einer öffnenden Klammer ((). Eine Möglichkeit, dies anzugeben, ist die Verwendung eines Backslash als Escapezeichen für das Zeichen im Muster (z. B. \().

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 customers;

  +-----------+
  | CUSTOMERS |
  |-----------|
  | (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 customers;

  +-----------+
  | CUSTOMERS |
  |-----------|
  | (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 Funktionen für reguläre Ausdrücke stimmt ein leeres Muster (d. h. '') mit nichts überein, nicht einmal mit einem leeren Subjekt.

Die Ausnahme sind REGEXP_LIKE und seine Aliasse REGEXP und 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. 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.

Bemerkung

Um Backslashes in einem regulären Ausdruck nicht mit Escapezeichen versehen zu müssen, können Sie anstelle einer Zeichenfolgenkonstante in einfachen Anführungszeichen auch eine Zeichenfolgenkonstante in Dollarzeichen verwenden.

Beispiel:

Beispiel für Verwendung von Metazeichen in einer Zeichenfolgenkonstante in einfachen Anführungszeichen

In diesem Beispiel wird der Backslash als Teil einer Escapesequenz in einem regulären Ausdruck verwendet, der nach einem Fragezeichen ? sucht.

Erstellen Sie eine Tabelle, und fügen Sie eine Zeile ein, die in einer Spalte einen einzelnen Backslash und in einer anderen Spalte ein Fragezeichen enthält:

create table wildcards (w varchar, w2 varchar);
insert into wildcards (w, w2) values ('\\', '?');

Die folgende SELECT-Anweisung sucht nach dem Fragezeichenliteral. Für die Suche wird ein regulärer Ausdruck verwendet, und das Fragezeichen ist ein Metazeichen in regulären Ausdrücken, sodass die Suche das Fragezeichen entschlüsseln muss, um es als Literal zu behandeln. Da der Backslash in einem Zeichenfolgenliteral erscheint, muss auch der Backslash selbst mit einem Escapezeichen versehen werden, sodass die Abfrage wie folgt aussieht:

select w2
    from wildcards
    where regexp_like(w2, '\\?');
+----+
| W2 |
|----|
| ?  |
+----+

Die folgende Abfrage verdeutlicht, dass der reguläre Ausdruck aus zwei Zeichen besteht (dem Backslash-Escapezeichen und dem Fragezeichen):

select w2
    from wildcards
    where regexp_like(w2, '\\' || '?');
+----+
| W2 |
|----|
| ?  |
+----+

Im vorherigen Beispiel wurde der zusätzliche Backslash nur benötigt, weil das Escapezeichen Teil eines Zeichenfolgenliterals war, nicht für den regulären Ausdruck selbst. Die folgende SELECT-Anweisung muss kein Zeichenfolgenliteral als Teil der SQL-Befehlszeichenfolge analysieren und benötigt daher nicht das zusätzliche Escapezeichen, das vom Zeichenfolgenliteral benötigt wurde:

select w, w2, w || w2 as escape_sequence, w2
    from wildcards
    where regexp_like(w2, w || w2);
+---+----+-----------------+----+
| W | W2 | ESCAPE_SEQUENCE | W2 |
|---+----+-----------------+----|
| \ | ?  | \?              | ?  |
+---+----+-----------------+----+

Beispiel für Verwendung von Rückverweisen in einer Zeichenfolgenkonstante in einfachen Anführungszeichen

Wenn Sie einen Rückverweis (z. B. \1) in einem Zeichenfolgenliteral verwenden, müssen Sie den Backslash, der Teil des Rückverweises ist, ebenfalls mit Escapezeichen versehen. Um zum Beispiel den Rückverweis \1 in einem Ersetzungs-Zeichenfolgenliteral von REGEXP_REPLACE anzugeben, verwenden Sie \\1.

Im folgenden Beispiel wird die zuvor erstellte Tabelle verwendet. In der SELECT-Anweisung wird ein Rückverweis verwendet, um jedes Vorkommen des regulären Ausdrucks .old durch eine Kopie der übereinstimmenden Zeichenfolge zu ersetzen, der das Wort „very“ vorangestellt ist:

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.     |
+----------------------------+------------------------------------------+
Zurück zum Anfang