Comment appeler une procédure stockée MySQL

Présentation

À partir de la version MySQL 5.0, les procédures stockées sont prises en charge.

Si nous devons écrire un ensemble complexe d'instructions SQL pour répondre à certains besoins des utilisateurs, nous pouvons alors écrire cet ensemble complexe d'instructions SQL dans la base de données à l'avance et appeler JDBC pour exécuter cet ensemble d'instructions SQL. L'ensemble des instructions SQL écrites dans la base de données est appelé une procédure stockée.

Procédure stockée : (PROCEDURE) est une collection d'instructions SQL qui ont été compilées à l'avance et stockées dans la base de données. L'appel de procédures stockées peut simplifier beaucoup de travail pour les développeurs d'applications, réduire la transmission de données entre la base de données et le serveur d'applications et s'avère très bénéfique pour améliorer l'efficacité du traitement des données.

Il s'agit de l'encapsulation et de la réutilisation de code au niveau du langage SQL de la base de données.

Semblable aux méthodes en Java, les procédures stockées doivent d'abord être définies et appelées lorsqu'elles sont utilisées. Les paramètres peuvent être définis dans des procédures stockées. Ces paramètres sont divisés en trois types : IN, OUT et INOUT. Les paramètres de type

• IN représentent l'acceptation des données transmises par l'appelant ; les paramètres de type

• OUT représentent le retour des données à l'appelant ; les paramètres de type INOUT peuvent également accepter les paramètres transmis par l'appelant. retourné à l'appelant.

• Avantages

Les procédures stockées sont regroupées dans des unités faciles à utiliser, simplifiant les opérations complexes.

1. Simplifiez la gestion des changements. Si le nom de la table, le nom de la colonne ou la logique métier change. Seul le code de la procédure stockée doit être modifié. Les personnes qui l'utilisent n'ont pas besoin de modifier leur code.

2. Les procédures généralement stockées aident à améliorer les performances des applications. Lorsque la procédure stockée créée est compilée, elle est stockée dans la base de données.

   Cependant, MySQL implémente les procédures stockées légèrement différemment.
Les procédures stockées MySQL sont compilées à la demande. Après avoir compilé la procédure stockée, MySQL la place dans le cache.
3. MySQL maintient son propre cache de procédures stockées pour chaque connexion. Si l'application utilise la procédure stockée plusieurs fois dans une seule connexion, utilisez la version compilée, sinon la procédure stockée fonctionne comme une requête.

   
   
   
   Les procédures stockées permettent de réduire le trafic entre l'application et le serveur de base de données.

   Étant donné que l'application n'a pas besoin d'envoyer plusieurs instructions SQL longues, elle doit uniquement envoyer le nom et les paramètres dans la procédure stockée.

4. 
   Les procédures stockées sont réutilisables et transparentes pour toute application. Pour éviter aux développeurs de dupliquer des fonctionnalités déjà prises en charge, les procédures stockées exposent l'interface de base de données à toutes les applications.

5. Les programmes stockés sont sécurisés. Les administrateurs de base de données peuvent accorder les autorisations appropriées aux applications qui accèdent aux procédures stockées dans la base de données sans accorder d'autorisations aux tables de base de données sous-jacentes.

6. Inconvénients

Si vous utilisez un grand nombre de procédures stockées, l'utilisation de la mémoire de chaque connexion utilisant ces procédures stockées augmentera considérablement.

De plus, si un grand nombre d'opérations logiques sont surutilisées dans les procédures stockées, l'utilisation du processeur augmentera également, car la conception originale de la base de données MySQL se concentrait sur des requêtes efficaces plutôt que sur des opérations logiques.

1. 
   La structure des procédures stockées rend difficile le développement de procédures stockées avec une logique métier complexe.

2. Il est difficile de déboguer des procédures stockées. Seuls quelques systèmes de gestion de bases de données permettent le débogage des procédures stockées. Malheureusement, MySQL n'offre pas la possibilité de déboguer les procédures stockées.

3. Développer et maintenir des procédures stockées n'est pas facile.

   Le développement et la maintenance de procédures stockées nécessitent souvent un ensemble de compétences spécialisées que tous les développeurs d'applications ne possèdent pas. Cela peut entraîner des problèmes lors des phases de développement et de maintenance des applications.

4. 
   

   Il présente un degré élevé de dépendance à l'égard de la base de données et une faible transférabilité.

5. Définition de la procédure stockée MySQL

Format d'instruction de base de la procédure stockée

DELIMITER $$

CREATE
    /*[DEFINER = { user | CURRENT_USER }]*/
    PROCEDURE 数据库名.存储过程名([in变量名 类型,out 参数 2，...])
    /*LANGUAGE SQL
    | [NOT] DETERMINISTIC
    | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
    | SQL SECURITY { DEFINER | INVOKER }
    | COMMENT 'string'*/
	BEGIN
		[DECLARE 变量名 类型 [DEFAULT 值];]
		存储过程的语句块;
	END$$

DELIMITER ;

Quantity Les paramètres de la procédure stockée sont in, out et inout

in représente le paramètre d'entrée (par défaut, c'est le en paramètre), indiquant que la valeur de ce paramètre doit être spécifiée par le programme appelant.

1. ou représente le paramètre de sortie, ce qui signifie qu'une fois la valeur du paramètre calculée par la procédure stockée, le résultat du calcul du paramètre out est renvoyé au programme appelant.

2. inout représente un paramètre d'entrée immédiat et un paramètre de sortie, ce qui signifie que la valeur du paramètre peut être formulée par le programme appelant et que le résultat du calcul du paramètre inout peut être renvoyé au programme appelant.

3. Quantity Les instructions dans les procédures stockées doivent être incluses entre BEGIN et END.

weight DECLARE est utilisé pour déclarer des variables. L'affectation de variable par défaut utilise DEFAULT. Pour modifier la valeur de la variable dans un bloc d'instruction, utilisez SET variable = value ;

Appelez une procédure stockée

DELIMITER $$

CREATE
    PROCEDURE `demo`.`demo1`()
	-- 存储过程体
	BEGIN
		-- DECLARE声明 用来声明变量的
		DECLARE de_name VARCHAR(10) DEFAULT '';
		
		SET de_name = "jim";
		
		-- 测试输出语句（不同的数据库，测试语句都不太一样。
		SELECT de_name;
	END$$

DELIMITER ;

Définissez une procédure stockée avec des paramètres

Définissez d'abord une table de base de données étudiant :

现在要查询这个student表中的sex为男的有多少个人。

DELIMITER $$

CREATE
    PROCEDURE `demo`.`demo2`(IN s_sex CHAR(1),OUT s_count INT)
	-- 存储过程体
	BEGIN
		-- 把SQL中查询的结果通过INTO赋给变量
		SELECT COUNT(*) INTO s_count FROM student WHERE sex= s_sex;
		SELECT s_count;
		
	END$$
DELIMITER ;

调用这个存储过程

-- @s_count表示测试出输出的参数
CALL demo2 ('男',@s_count);

定义一个流程控制语句 IF ELSE

IF 语句包含多个条件判断，根据结果为 TRUE、FALSE执行语句，与编程语言中的 if、else if、else 语法类似。

DELIMITER $$
CREATE
    PROCEDURE `demo`.`demo3`(IN `day` INT)
	-- 存储过程体
	BEGIN
		IF `day` = 0 THEN
		SELECT '星期天';
		ELSEIF `day` = 1 THEN
		SELECT '星期一';
		ELSEIF `day` = 2 THEN
		SELECT '星期二';
		ELSE
		SELECT '无效日期';
		END IF;
		
	END$$
DELIMITER ;

调用这个存储过程

CALL demo3(2);

定义一个条件控制语句 CASE

case是一种类似于编程语言中的choose和when语法的条件判断语句。MySQL 中的 case语句有两种语法格式。

第一种

DELIMITER $$
CREATE 
    PROCEDURE demo4(IN num INT)
	BEGIN
		CASE -- 条件开始
	
		WHEN num<0 THEN 
			SELECT &#39;负数&#39;;
		WHEN num>0 THEN 
			SELECT &#39;正数&#39;;
		ELSE 
		SELECT &#39;不是正数也不是负数&#39;;
	
		END CASE; -- 条件结束
	END$$
DELIMITER;

调用这个存储过程

CALL demo4(1);

2.第二种

DELIMITER $$
CREATE 
    PROCEDURE demo5(IN num INT)
	BEGIN
		CASE num  -- 条件开始
		WHEN 1 THEN 
			SELECT '输入为1';
		WHEN 0 THEN 
			SELECT '输入为0';
		ELSE 
		SELECT '不是1也不是0';
		END CASE; -- 条件结束
	END$$
DELIMITER;

调用此函数

CALL demo5(0);

定义一个循环语句 WHILE

DELIMITER $$
CREATE 
    PROCEDURE demo6(IN num INT,OUT SUM INT)
	BEGIN
	     SET SUM = 0;
	     WHILE num<10 DO -- 循环开始
	         SET num = num+1;
	         SET SUM = SUM+num;
	         END WHILE; -- 循环结束
	END$$
DELIMITER;

调用此函数

-- 调用函数
CALL demo6(0,@sum);

-- 查询函数
SELECT @sum;

定义一个循环语句 REPEAT UNTLL

REPEATE…UNTLL 语句的用法和 Java中的 do…while 语句类似，都是先执行循环操作，再判断条件，区别是REPEATE 表达式值为 false时才执行循环操作，直到表达式值为 true停止。

-- 创建过程
DELIMITER $$
CREATE 
    PROCEDURE demo7(IN num INT,OUT SUM INT)
	BEGIN
	     SET SUM = 0;
	     REPEAT-- 循环开始
		SET num = num+1;
		SET SUM = SUM+num ;
		UNTIL num>=10
		END REPEAT; -- 循环结束
	END$$
DELIMITER;

调用此函数

CALL demo7(9,@sum);

SELECT @sum;

定义一个循环语句 LOOP

循环语句，用来重复执行某些语句。

执行过程中可使用 LEAVE语句或者ITEREATE来跳出循环，也可以嵌套IF等判断语句。

LEAVE 语句效果对于Java中的break，用来终止循环；

ITERATE语句效果相当于Java中的continue，用来跳过此次循环。进入下一次循环。且ITERATE之下的语句将不在进行。

DELIMITER $$
CREATE 
    PROCEDURE demo8(IN num INT,OUT SUM INT)
	BEGIN
	     SET SUM = 0;
	     demo_sum:LOOP-- 循环开始
		SET num = num+1;
		IF num > 10 THEN
		    LEAVE demo_sum; -- 结束此次循环
		ELSEIF num < 9 THEN
		    ITERATE demo_sum; -- 跳过此次循环
		END IF;
		
		SET SUM = SUM+num;
		END LOOP demo_sum; -- 循环结束
	END$$
DELIMITER;

调用此函数

CALL demo8(0,@sum);

SELECT @sum;

使用存储过程插入信息

DELIMITER $$
CREATE 
    PROCEDURE demo9(IN s_student VARCHAR(10),IN s_sex CHAR(1),OUT s_result VARCHAR(20))
	BEGIN
	   -- 声明一个变量 用来决定这个名字是否已经存在
	   DECLARE s_count INT DEFAULT 0;
	   -- 验证这么名字是否已经存在
	   SELECT COUNT(*) INTO s_count FROM student WHERE `name` = s_student;	
	   IF s_count = 0 THEN
	        INSERT INTO student (`name`, sex) VALUES(s_student, s_sex);
		SET s_result = '数据添加成功';
	   ELSE
                SET s_result = '名字已存在，不能添加';
                SELECT s_result;
	   END IF;
	END$$
DELIMITER;

调用此函数

CALL demo9("Jim","女",@s_result);

再次调用次函数

CALL demo9("Jim","女",@s_result)

存储过程的管理

显示存储过程

SHOW PROCEDURE STATUS

显示特定数据库的存储过程

SHOW PROCEDURE STATUS WHERE db = 'db名字' AND NAME = 'name名字';

显示特定模式的存储过程

SHOW PROCEDURE STATUS WHERE NAME LIKE '%mo%';

显示存储过程的源码

SHOW CREATE PROCEDURE 存储过程名;

删除存储过程

DROP PROCEDURE 存储过程名;

后端调用存储过程的实现

在mybatis当中，调用存储过程

<parameterMap type="savemap" id=“usermap"> 
	<parameter property="name" jdbcType="VARCHAR" mode="IN"/>
	<parameter property="sex" jdbcType="CHAR" mode="IN"/>
	<parameter property="result" jdbcType="VARCHAR" mode="OUT"/>
</parameterMap>

<insert id="saveUserDemo" parameterMap="savemap" statementType="CALLABLE"> 
{call saveuser(?, ?, ?)} 
</insert >

调用数据库管理

HashMap<String, Object> map = new HashMap<String, Object>(); 
	map.put("name", "Jim"); 
	map.put("sex","男");
	userDao.saveUserDemo(map); 
	map.get(“result”);//获得输出参数

通过这样就可以调用数据库中的存储过程的结果。

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!