Kategorien:

Zeichenfolgenfunktionen (reguläre Ausdrücke)

REGEXP_SUBSTR

Gibt die Teilzeichenfolge zurück, die mit einem regulären Ausdruck innerhalb einer Zeichenfolge übereinstimmt.

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

Syntax

REGEXP_SUBSTR( <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.

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 wildcard character . matches \n

Standard: c

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

Bemerkung

Standardmäßig gibt REGEXP_SUBSTR den gesamten übereinstimmenden Teil des Subjekts zurück. Wenn jedoch der Parameter e (für „extrahieren“) angegeben ist, gibt REGEXP_SUBSTR 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 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

Gibt einen Wert vom Typ VARCHAR zurück, der mit der Teilzeichenfolge übereinstimmt.

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

  • Es wurde keine Übereinstimmung gefunden.

  • Alle Argumente sind NULL.

Nutzungshinweise

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

Sortierungsdetails

Arguments with collation specifications are currently not supported.

Beispiele

Die Dokumentation zur Funktion REGEXP_INSTR enthält viele Beispiele, die sowohl REGEXP_SUBSTR als auch REGEXP_INSTR verwenden. Vielleicht möchten Sie sich auch diese Beispiele ansehen.

In den Beispielen werden die unten erstellten Zeichenfolgen verwendet:

CREATE OR REPLACE TABLE demo2 (id INT, string1 VARCHAR);

INSERT INTO demo2 (id, string1) VALUES
    (2, 'It was the best of times, it was the worst of times.'),
    (3, 'In    the   string   the   extra   spaces  are   redundant.'),
    (4, 'A thespian theater is nearby.');

SELECT * FROM demo2;
Copy
+----+-------------------------------------------------------------+
| ID | STRING1                                                     |
|----+-------------------------------------------------------------|
|  2 | It was the best of times, it was the worst of times.        |
|  3 | In    the   string   the   extra   spaces  are   redundant. |
|  4 | A thespian theater is nearby.                               |
+----+-------------------------------------------------------------+

Die Zeichenfolgen haben die folgenden Eigenschaften:

  • Die Zeichenfolge mit einer id von 2 hat mehrere Vorkommen des Wortes „the“.

  • Die Zeichenfolge mit einer id von 3 hat mehrere Vorkommen des Wortes „the“ mit zusätzlichen Leerzeichen zwischen den Wörtern.

  • Die Zeichenfolge mit einer id von 4 enthält die Zeichenfolge „the“ innerhalb mehrerer Wörter („thespian“ und „theater“), aber ohne das Wort „the“ selbst.

In Beispiel wird nach dem ersten Vorkommen des Wortes the gesucht, gefolgt von einem oder mehreren Nicht-Wort-Zeichen (z. B. dem Leerzeichen, das Wörter trennt), gefolgt von einem oder mehreren Wort-Zeichen.

„Wortzeichen“ umfassen nicht nur die Buchstaben a–z und A–Z, sondern auch den Unterstrich („_“) und die Dezimalziffern 0–9, jedoch keine Leerzeichen, Satzzeichen und so weiter.

SELECT id,
       REGEXP_SUBSTR(string1, 'the\\W+\\w+') AS result
  FROM demo2
  ORDER BY id;
Copy
+----+--------------+
| ID | RESULT       |
|----+--------------|
|  2 | the best     |
|  3 | the   string |
|  4 | NULL         |
+----+--------------+

Suchen Sie ab Position 1 der Zeichenfolge nach dem zweiten Vorkommen des Wortes the, gefolgt von einem oder mehreren Nicht-Wort-Zeichen, gefolgt von einem oder mehreren Wort-Zeichen.

SELECT id,
       REGEXP_SUBSTR(string1, 'the\\W+\\w+', 1, 2) AS result
  FROM demo2
  ORDER BY id;
Copy
+----+-------------+
| ID | RESULT      |
|----+-------------|
|  2 | the worst   |
|  3 | the   extra |
|  4 | NULL        |
+----+-------------+

Suchen Sie ab Position 1 der Zeichenfolge nach dem zweiten Vorkommen des Wortes the, gefolgt von einem oder mehreren Nicht-Wort-Zeichen, gefolgt von einem oder mehreren Wort-Zeichen.

Anstatt den gesamten Treffer zurückzugeben, geben Sie nur die „Gruppe“ zurück (z. B. den Teil der Teilzeichenkette, der mit dem Teil des regulären Ausdrucks in Klammern übereinstimmt). In diesem Fall sollte der zurückgegebene Wert das Wort nach „the“ sein.

SELECT id,
       REGEXP_SUBSTR(string1, 'the\\W+(\\w+)', 1, 2, 'e', 1) AS result
  FROM demo2
  ORDER BY id;
Copy
+----+--------+
| ID | RESULT |
|----+--------|
|  2 | worst  |
|  3 | extra  |
|  4 | NULL   |
+----+--------+

In diesem Beispiel wird gezeigt, wie das zweite Wort aus den ersten, zweiten und dritten Übereinstimmungen eines Zwei-Wort-Musters abgerufen wird, in dem das erste Wort A ist. Dieses Beispiel zeigt auch, dass der Versuch, über das letzte Muster hinauszugehen, Snowflake dazu veranlasst, NULL zurückzugeben.

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

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

Führen Sie die Abfrage aus:

SELECT REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 2, 'e', 1) AS result2,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 3, 'e', 1) AS result3,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 4, 'e', 1) AS result4
  FROM test_regexp_substr;
Copy
+---------+---------+---------+---------+
| RESULT1 | RESULT2 | RESULT3 | RESULT4 |
|---------+---------+---------+---------|
| MAN     | PLAN    | CANAL   | NULL    |
+---------+---------+---------+---------+

In diesem Beispiel wird gezeigt, wie die erste, zweite und dritte Gruppe innerhalb des ersten Auftretens des Musters abgerufen werden. In diesem Fall sind die zurückgegebenen Werte die einzelnen Buchstaben des Wortes MAN.

SELECT REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 1) AS result1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 2) AS result2,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 'e', 3) AS result3
  FROM test_regexp_substr;
Copy
+---------+---------+---------+
| RESULT1 | RESULT2 | RESULT3 |
|---------+---------+---------|
| M       | A       | N       |
+---------+---------+---------+

Hier sind einige zusätzliche Beispiele.

Erstellen Sie eine Tabelle, und fügen Sie Daten ein:

CREATE OR REPLACE TABLE message(body VARCHAR(255));

INSERT INTO message VALUES
  ('Hellooo World'),
  ('How are you doing today?'),
  ('the quick brown fox jumps over the lazy dog'),
  ('PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS');
Copy

Gibt den ersten Treffer zurück, der den Kleinbuchstaben o enthält:

SELECT body,
       REGEXP_SUBSTR(body, '\\b\\S*o\\S*\\b') AS result
  FROM message;
Copy
+---------------------------------------------+---------+
| BODY                                        | RESULT  |
|---------------------------------------------+---------|
| Hellooo World                               | Hellooo |
| How are you doing today?                    | How     |
| the quick brown fox jumps over the lazy dog | brown   |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | NULL    |
+---------------------------------------------+---------+

Gibt die erste Übereinstimmung zurück, die ein klein geschriebenes o enthält, beginnend mit dem dritten Zeichen im Subjekt:

SELECT body,
       REGEXP_SUBSTR(body, '\\b\\S*o\\S*\\b', 3) AS result
  FROM message;
Copy
+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               | llooo  |
| How are you doing today?                    | you    |
| the quick brown fox jumps over the lazy dog | brown  |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | NULL   |
+---------------------------------------------+--------+

Gibt die dritte Übereinstimmung zurück, die ein klein geschriebenes o enthält, beginnend mit dem dritten Zeichen im Subjekt:

SELECT body,
       REGEXP_SUBSTR(body, '\\b\\S*o\\S*\\b', 3, 3) AS result
  FROM message;
Copy
+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               | NULL   |
| How are you doing today?                    | today  |
| the quick brown fox jumps over the lazy dog | over   |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | NULL   |
+---------------------------------------------+--------+

Gibt die dritte Übereinstimmung zurück, die ein klein geschriebenes o enthält, beginnend mit dem dritten Zeichen im Subjekt, wobei Groß- und Kleinschreibung nicht berücksichtigt werden:

SELECT body,
       REGEXP_SUBSTR(body, '\\b\\S*o\\S*\\b', 3, 3, 'i') AS result
  FROM message;
Copy
+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               | NULL   |
| How are you doing today?                    | today  |
| the quick brown fox jumps over the lazy dog | over   |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | LIQUOR |
+---------------------------------------------+--------+

Dieses Beispiel zeigt, dass Sie alle Parameter für reguläre Ausdrücke explizit weglassen können, indem Sie eine leere Zeichenfolge angeben.

SELECT body,
       REGEXP_SUBSTR(body, '(H\\S*o\\S*\\b).*', 1, 1, '') AS result
  FROM message;
Copy
+---------------------------------------------+--------------------------+
| BODY                                        | RESULT                   |
|---------------------------------------------+--------------------------|
| Hellooo World                               | Hellooo World            |
| How are you doing today?                    | How are you doing today? |
| the quick brown fox jumps over the lazy dog | NULL                     |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | NULL                     |
+---------------------------------------------+--------------------------+

Im folgenden Beispiel werden sich überlappende Vorkommen veranschaulicht: Erstellen Sie zunächst eine Tabelle und fügen Sie Daten ein:

CREATE OR REPLACE TABLE overlap (
  id NUMBER,
  a STRING);

INSERT INTO overlap VALUES (1, ',abc,def,ghi,jkl,');
INSERT INTO overlap VALUES (2, ',abc,,def,,ghi,,jkl,');

SELECT * FROM overlap;
Copy
+----+----------------------+
| ID | A                    |
|----+----------------------|
|  1 | ,abc,def,ghi,jkl,    |
|  2 | ,abc,,def,,ghi,,jkl, |
+----+----------------------+

Führen Sie eine Abfrage aus, die das zweite Auftreten des folgenden Musters in jeder Zeile findet: ein Satzzeichen gefolgt von Ziffern und Buchstaben, gefolgt von einem Satzzeichen.

SELECT id,
       REGEXP_SUBSTR(a,'[[:punct:]][[:alnum:]]+[[:punct:]]', 1, 2) AS result
  FROM overlap;
Copy
+----+--------+
| ID | RESULT |
|----+--------|
|  1 | ,ghi,  |
|  2 | ,def,  |
+----+--------+

Im folgenden Beispiel wird aus dem Zugriffsprotokoll eines Apache HTTP-Servers ein JSON-Objekt erstellt, wobei Mustererkennung und Verkettung zum Einsatz kommen: Erstellen Sie zunächst eine Tabelle und fügen Sie Daten ein:

CREATE OR REPLACE TABLE test_regexp_log (logs VARCHAR);

INSERT INTO test_regexp_log (logs) VALUES
  ('127.0.0.1 - - [10/Jan/2018:16:55:36 -0800] "GET / HTTP/1.0" 200 2216'),
  ('192.168.2.20 - - [14/Feb/2018:10:27:10 -0800] "GET /cgi-bin/try/ HTTP/1.0" 200 3395');

SELECT * from test_regexp_log
Copy
+-------------------------------------------------------------------------------------+
| LOGS                                                                                |
|-------------------------------------------------------------------------------------|
| 127.0.0.1 - - [10/Jan/2018:16:55:36 -0800] "GET / HTTP/1.0" 200 2216                |
| 192.168.2.20 - - [14/Feb/2018:10:27:10 -0800] "GET /cgi-bin/try/ HTTP/1.0" 200 3395 |
+-------------------------------------------------------------------------------------+

Führen Sie eine Abfrage durch:

SELECT '{ "ip_addr":"'
       || REGEXP_SUBSTR (logs,'\\b\\d{1,3}\.\\d{1,3}\.\\d{1,3}\.\\d{1,3}\\b')
       || '", "date":"'
       || REGEXP_SUBSTR (logs,'([\\w:\/]+\\s[+\-]\\d{4})')
       || '", "request":"'
       || REGEXP_SUBSTR (logs,'\"((\\S+) (\\S+) (\\S+))\"', 1, 1, 'e')
       || '", "status":"'
       || REGEXP_SUBSTR (logs,'(\\d{3}) \\d+', 1, 1, 'e')
       || '", "size":"'
       || REGEXP_SUBSTR (logs,'\\d{3} (\\d+)', 1, 1, 'e')
       || '"}' as Apache_HTTP_Server_Access
  FROM test_regexp_log;
Copy
+-----------------------------------------------------------------------------------------------------------------------------------------+
| APACHE_HTTP_SERVER_ACCESS                                                                                                               |
|-----------------------------------------------------------------------------------------------------------------------------------------|
| { "ip_addr":"127.0.0.1", "date":"10/Jan/2018:16:55:36 -0800", "request":"GET / HTTP/1.0", "status":"200", "size":"2216"}                |
| { "ip_addr":"192.168.2.20", "date":"14/Feb/2018:10:27:10 -0800", "request":"GET /cgi-bin/try/ HTTP/1.0", "status":"200", "size":"3395"} |
+-----------------------------------------------------------------------------------------------------------------------------------------+
Sprache: Deutsch