, , Utilisation du catalogue DB2

Il existe de nombreuses tables dans QSYS qui constituent le catalogue DB2,
Ces tables sont accessibles par des vues qui se trouvent dans QSYS2 de manière globale et dans les bibliothèques de vos collections SQL.

On utilise pas assez ces informations pour analyser la base de données, elles contiennent une multitude d’informations

On va faire une petit exemple:

Imaginons que nous voulons savoir ou est utilisée une zone


Nous fixerons la database par set schema , pour éviter les qualifications

exemple de manière globale
SET SCHEMA QSYS2

On va utiliser une vue qui s’appelle SYSCOLUMNS qui contient les zones de votre database

SELECT
A.SYSTEM_COLUMN_NAME,
A.SYSTEM_TABLE_NAME,
A.SYSTEM_TABLE_SCHEMA
FROM SYSCOLUMNS A
WHERE COLUMN_NAME = ‘NUMCLI’

Vous obtenez une liste de tous les fichiers (tables, vue, PF, LF) etc …

Imaginons ensuite que vous ne vouliez que les tables ou PF vous pouvez utiliser la vue SYSTABLES

SELECT a.SYSTEM_COLUMN_NAME,
A.SYSTEM_TABLE_NAME,
A.SYSTEM_TABLE_SCHEMA
FROM SYSCOLUMNS a join SYSTABLES b on A.SYSTEM_TABLE_NAME=b.SYSTEM_TABLE_NAME
and a.SYSTEM_TABLE_SCHEMA = b.SYSTEM_TABLE_SCHEMA and B.TABLE_TYPE in(‘T’ , ‘P’)
WHERE COLUMN_NAME = ‘NUMCLI’

Vous limitez ainsi votre recherche aux tables et PF

Imaginons maintenant que vous ne vouliez que les tables et PF qui ont été utilisées sur l’année flottante (13 mois), on va utiliser la vue SYSTABLESTAT

SELECT a.SYSTEM_COLUMN_NAME,
A.SYSTEM_TABLE_NAME,
A.SYSTEM_TABLE_SCHEMA
FROM SYSCOLUMNS a join SYSTABLES b on A.SYSTEM_TABLE_NAME=b.SYSTEM_TABLE_NAME
and a.SYSTEM_TABLE_SCHEMA = b.SYSTEM_TABLE_SCHEMA and B.TABLE_TYPE in( ‘T’ , ‘P’)
join SYSTABLESTAT c on A.SYSTEM_TABLE_NAME=c.SYSTEM_TABLE_NAME
and a.SYSTEM_TABLE_SCHEMA = c.SYSTEM_TABLE_SCHEMA and c.LAST_USED_TIMESTAMP >
(current date – 13 months)
WHERE COLUMN_NAME = ‘NUMCLI’

Cette exemple n’est pas parfait, mais il vous montre qu’avec le catalogue db2 et un peu de SQL vous pouvez avoir de nombreuses informations pertinentes sur cette dernière .
Vous pouvez par exemple avoir des informations statistiques sur vos colonnes par la vue SYSCOLUMNSTAT et une vue globale avec la vue SYSFILES qui permet d’avoir un bon résumé de vos fichiers

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


Voici un lien qui vous présente les vues disponibles,

https://www.ibm.com/docs/en/i/7.5?topic=views-i-catalog-tables

Contrôlez un numéro de sécu

Voici une fonction RPGLE pour contrôler un numéro de sécurité sociale.


Elle reçoit une variable caractère de 15 de long qui contient le numéro de sécu + sa clé
et renvoie un booléen indiquant si la clé calculée est différente ou égale de la clé passée.


C’est une fonction que vous pouvez inclure dans un programme de service par exemple !

Voici le code à inclure dans votre programme de service :

dcl-proc Check_Numero_Secu export;
    dcl-pi *n ind;
        numSecu char(15) const;
    end-pi;

    select;
      when %SUBST(numSecu : 6 : 2) = '2A';
        numSecu = %SUBST(numSecu : 1 : 5) + '19' + %SUBST(numSecu : 8 : 7);
      when %SUBST(numSecu : 6 : 2) = '2B';
        numSecu = %SUBST(numSecu : 1 : 5) + '18' + %SUBST(numSecu : 8 : 7);
    endsl;

    return (97 - (%DEC(%SUBST(numSecu : 1 : 13) : 13 : 0)
              - %DEC(%DEC(%SUBST(numSecu : 1 : 13) : 13 : 0) / 97 : 13 : 0) * 97)
           = %DEC(%SUBST(numSecu : 14 : 2) : 2 : 0));
end-proc;             

Voici le code à inclure dans source de liage :

EXPORT SYMBOL(« CHECK_NUMERO_SECU »)  

Voici le code a ajouter dans dans votre programme pour pouvoir utiliser votre contrôle :

dcl-PR Check_Numero_Secu ind ;        
 W_Num_Sec char(15);                  
end-pr ;                              

// dans votre code

if Check_Numero_Secu ind(‘16403323470623’) ;

  dsply ‘error’ ;

endif;

Remarque :

Vous pouvez améliorer le code en mettant votre code sous monitor pour éviter les numéros de sécu incomplets

, , , , 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

, Texte dynamique dans vos commandes

Vous pouvez demander à générer le texte des commandes que vous allez créer à l’utilisation non à la compilation !

Vous devez créer un fichier de message avec vos messages

Vous pouvez ensuite coder votre commande ici LSTFIC

CMD PROMPT(TXT0001) PMTFILE(CMDTXT DYNAMIC)

PARM KWD(BIBLIO) TYPE(NAME) LEN(10) PROMPT(TXT0002)

le fichier message peut être indiqué de 2 manières dans la commande CMD paramètre PMTFILE()
ou
à la compile dans la commande de génération CRTCMD
CRTCMD … PMTFILE()

c’est le paramètre dynamic qui permet cette possiblité

Utilisation

==>LSTFIC <F4>

Exemple pour gérer votre traduction
vous créer
Un fichier message en anglais dans une bibliothèque


vous mettez votre bibliothèque avant l’autre dans la liste des bibliothèques et voila

Utilisation

==>LSTFIC <F4>

Remarque :


Je n’ai pas mis ici le programme de traitement, il reçoit un paramètre char de 10
Ca ne concerne pas les messages d’erreur c’est le paramètre MSGF()
Attention s’il ne trouve pas votre message il ne plante pas vous aurez l’ID du message affiché, exemple TXT0001

, , , Paramétrer NGINX en SSL sur votre IBMi

Une fois que vous avez installé NGINX , vous voudrez sans doute le sécuriser

Voici comment le sécuriser

Pour notre exemple

nous générerons nous même les clés de cryptographie

Nous allons générer 2 fichiers qui vont contenir vos clés
un fichier .pem et un fichier .key
par convention on les appellera cert
on choisira un certificat de type x509 valable une année

pour cela on va utiliser OPENSSL, vous devrez donc vérifier que le produit est installé

sous QSH voici la commande à passer

openssl req -newkey rsa:2048 -nodes -keyout /home/nginx/cert.key -x509 -days 365 -out /home/nginx/cert.pem

Après avoir répondu aux questions vous obtenez vos 2 certificats

Maintenant vous allez devoir indiquer à nginx qu’il est protégé par ces clés

Vous allez devoir modifier le fichier de configuration de nginx dans notre cas celui par défaut
bien sur vous sauvegardez avant l’ancien /QOpenSys/etc/nginx/nginx.conf

Une fois que vous avez fait votre modification vous devez arrêter le serveur nginx et le redémarrer

nginx -c /QOpenSys/etc/nginx/nginx.conf -s stop
puis
nginx -c /QOpenSys/etc/nginx/nginx.conf

Pour tester vous allez indiquer https://votreserveur:1880
dans notre cas le port est 1880.

Vous allez recevoir une alerte de sécurité , c’est normal votre certificat de n’a pas de racine connue
Vous répondez une fois ou de manière définitive et vous obtenez votre première page et vous voyez le https:

, , Utiliser un USER SPACE en SQL

Depuis la TR6 de la V7R4, vous pouvez manipuler entièrement les objets de type *USRSPC
Rappel depuis la TR4 vous pouviez les lire

voici la liste des commandes à utiliser avec un exemple

Création, procédure, CREATE_USER_SPACE

CALL QSYS2.CREATE_USER_SPACE(USER_SPACE => ‘MONUSRSPC’,
USER_SPACE_LIBRARY => ‘GDATA’,
SIZE => 100,
PUBLIC_AUTHORITY => ‘*CHANGE’);


Ecriture, procédure, CHANGE_USER_SPACE ou CHANGE_USER_SPACE_BINARY

CALL QSYS2.CHANGE_USER_SPACE(USER_SPACE => ‘MONUSRSPC’,
USER_SPACE_LIBRARY => ‘GDATA’,
DATA => ‘Tester c »est douter , corriger c »est adbiquer’,
START_POSITION => 1);

Lecture, fonction table, USER_SPACE

SELECT Substr(DATA , 1 , 100) FROM TABLE(QSYS2.USER_SPACE(
USER_SPACE => ‘MONUSRSPC’,
USER_SPACE_LIBRARY => ‘GDATA’));

il existe d’autres services SQL , pour manipuler les USER SPACE

QSYS2.USER_SPACE_INFO pour avoir les informations du user space

SELECT * FROM TABLE(QSYS2.USER_SPACE_INFO(
USER_SPACE => ‘USRSPC1’,
USER_SPACE_LIBRARY => ‘GDATA’));

mais aussi pour modifier


QSYS2.CHANGE_USER_SPACE_ATTRIBUTES()

vous pouvez facilement intégrer ces requêtes dans du RPGLE par exemple

On utilise de plus en plus java dans les travaux de votre IBMi et on a parfois besoin d’avoir des informations d’exécution

Voici comment connaitre la version de la JVM d’un travail ?

2 solutions simples

==> WRKJWMJOB

Puis 5 puis 1

Ou en utilisant sql services par la vue QSYS2.JVM_INFO

exemple :

select JOB_NAME, JAVA_HOME from qsys2.JVM_INFO

plus d’informations ici

https://www.ibm.com/docs/en/i/7.3?topic=usage-java-system-properties

, Liste de valeurs dans une commande

Vous voulez utiliser dans une commande pour un paramètre une liste de valeur paramétrable

sur la commande de votre paramétre vous avez un paramètre CHOICEPGM pour indiquer votre programme

Ce programme peut être en Rpg ou en CL ou autres, il devra juste respecter un certaine syntaxe sur le paramètre à renvoyer

Voici un petit exemple d’une commande qui permet de passer une bibliothèque de *TEST à *PROD et alternativement

La commande

                           
              CMD        PROMPT('Change Type Lib')                       
 /*  NOM DE FICHIER                                                  */  
              PARM       KWD(BIBLIO) TYPE(*CHAR) LEN(10) MIN(1) +        
                           CHOICE(*PGM) CHOICEPGM(*LIBL/CHGLIBTYP4) +    
                           PROMPT('Nom de la bib')                       

le programme de liste

PGM PARM(&PARM1 &PARM2)                                              
DCL VAR(&PARM1) TYPE(*CHAR) LEN(21)                                  
DCL VAR(&PARM2) TYPE(*CHAR) LEN(2000)                                
  /*--------------------------------------------------------------*/ 
  /* Programme  CHOICEPGM                                         */ 
  /*                                                              */ 
  /* PARM1 :     PREMIER PARAMETRE                                */ 
  /*        1   A   10   NOM DE COMMANDE                          */ 
  /*       11   A   20   NOM DU PARAMETRE DE LA COMMANDE          */ 
  /*       21   A   21   TYPE  (P) LISTE  DE VALEURS    ? ou F4   */ 
  /*                           (C) TEXTE  D'INVITE      F11       */ 
  /*                                                              */ 
  /* PARM2 :     DEUXIEME PARAMETRE                               */ 
  /*   ------>si liste                                            */ 
  /*        1   A    2   NOMBRE DE PARAMETRES TRANSMIS EN BINAIRE */ 
  /*        3   A    4   TAILLE DE LA PREMIERE VALEUR  EN BINAIRE */ 
  /*        5   A    N   PREMIERE VALEUR                          */ 
  /*      N+1   A    N+2 TAILLE DE LA DEUXIEME VALEUR  EN BINAIRE */ 
  /*      N+3   A    M   DEUXIEME VALEUR                          */ 
   /*        ETC...   2000                                         */ 
   /*                                                              */ 
   /*   ------>si texte                                            */ 
   /*        1   A   30   TEXTE A AFFICHER                         */ 
   /*       31   A 2000   INUTILISER                               */ 
   /*                                                              */ 
   /****************************************************************/ 
   /*                                                              */ 
   /*  Déclaration des zones de travail                            */ 
   /*                                                              */ 
   dclf qadspobj                                                      
   DCL        VAR(&FINFICHIER) TYPE(*LGL)                             
   DCL VAR(&BIN) TYPE(*CHAR) LEN(2)                                   
   DCL VAR(&DEC) TYPE(*DEC) LEN(5 0)                                  
   DCL VAR(&SIGN) TYPE(*CHAR) LEN(1)                                  
   DCL VAR(&pos ) TYPE(*dec ) LEN(5)                                  
   DCL VAR(&nbr ) TYPE(*dec ) LEN(10 0)                               
    /*                                                              */
    /* Initialisation de la zone paramètre à retourner              */
   /* Attention elle peut contenir n'importe quoi a l'arrivée      */ 
   /*                                                              */ 
   CHGVAR  VAR(&PARM2) VALUE(' ')                                     
   /*                                                              */ 
   /* Test de la demande  P = liste de paramètres                  */ 
   /*                                                              */ 
               IF         COND(%SST(&PARM1 21 1) *EQ 'P') THEN(DO)    
   /*--------------------------------------------------------------*/ 
   /*                                                              */ 
   /* 1er cas pos 21 = P demande d'une liste de valeurs            */ 
   /*                                                              */ 
   /*--------------------------------------------------------------*/ 
   /*                                                              */ 
   /* Formatage de la variable à retourner                         */ 
   /* Position 1 à 2 en binaire nombre de paramètres de retours    */ 
   /* conversion longueur du paramètre en binaire                  */ 
   /* Position 3  à  4 en binaire longueur de la première valeur   */ 
   /* Position 5  à 14 premiére Valeur à afficher                  */ 
   /* Position 15 à 16 en binaire longueur de la deuxième valeur   */ 

    /* Position 17 à 26 Deuxième Valeur à afficher                  */   
    /* etc ...                                                      */   
    /* xxxxyyyyyyyyyxxyyyyyyyyyxxyyyyyyyyy                          */   
    /* Génération du fichier des bibliothèques  GAIA*               */   
    /*--------------------------------------------------------------*/   
              DSPOBJD    OBJ(QSYS/GAIA*) OBJTYPE(*LIB) OUTPUT(*OUTFILE) +
                           OUTFILE(QTEMP/WADSPOBJ)                       
              OVRDBF     FILE(QADSPOBJ) TOFILE(QTEMP/WADSPOBJ) +         
                           LVLCHK(*NO) SHARE(*YES)                       
              RTVMBRD    FILE(QTEMP/WADSPOBJ) NBRCURRCD(&NBR)            
    /* ecriture nombre de postes */                                      
              chgvar &pos 1                                              
                CHGVAR     VAR(%bin(&BIN)) VALUE(&nbr)                   
                CHGVAR     VAR(%SST(&PARM2 &pos 2)) VALUE(&BIN)          
              chgvar &pos 3                                              
                CHGVAR     VAR(%bin(&BIN)) VALUE(10)                     
   /* Traitement des postes      */                                      
              DOUNTIL    COND((&FINFICHIER) *OR &POS > 1980)             
              rcvf 
             monmsg cpf0864 exec(leave)                              
  /* Ecriture de la longueur du poste */                             
                CHGVAR     VAR(%SST(&PARM2  &pos  2)) VALUE(&BIN)    
             chgvar &pos (&pos + 2)                                  
  /* ecriture du poste                */                             
                CHGVAR     VAR(%SST(&PARM2  &pos  10)) VALUE(&odobnm)
             chgvar &pos (&pos + 10)                                 
             enddo                                                   
             dltovr     FILE(QADSPOBJ)                               
             ENDDO                                                   
 /*--------------------------------------------------------------*/  
 /*                                                              */  
 /* 2ème cas pos 21 = C demande d'un texte                       */  
 /*                                                              */  
 /*--------------------------------------------------------------*/  
             IF         COND(%SST(&PARM1 21 1) *EQ 'C') THEN(DO)     
             CHGVAR     VAR(&PARM2) VALUE('Un nom valide de +        
                          Bibliothèque')                             
             ENDDO                                                   
 ENDPGM 

Le programme de traitement

PGM PARM(&LIB)                                            
/*-----------------------------------------------------*/ 
/* Programme de traitement de la commande              */ 
/* récupération du type et changement                  */ 
/* *PROD  *TEST                                        */ 
/*-----------------------------------------------------*/ 
DCL &LIB *CHAR 10                                         
DCL &TYPE *CHAR 10                                        
             RTVLIBD    LIB(&LIB) TYPE(&TYPE)             
IF COND(&TYPE = '*TEST') THEN(DO)                         
             CHGLIB     LIB(&LIB) TYPE(*PROD)             
ENDDO                                                     
ELSE DO                                                   
             CHGLIB     LIB(&LIB) TYPE(*TEST)             
ENDDO                                                     
ENDPGM   

C’est un exemple simple et facilement transposable, on aurait pu utiliser les vues SQL … pour obtenir la liste de bibliothèque

, , Utilisations des indexs

l’utilisation des index est devenu un enjeux majeur de la bas de données ,

On me pose réguliérement la question sur l’utilisation de ceux ci, je vais essayer de vous éclairer

En DDS/LF RPGLE (par exemple)

Vous connaissez tous cette solution on déclare le fichier LF ou index et on le lis quand on regarde la description de l’objet
vous avez la date de dernière utilisation , bien sur cette information est disponible dans la vue qsys2.object_statistics

En SQL/INDEX SQLRPGLE (par exemple)


Dans ce cas la vous allez lire la table par SELECT et c’est l’optimiseur qui va déterminer que vous avez besoin du chemin d’accès ou pas
attention : ce n’est pas parce que l’index existe qu’il sera utilisé , mais il sera avisé

Pour faire le ménage dans les indexs inutilisés ?

Il vous faudra donc croiser ses éléments avant de faire vos suppressions

rappel

Il y a des procédures dans systools qui permettent d’ajouter des indexs par rapport à des critères ,
c’est la procédure SYSTOOLS.ACT_ON_INDEX_ADVICE
et pour supprimer vous avez la procédures SYSTOOLS.REMOVE_INDEXES (ne supprimera que les index ayants pour nom %RADIX_INDEX% et %EVI_INDEX%
ca peut être brutal de les utiliser comme ca .
Par contre vous pouvez extraire les sources de ces procédures pour voir ce qu’elles font et vous en inspirer …

Vous avez des informations très intéressantes sur le sujet sur le lkdn de Christian Griere (merci à lui)

lien sur les index

https://www.linkedin.com/pulse/vos-tables-db2-i-sont-elles-trop-index%C3%A9es-christian-griere/

autres liens

https://www.linkedin.com/in/christian-griere-6a3828a/recent-activity/posts/

Avec la TR6 de la V7R4 (TR disponible à partir du 24 mai 2022)


Vous pouvez désormais compresser en standard avec l’algorithme *ZLIB dans les commandes SAV*


Bien que un peu vieux, (la première version date de 1995) c’est un algo très fiable et efficace


Pour en savoir plus sur ZLIB https://fr.wikipedia.org/wiki/Zlib

Remarque :

Jusque la on pouvait l’installer en open-source