A quoi sert le curseur mysql ?

Dans MySQL, les curseurs fonctionnent comme des pointeurs et sont principalement utilisés pour parcourir l'ensemble de résultats d'enregistrement renvoyé en interrogeant la base de données afin d'effectuer les opérations correspondantes. Un curseur est en fait un mécanisme qui extrait un enregistrement à la fois d'un jeu de résultats contenant plusieurs enregistrements de données. Le système de gestion de base de données relationnelle est essentiellement orienté ensemble. Dans MySQL, il n'existe pas de forme d'expression pour décrire un seul enregistrement dans la table, à moins que la clause WHERE ne soit utilisée pour limiter la sélection d'un seul enregistrement. Un curseur doit donc parfois être utilisé ; pour sélectionner un seul enregistrement.

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

Curseur MySQL (Curseur)

Un curseur est en fait un mécanisme qui peut extraire un enregistrement à la fois à partir d'un ensemble de résultats comprenant plusieurs enregistrements de données.

Le curseur agit comme un pointeur.

Bien que le curseur puisse parcourir toutes les lignes du résultat, il ne pointe que vers une ligne à la fois.

La fonction du curseur est de parcourir les enregistrements renvoyés en interrogeant la base de données afin d'effectuer les opérations correspondantes.

Le système de gestion de base de données relationnelle est essentiellement orienté ensemble. Dans MySQL, il n'existe pas de forme d'expression pour décrire un seul enregistrement dans la table, à moins qu'une clause WHERE ne soit utilisée pour limiter la sélection d'un seul enregistrement. Nous devons donc parfois utiliser des curseurs pour traiter les données d'un seul enregistrement.

Généralement, le curseur est utilisé pour localiser une certaine ligne de l'ensemble de résultats afin de modifier les données.

Utilisation du curseur

1. Déclarez un curseur : déclarez le nom du curseur CURSOR pour la table ; (la table ici peut être n'importe quelle collection que vous interrogez)declare 游标名称 CURSOR for table;(这里的table可以是你查询出来的任意集合)

2、打开定义的游标：open 游标名称;

3、获得下一行数据：FETCH  游标名称 into testrangeid,versionid;

4、需要执行的语句(增删改查)：这里视具体情况而定

5、释放游标：CLOSE 游标名称;

2. : ouvrir le nom du curseur ;

3. Obtenez la ligne de données suivante : FETCH le nom du curseur dans testrangeid,versionid;

4. , supprimer, modifier, vérifier) ​​) : Cela dépend de la situation spécifique5. Relâchez le curseur : CLOSE nom du curseur ;

Remarque : Chaque phrase de la procédure stockée mysql doit être terminée par ; , et les champs temporaires utilisés doivent être utilisés avant que le curseur ne soit défini. Faites une déclaration.

Exemple

-  BEGIN  
  --定义变量  declare testrangeid BIGINT;  
declare versionid BIGINT;   
declare done int;  
--创建游标，并存储数据  declare cur_test CURSOR for   
   select id as testrangeid,version_id as versionid from tp_testrange;  
--游标中的内容执行完后将done设置为1  
 DECLARE CONTINUE HANDLER FOR NOT FOUND SET done=1;   
--打开游标  open cur_test;  
--执行循环    posLoop:LOOP  
--判断是否结束循环  
        IF done=1 THEN    
      LEAVE posLoop;  
    END IF;   
--取游标中的值  
    FETCH  cur_test into testrangeid,versionid;  
--执行更新操作  
    update tp_data_execute set version_id=versionid where testrange_id = testrangeid;  
  END LOOP posLoop;  
--释放游标  CLOSE cur_test;  
  
END  -

Exemple 2 :

Nous allons maintenant utiliser une procédure stockée pour créer une fonction permettant de compter l'inventaire total des iPhones et d'afficher le total sur la console.

--在windows系统中写存储过程时，如果需要使用declare声明变量，需要添加这个关键字，否则会报错。  delimiter //  drop procedure if exists StatisticStore;  
CREATE PROCEDURE StatisticStore()  
BEGIN  
    --创建接收游标数据的变量  
    declare c int;  
    declare n varchar(20);  
    --创建总数变量  
    declare total int default 0;  
    --创建结束标志变量  
    declare done int default false;  
    --创建游标  
    declare cur cursor for select name,count from store where name = 'iphone';  
    --指定游标循环结束时的返回值  
    declare continue HANDLER for not found set done = true;  
    --设置初始值  
    set total = 0;  
    --打开游标  
    open cur;  
    --开始循环游标里的数据      read_loop:loop  
    --根据游标当前指向的一条数据  
    fetch cur into n,c;  
    --判断游标的循环是否结束  
    if done then  
        leave read_loop;    --跳出游标循环  
    end if;  
    --获取一条数据时，将count值进行累加操作，这里可以做任意你想做的操作，  
    set total = total + c;  
    --结束游标循环  
    end loop;  
    --关闭游标  
    close cur;  
  
    --输出结果  
    select total;  
END;  
--调用存储过程  call StatisticStore();

fetch consiste à obtenir la ligne de données actuellement pointée par le curseur et à pointer le pointeur vers la ligne suivante. Poursuivre l'exécution lorsque le curseur pointe déjà vers la dernière ligne entraînera un débordement du curseur.

Lors de l'utilisation d'un curseur de boucle, il ne surveillera pas s'il a atteint la dernière donnée. L'écriture du code comme celui-ci provoquera une boucle infinie

read_loop:loop  
fetch cur into n,c;  
set total = total+c;  
end loop;

Dans MySql, lorsque le curseur déborde, il déclenchera le prédéfini mysql ; Erreur NOT FOUND, donc le code suivant est utilisé ci-dessus pour spécifier un événement continue lorsqu'une erreur introuvable est générée et pour modifier la valeur de la variable done lorsque cet événement se produit.

declare continue HANDLER for not found set done = true;

Le code suivant est donc ajouté à la boucle :

--判断游标的循环是否结束  if done then  
    leave read_loop;    --跳出游标循环  end if;

Si la valeur de done est vraie, terminez la boucle. Continuez à exécuter le code ci-dessous

Utilisation

Il existe trois façons d'utiliser les curseurs :

La première est l'implémentation ci-dessus, en utilisant la boucle en boucle ;

La deuxième façon est la suivante, en utilisant la boucle while :

drop procedure if exists StatisticStore1;  
CREATE PROCEDURE StatisticStore1()  
BEGIN  
    declare c int;  
    declare n varchar(20);  
    declare total int default 0;  
    declare done int default false;  
    declare cur cursor for select name,count from store where name = 'iphone';  
    declare continue HANDLER for not found set done = true;  
    set total = 0;  
    open cur;  
    fetch cur into n,c;  
    while(not done) do  
        set total = total + c;  
        fetch cur into n,c;  
    end while;  
      
    close cur;  
    select total;  
END;  
  
call StatisticStore1();

La troisième méthode consiste à utiliser l'exécution répétée :

drop procedure if exists StatisticStore2;  
CREATE PROCEDURE StatisticStore2()  
BEGIN  
    declare c int;  
    declare n varchar(20);  
    declare total int default 0;  
    declare done int default false;  
    declare cur cursor for select name,count from store where name = 'iphone';  
    declare continue HANDLER for not found set done = true;  
    set total = 0;  
    open cur;  
    repeat  
    fetch cur into n,c;  
    if not done then  
        set total = total + c;  
    end if;  
    until done end repeat;  
    close cur;  
    select total;  
END;  
  
call StatisticStore2();

Imbrication du curseur

Dans MySQL, chaque bloc de début et de fin est une zone de portée indépendante, car le même événement d'erreur dans MySql ne peut être défini qu'une seule fois, s'il y a plusieurs définitions, il affichera le gestionnaire de duplication déclaré dans le même bloc lors de la compilation.

drop procedure if exists StatisticStore3;  
CREATE PROCEDURE StatisticStore3()  
BEGIN  
    declare _n varchar(20);  
    declare done int default false;  
    declare cur cursor for select name from store group by name;  
    declare continue HANDLER for not found set done = true;  
    open cur;  
    read_loop:loop  
    fetch cur into _n;  
    if done then  
        leave read_loop;  
    end if;  
    begin  
        declare c int;  
        declare n varchar(20);  
        declare total int default 0;  
        declare done int default false;  
        declare cur cursor for select name,count from store where name = 'iphone';  
        declare continue HANDLER for not found set done = true;  
        set total = 0;  
        open cur;  
        iphone_loop:loop  
        fetch cur into n,c;  
        if done then  
            leave iphone_loop;  
        end if;  
        set total = total + c;  
        end loop;  
        close cur;  
        select _n,n,total;  
    end;  
    begin  
            declare c int;  
            declare n varchar(20);  
            declare total int default 0;  
            declare done int default false;  
            declare cur cursor for select name,count from store where name = 'android';  
            declare continue HANDLER for not found set done = true;  
            set total = 0;  
            open cur;  
            android_loop:loop  
            fetch cur into n,c;  
            if done then  
                leave android_loop;  
            end if;  
            set total = total + c;  
            end loop;  
            close cur;  
        select _n,n,total;  
    end;  
    begin  
      
    end;  
    end loop;  
    close cur;  
END;  
  
call StatisticStore3();

Ce qui précède consiste à implémenter une boucle imbriquée. Bien sûr, cet exemple est tiré par les cheveux. Jetez simplement un oeil.

Dynamic SQL

🎜🎜Mysql prend en charge la fonction de SQL dynamique🎜

set @sqlStr='select * from table where condition1 = ?';  
prepare s1 for @sqlStr;  
--如果有多个参数用逗号分隔  execute s1 using @condition1;  
--手工释放，或者是 connection 关闭时， server 自动回收  deallocate prepare s1;

🎜[Recommandations associées : 🎜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!