Archive pour l’année : 2026
Vous voulez répondre à un message dans la file d’attente QSYSOPR dans un de vos développements.
Vous devez utiliser la commande SNDRPY,
vous pouvez lui indiquer la réponse souhaitée, mais vous devez connaître la clé du message.
Cette clé est unique sur 4 caractères c’est le système qui la génère à l’envoi
Vous aurez donc souvent dans votre clp
DCL &key *char 4
RCVMSG … MSGKEY(&key)
SNDRPY …MSGKEY(&key)
Mais comment faire en SQL
Vous avez une vue qui vous permet de lire les messages d’une file (QSYS2.MESSAGE_QUEUE_INFO) et donc de récupérer la clé nécessaire.
Exemple
-- message avec réponse
SELECT MESSAGE_KEY
FROM QSYS2.MESSAGE_QUEUE_INFO
WHERE MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND MESSAGE_TYPE = 'INQUIRY';
-- message avec réponse pas encore répondu
WITH REPLIED_MSGS (KEY) AS (
SELECT A.MESSAGE_KEY
FROM QSYS2.MESSAGE_QUEUE_INFO A
INNER JOIN QSYS2.MESSAGE_QUEUE_INFO B
ON A.MESSAGE_KEY = B.ASSOCIATED_MESSAGE_KEY
WHERE A.MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND A.MESSAGE_QUEUE_LIBRARY = 'QSYS'
AND B.MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND B.MESSAGE_QUEUE_LIBRARY = 'QSYS'
ORDER BY B.MESSAGE_TIMESTAMP DESC)
SELECT HEX(A.MESSAGE_KEY) AS MSGKEY
FROM QSYS2.MESSAGE_QUEUE_INFO A
LEFT EXCEPTION JOIN REPLIED_MSGS B
ON A.MESSAGE_KEY = B.KEY
WHERE MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND MESSAGE_QUEUE_LIBRARY = 'QSYS'
AND MESSAGE_TYPE = 'INQUIRY'
ORDER BY MESSAGE_TIMESTAMP DESC;
Vous pourrez alors utiliser la fonction QCMDEXC pour lancer un SNDRPY paramétré
-- Avec Réponse au message
WITH REPLIED_MSGS (KEY) AS (
SELECT A.MESSAGE_KEY
FROM QSYS2.MESSAGE_QUEUE_INFO A
INNER JOIN QSYS2.MESSAGE_QUEUE_INFO B
ON A.MESSAGE_KEY = B.ASSOCIATED_MESSAGE_KEY
WHERE A.MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND A.MESSAGE_QUEUE_LIBRARY = 'QSYS'
AND B.MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND B.MESSAGE_QUEUE_LIBRARY = 'QSYS'
ORDER BY B.MESSAGE_TIMESTAMP DESC)
SELECT QCMDEXC(
'QSYS/SNDRPY MSGKEY(X''' CONCAT HEX(MESSAGE_KEY) CONCAT ''') MSGQ('
CONCAT MESSAGE_QUEUE_LIBRARY CONCAT '/'
CONCAT MESSAGE_QUEUE_NAME CONCAT ') RPY(''C'') RMV(*NO)')
FROM QSYS2.MESSAGE_QUEUE_INFO A
LEFT EXCEPTION JOIN REPLIED_MSGS B
ON A.MESSAGE_KEY = B.KEY
WHERE MESSAGE_QUEUE_NAME = 'QSYSOPR'
AND MESSAGE_QUEUE_LIBRARY = 'QSYS'
AND MESSAGE_TYPE = 'INQUIRY'
ORDER BY MESSAGE_TIMESTAMP DESC;
On a choisit de répondre C et de ne pas enlever le message dans la file
Mais les équipes de Scott on eu pitié de vous et dans SYSTOOLS vous avez la fonction REPLY_INQUIRY_MESSAGES
Voici comment elle s’utilise :
-- réponse sur un message sans MSGID par exemple envoyé par un SNDMSG ou SNDUSRMSG
-- le texte est obligatoire pour filtrer
VALUES SYSTOOLS.REPLY_INQUIRY_MESSAGES(
MESSAGE_ID => '*IMMED',
SEARCH_MESSAGE_TEXT => 'TESTPLB',
RESPONSE => 'C',
REMOVE_MESSAGE => 'NO'
);
-- réponse sur un message MSGID c'est toujours CPA0702
-- vous devez indiquer ensuite votre MSGID
VALUES SYSTOOLS.REPLY_INQUIRY_MESSAGES(
MESSAGE_ID => 'CPA0702', -- toujours ce message pour l'envoi
SEARCH_MESSAGE_TEXT => 'CPF0001', -- message applicatif
RESPONSE => 'C',
REMOVE_MESSAGE => 'NO'
);
-- réponse sur un texte de message ici erreur PGM
-- vous devez indiquer ensuite votre TEXT
VALUES SYSTOOLS.REPLY_INQUIRY_MESSAGES(
MESSAGE_ID => 'CPA0702',
SEARCH_MESSAGE_TEXT => 'ERREURPGM', -- filtré
RESPONSE => 'C',
REMOVE_MESSAGE => 'NO'
);

Remarque :
Vous pouvez extraire le source de la fonction de SYSTOOLS pour la personnaliser, ailleurs de préférence
Rappel :
Ce n’est pas parce que c’est possible qu’il faut le faire, des fois ne pas répondre peut être le bon réflexe.
Pour ne savoir plus :
Bob, son accueil et ses outils
Nous en avons récemment fait la promotion via notre page LinkedIn : nous avons commencé à tester l’usage de Bob en interne pour voir ce qu’il a dans le ventre. Nous continuons ce travail tout au long du mois d’août mais déjà, certains retours peuvent être réalisés et notamment à propos d’un élément qui peut aisément passer sous le radar : la commande /init.
Pour celles et ceux qui ont commencé à utiliser Bob, vous aurez constaté qu’IBM a créé une page d’accueil spécifique pour les détenteurs d’une licence payante. C’est assez sympa, IBM y a centralisé des accès vers des présentations rapides d’outils pratiques.

Vous aurez remarqué qu’une des tuiles se nomme « Slash Commands », que l’on peut traduire dans la langue de Molière par « commandes intégrées ». Et étrangement, /init est absente de la liste des commandes intégrées à laquelle cette tuile donne accès. Il m’a fallu lire la documentation en ligne de Bob avec un peu plus d’attention pour trouver trace de son existence.
La commande /init
Bon, la grammaire est assez transparente, vous l’aurez compris, cette commande a un rôle d’initialisation. Mais initialiser quoi, en fait ?
Eh bien d’initialiser l’utilisation de Bob dans votre projet ! L’idée derrière cette commande est de générer un ensemble de documents, adaptés à l’environnement de travail actuellement ouvert, sur lesquels Bob pourra ensuite s’appuyer pour répondre à vos demandes de manière plus efficaces et moins coûteuse.
Usage de la commande
Cette partie est assez simple :
- Ouvrez la barre latérale secondaire (Ctrl+Alt+B) de Bob. Vous y trouverez la vue de gestion des conversations avec l’agent IA.
- Dans le bloc bas de cet espace, assurez-vous que le mode « agent » soit bien sélectionné
- Dans l’espace dédié à l’écriture de texte, tapez simplement /init et appuyez sur Entrée.

L’exécution de la commande va générer plusieurs documents markdown nommés AGENTS.md.
- Le premier sera placé à la racine du dossier du projet et contiendra une description générale du contexte du projet.
- Les autres seront placés dans un dossier ‘.bob’ créé lui aussi à la racine du projet
Chacun d’entre eux sera dans un sous-dossier dédié, correspondant à un des principaux modes d’action de l’agent Bob (« ask », « plan », « agent »…)
Limitations
Cette commande se base sur l’espace de travail actuellement ouvert dans Bob ; typiquement, votre référentiel Git local d’un projet hébergé sur Github / Gitlab / votre IBM i.
Le fait même que la commande crée un dossier ‘.bob’ la rend incompatible avec une vision purement « QSYS ».
Vous pouvez utiliser la notion de surchargées SQL
Une surcharge c’est le fait de pouvoir appeler avec plusieurs prototypages différents, une fonction ou une procédure SQL
Voici un exemple :
soit une fonction qui convertit un integer en char
CREATE OR REPLACE FUNCTION PLB.FORMAT_CODE(P_VAL INTEGER)
RETURNS VARCHAR(10)
LANGUAGE SQL
SPECIFIC FORMAT_CODE_INT
BEGIN
RETURN CHAR(P_VAL);
END;
soit une fonction même nom qui convertit un char en majuscule
CREATE OR REPLACE FUNCTION PLB.FORMAT_CODE(P_VAL VARCHAR(10))
RETURNS VARCHAR(10)
LANGUAGE SQL
SPECIFIC FORMAT_CODE_CHAR
BEGIN
RETURN UPPER(TRIM(P_VAL));
END;
— Voici un jeu d’essai pour tester ces fonctions
— Création table de test
CREATE TABLE PLB.TESTSUR (
TESTINT INT NOT NULL WITH DEFAULT,
TESTCHAR VARCHAR ( 10) NOT NULL WITH DEFAULT)
INSERT INTO PLB.TESTSUR VALUES(1964, ‘PIERRE’) ;
INSERT INTO PLB.TESTSUR VALUES(1987, ‘Robert’) ;
— Test
SELECT plb.FORMAT_CODE(TESTINT),
plb.FORMAT_CODE(TESTCHAR)
FROM PLB.TESTSUR;
SQL choisit la fonction en fonction du type de paramètres reçus
Remarque :
il peut être intéressant de savoir si on a des fonctions ou procédures surchargées sur notre partition, notamment en cas de maintenance, cette information est importante.
Voici une petite requête pour analyser tout ca
SELECT ROUTINE_SCHEMA,
ROUTINE_NAME,
COUNT(*) AS NB_VARIANTES,
'FONCTION' AS TYPE_ROUTINE
FROM QSYS2.SYSFUNCS
WHERE ROUTINE_SCHEMA not LIKE('SYS%')
and ROUTINE_SCHEMA not LIKE('QSYS%')
GROUP BY ROUTINE_SCHEMA,
ROUTINE_NAME
HAVING COUNT(*) > 1
UNION
SELECT ROUTINE_SCHEMA,
ROUTINE_NAME,
COUNT(*) AS NB_VARIANTES,
'PROCEDURE' AS TYPE_ROUTINE
FROM QSYS2.SYSPROCS
WHERE ROUTINE_SCHEMA not LIKE('SYS%')
and ROUTINE_SCHEMA not LIKE('QSYS%')
GROUP BY ROUTINE_SCHEMA,
ROUTINE_NAME
HAVING COUNT(*) > 1
ORDER BY ROUTINE_SCHEMA,
ROUTINE_NAME,
TYPE_ROUTINE;
Vous pouvez facilement l’améliorer en joignant avec la vue SYSPARMS par exemple
Par exemple, vous utilisez SQL Error Logging Facility (SELF).
Vous voulez analyser les erreurs générées
Les erreurs sont stockées dans la vue SQL_ERROR_LOG de QSYS2
Vous avez une zone LOGGED_SQLCODE et une LOGGED_SQLSTATE qui contiennent le SQLCODE et le SQLSTATE de l’erreur
Vous voulez connaitre l’explication sur l’erreur SQL, vous avez des fonctions table SQLCODE_INFO et SQLCODE_STATE qui interprètent ce code
exemple :
SELECT LOGGED_SQLCODE,
STATEMENT_TEXT,
STATEMENT_OPERATION_DETAIL,
PROGRAM_LIBRARY,
PROGRAM_NAME
FROM QSYS2.SQL_ERROR;
Ajouter la Fonction table
SELECT LOGGED_SQLCODE,
(SELECT Message_text
FROM TABLE (
SYSTOOLS.SQLCODE_INFO(LOGGED_SQLCODE)
)) AS SQLCODE_TEXT,
STATEMENT_TEXT,
STATEMENT_OPERATION_DETAIL,
PROGRAM_LIBRARY,
PROGRAM_NAME
FROM QSYS2.SQL_ERROR;
Vous pouvez le faire sur le SQLSTATE ou sur le SQLCODE
Autre exemple, dans une programme RPGLE vous pouvez faire ceci par exemple
W_Text_sql char(512) ;
W_sqlcode like(sqlcode) ;
// traitement des erreurs SQL
if sqlcode <> 0;
w_sqlcode = sqlcode;
exec sql
// calcul du nombre de job à supprimer
SELECT Message_text into :W_Text_sql
FROM TABLE (
SYSTOOLS.SQLCODE_INFO(:w_sqlcode))
;
// Ecriture message dans la log
snd-msg (W_Text_sql) ;
endif ;
Plus d’informations ici
https://www.ibm.com/docs/en/i/7.6.0?topic=services-sqlcode-info-table-function
https://www.ibm.com/docs/en/i/7.6.0?topic=services-sqlstate-info-table
Rappel
il est important de traiter les erreurs SQL sur chaque instruction
Par exemple, vous voulez créer une commande qui suppriment les travaux d’un utilisateur avec des noms dupliqués ce que ne permet pas la Commande ENDJOB nativement.
Vous choisissez de le faire en SQLRPGLE, vous avez la fonction table QSYS2.ACTIVE_JOB_INFO qui va permettre de trouver les travaux à supprimer
Exemple :
Pour savoir le nombre de travaux à supprimer
dcl-s w_cnt int(10);
P_jobn = ‘QHSTB’ ;
P_user = ‘PLB’;
exec sql
SELECT COUNT(*)
INTO :w_cnt
FROM TABLE (
QSYS2.ACTIVE_JOB_INFO(JOB_NAME_FILTER => :p_jobnm)
) A
WHERE A.JOB_USER = :p_user ;
Remarque
Vous pouvez indiquer le nom du job dans le filtre et l’utilisateur dans la clause where de sélection
Maintenant pour agir vous devez utiliser la fonction QCMDEXC
SELECT QCMDEXC(‘ENDJOB JOB(‘ concat trim(A.JOB_NAME) concat ‘) OPTION(*IMMED)’)
FROM TABLE (
QSYS2.ACTIVE_JOB_INFO(JOB_NAME_FILTER => :P_jobn)
) A
WHERE A.JOB_USER = :p_user ;
Cette commande marche dans ACS par exemple, ou ajoutant un create table as dans un RUNSQL ou un RUNSQLSTM;
Le probléme de cette solution en RPGLE est qu’elle va vous obliger à avoir un curseur
soit dans le RPGLE
soit en faisant du Dynamic Compound Statement (Compile de code SQL à la volée)
Voici une astuce qui va permettre d’éviter le curseur
exec sql
SELECT COUNT(*) INTO :w_cnt
FROM TABLE(QSYS2.ACTIVE_JOB_INFO(
JOB_NAME_FILTER => :p_jobnm)) AS A
WHERE A.JOB_USER = :p_user
AND QSYS2.QCMDEXC(
‘ENDJOB JOB(‘ CONCAT TRIM(A.JOB_NAME)
CONCAT ‘) OPTION(*IMMED)’
) = 1;
On va utiliser le QCMDEXC dans la clause where
En effet cette fonction renvoie 1 quand c’est ok
Conclusions :
C’est simple et efficace
Mais attention à la sécurité et l’injection de code par exemple avec une clause where paramétrable qui peut permettre de passer n’importe quelle commande ?
Astuce :
Vous pouvez faire une commande qui lancera votre programme
CMD PROMPT(‘Arrêter plusieurs Travaux’)
PARM KWD(JOBNM) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Travail’)
PARM KWD(USER) TYPE(*NAME) LEN(10) MIN(1) +
PROMPT(‘Utilisateur’)
Fonction QSYS2.CREATE_DATA_JOURNAL_READER
Pour analyser des journaux la difficulté est de traiter le poste *entry data qui est spécifique à chaque fichier
La tr2 de la v7R6 et la tr8 de la v7r5 permet de résoudre cette problématique en créant une fonction spécifique sur un fichier pour analyser les postes de TYPE R
Voici un petit protocole de test
— création d’un schéma
create schema testjrn ;
- création d’une table journalisée par défaut sur qdftjrn
CREATE TABLE TESTJRN/TESTABLE (
NUMERO INT NOT NULL WITH DEFAULT,
NOM CHAR ( 50) NOT NULL WITH DEFAULT,
PRENOM CHAR ( 50) NOT NULL WITH DEFAULT,
DATMAJ TIMESTAMP NOT NULL WITH DEFAULT) ;
— génération de modifications dans le journal
INSERT INTO TESTJRN/TESTABLE VALUES(1, ‘Berthoin’, ‘Pierre-Louis’,
current timestamp);
INSERT INTO TESTJRN/TESTABLE VALUES(2, ‘Berthoin’, ‘Younes’,
current timestamp) ;
INSERT INTO TESTJRN/TESTABLE VALUES(3, ‘Mbappé’, ‘Kilian’, current
timestamp) ;
INSERT INTO TESTJRN/TESTABLE VALUES(4, ‘Chombier’, ‘Patrice’,
current timestamp) ;
UPDATE TESTJRN/TESTABLE SET PRENOM = ‘Robert’ WHERE NUMERO = 4;
DELETE FROM TESTJRN/TESTABLE WHERE NUMERO =3 :
— génération de la fonction table spécifique à votre fichier
VALUES QSYS2.CREATE_DATA_JOURNAL_READER(LIBRARY_NAME => ‘TESTJRN’,
FILE_NAME => ‘TESTABLE’,
OUTPUT_LIBRARY => ‘TESTJRN’);


— Utilisation de la fonction générée
SELECT * FROM TABLE (TESTJRN.DISPLAY_JOURNAL_TESTJRN_TESTABLE());

bien sur vous pouvez mettre des filtres sur l’affichage
Les liens à connaitre
https://www.ibm.com/support/pages/qsys2createdatajournalreader
https://www.ibm.com/docs/en/i/7.6.0?topic=function-using-data-journal-reader
Vous avez tous entendu parlé de entendu RPGUNIT
C’est un projet qui a eu plusieurs Vies, il existe même un plugin RDI et une extension vscode
C’est un projet qui permet de faire des tests unitaires sur des fonctions ILE
Il est basé sur les « assertions »
En informatique c’est une vérification intégrée dans le code qui s’assure qu’une condition spécifique est vraie à un moment donné de l’exécution du programme
Exemple :
2+2 ca doit faire 4
https://fr.wikipedia.org/wiki/Assertion
Voici un petit exemple
D’abord vous devez installer une version de la bibliothèque RPGUNIT sur votre systéme, cette bibliothèque contient le Framework qui va permettre de mettre en œuvre vos tests
Vous devrez avoir un programme service et connaitre la fonction à tester
Vous allez créer un programme de service spécifique qui va créer des surcouche à vos fonction
Exemple :
Fonction calcul dans votre application deviendra Fonction test_calcul dans le programme de service RPGUNIT
Votre programme CALCUL ici dans la bibliothèque DEMOUNIT
**free
ctl-opt nomain;
dcl-proc Addition export;
dcl-pi *n int(10);
a int(10) const;
b int(10) const;
end-pi;
return a + b;
end-proc;
Génération de votre programme de service
CRTRPGMOD MODULE(DEMOUNIT/CALCUL)
SRCFILE(DEMOUNIT/QRPGLESRC)
CRTSRVPGM SRVPGM(DEMOUNIT/CALCUL)
MODULE(DEMOUNIT/CALCUL)
EXPORT(*ALL)
Vous devrez coder un programme de service RPGUNIT qui ressemblera à ca
Une hypothèse avec un cas vrai et une erreur
**free
ctl-opt nomain;
/include RPGUNIT/QINCLUDE,ASSERT
dcl-pr Addition int(10);
a int(10);
b int(10);
end-pr;
dcl-proc testAddition export;
iEqual(
5 :
Addition(2:3)
);
end-proc;
// Test volontairement en erreur
dcl-proc testErreur export;
iEqual(
10 :
Addition(2:3)
);
Pour générer votre programme
CRTRPGMOD MODULE(DEMOUNIT/TESTCALC)
SRCFILE(DEMOUNIT/QRPGLESRC)
CRTSRVPGM SRVPGM(DEMOUNIT/TESTCALC)
MODULE(TESTCALC)
BNDSRVPGM(DEMOUNIT/CALCUL RPGUNIT/RUTESTCASE)
EXPORT(*ALL)
ou par RPGUNIT/RUCRTRPG , mais attention au liage ???
Vous devrez ensuite lancer le contrôle par la commande
==>RPGUNIT/RUCALLTST TESTCALC
Vous obtenez un spool RPGUNIT
Exemple :
*** Tests of TESTCALC ***
Date : 2026-07-23 / 15:41:45
Job : 935696/PLB/QPADEV002D
User : PLB
iRPGUnit : v6.0.0.v
IBM i : V7R6M0
Cur. library: PLB
Library list: 10 RPGUNIT 60 OUTILS
20 DEMOUNIT 70 TOOLS
30 QGPL
40 QTEMP
50 EXPLOIT
TESTERREUR - FAILURE
Expected 10, but was 5.
TESTERREUR (TESTCALC->TESTCALC:888)
Expected: 1 '10'
Actual: 1 '5'
-----------------------
FAILURE. 3 test cases, 2 assertions, 1 failure, 0 error.
ici on a bien validé nos 2 caseq
Les sources et outil de référence se trouvent ici
https://irpgunit.sourceforge.io/
https://github.com/Tools-400/irpgunit
Remarque :
Vous avez pouvez faire des choses plus évoluées et VSCODE vous offre un assistant pour générer le programme RPGUNIT de Test, mais je pense qu’il est important de comprendre ce qu’on fait
Les assertions sont inclues en standard dans la TR2 en V7R6 pour le RPGLE
https://www.ibm.com/support/pages/node/7276258
Site pour les extensions
iRPGUnit Plug-in Update Site RDi 9.6.0.13+
https://tools-400.github.io/irpgunit/update-site/eclipse/rdi8.0
Merci à Florian pour son aide !


