MySQL - REGEXP_REPLACE() Funktion

Hallo da draußen, angehende MySQL-Enthusiasten! Heute tauchen wir ein in die faszinierende Welt der REGEXP_REPLACE()-Funktion. Keine Sorge, wenn ihr neu im Programmieren seid; ich werde euch auf dieser Reise Schritt für Schritt führen, genau wie ich es über die Jahre mit unzähligen Schülern gemacht habe. Also, rollen wir die Ärmel hoch und los geht's!

MySQL - regexp_replace() Function

Was ist REGEXP_REPLACE()?

Bevor wir ins Detail gehen, lassen wir uns darstellen, was REGEXP_REPLACE() eigentlich macht. Stellt euch vor, ihr habt einen magischen Radiergummi, der spezifische Muster in eurem Text finden und durch etwas anderes ersetzen kann. Das ist im Wesentlichen, was REGEXP_REPLACE() in MySQL macht!

REGEXP_REPLACE() ist eine Funktion, die einen String nach einem Muster (verwendet reguläre Ausdrücke) durchsucht und alle Vorkommen dieses Musters durch einen angegebenen Ersatz-String ersetzt. Es ist wie ein supergestärktes "finden und ersetzen" Werkzeug in eurem Datenbank-Werkzeugkasten.

Die Grundsyntax

So verwendet ihr die REGEXP_REPLACE()-Funktion:

REGEXP_REPLACE(subject, pattern, replace)

subject: Der String, den ihr durchsuchen wollt
pattern: Der reguläre Ausdruck, nach dem ihr sucht
replace: Was ihr mit dem gefundenen Muster ersetzen wollt

Nun sehen wir uns diese Funktion in Aktion mit einigen Beispielen an!

Einfacher Textersatz

Fangen wir mit einem einfachen Beispiel an:

SELECT REGEXP_REPLACE('Hello, World!', 'World', 'MySQL') AS result;

Diese Abfrage wird folgendes zurückgeben:

+----------------+
| result         |
+----------------+
| Hello, MySQL!  |
+----------------+

Was ist hier passiert? Wir haben MySQL gesagt, den String 'Hello, World!' zu betrachten, das Wort 'World' zu finden und es durch 'MySQL' zu ersetzen. Einfach, oder?

Verwenden von regulären Ausdrücken

Nun verfeinern wir das mit ein bisschen regulärer Ausdruckszauber:

SELECT REGEXP_REPLACE('The quick brown fox', '[aeiou]', '*') AS result;

Dies wird uns geben:

+----------------------+
| result               |
+----------------------+
| Th* q**ck br*wn f*x  |
+----------------------+

Wow! Was für eine Magie ist das? Nun, [aeiou] ist ein regulärer Ausdruck, der alle Vokale matched. Unsere Funktion hat also jeden Vokal durch einen Stern (*) ersetzt. quite cool, oder?

Case-Insensitive Ersetzung

Angenommen, ihr wollt ein Wort ersetzen, unabhängig von seiner Groß- und Kleinschreibung. So könnt ihr das machen:

SELECT REGEXP_REPLACE('The APPLE doesn't fall far from the apple tree', '(?i)apple', 'orange') AS result;

Ergebnis:

+-----------------------------------------------+
| result                                        |
+-----------------------------------------------+
| The orange doesn't fall far from the orange tree |
+-----------------------------------------------+

Das (?i) am Anfang unseres Musters macht die Suche case-insensitiv. Daher werden sowohl 'APPLE' als auch 'apple' ersetzt.

Ersetzen mehrerer Vorkommen

REGEXP_REPLACE() ersetzt standardmäßig alle Vorkommen des Musters. Sehen wir uns ein Beispiel an:

SELECT REGEXP_REPLACE('one fish, two fish, red fish, blue fish', 'fish', 'cat') AS result;

Dies gibt uns:

+----------------------------------------+
| result                                 |
+----------------------------------------+
| one cat, two cat, red cat, blue cat    |
+----------------------------------------+

Jeder 'fish' wurde zu einem 'cat'! Ich hoffe, ihr seid nicht allergisch gegen Katzen. ?

REGEXP_REPLACE() in WHERE-Klauseln

REGEXP_REPLACE() ist nicht nur für SELECT-Anweisungen geeignet. Ihr könnt es auch in WHERE-Klauseln verwenden! Lassen wir eine einfache Tabelle erstellen und schauen, wie das funktioniert:

CREATE TABLE employees (
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50),
phone VARCHAR(20)
);

INSERT INTO employees (name, phone) VALUES
('John Doe', '123-456-7890'),
('Jane Smith', '987-654-3210'),
('Bob Johnson', '456-789-0123');

SELECT * FROM employees WHERE REGEXP_REPLACE(phone, '-', '') LIKE '123%';

Diese Abfrage wird folgendes zurückgeben:

+----+----------+--------------+
| id | name     | phone        |
+----+----------+--------------+
|  1 | John Doe | 123-456-7890 |
+----+----------+--------------+

Hier entfernen wir alle}-{ aus den Telefonnummern (REGEXP_REPLACE(phone, '-', '')) und überprüfen dann, ob das Ergebnis mit '123' beginnt.

REGEXP_REPLACE() Funktion in einem Client-Programm

Nun sehen wir, wie wir REGEXP_REPLACE() in einem Client-Programm verwenden können. Ich werde Python als Beispiel verwenden, aber das Konzept ist für andere Programmiersprachen ähnlich.

import mysql.connector

# Verbindung zur MySQL-Datenbank herstellen
cnx = mysql.connector.connect(user='your_username', password='your_password',
host='127.0.0.1', database='your_database')
cursor = cnx.cursor()

# Eine Abfrage mit REGEXP_REPLACE() ausführen
query = "SELECT REGEXP_REPLACE('Hello, World!', 'World', 'Python') AS result"
cursor.execute(query)

# Das Ergebnis abrufen und ausgeben
result = cursor.fetchone()
print(f"Ergebnis: {result[0]}")

# Verbindung schließen
cursor.close()
cnx.close()

Dieses Skript verbindet sich mit einer MySQL-Datenbank, führt unsere REGEXP_REPLACE()-Abfrage aus und gibt das Ergebnis aus. Die Ausgabe wäre:

Ergebnis: Hello, Python!

Und da habt ihr es! Wir haben die REGEXP_REPLACE()-Funktion von einfachen Ersetzungen bis hin zu komplexeren Mustervergleichen untersucht. Denkt daran, Übung macht den Meister. Also, experimentiert nicht mit verschiedenen Mustern und Ersatz-Strings.

Bevor wir aufhören, hier ist eine praktische Tabelle, die die REGEXP_REPLACE()-Funktion zusammenfasst:

Aspekt	Beschreibung
Syntax	REGEXP_REPLACE(subject, pattern, replace)
Zweck	Ersetzt alle Vorkommen eines Musters in einem String
Muster	Verwendet reguläre Ausdrücke für flexibles Matching
Case Sensitivity	Kann mit (?i) case-insensitiv gemacht werden
Vorkommen	Ersetzt standardmäßig alle Vorkommen
Verwendung	Kann in SELECT, WHERE und anderen SQL-Klauseln verwendet werden

Denkt daran, die Stärke von REGEXP_REPLACE() liegt in ihrer Flexibilität. Mit regulären Ausdrücken könnt ihr komplexe Mustervergleiche erstellen, um eure Daten so zu manipulieren, wie ihr es wollt. Viel Spaß beim Coden und möge jede Abfrage die Ergebnisse liefern, die ihr erwartet!

Credits: Image by storyset

Vorheriges Tutorial:

MySQL - regexp_like() Funktion

Nächstes Tutorial:

MySQL - regexp_substr() Funktion