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.

, , , , Verrouiller vos sources pour VSCODE

Une des difficultés, quand on développe avec VSCE sur IBMi ,
C’est que si on est 2 deux à modifier le même source, c’est le dernier qui a raison avec perte de modification du premier même s’il a sauvegardé

Voici comment on peut améliorer les choses.
On va créer un fichier base de données qui liste les sources qui sont en cours de maintenance, un peu comme un ALM.

Avec GIT on peut arriver à des mécanismes identiques, et surtout, il faut commencer à mettre vos sources dans l’IFS directement

Voila comment, vous pouvez faire pour améliorer les choses

CREATE TABLE DB_OPENLCK (FICHIER CHAR ( 10) NOT NULL WITH
DEFAULT, BIBLIO CHAR ( 10) NOT NULL WITH DEFAULT, MEMBRE CHAR ( 10)
NOT NULL WITH DEFAULT, PARTAGE CHAR ( 3) NOT NULL WITH DEFAULT,
PUSER CHAR ( 10) NOT NULL WITH DEFAULT, PDATE DATE NOT NULL WITH
DEFAULT, PTIME TIME NOT NULL WITH DEFAULT)

Pour ajouter un source à verrouiller

INSERT INTO DB_OPENLCK VALUES(‘QRPGLESRC’, ‘GDATA’, ‘AAAA’,
‘NON’, ‘PLB’, current date, current time)

Et parmi les programmes d’exit il en a un qui va nous permettre de mettre en œuvre ce contrôle
C’est le QIBM_QDB_OPEN

On va donc écrire un programme, ici en SQLRPGLE

**free
//
// ce programme permet d'éviter de travailler à 2 sur un même source
//
Dcl-Pi *N;
  DS_parm          likeds(ds_parm_t) ;
  reponse          int(10);
End-Pi;
// dsprogramme
 dcl-ds *N PSDS ;
  nom_du_pgm CHAR(10) POS(1);
  init_user  CHAR(10) POS(254);
  enc_user  CHAR(10) POS(358);
End-ds ;
// ds format  DBOP0100
Dcl-DS ds_parm_t qualified template ;
  taille_entete  Int(10);
  format         Char(8);
  offset_liste   Int(10);
  nbr_fichiers   Int(10);
  taille_liste   Int(10);
  job            Char(10);
  profil         Char(10);
  jobnbr         Char(6);
  cur_profil     Char(10);
  reste          Char(1024);
End-DS;
  // liste des fichiers dans notre cas un seul
Dcl-DS liste  ;
  fichier       Char(10);
  biblio        Char(10);
  membre        Char(10);
  filler         Char(2);
  typefichier    Int(10);
  sous_jacent    Int(10);
  access         Char(4);
End-DS;
// variable de travail
Dcl-S partage      char(4);
Dcl-S puser      char(10);

ds_parm.offset_liste += 1;
dsply   enc_user ;

  liste = %subst(ds_parm : ds_parm.offset_liste :
  ds_parm.taille_liste);

    ds_parm.offset_liste += ds_parm.taille_liste;
 // lecture des informations dans le fichier de verrouillage explicite
 // le verrouillage est donc par utilisateur
   exec sql
   SELECT PARTAGE, PUSER into :partage , :puser
      FROM DB_OPENLCK WHERE FICHIER = :FICHIER and BIBLIO
             = :BIBLIO and MEMBRE = :MEMBRE  ;
   //
   // La régle mise en oeuvre ici
   // on autorise
   // si même utilisateur
   // si non trouvé en modification
   // Si on on a dit partage à oui
   //
  if (sqlcode = 100  or partage = 'OUI' or puser = enc_user) ;
    reponse = 1 ;
  else ;
    reponse = 0 ;
  endif ;
  // fin de programme

*inlr = *on; 

ici notre règle est la suivante
on autorise
Si le source n’est pas présent dans le fichier
Si l’utilisateur est le même que celui en cours
Si on a accepté le partage et donc le risque

Pour ajouter votre pgm exit

SYSTEM/ADDEXITPGM EXITPNT(QIBM_QDB_OPEN)
FORMAT(DBOP0100)
PGMNBR(1)
PGM(GDATA/OPENSRC)
REPLACE(*NO)

Quand on essaye d’accéder par VSCDE à notre source

Remarque


Le contrôle marche aussi avec RDI
Il marche également pour SEU, parfois on préfère un contrôle spécifique SEU, vous devrez utiliser le programme d’exit
QIBM_QSU_ALW_EDIT en utilisant le même fichier par exemple !

 **free                                                                                       
 //                                                                                           
 // Ce programme eviter de travailler à 2 sur un même source                                 
 //                                                                                           
 Dcl-Pi *N;                                                                                   
   biblio     char(10);                                                                       
   fichier    char(10);                                                                       
   membre     char(10);                                                                       
   reponse    char(1);                                                                        
 End-Pi;                                                                                      
 // dsprogramme                                                                               
  dcl-ds *N PSDS ;                                                                            
   nom_du_pgm CHAR(10) POS(1);                                                                
   init_user  CHAR(10) POS(254);                                                              
   enc_user  CHAR(10) POS(358);                                                               
 End-ds ;                                                                                     
                                                                                              
 Dcl-S partage      char(4);                                                                  
 Dcl-S puser      char(10); 
                                                                           
 // lecture des informations dans le fichier de verrouillage explicite     
 // le verrouillage est donc par utilisateur                               
   exec sql                                                               
   SELECT PARTAGE, PUSER into :partage , :puser                           
      FROM DB_OPENLCK WHERE FICHIER = :FICHIER and BIBLIO                 
             = :BIBLIO and MEMBRE = :MEMBRE  ;                            
   //                                                                     
   // La règle mise en œuvre ici                                         
   // on autorise                                                         
   // si même utilisateur                                                 
   // si non trouvé en modification                                       
   // Si on on adit partage à oui                                         
   //                                                                     
  if (sqlcode = 100  or partage = 'OUI' or puser = enc_user) ;            
    reponse = '1' ;                                                       
  else ;                                                                  
    reponse = '0' ;                                                       
  endif ;     
  // fin de programme    
                         
*inlr = *on;      

On ajoute comme ca

SYSTEM/ADDEXITPGM EXITPNT(QIBM_QSU_ALW_EDIT)
FORMAT(EXTP0100)
PGMNBR(1)
PGM(GDATA/OPENSRCE)
REPLACE(*NO)


Ca ne fait pas tout, que faire si on est 2 sur le même source ? peut être faut il avoir un source de référence pour éviter le versionnage

Remarque :

Pour diminuer le nombre d’appels du programme d’exit , vous pouvez limiter le déclenchement aux fichiers qui sont audités.

Vous devez indiquer le paramètre PGMDTA(*JOB *CALC ‘*OBJAUD’) sur les commandes ADDEXITPGM ou CHGEXITPGM.

Exemple :

ADDEXITPGM EXITPNT(QIBM_QDB_OPEN)

PGMDTA(*JOB *CALC ‘*OBJAUD’)

Vous devez ensuite indiquer les fichiers à auditer :

Exemple :

CHGOBJAUD OBJ(GDATA/QRPGLESRC)
OBJTYPE(FILE) OBJAUD(CHANGE)

A partir de ce moment la, seuls les fichiers audités déclencheront l’appel du programme d’exit QIBM_QDB_OPEN

Vous voulez avoir des informations sur des exécutions SQL.

La meilleure méthode est de prendre la requête que vous voulez analyser et de l’exécuter dans Visual Explain.

Mais ce n’est pas toujours possible , dans le cas d’une chaine avec du SQL embarqué .

Si vous avez fait du SQL statique vous pouvez avoir des informations au niveau des programmes par PRTSQLINF.

Dans certains cas, on n’a pas ces possibilités. Le plus simple est alors de ce mettre en debug et d’exécuter votre chaine, attention ce n’est pas un mode à mettre en place en production, ça augmente considérablement les informations de log.

Vous devez démarrer le debug, le plus souvent en indiquant que vous autorisez les mises à jour sur les fichiers de production.
==>strdbg updprod(*yes)

Vous lancez ensuite votre traitement qui va générer un log avec des messages de votre optimiseur SQL, ce sont des messages id CPI43xx

Il vous suffit ensuite d’analyser votre log et regarder si certains messages vous donnent des informations intéressantes.
exemple :
CPI432F index à ajouter

Pour vous aider nous avons fait cet outil DBGSQLJOB que vous retrouverez ici et qui vous facilite la démarche
https://github.com/Plberthoin/PLB/tree/master/GTOOLS

Vous soumettez votre programme comme ceci
sbmjob cmd(DBGSQLJOB cmd(call monpgm) ) job(dbgsql)

et vous obtenez un fichier dbgsql dans la bibliothèque indiquée (par défaut *curlib) qui contiendra les messages de votre optimiseur.

Vous n’avez plus qu’a les analyser ensuite par select * from DBGSQL .

Limitation :
Dans cet outil, nous traitons en commit(*none) les requêtes SQL, si ce n’est pas le cas chez vous, adaptez le mode.

Rappel :
80 % de votre performance SQL c’est les index , suivez les recommandations de INDEX ADVISOR.