Présentation
« Une routine stockée est un ensemble d'instructions SQL qui peuvent être stockés sur le serveur. »
Une procédure stockée est un segment d'instructions SQL déclaratives stockés à l'intérieur le catalogue de base de données. Une procédure stockée peut être invoqué par les déclencheurs, d'autres procédures stockées et des applications telles que Java , Python, PHP, etc.
Une procédure stockée est une méthode pour encapsuler des tâches répétitives. Ils permettent des déclarations variables, le contrôle de flux et d'autres techniques de programmation utiles.
Pros
- Partager la logique avec d'autres applications.
Les procédures stockées encapsulent la fonctionnalité; cela garantit que l'accès aux données et la manipulation sont cohérents entre différentes applications.
Isoler les utilisateurs des tables de données. Cela vous donne la possibilité d'accorder l'accès aux procédures stockées qui manipulent les données mais pas directement aux tables.
Fournir un mécanisme de sécurité. Compte tenu de l'élément précédent, si vous ne pouvez accéder aux données qu'en utilisant les procédures stockées définies, personne d'autre ne peut exécuter une instruction SQL DELETE et effacer vos données.
Pour améliorer les performances, car cela réduit le trafic réseau. Avec une procédure stockée, plusieurs appels peuvent être fusionnés en un seul.
Contre
- charge accrue sur le serveur de base de données - la plupart du travail se fait sur le côté serveur, et moins du côté client.
- Il y a une courbe d'apprentissage décente. Vous aurez besoin d'apprendre la syntaxe des instructions MySQL afin d'écrire des procédures stockées.
- Vous répétez la logique de votre application dans deux endroits différents:
- votre code serveur et le code des procédures stockées, rendant les choses un peu plus difficiles à maintenir. La migration vers un système de gestion de base de données différent (DB2, SQL Server, etc.) peut s'avérer plus difficile.
Étape 1 - Choisir un délimiteur
Le séparateur est le caractère ou une chaîne de caractères que vous utilisez pour dire au client MySQL que vous avez fini de taper dans une instruction SQL. Pour les âges, le délimiteur a toujours été un point-virgule. Cela pose cependant des problèmes car, dans une procédure stockée, il est possible d'avoir plusieurs instructions, et chacune doit se terminer par un point-virgule. J'utilise « // »
Étape 2 - Comment travailler avec une procédure stockée
Création d'une procédure
DELIMITER //
CREATE PROCEDURE `p2`()
LANGUAGE SQL
DETERMINISTIC
SQL SECURITY DEFINER
COMMENT 'A procedure'
BEGIN
SELECT 'Hello World !';
END//
stockées La première partie de la déclaration crée la procédure. Les clauses suivantes définissent les caractéristiques optionnelles de la procédure. Ensuite, vous avez le nom et enfin le corps ou le code de routine.
Les noms de procédure stockée sont sensibles à la casse et vous ne pouvez pas créer de procédures portant le même nom. Dans un corps de procédure, vous ne pouvez pas mettre d'instructions de manipulation de base de données.
Les quatre caractéristiques d'une procédure sont:
Langue:
Aux fins de portabilité; la valeur par défaut est SQL.
déterministes:
Si la procédure renvoie toujours les mêmes résultats, compte tenu de la même entrée. Ceci est pour la réplication et la journalisation. La valeur par défaut est NOT DETERMINISTIC.
sécurité SQL:
Au moment de l'appel, vérifier les privilèges de l'utilisateur. INVOKER est l'utilisateur qui appelle la procédure. DEFINER est le créateur de la procédure. La valeur par défaut est DEFINER.
Commentaire:
Pour la documentation; la valeur par défaut est « »
Appel d'une procédure
Stocké Pour appeler une procédure, il vous suffit d'entrer le mot CALL, suivi du nom de la procédure, et les parenthèses, y compris tous les paramètres entre eux (variables ou valeurs). Les parenthèses sont obligatoires.
CALL stored_procedure_name (param1, param2, ....)
CALL procedure1(10 , 'string parameter' , @parameter_var);
Modifier une procédure
stockées MySQL fournit une instruction ALTER PROCEDURE de modifier une routine, mais permet la possibilité de modifier certaines caractéristiques. Si vous devez modifier le corps ou les paramètres, vous devez supprimer et recréer la procédure.
Supprimer une procédure stockée
DROP PROCEDURE IF EXISTS p2;
Ceci est une simple commande. La clause IF EXISTS empêche une erreur si la procédure n'existe pas.
Étape 3 - Paramètres
Examinons comment vous pouvez définir des paramètres dans une procédure stockée. La liste des paramètres est vide. - CREATE PROCEDURE proc1 (IN varname DATA-TYPE): Un paramètre d'entrée. Le mot IN est facultatif car les paramètres sont IN (entrée) par défaut. - CREATE PROCEDURE proc1 (OUT varname DATA-TYPE) : Un paramètre de sortie. - CREATE PROCEDURE proc1 (INOUT varname DATA-TYPE) : Un paramètre qui est à la fois entrée et sortie. Bien sûr, vous pouvez définir plusieurs paramètres définis avec différents types.
dans l'exemple
DELIMITER //
CREATE PROCEDURE `proc_IN` (IN var1 INT)
BEGIN
SELECT var1 + 2 AS result;
END//
INOUT exemple
DELIMITER //
CREATE PROCEDURE `proc_INOUT` (OUT var1 INT)
BEGIN
SET var1 = var1 * 2;
END //
Étape 4 - Variables
L'étape suivante vous apprendra comment définir des variables et des valeurs de magasin à l'intérieur une procédure. Vous devez les déclarer explicitement au début du bloc BEGIN/END, avec leurs types de données. Une fois que vous avez déclaré une variable, vous pouvez l'utiliser partout où vous pourriez utiliser une variable de session, ou un littéral, ou un nom de colonne.
Déclarer une variable en utilisant la syntaxe suivante:
DECLARE DÉFAUT DE DONNÉES DE TYPE nomvar defaultvalue; Déclarons quelques variables:
DECLARE a, b INT DEFAULT 5;
DECLARE str VARCHAR(50);
DECLARE today TIMESTAMP DEFAULT CURRENT_DATE;
DECLARE v1, v2, v3 TINYINT;
Utilisation des variables
Une fois que les variables ont été déclarées, vous pouvez les assigner des valeurs en utilisant la commande SET ou SELECT:
Étape 5 - Structures de contrôle de flux
MySQL prend en charge le IF, CASE, ITERATE, LEAVE LOOP, WHILE and REPEAT construit pour le contrôle de flux dans les programmes stockés. Nous allons examiner comment utiliser IF, CASE et WHILE spécifiquement, car ils sont les plus couramment utilisés dans les routines.
instruction IF Avec la déclaration IF, nous pouvons gérer les tâches qui implique des conditions:
DELIMITER //
CREATE PROCEDURE `proc_IF` (IN param1 INT)
BEGIN
DECLARE variable1 INT;
SET variable1 = param1 + 1;
IF variable1 = 0 THEN
SELECT variable1;
END IF;
IF param1 = 0 THEN
SELECT 'Parameter value = 0';
ELSE
SELECT 'Parameter value <> 0';
END IF;
END //
instruction CASE La déclaration CASE est une autre façon de vérifier les conditions et prendre le chemin approprié. C'est un excellent moyen de remplacer plusieurs instructions IF. La déclaration peut être écrite de deux manières différentes, offrant une grande flexibilité pour gérer plusieurs conditions.
DELIMITER //
CREATE PROCEDURE `proc_CASE` (IN param1 INT)
BEGIN
DECLARE variable1 INT;
SET variable1 = param1 + 1;
CASE variable1
WHEN 0 THEN
INSERT INTO table1 VALUES (param1);
WHEN 1 THEN
INSERT INTO table1 VALUES (variable1);
ELSE
INSERT INTO table1 VALUES (99);
END CASE;
END //
OU
DELIMITER //
CREATE PROCEDURE `proc_CASE` (IN param1 INT)
BEGIN
DECLARE variable1 INT;
SET variable1 = param1 + 1;
CASE
WHEN variable1 = 0 THEN
INSERT INTO table1 VALUES (param1);
WHEN variable1 = 1 THEN
INSERT INTO table1 VALUES (variable1);
ELSE
INSERT INTO table1 VALUES (99);
END CASE;
END //
déclaration WHILE
Il y a trois boucles sur le plan technique standard: WHILE loops, LOOP loops, and REPEAT loops. Vous avez également la possibilité de créer une boucle en utilisant le "Darth Vader" des techniques de programmation: le GOTO statement. Voir cet exemple d'une boucle en action:
DELIMITER //
CREATE PROCEDURE `proc_WHILE` (IN param1 INT)
BEGIN
DECLARE variable1, variable2 INT;
SET variable1 = 0;
WHILE variable1 < param1 DO
INSERT INTO table1 VALUES (param1);
SELECT COUNT(*) INTO variable2 FROM table1;
SET variable1 = variable1 + 1;
END WHILE;
END //
Étape 6 - curseurs
Cursor est utilisé pour itérer à travers un ensemble de lignes renvoyées par une requête et traiter chaque ligne. MySQL prend en charge le curseur dans les procédures stockées.
Voici un résumé de la syntaxe essentielle pour créer et utiliser un curseur.
- DECLARE cursor-name CURSOR FOR SELECT ...;/* Déclarer et remplir le curseur avec une instruction SELECT */
- DECLARE CONTINUER GESTIONNAIRE POUR INTROUVABLE/Précisez ce qu'il faut faire lorsqu'il n'y a pas plus de disques trouvé/
OPEN cursor-name;/curseur ouvert pour utiliser/
FETCH cursor-name INTO variable [, variable];/des variables Assign avec les valeurs de colonne courante/
CLOSE cursor-name;/Fermer curseur après utilisation/
Dans cet exemple, je vais effectuer certaines opérations simples à l'aide d'un curseur:
DELIMITER //
CREATE PROCEDURE `proc_CURSOR` (OUT param1 INT)
BEGIN
DECLARE a, b, c INT;
DECLARE cur1 CURSOR FOR SELECT col1 FROM table1;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET b = 1;
OPEN cur1;
SET b = 0;
SET c = 0;
WHILE b = 0 DO
FETCH cur1 INTO a;
IF b = 0 THEN
SET c = c + a;
END IF;
END WHILE;
CLOSE cur1;
SET param1 = c;
END //
curseur a trois propriétés importantes que vous devez connaître avec afin d'éviter des résultats inattendus:
Asensitive: Une fois ouvert, le curseur ne reflète pas les modifications dans ses tables source. En fait, MySQL ne garantit pas que le curseur sera mis à jour, donc vous ne pouvez pas compter dessus.
Lecture seule: Les curseurs ne peuvent pas être mis à jour.
Non Scrollable: Curseurs peuvent être traversèrent que dans une seule direction, vers l'avant, et vous ne pouvez pas ignorer les enregistrements de l'extraction
Hope this utile
no contest - sprocs sont plus efficace sur tant de niveaux. Oublions l'optimisation des requêtes et la vitesse d'exécution - pensons en termes d'appels requis, d'octets envoyés ..., de subventions requises (exec vs all), de sécurité, combien d'appels mysqli/pdo doit-il faire à exec 1 requête paramétrée? serait-ce 2 ??? lol –