Kategorien:: Zeichenfolgenfunktionen (reguläre Ausdrücke)

REGEXP_REPLACE¶

Gibt das Subjekt mit dem angegebenen Muster (oder allen Vorkommen des Musters) zurück, entweder durch eine Ersetzungszeichenfolge entfernt oder ersetzt.

Syntax¶

 REGEXP_REPLACE( <subject> ,
                 <pattern>
                   [ , <replacement>
                     [ , <position>
                       [ , <occurrence>
                         [ , <parameters> ]
                       ]
                     ]
                   ]
)

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:

replacement

Zeichenfolge, die als Ersatz für die vom Muster gefundenen Teilzeichenfolgen dient. Wenn eine leere Zeichenfolge angegeben wird, entfernt die Funktion alle gefundenen Muster und gibt die resultierende Zeichenfolge zurück.

Standard: '' (leere Zeichenfolge).

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 an, welches Vorkommen des Musters ersetzt werden soll. Wenn 0 angegeben ist, werden alle Vorkommen ersetzt.

Standard: 0 (alle Vorkommen)

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.

Rückgabewerte¶

Gibt einen Wert vom Typ VARCHAR zurück.

Wenn keine Übereinstimmungen gefunden werden, wird das ursprüngliche Subjekt zurückgegeben.

Gibt NULL zurück, wenn ein Argument NULL ist.

Nutzungshinweise¶

Die Ersetzungszeichenfolge kann Rückverweise enthalten, um Gruppen zu erfassen (z. B. Unterausdrücke des Musters). Eine Erfassungsgruppe ist ein regulärer Ausdruck, der in Klammern (( )) eingeschlossen ist. Die maximale Anzahl von Erfassungsgruppen beträgt 9.

Rückverweise gleichen Ausdrücke in einer Erfassungsgruppe ab. Rückverweise haben das Format n. Dabei n ein Wert zwischen 0 und 9 einschließlich , der sich auf die übereinstimmende Instanz der Erfassungsgruppe bezieht. Weitere Informationen finden Sie unter Beispiele (unter diesem Thema).
Runde Klammern (( )) und eckige Klammern ([ ]) müssen derzeit mit doppelten Escape-Zeichen versehen werden, damit sie als Literalzeichenfolgen analysiert werden.

Das folgende Beispiel zeigt, wie Klammern entfernt werden:
```
SELECT REGEXP_REPLACE('Customers - (NY)','\\(|\\)','') AS customers;
```
Copy
```
+----------------+
| CUSTOMERS      |
|----------------|
| Customers - NY |
+----------------+
```
Weitere Hinweise zur Verwendung der Funktionen für reguläre Ausdrücke finden Sie unter Allgemeine Nutzungshinweise.

Sortierungsdetails¶

Arguments with collation specifications currently aren’t supported.

Beispiele¶

Im folgenden Beispiel werden alle Leerzeichen in der Zeichenfolge durch nichts ersetzt (d. h. alle Leerzeichen werden entfernt):

SELECT REGEXP_REPLACE('It was the best of times, it was the worst of times',
                      '( ){1,}',
                      '') AS result;

Copy

+------------------------------------------+
| RESULT                                   |
|------------------------------------------|
| Itwasthebestoftimes,itwastheworstoftimes |
+------------------------------------------+

Im folgenden Beispiel wird die Zeichenfolge times abgeglichen und durch die Zeichenfolge days ersetzt. Der Abgleich beginnt beim ersten Zeichen in der Zeichenfolge und ersetzt das zweite Vorkommen der Teilzeichenfolge:

SELECT REGEXP_REPLACE('It was the best of times, it was the worst of times',
                      'times',
                      'days',
                      1,
                      2) AS result;

Copy

+----------------------------------------------------+
| RESULT                                             |
|----------------------------------------------------|
| It was the best of times, it was the worst of days |
+----------------------------------------------------+

Im folgenden Beispiel werden Rückverweise verwendet, um die Zeichenfolge firstname middlename lastname als lastname, firstname middlename neu zu ordnen und zwischen lastname und firstname ein Komma einzufügen:

SELECT REGEXP_REPLACE('firstname middlename lastname',
                      '(.*) (.*) (.*)',
                      '\\3, \\1 \\2') AS name_sort;

Copy

+--------------------------------+
| NAME_SORT                      |
|--------------------------------|
| lastname, firstname middlename |
+--------------------------------+

Die übrigen Beispiele verwenden die Daten in der folgenden Tabelle:

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

INSERT INTO regexp_replace_demo 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

Im folgenden Beispiel wird das Zeichen * zwischen jedem Zeichen des Subjekts eingefügt, einschließlich Anfang und Ende. Dabei wird eine leere Gruppe (()) verwendet, die eine Übereinstimmung zwischen zwei beliebigen Zeichen findet:

SELECT body,
       REGEXP_REPLACE(body, '()', '*') AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+-----------------------------------------------------------------------------------------+
| BODY                                        | REPLACED                                                                                |
|---------------------------------------------+-----------------------------------------------------------------------------------------|
| Hellooo World                               | *H*e*l*l*o*o*o* *W*o*r*l*d*                                                             |
| How are you doing today?                    | *H*o*w* *a*r*e* *y*o*u* *d*o*i*n*g* *t*o*d*a*y*?*                                       |
| the quick brown fox jumps over the lazy dog | *t*h*e* *q*u*i*c*k* *b*r*o*w*n* *f*o*x* *j*u*m*p*s* *o*v*e*r* *t*h*e* *l*a*z*y* *d*o*g* |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | *P*A*C*K* *M*Y* *B*O*X* *W*I*T*H* *F*I*V*E* *D*O*Z*E*N* *L*I*Q*U*O*R* *J*U*G*S*         |
+---------------------------------------------+-----------------------------------------------------------------------------------------+

Im folgenden Beispiel werden alle Vokale entfernt, indem sie durch nichts ersetzt werden, unabhängig von ihrer Reihenfolge oder der Groß-/Kleinschreibung:

SELECT body,
       REGEXP_REPLACE(body, '[aeiou]', '', 1, 0, 'i') AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+----------------------------------+
| BODY                                        | REPLACED                         |
|---------------------------------------------+----------------------------------|
| Hellooo World                               | Hll Wrld                         |
| How are you doing today?                    | Hw r y dng tdy?                  |
| the quick brown fox jumps over the lazy dog | th qck brwn fx jmps vr th lzy dg |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PCK MY BX WTH FV DZN LQR JGS     |
+---------------------------------------------+----------------------------------+

Im folgenden Beispiel werden alle Wörter, die den Kleinbuchstaben o enthalten, aus dem Subjekt entfernt, indem eine Wortgrenze (\b) abgeglichen wird, gefolgt von null oder mehr Wortzeichen (\S), dem Buchstaben o und dann null oder mehr Wortzeichen bis zur nächsten Wortgrenze:

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b') AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+-----------------------------------------+
| BODY                                        | REPLACED                                |
|---------------------------------------------+-----------------------------------------|
| Hellooo World                               |                                         |
| How are you doing today?                    |  are   ?                                |
| the quick brown fox jumps over the lazy dog | the quick   jumps  the lazy             |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS |
+---------------------------------------------+-----------------------------------------+

Im folgenden Beispiel werden alle Wörter ersetzt, die den Kleinbuchstaben o enthalten, wobei die Buchstaben vor und hinter der ersten Instanz von o vertauscht werden und das o mit der Zeichensequenz @@ ersetzt wird:

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1') AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+-------------------------------------------------+
| BODY                                        | REPLACED                                        |
|---------------------------------------------+-------------------------------------------------|
| Hellooo World                               | @@Helloo rld@@W                                 |
| How are you doing today?                    | w@@H are u@@y ing@@d day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick wn@@br x@@f jumps ver@@ the lazy g@@d |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS         |
+---------------------------------------------+-------------------------------------------------+

Das folgende Beispiel ist dasselbe wie das vorherige Beispiel, aber die Ersetzung beginnt an der Position 3 im Subjekt:

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3) AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+-------------------------------------------------+
| BODY                                        | REPLACED                                        |
|---------------------------------------------+-------------------------------------------------|
| Hellooo World                               | He@@lloo rld@@W                                 |
| How are you doing today?                    | How are u@@y ing@@d day@@t?                     |
| the quick brown fox jumps over the lazy dog | the quick wn@@br x@@f jumps ver@@ the lazy g@@d |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS         |
+---------------------------------------------+-------------------------------------------------+

Das folgende Beispiel ist dasselbe wie das vorherige Beispiel, aber nur das dritte Vorkommen wird ersetzt, beginnend an Position 3 im Subjekt:

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3, 3) AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+----------------------------------------------+
| BODY                                        | REPLACED                                     |
|---------------------------------------------+----------------------------------------------|
| Hellooo World                               | Hellooo World                                |
| How are you doing today?                    | How are you doing day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick brown fox jumps ver@@ the lazy dog |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS      |
+---------------------------------------------+----------------------------------------------+

Das folgende Beispiel ist dasselbe wie das vorherige Beispiel, der Abgleich erfolgt jedoch ohne Berücksichtigung der Groß-/Kleinschreibung:

SELECT body,
       REGEXP_REPLACE(body, '\\b(\\S*)o(\\S*)\\b', '\\2@@\\1', 3, 3, 'i') AS replaced
  FROM regexp_replace_demo;

Copy

+---------------------------------------------+----------------------------------------------+
| BODY                                        | REPLACED                                     |
|---------------------------------------------+----------------------------------------------|
| Hellooo World                               | Hellooo World                                |
| How are you doing today?                    | How are you doing day@@t?                    |
| the quick brown fox jumps over the lazy dog | the quick brown fox jumps ver@@ the lazy dog |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     | PACK MY BOX WITH FIVE DOZEN R@@LIQU JUGS     |
+---------------------------------------------+----------------------------------------------+