pause-café

if   I < %elem(tbl_tva)

if   %subst(raisoc : 1 : 1) <> ' '
         
eval %subst(pgm : 1 : 1) = 'Q' 

if    %SUBST(nom : %size(nom): 1) = *blank

eval NP = %trim(nom) + ' ' + %trim(prenom)

if   %parms > 2 

transforme une valeur numérique (char en V5.2,date en V5.3) en numérique condensé ou packé.
(%DECH applique un arrondi)

transforme une valeur numérique (ou caractère en 5.20)au format binaire signé

transforme une valeur numérique (ou caractère ) au format binaire non signé

%FLOAT

%EDITFLT

%EDITC

eval msg = 'date de traitement' + 
           %editc(date : 'Y') 
         
eval montanchar = %editc( 
                  qte * prix : '3')

%EDITW

ZoneChar=%CHAR(ZoneDec) // 000123,45- ==> '-123,45'

%LEN

if   %len(%trim(nom)) > 2

eval L = %len(zone-variable)

%SCAN

eval chaine = 'ILE/RPG-IV' 
eval pos = %scan('I' : chaine)        [pos=1]
eval deb = pos + 1 
eval pos = %scan('I' : chaine: deb)   [pos=9]

                          [var1 = 'AS/400'] 
eval x = %scan('4' : var1) 
eval var2 = %replace('5': var1:x) 
                          [var2 = 'AS/500']

eval var2 = %replace('X': var1 : 1 : 3) 
   [je remplace 3 caractères : var2 = 'X500']

%NULLIND

IF   %NULLIND(datcmd) = *ON 
         
EVAL %NULLIND(prime) = *OFF 
EVAL prime = 1500 

%OPEN

if   %open(clients)

%EOF

dow  not %eof(clients)

%ERROR

if   %error

%STATUS

if   %error and %status(clients) = 1252

%EQUAL

%FOUND

%GRAPH

%UCS2

%XFOOT

eval total = %xfoot(tb_salaire) + prime

%DIV

%REM

if   %rem(an : 4 )= 0 

Eval pos = %check('0123456789.' : variable)

eval datcmd = %DATE(datchar : *YMD0)//(c'est un zéro)

eval datliv = datcmd + %DAYS(15)

eval ecart = %DIFF(datliv : datcmd : *DAYS)

eval annee = %SUBDT(datliv : *YEARS)

eval demain = maintenant + %hours(18)

%LOOKUP
(%LOOKUPxx)

voir %HOURS()

voir %DAYS()

exprime un nombre de microsecondes

voir %HOURS

positionne sur une occurrence de DS

%OCCUR(DS1) = 7 ou x = %occur(DS2)

Réalloue un espace mémoire plus grand

voir %ALLOC

%SECONDS

voir %HOURS()

%SHTDN

if %SHTDN

%TIME

if %time(pointage : *HMS) = T'23:59:59'

%TLOOKUP[xx]

voir %lookup

eval resultat = %XLATE('abcdef' : 'ABCDEF' : origine)

voir %DAYS

CHAIN %KDS(dscli) clientf1;
// mais aussi CHAIN (DEPCLI : NOCLI) clientf1;
                          

Update clientf1 %FIELDS(nomcli : depcli : ville) ;

%BITNOT(x'00') = x'FF'

%BITOR(x'F0' : x'0F') = x'FF'

%BITAND(x'F1' : x'1F') = x'11'

%BITXOR(x'F1' : x'1F') = x'EE' [1110 1110)

resultat = %xfoot( %subarr(tbl : i : 5) )// 5 postes

xml-into DS1 %xml(data : 'doc=string')

   Procédures cataloguées [STORED PROCEDURES] :
  -----------------------------------------------


 SQL permet maintenant de demander l'exécution d'un programme sur un serveur
  distant (normalement devant réaliser une action sur la base de ce serveur)


 Cette fonction n'est pas encore normalisée (mais largement répandue).


  - certains SGBD n'autorisent que des procédures SQL.


  - DB2/400 autorise l'appel à n'importe quel programme.


    + avec passage de paramètres.


    + ces paramètres pouvant être modifiés par le pgm distant.




 Syntaxe  CALL nom-procédure----------------------------------------------
                                 |                       |
                                 |-(param1,[param2,...])-|



                          

Il est possible de déclarer une procédure afin de préciser certaines options


DECLARE -nom-proc-PROCEDURE------------------------------------------------>
                             |        |-IN----|                         |
                             |-(param---OUT-----type de données(lg)-----|
                                      |-INOUT-|
   |-EXTERNAL------------------|
 >------------------------------LANGUAGE--langage---------------------------
   |-EXTERNAL NAME-nom-externe-|                   |-SIMPLE CALL-----------|
                                                   |-SIMPLE CALL WITH NULL-|


 définition des paramètres :


    IN  le paramètre est uniquement reçu par la procédure
    OUT le paramètre est renvoyé par la procédure
    INOUT le paramètre est utilisé dans les deux sens


    type de donnée(lg) : idem CREATE TABLE    CHAR(xx)
                                              INT(lg, dec)
                                              etc ...



                          

 EXTERNAL NAME permet de définir le nom réel du pgm sur le serveur, si cette
  clause n'est pas renseignée c'est le nom de procédure qui est utilisé.


 LANGUAGE permet de définir le langage d'origine du pgm à exécuter


          C, CL, COBOL, COBOLLE, RPG, RPGLE, REXX, ...


          ceci est obligatoire avec une procédure REXX


          si cette clause n'est pas utilisé le server recherche l'attribut
           du pgm et par défaut le considère comme un pgm C.




 SIMPLE CALL WITH NULL signifie que le pgm doit recevoir les indicateurs
                        indiquant les valeurs nulles (254 param maxi)


 SIMPLE CALL           le pgm ne reçoit pas ces indicateurs (255 param maxi)




 l'instruction DECLARE PROCEDURE doit être utilisée pour appeler des
  procédures REXX, et doit être écrite AVANT l'instruction CALL.



                          

 Vous pouvez même renvoyer un groupe d'enregistrements en une seule fois :


  Dans la procédure appelée, ajoutez :




       SET RESULT SETS -----------------------------------------------------
                        !                                       !
                        !-----CURSOR nomcurseur-----------------!
                        !                                       !
                        !                                       !
                        !--ARRAY nomdetableau -----FOR x ROWS----




  Le curseur indiqué (il doit être ouvert) ou l'ensemble des enregistrements
   placés dans le tableau (ou la table en COBOL) représentent les valeurs
   en retour retournées au micro.




  L'application cliente (VB, WINDEV, PHP, Java/JDBC, exécute la requête (contenant CALL) 
 et recoit un paquet d'enregistrements, comme si elle avait lancé un SELECT (movefirst puis movenext, etc...)





                          

 Vous pouvez enfin préparer tout cela à l'avance en déclarant une fois pour
  toute la procédure et ses particularités ( ce qui est conseillé )






  CREATE PROCEDURE   -nom-proc--(même syntaxe que DECLARE --)---->


                     ----------------------------------------------.
                       !                                        !
                       !---DYNAMIC RESULT SETS -----n------------
                    
                       


                     n indique le nombre "result sets" retournés


   La définition est enregistrée dans les fichiers SYSPROCS et SYSPARMS
    du catalogue.

                          

 Mais, il est aussi possible de créer des procédures cataloguées SQL en SQL PSM


    (même langage que les bases Oracle avec PL/SQL)


 ATTENTION :


    cela va créer un programme OS/400 qui sera référencé dans les
         catalogues SQL (SYSPROCS et SYSPARMS dans QSYS2)


    mais pour créer ce programme OS, SQL va générer un source C contenant
         du SQL et appeler le compilateur.






      

Exemple général :


  CREATE PROCEDURE xxxxxxx/P1
         (in  nouveau_module CHAR(10) ,
          out probleme       integer  )
         LANGUAGE SQL


         BEGIN ATOMIC
              DECLARE UNDO HANDLER FOR SQLEXCEPTION
                          SET probleme = -1;


              FOR v1 as C1 cursor for SELECT module, nomcours
                                       FROM COURS
                  DO
                  IF nomcours <> ' '
                     THEN
                     UPDATE COURS SET module = nouveau_module
                     WHERE CURRENT OF C1 ;
                  END IF ;
              END FOR;
         END

 I/ syntaxe générale 


          --ATOMIC------
 BEGIN ---              ------------------>
          --NOT ATOMIC--


     déclaratives
       .../...




     instructions SQL
       .../...
       .../...


 END


 ATOMIC ==>   l'ensemble de la procédure doit être réalisé comme un tout,
               vous ne pouvez pas placer d'ordres COMMIT/ROLLBACK


 NOT ATOMIC   pas de validation/invalidation automatique, vous définissez
               vos transactions par COMMIT/ROLLBACK.

 II/ déclaratives :


 on peut déclarer des variables (sauf les paramètres qui sont déja déclarés)


                                          ---DEFAULT NULL-----
    DECLARE ---nom-variable----type-sql---                    -----
                                          ---DEFAULT val/dft--






 on peut assigner des noms aux codes erreurs SQL :


    DECLARE ---nom-condition--- CONDITION FOR -----code-erreur




     code-erreur:       '01234'       = code 1234
                        SQLEXCEPTION  = erreur <0
                        SQLWARNING    = erreur >0 (sauf 100)
                        NOT FOUND     = erreur 100





      

 déclaration de condition d'erreur (sorte de MONMSG ..)


   on déclare 1/ l'erreur (code ou nom-condition)


              2/ le traitement


              3/ la reprise après traitement.
                                                             (1)


    DECLARE   ------------------------  HANDLER FOR  code-erreur--------->
                !              !
             (3)!--CONTINUE----!
                !              !
                !--EXIT--------!
                !              !
                !--UNDO--------!




   >-------instruction SQL ;
                 (2)



      

  la reprise :


     dans tous les cas on exécute le traitement (2) avant de gérer
      la reprise (3)






     CONTINUE =  on continue le code en séquence.
                 (si l'erreur a lieu dans un IF, CASE, WHILE, on sort
                  et on se débranche à l'instruction qui suit le IF ...)




     EXIT     =  on va au END




     UNDO     =  on annule tous les changements (ROLLBACK) puis EXIT,


                  ce qui implique  BEGIN ATOMIC !







      

 III/ Instructions :


  toutes les instructions SQL sont valides, aussi bien les ordres de gestion
   de la base (CREATE, GRANT, ...) que les ordres de manipulation.


 plus, en assignation :


  SET nom-variable = expression (même possibilités que SELECT)


 et en structuration  :


  IF  --test----THEN--instruction;---------->


  >----------------------------------------->
    !                                 !
    !-ELSEIF test2 THEN instruction2;-!


  >--------------------------END IF ;------->
    !                    !
    !-ELSE instruction3;-!



      

CASE


1ere forme


  CASE--nom-variable----------------------->


  >---WHEN valeur1 THEN instruction1;------>


   >----------------------------------------->
     !                                !
     !-WHEN valeur2 THEN instruction2;!


    >------------------------END CASE;
     !                    !
     !-ELSE instruction3;-!






  chaque test se fait par égalité et sur la même variable.





      

CASE


2eme forme


  CASE------------------------------------->


  >---WHEN test1---THEN instruction1;------>


   >----------------------------------------->
     !                              !
     !-WHEN test2 THEN instruction2;!


    >------------------------END CASE;
     !                    !
     !-ELSE instruction3;-!


 chaque test peut utiliser :


             - un autre opérateur que l'égalité.
             - une variable différente.



      

LOOP (boucle)


    -----------------LOOP---------->
     !-label:--!


     série d'instructions SQL;----->


    ----END LOOP;


le seul moyen de sortir de la boucle est LEAVE


WHILE (boucle conditionnée, tant que)


    -----------------WHILE--condition pour boucler--- DO ---->
     !-label:--!


     série d'instructions SQL;----->


    ----END WHILE;


 la condition est testée AVANT de faire.

REPEAT (boucle conditionnée, jusqu'à)


    -----------------REPEAT ---->
     !-label:--!


     série d'instructions SQL;----->


    --UNTIL (condition d'arret)


    ----END REPEAT;


 la condition est testée en fin de boucle (après).




  LEAVE


  ----LEAVE label-------->


      sortie de la boucle qui s'appelle "label"



      

FOR  (exécution d'une série d'instructions pour chaque ligne d'un curseur)


     -------------FOR nomf -------------------------------------->
      !-label:--!           !                                 !
                            !--AS nomcurseur CURSOR FOR-------!


    ----------clause SELECT------------- DO -------------->


     série d'instructions SQL;----->


    END FOR;


si vous utilisez un nom de curseur il doit être unique
   (non déclaré par DECLARE CURSOR)
sinon, il sera déclaré implicitement.


toutes les variables retournées par le SELECT doivent être unique (jointure)
si vous utilisez AS [nocli AS codeclient] c'est "codeclient" que vous devez
    manipuler dans la boucle.


et enfin "nomf" n'est pas utilisable dans la série d'instructions.

  l'ordre FOR remplace la série suivante :


 ..............................................................
 :   DECLARE ... pour chaque variable du SELECT               :
 :                                                            :
 :   DECLARE C1 CURSOR FOR (votre SELECT)                     :
 :                                                            :
 :   OPEN C1;                                                 :
 :                                                            :
 :   FETCH C1 INTO (les variables déclarées plus haut);       :
 :                                                            :
 :   WHILE (fin de fichier non rencontrée)                    :
 :                                                            :
 :     ---vos instructions SQL;---                            :
 :                                                            :
 :     FETCH C1 INTO (les variables déclarées plus haut);     :
 :                                                            :
 :   END WHILE;                                               :
 :                                                            :
 :   CLOSE C1 ;                                               :
 :............................................................:

   Fonctions Définies par l'utilisateur (V4R40) :
  ------------------------------------------------


une fonction est un programme ou une procédure dans un programme de service
 enregistré(e) dans les catalogues SQL par CREATE FUNCTION.


 par exemple :


    CREATE FUNCTION AF4TEST/DT8_CHAR8 (DEC(8 , 0) )
                              RETURNS  CHAR(8)
           EXTERNAL NAME 'AF4TEST/DT_SQL(DT8_CHAR8)'    (1)
           PARAMETER STYLE GENERAL                      (2)
           RETURNS NULL ON NULL INPUT  ;                (3)


(1) fait référence à DT8_CHAR8 dans DT_SQL


(2) le passage de paramètres se fait sans gestion de la val. nulle


(3) la fonction retourne nul si un des argument est nul
     (il n'y aura pas d'appel)



      

 Là aussi vous pouvez utiliser le SQL PSM.


 create function af4test/euro_francs (VALEUR decimal(9, 2))
                 returns decimal(9, 2)
 LANGUAGE SQL RETURNS NULL ON NULL INPUT


 BEGIN (1)
(3) DECLARE VALFRANCS DECIMAL ( 9 , 2 ) ;(2)
(4) SET VALFRANCS= VALEUR * 6.55957;
(5) RETURN VALFRANCS ;
 END;


(1)  le corps de la fonction est encadré de BEGIN  - END;


(2) chaque ligne se termine par ;


(3) les déclarations se font par DECLARE (même types que CREATE TABLE)


(4) les manipulations se font par SET ou VALUES


(5) RETURN termine la fontion en indiquant la valeur retournée.

        -- retourne le libellé d'une date 
CREATE FUNCTION MABIB.LIBDATE ( DATE_IN DATE ) 
                              RETURNS CHAR(27) 
LANGUAGE SQL SPECIFIC MABIB.LIBDATE 
NOT DETERMINISTIC READS SQL DATA 
RETURNS NULL ON NULL INPUT 

BEGIN 
 DECLARE WDATE CHAR ( 27 ) ; 
 DECLARE MOIS CHAR ( 9 ) ; 
 DECLARE JOUR CHAR ( 8 ) ; 
 
 SET JOUR = CASE DAYOFWEEK( DATE_IN ) 
 WHEN 1 THEN 'DIMANCHE' 
 WHEN 2 THEN 'LUNDI' 
 WHEN 3 THEN 'MARDI' 
 WHEN 4 THEN 'MERCREDI' 
 WHEN 5 THEN 'JEUDI' 
 WHEN 6 THEN 'VENDREDI' 
 WHEN 7 THEN 'SAMEDI' 
 END; 
 
 SET MOIS = CASE SUBSTR ( CHAR ( DATE_IN ) , 6 , 2 ) 
 WHEN '01' THEN 'JANVIER' 
 WHEN '02' THEN 'FÉVRIER' 
 WHEN '03' THEN 'MARS' 
 WHEN '04' THEN 'AVRIL' 
 WHEN '05' THEN 'MAI' 
 WHEN '06' THEN 'JUIN' 
 WHEN '07' THEN 'JUILLET' 
 WHEN '08' THEN 'AOUT' 
 WHEN '09' THEN 'SEPTEMBRE' 
 WHEN '10' THEN 'OCTOBRE' 
 WHEN '11' THEN 'NOVEMBRE' 
 WHEN '12' THEN 'DÉCEMBRE' 
 END ; 
 
 SET WDATE = TRIM(JOUR) CONCAT ', ' 
 CONCAT SUBSTR ( CHAR ( DATE_IN ) , 9 , 2 ) 
 CONCAT ' ' CONCAT TRIM(MOIS) 
 CONCAT ' ' CONCAT SUBSTR ( CHAR ( DATE_IN ) , 1 , 4 ) ; 
 
 RETURN WDATE ; 
 END ; 


      

        -- retourne une date de jj/mm/aa vers aaaa-mm-jj

CREATE FUNCTION MABIB.INVDATE ( CHAR_IN CHAR(10) ) 
                                RETURNS CHAR(10) 
 LANGUAGE SQL SPECIFIC MABIB.INVDATE 
 NOT DETERMINISTIC READS SQL DATA 
 RETURNS NULL ON NULL INPUT 
 
 BEGIN 
 DECLARE WDATE CHAR(10) ; 
 SET WDATE = CASE 
 WHEN LENGTH(TRIM(CHAR_IN)) > 8 
 THEN SUBSTR(CHAR_IN, 7 ,4) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 4 ,2) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 1, 2) 
 WHEN LENGTH(TRIM(CHAR_IN)) > 6 
 THEN '20' CONCAT SUBSTR(CHAR_IN, 7 ,2) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 4 ,2) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 1, 2) 
 ELSE 
 '20' CONCAT SUBSTR(CHAR_IN, 5 ,2) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 3 ,2) 
 CONCAT '-' CONCAT SUBSTR(CHAR_IN, 1, 2) 
 END; 
 
 RETURN WDATE ; 
 END ; 

      

 et enfin la création de triggers en SQL (V5R10) :


                                                    --- BEFORE----
 CREATE TRIGGER --nom-trigger----------------------!              !------>
                                                    ---AFTER------


       ---INSERT-----------------------------------
       !                                          !
 >-----!--DELETE----------------------------------!-----REFERENCING--->
       !                                          !
       !--UPDATE----------------------------------!
                !                      !
                !-- OF colonne --------!


      ----OLD ROW -- AS ---nom-correlation-------
      !                                         !
      !---NEW ROW -- AS ---nom correlation------!   -FOR EACH STATEMENT-
 >----!                                         !---!                   !->
      !---OLD TABLE -- AS --identifiant---------!   --- FOR EACH ROW----
      !                                         !
      !---NEW TABLE -- AS --identifiant---------!

                                           --MODE DB2ROW---
>---- SET OPTION (option de compilation)--!                !-------->
                                           --MODE DB2SQL---


>-----WHEN (condition d'exécution du trigger)---------------->


>-BEGIN
  ...
(corps du trigger )
  ...
  END


quelques explications :


 + BEFORE ne peut pas contenir des ordres INSERT, UPDATE, DELETE
          mais peut modifier les variables de la table par SET.


   AFTER peut contenir des ordres INSERT, UPDATE, DELETE sur d'autres tables




    

 + INSERT | DELETE | UPDATE représentent l'événement associé(READ non admis)


   UPDATE OF "colonne" permet de ne déclencher le trigger que si "colonne"
     a été modifiée.


 + REFERENCING OLD ROW | NEW ROW


               OLD n'est valide qu'avec UPDATE, DELETE
               NEW   "     "       "    UPDATE, INSERT




    exemple :  REFERENCING OLD ROW AS avant NEW ROW AS apres


                puis dans le code :


                  IF apres.prix > avant.prix ....




  OLD ROW, NEW ROW ne peuvent pas être utilisés avec l'option
    FOR EACH STATEMENT.


    

exemple, lors d'une modification si le prix actuel est < au prix d'achat
  il doit prendre au moins la valeur du nouveau prix d'achat :


 ........................................................................
 :                                                                      :
 : CREATE TRIGGER  MAJ_PRIX BEFORE UPDATE OF CAV_PRXACTUEL              :
 :                           ON BDVIN/MA_CAVE                           :
 :  REFERENCING NEW ROW AS NOUVEAU                                      :
 :  FOR EACH ROW MODE DB2ROW                                            :
 :                                                                      :
 : BEGIN                                                                :
 :                                                                      :
 :  IF NOUVEAU.CAV_PRXACTUEL < NOUVEAU.CAV_PRIX THEN                    :
 :      SET NOUVEAU.CAV_PRXACTUEL = NOUVEAU.CAV_PRIX ;                  :
 :  END IF;                                                             :
 :                                                                      :
 : END                                                                  :
 :                                                                      :
 :......................................................................:




    

 + REFERENCING OLD TABLE | NEW TABLE


                OLD n'est valide qu'avec UPDATE, DELETE
                NEW   "     "       "    UPDATE, INSERT




     OLD table représente une table temporaire contenant l'ensemble
         des enregistrements modifiés ou supprimés.
         (les valeurs sont celles avant l'instruction d'origine)


     NEW table représente une table temporaire contenant l'ensemble
         des enregistrements insérés ou supprimés.
         (les valeurs sont celles après l'instruction d'origine et après
           l'appel du(des) trigger(s) BEFORE)


    ces deux options ne peuvent être utilisées qu'avec :
      le mode DB2SQL, et le moment AFTER.
      (FOR EACH ROW ou FOR EACH STATEMENT)




    

exemple, on trace cumul des prix modifiés :
.......................................................................
: CREATE TRIGGER  VIN_CUMUL  AFTER UPDATE OF CAV_PRIX                 :
:                            ON BDVIN9/MA_CAVE                        :
: REFERENCING OLD TABLE AS OCAVE                                      :
:           NEW TABLE AS NCAVE                                        :
: FOR EACH STATEMENT MODE DB2SQL                                      :
:                                                                     :
:  BEGIN                                                              :
:   DECLARE AV_CUMUL DEC(11, 2);                                      :
:   DECLARE AP_CUMUL DEC(11, 2);                                      :
:                                                                     :
:   SELECT SUM(CAV_PRIX) INTO AV_CUMUL FROM OCAVE  ;                  :
:   SELECT SUM(CAV_PRIX) INTO AP_CUMUL FROM NCAVE  ;                  :
:                                                                     :
:   INSERT INTO AF4TEST/CUMUL VALUES(NOW() , AV_CUMUL, AP_CUMUL) ;    :
:  END                                                                :
:.....................................................................:
 suite à un ordre : update bdvin9/ma_cave set cav_prix = cav_prix * 1,5


  QUAND                          AVANT_CUMUL      APRES_CUMUL  
  2001-08-23-14.25.20.181728          205,95           308,92

 + FOR EACH ROW | EACH STATEMENT


   FOR EACH ROW le trigger est appelé une fois par ligne


       cas des contrôles, des mise à jour de champs, des traces ...




   FOR EACH STATEMENT le trigger est appellé une fois par instruction.


       cas de recalcule automatique de cumuls, etc...


     ATTENTION : le trigger est appellé même si aucune ligne n'est impactée


 + MODE DB2ROW , DB2SQL


   MODE DB2ROW, l'appel a lieu à chaque ligne modifiée,


                BEFORE ET AFTER sont valides,


                FOR EACH STATEMENT et l'utilisation de OLD TABLE/NEW TABLE
                  ne sont PAS admis.

   MODE DB2SQL, l'appel a lieu à la fin de l'instruction,


                seul AFTER est valide,


                FOR EACH STATEMENT et l'utilisation de OLD TABLE/NEW TABLE
                  SONT admis.


   les valeurs reçues sont bien celles utilisée lors de la transaction,
    la grande différence est que le trigger n'est appellé que si l'ordre
    SQL va jusqu'au bout.


 exemple : 


   mise à jour d'un fichier dont la dernière ligne est verrouillée par un
    autre JOB, le trigger écrit dans une table afin de conserver une trace.


   avec MODE DB2ROW le trigger est appellé (n - 1 ) fois,  n étant le
    nombre d'enregistrements à modifier.


   avec MODE DB2SQL le trigger n'est pas activé (fichier trace vide).


    

 + SET OPTIONS


       options du compilateur (C), particulièrement DBGVIEW = *SOURCE


 + WHEN (condition)


       condition quant à l'appel du trigger


 exemple :
 ........................................................................
 :                                                                      :
 : CREATE TRIGGER  MAJ_PRIX BEFORE UPDATE OF CAV_PRXACTUEL              :
 :                           ON BDVIN/MA_CAVE                           :
 :  REFERENCING NEW ROW AS NOUVEAU                                      :
 :  FOR EACH ROW MODE DB2ROW                                            :
 :  WHEN (NOUVEAU.CAV_PRXACTUEL < NOUVEAU.CAV_PRIX)                     :
 :                                                                      :
 : BEGIN                                                                :
 :      SET NOUVEAU.CAV_PRXACTUEL = NOUVEAU.CAV_PRIX ;                  :
 : END                                                                  :
 :......................................................................:

Gestion des erreurs et triggers

UNDO n'est pas valide, utilisez ATOMIC (trigger complet ou rien)
     ou bien gérer le COMMIT/ROLLBACK


 GET DIAGNOSTIC variable ROW COUNT : retourne le nombre de lignes affectées
  "     "         "      RETURN STATUS "       "  dernier code status



 pour signaler un code retour, terminer la procédure par RETURN n°


       RETURN 0
   ou
       RETURN -200



 pour signaler une erreur, utilisez SIGNAL (ordre de la V4)


   SIGNAL SQLSTATE 'n°'---------------------------------------- -
                         !--- SET MESSAGE_TEXT 'votre-texte'--!


   RESIGNAL  doit être placé dans un condition handler


   (sans paramètres, il génère l'erreur qu'il a lui-même recu.)
    

SQLSTATE est amené à remplacer SQLCOD/SQLCODE (orientation ISO)


 SQLSTATE est composé de CINQ caractères (chiffres ou lettres)


 les deux premiers caractères représentent la classe,
  les codes commencant par 0 à 6 et A à H sont réservés


  00 : Success (terminé normalement)
  01 : Warning (message d'attention), donne SQLCOD = +438)
  02 : No DATA (l'équivalent de SQLCOD = 100)
  03 à ZZ : erreur, donne SQLCOD = -438.
   (38 signale la fin anormale, d'une fonction par exemple)


  le troisième caractère représente la sous classe.
  les sous classes de '0' à 'H' sont réservés, I à Z est libre.


 les codes commencant par 7,8,9 et I à Z sont libres,les sous classes aussi.
 ce qui fait que vous devez utiliser :
 - '00000' quand tout va bien.
 - '01Hxx' pour signaler un WARNING.
 - '38Ixx' à '38Zxx' pour signaler vos erreurs dans vos fonctions/triggers.
 - un code disponible dans les autres cas.