Quels sont les types de paramètres des procédures stockées MySQL ?

Il existe trois types de paramètres pour les procédures stockées MySQL : 1. Les paramètres d'entrée, identifiés par le mot-clé "IN", peuvent être transmis à une procédure stockée ; 2. Les paramètres de sortie, identifiés par le mot-clé "OUT", sont utilisés lorsque le la procédure stockée doit renvoyer La situation du résultat d'une opération ; 3. Les paramètres d'entrée et de sortie, marqués du mot-clé "INOUT".

L'environnement d'exploitation de ce tutoriel : système windows7, version mysql8, ordinateur Dell G3.

Procédure stockée :

Un ensemble de fonctions programmables, qui sont un ensemble d'instructions SQL pour remplir des fonctions spécifiques. Elles sont compilées, créées et enregistrées dans la base de données. L'utilisateur peut spécifier le nom de la procédure stockée. et Exécution de l'appel avec des arguments (si nécessaire).

Avantages (Pourquoi utiliser des procédures stockées ?) :

　　① Encapsuler certaines opérations très répétitives dans une procédure stockée, simplifiant les appels à ces SQL

　　②Traitement par lots : SQL + boucle, réduire le trafic, c'est-à-dire "exécuter des lots"

　　③Interface unifiée pour garantir la sécurité des données

Par rapport à la base de données Oracle, les procédures stockées de MySQL sont relativement faibles en fonction et moins utilisées.

1. Création et appel de procédures stockées

　　>Une procédure stockée est un morceau de code avec un nom qui est utilisé pour remplir une fonction spécifique.

　　>La procédure stockée créée est enregistrée dans le dictionnaire de données de la base de données.

1. Créer une procédure stockée

CREATE
    [DEFINER = { user | CURRENT_USER }]
　PROCEDURE sp_name ([proc_parameter[,...]])
    [characteristic ...] routine_body

proc_parameter:
    [ IN | OUT | INOUT ] param_name type

characteristic:
    COMMENT 'string'
  | LANGUAGE SQL
  | [NOT] DETERMINISTIC
  | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
  | SQL SECURITY { DEFINER | INVOKER }

routine_body:
　　Valid SQL routine statement

[begin_label:] BEGIN
　　[statement_list]
　　　　……
END [end_label]

#Créer une base de données et sauvegarder la table de données par exemple d'opérations

mysql> create database db1;
mysql> use db1;    
mysql> create table PLAYERS as select * from TENNIS.PLAYERS;
mysql> create table MATCHES  as select * from TENNIS.MATCHES;

Exemple : Créer une procédure stockée pour supprimer tous les jeux joués par un joueur donné

mysql> delimiter $$　　#将语句的结束符号从分号;临时改为两个$$(可以是自定义)
mysql> CREATE PROCEDURE delete_matches(IN p_playerno INTEGER)
    -> BEGIN
    -> 　　DELETE FROM MATCHES
    ->    WHERE playerno = p_playerno;
    -> END$$
Query OK, 0 rows affected (0.01 sec)

mysql> delimiter ;　　#将语句的结束符号恢复为分号

Analyse :

Situation par défaut Ci-dessous, la procédure stockée est associée à la base de données par défaut. Si vous souhaitez spécifier que la procédure stockée est créée sous une base de données spécifique, ajoutez le nom de la base de données comme préfixe devant le nom de la procédure. la procédure, utilisez la commande DELIMITER $$ pour modifier l'instruction. Le symbole de fin est temporairement remplacé du point-virgule par deux $$, de sorte que le point-virgule utilisé dans le corps de la procédure soit transmis directement au serveur sans être interprété par le client (comme comme MySQL).

2. Appelez la procédure stockée : call sp_name[(parameters transmis)];

mysql> select * from MATCHES;
+---------+--------+----------+-----+------+
| MATCHNO | TEAMNO | PLAYERNO | WON | LOST |
+---------+--------+----------+-----+------+
|       1 |      1 |        6 |   3 |    1 |
|       7 |      1 |       57 |   3 |    0 |
|       8 |      1 |        8 |   0 |    3 |
|       9 |      2 |       27 |   3 |    2 |
|      11 |      2 |      112 |   2 |    3 |
+---------+--------+----------+-----+------+
5 rows in set (0.00 sec)

mysql> call delete_matches(57);
Query OK, 1 row affected (0.03 sec)

mysql> select * from MATCHES;
+---------+--------+----------+-----+------+
| MATCHNO | TEAMNO | PLAYERNO | WON | LOST |
+---------+--------+----------+-----+------+
|       1 |      1 |        6 |   3 |    1 |
|       8 |      1 |        8 |   0 |    3 |
|       9 |      2 |       27 |   3 |    2 |
|      11 |      2 |      112 |   2 |    3 |
+---------+--------+----------+-----+------+
4 rows in set (0.00 sec)

Analyse :

　La variable p_playerno qui doit recevoir des paramètres est définie dans la procédure stockée, 57. sera transmis en passant des paramètres. Attribuez une valeur à p_playerno, puis effectuez l'opération SQL dans la procédure stockée.

3. Corps de la procédure stockée

　　> Le corps de la procédure stockée contient des instructions qui doivent être exécutées lorsque la procédure est appelée, telles que : les instructions dml, ddl, les instructions if-then-else et while-do, et déclarer instructions pour déclarer des variables. Attendez

　　>Format du corps procédural : commencez par commencer et terminez par fin (peut être imbriqué)

BEGIN
　　BEGIN
　　　　BEGIN
　　　　　　statements; 
　　　　END
　　END
END

Remarque : chaque bloc imbriqué et chaque instruction qu'il contient doivent se terminer par un point-virgule, qui indique la fin de le corps du processus. -end bloc (également appelé instruction composée) ne nécessite pas de point-virgule.

4. Blocs d'instructions d'étiquette

[begin_label:] BEGIN
　　[statement_list]
END [end_label]

Par exemple :

label1: BEGIN
　　label2: BEGIN
　　　　label3: BEGIN
　　　　　　statements; 
　　　　END label3 ;
　　END label2;
END label1

Les étiquettes ont deux fonctions :

　　①Améliorer la lisibilité du code

　②Dans certaines instructions (par exemple : laisser et itérer les instructions), il est nécessaire d'utiliser tags

2. Paramètres des procédures stockées 　 Les procédures stockées peuvent avoir 0 ou plusieurs paramètres, qui sont utilisés pour la définition des procédures stockées.

Les procédures stockées MySQL prennent en charge trois types de paramètres, à savoir les paramètres d'entrée, les paramètres de sortie et les paramètres d'entrée/sortie, qui sont identifiés respectivement par les trois mots-clés IN, OUT et INOUT.

Parmi eux, les paramètres d'entrée peuvent être transmis à une procédure stockée, les paramètres de sortie sont utilisés lorsque la procédure stockée doit renvoyer un résultat d'opération, et les paramètres d'entrée/sortie peuvent servir à la fois de paramètres d'entrée et de paramètres de sortie.

3 types de paramètres :

Paramètre d'entrée IN : indique que l'appelant transmet une valeur au processus (la valeur entrante peut être un littéral ou une variable)
Paramètre de sortie OUT : indique que le processus transmet la valeur à l'appelant Valeurs sortantes (peut renvoyer plusieurs valeurs) (les valeurs sortantes ne peuvent être que des variables)
Paramètres d'entrée et de sortie INOUT : cela signifie que l'appelant transmet une valeur au processus, et il signifie que le processus transmet une valeur à l'appelant (la valeur est uniquement Peut être une variable)

1 dans le paramètre d'entrée

mysql> delimiter $$
mysql> create procedure in_param(in p_in int)
    -> begin
    -> 　　select p_in;
    -> 　　set p_in=2;
    ->    select P_in;
    -> end$$
mysql> delimiter ;

mysql> set @p_in=1;

mysql> call in_param(@p_in);
+------+
| p_in |
+------+
|    1 |
+------+

+------+
| P_in |
+------+
|    2 |
+------+

mysql> select @p_in;
+-------+
| @p_in |
+-------+
|     1 |
+-------+
#以上可以看出，p_in在存储过程中被修改，但并不影响@p_id的值，因为前者为局部变量、后者为全局变量。

2 dans le paramètre de sortie

mysql> delimiter //
mysql> create procedure out_param(out p_out int)
    ->   begin
    ->     select p_out;
    ->     set p_out=2;
    ->     select p_out;
    ->   end
    -> //
mysql> delimiter ;

mysql> set @p_out=1;

mysql> call out_param(@p_out);
+-------+
| p_out |
+-------+
|  NULL |
+-------+
　　#因为out是向调用者输出参数，不接收输入的参数，所以存储过程里的p_out为null
+-------+
| p_out |
+-------+
|     2 |
+-------+

mysql> select @p_out;
+--------+
| @p_out |
+--------+
|      2 |
+--------+
　　#调用了out_param存储过程，输出参数，改变了p_out变量的值

3.

mysql> delimiter $$
mysql> create procedure inout_param(inout p_inout int)
    ->   begin
    ->     select p_inout;
    ->     set p_inout=2;
    ->     select p_inout;
    ->   end
    -> $$
mysql> delimiter ;

mysql> set @p_inout=1;

mysql> call inout_param(@p_inout);
+---------+
| p_inout |
+---------+
|       1 |
+---------+

+---------+
| p_inout |
+---------+
|       2 |
+---------+

mysql> select @p_inout;
+----------+
| @p_inout |
+----------+
|        2 |
+----------+
#调用了inout_param存储过程，接受了输入的参数，也输出参数，改变了变量

Remarque :

　①Si le processus n'a pas de paramètres, il doit également écrire des parenthèses après le nom de la procédure

　　Exemple : CREATE PROCEDURE sp_name ([proc_parameter[,...]]) ……

　　②Assurez-vous que le le nom du paramètre n'est pas égal au nom de la colonne, sinon dans le corps de la procédure, le nom du paramètre sera Traitez-le comme un nom de colonne

[Recommandation associée :

Tutoriel vidéo mysql

]

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!