, , , , , , , Enumération typée en RPG

Enumération typée

Depuis décembre 2025, le compilateur RPG permet la déclaration d’une énumération typée, ainsi que de variables de même type que l’énumération.

Prérequis

Avoir les PTFs :

7.5:

  • ILE RPG compiler: 5770WDS SJ08375

7.6:

  • ILE RPG compiler: 5770WDS SJ08384
  • ILE RPG compiler, TGTRLS(V7R5M0): 5770WDS SJ08394

Syntaxe

Par exemple :

Il faut indiquer le type précis de l’énumération, ici CHAR(3). Les valeurs des constantes énumérées doivent correspondre au type.

DFT indique une valeur par défaut : 1 et 1 seule, facultatif.

Il est impossible de définir une énumération comme une autre énumération :

Par contre, vous pouvez définir des variables comme une énumération typée :

Quelques règles

  • une valeur par défaut supportée par énumération
  • initialisation des variables ou zone de DS par une valeur de l’énumération :
    • dcl-s myCall1 like(CALL_TYPE) inz(CALL_TYPE.DISPLAY) : OK
    • dcl-s myCall2 like(CALL_TYPE) inz('DSP') : Erreur, même si la valeur existe dans l’énumération
  • si inz est indiqué sans valeur, la valeur par défaut de l’énumération est utilisée
  • de même pour l’affectation d’une nouvelle valeur, doit se faire via l’énumération, quelque soit le type de valeur :
    • myCall1 = CALL_TYPE.UPDATE : OK
    • myCall1 = 'UPD' oumyCall1 = ('U' + 'PD') : Erreur
  • Les fonctions %hival et %loval fonctionnent
  • Contrairement à*hival et*loval

En tant que tableau ou liste

Il est possible d’utiliser une énumération partout où un tableau est utilisable, sauf avec :

  • SORTA
  • %elem
  • %lookup
  • %subarr

Par exemple en tant que liste :

Domaine de validité

Seules les valeur de l’énumération sont utilisables, toute autre valeur provoque une erreur de compilation.

Toutefois, il est possible de contourner ce fonctionnement.

Pour les variables de type numérique, les calculs sont autorisés :

En passant avec un pointeur :

En paramètre de procédure

Cela permet d’indiquer explicitement les valeurs autorisés pour les paramètres définis comme une énumération :

  • la valeur de retour est définie parlike(ERROR) et ne pourra avoir que les valeurs définies
  • le paramètre p_callType est défini parlike(CALL_TYPE) pour lequel les valeurs sont également définies

C’est beaucoup plus pertinent qu’un commentaire, le compilateur effetuant le contrôle.

Précompilateur SQL

Les valeurs énumérées sont reconnues en tant que constantes, et les variables définies depuis une énumération sont utilisables :

Par contre, l’affectation d’une valeur non énumérée est possible :

L’utilisation en tant que liste de valeurs dans un IN SQL n’est pas supportée :

option de compilation CCSID(*EXACT)

Si votre énumération est définie en CHAR ou VARCHAR et contient des valeurs non définies par des constantes hexadécimales, c’est à dire la plupart des cas, vous devez indiquer ctl-opt ccsid(*exact).

C’est une obligation afin que le compilateur ne fasse pas de supposition incorrecte sur le CCSID des littéraux pour comparaison avec les variables de vos programmes. Aucune conversion implicite n’est effectuée et cela évote les incohérences que l’on peut avoir, particulièrement avec des fichiers source dans l’IFS, généralement encodés en UTF-8.

Références

https://www.ibm.com/docs/en/i/7.6.0?topic=enumerations-typed

https://www.ibm.com/support/pages/rpg-cafe

https://ibm.biz/rpgcafe_fall_2025_fld_like_enum

https://www.ibm.com/docs/en/i/7.6.0?topic=keyword-ccsidexact

/par
Test Basic IA et RPGLE

On attend beaucoup de BOB, mais que font les autres IA aujourd’hui, par exemple sur du RPGLE sur IBMi

j’ai décider de faire un petit challenge Gemini, Coplilot, ChatGPT, Grok

J’ai volontairement fait 3 erreurs dans mon code
w_bool non déclaré
endif manquant
fin de programme manquante

*free ctl-opt DFTACTGRP(NO) ;
dcl-s texte char(10 ) ;
dcl-s bool ind ;
// ecriture
if w_bool ;
texte = 'Texte' ;
dsply ('texte ' + texte) ;

Je n’ai pas fourni de contexte
je n’ai pas fourni le résultat de compilation
je n’ai aucun abonnement, j’ai utilisé une version grand public pour les 3 IA

Voici mon prompt, il est volontairement très basic

« Ce programme ne compile pas, SVP, peux tu m’indiquer ou est le probléme « 

*free ctl-opt DFTACTGRP(NO) ;
dcl-s texte char(10 ) ;
dcl-s bool ind ;
// ecriture
if w_bool ;
texte = ‘Texte’ ;
dsply (‘texte ‘ + texte) ;

Je n’ai pas mis l’analyse que les IA ont rendues qui étaient pertinentes dans les 3 cas

Voici le résultat quelles ont produit

Gemini

Il a ajouter un return. 

*free ctl-opt DFTACTGRP(NO);

dcl-s texte char(10);
dcl-s bool ind;

// Initialisation (pour le test)
bool = *on;

if bool; // Utilisation du bon nom de variable
texte = 'Texte';
dsply ('texte ' + texte);
endif; // Ne pas oublier de fermer le IF
*inlr = *on;
return;

Chatgpt 

*free ctl-opt dftactgrp(no);

dcl-s texte char(10);
dcl-s bool ind inz(*on);

// écriture
if bool;
texte = 'Texte';
dsply ('texte ' + texte);
endif;

*inlr = *on;

Copilot

*free ctl-opt dftactgrp(no);

dcl-s texte char(10);
dcl-s bool ind;

// ecriture
if bool;
texte = 'Texte';
dsply ('texte ' + texte);
endif;

*inlr = *on;
return;

Grok

un %char sur le texte qui ne sert à rien 

**free
ctl-opt                      
  dftactgrp(*no) ;             
dcl-s texte   char(10) ;       
dcl-s bool    ind    ;         
// Initialisation
bool = *on ;                   // ← Ajout nécessaire !
// Ecriture                   
if bool ;                     
  texte = 'Texte' ;            
  dsply ('texte  ' + %char(texte)) ;
endif ;
*inlr = *on ;

Conclusion :

Les 4 IA ont produit un code qui compile, et une analyse pertinente
Avec de IA entrainées et spécialisées, on doit pouvoir faire des choses étonnantes

/par
, , C’est quoi ce BOM ?

BOM signifie Byte Order Mark
👉 en français : marque d’ordre des octets

C’est une séquence d’octets placée au tout début d’un fichier texte pour indiquer :

l’encodage du fichier

parfois l’ordre des octets (endianness)

📌 À quoi sert un BOM ?
1️⃣ Identifier l’encodage

Quand un logiciel ouvre un fichier, le BOM lui dit :

« Ce fichier est en UTF-8 / UTF-16 / UTF-32 »

Sans BOM, certains outils devinent l’encodage… et se trompent.

2️⃣ Indiquer l’ordre des octets (UTF-16 / UTF-32)

Pour les encodages multi-octets :

Little Endian

Big Endian

Le BOM permet de savoir dans quel ordre lire les octets.

Sur L’IBMi on l’utilisera pour échanger un fichier UTF8 avec un autre système que le réclame, ou à l’inverse il faudra l’enlever sur un fichier recu !

Voici 2 procédures pour vous aider et une requête

Une requête pour afficher le BOM sur un fichier IFS

WITH FICHIER AS (
    SELECT DATA
    FROM TABLE (
        QSYS2.IFS_READ_BINARY('/tmp/test.txt')
    )
)
SELECT
    HEX(SUBSTR(DATA, 1, 4))      AS BOM_HEXA,
    CASE
        WHEN SUBSTR(DATA, 1, 3) = X'EFBBBF'
            THEN 'UTF-8 avec BOM'
        WHEN SUBSTR(DATA, 1, 2) = X'FFFE'
            THEN 'UTF-16 Little Endian'
        WHEN SUBSTR(DATA, 1, 2) = X'FEFF'
            THEN 'UTF-16 Big Endian'
        WHEN SUBSTR(DATA, 1, 4) = X'FFFE0000'
            THEN 'UTF-32 Little Endian'
        WHEN SUBSTR(DATA, 1, 4) = X'0000FEFF'
            THEN 'UTF-32 Big Endian'
        ELSE
            'Aucun BOM détecté (UTF-8 sans BOM probable)'
    END AS ENCODAGE_DETECTE
FROM FICHIER;

Une procédure pour ajouter un BOM sur un fichier à envoyer

CREATE OR REPLACE PROCEDURE AJOUTER_BOM (
IN p_path VARCHAR(1024) CCSID 1208,
IN p_bom VARCHAR(10)
)
LANGUAGE SQL
BEGIN
DECLARE v_data BLOB(10M);
DECLARE v_new_data BLOB(10M);
DECLARE v_bom BLOB(4);-- Déterminer le BOM à ajouter
SET v_bom =
    CASE UPPER(p_bom)
        WHEN 'UTF8'     THEN X'EFBBBF'
        WHEN 'UTF16LE'  THEN X'FFFE'
        WHEN 'UTF16BE'  THEN X'FEFF'
        ELSE NULL
    END;

IF v_bom IS NULL THEN
    SIGNAL SQLSTATE '38001'
        SET MESSAGE_TEXT = 'BOM non reconnu (UTF8, UTF16LE, UTF16BE)';
END IF;

-- Lire le fichier
SELECT DATA
  INTO v_data
  FROM TABLE (
    QSYS2.IFS_READ_BINARY(p_path)
  );

-- Vérifier si le BOM est déjà présent
IF SUBSTR(v_data, 1, LENGTH(v_bom)) <> v_bom THEN
    SET v_new_data = v_bom || v_data;

    -- Réécriture du fichier avec BOM
    CALL QSYS2.IFS_WRITE_BINARY(
        PATH_NAME => p_path,
        DATA      => v_new_data,
        REPLACE   => 1
    );
END IF;
END;

Une procédure pour enlever le BOM

CREATE OR REPLACE PROCEDURE SUPPRIMER_BOM (
IN p_path VARCHAR(1024) CCSID 1208,
IN p_bom VARCHAR(10)
)
LANGUAGE SQL
BEGIN
DECLARE v_data BLOB(10M);
DECLARE v_bom BLOB(4);
DECLARE v_len INTEGER;-- Déterminer le BOM à supprimer
SET v_bom =
    CASE UPPER(p_bom)
        WHEN 'UTF8'     THEN X'EFBBBF'
        WHEN 'UTF16LE'  THEN X'FFFE'
        WHEN 'UTF16BE'  THEN X'FEFF'
        WHEN 'UTF32LE'  THEN X'FFFE0000'
        WHEN 'UTF32BE'  THEN X'0000FEFF'
        ELSE NULL
    END;

IF v_bom IS NULL THEN
    SIGNAL SQLSTATE '38001'
        SET MESSAGE_TEXT =
          'BOM non reconnu (UTF8, UTF16LE, UTF16BE, UTF32LE, UTF32BE)';
END IF;

SET v_len = LENGTH(v_bom);

-- Lire le fichier
SELECT DATA
  INTO v_data
  FROM TABLE (
    QSYS2.IFS_READ_BINARY(p_path)
  );

-- Vérifier et supprimer le BOM demandé
IF SUBSTR(v_data, 1, v_len) = v_bom THEN
    SET v_data = SUBSTR(v_data, v_len + 1);

    -- Réécrire le fichier sans BOM
    CALL QSYS2.IFS_WRITE_BINARY(
        PATH_NAME => p_path,
        DATA      => v_data,
        REPLACE   => 1
    );
END IF;
END;

Conclusion

Sur IBMi ca ne sert à rien le CCSID donne cette information

Pour en savoir plus Indicateur d’ordre des octets — Wikipédia

/par
, , , , , , , Open api avec IWS 3.0

En novembre 2025, IBM a fait évoluer IWS de la version 2.6 à la version 3.0

Outre le passage à Jakarta EE au lieu de Java EE, la principale nouveauté concerne l’intégration de d’open api.

Création d’une instance

La version de l’instance est affichée :

Open api

Une fois l’instance créée, vous avez désormais accès à l’interface open api :

http[s]://instance:port/openapi/ui

L’interface présente l’ensemble des services déployés dans le serveur, avec les routes (opérations).

Vous avez également la possibilité de tester les services en direct :

L’outil affiche les syntaxes curl correspondantes !

Evidemment, seuls les services REST sont affichés dans l’interface openapi.

Vous pouvez personnaliser certains attributs openapi via la commande setWebServicesServerProperties et un fichier de configuration à fournir.

Migration des instances

Toutjours par script shell (dans /QIBM/ProdData/OS/WebServices/bin), vous pouvez migrer vos instances IWS 2.6 en 3.0 :

updateWebServicesServer.sh -server instance -version *CURRENT

Lors de l’opération :

  • Les serveur est migré en 3.0
  • Les services sont convertis

en cas d’erreur, vous pouvez lancer la conversion de services par updateWebServices.sh.

Dans nos différents tests, nous n’avons pas observé de modification de comportement des services migrés.

Par contre, nous observons, pour l’instant, des erreurs de conversion pour les services SOAP.

Voir la documentation : https://www.ibm.com/support/pages/node/7248102

/par
, , Comprendre l’impact du CCSID de votre source

Vous avez vos sources coté IBMi qui sont le plus souvent stockés dans des fichiers sources QRPGLESRC et le CCSID est à 1147 (je reviens pas sur les dangers du 65635)

Vous décidez de placer, vos sources dans l’IFS et vous décidez d’adopter un (CCSID UTF-8 recommandé) ,voir Windows 1252.

C’est le sens de l’histoire pour giter par exemple

Le CCSID du source a un impact sur les constantes de votre programme RPGLE, à la compilation on va voir un exemple :

Les constantes étant basées sur le CCSID du source par défaut

Voici un programme 

**free                                                                 
ctl-opt dftactgrp(*no)                                                 
  //    ccsid(*exact)    // << clé : figer au CCSID de                   
  ;                                                                    
dcl-c titre 'Tarif semaine dès 4 jours ?  ' ;   // Constante           
dcl-s mots char(06) dim(3) ctdata perrcd(1);    // tableau chargé à la 
dcl-ds ds_texte    ;                            // tableau de constante
      *N Char(06) Inz('école' ) ;       //                             
      *N Char(06) Inz('garçon') ;       //                             
      *N Char(06) Inz('café ' ) ;       //                             
      texte   char(06) dim(3) pos(1) ;                                 
end-ds;                                                                
dcl-s i     int(10);                                                   
// Affichage Résultat                                                  
dsply ('Constante : ' + titre);                                        
for i = 1 to %elem(texte) ;                                            
  dsply ('Texte    : ' + texte(i));                                    
endfor; 
for i = 1 to %elem(mots);                     
  dsply (' CTDATA   : ' + mots(i));           
endfor;                                       
*inlr = *on;                                  
** CTDATA mots (3 lignes, codées avec accents)
école                                         
garçon                                        
café

Coté IBMi

Avec un ccsid 1147

CRTBNDRPG PGM(GDATA/SRCCCSID)
SRCFILE(GDATA/QRPGLESRC)

Vous obtenez ceci

Coté IFS

Avec un ccsid UTF-8

CRTBNDRPG PGM(GDATA/SRCCCSID)      

          SRCSTMF(‘SRCCCSID.RPGLE’)

Vous obtenez ceci

Vous perdez les caractères spéciaux

Vous avez une option de compile TGTCCSID qui fixe le CCSID à utiliser

donc on ajoute l’option

CRTBNDRPG PGM(GDATA/SRCCCSID)      

          SRCSTMF(‘SRCCCSID.RPGLE’)

          TGTCCSID(1147)    

L’affichage est correct

Conclusion :

Vous pouvez également utiliser *JOB dans la valeur de TGTCCSID(), à ce moment la vous aurez le même comportement dans les 2 cas si votre job est en 1147.

On expliquera ccsid(*exact) dans un autre post

t

/par
, , , , , , , Fonction d’usage QIBM_NAV_SECURITY_EIM

Si vous êtes utilisateur de SSO (Single Sign On) sur l’IBM i, alors vous utilisez l’EIM (Enterprise Identity Mapping).

Pour rappel (en très simplifié), le SSO vous permet de propager votre authentification Windows jusqu’à l’IBM i de sorte que n’avez pas besoin de saisir votre profil/mot de passe : une association entre vos comptes Windows et IBM i est réalisée et prise en compte automatiquement.

Pour gérer ces associations, vous pouvez utiliser IBM Navigator for i :

A partir de là vous avez accès à toute la gestion de l’annuaire (nécessite une authentification).

Bien entendu, ces fonctions sont critiques d’un point de vue de la sécurité : une modification de la configuration peut empêcher toute connexion, ou au contraire permettre une connexion avec un profil IBM i élevé !

IBM a donc délivré une nouvelle fonction d’usage QIBM_NAV_SECURITY_EIM (EIM related security) à cet effet : limiter l’accès aux fonctions EIM via Navigator for i.

La valeur par défaut est *ALLOWED pour tous -> vous devriez la passer à *DENIED !

Dès lors, si vous tentez d’accéder aux fonctions EIM, vous obtenez :

Plus de détails sur les Group PTF :

https://www.ibm.com/support/pages/node/6520030#Q22025

https://www.ibm.com/support/pages/node/6485853

Vous voulez automatiser la gestion de votre SSO pour l’IBM i, contactez nous : https://www.gaia.fr/produits/

/par
, , , , , , , Sécurité du plan Cache SQL

Si vous avez assisté à l’événement Securiti 2025 organisé par i.gayte.it, nous avions présenté une fonctionnalité SQL permettant de limiter l’accès aux informations du plan cache SQL.

Vous trouverez par ailleurs le replay de l’événement ici : Sécurit.i 2025 : Replays – I.Gayte.it

En effet, ce dernier contient de nombreuses informations nécessaires à l’adaptation du moteur SQL. Mais il contient aussi les données utilisées dans vos requêtes : constantes littérales, valeurs de comparaisons …

Bien entendu, certaines valeurs sont à protéger, y compris des utilisateurs ayant les droits de consulter le plan cache.

SYSPROC.SET_COLUMN_ATTRIBUTE

Cette procédure permet de cacher les informations pour certaines colonnes de certaines tables : https://www.ibm.com/docs/en/i/7.6.0?topic=services-set-column-attribute-procedure

Pour ceci :

L’attribut est visible dans le catalogue DB2 : QSYS2.SYSCOLUMNS2, colonne SECURE => 0 ou 1

Désormais, lorsque vous accédez au cache :

Cela fonctionne, mais à moitié !

Correctif

IBM a publié un correctif : https://www.ibm.com/support/pages/security-bulletin-ibm-i-affected-obtaining-information-without-proper-authority-cve-2025-36371

Toutes les versions depuis la 7.2 sont touchées : mettez à jour !

Merci à l’équipe du lab de Rochester qui a résolu ce problème rapidement. Il semble toutefois que personne ne l’avait remonté préalablement !

Désormais on obtient bien :

L’IBM i propose de nombreuses fonctionnalités sous-utilisées, n’hésitez pas à nous faire part de vos questions.

/par
, Copier vos données VIA DDM/DRDA

Vous connaissez tous DDM qui permet d’avoir un fichier qui pointe sur une système

Cette solution s’appui sur DRDA, donc DRDA devra etre configuré aujourdh’ui en IP

Cette solution est simple elle permet par exemple de mettre à jour des données d’un système vers un autre IBMi

Nous vous proposons un outil simple qui vous permettra de faire des copies dynamiques

La commande CPYRMTDTA

/* programme associé CPYRMTDTA */
CMD PROMPT(‘Copie data vers un IBMi’)

PARM KWD(FROMFILE) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Fichier source’)
PARM KWD(FROMLIB) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Bibliothèque source’)
PARM KWD(TOFILE) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Fichier cible’)
PARM KWD(TOLIB) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Bibliothèque cible’)
PARM KWD(RMTLOC) TYPE(*CHAR) LEN(30) MIN(1) +
PROMPT(‘Emplacement distant (RDB)’)

Le programme CLLE (à améliorer )

PGM (&FFILE &FLIB &TLIB &TFILE &RMT)/*——————————*/
/* Copier les données d’un fichier local vers un fichier distant */
/* en utilisant drda */
/* drda doit etre configurer sur le système distant */
/* et l’utilisateur en cours doit pouvoir s’authentifier */
/* */
/*——————————————————————*/
DCL &FFILE *CHAR 10
DCL &FLIB *CHAR 10
DCL &TFILE *CHAR 10
DCL &TLIB *CHAR 10
DCL &RMT *CHAR 30
INCLUDE SRCMBR(ERREUR1) SRCFILE(GCOMPILE/QCLSRC)
CHKOBJ &FLIB/&FFILE *FILE
DLTF FILE(QTEMP/RMTFILE)
MONMSG CPF2100
CRTDDMF FILE(QTEMP/RMTFILE) RMTFILE(&TLIB/&TFILE) +
RMTLOCNAME(&RMT *IP)
CPYF FROMFILE(&FLIB/&FFILE) TOFILE(QTEMP/RMTFILE) +
MBROPT(*REPLACE)
MONMSG CPF0000 EXEC(DO)
SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG) MSGDTA(‘Copie +
fichier : ‘ *BCAT &FFILE *BCAT +
‘,impossible’) MSGTYPE(*ESCAPE)
ENDDO
INCLUDE SRCMBR(ERREUR2) SRCFILE(GCOMPILE/QCLSRC)

Remarque :

Bien sur vous devrez contrôler la sécurité, attention par exemple un profil *disabled peut se connecter en DRDA

Pour vous aidez, vous pouvez télécharger notre outil WRKSRVAUTE pour gérer vos postes d’authentifications :https://github.com/Plberthoin/PLB/tree/master/GTOOLS

/par
Passage d’un paramètre à l’état Null de SQL à RPGLE

Voici un petit retour d’expérience sur un cas d’usage où on doit transmettre l’état Null d’un paramètre depuis une procédure SQL vers une procédure de service RPGLE.

Pour rappel, Null est un état, pas une valeur. Il permet justement d’indiquer qu’une variable ne possède pas de valeur définie.

Dans le cas d’usage traité ici, je dois exposer une procédure de service RPGLE en procédure SQL, et gérer l’état Null pour l’un des paramètres seulement.

La procédure de service RPGLE reçoit en paramètre une DS qui contient 3 sous-zones, chacune ayant été définie avec 2 noms (un nom long et un nom court) grâce à un overlay. La procédure de service RPGLE doit pouvoir gérer l’état Null de la deuxième sous-zone.

Template de la DS et Prototype de la procédure de service RPGLE :

Le mot-clé NULLIND permet de définir l’état Null pour les sous-zones Parametre_02 et P2.

Le stockage de la sous-zone P2 est superposé à celui de la sous-zone Parametre_02. Lorsque l’une des deux sous-zones prend une valeur, l’autre prend la même valeur.

En revanche, ce n’est pas le cas pour l’état Null. Chaque sous-zone possède son propre indicateur Null. Si on veut pouvoir tester indifféremment l’indicateur Null pour l’une ou l’autre des deux sous-zones, il faudra gérer l’état Null pour les deux noms de sous-zones. J’ai donc défini le mot-clé NULLIND pour les deux sous-zones.

OPTION(*NULLIND) permet de transmettre à la procédure de service, l’état Null des sous-zones de la DS.

En RPG, l’état Null d’un paramètre est transmis sous forme d’un INDICATEUR. Il pourra être testé avec la fonction intégrée %NULLIND() : *ON (état Null) ou *OFF (état non Null).

Procédure de service :

Le mot-clé ALWNULL(*USRCTL) est indiqué dans la déclaration de contrôle pour permettre de gérer l’état Null des paramètres.

OPTION(*NULLIND) permet de transmettre à la procédure de service, l’état Null des sous-zones de la DS.

%NULLIND(DSParm.P2) est l’indicateur de l’état Null du paramètre DSParm.P2. Il sera transmis à la procédure.

Procédure SQL avec programme externe RPGLE qui appellera la procédure de service :

Les paramètres 1 à 3 sont INOUT car ils peuvent être modifiés par la procédure de service et retournés à la procédure SQL.

WITH NULLS permet de transmettre au programme externe les indicateurs d’état Null pour tous les paramètres de la procédure.

Les indicateur Null sont transmis au programme externe sous forme de valeurs numériques :

  • -1 -> le paramètre est à l’état Null avec une valeur indéfinie
  • 0 -> le paramètre possède une valeur définie

Procédure SQL avec programme externe RPGLE qui appellera la procédure de service :

Programme externe RPGLE

Programme PROGRPG :

Le mot-clé ALWNULL(*USRCTL) est indiqué dans la déclaration de contrôle pour permettre de gérer l’état Null des paramètres.

Le tableau Null_Array est déclaré à la fin des paramètres, en plus des paramètres de la procédure SQL. Il contient les indicateur d’état Null transmis par la procédure SQL sous forme de valeurs numériques :

  • 0 -> le paramètre possède une valeur définie
  • -1 -> le paramètre est à l’état Null avec une valeur indéfinie

Tous les paramètres peuvent être transmis à l’état Null par la procédure SQL, mais seul l’état Null de Parametre_02 est géré par la procédure de service. J’ai donc rajouté une boucle de contrôle de l’état Null des paramètres pour retourner une erreur à la procédure SQL si un autre paramètre était transmis à l’état Null.

Avant d’appeler PROCILE, il faut définir l’indicateur Null %nullind pour Parametre_02 et P2 en convertissant l’indicateur numérique envoyé par SQL (0 ou -1) en indicateur booléen *ON/*OFF pour la procédure de service. Nous avons vu plus haut que, même si P2 a été définie comme overlay de Parametre_02, il existe un indicateur état Null distinct attaché à chaque nom de zone.

Appel de la procédure PROCILE

On a vu que PROCILE retourne la valeur 999,99 pour le paramètre 2 s’il a été transmis à l’état Null. Pour que la procédure SQL retourne à son tour cette valeur 999,99 il faut forcer l’état Non Null pour PARM2 de la procédure SQL en affectant la valeur numérique 0 à l’indicateur SQL état Null de PARM2.

Test de la procédure SQL

Test 1

Si l’état Null est envoyé pour un PARM1 au lieu de PARM2, un code E est retournée dans le paramètre ERREUR

.

Test 2

PARM2 envoyé à Null, retourné à 999.99.

Sans Null_Array(2) = 0 dans le programme externe, la valeur affichée pour PARM2 au retour aurait été <NULL> au lieu de la valeur réelle retournée 999.99

.

Test 3

PARM2 envoyé avec une valeur définie, retourné avec la même valeur

/par
, , , , , , , Power Week 2025 : retour à la maison !

Vous avez assisté, ou non, à la Power Week coorganisée par IBM France et Common France :

Gaia-Volubis a été très heureux de participer à cette édition, riche en annonces. Avant de reprendre une vie normale, de retourner à notre quotidien, voici le retour de nos speakers !

Damien

C’est toujours un moment particulier pour nous dans notre calendrier, et cette année n’aura pas dérogée aux autres : beaucoup de participants, d’échanges que ce soit avec des clients ou des IBMers, quelques dépannages en direct ! 3 jours intenses.

Merci aux participants à nos sessions et à leurs retours. Il est toujours appréciables de savoir que nos choix de sujets correspondent à des attentes des participants à l’évènement.
Prochain évènement de masse : le Common Europe à Lyon en juin 2026…

Florian

Trois jours intenses et passionnants pour cette édition de la Power Week 2025 !

Au-delà du programme officiel, ce sont surtout les échanges directs avec nos clients, partenaires, IBMers et l’ensemble des participants qui ont marqué l’événement. Ces discussions spontanées, souvent en marge des sessions, sont celles qui font grandir notre réseau, ouvrent des perspectives et apportent des idées concrètes pour aller plus loin.

J’ai également pu présenter COMMON France et toutes les actions que nous avons menées cette année, notamment la Battle Dev que j’ai eu le plaisir de coorganiser avec Philippe Bourgeois et Jérôme Clément. J’espère que nous pourrons organiser une 4ᵉ édition l’année prochaine !

Merci à tous d’être venus !

Julien

Merci à toutes et à tous pour ces trois journées intenses à la Power Week 2025 !

J’ai particulièrement apprécié la qualité des échanges avec nos clients, partenaires et IBMers. Ces moments informels, toujours très enrichissants, sont essentiels pour nourrir notre réseau et nos perspectives.

J’ai également été heureux de présenter deux sessions orientées sécurité et bonnes pratiques sur IBM i, des sujets au cœur des préoccupations de nombreux clients. Merci pour votre participation et vos questions !

L’événement a une nouvelle fois confirmé sa convivialité, et la troisième édition de la Battle Dev a été remarquablement organisée.

Ravi de vous avoir retrouvés en nombre, et déjà impatient de vous revoir au Common Europe à Lyon en juin 2026 !

Betty

Ces trois jours au cœur de la communauté IBM étaient d’une richesse incroyable.

Ils m’ont permis d’avoir une vue plus globale et plus synthétique de la puissance, des possibilités et de l’avenir du power et de ses applications.

Mais le futur s’écrit aussi avec la jeune génération de  programmeurs, et la présence des participants à la pépinière de cette année m’a permis de voir que la relève était assurée grâce à ces formations.

J’ai eu l’occasion de faire une première présentation qui concernait la modernisation via SQL, et je n’ai aucun doute que les équipes hybrides qui se construisent actuellement avec des jeunes et des personnes plus expérimentées sauront trouver des méthodes de travail permettant d’aller vers cette modernisation, nécessaire, et souhaitée.

Eric

3 jours intenses de rencontres, des visages connus et des nouveaux venus. 3 jours de sessions intéressantes. Toutes les personnes rassemblées ont en commun un grand intérêt, voire même une passion pour leur système favori. Une communauté IBMi toujours aussi active.

J’ai pu cette année présenter la session « Modernisation avec SQL : comment Intégrer l’existant », avec BETTY et LUCAS. Notre première session. Ce fut intense à préparer, et à présenter.

Les outils open source ont suscité mon intérêt cette année. La présentation de BOB a été très instructive, bien qu’il reste de nombreuses questions encore sans réponse.

Merci à tous pour votre énergie et votre participation!

Pierre Louis

C’est avec plaisir que comme chaque année, on retrouve la communauté IBMi, cette année pour la première fois les gens du monde Power nous ont rejoint.

On a pu assister à des présentations techniques intéressantes, beaucoup était basées sur l’IA, comme BOB , dont la présentation a été très prometteuse …

Pour ma part j’ai trouvé très intéressant le produit MANZAN qui permet de supervisé votre IBMi et qui a l’air simple et efficace.

Cette année, j’ai présenté 2 sessions en duo avec Gautier Dumas, sur le chemin de modernisation et avec Florian Gradot sur, comment donner une seconde vie à vos application 5250, merci a eux de m’avoir supporté, ce fut une expérience intéressante.

J’ai pu échangé sur des thèmes différents, avec des clients et des partenaires, ce qui est toujours enrichissant.

Merci à IBM et à Common pour cette organisation, merci à ceux qui sont venus, et l’année prochaine !

Nathanaël

3 jours très intenses pour ma part, mais très enrichissants !

Les meilleurs moments : ceux que l’on ne peut pas mettre en photo 😉

J’ai particulièrement apprécié de pouvoir échanger de façon libre et informelle avec nos clients, partenaires, IBMers et de façon plus globale toutes les personnes présentes. C’est important, c’est la construction d’un réseau, un réseau qui apporte des perspectives, des solutions.

Donc merci à vous d’être venu, nombreux, y compris dans non sessions, de poser des questions. C’est ce qui nous donne l’énergie pour les mois à venir jusqu’au prochain grand rassemblement !

Retrouvez toutes les informations

👉 Consultez le programme complet ici avec les supports de présentation https://powerweek2025.sched.com/

👉 Les sessions de Gaia-Volubis téléchargement

Vers le prochain grand rendez-vous : Common Europe Congress à Lyon

La Power Week est aussi une étape vers un autre événement majeur : le Common Europe Congress, qui se tiendra à Lyon du 14 au 17 juin prochain. Ce congrès réunira la communauté IBM i européenne autour de conférences, ateliers, et moments conviviaux. Une occasion unique de faire rayonner notre territoire et notre expertise.

C’est la première fois en France depuis 1997, une autre ère !

Common Europe – A pan-European IT Community of IBM based solutions

/par