Utilitário z/OS - IEBGENER e IEBCOPY

Os utilitários IEBGENER e IEBCOPY são dois utilitários IBM usados para várias operações.

O IEBCOPY é um utilitário usado para copiar ou mesclar membros entre um ou mais dataset particionados ou dataset particionados estendidos (PDSEs), total ou parcialmente. O IEBCOPY é para criar um backup de um dataset particionados em um dataset sequencial (chamado de dataset de descarregamento ou PDSU) ou para copiar membros do backup em um dataset particionados. Com o IEBCOPY , você pode executar qualquer um dos seguintes Faça uma cópia de um dataset particionado ou PDSE.

• Mesclar dataset particionados (exceto ao descarregar).
• Crie uma forma sequencial de um dataset particionado ou PDSE para um backup ou transporte.
  
• Recarregue um ou mais membros de um PDSU em um dataset particionado ou PDSE. (Observe que um módulo de carregamento descarregado não pode ser convertido em um objeto de programa neste processo.)
• Selecione membros específicos de um dataset particionado ou PDSE para serem copiados, carregados ou descarregados.
• Substitua membros de um dataset particionado ou PDSE.
• Renomeie os membros selecionados de um dataset particionado ou PDSE quando copiado.
• Exclua membros de um dataset a ser copiado, descarregado ou carregado. (Exceto em COPYGRP).
• Compacte um dataset particionado no local.
• Atualize um módulo de carregamento para carregamento mais rápido por busca de programa MVS.
• Copie e bloqueie novamente os módulos de carregamento.
• Converta módulos de carregamento em um dataset particionados para objetos de programa em um PDSE ao copiar um dataset particionados para um PDSE.
• Converta um dataset particionados em um PDSE ou um PDSE em um dataset particionados.
• Copiar de ou para um dataset PDS ou PDSE, um membro e seus aliases juntos como um grupo (COPYGROUP)

IEBCOPY - Copie um PDS inteiro para outro PDS

//COPYPDS JOB (COPYPDS,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//***********************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.JCLS,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.BKUP,
//          DISP=(NEW,CATLG,DELETE),
//          UNIT=TESTDA,
//          SPACE=(CYL,(10,10,40)),
//          DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
/*

Nota : os dataset de entrada e saída são identificados como SYSUT1 e SYSUT2, o dataset SYSIN é opcional. O dataset SYSUT1 será copiado integralmente para o dataset SYSUT2. Depois que a operação de cópia for concluída, DATASET4 conterá os mesmos membros que estão em DATASET5. No entanto, não haverá espaço não utilizado incorporado no DATASET4. Se você estiver copiando um PDSE, o processamento será o mesmo, exceto que não há nenhum espaço incorporado e não utilizado em um PDSE.

IEBCOPY - Mesclar vários dataset

//MERGEDS JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//************************************************
//SYSPRINT DD SYSOUT=*
//IN1 DD DSNAME=DATASET1,UNIT=DISK,VOL=SER=111112,
// DISP=SHR
//IN5 DD DSNAME=DATASET5,UNIT=DISK,VOL=SER=111114,
// DISP=OLD
//OUT2 DD DSNAME=DATASET2,UNIT=DISK,VOL=SER=111115,
// DISP=(OLD,KEEP)
//IN6 DD DSNAME=DATASET6,UNIT=DISK,VOL=SER=111117,
// DISP=(OLD,DELETE)
//SYSUT3 DD UNIT=SYSDA,SPACE=(TRK,(1))
//SYSIN DD *
  COPYOPER COPY OUTDD=OUT2
  INDD=IN1
  INDD=IN6
  INDD=IN5
/*

IEBCOPY - Copiar e substituir membros selecionados de um dataset

//COPYRPLC JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//*************************************************
//SYSPRINT DD SYSOUT=A
//OUT1 DD DSNAME=DATASET1,UNIT=DISK,VOL=SER=111112,
//        DISP=(OLD,KEEP)
//IN6 DD DSNAME=DATASET6,UNIT=DISK,VOL=SER=111115,
//       DISP=OLD
//IN5 DD DSNAME=DATASET5,UNIT=DISK,VOL=SER=111116,
//       DISP=(OLD,KEEP)
//SYSUT3 DD UNIT=SYSDA,SPACE=(TRK,(1))
//SYSUT4 DD UNIT=SYSDA,SPACE=(TRK,(1))
//SYSIN DD *
  COPYOPER COPY OUTDD=OUT1
  INDD=IN5,IN6
  SELECT MEMBER=((B,,R),A)
/*

IEBCOPY - Copie um PDS inteiro para um dataset de fita sequencial (descarregando)

//UNLOADPDS JOB (SATYA,SAMPLE),'SATYA',
//    CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//**********************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.JCLS,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.UNLOAD,
//          DISP=(NEW,CATLG),
//          UNIT=CART,
//          DCB=(LRECL=80,RECFM=FB,BLKSIZE=0)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
/*

IEBCOPY - Load (restaurar cópia não carregada da fita para o DASD)

//LOADUNLD JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.JCLS.UNLOAD,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.LOADED,
//          DISP=(NEW,CATLG),
//          UNIT=TESTDA,
//          SPACE=(CYL,(10,10,40),RLSE),
//          DCB=(LRECL=80,RECFM=FB,BLKSIZE=0)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
/*

IEBCOPY - Compactar dataset PDS

//COMPRPDS JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.JCLS,DISP=SHR
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT1
/*

IEBCOPY - Inclui membros do PDS em um comando COPY

//PDSCOPY  JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.PDSE.JCLS,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.IEBCOPY,
//          DISP=(NEW,CATLG,DELETE),
//          SPACE=(CYL,(5,5,5),RLSE),
//          DCB=(LRECL=80,RECFM=FB,BLKSIZE=800)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
  SELECT MEMBER=(IEBCOPY1,IEBCOPY2,IEBCOPY3,IEBCOPY4, -
  IEBCOPY5,IEBCOPY6)
/*

IEBCOPY - Excluir membros do PDS em um comando COPY

//PDSCOPY  JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.PDSE.JCLS,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.OTHERS,
//          DISP=(NEW,CATLG,DELETE),
//          SPACE=(CYL,(10,10,40),RLSE),
//          DCB=(LRECL=80,RECFM=FB,BLKSIZE=800)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
  EXCLUDE MEMBER=(IEBCOPY1,IEBCOPY2,IEBCOPY3,IEBCOPY4, -
  IEBCOPY5,IEBCOPY6)
/*

IEBCOPY - Renomear um membro durante a cópia

//RENAMECPY JOB (SATYA,SAMPLE),'SATYA',
// CLASS=J,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.PDSE.JCLS,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.IEBCOPY,
//       DISP=(NEW,CATLG,DELETE),
//       SPACE=(CYL,(5,5,5),RLSE),
//       DCB=(LRECL=80,RECFM=FB,BLKSIZE=800)
//SYSIN DD *
  COPY INDD=SYSUT1,OUTDD=SYSUT2
  SELECT MEMBER=(IEBCOPY1,IEBCOPY2,IEBCOPY3,IEBCOPY4,
  IEBCOPY5,(IEBCOPY6,NEWIEBC6))
/*

IEBCOPY - Mesclar dataset particionados

//MERGEPDS  JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBCOPY
//**********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.JCLS.IEBCOPY,DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.JCLS.OTHERS,DISP=SHR
//SYSUT3 DD DSN=XXXX.JCLTEST.SATYA.JCLS.ALL,
//          DISP=(NEW,CATLG,DELETE),
//          SPACE=(CYL,(10,10,40),RLSE),
//          DCB=(LRECL=80,RECFM=FB,BLKSIZE=800)
//SYSIN DD *
  COPY INDD=(SYSUT1,SYSUT2),OUTDD=SYSUT3
/*

IEBGENER

IEBGENER é um utilitário de cópia generalizado usado para as seguintes tarefas

• Criar uma cópia de backup de um dataset sequencial, um membro de um dataset particionado ou arquivo PDSE ou z / OS UNIX System Services (z / OS UNIX), como um arquivo HFS .
• Produzir um dataset particionado ou PDSE, ou um membro de um dataset particionado ou PDSE, a partir de um dataset sequencial ou arquivo z / OS UNIX.
• Expanda um dataset particionado existente ou PDSE criando membros particionados e mesclando-os no dataset existente.
  
• Produzir um dataset sequencial ou particionado editado ou PDSE.
• Manipular dataset contendo dados de conjuntos de caracteres de byte duplo.
• Imprimir dataset sequenciais, membros de dataset particionados ou PDSEs ou arquivos z/OS UNIX.
• Reblock ou altere o comprimento do registro lógico de um dataset.
• Copie rótulos de usuário em dataset de saída sequencial.
• Fornece recursos de edição e saídas para suas rotinas que processam rótulos, manipulam dados de entrada, criam chaves e tratam de erros permanentes de entrada / saída.

IEBGENER - Criar backup de um membro PDS/PDSE para outro membro PDS / PDSE

//SATYAJOB2 JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER 
//****************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.PDSE.JCLS(IEBGEN2),
//          DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.PDSE.JCLS(IEBGEN3),
//          DISP=SHR,
//          UNIT=TESTDA,
//          SPACE=(CYL,(1,1),RLSE),
//          DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

IEBGENER - Criar cópia de backup de um dataset sequencial para outro dataset sequencial

//SATYAJOB3 JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTINPUT,
// DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTINBK,
//       DISP=(NEW,CATLG,DELETE),
//       UNIT=TESTDA,
//       SPACE=(CYL,(1,1),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

IEBGENER - Criar cópia de backup de um dataset sequencial para um membro de um PDS/PDSE

//SATYJOB3 JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER
//********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTINPUT,
//       DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.WORK(SRTINBK),
//       DISP=SHR,
//       UNIT=TESTDA,
//       SPACE=(CYL,(1,1),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

IEBGENER - Criar cópia de backup de um membro PDS/PDSE para um dataset sequencial

//SATYJOB4  JOB (SATYA,SAMPLE),'SATYA  ',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK(SRTINBK),
//       DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTBKUP,
//       DISP=(NEW,CATLG,DELETE),
//       UNIT=TESTDA,
//       SPACE=(CYL,(1,1),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

IEBGENER - Criar PDSE a partir de um membro PDS

//SATYJOB5  JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER 
//*****************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK(SRTINBK),
//       DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.PDSE.WORK(SRTINBK),
//       DISP=(NEW,CATLG,DELETE),
//       UNIT=TESTDA,
//       DSORG=PO,
//       DSNTYPE=LIBRARY,
//       SPACE=(CYL,(1,1),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

IEBGENER - Alterar o tamanho do bloco de um dataset sequenciais existente para outro novo dataset sequenciais

//SATYJOB6 JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=IEBGENER 
//****************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTINPUT,
//       DISP=SHR,
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.WORK.SRTINPUT.NEWBS,
//       DISP=(NEW,CATLG,DELETE),
//       UNIT=TESTDA,
//       SPACE=(CYL,(1,1),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=32000)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

Você obterá um erro se tentar o seguinte JCL

//SATYJOB7 JOB (SATYA,SAMPLE),'SATYA',
// CLASS=A,MSGCLASS=Z,REGION=0M,NOTIFY=&SYSUID //*
//STEP1 EXEC PGM=IEBGENER
//*********************************************************
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD DSN=XXXX.JCLTEST.SATYA.WORK,
// DISP=SHR
//SYSUT2 DD DSN=XXXX.JCLTEST.SATYA.WORK.BKUP,
//       DISP=(NEW,CATLG,DELETE),
//       UNIT=TESTDA,
//       SPACE=(CYL,(10,10,100),RLSE),
//       DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)
//SYSIN DD DUMMY
//SYSUDUMP DD SYSOUT=*

Categories: Mainframe