Une structure de routine SPL standard

A l’intérieur du bloc extérieur
ProcBody, déclarez la variable SqlState
comme indiqué. Pour presque toutes
les instructions qui s’exécutent dans
une routine SPL, le SQL runtime définit
SqlState en un code de cinq caractères
qui indique l’une des quatre issues suivantes :
• Success (SqlState est « 00000 »)
• Warning (SqlState commence par
« 01 »)
• Not Found (SqlState commence par
« 02 »)
• Exception (autres valeurs de SqlState)

Vous devez déclarer SqlState dans
le bloc le plus à  l’extérieur, de manière
à  pouvoir le tester partout dans la routine.
(Le manuel SQL Reference fait référence
à  cette déclaration sous l’appellation
« return code declaration »
mais, pour des raisons pratiques, c’est
simplement une déclaration de variable.)
Ne déclarez aucune autre variable
SqlState à  l’intérieur d’un bloc
imbriqué.
Après avoir déclaré SqlState, déclarez
d’autres variables de travail utilisées
par la routine. Dans la figure 3, je
montre des déclarations pour trois variables
utilisées dans l’exemple de
handler montré plus loin dans la même
figure. Vous pouvez aussi déclarer certaines
variables de travail à  l’intérieur
des blocs imbriqués, mais il vaut mieux
mettre toutes les déclarations concernant
le traitement d’erreurs standard,
dans le bloc extérieur. En effet, les variables
qui y sont déclarées sont visibles
dans toute la routine.
Après les déclarations de variables
de travail, déclarez les mnémoniques
et les noms de conditions pour toutes
les valeurs SqlState qui sont testées ou
définies dans la routine. (Par « mnémonique
», j’entends une variable avec
une valeur constante spécifiée dans la
clause Default. Pour améliorer légèrement
la performance, codez toujours
la clause Not Null pour vos mnémoniques.)
Le fait de déclarer les mnémoniques
et les noms de conditions de
SqlState dans un endroit simplifie la
maintenance et favorise la compréhension
du programme. Un nom de condition
SPL n’est rien d’autre qu’un nom
donné à  une valeur SqlState. Les noms
de conditions sont utilisés dans les instructions
Signal et Resignal, ainsi que
dans les déclarations du handler SPL.
(J’expliquerai plus loin comment utiliser
les conditions). Dans ce même
groupe de déclarations, vous devez
aussi déclarer les éventuels mnémoniques
pour des chaînes de texte de
messages qui correspondent à  des valeurs
SqlState définies par l’utilisateur.
Vous pouvez utiliser ces chaînes de
texte, ainsi qu’un nom de condition,
sur une instruction Signal ou Resignal.
La figure 3 montre des exemples
des trois types de déclarations (mnémonique
SqlState, nom de condition,
et mnémonique texte de message) associées
à  un SqlState « 01U03 » défini
par l’utilisateur. Je recommande
d’adopter un standard de nommage
qui commence les trois types de noms
par « SqlState » suivi d’un terme descriptif
pour la condition associée à 
SqlState (« NoSales », par exemple).
Ajoutez « Condition » au nom de condition
et « Text » au mnémonique du
texte du message. (Vous pouvez bien
sûr adopter d’autres standards en matière
de préfixe et de suffixe, mais l’essentiel
est que la structure des noms
soit homogène.)
En suivant les déclarations dont
nous venons de parler, définissez un
bloc Main qui contiendra les blocs imbriqués
qui mettent en oeuvre le but
principal de la routine. Faites suivre le
bloc Main d’un bloc Wrapup contenant
du code chargé de traiter les erreurs et
de renvoyer un SqlState approprié à 
l’appelant de la procédure stockée,
UDF, ou trigger.
Cette structure globale donne de
nombreuses possibilités pour détecter
et traiter les avertissements et les
erreurs qui se produisent pour des
instructions dans le bloc Main. L’utilisation
de blocs Main et Wrapup séparés
simplifie les actions de post-avertissement
ou post-erreur, comme nous le
verrons quand nous examinerons une
routine SPL modèle dans le second article
de cette série. Mais, avant d’entrer
plus en détail dans la structure de routine
SPL recommandée, il nous faut explorer
plusieurs fonctions SPL importantes.