Overblog
Suivre ce blog Administration + Créer mon blog
19 février 2017 7 19 /02 /février /2017 11:42

// Voir fmr050


**free
ctl-opt option(*srcstmt :*nodebugio) actgrp(‘MILAN’) ;

dcl-ds enregw;
    mois packed(2) ;
    code packed(8) ;
    codcli char(8) ;
end-ds ;

dcl-ds nullw int(5) dim(3) ;

dcl-s mylocator sqltype(result_set_locator) ;

exec sql 
call fmr050(7) ;

exec sql
associate locator(:mylocator) with procedure fmr050 ;

exec sql
allocate c1 cursor for result set :mylocator ;

exec sql
fetch c1 into :enregw :nullw ;

exec sql
close c1 ;

Partager cet article
Repost0
5 août 2010 4 05 /08 /août /2010 13:52

/* Pour Escape dans Programme de Service  DT99                       */
             PGM        PARM(&MSGW)
             DCL        VAR(&MSGW) TYPE(*CHAR) LEN(512)
             SNDPGMMSG  MSGID(CPF9898) MSGF(QCPFMSG) MSGDTA(&MSGW) +
                          MSGTYPE(*ESCAPE)
             ENDPGM

 

* Prototypes d'appel :

     Ddt99             pr              d
     D n80x                           8  0 const options(*nopass:*omit)
     D a10x                          10    const options(*nopass:*omit)
     D fmtx                           5    const options(*nopass:*omit)

 

     Ddt99n            pr              d
     D n80x                           8  0 const

 

     Ddt99a            pr              d
     D a10x                          10    const varying

 

     Ddt99as           pr              d
     D a10x                          10    const varying

 

     Ddt99naf          pr              d
     D n80x                           8  0 const
     D a10x                          10    const varying
     D fmtx                           5    const varying

 

 

 

      * Test  1
      *
     Hdftactgrp(*no)
     Hactgrp('milan')
     Hbnddir('SPX2')
     Hdatfmt(*iso)
     Hoption(*srcstmt:*nodebugio)

     Fdt99tstd  cf   e             workstn

      /copy sources,dt99k

     D                sds
     Dproc_name          *proc
     Duserr2                 254    263

 

 

     Dbouclew          s               n                   do *hival
      /free
           fmt1w = '*cymd';

           dou bouclew;        // B o u c l e   1

           exfmt ecran01;      // A f f i c h a g e
           if *inkc or *inkl;  //
           exsr srfin;         // Fin
           endif;

           monitor;
           dt1w    = dt99(n1w:a1w:fmt1w);
           dt2w    = dt99(n2w);
           dt3w    = dt99(0:a3w);
           nn3w    = %dec(dt99(0:a3w):*usa);
           aa3w    = %char(dt99(0:a3w):*longjul);
           on-error;
           *in51 = *on;
           endmon;

           enddo;


         // S o u s - p r o g r a m m e ( s ) * * * * * * * * * * * *


           begsr srfin;        // Fin de programme
           *inlr = *on

            return;
           endsr;


      /end-free

 

 

 

 

      * Test  2
      *
     Hdftactgrp(*no)
     Hactgrp('milan')
     Hbnddir('SPX2')
     Hdatfmt(*iso)
     Hoption(*srcstmt:*nodebugio)

     Fdt99tst2d cf   e             workstn

      /copy sources,dt99k

     D                sds
     Dproc_name          *proc
     Duserr2                 254    263

 

 

     Dbouclew          s               n                  do *hival
      /free

           dou bouclew;        // B o u c l e   1

           exfmt ecran01;      // A f f i c h a g e
           if *inkc or *inkl;  //
           exsr srfin;         // Fin
           endif;

           monitor;
           dt1w    = dt99n(n1w);
           dt2w    = dt99a(a2w);
           dt3w    = dt99as(a3w);
           dt4w    = dt99naf(n4w:a4w:fmt4w);
           on-error;
           *in51 = *on;
           endmon;

           enddo;


         // S o u s - p r o g r a m m e ( s ) * * * * * * * * * * *


           begsr srfin;        // Fin de programme
           *inlr = *on;
           return;
           endsr;


      /end-free

Partager cet article
Repost0
4 août 2010 3 04 /08 /août /2010 13:51

      *              Programme de Service  v1
      *              Fonctions de date
     Hnomain
     Hdatfmt(*iso)


DT99  * renvoie une   Date
      *   parm1   Num    8 0  || 991130 1091129 20080223 0         *omit     ||
      *   parm2   Alpha 10    || rien   ' '     *omit   '1101231' '17890714' ||
      *   parm3   Alpha  5  (*iso,*eur,*usa,*cymd,*ymd,*cdmy,*dmy,*cmdy,*mdy)
      *

      /copy sources,dt99k

     Pdt99             b                   export

     Ddt99             pi              d
     Dn80x                            8  0 const options(*nopass:*omit)
     Da10x                           10    const options(*nopass:*omit)
     Dfmtx                            5    const options(*nopass:*omit)

      * Message d'escape
     Ddt99c            pr                  extproc('DT99C')
     D parm1                        512    const

      * Zones de travail correspondant au paramètres
     Dretw             s                   like(dt99)
     Dn80w             s                   like(n80x)
     Da10w             s                   like(a10x)
     Dfmtw             s                   like(fmtx) inz('*cymd')

     Derrfmtw          s               n

      /free

        // Si transmis les parametres sont affectés.
         if %parms >= 1 and
            %addr(n80x) <> *null;
         n80w = n80x;
         endif;

         if %parms >= 2 and
            %addr(a10x) <> *null;
         a10w = a10x;
         endif;

         if %parms >= 3 and
            %addr(fmtx) <> *null;
         fmtw = fmtx;
         endif;


        // Numérique ou alpha, mais pas les deux !
         if n80w <> 0 and a10w <> *blanks;
         callp dt99c('Numérique ou Alpha, mais pas les deux : ' +
               %editc(n80w:'X') + ' ' + a10w + ' !'); // Erreur, escape
         endif;


        // Si blank ou des zéro :
         if n80w = 0 and
           (a10w = *blanks or
           (%check('  0':a10w) = 0));
         return  *loval;               // Retour *loval  0001-01-01
         endif;


          monitor;

         // Les éventuels séparateurs de date sont enlevé.

         // Convertion en numérique
          if a10W <> *blanks;
          n80w = %dec(%xlate('/-_.,:;':'       ':a10w):8:0);
          endif;

         // Traitement des 999999
          if (fmtw = '*cymd' or fmtw = '*cdmy' or fmtw = '*cmdy' or
               fmtw = '*ymd ' or fmtw = '*dmy ' or fmtw = 'cmdy ') and
             (n80w = 999999 or n80w = 1999999);
          return *hival;                  // Retour *hival  9999-12-31
          endif;

         // Conversion en date
          select;
          when fmtw = '*cymd';
          retw = %date(n80W:*cymd);
          when fmtw = '*ymd ';
          retw = %date(n80W:*ymd);
          when fmtw = '*cdmy';
          retw = %date(n80W:*cdmy);
          when fmtw = '*dmy ';
          retw = %date(n80W:*dmy);
          when fmtw = '*cmdy';
          retw = %date(n80W:*cmdy);
          when fmtw = '*mdy ';
          retw = %date(n80W:*mdy);
          when fmtw = '*iso ';
          retw = %date(n80W:*iso);
          when fmtw = '*eur ';
          retw = %date(n80W:*eur);
          when fmtw = '*usa ';
          retw = %date(n80W:*usa);
          other;
          errfmtw = *on;              // Le format doit être valide !
          endsl;

          on-error;
          retw = d'0001-01-02';      // Date invalide (par convention)
          endmon;


          if errfmtw;   // Erreur, escape
          callp dt99c('Format d''appel inconnu : ' +

            fmtw + ' !');            

          endif;


          return retw;                         // Retour d'une date

      /end-free
     P                 e

 


      // Pour être appelable par une fonctions Sql,

      // no more paramètres facultatifs.

 
      // Entrée numérique, format par défaut.

     Pdt99n            b                   export

     Ddt99n            pi              d
     Dn80x                            8  0 const

      /free

           return  dt99(n80x);

      /end-free
     P                 e


      // Entrée alpha, format par défaut.

     Pdt99a            b                   export

     Ddt99a            pi              d
     Da10x                           10    const varying

     Da10w             s                   like(a10x)

      /free

           a10w = a10x;
           return  dt99(*omit:a10w);

      /end-free
     P                 e


      // Entrée alpha, format par *cmdy pour les pseudo-dates système

     Pdt99as           b                   export

     Ddt99as           pi              d
     Da10x                           10    const varying

     Da10w             s                   like(a10x)

      /free

           a10w = a10x;
           return  dt99(*omit:a10w:'*cmdy');

      /end-free
     P                 e

 

      // Tous parametres

     Pdt99naf          b                   export

     Ddt99naf          pi              d
     Dn80x                            8  0 const
     Da10x                           10    const varying
     Dfmtx                            5    const varying

      /free

           return  dt99(n80x:a10x:fmtx);

      /end-free
     P                 e

Partager cet article
Repost0
3 août 2010 2 03 /08 /août /2010 16:09

DT99    the Ultimate Date Functions...   ;-))

 

Une nouvelle fonction DT99, éventuellement associée à des
%bif Rpg - built in function - ou des fonctions Sql,
devrait nous permettre de vaincre l'énervant incomfort  :o((
où nous entrainent les pseudo-dates des anciens fichiers et traitements.

 
Songeons-y : les fonctions se combinent entres elles.
(Et parfois commes les feuilles mortes, se ramassent à l'appel...)

 

Quelques caractèristiques des - anciennes, espérons-le ! - pseudo-dates :
  numérique ou alpha
  une ou plusieurs parties
  le "siècle" plus ou moins indiqué
  n'est pas forcement valide
  valeurs spéciales genre 999999 ou zéro/blanc

 

Que voulons-nous ?
  Une date - une vraie ! - en sortie
  0001-01-01 si blanc ou zéro
  0001-01-02 si non valide
  2010-12-25 à Noël prochain, par exemple
  9999-12-31 si 999999

 

Cette fonction, DT99, écrite en Rpg Ile free format, est logée dans un
programme de service. Notez l'usage de paramètres facultatifs.

 

**************************************************************************************************

 

DT99       renvoie une   Date
                 parm1   Num    8 0     ||  991130   1091129   20080223     0          *omit           ||
                 parm2   Alpha 10       ||  rien          ' '             *omit       '1101231'    '17890714' ||
                 parm3   Alpha  5        (*iso, *eur, *usa, *cymd, *ymd, *cdmy, *dmy, *cmdy, *mdy)

 

La valeur d'un seul parametre, parmi les deux premiers,
doit étre transmise, attn tout de même à la position : cf. 62sus. Sinon message d'escape.
Le troisième est facultatif, *cymd par défaut. Concerne le format de la pseudo-date transmise.
Une erreur dans le format provoque une message d'escape.

 
Au cas ou une pseudo-date soit en plusieurs morceaux, voici quelques possibilité offertes
par les expressions Rpg :

   maDate1 = dt99((n1w*10000)+(n2w*100)+n3w);    // année mois jour en numérique

   maDate2 = dt99(0:(%trim(a1w)+%trim(a2w)+%trim(a3w));    // en alpha

 
Possibilité d'imbriquer une fonction, par exemple :

   maDate3 = dt99(mafonct1(n1w:n2w:n3w));  //idem maDate1, mafonct fait les * et +

   maDate4 = dt99(mafonct2(sieclew:dt6w)); //multiplie le sieclew par un million et
                                                     l'ajoute à dt6w

 

   Vous pouvez souhaiter que les pseudo-dates à zéro ou blanc donne 0001-01-02 - "non valide"
   dans notre codification - au lieu de 0001-01-01. Dans ce cas, une fonction bien placée
   modifiera subtilement la donnée en entrée...

   (Ceux qui souhaite pouvoir parametrer la valeur de retour d'une date "non valide"
    sont invité à se procurer la version "Enterprise" du logiciel...)

 
DT99 renvoie une date. Souhaitez-vous un autre format en sortie, numérique ou alpha,
préciser le format de la pseudo-date, pas de problème, les %bif Rpg sont là :

   nn3w  = %dec(dt99(0:a3w):*usa);
   aa3w  = %char(dt99(n3w):*longjul);

 
A partir de cette fonction initialle, nous avons
créer les fonctions plus spécialisées DT99N, DT99A, DT99AS, DT99NAF.
Leurs paramètres ne sont pas facultatifs,
ce qui nous permet de les appeler via Sql.
Nous sommes  bien sur un AS400 iSeries i5 system i IBM i, non !

 

  create function  milan/dt99naf(dec(8, 0), varchar (10),
  varchar(5))
  returns    date
  language RPGLE
  no sql
  external name 'milan/DT99(DT99NAF)'
  parameter style general
  returns null on null input

 

Utilisation Sql :

 

 select dt99naf(datenum ,'','*cymd')
 from fichier

 

 select dt99n(datenum)
 from fichier

 

 select dt99a(datealpha)
 from fichier

 

 select dt99naf(0, odccen || odcdat, '*cmdy') from fichiersystem


       ou + simplement :

 
 select dt99as(odccen || odcdat) from fichiersystem
       -- pratique pour les pseudo-dates système !

 
En résumé, et ce n'est pas nouveau,
l'intérêt des fonctions n'est plus à démontrer...
Et sur le i aussi !
QED

 

 
(Il se trouve que je m'appelle 1000 ans, alors les dates...)

Partager cet article
Repost0
20 juillet 2010 2 20 /07 /juillet /2010 16:07

      * Demande un nom de fichier, biblio, éventuellement un préfix.
      * Génère dans un fichier source "srcg", 

      * le détail des instructions SQL Select, Insert, Update

      * et des cartes D.
      * afin d'éviter l'emploi de * (toute les zones).
      *
     Hdftactgrp(*no)
     Hactgrp('milan')
     Hoption(*srcstmt:*nodebugio)

     Ftst020D   cf   e             workstn

     D                sds
     Dproc_name          *proc
     Duserr2                 254    263


     Dbouclew          s               n                        Do *hival
     Diw               s              3  0                      Ctr
     Dimaxw            s              3  0                      Ctr zones
     Dtrvw             s               n                        Trouvé
     Dokw              s               n                        OK
     Dzerow            s              3  0                      Pour anom
     Dopenw            s               n                        ouverture curseur
     Dbibfichw         s             21    varying              Pour message info

      * Attn, certaines longueurs tronquées...
     DcolomnDS         ds
     Dsys_column_name                10
     Ddata_type                       8
     Dlength                          3  0
     Dnumeric_scale                   3  0
     Dis_nullable                     1
     Dcolumn_heading                 60
     Dcolumn_text                    50

     Dsrcdtaw          s            100
     Dsrcseqw          s              6  0
     Despacesw         s             10
     Despace5w         s              5
     Dnumeric_scale2w  s              3
     Dtextew           s             60
     Dvirgw            s              1
     Dcmdw             s           2000    varying


      * La spécif D
     Dspecifdds        ds
     Dddw                             1    inz('D')
     Ddnomw                          15
     Dsp1W                            2
     Dddeclaw                         2
     Dsp2W                            7
     Ddlongw                          7
     Ddtypew                          1
     Dddecw                           2
     Ddkw                            37
     Dsp3W                            1
     Ddcommentw                      20


     Dfetchsql         pr
     D NextFirstw                     9    value

     Dvrfsql           pr

     Ddegrossissage    pr

     Diplus            pr
     Dquoiw                          10    value varying

     Dclosecurseur     pr

     Dqcmdexc          pr                  extpgm('QCMDEXC')
     D cmd                        32702    options(*varsize) const
     D cmdlen                        15  5 const


      /free
              exec sql
              set option commit = *none, datfmt = *iso;

              exec sql
              declare curseur scroll cursor for
              select system_column_name, data_type,
              length, ifnull(numeric_scale, -1), is_nullable,
              ifnull(column_heading, ''),
              ifnull(column_text, '')
              from syscolumns
              where system_table_name = :fichierw and
                    system_table_schema = :bibliow;


           monitor;

           dou bouclew;        // B o u c l e   1
           closecurseur();
           exfmt ecran01;      // A f f i c h a g e
           if *inkc or *inkl;  //
           exsr srfin;         // Fin
           endif;

           if fichierw= *blanks;
           *in51 = *on;             // Saisir le nom d'un fichier !
           iter;
           endif;

           if  bibliow= *blanks;
           *in52 = *on;             // Saisir le nom de bibliothèque !
           iter;
           endif;

           bibfichw = %trim(bibliow) + '/' +  %trim(fichierw);


           messw = *blanks;


           cmdw = 'clrpfm srcg';    //  Mise à blanc du fichier résultat
           qcmdexc(cmdw:%len(cmdw));

           srcseqw = 0;


          // P h a s e   1 ,  g é n é r a t i o n   d e   S e l e c t   :
              exec sql           -- Ouverture du curseur
              open curseur;
              vrfsql();
              openw = *on;

 

           iw = 0;
           dou bouclew;          // Boucle de lecture

           fetchsql('NEXT');

           if sqlstate = '02000';
           leave;                // Retour affichage
           endif;

           iw += 1;

           if iw = 1;
           srcseqw += 1;
           srcdtaw = espacesw + 'Declare curseur scroll cursor for select';
              exec sql                                         -- Première ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();
           endif;

           degrossissage();

           srcseqw += 1;
           srcdtaw = espacesw + sys_column_name + ', -- ' + textew +
                   %editc(length:'J') + ' ' + numeric_scale2W;
              exec sql                                               -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           enddo;

           imaxw = iw;               // Nbre de zones


           srcseqw += 1;
           if iw > 0;
           srcdtaw = espacesw + 'from ' + fichierw + ' where ... ' +
                     %editc(iw:'J') + ' zones   ' +  %char(%timestamp());
           else;
           srcdtaw = espacesw + 'Fichier ' + bibfichw + ' NON trouvé !';
           endif;
              exec sql                                         -- Dernière ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           if iw > 0;
           messw = 'Fichier ' + bibfichw + ' traité.   ' + %editc(imaxw:'J') +
                   ' zones.   ' + %char(%timestamp());
           else;
           *in53 = *on;            // Fichier NON trouvé !
           iter;
           endif;


          // P h a s e   2 ,   g é n é r a t i o n   d e   F e t c h  :

           srcseqw += 1;
           srcdtaw = '2 * * * * * * * * * * * * *';
              exec sql                                              -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           srcseqw += 1;
           srcdtaw = espacesw + 'fetch next from curseur into';
              exec sql                                        -- Première ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('FIRST');

           virgw = ',';
           iw = 0;
           dou bouclew;          // Boucle de lecture

           if sqlstate = '02000';
           leave;
           endif;

           iplus(';');

           degrossissage();

           srcseqw += 1;
           srcdtaw = espacesw + ':' +
                   %replace(%trim(prefixw):sys_column_name:1:carasuppw) +
                   virgw + ' -- ' + textew +
                   %editc(length:'J') + ' ' + numeric_scale2W;
              exec sql                                                -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('NEXT');

           enddo;

 

          // P h a s e   3 ,   g é n é r a t i o n   d e   I n s e r t   :

           srcseqw += 1;
           srcdtaw = '3 * * * * * * * * * * * * *';
              exec sql                                                -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           srcseqw += 1;
           srcdtaw = espacesw + 'insert into ' + fichierw + ' (';
              exec sql                                          -- Première ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('FIRST');

 

           virgw = ',';
           iw = 0;
           dou bouclew;          // Boucle de lecture

           if sqlstate = '02000';
           leave;
           endif;

           iplus(' ');

           degrossissage();

           srcseqw += 1;
           srcdtaw = espacesw + sys_column_name + virgw + ' -- ' + textew +
                   %editc(length:'J') + ' ' + numeric_scale2W;
              exec sql                                              -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('NEXT');

           enddo;

 

           srcseqw += 1;
           srcdtaw = espacesw + ') values (';
              exec sql                                              -- Transition
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();


           fetchsql('FIRST');   // Insert, 2°partie

 

           virgw = ',';
           iw = 0;
           dou bouclew;          // Boucle de lecture

           if sqlstate = '02000';
           leave;
           endif;

           iplus(');');

           degrossissage();

           srcseqw += 1;
           srcdtaw = espacesw + ':' +
                   %replace(%trim(prefixw):sys_column_name:1:carasuppw) +
                   virgw + ' -- ' + textew +
                   %editc(length:'J') + ' ' + numeric_scale2W;
              exec sql                                                -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('NEXT');

           enddo;

 


          // P h a s e   4 ,   g é n é r a t i o n   d e   U p d a t e   :

           srcseqw += 1;
           srcdtaw = '4 * * * * * * * * * * * * *';
              exec sql                                                -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           srcseqw += 1;
           srcdtaw = espacesw + 'update ' + fichierw + ' set';
              exec sql                                        -- Première ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('FIRST');

           virgw = ',';
           iw = 0;
           dou bouclew;          // Boucle de lecture

           if sqlstate = '02000';
           leave;
           endif;

           iplus(' ');

           degrossissage();

           srcseqw += 1;
           srcdtaw = espacesw + sys_column_name + ' = ' +
            ':' +  %replace(%trim(prefixw):sys_column_name:1:carasuppw) +
                   virgw + ' -- ' + %subst(textew:1:45) +
                   %editc(length:'J') + ' ' + numeric_scale2W;
              exec sql                                              -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('NEXT');

           enddo;


           srcseqw += 1;
           srcdtaw = espacesw + 'where ???';
              exec sql                                        -- Dernière ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

 


          // P h a s e   5 ,   g é n é r a t i o n   d e   S p é c i f   D   :

           srcseqw += 1;
           srcdtaw = '5 * * * * * * * * * * * * *';
              exec sql                                                -- Pam
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           srcseqw += 1;
           dnomw = %trim(fichierw) + 'DS';
           ddeclaw = 'ds';
           srcdtaw = espace5w + specifdds;
              exec sql                                       -- Première ligne
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('FIRST');

           ddeclaw = '';
           iw = 0;
           dou bouclew;          // Boucle de lecture

           if sqlstate = '02000';
           leave;
           endif;

           iplus(' ');

           degrossissage();

           dnomw = %replace(%trim(prefixw):sys_column_name:1:carasuppw);
           if numeric_scale2w = 'D' or numeric_scale2W = 'Z';      // Type D ou Z
           dtypew = numeric_scale2w;
           dlongw = *blanks;
           ddecw  = *blanks;
           else;                                                   // Usual type
           dtypew = *blanks;
           evalr dlongw = %editc(length:'3');
           evalr ddecw  = %editc(numeric_scale:'3');
           endif;
           dcommentw = textew;
           srcseqw += 1;
           srcdtaw = espace5w + specifdds;
              exec sql                                              -- Ecriture
              insert into srcg(srcseq, srcdta) values(:srcseqw, :srcdtaw);
              vrfsql();

           fetchsql('NEXT');

           enddo;

 


           enddo;

 

           on-error;
           exfmt ecranom;         // Anomalie grave
           exsr srfin;
       endmon;

         // S o u s - p r o g r a m m e ( s ) * * * * * * * * * * * * * * * * * *


           begsr srfin;        // Fin de programme
           closecurseur();
           *inlr = *on;
           return;
           endsr;


      /end-free

         // S o u s - p r o c é d u r e ( s )  *****************************************************

     Pvrfsql           b
     D                 pi
     C                   select
     C                   when      sqlstate = '00000'
     C                   when      sqlstate = '02000'
     C                   when      sqlstate = '01504'
     C                   other
      * Anomalie grave : remontée dans le "main"...
     C                   eval      zerow = 1/zerow
     C                   endsl

     C                   return
     P                 e

 

     Pfetchsql         b
     D                 pi
     D NextFirstw                     9    value
      /free
           select;
           when      nextfirstw = 'NEXT';
              exec sql                                                -- Le suivant
              fetch next  from curseur into
              :sys_column_name, :data_type,
              :length, :numeric_scale, :is_nullable,
              :column_heading, :column_text;
           when      nextfirstw = 'FIRST';
              exec sql                                                -- Le premier
              fetch first from curseur into
              :sys_column_name, :data_type,
              :length, :numeric_scale, :is_nullable,
              :column_heading, :column_text;
           endsl;
              vrfsql();
              return;
      /end-free
     P                 e

 

     Piplus            b
     D                 pi
     Dquoiw                          10    value varying
      /free
           iw += 1;
           if iw = imaxw;
           virgw = quoiw;
           endif;

           return;
      /end-free
     P                 e

 

     Pdegrossissage    b
     D                 pi
      /free
           exec sql

           values lower(:sys_column_name)

           into :sys_column_name;   -- En minuscule
           vrfsql();

           if numeric_scale = -1;
           numeric_scale2w = *blanks;
           else;
           numeric_scale2w = %editc(numeric_scale:'3');
           endif;

           select;
           when data_type = 'DATE';
           numeric_scale2w = 'D';
           when data_type = 'TIMESTMP';
           numeric_scale2w = 'Z';
           endsl;

           if column_text = '';                // Heading ou Text
           textew = column_heading;
           else;
           textew = column_text;
           endif;

           return;
      /end-free
     P                 e

 

     Pclosecurseur     b
     D                 pi
      /free
           if openw;          // Si nécessaire
              exec sql
              close curseur;
              vrfsql();
           openw = *off;
           endif;

           return;
      /end-free
     P                 e

 

Partager cet article
Repost0
4 juin 2010 5 04 /06 /juin /2010 15:05

// Mise à jour d'une table en Sqlrpgle.

// Proche de cet exemple Rpg .

// Les accès Sql sont dans des sous-procédures.

    

     Hdftactgrp(*no)
     Hactgrp('milan')
     Hoption(*srcstmt:*nodebugio)

     Ftst010D   cf   e             workstn


     D                sds
     Dproc_name          *proc
     Duserr2                 254    263

     Dcl_client      e ds           extname(client) prefix(cl_)


     Dbouclew          s               n              do *hival
     Dtrvw             s               n              Trouvé
     Dokw              s               n              OK
     Dzerow            s              3  0            Pour anom

      * Prototypes des appels Sql
     DchainClient      pr              n
     DwriteClient      pr              n
     DupdateClient     pr              n
     DdeleteClient     pr              n

      /free
              exec sql
              set option commit = *none, datfmt = *iso;


           monitor;
           write ecran01;      // Fond  1° affichage.

           dou bouclew;        // B o u c l e   1
           exfmt ecranw1;      // Fenetre ou l'on saisi
           if *inkc or *inkl;  // la clé du fichier.
           exsr srfin;         // Fin
           endif;

           if codew = *blanks;
           *in51 = *on;                 // Saisir l'identifiant !
           iter;
           endif;


           trvw = chainClient();     // Lect. non bloquante
           if not trvw;              // L'enregt existe-t'il ?
           clear  cl_client;         // Remise à blanc
           cl_idclien = codew;      // La clé des champs
           *in21 = *on;              // "Création"
           else;
           *in21 = *off;             // "Modification"
           endif;

           messw = *blanks;
           *in89 = *off;             // Témoin touché


           dou bouclew;            // B o u c l e   2
           exfmt ecran02;          // E c r a n   d e   s a i s i e
           if *inkc;
           exsr srfin;             // Fin
           endif;
           if *inkl;
           leave;                  // Ecran précédent
           endif;

           if *in88;                // Change
           *in89 = *on;             // Touché
           endif;

           if cl_nom = *blanks;     // Controle
           *in51 = *on;             // Message d'erreur
           iter;
           endif;

           if *in88 and not *inkx;   // Change, pas suppr.
           iter;                     // Réaffichage
           endif;

           if not *in89 and not *inkx;   // Pas touché, pas suppr.
           codew = *blanks;
           leave;                        // Retour écran précédent
           endif;


         // M i s e   à   j o u r   d e s   t a b l e s

           cl_timbre = %timestamp();
           cl_userr = userr2;
           cl_dbcount += 1;


           if not trvw;
           okw = writeClient();        // Ecriture
           messw = cl_idclien + ' créé';

           else;
           if *inkx;
           okw = deleteClient();       // Suppression
           messw = cl_idclien + ' supprimé';
           else;
           okw = updateClient();       // Modif
           messw = cl_idclien + ' modifié';
           endif;
           endif;

           if not okw;       // Collision entre 2 utilisateurs...
           messw = 'Opération NON effectuée, recommencez svp !';
           else;
           codew = *blanks;
           endif;

           leave;

           enddo;
           enddo;

           on-error;
           exfmt ecranom;         // Anomalie grave
           exsr srfin;
           endmon;

         // S o u s - p r o g r a m m e ( s )


           begsr srfin;        // Fin de programme
           *inlr = *on;
           return;
           endsr;


      /end-free

         // S o u s - p r o c é d u r e ( s )  *****************************************************

     PchainClient      b
     D                 pi              n
     C/exec sql
     C+ select * into :cl_client from client where idclien = :codew
     C/end-exec sql
     C                   select
     C                   when      sqlstate = '00000'
     C                   eval      trvw = *on
     C                   when      sqlstate = '02000'
     C                   eval      trvw = *off
     C                   other
      * Anomalie grave : remontée dans le "main"...
     C                   eval      zerow = 1/zerow
     C                   endsl

     C                   return    trvw
     P                 e


     PwriteClient      b
     D                 pi              n
     C/exec sql
     C+ insert into client values(:cl_client)
     C/end-exec
     C                   select
     C                   when      sqlstate = '00000'
     C                   eval      okw = *on
     C                   when      sqlstate = '23505'
     C                   eval      okw = *off
     C                   other
      * Anomalie grave : remontée dans le "main"...
     C                   eval      zerow = 1/zerow
     C                   endsl

     C                   return    okw
     P                 e


     PupdateClient     b
     D                 pi              n
     C/exec sql
     C+ update client set row  = :cl_client
     C+ where idclien = :cl_idclien
     C/end-exec
     C                   select
     C                   when      sqlstate = '00000'
     C                   eval      okw = *on
     C                   when      sqlstate = '02000'
     C                   eval      okw = *off
     C                   other
      * Anomalie grave : remontée dans le "main"...
     C                   eval      zerow = 1/zerow
     C                   endsl

     C                   return    okw
     P                 e


     PdeleteClient     b
     D                 pi              n
      /free
            exec sql
            delete from client
            where idclien  = :cl_idclien;

        select;
        when      sqlstate = '00000';
        okw=*on;
        when      sqlstate = '02000';
        okw = *off;
        other;
        zerow = 1/zerow; // Anomalie grave : remontée dans le "main"
        endsl;
        return    okw;
      /end-free
     P                 e

 

 

Partager cet article
Repost0