À 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
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.
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 permettent de réduire le trafic entre l'application et le serveur de base de données.
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.
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.
Inconvénients
La structure des procédures stockées rend difficile le développement de procédures stockées avec une logique métier complexe.
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.
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.Définition de la procédure stockée MySQL
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 ;
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.
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.
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.
Quantity Les instructions dans les procédures stockées doivent être incluses entre BEGIN et END.
DELIMITER $$ CREATE PROCEDURE `demo`.`demo1`() -- 存储过程体 BEGIN -- DECLARE声明 用来声明变量的 DECLARE de_name VARCHAR(10) DEFAULT ''; SET de_name = "jim"; -- 测试输出语句(不同的数据库,测试语句都不太一样。 SELECT de_name; END$$ DELIMITER ;
现在要查询这个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 语句包含多个条件判断,根据结果为 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是一种类似于编程语言中的choose和when语法的条件判断语句。MySQL 中的 case语句有两种语法格式。
第一种
DELIMITER $$ CREATE PROCEDURE demo4(IN num INT) BEGIN CASE -- 条件开始 WHEN num<0 THEN SELECT '负数'; WHEN num>0 THEN SELECT '正数'; ELSE SELECT '不是正数也不是负数'; 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);
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;
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;
循环语句,用来重复执行某些语句。
执行过程中可使用 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!