, , 5 astuces pour optimiser vos connexions ODBC.

On a souvent du mal a régler ODBC voici quelques points qui peuvent vous aider dans cette tache.
L’apport de la procédure SET_SERVER_SBS_ROUTING qui permet de router des jobs ODBC, par adresses IP ou utilisateurs à considérablement changer la donne.

Rappel sur la procédure SET_SERVER_SBS_ROUTING

Gestion par utilisateur

call qsys2.SET_SERVER_SBS_ROUTING(‘PLB’, ‘QZDASOINIT’ , ‘ODBC’)

pour activer la redirection

call qsys2.SET_SERVER_SBS_ROUTING(‘PLB’, ‘QZDASOINIT’ , NULL);

pour supprimer cette redirection

SELECT * FROM QSYS2.SERVER_SBS_ROUTING

Pour les redirections existantes par nom user

Gestion par adresse IP

Pour activer

CALL QSYS2.SET_SERVER_SBS_ROUTING(AUTHORIZATION_NAME => ‘*ALL’,
SERVER_NAME => ‘QZDASOINIT’,
IP_ADDRESS_START => ‘192.168.1.10’,
IP_ADDRESS_END => ‘192.168.1.30’,
SUBSYSTEM_NAME => ‘ODBC’)

Pour supprimer cette redirection

CALL QSYS2.SET_SERVER_SBS_ROUTING(AUTHORIZATION_NAME => ‘*ALL’,
SERVER_NAME => ‘QZDASOINIT’,
IP_ADDRESS_START => ‘192.168.1.10’,
IP_ADDRESS_END => ‘192.168.1.30’,
SUBSYSTEM_NAME => NULL);

pour voir les redirections existantes par adresses IP

SELECT * FROM QSYS2.SERVER_SBS_CONFIGURATION;

Voici quelques axes qui peuvent vous donner des idées

1) Séparer vos connexions en créant un sous-système spécifique

Ce qui permet une meilleur administration.
Vous pourrez router vos jobs par utilisateurs ou par adresse IP grâce à la procédure SQL SET_SERVER_SBS_ROUTING

CRTSBSD SBSD(VOTRESBS)
POOLS((1 *BASE))
TEXT(‘Sous-système pour job ODBC’)
vous pouvez indiquer le pool de base

un travail à démarrage automatique

ADDPJE SBSD(GODBC) PGM(QSYS/QZDASOINIT) INLJOBS(QZDASOINIT) JOBD(Qgpl/votrejobd) CLS(QSYS/votreclasse) user(votreuser)

et un poste de routage

ADDRTGE SBSD(VOTRESBS)
SEQNBR(9999)
CMPVAL(*ANY)
PGM(VOTREPGM)
CLS(VOTRECLASS)

2) Mettre un pool spécifique sur votre sous système

Ce qui permettra de réinitialiser votre cache entre 2 benchmarks.

POOLS((1 *SHRPOOL7))

3) Mettre une classe spécifique

Ce qui permettra de régler les priorités d’exécution sur la commande RTGE.
la classe par défaut est la QPWFSERVER , dupliquez la et ajustez les paramètres que vous désirez par CHGCLS.
Par exemple, les priorités.

4) Mettre une JOBD spécifique pour fixer le niveau de log

par exemple sur la commande ajout des travaux auto.
la jobd par défaut est la QDFTSVR , dupliquez la et ajustez les paramètres que vous désirez par CHGJOBD.
Par exemple le niveau de log.

5) Mettre un programme initial spécifique

Pour par exemple choisir le fichier QAQQINI pour les réglages SQL.
Le programme par défaut est QCMD , voici un exemple.
Par exemple, changer le fichier QAQQINI
PGM
CHGQRYA QRYOPTLIB(&LIB)
SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG) MSGDTA(‘Vous +
utilisez désormais QAQQINI de la +
bibliothèque, ‘ BCAT &LIB) MSGTYPE(STATUS)
ENDPM

Rappel :

Ici on traite pas de la traçabilité, il est important de voir qui peut faire de l’ODBC sur votre système.

Nous avons un logiciel GODBC qui peut vous aider dans cette tache ici : https://www.gaia.fr/produits/

, , Moderniser vos menus IBMi

Vous pouvez désormais accéder aux fichiers des messages par SQL grâce à la vue SQL QSYS2.MESSAGE_FILE_DATA.

Vos menus personnalisés utilisent des commandes qui sont stockés dans des fichiers messages.

Voici une idée pour améliorer vos menus : prendre la commande à exécuter et l’afficher, vous pouvez customizer l’affichage du texte

J’ai publié le code sur github l’adresse suivante : https://github.com/Plberthoin/PLB/tree/master/GTOOLS

Vous devez récupérer, un DDS , un SQLRPGLE et une CMD.

Voila qui peut vous donner des idées pour la gestion de vos fichiers messages

, , Comment repérer les requêtes SQL consommatrices sur votre IBMi

Comment voir à un instant donné, les requêtes les plus consommatrices de votre système ?

Vous êtes sans doute demandé comment connaitre les requêtes SQL qui consomment sur votre système, voici une solution.

Nous allons utiliser un dump du plan cache , vous pouvez aussi y accéder par ACS en quelques clics.

Voici une méthode qui va vous permettre d’automatiser et de trouver plus rapidement un problème.

Commencer par supprimer le fichier qui va servir à extraire le dump

Drop table gdata.dump_cache ;

Extrayez le cache dump dans votre fichier de travail

CALL QSYS2.DUMP_PLAN_CACHE (fileschema => ‘GDATA’, Filename => ‘DUMP_CACHE’) ;

Exécuter une requête sur ce fichier

Dans notre exemple, on sélectionne les jobs actifs sur le système, on sélectionne les requêtes SELECT et on trie par consommation descendante !

With job_act (JOB_NAME_SHORT, JOB_USER, JOB_NUMBER, JOB_USER_IDENTITY)
as (SELECT JOB_NAME_SHORT, JOB_USER, JOB_NUMBER,JOB_USER_IDENTITY
FROM TABLE (QSYS2.ACTIVE_JOB_INFO(DETAILED_INFO => ‘ALL’)) X
where substr(job_user_identity, 1, 1) <> ‘Q’)
Select qqjob, qquser, qvc102, qqjnum, qq1000, qqi6 as temps_execution
from gdata.dump_cache a join job_act b on
QQJOB = JOB_NAME_SHORT and QQUSER = JOB_USER and QQJNUM = JOB_NUMBER
where substr(QQ1000 , 1, 6) = ‘SELECT’
order by qqi6 desc

Vous pouvez changer vos critères de tri et de sélection, ici on est en mode pompier ?
Vous pouvez planifier cette requête et la faire tourner plusieurs fois par jour sur votre système en gardant le résultat ou les dump cache.

Nous avons packagé ce script pour faire une commande WRKSQLJOB que vous pouvez trouver ici !

https://github.com/Plberthoin/PLB/tree/master/GTOOLS


Vous retrouvez également une version un peu plus évoluée dans notre produit GODBC
https://www.gaia.fr/produits/

Les sites à connaitre, si vous voulez aller plus loin :

https://www.ibm.com/docs/en/i/7.4?topic=services-dump-plan-cache-procedure
https://www.ibm.com/docs/en/i/7.4?topic=cache-creating-snapshots

https://www.ibm.com/docs/api/v1/content/ssw_ibm_i_74/pdf/rzajqpdf.pdf

, , , QCMDEXC en Fonction SQL

Depuis la TR4 de la version V7R4, vous pouvez utiliser la fonction QCMDEXC

C’est l’occasion de faire un rappel sur les différents usages disponibles jusque la

1 ) C’est une API (un programme) que vous pouvez appelez depuis un programme RPG ou CLP

en RPGLE

Dcl-Pr Exec_Commande QCMDEXC ExtPgm(‘QCMDEXC’);
Cmd Char(3000) Const;
CmdLen packed(15:5) Const;
End-Pr;

Dcl-S Gbl_Cmd Char(3000);

Gbl_Cmd = ‘Votre commande’ ;

Exec_commande(Gbl_Cmd : %len(Gbl_Cmd)) ;

En CLLE

PGM
DCL &CMD *CHAR 300
DCL &LEN *DEC (15 5)

CHGVAR &CMD (‘VOTRE COMMANDE’)
CHGVAR &LEN %LEN(&CMD)
CALL QCMDEXC (&CMD &LEN)

2) C’est une procédure SQL

call qcmdexc(‘votre commande’)

en SQL embarqué

Dcl-S Gbl_Cmd Char(3000);

call qcmdexc(:Gbl_Cmd)

3) C’est une Fonction SQL à partir de la TR4

Réorganisation des fichiers BD

SELECT qcmdexc(‘RGZPFM FILE(‘ concat
trim(substr(TABLE_SCHEMA, 1 , 10))
concat ‘/’ concat
substr(TABLE_NAME, 1 , 10) concat ‘)’) as résultat
FROM systables WHERE TABLE_SCHEMA =
‘GDATA’ and FILE_TYPE = ‘D’

la fonction renvoi 1 si ok et -1 si ko

Conclusion :
Vous avez un aperçu des possibilités qcmdexc sur la machine, à vous de jouer !

, , , Surveillez vos requêtes SQL sur votre #IBMi

Il est possible que vous ayez des doutes sur les performances de vos requêtes SQL, voici comment avoir une idée rapide de ce qui tourne

On va utiliser ACS
dans Base de données choisir
SQL Performance center

Vous avez un onglet Affichage des instructions

Vous choisissez le filtre à appliquer, ici on choisit les actives, vous pouvez être beaucoup plus pertinent en limitant votre choix.

Une fois que vous avez repéré une requête candidate, il vous suffit de faire un clic droit sur celle ci et vous pouvez lancer directement Visual Explain, qui vous expliquera le comportement de cette requête, vous pourrez alors faire les ajustements qui s’imposent

Le résultat dans V-E

PS:
Le principal critère de performance sur SQL, c’est les index, pensez à surveiller les suggestions faites par Index Advisor

Une des nouveautés de TR4 c’est Query Supervisor

L’idée est de limiter les requêtes selon certain critères (de temps d’exécution, d’espace temporaire occupé etc… )
Jusqu’à présent c’était pas toujours simple et un peu binaire

Ajout d’un seuil à contrôler

Se fait par la procédure QSYS2.ADD_QUERY_THRESHOLD

Exemple

CALL QSYS2.ADD_QUERY_THRESHOLD(THRESHOLD_NAME => ‘Seuil’,
THRESHOLD_TYPE => ‘CPU TIME’,
THRESHOLD_VALUE => 1,
INCLUDE_USERS => ‘PLB’,
DETECTION_FREQUENCY => 60)

Vous devez indiquer :
– Un nom ici Seuil
– Le seuil à contrôler
– Une valeur pour ce seuil
– Un filtre d’inclusion ou d’exclusion ici inclusion du profil PLB
– Un délai de rafraichissement en seconde

Vous avez une vue qui permet de voir les seuils définis sur votre partition

C’est la vue QUERY_SUPERVISOR

exemple

voir tous les seuils définis pour Query supervisor

SELECT *
FROM QSYS2.QUERY_SUPERVISOR ORDER BY THRESHOLD_TYPE, THRESHOLD_VALUE DESC;

;

Vous pouvez indiquer un programme d’exit QIBM_QQQ_QRY_SUPER

ci joint un exemple basique pour expliquer ce qui ce passe

pgm parm(&qrysupdta &returncod)
/* Paramètres */
dcl &qrysupdta *char 1024
dcl &returncod char 8

/* Variables de Travail */

DCL VAR(&SIZ_HEADER) TYPE(CHAR) LEN(4) +
STG(DEFINED) DEFVAR(&qrysupdta 1)

DCL VAR(&FMT_NAME) TYPE(CHAR) LEN(8) +
STG(DEFINED) DEFVAR(&qrysupdta 5)

DCL VAR(&JOB_NAME) TYPE(CHAR) LEN(10) +
STG(DEFINED) DEFVAR(&qrysupdta 13)

DCL VAR(&JOB_USER) TYPE(CHAR) LEN(10) +
STG(DEFINED) DEFVAR(&qrysupdta 23)

DCL VAR(&JOB_NUMBER) TYPE(CHAR) LEN(6) +
STG(DEFINED) DEFVAR(&qrysupdta 33)

DCL VAR(&SUBSYSTEM) TYPE(CHAR) LEN(10) +
STG(DEFINED) DEFVAR(&qrysupdta 39)

DCL VAR(&Usr_name) TYPE(CHAR) LEN(49) +
STG(DEFINED) DEFVAR(&qrysupdta 23)

DCL VAR(&QRYPLANID) TYPE(CHAR) LEN(08) +
STG(DEFINED) DEFVAR(&qrysupdta 67)

DCL VAR(&THR_NAME) TYPE(CHAR) LEN(60) +
STG(*DEFINED) DEFVAR(&qrysupdta 75)
dcl &msg *char 2056
chgvar &msg (&JOB_NAME *cat ‘/’ *cat &JOB_USER *tcat ‘/’ *tcat +
&JOB_NUMBER *bcat ‘Arreté pour dépassement, ‘ *bcat &THR_NAME)
SNDUSRMSG MSG(&MSG)
/* on force l’arret de la requete */
CHGVAR VAR(%BIN(&returncod 1 4)) VALUE(1)
ENDPGM
Pour en savoir plus le lien ici

https://www.ibm.com/docs/en/i/7.4?topic=ssw_ibm_i_74/apis/xqrysuper.htm

Le message ne cas de débordement

Le message remonté depuis notre programme d’exit

Vous pouvez voir vos statistiques de sollicitation dans ACS SQL performance center

Vous pouvez enlever vos seuils

c’est la procédure REMOVE_QUERY_THRESHOLD

CALL QSYS2.REMOVE_QUERY_THRESHOLD(THRESHOLD_NAME => ‘Seuil’);

vous indiquez le nom que vous avez donné à votre seuil

Conclusion

C’est une bonne nouveauté pour les administrateurs DB2

On peut regretter l’absence du procédure de change qui permettrait de revenir sur les paramètres de définition.

, , UTILISATION DES API EN SQL

Récupérer une API

Il existe un grand nombre d’API aux fonctionnalités diverses dont certaines nous permettent de récupérer des données structurées dans différents formats (XML, JSON, …).

Grace aux fonctions SQL de l’IBMi nous pouvons récupérer ces données pour les insérer dans les fichiers de la base de données.

Pour les exemples qui suivent, on se base sur trois API tirées du site https://openweathermap.org/ :

  • Une première qui récupère la météo dans une ville donnée

https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=xml’

  • Une qui récupère jusqu’à 50 communes autour de coordonnées choisies

https://api.openweathermap.org/data/2.5/find?lat=45.75&lon=4.5833&cnt=50&appid={API key}&mode=xml

  • Une qui récupère jusqu’à des communes dans un rectangle de coordonnées choisies

https:// api.openweathermap.org/data/2.5/box/city?bbox=4,45,8,46,50&appid={API key}

Extraire les données de l’API

Sortie API en XML

La commande SQL suivante permet d’afficher les données dans un champ DATA 

SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=xml',''), 4096))
ws(data);

Sortie API en JSON

La commande SQL suivante permet d’afficher les données dans un champ DATA 

SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}',''), 4096))
ws(data);

Sortie API en HTML

La commande SQL suivante permet d’afficher les données dans un champ DATA 

SELECT DATA FROM (values
char(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/weather?q={city name}&appid={API key}&mode=html',''), 4096))
ws(data);

Récupération des données

En XML

On crée un fichier qui contiendra les colonnes que l’on veut récupérer (Ville, Température en cours, date, …)

CREATE TABLE GG/METEODB
(VILLE_ID DECIMAL (9, 0) NOT NULL WITH DEFAULT,
VILLE_NOM CHAR (50) NOT NULL WITH DEFAULT,
TEMPERATURE DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MIN DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MAX DECIMAL (5, 2) NOT NULL WITH DEFAULT,
DATE_MAJ CHAR (20) NOT NULL WITH DEFAULT)
;

Récupérer les données de l’API dans le fichier créé :

INSERT INTO GG.METEODB
select xdata.* FROM xmltable('$doc/cities/list/item'
PASSING XMLPARSE(document SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/find?lat=45.75&lon=4.5833&cnt=10&appid={API key}&mode=xml','')) AS "doc"
COLUMNS
ville_id decimal(9, 0) PATH 'city/@id',
ville_nom varchar(50) PATH 'city/@name',
temperature decimal(5, 2) PATH 'temperature/@value',
temp_min decimal(5, 2) PATH 'temperature/@min',
temp_max decimal(5, 2) PATH 'temperature/@max',
date_maj varchar(20) PATH 'lastupdate/@value' ) as xdata;

En JSON

Contrairement à XML, on peut créer tout de suite un fichier qui contiendra les colonnes que l’on veut récupérer.

CREATE TABLE GG.METEOBD
(VILLE_ID DECIMAL (9, 0) NOT NULL WITH DEFAULT,
VILLE_NOM CHAR (50) NOT NULL WITH DEFAULT,
TEMPERATURE DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MIN DECIMAL (5, 2) NOT NULL WITH DEFAULT,
TEMP_MAX DECIMAL (5, 2) NOT NULL WITH DEFAULT,
DATE_UX_MAJ DECIMAL (12, 0) NOT NULL WITH DEFAULT)

Récupérer les données de l’API dans le fichier créé :

INSERT INTO GG.METEOBD
select * from JSON_TABLE(SYSTOOLS.HTTPGETCLOB('https://api.openweathermap.org/data/2.5/box/city?bbox=4,45,8,46,50&appid={API key}','') ,
'$.list[*]'
COLUMNS
(ville_id decimal(9, 0) PATH '$.id',
ville_nom varchar(50) PATH '$.name',
temperature decimal(5, 2) PATH '$.main.temp',
temp_min decimal(5, 2) PATH '$.main.temp_min',
temp_max decimal(5, 2) PATH '$.main.temp_max',
date_ux_maj decimal(12, 0) PATH '$.dt'));

Pour aller plus loin

En utilisant une API de LA POSTE qui ne nécessite pas d’inscription au préalable, ni d’identification. Nous pouvons réaliser un programme qui nous aide à retrouver une commune à partir d’un code postal, dans l’optique d’aider au remplissage de certains formulaires.
On crée un fichier temporaire en interrogeant directement l’API.

, , Variables SQL utilisables dans vos scripts ?

Voici quelques variables que vous pouvez utiliser dans vos requêtes SQL

par exemple Client_Ipaddr qui est arrivée avec la TR4

Quelques registres et variables d’environnement

select
current time as heure_en_cours,
current date as date_en_cours,
current user as utilisateur_courant,
current timestamp as timestamp_en_cours,
CURRENT CLIENT_ACCTNG as Client_connexion,
CURRENT CLIENT_APPLNAME as Client_Application,
Current timezone as Fuseau_Horaire,
Current server as Current_Server ,
current path as Current_path,
CURRENT CLIENT_APPLNAME as Programme_client,
CURRENT CLIENT_USERID as Utilisateur_client,
CURRENT CLIENT_PROGRAMID as Programme_client
from sysibm.sysdummy1

Quelques Variables globales dans SYSIBM

select
SYSIBM.Client_Host as Client_Host,
SYSIBM.Client_Ipaddr as Client_Ipaddr,
SYSIBM.Client_Port as Client_Port,
SYSIBM.Package_Name as Package_Name,
SYSIBM.Package_Schema as Package_Schema,
SYSIBM.Package_Version as Package_Version,
SYSIBM.Routine_Schema as Routine_Schema,
SYSIBM.Routine_Specific_Name as Routine_Specific_Name,
SYSIBM.Routine_Type as Routine_Type
from sysibm.sysdummy1

Comme dans nos exemples, ces variables sont utilisables dans vos requêtes

exemple

les travaux actifs de l’utilisateur en cous

, , Passage SQLSTATE en SQL

Depuis la TR4 de la V7R4, vous pouvez passer votre propre SQLSTATE ce qui est très intéressant sur les triggers avants par exemple.
Vous pouvez avoir la vraie raison du refus
C’est un petit pas pour SQL, mais un grand pas pour le développeur SQL

Exemple

Création de la table

CREATE OR REPLACE TABLE ARTICLE (
NOMART CHAR(30) CCSID 297 NOT NULL DEFAULT  » ,
NUMART DECIMAL(6) ,
DESIGN CHAR(25) CCSID 297 NOT NULL DEFAULT  » ,
PRXUNI DECIMAL(6)
)
Insertion d’un article (Je sais, je surfe sur l’actualité du moment)
INSERT INTO ARTICLE VALUES(‘Maillot Benzema’, 19,
‘Maillot Benzema EDF’, 166)

tentative de mise à jour

UPDATE ARTICLE SET PRXUNI = 167 WHERE NUMART = 19

Création d’un trigger de controle
ici on teste que l’utilisateur est bien ‘DBADMIN’ pour pouvoir modifier le tarif

CREATE OR REPLACE TRIGGER ARTICLETRG
BEFORE UPDATE OF PRXUNI ON ARTICLE
FOR EACH ROW
BEGIN ATOMIC
IF CURRENT USER <> ‘DBADMIN’ THEN
SIGNAL SQLSTATE ‘DB999’
SET MESSAGE_TEXT = ‘UTILISATEUR NON AUTORISÉ’;
END IF;
END;

Par SQL

Maintenant dans un programme RPGLE

On va utiliser get diagnostics pour récupérer le SQLTATES et le Message associé

**free
dcl-s MessageText char(45) ;
dcl-s ReturnedSQLState char(5);
exec sql SET OPTION COMMIT = *NONE ;
// test mise à jour trigger
exec sql
UPDATE ARTICLE SET PRXUNI = 167 WHERE NUMART = 19 ;
exec sql
get diagnostics condition 2
:ReturnedSQLState = RETURNED_SQLSTATE ,
:MessageText = MESSAGE_TEXT;
dsply (ReturnedSQLState + ‘ ‘ + MessageText) ;
*inlr = *on ;

Vous lancez le programme

Conclusion :

c’est une nouveauté qui devrait simplifier le contrôle des triggers est donc leur usage.

, , Conversion d’une OUTQ en PDF par GENERATE_PDF

Depuis la TR4 de la V7R4,vous avez une fonction qui génère un PDF à partir d’un spool.

Voici une requête qui convertit les spools de votre outq en PDF

On va créer une variable globale pour indiquer le répertoire de génération des PDF

CREATE OR REPLACE VARIABLE QGPL.REPERT_PDF VARCHAR(30)DEFAULT ‘/home/PDF/’

Exécution de la requête sur votre outq

SELECT SPOOLED_FILE_NAME, JOB_NAME, FILE_NUMBER ,
SYSTOOLS.GENERATE_PDF(JOB_NAME => JOB_NAME ,
SPOOLED_FILE_NAME => SPOOLED_FILE_NAME ,
SPOOLED_FILE_NUMBER => FILE_NUMBER,
PATH_NAME => REPERT_PDF concat current date concat ‘_’ concat regexp_replace(JOB_NAME, ‘/’,  ») concat ‘_’ concat
SPOOLED_FILE_NAME concat ‘_’ concat FILE_NUMBER concat ‘.pdf’)
FROM QSYS2.OUTPUT_QUEUE_ENTRIES_BASIC WHERE OUTPUT_QUEUE_NAME = ‘votre_outq’

Le résultat vu par un WRKLNK


C’est juste un exemple, à vous de l’ajuster