Procédures stockées

Commencer
Définition de la procédure stockée
Une procédure stockée est un segment de code SQL déclaratif, qui est stocké dans le
catalogue de base de données. Une procédure stockée peut être invoquée par un programme, un déclencheur ou même
une autre procédure stockée.

Une procédure stockée qui s'appelle elle-même est une procédure stockée récursive. Presque tous les RDBMS
supporte les procédures stockées récursives mais MySQL ne les supporte pas bien. Vous devriez
vérifiez votre version de la base de données MySQL avant de mettre en œuvre des procédures stockées récursives

procédures.

Procédure stockée dans MySQL

MySQL est connu comme le SGBDR open source le plus populaire, largement utilisé par
à la fois communautaire et entreprise. Cependant, pendant la première décennie de son existence, il
n'a pas supporté les procédures stockées, les déclencheurs, les événements…etc. Depuis la version 5.0 de MySQL, ceux-ci
des fonctionnalités ont été ajoutées au moteur de base de données MySQL pour permettre à MySQL d'être plus

flexible et puissant.

Avant de commencer la série de tutoriels sur les procédures stockées, il est nécessaire que vous ayez
Version MySQL 5.x+ installée sur votre ordinateur ou serveur.

Avantages des procédures stockées

Les procédures stockées augmentent les performances de l'application. Une fois créées, les procédures stockées
la procédure est compilée et stockée dans le catalogue de la base de données. Elle s'exécute plus rapidement que

des commandes SQL non compilées qui sont envoyées depuis l'application.
La procédure stockée réduit le trafic entre l'application et le serveur de base de données
car au lieu d'envoyer plusieurs commandes SQL longues non compilées
déclarations, l'application doit seulement envoyer le nom de la procédure stockée et
récupérer les données.
La procédure stockée est réutilisable et transparente pour toute application qui le souhaite.
pour l'utiliser. La procédure stockée expose l'interface de la base de données à toutes les applications
ainsi, les développeurs n'ont pas à programmer les fonctions qui sont déjà
pris en charge dans les procédures stockées dans toutes les applications externes.
La procédure stockée est sécurisée. L'administrateur de base de données peut accorder l'accès.
droit à la demande qui souhaite accéder aux procédures stockées dans la base de données
catalogue sans accorder aucune permission sur les tables de base de données sous-jacentes.

1
En plus de ces avantages, la procédure stockée a encore ses propres inconvénients qui sont
énuméré ci-dessous :

Inconvénients des procédures stockées

Les procédures stockées mettent le serveur de base de données sous une forte charge tant en mémoire qu'en

processeurs. Au lieu d'être concentré sur le stockage et la récupération des données, vous
pourrait demander au serveur de base de données d'effectuer un certain nombre d'opérations logiques

des opérations ou un ensemble de logique commerciale qui n'est pas bien conçu dans
serveur de base de données.

La procédure stockée ne contient que du SQL déclaratif, il est donc très difficile d'écrire un.
procédure avec complexité de la logique d'affaires comme d'autres langages dans
couche application telle que Java, C#, C++…
La procédure stockée est difficile à déboguer. Vous ne pouvez pas déboguer la procédure stockée dans
presque tous les RDBMS et aussi dans MySQL. Il existe des solutions de contournement à ce sujet.

problème mais ce n'est toujours pas assez facile à faire.

Les procédures stockées ne sont pas faciles à écrire et à maintenir. Écrire et maintenir
La procédure stockée nécessite généralement un ensemble de compétences spécialisées que tous les développeurs n'ont pas.

posséder. Cela peut introduire des problèmes tant dans le développement d'applications que dans
phase de maintien.

La procédure stockée a ses propres avantages et inconvénients. Par conséquent, lorsque

dans le développement d'une application, vous devez trouver un équilibre entre eux pour choisir s'il faut utiliser

procédure stockée ou non. Dans les tutoriels suivants, nous vous guiderons sur la façon de tirer parti de
procédure stockée dans vos tâches de programmation de base de données avec quelques exemples pratiques
exemples.

2
Commencer avec les procédures stockées MySQL

Procédures
Écriture de la première procédure stockée

La première procédure stockée est très simple. Elle récupère tous les produits de la table des produits.
Tout d'abord, examinons le code source de la procédure stockée ci-dessous :

1 DÉLIMITER //
2 CRÉER UNE PROCÉDURE GetAllProducts()
3 DÉBUT
4 SELECT * FROM produits;
5 FIN
6 DÉLIMITER ;

Examinons la procédure stockée ci-dessus en détail :

La première commande que vous voyez est DELIMITER //. Cette commande n'est pas liée à
La déclaration DELIMITER dans MySQL est utilisée pour changer le
délimiteur standard (point-virgule) à un autre. Dans ce cas, le délimiteur est
passé de point-virgule (;) à //, donc vous pouvez avoir plusieurs instructions SQL
à l'intérieur de la procédure stockée qui peut être séparée par le point-virgule. Après le
Le mot clé END utilise le délimiteur // pour indiquer la fin de la procédure stockée.
La dernière commande change le délimiteur pour revenir à celui par défaut.
(point-virgule).
Pour créer une nouvelle procédure stockée, vous utilisez CREATE PROCEDURE
déclaration. Après l'instruction CREATE PROCEDURE, vous pouvez spécifier le nom
de la procédure stockée. Dans ce cas, le nom de la procédure stockée est
ObtenirTousLesProduits
Tout ce qui se trouve entre un mot-clé BETWEEN et END est appelé stock
corps de la procédure. Vous pouvez écrire du code SQL déclaratif dans le stocké
corps de la procédure.

Maintenant, nous avons créé une nouvelle procédure stockée. Il est temps de savoir comment l'invoquer.
ligne de commande de MySQL.

3
Appel de la procédure stockée
Pour invoquer une procédure stockée, nous utilisons la commande SQL suivante :

1 APPELER LA_PROCÉDURE_STOCKÉE_NOM()

Tout d'abord, vous utilisez le mot-clé APPEL suivi du nom de la procédure stockée et d'une paire de
parenthèse. Pour invoquer la procédure stockée GetAllProducts, nous utilisons les éléments suivants
commande:

1 APPELER GetAllProducts();

Si vous exécutez la commande ci-dessus, vous obtiendrez tous les produits dans la base de données des produits.

table.

Dans ce tutoriel, vous avez appris comment changer le délimiteur en utilisant DELIMITER
déclaration. Il vous permet de taper plusieurs instructions SQL à l'intérieur d'une procédure stockée.
Vous avez également appris à écrire une procédure stockée simple en utilisant CREATE
Déclarez une procédure et invoquez-la depuis la ligne de commande en utilisant l'instruction CALL.

4
Variables dans les procédures stockées

Déclaration de variables

Les variables sont utilisées dans les procédures stockées pour stocker le résultat immédiat. Vous pouvez déclarer
une variable selon la syntaxe suivante :

1 DÉCLARER variable_nom type_de_donnée(taille) PAR DÉFAUT valeur_par_défaut;

Le nom de la variable suivant la déclaration DECLARE est le nom de la variable. Le nom de la variable doit suivre

la convention de nommage et ne doit pas être le même nom de table ou de colonne dans un
base de données. Ensuite, vous pouvez spécifier le type de données de la variable, cela peut être n'importe quel type primitif

type que MySQL prend en charge tel que INT, VARCHAR et DATETIME… ainsi qu'avec le
le type de données est la taille de la variable. Lorsque vous déclarez une variable, sa valeur initiale est
NULL. Vous pouvez également attribuer la valeur par défaut à la variable en utilisant DEFAULT
déclaration. Par exemple, nous pouvons définir une variable nommée total_sale avec le type de données
INT et la valeur par défaut est 0 comme suit :

1 DÉCLARER total_sale INT PAR DÉFAUT 0

Pour déclarer deux variables ou plus du même type de données, nous pouvons en utiliser une seule.
DÉCLARER tel que :

1 DECLARE x, y INT PAR DÉFAUT 0

Nous avons déclaré deux variables x et y du même type de données INT et leur valeur par défaut
la valeur est zéro.

Affectation de variables
Une fois que vous avez déclaré une variable, vous pouvez commencer à l'utiliser. Pour attribuer une autre valeur à un
variable que vous pouvez utiliser dans l'instruction SET, par exemple :

1 DÉCLARER total_count INT PAR DÉFAUT 0

2 SET total_count = 10 ;

La valeur de la variable total_count est maintenant dix (10).

5
À côté de l'instruction SET, nous pouvons utiliser SELECT ... INTO pour attribuer le résultat d'une requête à un

variable.

1 DÉCLARER total_products INT PAR DÉFAUT 0

2 SÉLECTIONNER COUNT(*) DANS total_products

3 DE produits

Dans l'exemple ci-dessus, nous déclarons une variable total_products et initialisons sa valeur à
Zéro. Ensuite, nous utilisons l'instruction SELECT ... INTO pour assigner la variable total_products
avec le total des produits dans la table des produits de la base de données.

Portée des variables

Une variable a son propre scope. Si vous déclarez une variable à l'intérieur d'une procédure stockée, elle
sera hors de portée lorsque la FIN de la procédure stockée sera atteinte. Si vous avez défini un
la variable à l'intérieur du bloc BEGIN/END dans une procédure stockée sera hors de portée si
la FIN atteinte. Vous pouvez déclarer deux variables ou plusieurs variables avec le même
nom dans différents portées ; la variable n'est efficace que dans sa portée.

Une variable avec un ‘@’ au début est une variable de session. Elle existe jusqu'à la session.
fin.

6
Paramètres de procédure stockée MySQL

La plupart des procédures stockées que vous développez nécessitent des paramètres. Les paramètres rendent le

procédure stockée plus flexible et utile. Dans MySQL, un paramètre a l'un des trois
modes IN, OUT et INOUT.

. DANS ceci est le mode par défaut. DANS indique qu'un paramètre peut être passé dans
procédures stockées mais toute modification à l'intérieur de la procédure stockée ne
changer le paramètre. Supposons que vous passiez parameterId, qui est égal à 10, dans
procédure stockée GetAll(Id), après l'exécution de la procédure stockée la valeur de
L'ID est toujours 10 même si la procédure stockée GetAll peut changer la valeur de
il.
. OUT ce mode indique que la procédure stockée peut modifier ce paramètre
et renvoyer au programme appelant.
. INOUT est évidemment ce mode combiné de mode IN et OUT ; vous pouvez passer
paramètre dans une procédure stockée et le récupérer avec la nouvelle valeur de
programme d'appel.

La syntaxe de définition d'un paramètre dans une procédure stockée est la suivante :

MODE nom_paramètre type_paramètre(taille_paramètre)

Le MODE peut être IN, OUT ou INOUT selon le but du paramètre.

spécifié.
param_name est le nom du paramètre. Le nom ne doit pas être identique à le
nom de la colonne des tables et suivi de la convention de nommage. Suivi du paramètre
le nom est le type de paramètre et sa taille.

Chaque paramètre est séparé par une virgule si la procédure stockée en a plusieurs
paramètre.

Pratiquons avec les exemples suivants pour mieux comprendre.

Le premier exemple est une procédure stockée pour obtenir tous les bureaux dans un pays. Voici le SQL
code source :

1 DÉLIMITER //
2 CRÉER UNE PROCÉDURE GetOfficeByCountry(IN countryName VARCHAR(255))
3 DÉBUT
4 ville
5 DE bureaux
6 OÙ pays = nomDuPays;

7
7 FIN //
8 DELIMITEUR ;

Comme vous pouvez le voir, nous utilisons countryName comme paramètre IN avec son type est varchar et
sa taille est de 255. Dans la partie corps de la procédure stockée, nous récupérons tous les bureaux dont sa
pays est le nomDuPays
Supposons que vous souhaitiez récupérer tous les bureaux aux États-Unis, il vous suffit de passer la valeur au stocké
des procédures comme celle-ci :

1 APPELER GetOfficeByCountry('USA')

Il retourne tous les bureaux aux États-Unis

Pour obtenir tous les bureaux en France, il suffit de passer la France à la procédure stockée comme suit :

1APPEL ObtenirBureauParPays('France')

Il renvoie tous les bureaux en France.

Dans le deuxième exemple, nous allons écrire une procédure stockée pour compter les commandes dans un spécifié
order status such as shipped, resolved, cancelled, on hold, disputed or in process.
Voici la procédure stockée

01 DÉLIMITER $$
02 CRÉER PROCÉDURE CompterCommandeParStatut(
03 DANS orderStatus VARCHAR(25),
04 SORTIE total INT)
05 DÉBUT
06 SELECT count(orderNumber)
07 DANS total
08 DE commandes
09 OÙ statut = orderStatus;
10 FIN$$
11 DÉLIMITATEUR ;

La procédure stockée CountOrderByStatus a deux paramètres :

. Le paramètre orderStatus est un paramètre IN ; nous passons le statut de la commande tel que expédié.
ou en attente pour obtenir son numéro
. le paramètre total est le paramètre OUT que nous utilisons pour obtenir le total de la commande par un
statut spécifié retourné.

Pour obtenir le nombre de commandes expédiées, nous exécutons simplement les déclarations suivantes

1 APPELER CountOrderByStatus('Expédié',@total);

8
Pour obtenir le nombre en cours, nous faisons la même chose que ci-dessus.

1 APPELER CountOrderByStatus('en cours',@total);

2 SELECT @total AS total_en_cours;

Dans la troisième procédure, nous allons démontrer le paramètre INOUT. Le stocké

la procédure met en majuscule tous les mots d'une chaîne et la renvoie au programme appelant.
Le code source de la procédure stockée est le suivant :

01 DELIMITATEUR $$
02 CRÉER PROCÉDURE `MettreEnMajuscule`(ENOUT str VARCHAR(1024))
03 COMMENCER
04 DÉCLARE i INT PAR DÉFAUT 1;
05 DÉCLARE myc, pc CHAR(1);
06 DÉCLARER outstr VARCHAR(1000) DEFAULT str;
TANT QUE i <= LONGUEUR_DE_CHAINE(str)
07
FAITES
08 SET myc = SOUS CHAÎNE(str, i, 1);
SET pc = CASE WHEN i = 1 THEN '
09
'
10 SINON SOUS CHAÎNE(str, i - 1, 1)
11 FIN;
12 SI pc DANS (' ', '&', '''', '_', '?', ';', ':', '!', ',', '-', '/', '(', '.') ALORS
13 SET outstr = INSÉRER(outstr, i, 1, MAJUSCULE(myc));
14 FIN SI;
15 METTRE i = i + 1;
16 FIN TANT QUE;
17 SET str = outstr;
18 FIN$$
19 DELIMITER ;

Voici l'utilisation de la procédure stockée Capitalize

1 DEFINIR @str = 'tutoriel de procédure stockée mysql';

2 APPELER Capitaliser(@str);
3 SÉLECTIONNER @str;

Et la valeur @str est 'Tutoriel de procédure stockée Mysql'

9
Contrôle Conditionnel dans MySQL Stocké
Procédure

Le contrôle conditionnel vous permet d'exécuter le code en fonction de la valeur d'un

expression ou une combinaison d'expressions utilisant des opérateurs logiques. MySQL prend en charge
deux instructions de contrôle conditionnel telles que IF et CASE.

L'instruction SI
La syntaxe de l'instruction IF est simple comme suit :

1 SI expression ALORS commandes

2 [SINON SI expression ALORS commandes]
3 [commandes ELSE]
4 FIN SI;

Les commandes associées à IF ou ELSEIF ou ELSE ne s'exécutent que lorsque le

l'expression est évaluée comme VRAI. Un des pièges courants de l'instruction IF est NULL
valeur; Lorsque l'expression est évaluée comme NULL, elle n'est ni VRAIE ni FAUSSE. Ici
il existe plusieurs combinaisons d'instructions IF

1 SI expression ALORS commandes

2 FIN SI;
1 SI expression ALORS commandes
2 commandes ELSE
3 FIN SI;
1 SI expression ALORS commandes
2 SINON SI expression ALORS commandes
3 commandes ELSE
4 FIN SI;

Vous pouvez avoir des instructions IF imbriquées avec d'autres instructions IF.

10
L'instruction CASE
Lorsque plusieurs conditions sont utilisées avec l'instruction IF, le code n'est pas facile à lire. À
Cette fois, le CASE peut être utilisé pour rendre le code plus clair. La syntaxe du CASE
la déclaration est comme suit :

1 AFFAIRE
2 QUAND expression ALORS commandes
3...
4 QUAND expression ALORS commandes
5 commandes ELSE
6 FIN DU CAS;

11
Boucle dans les procédures stockées

Le langage de programmation stocké MySQL prend en charge les boucles, ce qui vous permet de traiter
les commandes de manière itérative. Les boucles standard sont discutées comme suit

Boucle WHILE
La syntaxe de la boucle while est la suivante :

1 TANT QUE expression FAIRE

2 déclarations
3 FIN TANT QUE

Tout d'abord, la boucle while vérifie l'expression, si elle est vraie, elle exécutera l'instruction jusqu'à ce que
l'expression devient fausse. Parce que la boucle while vérifie l'expression avant
les instructions exécutées, c'est souvent connu comme une boucle pré-test. Voici un exemple d'utilisation de
boucle while dans la procédure stockée :

01 DELIMITER $$
02 SUPPRIMER LA PROCÉDURE SI ELLE EXISTE WhileLoopProc$$

03 CRÉER PROCÉDURE WhileLoopProc()

04 COMMENCER
05 DÉCLARER x INT;
06 DÉCLARER str VARCHAR(255);
07 METTRE x = 1;
08 SET str = '';
09 TANT QUE x <= 5 FAIRE

10 SET str = CONCAT(str,x,',');

11 DEFINIR x = x + 1;
12 FIN TANT QUE;
13 SÉLECTIONNER str;

14 FIN$$
15 DÉLIMITER ;

Dans les procédures stockées ci-dessus, nous construisons la chaîne de manière répétée jusqu'à ce que la variable x soit supérieure.

que 5 et ensuite nous affichons la chaîne construite dans l'écran de la console en utilisant SELECT
déclaration. L'une des pièges communs que presque tous les développeurs rencontrent est si la variable x est
pas initialisé, sa valeur par défaut est NULL donc la condition dans la boucle while est toujours vraie;
le bloc de code à l'intérieur de la boucle while est exécuté indéfiniment jusqu'à ce que votre serveur de base de données

écrasé.

12
boucle REPEAT
La syntaxe de la boucle repeat est la suivante :

1 RÉPÉTER
2 déclarations;
3 JUSQU'À expression
4 FIN DE RÉPÉTER

D'abord, les instructions sont exécutées, puis l'expression est évaluée. Si le

l'expression est évaluée comme vraie, les instructions sont exécutées à plusieurs reprises jusqu'à ce que cela
la valeur devient fausse. Parce que la boucle de répétition vérifie l'expression après le
l'exécution des déclarations, c'est donc aussi connu sous le nom de boucle post-test. Nous pouvons réécrire le
procédure stockée ci-dessus en utilisant une boucle répétée comme suit :

01 DÉLIMITEUR $$
02 SUPPRIMER LA PROCÉDURE SI ELLE EXISTE RepeatLoopProc$$

03 CRÉER UNE PROCÉDURE RepeatLoopProc()

04 DEBUT
05 DÉCLARER x INT;
06 DÉCLARER str VARCHAR(255);
07 SET x = 1;
08 SET str = '';
09 RÉPÉTER
10 SET str = CONCAT(str,x,',');
11 METTRE x = x + 1;
12 JUSQU'À x > 5
13 FIN DE LA RÉPÉTITION;

14 Sélectionnez str;

15 FIN$$
16 DÉLIMITANT ;

Veuillez noter qu'il n'y a pas de délimiteur (;) après l'expression UNTIL.

BOUCLE boucle, QUITTER et ITÉRER

L'instruction leave vous permet de quitter la boucle. C'est un peu comme break dans d'autres langages.
tel comme Java C#...
L'instruction itérer vous permet de recommencer la boucle. C'est comme continue en Java ou C#.
MySQL prend également en charge une boucle LOOP qui vous permet d'exécuter des instructions
répétitif et plus flexible. Voici un exemple d'utilisation de la boucle LOOP.

13
01 DÉLIMITEUR $$
02 SUPPRIMER LA PROCÉDURE SI EXISTE LOOPLoopProc$$

03 CRÉER PROCÉDURE LOOPLoopProc()

04 DÉBUT
05 DÉCLARER x ENTIER;
06 DÉCLARER str VARCHAR(255);
07 SET x = 1;
08 DEFINIR str = '';

09 BOUCLE
10 SI x > 10 ALORS
11 QUITTER loop_label;
12 FIN SI;
13 SET x = x + 1;
14 SI (x mod 2) ALORS
15 ITÉRER boucle_label;
16 SINON
17 SET str = CONCAT(str,x,',');
18 FIN SI;
19
FIN
20
BOUCLE;
21 SÉLECTIONNER str;

22 FIN$$
23 DELIMITEUR ;

La procédure stockée ne construit que des chaînes avec des nombres pairs. D'abord, nous définissons un
étiquette de boucle, si une variable x est supérieure à 10, la boucle se termine à cause de leave
Déclaration. Sinon, si la variable x est impaire, l'ITÉRER ignore tout en dessous.
et continue, si la variable x est paire, le bloc après ELSE construit des chaînes avec
nombres pairs.

14
Curseur SQL dans les procédures stockées
MySQL prend en charge les curseurs dans les procédures stockées, les fonctions et les déclencheurs. Le curseur est utilisé

itérer à travers un ensemble de lignes, qui sont renvoyées par une requête, et traiter individuellement
ligne. Actuellement, avec toutes les versions supérieures à 5.x, le curseur MySQL a les propriétés suivantes :

Lecture seule : cela signifie que vous ne pouvez pas mettre à jour le curseur.
Non défilable : il ne peut se déplacer que dans une seule direction et ne peut pas sauter, bouger
en arrière ou en avant dans l'ensemble de résultats.

Asensitive : vous devriez éviter de mettre à jour la table tout en ayant un curseur ouvert sur cette table.
sinon vous risquez d'obtenir des résultats inattendus.

MySQL prend en charge les déclarations suivantes pour travailler avec le curseur.

Tout d'abord, vous devez déclarer un curseur en utilisant l'instruction DECLARE :

1 DÉCLARE cursor_name CURSOR POUR SELECT_statement;

Deuxièmement, vous devez ouvrir le curseur en utilisant l'instruction OPEN. Vous devez ouvrir le curseur.
avant de récupérer des lignes à partir de celui-ci.

1 OUVRIR cursor_name;

Ensuite, vous pouvez récupérer la ligne suivante du curseur et déplacer le curseur vers la ligne suivante.
dans un ensemble de résultats en utilisant l'instruction FETCH.

1 RÉCUPÉRER le nom_du_curseur DANS la liste_des_variables;

Et enfin, vous devez fermer le curseur pour le désactiver et libérer la mémoire.

associé à ce curseur. Pour fermer le curseur, vous utilisez l'instruction CLOSE :

1 FERMER cursor_name;

L'un des points les plus importants lors de l'utilisation d'un curseur est que vous devez utiliser un NOT
Un gestionnaire trouvé pour éviter de soulever une condition fatale "aucune donnée à récupérer".
Nous utilisons un exemple de procédure stockée ci-dessous pour démontrer le curseur.

01 DÉLIMITATEUR $$
02 SUPPRIMER LA PROCÉDURE SI ELLE EXISTE CursorProc$$

03 CRÉER PROCÉDURE CursorProc()

04 DÉBUT
05 DÉCLARER no_more_products, quantity_in_stock INT PAR DÉFAUT 0;
06 DÉCLARE prd_code VARCHAR(255);

15
07 DÉCLARER cur_product CURSEUR POUR
08 SÉLECTIONNER codeProduit DE produits;
09 DÉCLARER UN GESTIONNAIRE CONTINU POUR NON TROUVÉ

10 SET no_more_products = 1;
11
12 /* pour journaliser des informations */
13 CRÉER UNE TABLE infologs (
14 Id int(11) NON NULL AUTO_INCREMENT,
15 Msg varchar(255) NON NULL,
16 CLÉ PRIMAIRE (Id)
17 );
18 OUVRIR cur_product;
19
20 Récupérer cur_product DANS prd_code;
21 RÉPÉTER
22 SELECT quantityInStock INTO quantity_in_stock
23 DE produits
24 OÙ productCode = prd_code;
25
26 SI quantité_en_stock < 100 ALORS
27 INSÉRER DANS infologs(msg)
28 VALEURS (prd_code);
29 FIN SI;
30 RÉCUPÉRER cur_product DANS prd_code;
31 JUSQU'À ce qu'il n'y ait plus de produits = 1

32 FIN DE RÉPÉTER;

33 FERMER cur_product;
34 SÉLECTIONNEZ * À PARTIR DE infologs;

35 SUPPRIMER LA TABLE infologs;

36 FIN$$
37 DÉLIMITER;

La procédure stockée est très simple et peut archiver le même résultat par une requête SQL.
Nous l'utilisons uniquement pour démontrer comment fonctionnent les curseurs.

Nous utilisons un curseur pour les tables de produits et parcourons le jeu de résultats des produits. Si le
la quantité en stock d'un produit est inférieure à 100, nous l'enregistrons dans une table temporaire et
Après la boucle, nous sélectionnons tous les produits pour les afficher à l'écran.

16
N'oubliez pas que vous devez d'abord déclarer le curseur puis déclarer un gestionnaire NOT FOUND;
sinon vous obtiendrez une erreur.

17