MySQL - Fonctions Stockées

Bonjour, aspirants passionnés de bases de données ! Aujourd'hui, nous allons plonger dans le monde fascinant des fonctions stockées MySQL. En tant que votre enseignant bienveillant en informatique du quartier, je suis excité de vous guider dans ce voyage, même si vous n'avez jamais écrit une ligne de code auparavant. Alors, prenez une tasse de votre boisson favorite et mettons-nous en route !

Qu'est-ce que les fonctions stockées MySQL ?

Imaginez que vous avez un livre de recettes magique qui peut instantanément préparer votre plat préféré chaque fois que vous en avez besoin. C'est un peu ce que sont les fonctions stockées MySQL pour les bases de données ! Ce sont comme des recettes pré-écrites (ou fonctions) que vous pouvez appeler chaque fois que vous avez besoin d'effectuer une tâche spécifique dans votre base de données.

Pourquoi utiliser des fonctions stockées ?

1. Réutilisabilité : Écrivez une fois, utilisez plusieurs fois !
2. Consistance : Assurez-vous que la même logique est appliquée partout.
3. Sécurité : Contrôlez qui peut accéder et modifier vos fonctions.
4. Performance : Elles peuvent être plus rapides que d'écrire le même code à plusieurs reprises.

Maintenant, mettons-nos manches et créons notre première fonction stockée !

Créer Votre Première Fonction Stockée

Voici un exemple simple pour nous lancer :

DELIMITER //

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

DELIMITER ;

Décomposons cela :

1. DELIMITER // : Cela indique à MySQL d'utiliser // comme délimiteur d'instruction au lieu du point-virgule par défaut (;). Nous faisons cela car notre fonction contient des point-virgules, et nous ne voulons pas que MySQL soit confondu.

2. CREATE FUNCTION HelloWorld() : Cette ligne déclare que nous créons une fonction nommée "HelloWorld".

3. RETURNS VARCHAR(50) : Cela spécifie que notre fonction renverra une chaîne (VARCHAR) de jusqu'à 50 caractères.

4. DETERMINISTIC : Ce mot-clé indique à MySQL que pour les mêmes entrées, la fonction renverra toujours la même sortie.

5. BEGIN et END : Ces mots-clés enveloppent le corps de notre fonction.

6. RETURN 'Hello, World!'; : C'est le code réel de notre fonction. Il renvoie simplement la chaîne "Hello, World!".

7. DELIMITER ; : Cela rétablit le délimiteur par défaut au point-virgule.

Maintenant, appelons notre fonction :

SELECT HelloWorld();

Et voilà ! Vous devriez voir "Hello, World!" comme résultat. Félicitations, vous venez de créer et d'appeler votre première fonction stockée !

Paramètres et Variables dans les Fonctions Stockées

Rendons les choses un peu plus intéressantes en ajoutant des paramètres et des variables à nos fonctions.

DELIMITER //

CREATE FUNCTION Greet(name VARCHAR(50))
RETURNS VARCHAR(100)
DETERMINISTIC
BEGIN
DECLARE greeting VARCHAR(100);
SET greeting = CONCAT('Hello, ', name, '! Welcome to MySQL functions!');
RETURN greeting;
END //

DELIMITER ;

Dans cet exemple :

1. Nous avons ajouté un paramètre name VARCHAR(50) à notre fonction.
2. Nous avons déclaré une variable greeting en utilisant le mot-clé DECLARE.
3. Nous utilisons le mot-clé SET pour affecter une valeur à notre variable.
4. Nous avons utilisé la fonction CONCAT pour combiner des chaînes.

Appelons notre nouvelle fonction :

SELECT Greet('Alice');

Cela devrait renvoyer : "Hello, Alice! Welcome to MySQL functions!"

Utilisation des Fonctions Stockées avec les Données de la Base

Maintenant, créons une fonction qui interagit réellement avec notre base de données. Imaginons que nous avons une table appelée employees avec les colonnes id, first_name, last_name, et salary.

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 ;

Cette fonction :

1. Prend un employee_id en entrée.
2. Déclare des variables pour employee_salary et bonus.
3. Récupère le salaire de l'employé à partir de la table employees.
4. Calcule une prime de 10 % basée sur le salaire.
5. Renvoie la prime calculée.

Pour utiliser cette fonction :

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

Cela renverra le prénom, le nom et la prime calculée pour l'employé avec l'id 1.

Contrôle de Flux dans les Fonctions Stockées

Améliorons notre calcul de prime avec un peu de contrôle de flux :

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 = 'Silver';
ELSE
SET bonus_tier = 'Gold';
END IF;

RETURN bonus_tier;
END //

DELIMITER ;

Cette fonction utilise IF, ELSEIF, et ELSE pour déterminer un niveau de prime basé sur le salaire de l'employé.

Appel de Fonction Stockée à partir d'une Procédure Stockée

Enfin, voyons comment nous pouvons utiliser nos fonctions stockées à l'intérieur d'une procédure stockée :

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 ;

Cette procédure stockée :

1. Prend un identifiant d'employé en entrée.
2. Récupère le nom complet de l'employé.
3. Appelle notre fonction CalculateBonus pour obtenir le montant de la prime.
4. Appelle notre fonction CalculateBonusTier pour obtenir le niveau de prime.
5. Retourne un rapport avec le nom de l'employé, le montant de la prime et le niveau de prime.

Pour appeler cette procédure :

CALL EmployeeBonusReport(1);

Et voilà ! Nous avons couvert les bases des fonctions stockées MySQL, de leur création à leur utilisation dans les procédures stockées. Souvenez-vous, la pratique rend parfait, donc n'ayez pas peur d'expérimenter avec vos propres fonctions. Bonne programmation !

Credits: Image by storyset