Sept étapes dynamiques (1 à  4)

For
spécifie un nom d’instruction
(SelectStm), et pas une instruction
Select codée en dur
(hard-coded). C’est cette méthode
qui nous permet de
traiter n’importe quelle instruction
Select.

Etape 2 : Préparer l’instruction
Select du curseur. La figure 5 contient
le code qui produit la table de résultats
du curseur. Dans l’instruction Eval,
je construis l’instruction Select du
curseur à  partir de la chaîne de l’instruction
Select entrée sur l’écran
(contenue dans le champ d’écran
SelectStr) et deux clauses supplémentaires,
For Read Only et Optimize for 8
Rows, qui améliorent les performances.
Aussitôt l’instruction Select
construite, l’instruction SQL Prepare
imbriquée est exécutée. Observez que, dans la figure 5, j’utilise le même nom
d’instruction (SelectStm) que celui
que j’ai utilisé dans l’instruction
Declare Cursor. Ces noms doivent correspondre
afin que cette instruction
Select soit utilisée quand j’ouvrirai le
curseur.

L’instruction SQL Prepare crée un plan d’accès pour l’instruction
Select. Ce plan
contient les informations
d’accès pour exécuter
l’instruction Select,
comme la manière d’accéder
à  la base de données
et par quel chemin
d’accès. (Pour plus d’informations
sur l’instruction
Prepare, voir l’article
« Intégration de SQL dynamique
dans un programme
RPG IV », NEWSMAGAZINE,
mai 2000.)
L’instruction Open produit
la table de résultats
du curseur. Nous verrons
plus loin que l’on peut accéder
à  cette table de résultats,
une ligne à  la fois,
avec une instruction SQL
Fetch.

Etape 3 : Déterminer
le nombre de colonnes
dans l’instruction Select
préparée. On peut utiliser
l’instruction SQL
Describe pour déterminer
le nombre de colonnes
dans une table de
résultats de l’instruction
Select préparée.
L’instruction Describe
stocke cette information
dans une structure de
données quelque peu complexe appelée
SQLDA (SQL Descriptor Area).

La figure 6 montre la structure de
SQLDA. L’en-tête de 16 octets contient
des informations, comme le nombre
de colonnes, concernant la totalité du
SQLDA. Les descriptions de colonnes
de 80 octets incluent des informations
pour chaque colonne dans la table de
résultats de l’instruction Select. L’ordre
de ces descriptions est le même que
celui des colonnes spécifiées dans la
liste des colonnes de l’instruction
Select (c’est-à -dire, immédiatement
après le mot-clé Select). Si l’instruction Select utilise un astérisque (*) pour indiquer
toutes les colonnes dans une
table ou vue de base, les colonnes de la
table de résultats seront classées dans
le même ordre que les colonnes dans
cette table ou vue de base. Dans certains
cas, les descriptions de colonnes
peuvent dépasser 80 octets. Pour plus
d’informations sur de tels cas, voir DB2
UDB for AS/400 SQL Reference.

Comme j’ignore au moment de la
compilation combien de colonnes sont
impliquées dans l’instruction Select
fournie à  l’exécution, j’utilise l’instruction
SQL Describe pour le déterminer.
La figure 7 contient des fragments de
code provenant du programme
Describe qui illustrent comment allouer
et peupler SQLDA. En A, la figure
7 montre les définitions du programme
pour SQLDA. Bien que
SQLDA soit une structure de données
contiguà«, j’ai divisé sa définition RPG
en deux structures de données basées.
La première structure de données
(SqldaHdr) contient l’en-tête SQLDA
de 16 octets. La seconde (SqlVarData)
adresse une description de colonne de
80 octets.

Pour déterminer le nombre de colonnes
dans la table de résultats de
l’instruction Select préparée, mettez le
champ SqldaNumColsRequested à 
zéro dans cette structure de données
puis exécutez l’instruction SQL
Describe. La mise à  zéro de ce champ
ordonne à  Describe de ne remplir que
l’information d’en-tête de SQLDA.

Dans le même esprit, en B, j’alloue
uniquement assez de mémoire pour
contenir l’en-tête de SQLDA. Comme
je spécifie le pointeur de base pour la
structure de données SqldaHdr
(SqldaHdrPtr) dans le champ résultat
du code opération Alloc, RPG établira
ce pointeur de base pour qu’il pointe
vers la mémoire nouvellement allouée.
En C, j’émets l’instruction Describe.
Après sa bonne exécution, le souschamp
SqldaNumColsReceived contiendra le nombre de colonnes de
la table de résultats de l’instruction
Select préparée.

Etape 4 : Extraire le nom, le type
de données et la longueur des informations
pour chaque colonne. Puisque
je connais le nombre de colonnes dans
la table de résultats, je peux allouer la
mémoire pour la totalité de SQLDA. La
mémoire doit être de 16 octets pour
l’en-tête, plus 80 octets (la taille de
chaque description de colonne) multipliés
par le nombre de colonnes.
L’instruction Eval en D calcule cette
taille de mémoire. L’instruction
ReAlloc augmente ensuite logiquement
la taille du SQLDA précédemment
alloué afin qu’il contienne
suffisamment de mémoire pour tout le
SQLDA.

L’instruction Eval en E définit le
sous-champ SqldaNumColsRequested
de la structure de données de l’en-tête
de SQLDA (précédemment mise à 
zéro) égal au nombre de colonnes
dans la table de résultats de l’instruction
Select préparée. De ce fait, la prochaine
instruction SQL Describe placera
les descriptions de toutes les
colonnes dans le SQLDA.

Notons qu’il faut exécuter SQL
Describe deux fois : d’abord pour découvrir
combien de colonnes il y a
dans la table de résultats (étape 3),
puis pour décrire toutes les colonnes
(étape 4).