Ces procédures sont des enveloppes autour du code RPG. L’instruction SQL suivante crée une procédure stockée qui enveloppe un programme RPG chargé de vérifier si un numéro de bon de commande est en double pour un client :

CREATE PROCEDURE denoncourt.o99epo (

  IN  compNo CHAR(2),

  IN  custNo CHAR(7),

  IN  poNo   CHAR(25), 

  OUT dup    CHAR(1)

) 

LANGUAGE RPGLE 

NOT DETERMINISTIC 

NO SQL 

EXTERNAL NAME denoncourt.o99epo 

PARAMETER STYLE GENERAL

Il est facile de voir les paramètres nécessaires pour appeler le code RPG au travers de la procédure stockée. Il est clair, par exemple, que le paramètre appelé dup contiendra une indication caractère disant si le numéro de bon de commande (PO number) passé est un doublon.

Intégration RPG au moyen de procédures stockées

RPG peut renvoyer de l’information de deux manières : (1) par des paramètres output (ou input/output) et (2) par un jeu de résultats SQL. Si les données renvoyées se trouvent dans une liste, utilisez l’option 2. Le code SQL suivant crée une procédure stockée qui renvoie une liste de clients :

CREATE PROCEDURE denoncourt.getaccounts3

(IN     acctNo     DEC (5, 0) ) 

LANGUAGE RPGLE 

NOT DETERMINISTIC 

contains SQL 

EXTERNAL NAME denoncourt.getaccts3

PARAMETER   STYLE GENERAL

Pour appeler ces procédures stockées à partir de Groovy, Java doit être installé, et les fichiers Groovy jar (groovy-1.6.x.jar) et j400 jar (jt400.jar) doivent être présents. Pour pouvoir compiler Groovy, vous devrez vous procurer le Groovy Development Kit (GDK) auprès de groovy.codehaus.org/Download (qui inclut le fichier Groovy jar). Comme le Java Development Kit (JDK), le GDK n’est pas un IDE mais un ensemble d’utilitaires lignes de commande. Sachez que Eclipse, WDSC, RDi, et NetBeans reconnaissent tous Groovy. L’un des utilitaires lignes de commande de Groovy est groovyConsole. La console Groovy procure une GUI pratique, que montre la figure 1, qui sert à tester le code Groovy. Bien que la console Groovy soit commode pour tester rapidement du code, je préfère utiliser pour cela le plug-in Groovy Eclipse. La figure 2 montre l’exemple Groovy de cet article s’exécutant dans WDSC. (Pour plus d’instructions sur l’installation du plug-in Groovy dans WDSC, voir code.google.com/p/grails400utils/wiki/GroovyEclipsePlugin.)

La figure 3 montre le code Groovy servant à appeler les procédures stockées précédentes. La première chose qu’un habitué de Java remarquera est l’absence de définition de classes. En effet, Groovy reconnaît parfaitement les classes mais permet aussi d’exécuter du code en tant que scripts sans qu’un nom de classe soit nécessaire.

En A de la figure 3, il y a trois instructions importantes. Les imports sont exactement comme ceux de Java (ils ressemblent beaucoup à des copybooks RPG). À noter que deux des imports qualifient des classes Java standard. Le code Groovy peut utiliser des classes à partir de tout package Java. Cela rend Groovy plus puissant que la plupart des autres langages dynamiques, parce qu’il peut utiliser la plus vaste base de code des API disponibles aujourd’hui sous la forme de frameworks Java et d’extensions de langages.

En B, une connexion SQL est établie. Sql est une classe Groovy qui réduit sensiblement le code nécessaire pour effectuer un traitement SQL. Un code Java comparable demanderait plusieurs instructions. À noter que dans une application web Grails, pour utiliser la même connexion déjà acquise par le framework, l’objet Sql est créé avec le code suivant :

Sql sql = new Sql(sessionFactory.
getCurrentSession().connection())

En C, quatre variables sont définies. Ces déclarations de variables vous montrent que Groovy est un langage typé optionnellement. Observez comment la variable appelée duplicate est explicitement typée comme un booléen et custNo comme une chaîne. Mais compCode et poNo sont typées lâchement (loosely) en utilisant le mot réservé Groovy def. Les discussions sont vives dans le monde de la programmation à propos des langages typés lâchement (par exemple, PHP) ou typés statiquement (par exemple, Java). Groovy vous laisse le choix. Pour ma part, j’utilise un typage fort pour des paramètres de méthodes afin d’améliorer les vérifications de compilation et de définir plus clairement les paramètres nécessaires pour une interface.

En D, le code RPG est invoqué. La classe sql prend deux paramètres : (1) l’instruction SQL call, avec des paramètres substituables sous forme de points d’interrogation, et (2) une matrice d’arguments qui correspondent à ces paramètres. Observez que le second paramètre est entre crochets. Ces derniers identifient les matrices dans Groovy. Par rapport à Java, c’est une grande simplification. En effet, il n’est pas simple de manipuler des matrices et des maps en Java. Le code suivant montre combien il est facile de déclarer une matrice puis d’accéder au troisième élément :

def myAra = [‘zero’, ‘one’, ‘two’, ‘three’, ‘four’]
println myAra[2]

Mais revenons à l’appel (call) RPG. L’accolade qui suit immédiatement la parenthèse fermante de call ouvre ce qu’on appelle une closure. Les closures sont très commodes et font fureur dans les langages dynamiques. Mais en réalité, si vous débutez avec Groovy, vous utiliserez les closures sans même remarquer qu’elles sont un mécanisme puissant dont Java, C, ou C++ sont dépourvus.

Les closures ont une liste d’arguments optionnels. La liste d’arguments dans la closure de l’instruction sql.call est dup suivi par l’opérateur flèche. La valeur de la variable dup est définie d’après l’argument output de la procédure stockée. Si celle-ci avait de multiples arguments output, vous mettriez une liste des arguments dans la closure. Supposons que vous ayez écrit une procédure stockée qui a pris une date en entrée puis sort les trois arguments month, day, et year. Dans ce cas, votre sql.call ressemblerait à ceci :

sql.call(« call getMonthDayYear(?,?,?,?) »,
[Sql.in(Types.DATE, new Date()),
Sql.out(Types.CHAR),
Sql.out(Types.CHAR),
Sql.out(Types.CHAR)]
) { month, day, year ->
println « $month/$day/$year »
}

Le corps de la closure en D définit la variable booléenne duplicate comme true si dup égale Y. Le bloc de code se termine par l’impression de la valeur de la variable dup. Si PHP vous est familier, vous verrez que la chaîne suivant le nom de méthode println fait référence à une variable avec l’opérateur dollar. Avec Java, vous auriez dû concaténer manuellement la variable dup avec une chaîne texte. Il y a une autre source d’étonnement pour les habitués de Java à propos de la fonction println : où sont les parenthèses de la méthode ? En Groovy, les parenthèses de fonctions ou de méthodes sont facultatives. Et dans la même veine : où sont les points-virgules fermants ? Eux aussi sont facultatifs en Groovy. Ils ne sont nécessaires que pour placer plusieurs instructions sur une ligne. (Je déteste devoir taper des points-virgules dans mon RPG libre.) Les parenthèses de méthodes et les points-virgules d’instructions sont jugés indésirables par les aficionados de Groovy ; si de tels caractères n’améliorent pas la lisibilité du code, ils n’ont rien à y faire. Ce ne sont là que quelques fonctions Groovy qui rendent sa syntaxe plus courte, plus facile à lire, et plus puissante que son cousin Java.