Kategorien:

Zeichenfolgenfunktionen (reguläre Ausdrücke)

REGEXP_SUBSTR_ALL

Gibt ein ARRAY zurück, das alle Teilzeichenfolgen enthält, die mit einem regulären Ausdruck in einer Zeichenfolge übereinstimmen.

Aliasse:

REGEXP_EXTRACT_ALL

Syntax

REGEXP_SUBSTR_ALL( <subject> ,
                   <pattern>
                     [ , <position>
                       [ , <occurrence>
                         [ , <regex_parameters>
                           [ , <group_num> ]
                         ]
                       ]
                     ]
)
Copy

Argumente

Benötigt:

subject

Die Zeichenfolge, nach der gesucht werden soll.

pattern

Abzugleichendes Muster.

Richtlinien zur Angabe von Mustern finden Sie unter Zeichenfolgenfunktionen (reguläre Ausdrücke).

Optional:

position

Anzahl der Zeichen ab dem Anfang der Zeichenfolge, an dem die Funktion mit der Suche nach Übereinstimmungen beginnt. Der Wert muss eine positive Ganzzahl sein.

Standard: 1 (die Suche nach einer Übereinstimmung beginnt beim ersten Zeichen links)

occurrence

Gibt das erste Auftreten des Musters an, ab dem Übereinstimmungen zurückgegeben werden sollen.

Die Funktion überspringt die ersten occurrence - 1 Übereinstimmungen. Wenn es beispielsweise 5 Übereinstimmungen gibt und Sie 3 für das occurrence-Argument angeben, ignoriert die Funktion die ersten beiden Übereinstimmungen und gibt die dritte, vierte und fünfte Übereinstimmung zurück.

Standard: 1

regex_parameters

Zeichenfolge aus einem oder mehreren Zeichen, in der die Parameter angegeben sind, die zur Suche nach Übereinstimmungen verwendet werden. Unterstützte Werte:

Parameter

Beschreibung

c

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

i

Abgleich ohne Berücksichtigung der Groß-/Kleinschreibung

m

Mehrzeiliger Modus.

e

Untergeordnete Übereinstimmungen extrahieren

s

POSIX-Platzhalterzeichen . im einzeiligen Modus stimmt mit \n überein

Standard: c

Weitere Informationen dazu finden Sie unter Angeben der Parameter für reguläre Ausdrücke.

Bemerkung

Standardmäßig gibt REGEXP_SUBSTR_ALL den gesamten übereinstimmenden Teil des Subjekts zurück. Wenn jedoch der Parameter e angegeben ist, gibt REGEXP_SUBSTR_ALL nur den Teil des Subjekts zurück, der mit der ersten Gruppe im Muster übereinstimmt. Wenn zwar e angegeben ist, aber kein Wert für group_num, dann ist der Wert von group_num standardmäßig 1 (die erste Gruppe). Wenn das Muster keinen Teilausdruck enthält, verhält sich REGEXP_SUBSTR_ALL so, als wäre e nicht gesetzt. Beispiele, die e verwenden, finden Sie im Abschnitt Beispiele (unter diesem Thema).

group_num

Gibt an, welche Gruppe extrahiert werden soll. Gruppen werden im regulären Ausdruck mithilfe von Klammern angegeben.

Wenn eine group_num angegeben ist, ermöglicht Snowflake das Extrahieren, auch wenn die Option 'e' nicht angegeben wurde. Das 'e' ist impliziert.

Snowflake unterstützt bis zu 1.024 Gruppen.

Beispiele, die group_num verwenden, finden Sie im Abschnitt Beispiele (unter diesem Thema).

Rückgabewerte

Die Funktion gibt einen Wert vom Typ ARRAY zurück. Das Array enthält ein Element für jede übereinstimmende Teilzeichenfolg.

Die Funktion gibt ein leeres Array zurück, wenn keine Übereinstimmung gefunden wird.

Die Funktion gibt in den folgenden Fällen NULL zurück:

  • Alle Argumente sind NULL.

  • Sie geben group_num an und das Muster gibt keine Gruppierung mit dieser Nummer an. Wenn das Muster zum Beispiel nur eine Gruppe angibt (z. B. a(b)c) und Sie 2 als group_num verwenden, gibt die Funktion NULL zurück.

Nutzungshinweise

Weitere Informationen zur Verwendung regulärer Ausdrücke finden Sie unter Zeichenfolgenfunktionen (reguläre Ausdrücke).

Sortierungsdetails

Arguments with collation specifications currently aren’t supported.

Beispiele

Das Muster im folgenden Beispiel stimmt mit einem kleinen „a“ gefolgt von einer Ziffer überein. Das Beispiel gibt ein ARRAY zurück, das alle Übereinstimmungen enthält:

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]') AS matches;
Copy
+---------+
| MATCHES |
|---------|
| [       |
|   "a1", |
|   "a2", |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

Im folgenden Beispiel beginnt die Suche nach Übereinstimmungen mit dem zweiten Zeichen der Zeichenfolge (2):

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 2) AS matches;
Copy
+---------+
| MATCHES |
|---------|
| [       |
|   "a2", |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

Das folgende Beispiel beginnt mit der Rückgabe von Übereinstimmungen ab dem dritten Auftreten des Musters in der Zeichenfolge (3):

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 1, 3) AS matches;
Copy
+---------+
| MATCHES |
|---------|
| [       |
|   "a3", |
|   "a4", |
|   "a6"  |
| ]       |
+---------+

Im folgenden Beispiel wird eine Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung gesucht (i):

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'a[[:digit:]]', 1, 1, 'i') AS matches;
Copy
+---------+
| MATCHES |
|---------|
| [       |
|   "a1", |
|   "a2", |
|   "a3", |
|   "a4", |
|   "A5", |
|   "a6"  |
| ]       |
+---------+

Im folgenden Beispiel wird eine Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung gesucht und der Teil der Zeichenfolge zurückgegeben, der mit der ersten Gruppe (ie) übereinstimmt:

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', '(a)([[:digit:]])', 1, 1, 'ie') AS matches;
Copy
+---------+
| MATCHES |
|---------|
| [       |
|   "a",  |
|   "a",  |
|   "a",  |
|   "a",  |
|   "A",  |
|   "a"   |
| ]       |
+---------+

Das folgende Beispiel zeigt, dass die Funktion ein leeres Array zurückgibt, wenn keine Übereinstimmungen gefunden werden:

SELECT REGEXP_SUBSTR_ALL('a1_a2a3_a4A5a6', 'b') AS matches;
Copy
+---------+
| MATCHES |
|---------|
| []      |
+---------+

In diesem Beispiel wird gezeigt, wie jedes zweite Wort in einer Zeichenfolge (String) aus den ersten, zweiten und dritten Übereinstimmungen eines Zwei-Wort-Musters abgerufen wird, in dem das erste Wort A ist.

Erstellen Sie zunächst eine Tabelle und fügen Sie Daten ein:

CREATE OR REPLACE TABLE test_regexp_substr_all (string1 VARCHAR);;
INSERT INTO test_regexp_substr_all (string1) VALUES ('A MAN A PLAN A CANAL');
Copy

Führen Sie die Abfrage aus:

SELECT REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 2, 'e', 1) AS result2,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w+)', 1, 3, 'e', 1) AS result3
  FROM test_regexp_substr_all;
Copy
+-----------+-----------+-----------+
| RESULT1   | RESULT2   | RESULT3   |
|-----------+-----------+-----------|
| [         | [         | [         |
|   "MAN",  |   "PLAN", |   "CANAL" |
|   "PLAN", |   "CANAL" | ]         |
|   "CANAL" | ]         |           |
| ]         |           |           |
+-----------+-----------+-----------+

In diesem Beispiel wird gezeigt, wie jede, zweite und dritte Gruppe innerhalb jedes Auftretens des Musters abgerufen werden. In diesem Fall sind die zurückgegebenen Werte jeder einzelne Buchstabe jedes übereinstimmenden Wortes in jeder Gruppe.

SELECT REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 2) AS result2,
       REGEXP_SUBSTR_ALL(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 3) AS result3
  FROM test_regexp_substr_all;
Copy
+---------+---------+---------+
| RESULT1 | RESULT2 | RESULT3 |
|---------+---------+---------|
| [       | [       | [       |
|   "M",  |   "A",  |   "N",  |
|   "P",  |   "L",  |   "A",  |
|   "C"   |   "A"   |   "N"   |
| ]       | ]       | ]       |
+---------+---------+---------+
Sprache: Deutsch