MySQL utilise des curseurs

Préface: MySQL5 ou version ultérieure prend en charge la fonction curseur

Pourquoi utiliser des curseurs: les opérations de recherche MySQL renvoient généralement un jeu de résultats, à l'aide d'une simple instruction SELECT, mais il n'y a aucun moyen d'obtenir la première ligne, la ligne suivante ou une ligne à la fois. Parfois, il est nécessaire d'avancer ou de reculer d'une ou plusieurs lignes parmi les lignes récupérées.

Introduction du curseur: Un curseur est une requête de base de données stockée sur le serveur MySQL. Ce n'est pas une instruction SELECT. Après avoir stocké le curseur, l'application peut faire défiler ou parcourir les données selon les besoins. Les curseurs ne peuvent être utilisés que dans des procédures stockées

Étapes d'utilisation des curseurs:

1. Avant d'utiliser un curseur, il doit être déclaré. Ce processus ne récupère pas les données, il définit simplement l'instruction SELECT à utiliser
2. Une fois déclaré, le curseur doit être ouvert pour utilisation. Ce processus récupère les données à l'aide de l'instruction SELECT précédemment définie
3. Pour les curseurs remplis de données, supprimez les lignes au besoin
4. À la fin du curseur, le curseur doit être fermé

 

Créez d'abord un curseur

   Le curseur est créé avec une instruction DECLARE et l'instruction SELECT correspondante est définie.

   Par exemple, l'instruction suivante définit un curseur nommé ordernumbers et définit l'instruction SELECT correspondante. Vous devez ensuite utiliser l'instruction OPEN pour ouvrir le curseur avant de pouvoir l'utiliser. Une fois le curseur utilisé, vous devez utiliser CLOSE pour fermer le curseur et libérer toutes les ressources internes et la mémoire utilisées par le curseur. Ainsi, lorsque chaque curseur n'est plus utilisé, il doit être fermé. Bien sûr, lorsqu'il atteint END, le curseur se ferme automatiquement.

CREATE PROCEDURE processorders()
BEGIN
    DECLARE ordernumbers CURSOR
		FOR
		SELECT order_num FROM orders;
		OPEN ordernumbers;
		CLOSE ordernumbers;
END;

 

Deuxièmement, utilisez le curseur

Dans le premier exemple, une seule ligne est extraite du curseur. FETCH est utilisé pour récupérer la colonne order_num de la ligne actuelle (à partir de la première ligne) dans une variable locale nommée o, sans aucun traitement des données récupérées

CREATE PROCEDURE processorders()
BEGIN
   -- 定义一个int类型的局部变量
    DECLARE o int;
		-- 定义游标到SELECT语句
    DECLARE ordernumbers CURSOR
		FOR
		SELECT order_num FROM orders;
		
		-- 打开游标
		OPEN ordernumbers;
		
		FETCH ordernumbers INTO o;
		
		-- 关闭游标
		CLOSE ordernumbers;
END;

 

Dans l'exemple suivant, récupère de manière itérative les données de la première ligne à la dernière ligne. Différent d'un exemple, le FETCH dans cet exemple est dans REPEAT, il est donc exécuté à plusieurs reprises jusqu'à ce que done soit vrai, et done est défini comme faux au début, alors comment le fait peut-il être défini sur true à la fin?

La réponse est cette instruction: DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1; Cette instruction définit un CONTINUE HANDLER, qui est le code qui est exécuté lorsque la condition se produit, et il indique que lorsque SQLSTATE '02000' se produit, SET done = 1, SQLSTATE '02000' est une condition introuvable, cette condition se produit lorsque REPEAT n'a plus de lignes à boucler

CREATE PROCEDURE processorders()
BEGIN
    -- 定义布尔变量，默认为0
    DECLARE done BOOLEAN DEFAULT O;
		
   -- 定义一个int类型的局部变量
    DECLARE o int;
		
		-- 定义游标到SELECT语句
    DECLARE ordernumbers CURSOR
		FOR
		SELECT order_num FROM orders;
		
		DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1;
		
		-- 打开游标
		OPEN ordernumbers;
		
        -- 开始循环，直到done为真
 		REPEAT
		   FETCH ordernumbers INTO o;
		UNTIL done END REPEAT;
		
		-- 关闭游标
		CLOSE ordernumbers;
END;

 

Synthétisons l'exemple ci-dessus pour implémenter une fonction. Cette fois, nous allons effectuer un traitement réel sur les données récupérées.

CREATE PROCEDURE processorders()
BEGIN
    -- 定义布尔变量，默认为0
    DECLARE done BOOLEAN DEFAULT O;
		
   -- 定义两个局部变量
    DECLARE o int;
		DECLARE t DECIMAL(8,2);
		
		-- 定义游标到SELECT语句
    DECLARE ordernumbers CURSOR
		FOR
		SELECT order_num FROM orders;
		
		-- 它指出当SQLSTATE '02000'出现时(也就是REPEAT由于没有更多的行循环时)，SET done = 1,
		DECLARE CONTINUE HANDLER FOR SQLSTATE '02000' SET done = 1;
		
		-- 创建一张表
		CREATE TABLE IF NOT EXISTS ordertotals(order_num INT, total DECIMAL(8,2));
		
		-- 打开游标
		OPEN ordernumbers;
		
		-- 开始循环 直到done为真
		REPEAT
		  -- 将游标第一行内容放入局部变量o中
		   FETCH ordernumbers INTO o;
			 -- 调用名为ordertotal的存储过程
			 CALL ordertotal(o, 1, t);
			 INSERT INTO ordertotals(order_num,total) VALUES(o,t);
		UNTIL done END REPEAT;
		
		-- 关闭游标
		CLOSE ordernumbers;
END;

CREATE DEFINER=`root`@`localhost` PROCEDURE `ordertotal`(
	IN onumber int,
	IN taxable BOOLEAN,
	OUT ototal DECIMAL(8,2)
)
BEGIN
    -- 定义存储过程体的内部变量
		DECLARE total DECIMAL(8,2);
		DECLARE taxrate int DEFAULT 6;
		
		SELECT SUM(item_price * quantity)
		FROM orderitems
		WHERE order_num = onumber
		INTO total;
		
		-- 判断客户订单是否需要增加营业税
		IF taxable THEN
			SELECT total + (total * taxrate/100) INTO total;
		END IF;
		
		-- 将订单总价返回到ototal变量中
		SELECT total INTO ototal;
END

Dans la procédure stockée processorders ci-dessus, une table de total des commandes est créée. Le processus de stockage total des commandes consiste à calculer la commande totale (y compris la taxe professionnelle), puis à l'enregistrer dans la table de total des commandes. Cette procédure stockée doit être appelée avec CALL pour être exécutée.

CALL processorders();

De cette façon, nous utilisons des procédures stockées, des curseurs, un traitement ligne par ligne et des procédures stockées pour appeler une autre procédure stockée afin de compléter un exemple de travail complet.