JCL - Procédures

le JCL Proceduressont un ensemble d'instructions à l'intérieur d'un JCL regroupées pour exécuter une fonction particulière. En général, la partie fixe du JCL est codée dans une procédure. La partie variable du Job est codée dans le JCL.

Vous pouvez utiliser une procédure pour réaliser l'exécution parallèle d'un programme à l'aide de plusieurs fichiers d'entrée. Un JCL peut être créé pour chaque fichier d'entrée et une seule procédure peut être appelée simultanément en transmettant le nom du fichier d'entrée en tant que paramètre symbolique.

Syntaxe

Voici la syntaxe de base d'une définition de procédure JCL:

//*
//Step-name EXEC procedure name

Le contenu de la procédure est conservé dans le JCL pour une procédure en cours d'eau. Le contenu est conservé dans un membre différent de la bibliothèque de base pour une procédure cataloguée. Ce chapitre va expliquer deux types de procédures disponibles dans JCL et enfin nous verrons comment nous pouvons imbriquer différentes procédures.

Procédure Instream

Lorsque la procédure est codée dans le même membre JCL, elle est appelée procédure Instream. Il doit commencer par une instruction PROC et se terminer par une instruction PEND.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//INSTPROC   PROC                //*START OF PROCEDURE
//PROC1		EXEC PGM=SORT
//SORTIN	DD DSN=&DSNAME,DISP=SHR
//SORTOUT	DD SYSOUT=*MYINCL
//SYSOUT	DD SYSOUT=*
//SYSIN		DD DSN=&DATAC LRECL=80
//           PEND               //*END OF PROCEDURE
//*
//STEP1      EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT1,
//           DATAC=MYDATA.BASE.LIB1(DATA1)
//*
//STEP2      EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT2
//           DATAC=MYDATA.BASE.LIB1(DATA1)
//*

Dans l'exemple ci-dessus, la procédure INSTPROC est appelée dans STEP1 et STEP2 en utilisant différents fichiers d'entrée. Les paramètres DSNAME et DATAC peuvent être codés avec des valeurs différentes lors de l'appel de la procédure et ils sont appelés commesymbolic parameters. Les différentes entrées du JCL telles que les noms de fichiers, les cartes de données, les valeurs PARM, etc., sont transmises en tant que paramètres symboliques aux procédures.

Lors du codage des paramètres symboliques, n'utilisez pas de MOTS CLÉS, PARAMÈTRES ou SOUS-PARAMÈTRES comme noms symboliques. Exemple: n'utilisez pas TIME = & TIME, mais oui, vous pouvez utiliser TIME = & TM et cela est supposé être une bonne manière de coder les symboles.

Les paramètres symboliques définis par l'utilisateur sont appelés JCL Symbols. Il existe certains symboles appeléssystem symbols, qui sont utilisés pour les exécutions de travaux de connexion. Le seul symbole système utilisé dans les travaux par lots par les utilisateurs normaux est&SYSUID et ceci est utilisé dans le paramètre NOTIFY de l'instruction JOB.

Procédure cataloguée

Lorsque la procédure est séparée du JCL et codée dans un autre magasin de données, elle est appelée Cataloged Procedure. Une instruction PROC n'est pas obligatoire pour être codée dans une procédure cataloguée. Voici un exemple de JCL où il appelle la procédure CATLPROC:

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
//          DATAC=MYDATA.BASE.LIB1(DATA1)

Ici, la procédure CATLPROC est cataloguée dans MYCOBOL.BASE.LIB1. PROG, DATAC et DSNAME sont transmis comme paramètres symboliques à la procédure CATLPROC.

//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//PROC1     EXEC PGM=&PROG
//STEPLIB   DD DSN=&BASELB,DISP=SHR
//IN1       DD DSN=&DSNAME,DISP=SHR
//OUT1      DD SYSOUT=*
//SYSOUT    DD SYSOUT=*
//SYSIN     DD DSN=&DATAC
//*

Dans la procédure, les paramètres symboliques PROG et BASELB sont codés. Veuillez noter que le paramètre PROG dans la procédure est remplacé par la valeur du JCL et que PGM prend donc la valeur CATPRC1 lors de l'exécution.

Procédures imbriquées

L'appel d'une procédure à partir d'une procédure s'appelle un nested procedure. Les procédures peuvent être imbriquées jusqu'à 15 niveaux. L'imbrication peut être entièrement intégrée ou cataloguée. Nous ne pouvons pas coder une procédure en cours d'eau dans une procédure cataloguée.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//SETNM     SET DSNM1=INPUT1,DSNM2=OUTPUT1
//INSTPRC1  PROC               //* START OF PROCEDURE 1
//STEP1        EXEC PGM=SORT,DISP=SHR
//SORTIN       DD DSN=&DSNM1,DISP=SHR
//SORTOUT      DD DSN=&DSNM2,DISP=(,PASS)
//SYSOUT       DD SYSOUT=*
//SYSIN        DD DSN=&DATAC
//*
//STEP2        EXEC PROC=INSTPRC2,DSNM2=MYDATA.URMI.OUTPUT2
//          PEND               //* END OF PROCEDURE 1
//*
//INSTPRC2  PROC               //* START OF PROCEDURE 2
//STEP1        EXEC PGM=SORT
//SORTIN       DD DSN=*.INSTPRC1.STEP1.SORTOUT
//SORTOUT      DD DSN=&DSNM2,DISP=OLD
//SYSOUT       DD SYSOUT=*
//SYSIN        DD DSN=&DATAC
//          PEND               //* END OF PROCEDURE 2
//*
//JSTEP1    EXEC INSTPRC1,DSNM1=MYDATA.URMI.INPUT1,
//          DATAC=MYDATA.BASE.LIB1(DATA1)
//*

Dans l'exemple ci-dessus, le JCL appelle la procédure INSTPRC1 dans JSTEP1 et la procédure INSTPRC2 est appelée dans la procédure INSTPRC1. Ici, la sortie de INSTPRC1 (SORTOUT) est transmise comme entrée (SORTIN) à INSTPRC2.

UNE SET statementest utilisé pour définir les symboles couramment utilisés dans les étapes ou les procédures du travail. Il initialise les valeurs précédentes dans les noms symboliques. Il doit être défini avant la première utilisation des noms symboliques dans le JCL.

Jetons un coup d'œil à la description ci-dessous pour en comprendre un peu plus sur le programme ci-dessus:

• Le paramètre SET initialise DSNM1 = INPUT1 et DSNM2 = OUTPUT1.

• Lorsque INSTPRC1 est appelé dans JSTEP1 de JCL, DSNM1 = MYDATA.URMI.INPUT1 et DSNM2 = OUTPUT1., C'est-à-dire que la valeur initialisée dans l'instruction SET est réinitialisée avec la valeur définie dans l'une des étapes / procédures de travail.

• Lorsque INSTPRC2 est appelé à l'étape 2 de INSTPRC1, DSNM1 = MYDATA.URMI.INPUT1 et DSNM2 = MYDATA.URMI.OUTPUT2.