MySQL - Speicherfunktionen

Hallo, angehende Datenbankbegeisterte! Heute tauchen wir ein in die faszinierende Welt der MySQL-Speicherfunktionen. Als dein freundlicher Nachbarschafts-EDV-Lehrer bin ich begeistert, dich auf dieser Reise zu begleiten, selbst wenn du noch nie eine Zeile Code geschrieben hast. Also, hole dir ein Getränk deiner Wahl und los geht's!

MySQL - Stored Functions

Was sind MySQL-Speicherfunktionen?

Stell dir vor, du hast ein magisches Kochbuch, das deine Lieblingsgerichte sofort zaubert, wann immer du sie benötigst. Das ist so ein bisschen, was MySQL-Speicherfunktionen für Datenbanken tun! Sie sind wie vorab geschriebene Rezepte (oder Funktionen), die du jederzeit aufrufen kannst, wenn du eine bestimmte Aufgabe in deiner Datenbank ausführen musst.

Warum Speicherfunktionen verwenden?

Wiederverwendbarkeit: Einmal schreiben, viele Male verwenden!
Konsistenz: Sicherstellen, dass überall die gleiche Logik angewendet wird.
Sicherheit: Kontrolle darüber, wer auf deine Funktionen zugreifen und diese ändern kann.
Leistung: Sie können schneller sein als das wiederholte Schreiben desselben Codes.

Nun, lasst uns die Ärmel hochwerren und unsere erste Speicherfunktion erstellen!

Erstellen deiner ersten Speicherfunktion

Hier ist ein einfaches Beispiel, um loszulegen:

DELIMITER //

CREATE FUNCTION HelloWorld()
RETURNS VARCHAR(50)
DETERMINISTIC
BEGIN
RETURN 'Hallo, Welt!';
END //

DELIMITER ;

Lassen wir das auseinanderfallen:

DELIMITER //: Das teilt MySQL mit, dass // als Anweisungs-Trennzeichen verwendet werden soll, anstatt des Standard-Semikolons (;). Wir tun dies, weil unsere Funktion Semikolons enthält, und wir nicht möchten, dass MySQL verwirrt wird.
CREATE FUNCTION HelloWorld(): Diese Zeile erklärt, dass wir eine Funktion namens "HelloWorld" erstellen.
RETURNS VARCHAR(50): Das gibt an, dass unsere Funktion eine Zeichenkette (VARCHAR) von bis zu 50 Zeichen zurückgeben wird.
DETERMINISTIC: Dieses Schlüsselwort teilt MySQL mit, dass für die gleiche Eingabe die Funktion stets die gleiche Ausgabe liefert.
BEGIN und END: Diese Schlüsselwörter umschließen den Körper unserer Funktion.
RETURN 'Hallo, Welt!';: Dies ist der tatsächliche Code unserer Funktion. Er gibt einfach die Zeichenkette "Hallo, Welt!" zurück.
DELIMITER ;: Das setzt das Trennzeichen zurück auf das Standard-Semikolon.

Nun rufen wir unsere Funktion auf:

SELECT HelloWorld();

Und voilà! Du solltest "Hallo, Welt!" als Ergebnis sehen. Herzlichen Glückwunsch, du hast gerade deine erste Speicherfunktion erstellt und aufgerufen!

Parameter und Variablen in Speicherfunktionen

Machen wir die Dinge ein bisschen interessanter, indem wir unserer Funktion Parameter und Variablen hinzufügen.

DELIMITER //

CREATE FUNCTION Greet(name VARCHAR(50))
RETURNS VARCHAR(100)
DETERMINISTIC
BEGIN
DECLARE greeting VARCHAR(100);
SET greeting = CONCAT('Hallo, ', name, '! Willkommen bei MySQL-Funktionen!');
RETURN greeting;
END //

DELIMITER ;

In diesem Beispiel:

Wir haben einen Parameter name VARCHAR(50) zu unserer Funktion hinzugefügt.
Wir haben eine Variable greeting mit dem DECLARE-Schlüsselwort deklariert.
Wir verwenden das SET-Schlüsselwort, um unserer Variable einen Wert zuzuweisen.
Wir haben die CONCAT-Funktion verwendet, um Zeichenketten zu kombinieren.

Rufen wir unsere neue Funktion auf:

SELECT Greet('Alice');

Das sollte folgende Ausgabe liefern: "Hallo, Alice! Willkommen bei MySQL-Funktionen!"

Verwendung von Speicherfunktionen mit Datenbankdaten

Nun erstellen wir eine Funktion, die actually mit unseren Datenbankdaten interagiert. Stellen wir uns eine Tabelle namens employees mit den Spalten id, first_name, last_name und salary vor.

DELIMITER //

CREATE FUNCTION CalculateBonus(employee_id INT)
RETURNS DECIMAL(10,2)
READS SQL DATA
BEGIN
DECLARE employee_salary DECIMAL(10,2);
DECLARE bonus DECIMAL(10,2);

SELECT salary INTO employee_salary
FROM employees
WHERE id = employee_id;

SET bonus = employee_salary * 0.1;

RETURN bonus;
END //

DELIMITER ;

Diese Funktion:

Nimmt eine employee_id als Eingabe.
Deklariert Variablen für employee_salary und bonus.
Holt das Gehalt des Mitarbeiters aus der employees-Tabelle.
Berechnet eine 10%ige Prämie basierend auf dem Gehalt.
Gibt die berechnete Prämie zurück.

Um diese Funktion zu verwenden:

SELECT first_name, last_name, CalculateBonus(id) AS bonus
FROM employees
WHERE id = 1;

Das wird den Vornamen, Nachnamen und die berechnete Prämie für den Mitarbeiter mit der ID 1 zurückgeben.

Kontrollfluss in Speicherfunktionen

Lassen wir unsere Bonusberechnung mit etwas Kontrollfluss erweitern:

DELIMITER //

CREATE FUNCTION CalculateBonusTier(employee_id INT)
RETURNS VARCHAR(20)
READS SQL DATA
BEGIN
DECLARE employee_salary DECIMAL(10,2);
DECLARE bonus_tier VARCHAR(20);

SELECT salary INTO employee_salary
FROM employees
WHERE id = employee_id;

IF employee_salary < 30000 THEN
SET bonus_tier = 'Bronze';
ELSEIF employee_salary < 50000 THEN
SET bonus_tier = 'Silber';
ELSE
SET bonus_tier = 'Gold';
END IF;

RETURN bonus_tier;
END //

DELIMITER ;

Diese Funktion verwendet IF, ELSEIF und ELSE, um eine Prämienstufe basierend auf dem Gehalt des Mitarbeiters zu bestimmen.

Aufruf von Speicherfunktionen aus einer Speicherprozedur

Schließlich sehen wir, wie wir unsere Speicherfunktionen in einer Speicherprozedur verwenden können:

DELIMITER //

CREATE PROCEDURE EmployeeBonusReport(IN emp_id INT)
BEGIN
DECLARE emp_name VARCHAR(100);
DECLARE emp_bonus DECIMAL(10,2);
DECLARE emp_bonus_tier VARCHAR(20);

SELECT CONCAT(first_name, ' ', last_name) INTO emp_name
FROM employees
WHERE id = emp_id;

SET emp_bonus = CalculateBonus(emp_id);
SET emp_bonus_tier = CalculateBonusTier(emp_id);

SELECT emp_name AS 'Employee Name',
emp_bonus AS 'Bonus Amount',
emp_bonus_tier AS 'Bonus Tier';
END //

DELIMITER ;

Diese Speicherprozedur:

Nimmt eine Mitarbeiter-ID als Eingabe.
Holt den vollständigen Namen des Mitarbeiters.
Ruft unsere CalculateBonus-Funktion auf, um den Bonusbetrag zu erhalten.
Ruft unsere CalculateBonusTier-Funktion auf, um die Bonusstufe zu erhalten.
Gibt einen Bericht mit dem Namen, dem Bonusbetrag und der Bonusstufe des Mitarbeiters zurück.

Um diese Prozedur aufzurufen:

CALL EmployeeBonusReport(1);

Und das ist es! Wir haben die Grundlagen der MySQL-Speicherfunktionen von der Erstellung bis zur Verwendung in Speicherprozeduren behandelt. Denke daran, Übung macht den Meister, also probiere ruhig eigene Funktionen aus. Viel Spaß beim Programmieren! |

MySQL-Funktionsmethoden
CREATE FUNCTION
RETURNS
DETERMINISTIC
BEGIN...END
DECLARE
SET
IF...ELSEIF...ELSE
SELECT...INTO
RETURN

Credits: Image by storyset