So rufen Sie eine gespeicherte MySQL-Prozedur auf

Übersicht

Ab MySQL Version 5.0 werden gespeicherte Prozeduren unterstützt.

Wenn Sie einen komplexen Satz SQL-Anweisungen schreiben müssen, um bestimmte Benutzeranforderungen zu erfüllen, können wir diesen komplexen Satz SQL-Anweisungen im Voraus in die Datenbank schreiben und JDBC aufrufen, um diesen Satz SQL-Anweisungen auszuführen. Der Satz von SQL-Anweisungen, die in die Datenbank geschrieben werden, wird als gespeicherte Prozedur bezeichnet.

Gespeicherte Prozedur: (PROCEDURE) ist eine Sammlung von SQL-Anweisungen, die im Voraus kompiliert und in der Datenbank gespeichert wurden. Das Aufrufen gespeicherter Prozeduren kann Anwendungsentwicklern viel Arbeit erleichtern, die Datenübertragung zwischen der Datenbank und dem Anwendungsserver reduzieren und trägt sehr dazu bei, die Effizienz der Datenverarbeitung zu verbessern.

Es handelt sich um die Kapselung und Wiederverwendung von Code auf der SQL-Sprachebene der Datenbank.

Ähnlich wie Methoden in Java müssen gespeicherte Prozeduren zuerst definiert und bei Verwendung aufgerufen werden. Parameter können in gespeicherten Prozeduren definiert werden. Diese Parameter sind in drei Typen unterteilt: IN, OUT und INOUT.

• IN-Typparameter stellen die vom Aufrufer übergebenen Daten dar;

• OUT-Typparameter stellen die vom Aufrufer übergebenen Daten dar; an den Anrufer zurückgegeben.

• Vorteile

Gespeicherte Prozeduren sind in benutzerfreundlichen Einheiten verpackt, was komplexe Vorgänge vereinfacht.

1. Vereinfachen Sie die Verwaltung von Änderungen. Wenn sich der Tabellenname, der Spaltenname oder die Geschäftslogik ändert. Lediglich der Code der gespeicherten Prozedur muss geändert werden. Wer es nutzt, muss seinen Code nicht ändern.

2. Normalerweise tragen gespeicherte Prozeduren zur Verbesserung der Anwendungsleistung bei. Wenn die erstellte gespeicherte Prozedur kompiliert wird, wird sie in der Datenbank gespeichert.

   MySQL implementiert gespeicherte Prozeduren jedoch etwas anders.
Gespeicherte MySQL-Prozeduren werden bei Bedarf kompiliert. Nachdem die gespeicherte Prozedur kompiliert wurde, legt MySQL sie im Cache ab.
3. MySQL verwaltet für jede Verbindung einen eigenen Cache mit gespeicherten Prozeduren. Wenn die Anwendung die gespeicherte Prozedur mehrmals in einer einzigen Verbindung verwendet, verwenden Sie die kompilierte Version, andernfalls funktioniert die gespeicherte Prozedur wie eine Abfrage.

   
   
   
   Gespeicherte Prozeduren tragen dazu bei, den Datenverkehr zwischen der Anwendung und dem Datenbankserver zu reduzieren.

   Da die Anwendung nicht mehrere lange SQL-Anweisungen senden muss, muss sie nur den Namen und die Parameter in der gespeicherten Prozedur senden.

4. 
   Gespeicherte Prozeduren sind wiederverwendbar und für jede Anwendung transparent. Um Entwicklern das Duplizieren bereits unterstützter Funktionen zu ersparen, stellen gespeicherte Prozeduren die Datenbankschnittstelle allen Anwendungen zur Verfügung.

5. Gespeicherte Programme sind sicher. Datenbankadministratoren können Anwendungen, die auf gespeicherte Prozeduren in der Datenbank zugreifen, entsprechende Berechtigungen erteilen, ohne Berechtigungen für die zugrunde liegenden Datenbanktabellen zu erteilen.

6. Nachteile

Wenn Sie eine große Anzahl gespeicherter Prozeduren verwenden, erhöht sich die Speichernutzung jeder Verbindung, die diese gespeicherten Prozeduren verwendet, erheblich.

Wenn außerdem eine große Anzahl logischer Operationen in gespeicherten Prozeduren überbeansprucht wird, erhöht sich auch die CPU-Auslastung, da das ursprüngliche Design der MySQL-Datenbank eher auf effiziente Abfragen als auf logische Operationen ausgerichtet war.

1. 
   Die Struktur gespeicherter Prozeduren erschwert die Entwicklung gespeicherter Prozeduren mit komplexer Geschäftslogik.

2. Es ist schwierig, gespeicherte Prozeduren zu debuggen. Nur wenige Datenbankverwaltungssysteme ermöglichen das Debuggen gespeicherter Prozeduren. Leider bietet MySQL keine Möglichkeit zum Debuggen gespeicherter Prozeduren.

3. Die Entwicklung und Pflege gespeicherter Prozeduren ist nicht einfach.

   Die Entwicklung und Wartung gespeicherter Prozeduren erfordert häufig spezielle Fähigkeiten, über die nicht alle Anwendungsentwickler verfügen. Dies kann während der Anwendungsentwicklungs- und Wartungsphasen zu Problemen führen.

4. 
   

   Es besteht ein hohes Maß an Abhängigkeit von der Datenbank und eine schlechte Übertragbarkeit.

5. Definition der gespeicherten MySQL-Prozedur

Grundlegendes Anweisungsformat der gespeicherten Prozedur

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 ;

● Die Parameter in der gespeicherten Prozedur sind in, out und inout;

in stellt den Eingabeparameter dar (standardmäßig ist der im Parameter), der angibt, dass der Wert dieses Parameters vom aufrufenden Programm angegeben werden muss.

1. ou stellt den Ausgabeparameter dar, was bedeutet, dass nach der Berechnung des Parameterwerts durch die gespeicherte Prozedur das Berechnungsergebnis des Out-Parameters an das aufrufende Programm zurückgegeben wird.

2. inout stellt einen unmittelbaren Eingabeparameter und einen Ausgabeparameter dar, was bedeutet, dass der Wert des Parameters vom aufrufenden Programm formuliert werden kann und das Berechnungsergebnis des inout-Parameters an das aufrufende Programm zurückgegeben werden kann.

3. ● Anweisungen in gespeicherten Prozeduren müssen zwischen BEGIN und END eingefügt werden.

● DECLARE wird zum Deklarieren von Variablen verwendet. Um den Variablenwert in einem Anweisungsblock zu ändern, verwenden Sie SET variable = value.

Verwendung gespeicherter Prozeduren.

DELIMITER $$

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

DELIMITER ;

Gespeicherte Prozedur aufrufen

CALL demo1();

Definieren Sie eine gespeicherte Prozedur mit Parametern

Definieren Sie zunächst eine Schülerdatenbanktabelle:

现在要查询这个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”);//获得输出参数

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

Das obige ist der detaillierte Inhalt vonSo rufen Sie eine gespeicherte MySQL-Prozedur auf. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!