Tous les articles par Mr COBOL

JCL Info

JCL – IEBCOMPR

Les exemples du tableau 1 illustrent certaines des utilisations d’IEBCOMPR.
Les nombres dans la colonne Exemple font référence aux exemples qui suivent.
Les exemples qui utilisent un disque ou une bande à la place des noms ou des numéros de périphérique réels doivent être modifiés avant utilisation.
Les noms ou numéros de périphérique réels dépendent de la façon dont votre installation a défini les périphériques sur votre système.

Tableau 1. Répertoire d’exemple IEBCOMPR

Opération
Organisation du jeu de donnéesPériphériqueCommentairesExemple
COMPARESéquentielCassette 9 pistes Aucune routine utilisateur.
Entrée bloquée.		Exemple 1 : Comparer des ensembles de
données résidant sur bande
COMPARESéquentielCassette 7 pistesAucune routine utilisateur.
Entrée bloquée.		Exemple 2 : Comparer des ensembles de données séquentielles résidant sur bande
COMPARESéquentielBande 7 pistes et bande 9 pistes Routines utilisateur.
Entrée bloquée.
Bandes de différentes densités.		Exemple 3 : Comparer des ensembles de données séquentielles écrites à différentes densités
COMPARESéquentielFlux d’ entrée système
Bande 9 pistes 		Aucune routine utilisateur.
Entrée bloquée.		Exemple 4 : Comparer des ensembles de données séquentielles : flux d’entrée et entrée de bande
COPY (avec IEBGENER) et COMPARESéquentielDisque ou bandeAucune routine utilisateur.
Entrée bloquée.
Deux étapes de travail ; les ensembles de données sont transmis à la deuxième étape du travail.		Exemple 5 : copier et comparer un ensemble de données séquentielles en deux steps de job
COMPAREpartitionné
DisqueAucune routine utilisateur.
Entrée bloquée.		Exemple 6 : Comparer deux ensembles de données partitionnés
COPY (avec IEBCOPY) et COMPAREpartitionnéDisqueRoutine utilisateur.
Entrée bloquée.
Deux étapes de travail ; les ensembles de données sont transmis à la deuxième étape du travail.		Exemple 7 : Copier et comparer un ensemble de données partitionnées en deux steps de job
COMPAREPDSE
DisqueAucune routine utilisateur.
Ensembles de données gérés par SMS.
Exemple 8 : Comparer deux PDSE

EXEMPLE

Exemple 1 : Comparer des ensembles de données résidant sur bande

Dans cet exemple, deux ensembles de données séquentielles résidant sur des volumes de bande à 9 pistes sont comparés.

//TAPETAPE JOB  ...
//         EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=SET1,UNIT=tape,LABEL=(,NL),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=2000),
//             DISP=(OLD,KEEP),VOLUME=SER=001234
//SYSUT2   DD  DSNAME=SET2,UNIT=tape,LABEL=(,NL),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=1040),
//             DISP=(OLD,KEEP),VOLUME=SER=001235
//SYSIN    DD  DUMMY
/*

Les instructions de contrôle de travail sont décrites comme suit :

  • SYSUT1 DD définit un ensemble de données d’entrée (SET1), qui réside sur un volume de bande 9 pistes sans étiquette.
  • SYSUT2 DD définit un ensemble de données d’entrée (SET2), qui réside sur un volume de bande 9 pistes sans étiquette.
  • SYSIN DD définit un jeu de données factice.
    Étant donné qu’aucune routine utilisateur n’est utilisée et que les ensembles de données d’entrée ont une organisation séquentielle, les instructions de contrôle de l’utilitaire ne sont pas nécessaires.

Exemple 2 : Comparer des ensembles de données séquentielles résidant sur bande

Dans cet exemple, deux ensembles de données séquentielles résidant sur des volumes de bande à 7 pistes sont comparés.

//TAPETAPE JOB  ...
//         EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=SET1,LABEL=(2,SUL),DISP=(OLD,KEEP),
//             VOL=SER=001234,DCB=(DEN=2,RECFM=FB,LRECL=80,
//             BLKSIZE=2000,TRTCH=C),UNIT=tape
//SYSUT2   DD  DSNAME=SET2,LABEL=(,SUL),DISP=(OLD,KEEP),
//             VOL=SER=001235,DCB=(DEN=2,RECFM=FB,LRECL=80,
//             BLKSIZE=2000,TRTCH=C),UNIT=tape
//SYSIN    DD  *
        COMPARE  TYPORG=PS
         LABELS  DATA=ONLY
/*

Les instructions de contrôle sont discutées comme suit
 :

  • SYSUT1 DD définit un ensemble de données d’entrée, SET1, qui réside sur un volume de bande étiqueté à 7 pistes.
    L’ensemble de données bloqué a été initialement écrit à une densité de 800 bits par pouce (DEN=2) avec le convertisseur de données activé (TRTCH=C).
  • SYSUT2 DD définit un jeu de données d’entrée, SET2, qui est le premier ou le seul jeu de données sur un volume de bande étiqueté à 7 pistes.
    L’ensemble de données bloqué a été initialement écrit à une densité de 800 bits par pouce (DEN=2) avec le convertisseur de données activé (TRTCH=C).
  • SYSIN DD définit l’ensemble de données de contrôle, qui suit dans le flux d’entrée.
  • COMPARE TYPORG=PS spécifie que les ensembles de données d’entrée sont organisés de manière séquentielle.
  • LABELS DATA=ONLY spécifie que les étiquettes d’en-tête utilisateur doivent être traitées comme des données et comparées.
    Toutes les autres étiquettes sur la bande sont ignorées.

Exemple 3 : Comparer des ensembles de données séquentiels écrits à différentes densités

Dans cet exemple, deux ensembles de données séquentielles qui ont été écrites à des densités différentes sur différentes unités de bande sont comparées.

//TAPETAPE JOB  ...
//         EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=SET1,LABEL=(,SUL),DISP=(OLD,KEEP),
//             VOL=SER=001234,DCB=(DEN=1,RECFM=FB,LRECL=80,
//             BLKSIZE=320,TRTCH=C),UNIT=tape
//SYSUT2   DD  DSNAME=SET2,LABEL=(,SUL),DISP=(OLD,KEEP),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=640),
//             UNIT=tape,VOLUME=SER=001235
//SYSIN    DD  *
        COMPARE  TYPORG=PS
          EXITS  INHDR=HDRS,INTLR=TLRS
         LABELS  DATA=NO
/*

Les instructions de contrôle sont discutées comme suit :

  • SYSUT1 DD définit un jeu de données d’entrée, SET1, qui est le premier ou le seul jeu de données sur un volume de bande étiqueté à 7 pistes.
    L’ensemble de données bloqué a été initialement écrit à une densité de 556 bits par pouce (DEN=1) avec le convertisseur de données activé (TRTCH=C).
  • SYSUT2 DD définit un ensemble de données d’entrée, SET2, qui est le premier ou le seul ensemble de données bloquées sur un volume de bande étiqueté.
    Dans cet exemple, supposons que SYSUT2 se trouve sur un lecteur de bande à 9 pistes.
  • SYSIN DD définit l’ensemble de données de contrôle, qui suit dans le flux d’entrée.
  • COMPARE TYPORG=PS spécifie que les ensembles de données d’entrée sont organisés de manière séquentielle.
  • EXITS identifie les noms des routines à utiliser pour traiter les étiquettes d’en-tête d’entrée utilisateur et les étiquettes de fin.
  • LABELS DATA=NO spécifie que les étiquettes d’en-tête et de fin d’entrée utilisateur pour chaque ensemble de données ne doivent pas être comparées.

Exemple 4 : Comparer des ensembles de données séquentiels – Flux d’entrée et entrée de bande

Dans cet exemple, deux ensembles de données séquentiels (flux d’entrée et bande) sont comparés.

//CARDTAPE JOB  ...
//         EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSIN    DD  DUMMY
//SYSUT2   DD  UNIT=tape,VOLUME=SER=001234,LABEL=(,NL),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=2000),
//             DISP=(OLD,KEEP)
//SYSUT1   DD  DATA
 
  (jeu de données d'entrée)
 
/*

Les instructions de contrôle sont décrites comme suit :

  • SYSIN DD définit un jeu de données de contrôle factice.
    Étant donné qu’aucune routine utilisateur n’est fournie et que les ensembles de données d’entrée sont séquentiels, les instructions de contrôle de l’utilitaire ne sont pas nécessaires.
  • SYSUT2 DD définit un ensemble de données d’entrée, qui réside sur un volume de bande sans étiquette.
  • SYSUT1 DD définit un ensemble de données de flux d’entrée système.

Exemple 5 : Copier et comparer un jeu de données séquentiel en deux step de job

Dans cet exemple, un jeu de données séquentiel sur disque ou sur bande est copié et comparé en deux step de job.

//TAPETAPE JOB  ...
//STEPA    EXEC PGM=IEBGENER
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSN=WAREHOUS.COPYSET1,DISP=(OLD,PASS),
//SYSUT2   DD  DSNAME=WAREHOUS.COPYSET2,DISP=(,PASS),LABEL=(,SL),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=640),
//             UNIT=tape,VOLUME=SER=001235
//SYSIN    DD  DUMMY
//STEPB    EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=*.STEPA.SYSUT1,DISP=(OLD,KEEP)
//SYSUT2   DD  DSNAME=*.STEPA.SYSUT2,DISP=(OLD,KEEP)
//SYSIN    DD  DUMMY

Le premier step de job copie l’ensemble de données et transmet les ensembles de données d’origine et copiés au deuxième step de job.
Le deuxième step de job compare les deux ensembles de données.

Les instructions de contrôle pour le step de job IEBCOMPR sont présentées comme suit :

  • SYSUT1 DD définit un ensemble de données d’entrée transmis à partir du step de job précédent (COPYSET1).
    L’ensemble de données réside sur un volume de bande étiqueté.
  • SYSUT2 DD définit un ensemble de données d’entrée transmis à partir du step de job précédent (COPYSET2).
    L’ensemble de données, qui a été créé au step de job précédent, réside sur un volume de bande étiqueté.
  • SYSIN DD définit un jeu de données de contrôle factice.
    Etant donné que l’entrée est séquentielle et qu’aucun exit utilisateur n’est fourni, aucune instruction de contrôle d’utilitaire n’est requise.

Exemple 6 : Comparer deux ensembles de données partitionnés

Dans cet exemple, deux ensembles de données partitionnés sont comparés.

//DISKDISK JOB  ...
//STEP1    EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=PDSSET1,UNIT=disk,DISP=SHR,
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=2000),
//             VOLUME=SER=111112
//SYSUT2   DD  DSNAME=PDSSET2,UNIT=disk,DISP=SHR,
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=2000),
//             VOLUME=SER=111113
//SYSIN    DD  *
      COMPARE  TYPORG=PO
/*

Les instructions de contrôle sont décrites comme suit : 

  • SYSUT1 DD définit un ensemble de données partitionnées en entrée, PDSSET1.
    L’ensemble de données bloqué réside sur un volume de disque.
  • SYSUT2 DD définit un ensemble de données partitionnées en entrée, PDSSET2.
    L’ensemble de données bloqué réside sur un volume de disque.
  • SYSIN DD définit l’ensemble de données de contrôle, qui suit dans le flux d’entrée.
  • COMPARE TYPORG=PO indique que les ensembles de données d’entrée sont partitionnés.

Exemple 7 : Copier et comparer un ensemble de données partitionné en deux step de job

Dans cet exemple, un ensemble de données partitionné est copié et comparé en deux step de job.

//DISKDISK JOB  ...
//STEPA    EXEC PGM=IEBCOPY
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=MAINDB.LOG.OLDSET,DISP=SHR
//SYSUT2   DD  DSNAME=NEWMEMS,UNIT=disk,DISP=(,PASS),
//             VOLUME=SER=111113,SPACE=(TRK,(5,5,5)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=640)
//SYSUT3   DD  UNIT=SYSDA,SPACE=(TRK,(1))
//SYSUT4   DD  UNIT=SYSDA,SPACE=(TRK,(1))
//SYSIN    DD  *
       COPY OUTDD=SYSUT2,INDD=SYSUT1
       SELECT MEMBER=(A,B,D,E,F)
/*
//STEPB    EXEC PGM=IEBCOMPR
//SYSPRINT DD  SYSOUT=A
//SYSUT1   DD  DSNAME=OLDSET,DISP=(OLD,KEEP)
//SYSUT2   DD  DSNAME=NEWMEMS,DISP=(OLD,KEEP)
//SYSIN    DD  *
       COMPARE TYPORG=PO
       EXITS ERROR=SEEERROR
/*

Le premier step de job copie l’ensemble de données et transmet les ensembles de données d’origine et copiés au deuxième step de job.
Le deuxième step de job compare les deux ensembles de données.

Les instructions de contrôle pour l’étape de travail IEBCOMPR sont abordées comme suit :

  • SYSUT1 DD définit un ensemble de données d’entrée bloquées (MAINDB.LOG.OLDSET) transmis à partir du step précédent.
    L’ensemble de données réside sur un volume de disque ou de bande.
  • SYSUT2 DD définit un ensemble de données d’entrée bloquées (MAINDB.LOG.NEWMEMS) transmis à partir du step précédent.
    L’ensemble de données réside sur un volume de disque.
  • SYSIN DD définit l’ensemble de données de contrôle, qui suit dans le flux d’entrée.
  • COMPARE TYPORG=PO spécifie une organisation partitionnée.
  • EXITS spécifie qu’une routine d’erreur utilisateur, SEEERROR, doit être utilisée.

Étant donné que les noms des ensembles de données d’entrée ne sont pas identiques, les ensembles de données peuvent être récupérés par leurs noms d’ensemble de données.

Exemple 8 : Comparer deux PDSE

Dans cet exemple, deux PDSE sont comparés.

//DISKDISK  JOB ...
//          EXEC PGM=IEBCOMPR
//SYSPRINT  DD  SYSOUT=A
//SYSUT1    DD  DSN=PDSE1,DISP=SHR
//SYSUT2    DD  DSN=PDSE2,DISP=SHR
//SYSIN     DD  *
            COMPARE TYPORG=PO
/*

Les PDSE ne doivent plus être gérés par SMS.
Étant donné que ces PDSE sont catalogués, vous n’avez pas besoin de spécifier les paramètres UNIT ou VOLUME.

Les instructions de contrôle sont décrites comme suit :

  • SYSUT1 DD et SYSUT2 DD définissent les PDSE d’entrée, PDSE1 et PDSE2.
    Étant donné qu’aucune valeur DCB n’est spécifiée, les valeurs DCB qui ont été spécifiées lors de la création des ensembles de données seront utilisées.
  • SYSIN DD définit l’ensemble de données de contrôle, qui suit dans le flux d’entrée.
  • COMPARE TYPORG=PO indique que les ensembles de données d’entrée sont des PDSE.
JCL Info

JCL – IDCAMS

Utiliser les services de méthode d’accès aux catalogues d’ IDCAMS:

  • Gestion des données et du stockage sur z/OS
  • Bien qu’il fournisse d’autres fonctions, IDCAMS, qui est le nom du programme pour les services de méthode d’accès, est principalement utilisé pour définir et gérer les ensembles de données VSAM et les catalogues d’installations de catalogue intégré.
  • Une méthode d’accès définit la technique utilisée pour stocker et récupérer des données.
    Les méthodes d’accès ont leurs propres structures d’ensembles de données pour organiser les données, des programmes (ou macros) fournis par le système pour définir les ensembles de données et des programmes utilitaires pour traiter les ensembles de données.
    VSAM (Virtual Sequential Access Method) est une méthode d’accès utilisée pour des applications plus complexes.
    VSAM organise les enregistrements selon une clé d’index, un numéro d’enregistrement relatif ou un adressage d’octet relatif.
  • Certains utilisateurs prononcent le nom de ce programme comme “id-cams” (deux syllabes) tandis que d’autres disent “ID-cams” (trois syllabes).
  • Les services de méthode d’accès, également connus sous le nom d’IDCAMS, créent et maintiennent des ensembles de données VSAM.
  • Avec les services de méthode d’accès, vous pouvez effectuer les tâches suivantes :
    1. Définissez les jeux de données VSAM.
    2. Définir et créer des index alternatifs.
    3. Sauvegardez et restaurez les ensembles de données VSAM.
    4. Copiez les ensembles de données.
    5. Imprimer le contenu des jeux de données.
    6. Supprimer des ensembles de données.
    7. Recueillir des informations sur les ensembles de données.
    8. Examinez la cohérence structurelle des jeux de données séquencés par clé VSAM.
    9. Contrôlez le cache DASD.
    10. Répertorier les entrées du catalogue de volumes de bandes (VOLCAT).
    11. Diagnostiquer les erreurs de catalogue.
    12. Récupérer des erreurs de catalogue.
    13. Définissez des bibliothèques et des volumes gérés par le système.
    14. Définissez l’adressabilité étendue pour un ensemble de données VSAM au format étendu afin de prendre en charge une taille d’ensemble de données supérieure à 4 Go.
    15. Crypter et décrypter les ensembles de données.
  • Vous pouvez également définir des jeux de données VSAM à l’aide de JCL ou de macros d’allocation dynamique.

Un exemple typique d’utilisation simple d’IDCAMS est le suivant :

//VDFNDEL  JOB 1,LINDAJO,MSGCLASS=X
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD *
//DATAIN   DD DISP=OLD,DSN=LCDC.SORTOUT
//SYSIN    DD *
 DEFINE CLUSTER (NAME (LCDC.DATA.VSAM) -
 VOLUMES(WORK02) CYLINDERS(1 1) -
 RECORDSIZE (72 100) KEYS(9 8) INDEXED)
 REPRO INFILE(DATAIN) OUTDATASET(LCDC.DATA.VSAM) ELIMIT(200)
/*
//STEP2    EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN    DD *
 DELETE LCDC.DATA.VSAM CLUSTER
/*

Cet exemple de job, nommé VDFNDEL, se compose de deux steps:
– une pour définir un ensemble de données VSAM ; 
– l’autre pour le supprimer.

La première étape, STEP1 remplit deux fonctions :

  1. Crée un ensemble de données VSAM via la commande DEFINE CLUSTER.
    Notez qu’IDCAMS utilise l’allocation dynamique pour créer le JCL nécessaire pour ce nouvel ensemble de données, de sorte que l’exemple n’inclut pas d’instruction DD pour le nouvel ensemble de données.
    • La commande DEFINE CLUSTER se poursuit sur trois enregistrements ; les indicateurs de continuation sont des traits d’union.
    • L’ensemble de données VSAM se trouve sur le volume WORK02 et utilise un cylindre pour l’espace principal et un cylindre pour l’allocation secondaire.
      La taille d’enregistrement moyenne est de 72 octets et la taille d’enregistrement maximale est de 100 octets.
      (Les ensembles de données VSAM utilisent toujours des enregistrements de longueur variable.)
      La clé primaire (pour accéder aux enregistrements dans l’ensemble de données) a une longueur de 8 octets et commence à un décalage de 9 octets dans chaque enregistrement.
    • Les enregistrements permettant de charger un ensemble de données VSAM de cette manière doivent déjà être triés par ordre de clé.
    • Le paramètre ELIMIT spécifie le nombre d’enregistrements d’erreurs que REPRO ignorera avant de terminer l’opération.
      Un enregistrement d’erreur est généralement dû à une valeur de clé en double.
  2. Charge le nouveau jeu de données via la commande REPRO.
    L’entrée chargée dans le nouvel ensemble de données provient d’un ensemble de données séquentielles, qui est identifié par l’instruction DATAIN DD.

La deuxième étape, STEP2, supprime l’ensemble de données qui est créé STEP1.
De nombreuses fonctions IDCAMS peuvent être saisies en tant que commandes TSO.
Par exemple, DEFINE CLUSTER peut être utilisé comme commande TSO.
Cependant, l’utilisation d’IDCAMS de cette manière n’est généralement pas recommandée car ces commandes peuvent être complexes et les erreurs rencontrées peuvent être complexes.
La saisie des commandes IDCAMS via un job par lots permet de revoir les commandes et les messages résultants aussi souvent que nécessaire en utilisant SDSF pour afficher la sortie.

JCL Info

JCL – Programmes utilitaires

Utilitaires d’ensemble de données IBM

Les programmes utilitaires sont des programmes pré-écrits, largement utilisés dans les mainframes par les programmeurs système et les développeurs d’applications pour répondre aux exigences quotidiennes, organiser et maintenir les données. Quelques-uns d’entre eux sont listés ci-dessous avec leurs fonctionnalités :

Nom de l’utilitaireFonctionnalité
IEHMOVEDéplace ou copie des jeux de données séquentiels.
IEHPROGMSupprimer et renommer des ensembles de données ; cataloguer ou décataloguer des ensembles de données autres que VSAM.<
IEHCOMPRCompare les données dans des ensembles de données séquentiels.
IEBCOPYCopiez, fusionnez, compressez, sauvegardez ou restaurez le PDS.
IEFBR14Aucun utilitaire d’opération. Utilisé pour rendre le contrôle à l’utilisateur et terminer.
Il est généralement utilisé pour créer un jeu de données vide ou supprimer un jeu de données existant.
Par exemple, si un jeu de données est passé en entrée à un programme IEFBR14 avec DISP=(OLD,DELETE,DELETE), le jeu de données est supprimé à la fin du travail.
IEBEDITUtilisé pour copier des parties sélectionnées d’un JCL.
Par exemple, si un JCL comporte 5 étapes et que nous devons exécuter les étapes 1 et 3 uniquement, un JCL IEBEDIT peut être codé avec un jeu de données qui contient le JCL réel à exécuter.
Dans le SYSIN d’IEBEDIT, nous pouvons spécifier STEP1 et STEP3 comme paramètres.
Lorsque ce JCL est exécuté, il exécute les STEP1 et STEP3 du JCL réel.
IDCAMCréer, supprimer, renommer, cataloguer, décataloguer des ensembles de données (autres que PDS).
Généralement utilisé pour gérer les ensembles de données VSAM.
IEBDGProgramme de générateur de données de test
IEBGENERProgramme séquentiel de copie/génération d’ensemble de données
IEBIMAGECréer un programme d’image d’imprimante (print)
IEBPDSEProgramme de validation PDSE
IEBPTPCHProgramme d’impression-perforation
IEBUPDTEMettre à jour le programme d’ensemble de données
IEHINITTInitialiser le programme de bande
IEHLISTLister le programme de données système
IFHSTATRListe des programmes de données ESV

Ces programmes utilitaires doivent être utilisés avec les instructions DD appropriées dans un JCL afin d’obtenir la fonctionnalité spécifiée.

JCL Info

JCL – Exécution de programme COBOL

Ci-dessous un exemple JCL où le programme MYPROG est exécuté à l’aide du fichier d’entrée MYDATA.LCDC.INPUT et produit deux fichiers de sortie écrits dans le spool.

//COBBSTEP  JOB CLASS=6,NOTIFY=&SYSUID
//
//STEP10    EXEC PGM=MYPROG,PARM=ACCT5000
//STEPLIB   DD DSN=MYDATA.LCDC.LOADLIB,DISP=SHR
//INPUT1    DD DSN=MYDATA.LCDC.INPUT,DISP=SHR
//OUT1      DD SYSOUT=*
//OUT2      DD SYSOUT=*
//SYSIN     DD *
//CUST1     1000
//CUST2     1001
/*

Le module de chargement de MYPROG se trouve dans MYDATA.LCDC.LOADLIB.
Il est important de noter que le JCL ci-dessus ne peut être utilisé que pour un module COBOL non DB2.

Transmission de données aux programmes COBOL

L’entrée de données dans le programme batch COBOL peut se faire via des fichiers, le paramètre PARAM et l’instruction SYSIN DD. 

Dans l’exemple ci-dessus :

  • Les enregistrements de données sont transmis à MYPROG via le fichier MYDATA.LCDC.INPUT.
    Ce fichier sera référencé dans le programme en utilisant le nom DD INPUT1.
    Le fichier peut être ouvert, lu et fermé dans le programme.
  • Les données de paramètre PARM ACCT5000 sont reçues dans la section LINKAGE du programme MYPROG dans une variable définie dans cette section.
  • Les données de l’instruction SYSIN sont reçues via l’instruction ACCEPT dans la division PROCEDURE du programme.
    Chaque instruction ACCEPT lit un enregistrement entier (c’est-à-dire, CUST1 1000) dans une variable de stockage de travail définie dans le programme.

Exécution d’un programme COBOL-DB2

Pour exécuter le programme COBOL DB2, un utilitaire IBM spécialisé est utilisé dans le JCL et le programme ; La région DB2 et les paramètres requis sont transmis en entrée à l’utilitaire.

Les étapes ci-dessous sont suivies lors de l’exécution d’un programme COBOL-DB2 :

  • Lorsqu’un programme COBOL-DB2 est compilé, un DBRM (Database Request Module) est créé avec le module de chargement.
    Le DBRM contient les instructions SQL des programmes COBOL avec sa syntaxe vérifiée pour être correcte.
  • Le DBRM est lié à la région DB2 (environnement) dans laquelle le COBOL s’exécutera.
    Cela peut être fait à l’aide de l’utilitaire IKJEFT01 dans un JCL.
  • Après l’étape de liaison, le programme COBOL-DB2 est exécuté à l’aide de IKJEFT01 (à nouveau) avec la bibliothèque de chargement et la bibliothèque DBRM comme entrée du JCL.
//STEP001  EXEC PGM=IKJEFT01
//*
//STEPLIB  DD DSN=MYDATA.LCDC.DBRMLIB,DISP=SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY  DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
    DSN SYSTEM(SSID)
    RUN PROGRAM(MYCOBB) PLAN(PLANNOM) PARM(paramètres du programme cobol) -
    LIB('MYDATA.LCDC.LOADLIB')
    END
/*

Dans l’exemple ci-dessus, MYCOBB est le programme COBOL-DB2 exécuté à l’aide de IKJEFT01. Veuillez noter que le nom du programme, l’ID du sous-système DB2 (SSID) et le nom du plan DB2 sont transmis dans l’instruction SYSTSIN DD. La bibliothèque DBRM est spécifiée dans la STEPLIB.

JCL Info

JCL – Compilation de programmes COBOL

Pour exécuter un programme COBOL en mode batch à l’aide de JCL, le programme doit être compilé et un module de chargement est créé avec tous les sous-programmes.
Le JCL utilise le module de chargement et non le programme réel au moment de l’exécution.
Les bibliothèques de chargement sont concaténées et transmises au JCL au moment de l’exécution à l’aide de JCLLIB ou STEPLIB.

Il existe de nombreux utilitaires de compilateur mainframe disponibles pour compiler un programme COBOL.
Certaines entreprises utilisent des outils de gestion du changement comme Endevor, qui compile et stocke chaque version du programme.
Ceci est utile pour suivre les modifications apportées au programme.

//COMPILE   JOB ,CLASS=6,MSGCLASS=X,NOTIFY=&SYSUID             
//*            
//STEP1     EXEC IGYCRCTL,PARM=RMODE,DYNAM,SSRANGE
//SYSIN     DD DSN=MYDATA.LCDC.SOURCES(MYCOBB),DISP=SHR
//SYSLIB    DD DSN=MYDATA.LCDC.COPYBOOK(MYCOPY),DISP=SHR
//SYSLMOD   DD DSN=MYDATA.LCDC.LOAD(MYCOBB),DISP=SHR
//SYSPRINT  DD SYSOUT=*
//*

IGYCRCTL est un utilitaire de compilateur IBM COBOL.
Les options du compilateur sont transmises à l’aide du paramètre PARM.
Dans l’exemple ci-dessus, RMODE demande au compilateur d’utiliser le mode d’adressage relatif dans le programme.
Le programme COBOL est passé à l’aide du paramètre SYSIN et le copybook est la bibliothèque utilisée par le programme dans SYSLIB.

Ce JCL produit le module de chargement du programme en sortie qui sert d’entrée au JCL d’exécution.

JCL Info

JCL – Méthode Input-Output

Tout programme batch exécuté via un JCL nécessite une entrée de données, qui est traitée et une sortie est créée.
Il existe différentes méthodes pour alimenter le programme en entrée et écrire la sortie reçue d’un JCL.
En mode batch, aucune intervention de l’utilisateur n’est requise, mais les périphériques d’entrée et de sortie et l’organisation requise sont définis dans JCL et soumis.

Saisie de données dans un JCL

Il existe différentes manières d’alimenter les données d’un programme à l’aide de JCL et ces méthodes ont été expliquées ci-dessous :

Instream Data/Données Intégrées

Les données entrantes dans un programme peuvent être spécifiées à l’aide d’une instruction SYSIN DD.

//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID
//* Exemple 1:
//STEP10 EXEC PGM=MYPROG
//IN1    DD DSN=FICHIER.INPUT1,DISP=SHR
//OUT1   DD DSN=FICHIER.OUTPUT1,DISP=(,CATLG,DELETE),
//       LRECL=50,RECFM=FB
//SYSIN  DD *
//CUST1  1000
//CUST2  1001
/*
//*
//* Exemple 2:
//STEP20 EXEC PGM=MYPROG
//OUT1   DD DSN=FICHIER.OUTPUT2,DISP=(,CATLG,DELETE),
//       LRECL=50,RECFM=FB
//SYSIN  DD DSN=FICHIER.SYSIN.DATA,DISP=SHR
//*

Dans l’exemple 1, l’entrée de MYPROG est transmise via SYSIN.
Les données sont fournies dans le JCL. Deux enregistrements de données sont transmis au programme. Veuillez noter que /* marque la fin des données SYSIN instream.

“CUST1 1000” est record1 et “CUST2 1001” est record2. La condition de fin de données est remplie lorsque le symbole /* est rencontré lors de la lecture des données.

Dans l’exemple 2, les données SYSIN sont conservées dans un ensemble de données, où FICHIER.SYSIN.DATA est un fichier PS, qui peut contenir un ou plusieurs enregistrements de données.

Saisie de données (Data Input) via des fichiers

Comme mentionné dans la plupart des exemples des chapitres précédents, les entrées de données dans un programme peuvent être fournies via des fichiers PS, VSAM ou GDG, avec le nom DSN et les paramètres DISP pertinents ainsi que les instructions DD.

Dans l’exemple 1, FICHIER.INPUT1 est le fichier d’entrée par lequel les données sont transmises à MYPROG.
Il est appelé IN1 dans le programme.

Sortie de données (Data Output) dans un JCL

La sortie d’un JCL peut être cataloguée dans un ensemble de données ou transmise au SYSOUT.
Comme mentionné dans le chapitre sur les instructions DD, SYSOUT=* redirige la sortie vers la même classe que celle mentionnée dans le paramètre MSGCLASS de l’instruction JOB.

Enregistrement des Logs Job

La spécification de MSGCLASS=Y enregistre la log du job dans JMR (Joblog Management and Retrieval).
La log du JOB entier peut être redirigé vers le SPOOL et peut être enregistré dans un jeu de données en donnant la commande XDC contre le nom du job dans le SPOOL.
Lorsque la commande XDC est donnée dans le SPOOL, un écran de création de jeu de données s’ouvre.
La log du job peut ensuite être enregistrée en donnant la définition PS ou PDS appropriée.

Les logs de job peuvent également être enregistrées dans un jeu de données en mentionnant un jeu de données déjà créé pour SYSOUT et SYSPRINT.
Mais l’intégralité de la log du job ne peut pas être capturée de cette manière (c’est-à-dire que JESMSG ne sera pas catalogué) comme cela se fait dans JMR ou XDC.

//EXINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP1    EXEC PGM=MYPROG
//IN1      DD DSN=MYDATA.LCDC.INPUT,DISP=SHR
//OUT1     DD SYSOUT=*
//SYSOUT   DD DSN=MYDATA.LCDC.SYSOUT,DISP=SHR
//SYSPRINT DD DSN=MYDATA.LCDC.SYSPRINT,DISP=SHR
//SYSIN    DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2    EXEC PGM=SORT

Dans l’exemple ci-dessus, SYSOUT est catalogué dans MYDATA.LCDC.SYSOUT et SYSPRINT dans MYDATA.LCDC.SYSPRINT.

JCL Info

JCL – Utilisation de GDG

Dans l’exemple suivant, la dernière version de MYDATA.LCDC.FICHIER.GDG est utilisée comme entrée du programme et une nouvelle version de MYDATA.LCDC.FICHIER.GDG est créée comme sortie.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01   EXEC PGM=MYCOBB
//IN1     DD DSN=MYDATA.LCDC.FICHIER.GDG(0),DISP=SHR
//OUT1    DD DSN=MYDATA.LCDC.FICHIER.GDG(+1),DISP=(,CALTG,DELETE)
//        LRECL=100,RECFM=FB

Ici, si le GDG a été référencé par le nom réel comme MYDATA.LCDC.FICHIER.GDG.G0001V00, cela conduit à changer le JCL à chaque fois avant l’exécution.
L’utilisation de (0) et (+1) permet de substituer dynamiquement la version GDG pour l’exécution.

JCL Info

JCL – Suppression de GDG

À l’aide de l’utilitaire IEFBR14, nous pouvons supprimer une seule version d’un GDG.

//GDGSTEP3   EXEC PGM=IEFBR14
//GDGDEL     DD  DSN=MYDATA.LCDC.FICHIER.GDG(0),
//           DISP=(OLD,DELETE,DELETE)

Dans l’exemple ci-dessus, la dernière version de MYDATA.LCDC.FICHIER.GDG est supprimée.
Veuillez noter que le paramètre DISP à l’achèvement normal du job est codé comme DELETE.
Par conséquent, le jeu de données est supprimé lorsque l’exécution du job est terminée.

IDCAMS peut être utilisé pour supprimer le GDG et ses versions associées à l’aide de la commande SYSIN DELETE(MYDATA.LCDC.FICHIER.GDG) GDG FORCE/PURGE.

  • FORCE supprime les versions GDG et la base GDG.
    Si l’une des versions de GDG est définie avec une date d’expiration qui n’a pas encore expiré, celles-ci ne sont pas supprimées et, par conséquent, la base de GDG est conservée.
  • PURGE supprime les versions GDG et la base GDG quelle que soit la date d’expiration.
JCL Info

JCL – Création/Modification de GDG

Les versions GDG peuvent avoir des paramètres DCB identiques ou différents.
Un DCB modèle initial peut être défini pour être utilisé par toutes les versions, mais il peut être remplacé lors de la création de nouvelles versions.
Vous verrez donc sur cette page une création/modification de GDG.

//GDGSTEP1 EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
           DEFINE GDG(NAME(MYDATA.LCDC.FICHIER.GDG)   -
           LIMIT(7)                           -
           NOEMPTY                            -
           SCRATCH)
/*
//GDGSTEP2 EXEC PGM=IEFBR14
//GDGMODLD DD  DSN=MYDATA.LCDC.FICHIER.GDG,
//         DISP=(NEW,CATLG,DELETE),
//         UNIT=SYSDA,
//         SPACE=(CYL,10,20),
//         DCB=(LRECL=50,RECFM=FB)
//

Dans l’exemple ci-dessus, l’utilitaire IDCAMS définit la base GDG dans GDGSTEP1 avec les paramètres ci-dessous passés dans l’instruction SYSIN DD :

  • NAME spécifie le nom du jeu de données physique de la base GDG.
  • LIMIT spécifie le nombre maximum de versions que la base GDG peut contenir.
  • EMPTY décatalogue toutes les générations lorsque la LIMITE est atteinte.
  • NOEMPTY décatalogue la génération la moins récente.
  • SCRATCH supprime physiquement la génération lorsqu’elle est décataloguée.
  • NOSCRATCH ne supprime pas le jeu de données, c’est-à-dire qu’il peut être référencé à l’aide des paramètres UNIT et VOL.

Ici, dans GDGSTEP2, l’utilitaire IEFBR14 spécifie les paramètres DD du modèle à utiliser par toutes les versions.

IDCAMS peut être utilisé pour modifier les paramètres de définition d’un GDG, comme augmenter LIMIT, changer EMPTY en NOEMPTY, etc., et ses versions associées utilisant la commande SYSIN sont ALTER MYDATA.URMI.SAMPLE.GDG LIMIT(15) EMPTY.

JCL Info

JCL – Définition de GDG

Les groupes de données de génération (GDG) sont un groupe d’ensembles de données liés les uns aux autres par un nom commun.
Le nom commun est appelé base GDG et chaque jeu de données associé à la base est appelé version GDG.

Par exemple, MYDATA.LCDC.FICHIER.GDG est le nom de base GDG.
Les jeux de données sont nommés MYDATA.LCDC.FICHIER.GDG.G0001V00, MYDATA.LCDC.FICHIER.GDG.G0002V00, etc.
La dernière version du GDG est appelée MYDATA.LCDC.FICHIER.GDG(0), les versions précédentes sont appelées (-1), (-2) et ainsi de suite.
La prochaine version à créer dans un programme est appelée MYDATA.LCDC.FICHIER.GDG(+1) dans le JCL.