Sept étapes dynamiques (5 à  7)

les données de lignes extraites sous le
contrôle de SQLDA. De même, le programme
règle SvdNullIndPtr pour
pointer sur une variable d’indicateur
binaire de deux octets qui indique si la
colonne est nulle ou non. Pour définir
ces valeurs de pointeurs, le programme
doit d’abord déterminer la
taille de chaque colonne puis allouer
suffisamment de mémoire pour contenir
les données de toutes les colonnes
et variables d’indicateurs nuls.

La figure 8 montre le code permettant
d’allouer cette mémoire. En A, je
multiplie le nombre de colonnes dans
la table de résultats par deux (parce
que chaque indicateur nul a deux
octets) et j’alloue le nombre d’octets
correspondant pour contenir les indicateurs
nuls. Bien qu’il suffise d’allouer la mémoire pour les colonnes susceptibles
d’être nulles, j’ai préféré, par
souci de simplification, allouer des
indicateurs nuls pour toutes les
colonnes.

La boucle en B calcule la taille totale
des colonnes de la table de résultats.
Le pointeur de base pour la
structure de données SqlVarData
(SqlVarDataPtr) est initialisé pour pointer
juste au-delà  de l’en-tête de SQLDA,
de sorte qu’au premier passage dans
cette boucle, SqlVarDataPtr adresse la
première description de colonne.
Notons que l’instruction Eval finale définit
ce pointeur pour qu’il pointe sur
la description de colonne suivante en
incrémentant le pointeur par la longueur
d’une entrée de colonne
(SizeOfSqlVar). A l’intérieur de la
boucle, j’invoque d’abord la sous-routine
CalcColBytes qui calcule le
nombre d’octets des colonnes auxquelles
la structure de données
SqlVarData fait actuellement référence.
J’expliquerai le fonctionnement de
cette sous-routine plus loin. Une fois la
sous-routine terminée, le programme
met à  jour un total cumulé des
tailles de colonnes dans le champ
ColDataBufLen. Quand cette boucle
For sera terminée, ColDataBufLen
contiendra la taille totale des colonnes
de la table de résultats. En C, j’alloue la
mémoire pour contenir les données
de colonnes.

En D, la sous-routine CalcColBytes
calcule le nombre maximum d’octets
dans la colonne à  l’information de laquelle
la structure de données basée
sur SqlVarData fait actuellement référence.
Le bloc Select/EndSl calcule la
longueur de colonne d’après le type de
données (SvdDataType). Par exemple,
si c’est le type zoné (avec possibilité ou
non de nul), le champ binaire de deux
octets (SvdLen) divise l’information de
longueur entre ses deux octets. Le premier
octet contient une représentation
binaire d’un octet du nombre total de
chiffres, et le second fait de même
pour le nombre de décimales. Dans le
cas de décimales zonées, le nombre de
chiffres est le nombre d’octets dans un
c h a m p . M a t h é m a t i q u e m e n t ,
%Div(SvdLen: 256) produit le résultat
entier de la division de ce champ binaire
de deux octets par 256, en ignorant
le reste. Ce calcul est nécessaire
pour déterminer les contenus binaires
d’un octet du premier octet de ce
champ de deux octets.

La première instruction When
traite le cas du décimal zoné ; la seconde
gère le cas des données packées.
A nouveau, SvdLen définit la longueur
du champ. La différence étant
que, pour des données packées, le
nombre de chiffres n’est pas le nombre
d’octets que le champ utilise. Au lieu
de cela, pour obtenir le nombre d’octets
utilisé pour un champ packé, nous
divisons le nombre de chiffres par
deux (en ignorant le reste) et ajoutons
un au résultat. L’opération %Div(SvdLen: 512) calcule correctement
cette valeur quand la valeur est
stockée dans le premier octet du
champ SvdLen binaire de deux octets.

Dans tous les autres types de données
que ce programme prend en
charge (Date, Time, Character, Integer,
Half-Integer), le champ SvdLen
contient une représentation binaire de
deux octets de la longueur du champ.
C’est pourquoi le bloc Other en D
stocke simplement SvdLen comme la
longueur de la colonne.

La figure 9 présente le code qui
stocke les pointeurs de données et
nuls dans SQLDA. C’est une boucle For
dont l’itération correspond au nombre
de colonnes. Le champ CurrColPtr est
initialisé pour pointer au début du
tampon de données créé en figure 8.
Le pointeur de base pour la structure
d e d o n n é e s S q l V a r D a t a
(SqlVarDataPtr) est initialisé pour pointer
sur la première entrée de description
de colonne de 80 octets.
La première instruction Eval à  l’intérieur
de la boucle For définit
SvdDataPtr dans la première entrée
SqlVarData pour pointer sur le début
de la zone de mémoire de données allouée
en C, figure 8. La seconde instruction
Eval à  l’intérieur de la boucle
définit le pointeur nul pour qu’il
pointe sur le premier octet de la mémoire
allouée en A, figure 8, dans le
but de contenir des indicateurs nuls
SQL.

Le test If suivant la seconde instruction
Eval vérifie si la boucle a atteint
la description de colonne finale.
Dans la négative, nous invoquons la
sous-routine CalcColBytes décrite précédemment
pour obtenir le nombre
d’octets dans la colonne courante.
Nous incrémentons ensuite le
CurrColPtr par le nombre d’octets nécessaire
pour qu’il pointe sur la première
position inutilisée dans la zone
de mémoire pour contenir les données
de colonnes. La seconde instruction
Eval dans le bloc If/endIf incrémente
de la même manière le pointeur
de base pour la structure de données
SqlVarData afin qu’il pointe sur la description
de la prochaine colonne dans
la structure de données SQLDA.
Quand le contrôle reviendra au début
de la boucle For, nous opèrerons sur la
description de colonne suivante et
stockerons un pointeur sur la prochaine
zone disponible dans la mémoire
allouée pour contenir les données
de colonnes.

Etape 6: Atteindre les lignes par l’intermédiaire
du curseur. Nous pouvons
utiliser l’instruction SQL Fetch pour extraire
des lignes de la table de résultats
(figure 10). La clause Into Descriptor de
cette instruction indique que nous extrairons
les données et les placerons dans le
stockage décrit par la structure SQLDA
nommée (c’est-à -dire, SqlDaHdr) plutôt
que directement dans des variables
hôtes. Après l’exécution de cette instruction,
les valeurs de colonnes pour la ligne
suivante dans la table de résultats sont
placées dans les emplacements sur lesquels
les champs SvdDataPtr pointent
dans les descriptions de colonnes
SQLDA correspondantes. De même, les
indicateurs nuls SQL pour chaque colonne
acceptant le nul sont stockés dans
les emplacements sur lesquels le champ
SvdNullIndPtr pointe dans les descriptions
de colonnes SQLDA correspondantes.

Etape 7 : Travailler avec des données
de colonnes extraites. L’exemple
de programme Describe n’affiche que
les données extraites. Le SvdDataPtr
dans l’étape précédente pointe sur
SvdData, un champ caractère de longueur
de colonne maximale (32.767
octets).
Si la colonne considérée est une
colonne caractère, nous pouvons la
manipuler directement avec cette définition
de champ :

Eval ColData = %Subst( SvdData: 1: SvdLen )

Comme dernière action, nous fermons le curseur SQL de la manière suivante :

C/Exec SQL
C+ Close ResultTblCar
C/End-Exec