In MariaDB die REGEXP_REPLACE() Die Funktion ersetzt Vorkommen des Teilstrings innerhalb eines Strings, der mit dem angegebenen regulären Ausdrucksmuster übereinstimmt.
Der gesamte String wird zusammen mit den Ersetzungen zurückgegeben.
Wenn es keine Übereinstimmung gibt (d. h. die Eingabezeichenfolge enthält die Teilzeichenfolge nicht), wird die gesamte Zeichenfolge unverändert zurückgegeben.
Syntax
Die Syntax lautet wie folgt:
REGEXP_REPLACE(subject, pattern, replace)
Wobei subject ist die Eingabezeichenfolge, pattern ist das reguläre Ausdrucksmuster für die Teilzeichenfolge und replace ist die Ersetzungszeichenfolge.
Beachten Sie, dass zum Zeitpunkt des Schreibens die MariaDB-Version von REGEXP_REPLACE() akzeptiert weniger Argumente als MySQLs REGEXP_REPLACE() Funktion. In der MySQL-Version können Sie Argumente für die Startposition der Suche angeben, nach welchem Vorkommen gesucht werden soll, sowie eine Möglichkeit, den regulären Ausdruck mit dem Übereinstimmungstyp zu verfeinern.
Beispiel
Hier ist ein einfaches Beispiel für die Verwendung von REGEXP_REPLACE() in MariaDB:
SELECT REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird'); Ergebnis:
In diesem Fall gibt es eine Übereinstimmung und die Teilzeichenfolge wird durch die Ersatzzeichenfolge ersetzt.
Reguläre Ausdrücke können sehr leistungsfähig sein, und dieses Beispiel verwendet ein sehr einfaches Beispiel. Um REGEXP_REPLACE() zu verwenden Um effektiv zu sein, müssen Sie das richtige Muster kennen, um das gewünschte Ergebnis zu erzielen.
Mehrere Übereinstimmungen
Hier ist ein Beispiel mit mehreren Übereinstimmungen:
SELECT REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird'); Ergebnis:
Keine Übereinstimmung
Hier ist ein Beispiel, bei dem es keine Übereinstimmung gibt:
SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird'); Ergebnis:
Es gibt keine Übereinstimmung, daher wird die ursprüngliche Zeichenfolge unverändert zurückgegeben.
Groß-/Kleinschreibung
Der REGEXP_REPLACE() Funktion folgt den Regeln der Groß-/Kleinschreibung der effektiven Sortierung. Der Abgleich wird bei Sortierungen ohne Berücksichtigung der Groß-/Kleinschreibung und bei Sortierungen mit Berücksichtigung der Groß- und Kleinschreibung und bei Binärdaten ohne Berücksichtigung der Groß-/Kleinschreibung durchgeführt.
Hier ist ein Beispiel:
SELECT
REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "My Default",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, 'c.t', 'dog') AS "Case Insensitive",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, 'c.t', 'dog') AS "Case Sensitive"; Ergebnis:
+------------+-------------+------------- --+| Mein Standard | Groß-/Kleinschreibung wird nicht beachtet | Groß-/Kleinschreibung beachten |+------------+-------------+------------- --+| Meine Hunde | Meine Hunde | Meine Katzen |+------------+-------------+------------- --+
Bei meiner Standardsortierung wird die Groß-/Kleinschreibung nicht beachtet. Die anderen beiden Zeichenfolgen wurden zu einer Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung bzw. einer Sortierung mit Berücksichtigung der Groß-/Kleinschreibung gezwungen.
Bereitstellung eines BINARY string ist auch case sensitive (dazu später mehr).
Groß-/Kleinschreibung überschreiben
Die Unterscheidung zwischen Groß- und Kleinschreibung kann mit (?i ) und (?-i ) PCRE-Flags.
Hier ist das vorherige Beispiel, aber diesmal mit (?-i) Flag für jedes Muster, um die Groß-/Kleinschreibung zu erzwingen:
SELECT
REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "My Default",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?-i)c.t', 'dog') AS "Case Insensitive",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?-i)c.t', 'dog') AS "Case Sensitive"; Ergebnis:
+------------+-------------+------------- --+| Mein Standard | Groß-/Kleinschreibung wird nicht beachtet | Groß-/Kleinschreibung beachten |+------------+-------------+------------- --+| Meine Katzen | Meine Katzen | Meine Katzen |+------------+-------------+------------- --+
Und hier wird der (?i) verwendet Flag, um die Groß-/Kleinschreibung zu erzwingen:
SELECT
REGEXP_REPLACE('My Cats', '(?i)c.t', 'dog') AS "My Default",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?i)c.t', 'dog') AS "Case Insensitive",
REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?i)c.t', 'dog') AS "Case Sensitive"; Ergebnis:
+------------+-------------+------------- --+| Mein Standard | Groß-/Kleinschreibung wird nicht beachtet | Groß-/Kleinschreibung beachten |+------------+-------------+------------- --+| Meine Hunde | Meine Hunde | Meine Hunde |+------------+-------------+-------------- --+
Binäre Zeichenfolgen
Übergeben eines BINARY string wirkt sich auch auf die Groß-/Kleinschreibung aus. Mit BINARY Zeichenketten unterscheidet sich ein Großbuchstabe von seinem Kleinbuchstaben:
Beispiel:
SELECT
REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', 'c.t', 'dog') AS "Binary"; Ergebnis:
+-----------+---------+| Zeichen | Binär |+-----------+---------+| Meine Hunde | Meine Katzen |+-----------+---------+
Folgendes passiert, wenn wir die Groß-/Kleinschreibung ändern:
SELECT
REGEXP_REPLACE('My Cats', 'C.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', 'C.t', 'dog') AS "Binary"; Ergebnis:
+-----------+---------+| Zeichen | Binär |+-----------+---------+| Meine Hunde | Meine Hunde |+-----------+---------+
Groß-/Kleinschreibung auf BINARY Strings können auch mit (?-i) überschrieben werden und (?i) PCRE-Flags:
SELECT
REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "Character",
REGEXP_REPLACE(BINARY 'My Cats', '(?-i)c.t', 'dog') AS "Binary"; Ergebnis:
+-----------+---------+| Zeichen | Binär |+-----------+---------+| Meine Katzen | Meine Katzen |+-----------+---------+
Null-Argumente
Übergabe von null da jedes Argument zu null führt :
SELECT
REGEXP_REPLACE(null, 'c.t', 'dog') AS "1",
REGEXP_REPLACE('Cat', null, 'dog') AS "2",
REGEXP_REPLACE('Cat', 'c.t', null) AS "3",
REGEXP_REPLACE(null, null, null) AS "4"; Ergebnis:
+------+------+------+------+| 1 | 2 | 3 | 4 |+------+------+------+------+| NULL | NULL | NULL | NULL |+------+------+------+------+
Falsche Anzahl von Argumenten
Das Übergeben der falschen Anzahl von Argumenten oder keiner Argumente führt zu einem Fehler:
SELECT REGEXP_REPLACE(); Ergebnis:
FEHLER 1582 (42000):Falsche Parameteranzahl im Aufruf der nativen Funktion 'REGEXP_REPLACE'
