Série Sports de combat et IBM i : le judo

Franchement un titre à attirer les clics ! Quel rapport entre des sports où des gens se mettent des coups, s’étranglent,  se projettent et notre métier, si valorisant, si doux, dur parfois mais moins sanglant et brutal ?

Rien…et beaucoup quand même.

Pour ceux qui me connaissent, vous n’apprendrez rien mais pour les autres, j’ai passé beaucoup de temps sur les tatamis et autres salles à pratiquer des sports de combat. Et ce, depuis plus longtemps que je ne pratique l’informatique, bien que tombé dedans tout petit, avec les TO7, Amstrad CPC6128, Sinclair ZX81 Spectrum et autres avant de succomber aux sirènes du marché de l’emploi et à celles moins connues à l’époque des AS400 (eh oui, cela s’appelait bien des AS400 !).

Et une comparaison s’impose.

Le Judo

Je me souviens de moi, jeune judoka, m’entraînant à Lyon, 10 heures ou plus par semaine. En pleine poussée de testostérone mes camarades et moi-même regardions en nous moquant un peu quand même, Jacky et Raymond. Deux vieux judokas qui s’époumonaient dans le fond lors des échauffements, qui commençaient la séance par faire du sol avec des petits jeunes et qui peinaient à reprendre leur souffle après mais qui immanquablement recommençaient, séance après séance, à prendre ces petits jeunes pour les faire forcer au sol, au risque de se provoquer un infarctus. Bon, certaines de leurs techniques n’étaient plus d’actualités, dépassées et même dangereuses ou interdites.

Et de l’autre côté, nous, les ceintures noires, nous l’élite du club, ensemble en train de discuter, de s’entraîner entre nous. Bon, je n’ai jamais été très « élitiste ». L’entre-soi n’est pas ce que je préfère. Mais en ces temps pas si reculés, quand vous obteniez votre ceinture noire au prix de nombreuses souffrances, de fractures, de sacrifices personnels et de déceptions maintes fois répétées devant l’échec, il semblait justifié de savourer ce moment de gloire.

Etant très proche de mon professeur de l’époque, Maître Roger Bourgery, j’appris que Raymond, pour ne parler que de lui, avait été mainte fois champion d’Algérie en Judo. Après l’indépendance, Raymond était venu en France poursuivre sa vie et continuer le Judo en gagnant encore quelques titres de gloire.

Maître Bourgery, mon professeur, nous rappela un précepte fondateur du judo : Jita Kyoei « entraide et prospérité mutuelle ». Et j’avoue que je pris comme mes camarades ceintures noires une bonne claque. L’entre-soi égoïste des jeunes coqs versus l’entraide des anciens, la transmission du savoir.

J’ai été ce que vous êtes, vous serez ce que je suis.  Nos vies n’ont pas changé du jour au lendemain, je donnais déjà des cours de judo aux enfants et ados, pratiquement tous les soirs, mais certaines règles furent instaurées à l’entraînement : interdiction de refuser l’invitation d’une ceinture moins élevée, pour les combats ou pour l’entraînement. Il faut aussi donner pour recevoir et redonner ce que nous avions reçu.

L’humilité c’est aussi de reconnaître que l’on ne sait pas tout et que l’on peut aussi apprendre de ces ceintures moins élevées. En y repensant, maintenant que je suis moins frais et moins sportif, j’ai un autre regard sur ces vieux qui traînent dans un coin du bureau, qui font encore du GAP II ou du COBOL, qui se coltinent du colonné, du  Matching, des fichiers Primaires et secondaires, voir du 36 !  Je dois me rappeler que ces vieux (et vieilles) ont été par le passé, souvent, des précurseurs de l’AS400 en remplaçant le cycle gap, en créant des sous-fichiers, en mettant de la couleur sur leurs écrans, que sais-je encore.

Ce sont ces mêmes personnes qui ne sont plus up-to-date, mais qui transmettent encore des notions. On a eu récemment un client qui est passé d’un environnement 36 à du plus…moderne. Nos « vieux briscards » ont retroussé les manches, et leur connaissance de « l’ancien temps » et des ponts pour arriver aux « temps modernes » ont été mis à contribution. Ils ont été utiles pour faire le lien et montrer « leur » métier.

Mais ils savent nous rappeler que si on bâtit sur le passé, cela reste « le passé ». On ne vit pas dans le passé, on vit avec. Il n’y a pas de « c’était mieux avant ». Il y a du « c’était comme cela avant mais maintenant on fait autrement et peut-être mieux ».

Pour finir, nous ne sommes pas tous des ceintures noires de l’IBM i, loin de là. Et certains anciens pensent encore que « c’était mieux avant » et deviennent des spécialistes…du passé. 

Mais même si nous sommes des ceintures marrons, noires des années 90 ou des années 2000, 2010, 2020… il y a plein de ceintures blanches qui frappent à nos portes, qui peuvent et doivent apprendre.

Pas apprendre que c’était mieux avant, mais qu’il y avait un « avant » et surtout un « après » et que cet « après » ne soit pas une fin en soi. Que cet « après » deviendra un « c’était le bon temps » pour ceux qui sont les jeunes ceintures noires d’aujourd’hui. A nous de transformer notre pouvoir en un savoir à dispenser.

Attention, ce n’est pas un chant du cygne. C’est juste un rappel, comme dans mes années de judoka, que notre communauté est composée de ceintures de tous niveaux, de tous âges et que « l’entraide et la prospérité mutuelle » est une très belle notion à mettre en pratique.

C’est aussi un rappel aux anciens de leurs devoirs : transmettre et continuer à apprendre.

, , , Clé, contrainte et index : quelles différences ?

Dans une base de données bien définie, nos enregistrements sont identifiés par des clés (ie unique). Il existe toutefois différentes façon de matérialiser ces clés en SQL.

Première bonne résolution : on ne parlera pas ici des DDS (PF/LF) !

Quelques rappels

je n’insiste pas, mais une base de donnée relationnelle, DB2 for i dans notre cas, fonctionne à la perfection, à condition de pouvoir identifier nos enregistrements par des clés.

Cf https://fr.wikipedia.org/wiki/Forme_normale_(bases_de_donn%C3%A9es_relationnelles)

Une normalisation raisonnable pour une application de gestion est la forme normale de Boyce-Codd (dérivée de la 3ème FN).

Clés

Vous pouvez implémenter vos clés de différentes façons, voici une synthèse :

TypeSupport valeur nulle ?Support doublon ?Commentaire
Contrainte de clé primaireTableNonNonValeur nulle non admise, même si la colonne clé le supporte
Contrainte d’unicitéTableOuinon : valeurs non nulles
oui : valeurs nulles
Gère des clés uniques uniquement si non nulles
Index uniqueIndexOuiNonGère des clés uniques.
La valeur NULL est supportée pour 1 unique occurrence
Index unique where not nullIndexOuisnon : valeurs non nulles
oui : valeurs nulles
Gère des clés uniques uniquement si non nulles

Attention donc à la définition de UNIQUE : à priori ce qui n’est pas NULL est UNIQUE.

Concrètement ?

Prenons un cas de test simpliste pour montrer la mécanique : un fichier article avec une clé et un libellé

Clé primaire

La colonne CODE admet des valeurs nulles, mais est fait l’objet de la contrainte de clé primaire.

A la création de la contrainte de clé primaire, le système créé automatiquement une contrainte de type CHECK pour interdire l’utilisation de valeur nulle dans cette colonne :

Avec :

La clé primaire joue son rôle avec des valeurs non nulles :

Et des valeurs nulles :

On retrouve ici le nom de la contrainte générée automatiquement !

Avec une contrainte de clé unique ?

Le comportement est identique sur une clé non nulle.

Mais avec une clé nulle (ou dont une partie est nulle si elle composée) :

On peut ajouter un index unique pour gérer le problème. Dans ce cas, une et une seule valeur nulle sera acceptée :

Mais dans ce cas pourquoi ne pas utiliser une clé primaire ??

Clé étrangère, jointure

Ajoutons un fichier des commandes, ici une simplification extrême : 1 commande = 1 article.

On ajoute une contrainte de clé étrangère qui matérialise la relation entre les tables commande et article. Pour cette contrainte commande_FK, il doit exister une contrainte de clé primaire ou de clé unique sur la colonne CODE dans la table article.

La contrainte se déclenche si l’article référencé n’existe pas :

Cas identique mais en s’appuyant sur la table article_unique qui dispose d’une clé unique et non primaire :

Dans ce cas les valeurs nulles sont supportées, en multiples occurrences (sauf à ajouter encore une fois un index unique au niveau de la commande).

Récapitulons ici nos données pour comprendre les jointures :

Démarrons par ARTICLE & COMMANDE :

La table ARTICLE ne peut pas avoir de clé nulle, donc pas d’ambiguïté ici

Avec right join ou full outer join nous accèderons au lignes de commande pour lesquelles CODE = null.

C’est le comportement attendu.

Voyons avec ARTICLE_UNIQUE et COMMANDE :

Ici on pourrait s’attendre à obtenir également les lignes 11 et 12 de la table COMMANDE : le CODE est nulle pour celles-ci, mais il existe une ligne d’ARTICLE pour laquelle le code est null. Il devrait donc y avoir égalité.

En réalité les jointures ne fonctionnent qu’avec des valeurs non nulles

De même que la clause WHERE :

Il faut donc utiliser ce style de syntaxe :

C’est à dire :

  • soit remplacer les valeurs nulles par des valeurs inexistantes dans les données réelles
  • soit explicitement indiquer la condition de nullité conjointe

Bref, syntaxiquement cela va rapidement se complexifier dans des requêtes plus évoluées.

Clé composée

Evidemment, c’est pire ! Imaginons que l’on ait une clé primaire/unique dans la table ARTICLE composée de 2 colonnes (CODE1, CODE2), et donc présentes toutes les deux dans la table COMMANDE :

Et les performances ?

En utilisant la jointure, l’optimiseur est capable de prendre en charge des accès par index :

Mais en utilisant IFNULL/COALESCE, ces valeurs deviennent des valeurs calculées, ce qui invalide l’usage des index :

Ce n’est donc pas viable sur des volumes plus importants. Il existe des solutions (index dérivés par exemple) mais la mécanique se complique encore !

Préconisations

De façon générale pour vos données de gestion, en excluant les fichier de travail (QTEMP a d’autres propriétés), les fichiers de logs, les fichier d’import/export …

  • Pas de valeur NULL dans vos clés
    • Pour les clés atomique c’est une évidence, pour les clés composées c’est beaucoup plus simple
  • Une contrainte de clé primaire pour toutes vos tables !
    • N’hésitez pas à utiliser des clés auto-incrémentées
  • Des contraintes d’unicités ou des index uniques pour vos autres contraintes d’unicité, techniques ou fonctionnelles
    • Pas d’excès, sinon il y a un défaut de conception (cf les formes normales)
  • Si possible des contraintes de clé étrangère pour matérialiser les relations entre les tables
    • Délicat sur l’existant, les traitements doivent tenir compte du sens de la relation
  • Favorisez l’usage des clés, contraintes et index par l’optimiseur
    • Scalabilité entre vos environnements de développement/test et la production
, , , Gérer vos listes de validation avec SQL !

Vous connaissez bien désormais les services SQL qui vous permettent d’administrer de plus en plus facilement votre IBM i.

IBM fournit des services pour gérer les listes de validation :

Mais rien pour faire la liste des entrées, comme on peut trouver dans l’administration HTTP par exemple.

Nous vous proposons donc une fonction table SQL permettant d’avoir l’intégralité de la gestion via DB2 : cf https://github.com/FrenchIBMi/Outils/tree/master/Validation%20List

Cela permet de revenir sur le principe de l’implémentation via du code RPG :

  • Le code est basé sur les APIs QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry
  • Le moteur DB2 appelle l’implémentation :
    • 1 appel initial
    • 1 appel par poste de liste à retourner
    • 1 appel final

Nous utilisons __errno pour retrouver les codes erreur de l’APIs. Les différentes valeurs sont déclarées sous forme de constante.

La fonction SQL retourne les SQL STATE suivants :

  • 02000 lorsque l’on attend la fin des données (fin normale)
  • 38999 pour les erreurs. Cette valeur est arbitraire

Si possible, nous retrouvons le libellé de l’erreur retournée par l’API via strerror et on le retourne à DB2.

Code RPG :

**free

// Compilation / liage :
// CRTRPGMOD MODULE(NB/VLDLUDTF) SRCFILE(NB/QRPGLESRC) 
//           OPTION(*EVENTF) DBGVIEW(*SOURCE)
// CRTSRVPGM SRVPGM(NB/VLDLUDTF) EXPORT(*ALL) ACTGRP(*CALLER)

// Implémentation de la fonction UDTF VALIDATION_LIST_ENTRIES
// Liste les entrées d'une liste de validation
// Utilise l'API QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry

// @todo :
// - ajouter le support de la conversion de CCSID
// - améliorer la gestion des erreurs


ctl-opt nomain option(*srcstmt : *nodebugio) ;


// Déclarations pour APIs : QsyFindFirstValidationLstEntry et QsyFindNextValidationLstEntry

dcl-ds Qsy_Qual_Name_T qualified template ;
  name char(10) inz ;
  lib  char(10) inz ;
end-ds ;

dcl-ds Qsy_Entry_ID_Info_T qualified template ;
  Entry_ID_Len int(10) inz ;
  Entry_ID_CCSID uns(10) inz ;
  Entry_ID    char(100) inz ;
end-ds ;

dcl-ds Qsy_Rtn_Vld_Lst_Ent_T qualified template ;
  dcl-ds Entry_ID_Info likeds( Qsy_Entry_ID_Info_T) inz ;

  dcl-ds Encr_Data_Info ;
    Encr_Data_len   int(10) inz;
    Encr_Data_CCSID uns(10) inz;
    Encr_Data       char(600) inz ;
  end-ds ;

  dcl-ds Entry_Data_Info  ;
    Entry_Data_len   int(10) ;
    Entry_Data_CCSID uns(10) ;
    Entry_Data       char(1000) ;
  end-ds ;

  Reserved          char(4) inz ;
  Entry_More_Info   char(100) inz ;
end-ds ;

dcl-pr QsyFindFirstValidationLstEntry int(10) extproc('QsyFindFirstValidationLstEntry');
  vldList       likeds(Qsy_Qual_Name_T) const ;
  vldListEntry  likeds(Qsy_Rtn_Vld_Lst_Ent_T) ;
end-pr ;

dcl-pr QsyFindNextValidationLstEntry int(10) extproc('QsyFindNextValidationLstEntry');
  vldList       likeds(Qsy_Qual_Name_T) const ;
  entryIdInfo   likeds(Qsy_Entry_ID_Info_T)   ;
  vldListEntry  likeds(Qsy_Rtn_Vld_Lst_Ent_T) ;
end-pr ;

// Retrouver le code erreur de l'API
dcl-pr getErrNo int(10) ;
end-pr ;
// Code erreur
dcl-c EACCES   3401 ;
dcl-c EAGAIN   3406 ;
dcl-c EDAMAGE  3484 ;
dcl-c EINVAL   3021 ;
dcl-c ENOENT   3025 ;
dcl-c ENOREC   3026 ;
dcl-c EUNKNOWN 3474 ;

// Retrouver le libellé du code erreur
dcl-pr strError pointer extproc(*CWIDEN : 'strerror') ;
  errNo int(10) value ;
end-pr ;

// gestion UDTF
dcl-c CALL_OPEN     -1;
dcl-c CALL_FETCH     0;
dcl-c CALL_CLOSE     1;
dcl-c PARM_NULL     -1;
dcl-c PARM_NOTNULL   0;


// Liste les entrées de la liste de validation
// ==========================================================================
dcl-proc vldl_list export ;

// Déclarations globales
  dcl-s  ret int(10) inz ;
  dcl-s  errno int(10) inz ;
  dcl-ds vldListEntry likeds(Qsy_Rtn_Vld_Lst_Ent_T) inz static ;
  dcl-ds vldlname  likeds(Qsy_Qual_Name_T) inz          static ;
  dcl-s  first ind inz(*on)                             static ;


  dcl-pi *n ;
    // input parms
    pvldl_lib  varchar(10) const ;
    pvldl_name varchar(10) const ;
    // output columns
    pEntry_ID    varchar(100) ;
    pEntry_Data  varchar(1000) ;
    // null indicators
    pvldl_lib_n    int(5) const ;
    pvldl_name_n   int(5) const ;
    pEntry_ID_n    int(5)       ;
    pEntry_Data_n  int(5)       ;
    // db2sql
    pstate    char(5);
    pFunction varchar(517) const;
    pSpecific varchar(128) const;
    perrorMsg varchar(1000);
    pCallType int(10) const;
  end-pi ;


// Paramètres en entrée
  if pvldl_name_n = PARM_NULL or pvldl_lib_n = PARM_NULL;
    pstate = '38999' ;
    perrorMsg = 'VALIDATION_LIST_LIBRARY ou VALIDATION_LIST_NAME est null' ;
    return ;
  endif ;

  select;
    when ( pCallType = CALL_OPEN );
    // appel initial : initialisation des variables statiques
      vldlname.name = pvldl_name ;
      vldlname.Lib  = pvldl_lib ;
      clear vldListEntry ;
      first = *on ;

    when ( pCallType = CALL_FETCH );
    // retrouver l'entrée suivante
      exsr doFetch ;

    when ( pCallType = CALL_CLOSE );
    // rien à faire

  endsl;


  // traitement de l'entrée suivante
  begsr doFetch ;
    if first ;
      ret = QsyFindFirstValidationLstEntry( vldlname : vldListEntry);
      first = *off ;
    else ;
      ret = QsyFindNextValidationLstEntry( vldlname :
                                           vldListEntry.Entry_ID_Info : vldListEntry);
    endif ;

    if ret = 0 ;
      // Entrée trouvée
      monitor ;
        pEntry_ID   = %left(vldListEntry.Entry_ID_Info.Entry_ID :
                          vldListEntry.Entry_ID_Info.Entry_ID_Len);
        pEntry_Data = %left(vldListEntry.Entry_Data_Info.Entry_Data :
                          vldListEntry.Entry_Data_Info.Entry_Data_len) ;
        pEntry_ID_n   = PARM_NOTNULL ;
        pEntry_Data_n = PARM_NOTNULL ;
      on-error ;
        // Erreur de conversion
        pstate = '38999' ;
        perrorMsg = 'Erreur de conversion' ;
      endmon ;
    else ;
      // Entrée non trouvée : erreur ou fin de lecture
      errno = getErrNo() ;
      select ;
        when errno in %list( ENOENT : ENOREC ) ; // fin de lecture
          pstate = '02000' ;
          return ;
        other ; // Erreur
          pstate = '38999' ;
          perrorMsg = %str(strError(errno)) ;
      endsl ;
    endif ;
  endsr ;

end-proc ;



// Retrouver le code erreur de l'API
dcl-proc getErrNo ;

  dcl-pr getErrNoPtr pointer ExtProc('__errno') ;
  end-pr ;

  dcl-pi *n int(10) ;
  end-pi;

  dcl-s errNo int(10) based(errNoPtr) ;

  errNoPtr = getErrNoPtr() ;
  return errNo ;

end-proc;

Code SQL :

set current schema = NB ;
set path = 'NB' ;

Create or replace Function VALIDATION_LIST_ENTRIES ( 
                  VALIDATION_LIST_LIBRARY  varchar(10),
                  VALIDATION_LIST_NAME     varchar(10) )
               Returns Table                    
               (                   
                 VALIDATION_USER   varchar(100),                   
                 ENTRY_DATA        varchar(1000)
               )                
               external name 'VLDLUDTF(VLDL_LIST)'                
               language rpgle                
               parameter style db2sql                
               no sql                
               not deterministic                
               disallow parallel;


cl: DLTVLDL VLDL(NB/DEMO) ;
cl: CRTVLDL VLDL(NB/DEMO) TEXT('Démo VALIDATION_LIST_ENTRIES')   ;

VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 1',
                             PASSWORD                => 'MDP user 1',
                             ENTRY_DATA              => 'Client 1'));
VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 2',
                             PASSWORD                => 'MDP user 2',
                             ENTRY_DATA              => 'Client 1'));
VALUES SYSTOOLS.ERRNO_INFO(SYSTOOLS.ADD_VALIDATION_LIST_ENTRY(
                             VALIDATION_LIST_LIBRARY => 'NB', 
                             VALIDATION_LIST_NAME    => 'DEMO',
                             VALIDATION_USER         => 'user 3',
                             PASSWORD                => 'MDP user 3',
                             ENTRY_DATA              => 'Client 2'));

select * from table(VALIDATION_LIST_ENTRIES( VALIDATION_LIST_LIBRARY => 'NB',
                                             VALIDATION_LIST_NAME    => 'DEMO' )) ;

Cela produit :

Libre à vous maintenant d’utiliser ce résultat pour jointer avec vos fichiers de log HTTP (autorisation basique sur une liste de validation par exemple), avec le service USER_INFO_BASIC, croiser les profils présents dans vos différentes listes …

, , Fonction usage / Exit programme

Vous êtes de plus en plus confronter à la mise en place de sécurité sur des services (ODBC, FTP, etc..)
il existe 2 solutions sur l’ibmi qui vont vous aider dans votre démarche

Les fonctions usage et les exit programmes

Vous avez des interfaces 5250 pour les administrer, mais aussi maintenant Navigator for i
WRKFCNUSG et WRKREGINF
Vous avez également des services SQL
QSYS2.SQL_CHECK_FUNCTION_USAGE(), QSYS2.FUNCTION_USAGE, QSYS2.FUNCTION_INFO
QSYS2.EXIT_POINT_INFO,QSYS2.EXIT_PROGRAM_INFO

Rapidement voici une petite comparaison

D’abord un essai de comparaison entre les principales valeurs

Accès / FonctionnalitéFonction d’usage (Function Usage ID)Programme d’exit (Exit Point)Description / Concerne
Accès base de données (ODBC, JDBC…)QIBM_DB_OPENQIBM_QZDA_INIT, QIBM_QZDA_NDB1Autorise/refuse l’ouverture de base de données (SQL, ODBC, etc.)
SQL Server Mode (QSQSRVR)QIBM_DB_QSQSRVRN/AContrôle l’accès aux jobs QSQSRVR (SQL server mode)
DDM/DRDAQIBM_DB_DDMDRDAQIBM_QDDMDRDASERVER, QIBM_QDDSQLDRDAAccès aux bases via DDM / DRDA
ODBC SpécifiqueN/AQIBM_QZDA_SQL1, QIBM_QZDA_INITAppels SQL via ODBC / DRDA
JDBCN/AQIBM_QZDA_SQL1, QIBM_QZDA_INITJDBC via Toolbox ou Native JDBC
FTPQIBM_FTP_SERVERQIBM_QTMF_SVR_LOGON, QIBM_QTMF_SVR_EXITContrôle l’accès FTP
TelnetQIBM_TELNET_SERVERQIBM_QTV_TELNETContrôle l’accès Telnet
Remote Command (RUNRMTCMD)QIBM_NETWORK_SERVERQIBM_QZRC_RMTExécution de commandes distantes
Client Access (iSeries Access, ACS…)QIBM_ACCESS3270, QIBM_DB_OPENQIBM_QZDA_* (exits ODBC), QIBM_QZRC_RMTAccès via IBM i Access clients (ODBC, FTP, etc.)

Fonctions d’usage (Function Usage) :
Elles permettent d’activer ou de restreindre une fonctionnalité par utilisateur (sans programmation).
Elles ont un mode par défaut ouvert ou fermé
Vous devez ensuite gérer les exceptions à cette règle
C’est en œuvre par défaut sur votre système
C’est dynamique vous pouvez par exemple avoir un scripte qui modifie le paramétrage pour les heures HNO
C’est compliquer pour tracer les refus

Exit Programs (Programmes d’exit) :
Permettent une personnalisation des contrôles d’accès .
Vous pouvez indiquer des critères d’actions, de ressources, de temporalité
exemple, Michel à droit à uniquement le bibliothèque compta en HNO
Vous maitrisez entièrement la logique de contrôle
Vous pouvez auditer ou loguer avant d’interdire par exemple
Vous pouvez impacter les performances de votre système avec un mauvais programme, voir même bloquer sur un plantage
Ce n’est pas en œuvre par défaut sur votre système
Ce n’est pas dynamique vous devrez arrêter le service concerné pour une prise en compte
Simple pour tracer les refus, c’est votre programme

Conclusion
J’espère que ca vous aidera à faire votre choix
dans tous les cas c’est absolument indispensable aujourd’hui de se préoccuper de ces problèmes à minima des accès ODBC

Toujours d’actualité un service qui n’est pas utilisé doit être arrêter

Quand vous passez de FTP à SFTP vous ne bénéficier plus de ces 2 options

S’affranchir des noms courts en RPG

L’utilisation des noms longs dans le code RPG est un atout supplémentaire pour le rendre plus lisible et en faciliter la maintenance.

On continue malheureusement trop souvent à utiliser les noms courts hérités de nos bases de données et du code RPG colonné, même converti en Free.

Pourtant, l’utilisation des alias dans les DDS et les déclaratives RPG ainsi que la redéfinition des indicateurs, permettent de s’affranchir totalement des noms courts au profit des noms longs.

Utilisez le mot clé ALIAS dans les DDS

Le mot-clé ALIAS permet d’associer un nom long à un champ très souvent nommé avec seulement 6 caractères, et maximum 10 caractères

ALIAS dans un PF

Exemple avec un fichier sans ALIAS :

.

.

.

Le mot clé ALIAS peut être rajouté dans les DDS de vos fichiers sans aucun impact sur vos applications :

.

.

Les ALIAS peuvent être appliqués sans perte de données par un CHGPF :

CHGPF FILE(LC/CLIENT) SRCFILE(LC/QDDSSRC) SRCMBR(CLIENT)

Cette opération ne modifie pas le niveau de format du fichier, pas de recompilation des applications

.

.

.

.

ALIAS dans un DSPF

Dans vos écrans 5250, vous pouvez aussi associer des noms longs aux noms courts sous forme d’ALIAS.

Les ALIAS longs peuvent être utilisés dans le code RPG à la place des noms courts.

.

Utilisez le mot clé ALIAS dans la déclaration d’ouverture du fichier

Il vous permet d’utiliser les ALIAS du fichier en tant que noms de variables, dans le code RPG

.

.

Utilisez le mot clé ALIAS dans la déclaration d’une DS externe

Il vous permet d’utiliser les ALIAS du fichier externe de la DS en tant que noms de variables, dans le code RPG

.

.

Noms longs et noms courts dans une table SQL

Lorsque vous créez une table SQL, vous lui attribuez un nom long SQL mais vous pouvez aussi lui attribuer un nom court de votre choix par la clause SYSTEM NAME afin d’éviter que le système ne lui attribue un nom court par défaut.

Pour la même raison, il est conseillé d’attribuer à chaque colonne un nom court en plus du nom long, par la clause FOR COLUMN

.

Dans le code RPG, vous pouvez déclarez la DS de votre table pour qu’elle utilise les noms courts (sans mot clé ALIAS) ou les noms longs (avec le mot clé ALIAS) :

Déclaration d’une DS externe pour une table SQL avec utilisation des noms courts

.

Déclaration d’une DS externe pour une table SQL avec utilisation des noms longs

.

Renommez les indicateurs *INxx

Vous pouvez vous affranchir des indicateurs *INxx dans le code RPG en les renommant :

.

, , Conserver des informations avant migration

Vous changez de machine ou de version et les dates de référence de vos objets et vos sources vont être remise à zéro,
grâce aux services SQL , vous pouvez facilement conserver temporairement ces informations

Vous pourrez par exemple avoir besoin de ces informations pour faire une analyse d’impact sur l’utilisation de certain programmes ou de sources

Pour garder une trace de ces informations voici ce que vous pouvez faire

créer une bibliothèque

==> CRTLIB MIGRATION

vous avez intérêt à extraire les informations juste avant la migration

1) Sur les objets

Vous pouvez utiliser la fonction table QSYS2.OBJECT_STATISTICS

exemple :

create table migration.lstobj as(
SELECT * FROM TABLE (
QSYS2.OBJECT_STATISTICS(‘ALL’,’ALL’) ) AS X
) with data

Vous pouvez si vous le voulez choisir ou éliminer des objets ou des bibliothèques.

2) sur les sources

Si vous avez des fichiers sources QRPGLESRC, QCLSRC etc …

Vous pouvez utiliser la vue QSYS2.SYSPARTITIONSTAT

exemple :

create table migration.lstsrc as(
SELECT *
FROM qsys2.SYSPARTITIONSTAT WHERE
not source_type is null and NUMBER_ROWS > 0
) with data

ici on limite aux membres sources non vide

Si vous avez des fichiers sources dans L’ifs, nodejs, php, python, ou même des développements traditionnels en RPGLE ou CLLE

Vous pouvez utiliser la fonction table QSYS2.IFS_OBJECT_STATISTICS

exemple :

create table migration.lstifs1 as(
SELECT *
FROM TABLE (
qsys2.ifs_object_statistics(
start_path_name => ‘/Votre_repert/’ ,
subtree_directories => ‘YES’
)
)
) with data

Vous devrez limiter à vos repertoires de sources , vous pouvez en faire plusieurs

Ensuite vous devrez envoyer votre bibliothèque sur le systéme cible

Soit par la migration naturelle qui emmènera toutes les bibliothèques ou par une opération spécifique d’envoi de la bibliothèque FTP, SAVRSTLIB etc…

Attention :

Après 6 mois cette bibliothèque devra être supprimée, elle ne servira plus à rien

Remarque :

Vous pouvez également inclure dans cette bibliothèque d’autres éléments qui pourront être utile comme :

La liste des valeurs systèmes , QSYS2.SYSTEM_VALUE_INFO
Le planning des travaux , QSYS2.SCHEDULED_JOB_INFO
les programmes d’exit , QSYS2.EXIT_PROGRAM_INFO
les watchers , QSYS2.WATCH_INFO
les bases de données DRDA , QSYS2.RDB_ENTRY_INFO
les reroutages de travaux , QSYS2.ROUTING_ENTRY_INFO
la table des réponses par défaut , QSYS2.REPLY_LIST_INFO
etc …

, Débuter avec les webservices

Vous voulez commencer à utiliser des webservices en étant consommateur à partir de votre partition IBMi
Et vous de ne savez pas par ou commencer voici un exemple très simple, prêt à l’emploi que vous pourrez améliorer
on a choisi le site jsonplaceholder.typicode.com qui permet un accès libre , merci à eux
On peut l’utiliser à partir d’un GET et le flux renvoyé est du JSON
On utilisera la fonction QSYS2.HTTP_GET de la manière la plus basic
On parsera le flux recu en utilisant la fonction JSON table

2 prérequis :

Vous devrez avoir une version V7R4

Votre partition devra sortir vers le site jsonplaceholder.typicode.com

**free
ctl-opt dftactgrp(*no) actgrp(*caller);
// Un exemple simple d'un appel de webservice
// on utilise le site   jsonplaceholder.typicode.com
// Vous avez les numéros de 1 à 11
// Le flux renvoyé est du JSON on le parse dans une deuxième requête
//
dcl-s url varchar(256) inz('https://jsonplaceholder.typicode.com/users/1');
dcl-s Response Varchar(10000);
dcl-s nom varchar(100);
dcl-s email varchar(100);
dcl-s ville varchar(100);
dcl-s erreur varchar(200);
// Utilisation de la fonction QSYS2.HTTP_GET
exec sql
 set :response = QSYS2.HTTP_GET(:url) ;
if sqlcode <> 0;
  erreur = 'Erreur appel HTTP_GET : SQLCODE = ' + %char(sqlcode);
  SND-MSG *INFO erreur;
  return;
endif;
// Parsing du JSON avec JSON_TABLE
exec sql select name, email, address_city into
:nom, :email, :ville
 from json_table(
:response, '$' columns ( name varchar(100) path '$.name',
                         email varchar(100) path '$.email',
                         address_city varchar(100) path '$.address.city' ) ) as JT;
if sqlcode <> 0;
  erreur = 'Erreur parsing JSON : SQLCODE = ' + %char(sqlcode);
  SND-MSG *INFO erreur;
  return;
endif;
// Affichage du résultat
SND-MSG *INFO ('Nom : ' + nom);
SND-MSG *INFO ('Email : ' + email);
SND-MSG *INFO ('Ville : ' + ville);
// Fin de traitement
return;

.

Conclusion

Simple et efficace

Vous voyez qu’une connaissance de JSON et indispensable et donc au moins une V7R4

Appeler un webservice c’est assez simple
Attention la mise au point dans certains cas peut être compliqué
les idées d’amélioration seront :
Tester le httpstatus qui peut être renvoyer dans le Header
Parser le flux directement dans la requete http_get

etc …

Pour en savoir plus adressez vous à mes collègues qui sont des spécialistes

Une liste de sites libres pour vous entrainer

Une citation du philosophe Chuck Norris
https://api.chucknorris.io/jokes/random
indispensable, pour bien démarrer la journée


Bored API
https://www.boredapi.com/api/activity
Suggestion d’activité fun


Cat Facts
https://catfact.ninja/fact
Donne un fait amusant sur les chats, pour les « matouvus »


IP API (test IP)
https://ipinfo.io/json

Retourne ton IP, localisation, etc. moins fun mais intéressant

Open-Meteo (météo)
https://api.open-meteo.com/v1/forecast?
Météo gratuite sans clé , les autres nécessitent une clé, vous devrez lui passer des coordonnées

Vous devez échanger un fichier avec un partenaire qui vous le demande au format JSON

Il n’existe pas de CVTJSONxx comme la commande CPYTOIMPF pour le CSV

Pas de panique vous avez des services SQL qui font ceci voici un exemple :

Création d’une table de test

SET SCHEMA = ‘votre base’;
CREATE OR REPLACE TABLE CLIENTS
(
ID_CLIENT INTEGER NOT NULL WITH DEFAULT,
NOM_CLIENT VARCHAR ( 50) NOT NULL WITH DEFAULT,
VILLE VARCHAR ( 50) NOT NULL WITH DEFAULT
) ;
INSERT INTO CLIENTS VALUES(1, ‘Dupont’, ‘Paris’) ;
INSERT INTO CLIENTS VALUES(2, ‘Durand’, ‘Lyon’) ;

Voici la syntaxe qu’il vous faudra utiliser pour le convertir sous forme de flux json

SELECT JSON_OBJECT(
    'id_client' VALUE ID_CLIENT,
    'nom_client' VALUE NOM_CLIENT,
    'ville' VALUE VILLE
)  AS CLIENT_JSON
FROM CLIENTS;   

On utilise la fonction JSON_OBJECT

plus d’information ici

https://www.ibm.com/docs/fr/i/7.5.0?topic=functions-json-object

Maintenant il va falloir générer le fichier .JSON dans l’IFS par exemple en utilisant la procédure IFS_WRITE_UTF8

Malheureusement ce service n’existe pas sous forme de fonction on devra utiliser une des possibilités de SQL « Dynamic compound statement » qui permet de compiler un module dynamiquement

Ce qui donnera donc

BEGIN
    CALL QSYS2.IFS_WRITE_UTF8(
        PATH_NAME => 'PLB_CLIENTS.json',
        LINE => '',
        OVERWRITE => 'REPLACE',
        END_OF_LINE => 'NONE'
    );
    FOR SELECT TRIM(CAST(JSON_OBJECT(
                    'id_client' VALUE ID_CLIENT, 
                    'nom_client' VALUE NOM_CLIENT, 
                    'ville' VALUE VILLE
                ) AS VARCHAR(32000))) AS Line_to_write
        FROM PLB.CLIENTS
        DO
            CALL QSYS2.IFS_WRITE_UTF8(
                PATH_NAME => 'PLB_CLIENTS.json',
                LINE => Line_to_write
            );
    END FOR;
END;   

Si vous avez beaucoup de fichiers à convertir ca peut être fastidieux pas de panique nous avons fait une commande qui va vous aider

https://github.com/Plberthoin/PLB/tree/master/GTOOLS, vous avez l’habitude un source SQLRPGLE et un source CMD à compiler , voila SME

Vous pouvez enregistrer le scripte SQL (CVTFICJSON.SQL) avec l’option Sauvegarder le scripte

Vous pourrez le customiser :

en le formatant par ACS ,

en enlevant des zones

en sélectionnant des enregistrements

etc …

Remarque :

Vous avez une option pour agréger

Vous pouvez faire beaucoup mieux , c’est juste pour vous aider à démarrer dans le domaine

, Contrôler la cohérence des services SQL

On utilise de plus en plus les services SQL sur IBMi

Il peut être important de contrôler les services SQL installés sur votre machine

Vous avez 2 programmes qui sont fournis, nous vous proposons un petit habillage pour vous faciliter leurs utilisations
QSQIBMCHK et QSQSYSIBM

La commande

CMD        PROMPT('Contrôles services SQL')               
 PARM       KWD(TYPE) TYPE(*CHAR) LEN(4) RSTD(*YES) +      
              DFT(*CHK) VALUES(*CHK *FIX) PROMPT('Type +   
              de vérification') 

Le programme CLLE

pgm parm(&type)                                                         
dcl &type *char 4                                                       
dclf qsys/QADSPFFD                                                      
/* Récupération du CCSID de la première zone de qadbxref */             
             DSPFFD     FILE(QSYS/QADBXREF) OUTPUT(*OUTFILE) +          
                          OUTFILE(QTEMP/WADSPFFD) /* w */               
             OVRDBF     FILE(QADSPFFD) TOFILE(QTEMP/WADSPFFD) +         
                          LVLCHK(*NO)                                   
             RCVF                                                       
/* Changement du job au bon CCSID                              */       
             chgjob ccsid(&WHCSID)                                      
/* Pour contrôler les objets fournis par IBM qui sont manquants      */ 
if cond(&type = '*CHK') then(do)                                        
CALL QSYS/QSQIBMCHK                                                     
enddo                                                                   
/* Pour corriger                                                     */ 
if cond(&type = '*FIX') then(do)                                        
CALL QSYS/QSQSYSIBM                                                     
enddo                                                                   
             dltovr     FILE(QADSPFFD)  
endpgm    

Pour contrôler

==>CTLSRVSQL *CHK

Vous allez avoir ces messages dans la LOG

QSQXRLF OBJECTS FOUND = 55
QSQXRLF OBJECTS UNKNOWN = 0
QSQXRLF OBJECTS MISSING = 0
QSQSYSIBM OBJECTS FOUND = 716
QSQSYSIBM OBJECTS UNKNOWN = 0
QSQSYSIBM OBJECTS MISSING = 0
SYSTOOLS OBJECTS FOUND = 105
SYSTOOLS OBJECTS UNKNOWN = 0
SYSTOOLS OBJECTS MISSING = 0
TOTAL IBM OBJECTS FOUND = 876
TOTAL IBM OBJECTS UNKNOWN = 0
TOTAL IBM OBJECTS MISSING = 0
QSQIBMCHK – OBJECT VERIFICATION COMPLETE

Si vous avez des erreurs par exemple 1 dans OBJECTS UNKNOWN vous devrez corriger

Pour corriger

==>CTLSRVSQL *FIX

Vous allez avoir ces messages dans la LOG

QSQSYSIBM ASNEEDED PROCESSING SUCCESSFUL FOR 1236 COMPONENTS.

PS :
Vous n’avez pas besoin d’être en mode restreint
Mais vous devez être *SECADM et *ALLOBJ

Pour en savoir plus
https://www.ibm.com/support/pages/qsqibmchk-tool

Merci Jean-Marie pour le thème suggéré

SQL Pivot Table

Le pivot est une technique que vous permet de faire pivoter la sortie d’une requête de ligne à colonne et inversement.

Comme par exemple transformer ce résultat :

Par ce résultat :

Commençons par la création des tables

Imaginons que nous avons un ancien fichier des tarifs contenant 4 tarifs (dans 4 colonnes pour la table TARIF_H et 4 enregistrements pour la table TARIF_V)

TARIF_H : Table avec des tarifs sur une seule ligne mais dans plusieurs colonnes

CREATE TABLE TARIF_H ( 
	FOURNISSEUR INTEGER DEFAULT 0, 
	ARTICLE VARCHAR(10) CCSID 1208 DEFAULT '' , 
	TARIF1 DECIMAL(14, 6) DEFAULT 0 , 
	TARIF2 DECIMAL(14, 6) DEFAULT 0 , 
	TARIF3 DECIMAL(14, 6) DEFAULT 0 , 
	TARIF4 DECIMAL(14, 6) DEFAULT 0 );

insert into TARIF_H values(1, 'ART1', 14.1, 12.2, 11.3, 10.9);
insert into TARIF_H values(1, 'ART2', 15.6, 15.0, 14.5, 14.0);

TARIF_V : Table avec des tarifs dans une colonne mais sur plusieurs lignes

CREATE TABLE TARIF_V ( 
	FOURNISSEUR INTEGER DEFAULT 0 , 
	ARTICLE VARCHAR(10) CCSID 1208 DEFAULT '' , 
	NUMTARIF DECIMAL(2, 0) DEFAULT 0 , 
	TARIF DECIMAL(14, 6) DEFAULT 0 );

insert into TARIF_V values(1, 'ART1', 1, 14.1);
insert into TARIF_V values(1, 'ART1', 2, 12.2);
insert into TARIF_V values(1, 'ART1', 3, 11.3);
insert into TARIF_V values(1, 'ART1', 4, 10.9);
insert into TARIF_V values(1, 'ART2', 1, 15.6);
insert into TARIF_V values(1, 'ART2', 2, 15.0);
insert into TARIF_V values(1, 'ART2', 3, 14.5);
insert into TARIF_V values(1, 'ART2', 4, 14.0);

Passage d’un affichage horizontal à vertical

Utilisation du mot clé LATERAL pour faire une jointure LATERAL et afficher les tarifs sur plusieurs lignes. Nous allons la combiner avec la fonction VALUE ce qui nous permettra d’ajouter une colonne avec la position du tarif (Tarif colonne 1 = position tarif 1, Tarif colonne 2 = position tarif 2 etc…).

select T.fournisseur, T.article, V.POSITIONTARIF, V.VALEURTARIF
  from FG.TARIF_H as T,
    LATERAL(VALUES (1, T.TARIF1),
                   (2, T.TARIF2),
                   (3, T.TARIF3),
                   (4, T.TARIF4)) as V(POSITIONTARIF, VALEURTARIF)
  where FOURNISSEUR = 1;

ps : La clause where n’est pas indispensable pour notre cas.

Résultat :

Imaginons que nous avons pour chaque tarif une colonne « date début tarif  » (et certainement fin de tarif 🙂 ).

alter table TARIF_H add column DATEDEBUTTARIF1 date;
alter table TARIF_H add column DATEDEBUTTARIF2 date;
alter table TARIF_H add column DATEDEBUTTARIF3 date;
alter table TARIF_H add column DATEDEBUTTARIF4 date;

Il faudra simplement l’ajouter dans la jointure LATERAL ainsi que dans la sélection des zones à afficher :

select T.fournisseur, T.article, V.POSITIONTARIF, V.VALEURTARIF, V.DATEDEBUTTARIF
  from FG.TARIF_H as T,
    LATERAL(VALUES (1, T.TARIF1, T.DATEDEBUTTARIF1),
                   (2, T.TARIF2, T.DATEDEBUTTARIF2),
                   (3, T.TARIF3, T.DATEDEBUTTARIF3),
                   (4, T.TARIF4, T.DATEDEBUTTARIF4)) as V(POSITIONTARIF, VALEURTARIF, DATEDEBUTTARIF)
  where FOURNISSEUR = 1;

Résultat :

Passage d’un affichage vertical à horizontal

Cette fois-ci nous allons utiliser la fonction d’agrégation MAX (même si nous savons qu’il n’y aura qu’un tarif avec le numéro 1, 2, 3 etc…) avec un groupage sur le fournisseur et numéro d’article.

select fournisseur, article,
    max(case when numtarif = 1 then tarif end) as Tarif1,  
    max(case when numtarif = 2 then tarif end) as Tarif2,  
    max(case when numtarif = 3 then tarif end) as Tarif3,
    max(case when numtarif = 4 then tarif end) as Tarif4 
from TARIF_V
group by fournisseur, article;

Résultat :

Nous sommes d’accord qu’il existe d’autres méthodes pour faire pivoter des données (listagg etc…).