JCL - Procedimentos

o JCL Proceduressão conjuntos de instruções dentro de um JCL agrupados para executar uma função específica. Normalmente, a parte fixa do JCL é codificada em um procedimento. A parte variável do Job é codificada no JCL.

Você pode usar um procedimento para obter a execução paralela de um programa usando vários arquivos de entrada. Um JCL pode ser criado para cada arquivo de entrada e um único procedimento pode ser chamado simultaneamente, passando o nome do arquivo de entrada como um parâmetro simbólico.

Sintaxe

A seguir está a sintaxe básica de uma definição de procedimento JCL:

//*
//Step-name EXEC procedure name

O conteúdo do procedimento é mantido no JCL para um procedimento instream. O conteúdo é mantido em um membro diferente da biblioteca base para um procedimento catalogado. Este capítulo irá explicar dois tipos de procedimentos disponíveis em JCL e, finalmente, veremos como podemos aninhar vários procedimentos.

Procedimento Instream

Quando o procedimento é codificado no mesmo membro JCL, é chamado de Procedimento Instream. Deve começar com uma instrução PROC e terminar com uma instrução 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)
//*

No exemplo acima, o procedimento INSTPROC é chamado em STEP1 e STEP2 usando diferentes arquivos de entrada. Os parâmetros DSNAME e DATAC podem ser codificados com diferentes valores ao chamar o procedimento e são chamados desymbolic parameters. As entradas variáveis ​​para o JCL, como nomes de arquivo, cartões de dados, valores PARM, etc., são passados ​​como parâmetros simbólicos para procedimentos.

Ao codificar parâmetros simbólicos, não use PALAVRAS-CHAVE, PARÂMETROS ou SUBPARÂMETROS como nomes simbólicos. Exemplo: Não use TIME = & TIME, mas sim, você pode usar TIME = & TM e é considerado uma forma correta de codificar simbólicos.

Parâmetros simbólicos definidos pelo usuário são chamados JCL Symbols. Existem certos símbolos chamadossystem symbols, que são usados ​​para execuções de trabalho de logon. O único símbolo do sistema usado em trabalhos em lote por usuários normais é&SYSUID e isso é usado no parâmetro NOTIFY na instrução JOB.

Procedimento Catalogado

Quando o procedimento é separado do JCL e codificado em um armazenamento de dados diferente, é chamado de Cataloged Procedure. Uma declaração PROC não é obrigatória para ser codificada em um procedimento catalogado. A seguir está um exemplo de JCL em que chama o procedimento CATLPROC:

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

Aqui, o procedimento CATLPROC está catalogado em MYCOBOL.BASE.LIB1. PROG, DATAC e DSNAME são passados ​​como parâmetros simbólicos para o procedimento 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
//*

Dentro do procedimento, os parâmetros simbólicos PROG e BASELB são codificados. Observe que o parâmetro PROG no procedimento é substituído pelo valor no JCL e, portanto, PGM assume o valor CATPRC1 durante a execução.

Procedimentos Aninhados

Chamar um procedimento de dentro de um procedimento é chamado de nested procedure. Os procedimentos podem ser aninhados em até 15 níveis. O aninhamento pode ser totalmente in-stream ou catalogado. Não podemos codificar um procedimento instream dentro de um procedimento catalogado.

//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)
//*

No exemplo acima, a JCL chama o procedimento INSTPRC1 em JSTEP1 e o procedimento INSTPRC2 está sendo chamado dentro do procedimento INSTPRC1. Aqui, a saída de INSTPRC1 (SORTOUT) é passada como entrada (SORTIN) para INSTPRC2.

UMA SET statementé usado para definir símbolos comumente usados ​​em etapas ou procedimentos de trabalho. Ele inicializa os valores anteriores nos nomes simbólicos. Ele deve ser definido antes do primeiro uso dos nomes simbólicos no JCL.

Vamos dar uma olhada na descrição abaixo para entender um pouco mais sobre o programa acima:

  • O parâmetro SET inicializa DSNM1 = INPUT1 e DSNM2 = OUTPUT1.

  • Quando INSTPRC1 é chamado em JSTEP1 de JCL, DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = OUTPUT1., Ou seja, o valor inicializado na instrução SET é redefinido com o valor definido em qualquer uma das etapas / procedimentos do trabalho.

  • Quando INSTPRC2 é chamado no STEP2 de INSTPRC1, DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = MYDATA.URMI.OUTPUT2.