JCL - Guide rapide
Quand utiliser JCL
JCL est utilisé dans un environnement mainframe pour servir de communication entre un programme (exemple: COBOL, Assembler ou PL / I) et le système d'exploitation. Dans un environnement mainframe, les programmes peuvent être exécutés en mode batch et en ligne. Un exemple d'un système de traitement par lots peut être le traitement des transactions bancaires via un fichier VSAM (Virtual Storage Access Method) et son application aux comptes correspondants. Un exemple de système en ligne peut être un écran d'arrière-guichet utilisé par le personnel d'une banque pour ouvrir un compte. En mode batch, les programmes sont soumis au système d'exploitation en tant que travail via un JCL.
Le traitement par lots et en ligne diffère par l'aspect de la demande d'entrée, de sortie et d'exécution du programme. Dans le traitement par lots, ces aspects sont introduits dans un JCL qui est à son tour reçu par le système d'exploitation.
Traitement des tâches
Un travail est une unité de travail qui peut être composée de plusieurs étapes de travail. Chaque étape de travail est spécifiée dans un langage de contrôle de travail (JCL) via un ensemble d'instructions de contrôle de travail.
Le système d'exploitation utilise Job Entry System (JES) pour recevoir les travaux dans le système d'exploitation, pour planifier leur traitement et pour contrôler la sortie.
Le traitement des tâches passe par une série d'étapes comme indiqué ci-dessous:
Job Submission - Soumettre le JCL à JES.
Job Conversion - Le JCL avec le PROC est converti en un texte interprété pour être compris par JES et stocké dans un ensemble de données, que nous appelons SPOOL.
Job Queuing -JES décide de la priorité du travail en fonction des paramètres CLASS et PRTY dans l'instruction JOB (expliqué dans le chapitre JCL - Instruction JOB ). Les erreurs JCL sont vérifiées et le travail est planifié dans la file d'attente des travaux s'il n'y a pas d'erreurs.
Job Execution -Lorsque le travail atteint sa priorité la plus élevée, il est repris pour exécution à partir de la file d'attente des travaux. Le JCL est lu à partir du SPOOL, le programme est exécuté et la sortie est redirigée vers la destination de sortie correspondante, comme spécifié dans le JCL.
Purging -Lorsque le travail est terminé, les ressources allouées et l'espace JES SPOOL sont libérés. Afin de stocker le journal des travaux, nous devons copier le journal des travaux dans un autre ensemble de données avant qu'il ne soit libéré du SPOOL.
Installation de JCL sous Windows / Linux
Il existe de nombreux émulateurs mainframe gratuits disponibles pour Windows qui peuvent être utilisés pour écrire et apprendre des exemples de JCL.
Un tel émulateur est Hercules, qui peut être facilement installé dans Windows en suivant quelques étapes simples ci-dessous:
Téléchargez et installez l'émulateur Hercules, disponible sur le site d'accueil d'Hercules -: www.hercules-390.eu
Une fois que vous avez installé le package sur la machine Windows, il créera un dossier comme C:\Mainframes.
Exécutez l'invite de commande (CMD) et accédez au répertoire C: \ Mainframes sur CMD.
Le guide complet sur les différentes commandes pour écrire et exécuter un JCL peut être trouvé sur URL www.jaymoseley.com/hercules/installmvs/instmvs2.htm
Hercules est une implémentation logicielle open source des architectures mainframe System / 370 et ESA / 390, en plus de la dernière architecture z / 64 bits. Hercules fonctionne sous Linux, Windows, Solaris, FreeBSD et Mac OS X.
Exécution de JCL sur les mainframes
Un utilisateur peut se connecter à un serveur mainframe de différentes manières, comme un client léger, un terminal factice, un système de client virtuel (VCS) ou un système de bureau virtuel (VDS).
Chaque utilisateur valide reçoit un identifiant de connexion pour entrer dans l'interface Z / OS (TSO / E ou ISPF). Dans l'interface Z / OS, le JCL peut être codé et stocké en tant que membre dans un ensemble de données partitionné (PDS). Lorsque le JCL est soumis, il est exécuté et la sortie reçue comme expliqué dans la section de traitement des travaux du chapitre précédent.
Structure d'un JCL
La structure de base d'un JCL avec les instructions communes est donnée ci-dessous:
//SAMPJCL JOB 1,CLASS=6,MSGCLASS=0,NOTIFY=&SYSUID (1)
//* (2)
//STEP010 EXEC PGM=SORT (3)
//SORTIN DD DSN=JCL.SAMPLE.INPUT,DISP=SHR (4)
//SORTOUT DD DSN=JCL.SAMPLE.OUTPUT, (5)
// DISP=(NEW,CATLG,CATLG),DATACLAS=DSIZE50
//SYSOUT DD SYSOUT=* (6)
//SYSUDUMP DD SYSOUT=C (6)
//SYSPRINT DD SYSOUT=* (6)
//SYSIN DD * (6)
SORT FIELDS=COPY
INCLUDE COND=(28,3,CH,EQ,C'XXX')
/* (7)Description du programme
Les instructions JCL numérotées ont été expliquées ci-dessous:
(1) JOB statement - Spécifie les informations requises pour SPOOLing du travail, telles que l'identifiant du travail, la priorité d'exécution, l'ID utilisateur à notifier à la fin du travail.
(2) //* statement - Ceci est une déclaration de commentaire.
(3) EXEC statement- Spécifie le PROC / Programme à exécuter. Dans l'exemple ci-dessus, un programme SORT est en cours d'exécution (c'est-à-dire, tri des données d'entrée dans un ordre particulier)
(4) Input DD statement- Spécifie le type d'entrée à passer au programme mentionné dans (3). Dans l'exemple ci-dessus, un fichier physique séquentiel (PS) est passé en entrée en mode partagé (DISP = SHR).
(5) Output DD statement- Spécifie le type de sortie à produire par le programme lors de l'exécution. Dans l'exemple ci-dessus, un fichier PS est créé. Si une instruction s'étend au-delà de la 70e position d'une ligne, elle se poursuit dans la ligne suivante, qui doit commencer par "//" suivi d'un ou plusieurs espaces.
(6)Il peut y avoir d'autres types d'instructions DD pour spécifier des informations supplémentaires au programme (dans l'exemple ci-dessus: la condition SORT est spécifiée dans l'instruction SYSIN DD) et pour spécifier la destination du journal des erreurs / exécutions (exemple: SYSUDUMP / SYSPRINT). Les instructions DD peuvent être contenues dans un ensemble de données (fichier mainframe) ou comme dans des données de flux (informations codées en dur dans le JCL) comme indiqué dans l'exemple ci-dessus.
(7) /* marque la fin des données en flux.
Toutes les instructions JCL, à l'exception des données de flux, commencent par //. Il doit y avoir au moins un espace avant et après les mots clés JOB, EXEC et DD et il ne doit y avoir aucun espace dans le reste de l'instruction.
Types de paramètres JOB
Chacune des instructions JCL est accompagnée d'un ensemble de paramètres pour aider les systèmes d'exploitation à terminer l'exécution du programme. Les paramètres peuvent être de deux types:
Paramètres de position
Apparaît à la position et à l'ordre prédéfinis dans l'instruction. Exemple: Informations comptables Le paramètre ne peut apparaître qu'après leJOBmot-clé et avant le paramètre de nom du programmeur et les paramètres de mot-clé. Si un paramètre de position est omis, il doit être remplacé par une virgule.
Les paramètres de position sont présents dans les instructions JOB et EXEC. Dans l'exemple ci-dessus, PGM est un paramètre de position codé après leEXEC mot-clé.
Paramètres de mot-clé
Ils sont codés après les paramètres de position, mais peuvent apparaître dans n'importe quel ordre. Les paramètres de mot-clé peuvent être omis s'ils ne sont pas obligatoires. La syntaxe générique est KEYWORD = valeur . Exemple: MSGCLASS = X, c'est-à-dire que le journal du travail est redirigé vers le SPOOL de sortie une fois le travail terminé.
Dans l'exemple ci-dessus, CLASS, MSGCLASS et NOTIFY sont des paramètres de mot-clé de l'instruction JOB. Il peut également y avoir des paramètres de mot-clé dans l'instruction EXEC.
Ces paramètres ont été détaillés dans les chapitres suivants avec des exemples appropriés.
L'instruction JOB est la première instruction de contrôle d'un JCL. Cela donne l'identité du travail au système d'exploitation (OS), dans le spool et dans le planificateur. Les paramètres de l'instruction JOB aident les systèmes d'exploitation à allouer le bon planificateur, le temps processeur requis et à envoyer des notifications à l'utilisateur.
Syntaxe
Voici la syntaxe de base d'une instruction JCL JOB:
//Job-name JOB Positional-param, Keyword-paramLa description
Voyons la description des termes utilisés dans la syntaxe de l'instruction JOB ci-dessus.
Nom du travail
Cela donne un identifiant au travail tout en le soumettant au système d'exploitation. Il peut avoir une longueur de 1 à 8 avec des caractères alphanumériques et commence juste après //.
EMPLOI
Il s'agit du mot-clé pour l'identifier en tant qu'instruction JOB.
Paramètre de position
Il existe des paramètres de position, qui peuvent être de deux types:
| Paramètre de position | La description |
|---|---|
| Account information | Cela fait référence à la personne ou au groupe auquel le temps CPU est dû. Il est défini selon les règles de l'entreprise propriétaire des mainframes. S'il est spécifié par (*), alors il prend l'identifiant de l'utilisateur, qui s'est actuellement connecté au terminal mainframe. |
| Programmer name | Cela identifie la personne ou le groupe responsable du JCL. Ce n'est pas un paramètre obligatoire et peut être remplacé par une virgule. |
Keyword-param
Voici les différents paramètres de mot-clé, qui peuvent être utilisés dans l'instruction JOB. Vous pouvez utiliser un ou plusieurs paramètres en fonction des exigences et ils sont séparés par une virgule:
| Paramètre de mot-clé | La description |
|---|---|
| CLASS | En fonction de la durée et du nombre de ressources requises par le poste, les entreprises attribuent différentes classes d'emplois. Ceux-ci peuvent être visualisés comme des planificateurs individuels utilisés par le système d'exploitation pour recevoir les travaux. Placer les tâches dans le bon planificateur facilitera l'exécution des tâches. Certaines entreprises ont des classes différentes pour les emplois dans les environnements de test et de production. Les valeurs valides pour le paramètre CLASS sont les caractères A à Z et 0 à 9 numériques (de longueur 1). Voici la syntaxe: CLASS=0 to 9 | A to Z |
| PRTY | Pour spécifier la priorité du travail dans une classe de travail. Si ce paramètre n'est pas spécifié, le travail est ajouté à la fin de la file d'attente dans la CLASSE spécifiée. Voici la syntaxe: PRTY=N Où N est un nombre compris entre 0 et 15 et plus le nombre est élevé, plus la priorité est élevée. |
| NOTIFY | Le système envoie le message de réussite ou d'échec (code de condition maximum) à l'utilisateur spécifié dans ce paramètre. Voici la syntaxe: NOTIFY="userid | &SYSUID" Ici, le système envoie le message à l'utilisateur "userid" mais si nous utilisons NOTIFY = & SYSUID, alors le message est envoyé à l'utilisateur soumettant le JCL. |
| MSGCLASS | Pour spécifier la destination de sortie pour le système et les messages de tâche une fois la tâche terminée. Voici la syntaxe: MSGCLASS=CLASS Les valeurs valides de CLASS peuvent être de "A" à "Z" et "0" à "9". MSGCLASS = Y peut être défini comme classe pour envoyer le journal des travaux au JMR (JOBLOG Management and Retrieval: un référentiel dans les mainframes pour stocker les statistiques des travaux). |
| MSGLEVEL | Spécifie le type de messages à écrire dans la destination de sortie spécifiée dans MSGCLASS. Voici la syntaxe: MSGLEVEL=(ST, MSG) ST = Type d'instructions écrites dans le journal de sortie
MSG = Type de messages écrits dans le journal de sortie.
|
| TYPRUN | Spécifie un traitement spécial pour le travail. Voici la syntaxe: TYPRUN = SCAN | HOLD Où SCAN and HOLD a la description suivante
|
| TIME | Spécifie l'intervalle de temps à utiliser par le processeur pour exécuter le travail. Voici la syntaxe: TIME=(mm, ss) or TIME=ss Où mm = minutes et ss = secondes Ce paramètre peut être utile lors du test d'un programme nouvellement codé. Afin de garantir que le programme ne s'exécute pas longtemps en raison d'erreurs de boucle, un paramètre de temps peut être codé de sorte que le programme s'arrête lorsque le temps CPU spécifié est atteint. |
| REGION | Spécifie l'espace d'adressage requis pour exécuter une étape de travail dans le travail. Voici la syntaxe: REGION=nK | nM Ici, la région peut être spécifiée comme nK ou nM où n est un nombre, K est un kilo-octet et M est un mégaoctet. Lorsque REGION = 0K ou 0M, le plus grand espace d'adressage est fourni pour l'exécution.Dans les applications critiques, le codage de 0K ou 0M est interdit pour éviter de gaspiller l'espace d'adressage. |
Exemple
//URMISAMP JOB (*),"tutpoint",CLASS=6,PRTY=10,NOTIFY=&SYSUID,
// MSGCLASS=X,MSGLEVEL=(1,1),TYPRUN=SCAN,
// TIME=(3,0),REGION=10KIci, l'instruction JOB est étendue au-delà de la 70ème position d'une ligne, nous continuons donc à la ligne suivante qui devrait commencer par "//" suivi d'un ou plusieurs espaces.
Paramètres divers
Il existe peu d'autres paramètres qui peuvent être utilisés avec l'instruction JOB, mais ils ne sont pas fréquemment utilisés:
| ADDRSPC | Type de stockage utilisé: virtuel ou réel |
| BYTES | Taille des données à écrire dans le journal de sortie et action à entreprendre lorsque la taille est dépassée. |
| LINES | Nombre maximum de lignes à imprimer dans le journal de sortie. |
| PAGES | Nombre maximum de pages à imprimer dans le journal de sortie. |
| USER | ID utilisateur utilisé pour soumettre le travail |
| PASSWORD | Mot de passe de l'ID utilisateur spécifié dans le paramètre USER. |
| COND and RESTART | Ceux-ci sont utilisés dans le traitement d'étape de tâche conditionnelle et sont expliqués en détail tout en discutant du traitement conditionnel. |
Chaque JCL peut être composé de plusieurs étapes de travail. Chaque étape de tâche peut exécuter un programme directement ou peut appeler une procédure, qui à son tour exécute un ou plusieurs programmes (étapes de tâche). L'instruction, qui contient les informations de programme / procédure d'étape de travail, estEXEC statement.
Le but de l'instruction EXEC est de fournir les informations requises pour le programme / la procédure exécutée dans l'étape de travail. Les paramètres codés dans cette instruction peuvent transmettre des données au programme en cours d'exécution, peuvent remplacer certains paramètres de l'instruction JOB et peuvent transmettre des paramètres à la procédure si l'instruction EXEC appelle une procédure au lieu d'exécuter directement un programme.
Syntaxe
Voici la syntaxe de base d'une instruction JCL EXEC:
//Step-name EXEC Positional-param, Keyword-paramLa description
Voyons la description des termes utilisés dans la syntaxe des instructions EXEC ci-dessus.
NOM DE L'ÉTAPE
Cela identifie l'étape de travail dans le JCL. Il peut être de 1 à 8 avec des caractères alphanumériques.
EXEC
Il s'agit du mot-clé pour l'identifier en tant qu'instruction EXEC.
PARAMÉ POSITIONNEL
Ce sont des paramètres de position, qui peuvent être de deux types:
| Paramètre de position | La description |
|---|---|
| PGM | Cela fait référence au nom du programme à exécuter dans l'étape de travail. |
| PROC | Cela fait référence au nom de la procédure à exécuter dans l'étape de travail. Nous en discuterons dans un chapitre séparé. |
MOT-CLÉ-PARAM
Voici les différents paramètres de mot-clé pour l'instruction EXEC. Vous pouvez utiliser un ou plusieurs paramètres en fonction des exigences et ils sont séparés par une virgule:
| Paramètre de mot-clé | La description |
|---|---|
| PARM | Utilisé pour fournir des données paramétrées au programme en cours d'exécution dans l'étape de travail. Il s'agit d'un champ dépendant du programme et qui n'a pas de règles définies, sauf que la valeur PARM doit être incluse dans le devis en cas de caractères spéciaux. Par exemple donné ci-dessous, la valeur "CUST1000" est transmise sous forme de valeur alphanumérique au programme. Si le programme est en COBOL, la valeur transmise via un paramètre PARM dans un JCL est reçue dans la SECTION LINKAGE du programme. |
| ADDRSPC | Ceci est utilisé pour spécifier si l'étape de travail nécessite un stockage virtuel ou réel pour l'exécution. Le stockage virtuel est paginable alors que le stockage réel ne l'est pas et est placé dans la mémoire principale pour exécution. Les étapes de travail, qui nécessitent une exécution plus rapide, peuvent être placées dans un stockage réel. Voici la syntaxe: ADDRSPC=VIRT | REAL Lorsqu'un ADDRSPC n'est pas codé, VIRT est celui par défaut. |
| ACCT | Ceci spécifie les informations comptables de l'étape de travail. Voici la syntaxe: ACCT=(userid) Ceci est similaire au paramètre de position accounting informationdans l'instruction JOB. S'il est codé à la fois dans l'instruction JOB et dans l'instruction EXEC, les informations de comptabilité dans l'instruction JOB s'appliquent à toutes les étapes de travail où un paramètre ACCT n'est pas codé. Le paramètre ACCT dans une instruction EXEC remplacera celui présent dans l'instruction JOB pour cette étape de travail uniquement. |
Paramètres de mot-clé courants de l'instruction EXEC et JOB
| Paramètre de mot-clé | La description |
|---|---|
| ADDRSPC | ADDRSPC codé dans l'instruction JOB remplace l'ADDRSPC codé dans l'instruction EXEC de toute étape de travail. |
| TIME | Si TIME est codé dans une instruction EXEC, il s'applique uniquement à cette étape de travail. S'il est spécifié à la fois dans les instructions JOB et EXEC, les deux seront en vigueur et peuvent provoquer une erreur de temporisation due à l'un ou l'autre. Il n'est pas recommandé d'utiliser simultanément le paramètre TIME dans l'instruction JOB et EXEC. |
| REGION | Si REGION est codé dans une instruction EXEC, il s'applique uniquement à cette étape de travail. REGION codée dans l'instruction JOB remplace la REGION codée dans l'instruction EXEC de toute étape de travail. |
| COND | Utilisé pour contrôler l'exécution de l'étape de travail en fonction du code retour de l'étape précédente. Si un paramètre COND est codé dans une instruction EXEC d'une étape de travail, le paramètre COND de l'instruction JOB (s'il est présent) est ignoré. Les différents tests qui peuvent être effectués à l'aide d'un paramètre COND sont expliqués dans Traitement conditionnel. |
Exemple
Voici un exemple simple de script JCL avec les instructions JOB et EXEC:
//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,
// NOTIFY=&SYSUID
//*
//STEP010 EXEC PGM=MYCOBOL,PARAM=CUST1000,
// ACCT=(XXXX),REGION=8K,ADDRSPC=REAL,TIME=1440Les ensembles de données sont des fichiers mainframe avec des enregistrements organisés dans un format spécifique. Les ensembles de données sont stockés sur le périphérique de stockage à accès direct (DASD) ou sur les bandes du mainframe et sont des zones de stockage de données de base. Si ces données doivent être utilisées / créées dans un programme de traitement par lots, le nom physique du fichier (c'est-à-dire l'ensemble de données) ainsi que le format et l'organisation du fichier sont codés dans un JCL.
La définition de chaque ensemble de données utilisé dans le JCL est donnée à l'aide du DD statement. Les ressources d'entrée et de sortie requises par une étape de travail doivent être décrites dans une déclaration DD avec des informations telles que l'organisation de l'ensemble de données, les exigences de stockage et la longueur de l'enregistrement.
Syntaxe
Voici la syntaxe de base d'une instruction JCL DD:
//DD-name DD ParametersLa description
Voyons la description des termes utilisés dans la syntaxe des instructions DD ci-dessus.
DD-NAME
Un DD-NAME identifie l'ensemble de données ou la ressource d'entrée / sortie. S'il s'agit d'un fichier d'entrée / sortie utilisé par un programme COBOL / Assembler, le fichier est référencé par ce nom dans le programme.
DD
Il s'agit du mot-clé pour l'identifier en tant qu'instruction DD.
PARAMÈTRES
Voici les différents paramètres de l'instruction DD. Vous pouvez utiliser un ou plusieurs paramètres en fonction des exigences et ils sont séparés par une virgule:
| Paramètre | La description |
|---|---|
| DSN | Le paramètre DSN fait référence au nom de l'ensemble de données physique d'un ensemble de données nouvellement créé ou existant. La valeur DSN peut être constituée de sous-noms de 1 à 8 caractères chacun, séparés par des points et d'une longueur totale de 44 caractères (alphanumériques). Voici la syntaxe: DSN=Physical Dataset Name Temporary datasetsont besoin de stockage uniquement pour la durée du travail et sont supprimés à la fin du travail. Ces ensembles de données sont représentés commeDSN=&name ou simplement sans DSN spécifié. Si un ensemble de données temporaire créé par une étape de tâche doit être utilisé dans l'étape de tâche suivante, il est référencé comme DSN=*.stepname.ddname. C'est appelé Backward Referencing. |
| DISP | Le paramètre DISP est utilisé pour décrire l'état de l'ensemble de données, la disposition à la fin de l'étape de travail en cas d'achèvement normal et anormal. DISP n'est pas requis dans une instruction DD uniquement lorsque l'ensemble de données est créé et supprimé dans la même étape de travail (comme les ensembles de données temporaires). Voici la syntaxe: DISP=(status, normal-disposition, abnormal-disposition) Voici les valeurs valides pour status:
UNE normal-disposition le paramètre peut prendre l'une des valeurs suivantes
UNE abnormal-disposition le paramètre peut prendre l'une des valeurs suivantes
Voici la description des paramètres CATLG, UNCATLG, DELETE, PASS et KEEP:
Lorsque l'un des sous-paramètres de DISP n'est pas spécifié, les valeurs par défaut sont les suivantes:
|
| DCB | Le paramètre DCB (Data Control Block) détaille les caractéristiques physiques d'un jeu de données. Ce paramètre est obligatoire pour les ensembles de données nouvellement créés à l'étape de travail. LRECL est la longueur de chaque enregistrement contenu dans l'ensemble de données. RECFM est le format d'enregistrement de l'ensemble de données. RECFM peut contenir des valeurs FB, V ou VB. FB est une organisation de bloc fixe où un ou plusieurs enregistrements logiques sont regroupés dans un seul bloc. V est une organisation variable dans laquelle un enregistrement logique de longueur variable est placé dans un bloc physique. VB est une organisation à blocs variables dans laquelle un ou plusieurs enregistrements logiques de longueur variable sont placés dans un bloc physique. BLKSIZE est la taille du bloc physique. Plus le bloc est grand, plus le nombre d'enregistrements pour un fichier FB ou VB est grand. DSORG est le type d'organisation de l'ensemble de données. DSORG peut contenir les valeurs PS (Physical Sequential), PO (Partitioned Organization) et DA (Direct Organization). Lorsqu'il est nécessaire de répliquer les valeurs DCB d'un ensemble de données vers un autre dans le même étape de travail ou JCL, il est spécifié comme DCB = *. Stepname.ddname où stepname est le nom de l'étape de travail et ddname est l'ensemble de données à partir duquel le DCB est copié. Vérifiez l'exemple ci-dessous où RECFM = FB, LRECL = 80 forme le DCB de l'ensemble de données OUTPUT1. |
| SPACE | Le paramètre SPACE spécifie l'espace requis pour l'ensemble de données dans le DASD (Direct Access Storage Disk). Voici la syntaxe: SPACE=(spcunits, (pri, sec, dir), RLSE) Voici la description de tous les paramètres utilisés:
|
| UNIT | Les paramètres UNIT et VOL sont répertoriés dans le catalogue système pour les ensembles de données catalogués et sont donc accessibles uniquement avec le nom DSN physique. Mais pour les ensembles de données non catalogués, l'instruction DD doit inclure ces paramètres. Pour créer de nouveaux ensembles de données, les paramètres UNIT / VOL peuvent être spécifiés ou le Z / OS alloue le périphérique et le volume appropriés. Le paramètre UNIT spécifie le type de périphérique sur lequel l'ensemble de données est stocké. Le type de périphérique peut être identifié à l'aide du groupe Adresse matérielle ou Type de périphérique. Voici la syntaxe: UNIT=DASD | SYSDA Où DASD signifie Direct Access Storage Device et SYSDA signifie System Direct Access et fait référence au prochain périphérique de stockage sur disque disponible. |
| VOL | Le paramètre VOL spécifie le numéro de volume sur l'appareil identifié par le paramètre UNIT. Voici la syntaxe: VOL=SER=(v1,v2) Où v1, v2 sont des numéros de série de volume. Vous pouvez également utiliser la syntaxe suivante: VOL=REF=*.DDNAME Où REF est la référence arrière au numéro de série du volume d'un ensemble de données dans l'une des étapes de travail précédentes dans le JCL. |
| SYSOUT | Les paramètres de l'instruction DD discutés jusqu'à présent correspondent aux données stockées dans un ensemble de données. Le paramètre SYSOUT dirige les données vers le périphérique de sortie en fonction de la classe spécifiée. Voici la syntaxe SYSOUT=class Où si la classe est A alors elle dirige la sortie vers l'imprimante, et si la classe est * puis il dirige la sortie vers la même destination que celle du paramètre MSGCLASS dans l'instruction JOB. |
Exemple
Voici un exemple qui utilise des instructions DD avec divers paramètres expliqués ci-dessus:
//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,
// NOTIFY=&SYSUID
//*
//STEP010 EXEC PGM=ICETOOL,ADDRSPC=REAL
//*
//INPUT1 DD DSN=TUTO.SORT.INPUT1,DISP=SHR
//INPUT2 DD DSN=TUTO.SORT.INPUT2,DISP=SHR,UNIT=SYSDA,
// VOL=SER=(1243,1244)
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80,SPACE=(CYL,(10,20))
//OUTPUT2 DD SYSOUT=*Base Libraryest le jeu de données partitionné (PDS), qui contient les modules de chargement du programme à exécuter dans le JCL ou la procédure cataloguée, qui est appelée dans le programme. Les bibliothèques de base peuvent être spécifiées pour l'ensemble du JCL dans unJOBLIB bibliothèque ou pour une étape de travail particulière dans un STEPLIB déclaration.
Déclaration JOBLIB
UNE JOBLIBl'instruction est utilisée pour identifier l'emplacement du programme à exécuter dans un JCL. L'instruction JOBLIB est spécifiée après l'instruction JOB et avant l'instruction EXEC. Cela ne peut être utilisé que pour les procédures et programmes in stream.
Syntaxe
Voici la syntaxe de base d'une instruction JCL JOBLIB:
//JOBLIB DD DSN=dsnname,DISP=SHRL'instruction JOBLIB s'applique à toutes les instructions EXEC du JCL. Le programme spécifié dans l'instruction EXEC sera recherché dans la bibliothèque JOBLIB suivi de la bibliothèque système.
Par exemple, si l'instruction EXEC exécute un programme COBOL, le module de chargement du programme COBOL doit être placé dans la bibliothèque JOBLIB.
Déclaration STEPLIB
UNE STEPLIBL'instruction est utilisée pour identifier l'emplacement du programme à exécuter dans une étape de travail. L'instruction STEPLIB est spécifiée après l'instruction EXEC et avant l'instruction DD de l'étape de travail.
Syntaxe
Voici la syntaxe de base d'une instruction JCL STEPLIB:
//STEPLIB DD DSN=dsnname,DISP=SHRLe programme spécifié dans l'instruction EXEC sera recherché dans la bibliothèque STEPLIB suivi de la bibliothèque système. STEPLIB codé dans une étape de travail remplace l'instruction JOBLIB.
Exemple
L'exemple suivant montre l'utilisation des instructions JOBLIB et STEPLIB:
//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID
//*
//JOBLIB DD DSN=MYPROC.BASE.LIB1,DISP=SHR
//*
//STEP1 EXEC PGM=MYPROG1
//INPUT1 DD DSN=MYFILE.SAMPLE.INPUT1,DISP=SHR
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80
//*
//STEP2 EXEC PGM=MYPROG2
//STEPLIB DD DSN=MYPROC.BASE.LIB2,DISP=SHR
//INPUT2 DD DSN=MYFILE.SAMPLE.INPUT2,DISP=SHR
//OUTPUT2 DD DSN=MYFILES.SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80Ici, le module de chargement du programme MYPROG1 (dans STEP1) est recherché dans MYPROC.SAMPLE.LIB1. S'il n'est pas trouvé, il est recherché dans la bibliothèque système. Dans STEP2, STEPLIB remplace JOBLIB et le module de chargement du programme MYPROG2 est recherché dans MYPROC.SAMPLE.LIB2 puis dans la bibliothèque système.
Instruction INCLUDE
Un ensemble d'instructions JCL codées dans un membre d'un PDS peut être inclus dans un JCL à l'aide d'un INCLUDEdéclaration. Lorsque le JES interprète le JCL, l'ensemble d'instructions JCL du membre INCLUDE remplace l'instruction INCLUDE.
Syntaxe
Voici la syntaxe de base d'une instruction JCL INCLUDE:
//name INCLUDE MEMBER=member-nameLe but principal de l'instruction INCLUDE est la réutilisabilité. Par exemple, les fichiers communs à utiliser dans de nombreux JCL peuvent être codés comme des instructions DD dans le membre INCLUDE et utilisés dans un JCL.
Les instructions DD factices, les spécifications de la carte de données, les instructions PROC, JOB, PROC ne peuvent pas être codées dans un membre INCLUDE. Une instruction INLCUDE peut être codée dans un membre INCLUDE et une imbrication supplémentaire peut être effectuée jusqu'à 15 niveaux.
Déclaration JCLLIB
UNE JCLLIBL'instruction est utilisée pour identifier les bibliothèques privées utilisées dans le travail. Il peut être utilisé à la fois avec les procédures en cours d'eau et cataloguées.
Syntaxe
Voici la syntaxe de base d'une instruction JCL JCLLIB:
//name JCLLIB ORDER=(library1, library2....)Les bibliothèques spécifiées dans l'instruction JCLLIB seront recherchées dans l'ordre indiqué pour localiser les programmes, les procédures et le membre INCLUDE utilisés dans le travail. Il ne peut y avoir qu'une seule instruction JCLLIB dans un JCL; spécifié après une instruction JOB et avant les instructions EXEC et INCLUDE mais il ne peut pas être codé dans un membre INCLUDE.
Exemple
Dans l'exemple suivant, le programme MYPROG3 et INCLUDE membre MYINCL est recherché dans l'ordre de MYPROC.BASE.LIB1, MYPROC.BASE.LIB2, bibliothèque système.
//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID
//*
//MYLIB JCLLIB ORDER=(MYPROC.BASE.LIB1,MYPROC.BASE.LIB2)
//*
//STEP1 EXEC PGM=MYPROG3
//INC INCLUDE MEMBER=MYINCL
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80
//*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 nameLe 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 y a 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 dans le JCL et que PGM prend donc la valeur CATPRC1 pendant 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 œ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.
Le Job Entry System utilise deux approches pour effectuer un traitement conditionnel dans un JCL. Lorsqu'un travail se termine, un code retour est défini en fonction de l'état de l'exécution. Le code retour peut être un nombre compris entre 0 (exécution réussie) et 4095 (une condition d'erreur différente de zéro). Les valeurs conventionnelles les plus courantes sont:
0 = Normal - tout est OK
4 = Avertissement - erreurs ou problèmes mineurs.
8 = Erreur - erreurs ou problèmes importants.
12 = Erreur grave - erreurs ou problèmes majeurs, les résultats ne doivent pas être fiables.
16 = Erreur de terminal - problèmes très graves, n'utilisez pas les résultats.
L'exécution d'une étape de travail peut être contrôlée en fonction du code retour de la ou des étapes précédentes à l'aide du COND paramètre et IF-THEN-ELSE construct, qui a été expliqué dans ce tutoriel.
Paramètre COND
UNE CONDLe paramètre peut être codé dans l'instruction JOB ou EXEC de JCL. Il s'agit d'un test sur le code retour des étapes de travail précédentes. Si le test est évalué comme vrai, l'exécution de l'étape de travail en cours est ignorée. Le contournement est simplement une omission de l'étape de travail et non une interruption anormale. Il peut y avoir au plus huit conditions combinées dans un seul test.
Syntaxe
Voici la syntaxe de base d'un paramètre JCL COND:
COND=(rc,logical-operator)
or
COND=(rc,logical-operator,stepname)
or
COND=EVEN
or
COND=ONLYVoici la description des paramètres utilisés:
rc : Ceci est le code retour
logical-operator : Cela peut être GT (supérieur à), GE (supérieur ou égal à), EQ (égal à), LT (inférieur à), LE (inférieur ou égal à) ou NE (différent de).
stepname : Il s'agit de l'étape du travail dont le code retour est utilisé dans le test.
Les deux dernières conditions (a) COND = EVEN et (b) COND = ONLY, ont été expliquées ci-dessous dans ce tutoriel.
Le COND peut être codé à l'intérieur de l'instruction JOB ou de l'instruction EXEC, et dans les deux cas, il se comporte différemment comme expliqué ci-dessous:
Instruction COND inside JOB
Lorsque COND est codé dans l'instruction JOB, la condition est testée pour chaque étape du travail. Lorsque la condition est vraie à une étape de travail particulière, elle est contournée avec les étapes de travail qui la suivent. Voici un exemple:
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID,COND=(5,LE)
//*
//STEP10 EXEC PGM=FIRSTP
//* STEP10 executes without any test being performed.
//STEP20 EXEC PGM=SECONDP
//* STEP20 is bypassed, if RC of STEP10 is 5 or above.
//* Say STEP10 ends with RC4 and hence test is false.
//* So STEP20 executes and lets say it ends with RC16.
//STEP30 EXEC PGM=SORT
//* STEP30 is bypassed since 5 <= 16.COND dans l'instruction EXEC
Lorsque COND est codé dans l'instruction EXEC d'une étape de travail et trouvé vrai, seule cette étape de travail est contournée et l'exécution se poursuit à partir de l'étape de travail suivante.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.
//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),(10,GT,STP02))
//* In STP03, first condition fails and hence STP03 executes.
//* Since STP02 is bypassed, the condition (10,GT,STP02) in
//* STP03 is not tested.COND = MÊME
Lorsque COND = EVEN est codé, l'étape de travail en cours est exécutée, même si l'une des étapes précédentes se termine anormalement. Si une autre condition RC est codée avec COND = EVEN, alors l'étape de travail s'exécute si aucune des conditions RC n'est vraie.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.
//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),EVEN)
//* In STP03, condition (10,LT,STP01) evaluates to true,
//* hence the step is bypassed.COND = UNIQUEMENT
Lorsque COND = ONLY est codé, l'étape de travail en cours est exécutée uniquement lorsque l'une des étapes précédentes se termine anormalement. Si une autre condition RC est codée avec COND = ONLY, alors l'étape de travail s'exécute si aucune des conditions RC n'est vraie et si l'une des étapes de travail précédentes échoue anormalement.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.
//STP02 EXEC PGM=MYCOBB,COND=(4,EQ,STP01)
//* In STP02, condition evaluates to FALSE, step is executed
//* and assume the step abends.
//STP03 EXEC PGM=IEBGENER,COND=((0,EQ,STP01),ONLY)
//* In STP03, though the STP02 abends, the condition
//* (0,EQ,STP01) is met. Hence STP03 is bypassed.Construction IF-THEN-ELSE
Une autre approche pour contrôler le traitement du travail consiste à utiliser des constructions IF-THEN-ELSE. Cela donne plus de flexibilité et un moyen convivial de traitement conditionnel.
Syntaxe
Voici la syntaxe de base d'une construction JCL IF-THEN-ELSE:
//name IF condition THEN
list of statements //* action to be taken when condition is true
//name ELSE
list of statements //* action to be taken when condition is false
//name ENDIFVoici la description des termes utilisés dans la construction IF-THEN-ELSE ci-dessus:
name : Ceci est facultatif et un nom peut comporter de 1 à 8 caractères alphanumériques commençant par l'alphabet, #, $ ou @.
Condition : Une condition aura un format: KEYWORD OPERATOR VALUE, où KEYWORDSpeut être RC (code de retour), ABENDCC (code d'achèvement du système ou de l'utilisateur), ABEND, RUN (exécution de l'étape démarrée). UnOPERATOR peut être un opérateur logique (AND (&), OR (|)) ou un opérateur relationnel (<, <=,>,> =, <>).
Exemple
Voici un exemple simple montrant l'utilisation de IF-THEN-ELSE:
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//PRC1 PROC
//PST1 EXEC PGM=SORT
//PST2 EXEC PGM=IEBGENER
// PEND
//STP01 EXEC PGM=SORT
//IF1 IF STP01.RC = 0 THEN
//STP02 EXEC PGM=MYCOBB1,PARM=123
// ENDIF
//IF2 IF STP01.RUN THEN
//STP03a EXEC PGM=IEBGENER
//STP03b EXEC PGM=SORT
// ENDIF
//IF3 IF STP03b.!ABEND THEN
//STP04 EXEC PGM=MYCOBB1,PARM=456
// ELSE
// ENDIF
//IF4 IF (STP01.RC = 0 & STP02.RC <= 4) THEN
//STP05 EXEC PROC=PRC1
// ENDIF
//IF5 IF STP05.PRC1.PST1.ABEND THEN
//STP06 EXEC PGM=MYABD
// ELSE
//STP07 EXEC PGM=SORT
// ENDIFEssayons d'examiner le programme ci-dessus pour le comprendre un peu plus en détail:
Le code retour de STP01 est testé dans IF1. S'il vaut 0, alors STP02 est exécuté. Sinon, le traitement passe à l'instruction IF suivante (IF2).
Dans IF2, si STP01 a commencé l'exécution, alors STP03a et STP03b sont exécutés.
Dans IF3, si STP03b n'ABEND, alors STP04 est exécuté. Dans ELSE, il n'y a aucune déclaration. Cela s'appelle une instruction NULL ELSE.
En IF4, si STP01.RC = 0 et STP02.RC <= 4 sont TRUE, alors STP05 est exécuté.
Dans IF5, si l'étape de processus PST1 dans PROC PRC1 dans l'étape de travail STP05 ABEND, alors STP06 est exécuté. Sinon, STP07 est exécuté.
Si IF4 est évalué à faux, alors STP05 n'est pas exécuté. Dans ce cas, IF5 ne sont pas testés et les étapes STP06, STP07 ne sont pas exécutées.
Le IF-THEN-ELSE ne sera pas exécuté en cas d'arrêt anormal du travail tel que l'annulation du travail par l'utilisateur, l'expiration du temps du travail ou un ensemble de données est référencé en arrière vers une étape qui est contournée.
Définition des points de contrôle
Vous pouvez définir un jeu de données de point de contrôle dans votre programme JCL en utilisant SYSCKEOV, qui est une instruction DD.
UNE CHKPTest le paramètre codé pour les ensembles de données QSAM multi-volumes dans une instruction DD. Lorsqu'un CHKPT est codé comme CHKPT = EOV, un point de contrôle est écrit dans l'ensemble de données spécifié dans l'instruction SYSCKEOV à la fin de chaque volume de l'ensemble de données multi-volumes d'entrée / sortie.
//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=MYCOBB
//SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FBDans l'exemple ci-dessus, un point de contrôle est écrit dans l'ensemble de données SAMPLE.CHK à la fin de chaque volume de l'ensemble de données de sortie SAMPLE.OUT.
Redémarrer le traitement
Vous pouvez redémarrer le traitement de l'éther de manière automatisée en utilisant le RD parameter ou manuel en utilisant le RESTART parameter.
RD parameter est codé dans l'instruction JOB ou EXEC et facilite le redémarrage automatisé du JOB / STEP et peut contenir l'une des quatre valeurs: R, RNC, NR ou NC.
RD=R autorise les redémarrages automatisés et considère le point de contrôle codé dans le paramètre CHKPT de l'instruction DD.
RD=RNC autorise les redémarrages automatisés, mais remplace (ignore) le paramètre CHKPT.
RD=NRindique que le travail / l'étape ne peut pas être redémarré automatiquement. Mais lorsqu'il est redémarré manuellement à l'aide du paramètre RESTART, le paramètre CHKPT (le cas échéant) sera pris en compte.
RD=NC interdit le redémarrage automatique et le traitement des points de contrôle.
S'il est nécessaire d'effectuer un redémarrage automatique pour des codes de fin anormale spécifiques uniquement, cela peut être spécifié dans le SCHEDxx membre de la bibliothèque IBM System parmlib.
RESTART parameterest codé dans l'instruction JOB ou EXEC et facilite le redémarrage manuel du JOB / STEP après l'échec du travail. RESTART peut être accompagné d'un checkid, qui est le point de contrôle écrit dans l'ensemble de données codé dans l'instruction SYSCKEOV DD. Lorsqu'un checkid est codé, l'instruction SYSCHK DD doit être codée pour référencer l'ensemble de données de point de contrôle après l'instruction JOBLIB (le cas échéant), sinon après l'instruction JOB.
//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID,RESTART=(STP01,chk5)
//*
//SYSCHK DD DSN=SAMPLE.CHK,DISP=OLD
//STP01 EXEC PGM=MYCOBB
//*SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FBDans l'exemple ci-dessus, chk5 est le checkid, c'est-à-dire que STP01 est redémarré au point de contrôle5. Veuillez noter qu'une instruction SYSCHK est ajoutée et l'instruction SYSCKEOV est commentée dans le programme précédent expliqué dans la section Définition du point de contrôle.
Un nom d'ensemble de données spécifie le nom d'un fichier et il est indiqué par DSN dans JCL. Le paramètre DSN fait référence au nom de l'ensemble de données physique d'un ensemble de données nouvellement créé ou existant. La valeur DSN peut être constituée de sous-noms de 1 à 8 caractères chacun, séparés par des points et d'une longueur totale de 44 caractères (alphanumériques). Voici la syntaxe:
DSN=&name | *.stepname.ddnameTemporary datasetsont besoin de stockage uniquement pour la durée du travail et sont supprimés à la fin du travail. Ces ensembles de données sont représentés commeDSN=&name ou simplement sans DSN spécifié.
Si un ensemble de données temporaire créé par une étape de tâche doit être utilisé dans l'étape de tâche suivante, il est référencé comme DSN=*.stepname.ddname. C'est appeléBackward Referencing.
Concaténation d'ensembles de données
S'il existe plusieurs ensembles de données du même format, ils peuvent être concaténés et transmis en tant qu'entrée au programme dans un seul nom DD.
//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID
//*
//STEP10 EXEC PGM=SORT
//SORTIN DD DSN=SAMPLE.INPUT1,DISP=SHR
// DD DSN=SAMPLE.INPUT2,DISP=SHR
// DD DSN=SAMPLE.INPUT3,DISP=SHR
//SORTOUT DD DSN=SAMPLE.OUTPUT,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FBDans l'exemple ci-dessus, trois ensembles de données sont concaténés et transmis en entrée au programme SORT dans le nom SORTIN DD. Les fichiers sont fusionnés, triés sur les champs clés spécifiés, puis écrits dans un seul fichier de sortie SAMPLE.OUTPUT dans le nom SORTOUT DD.
Remplacer les ensembles de données
Dans un JCL standardisé, le programme à exécuter et ses jeux de données associés sont placés dans une procédure cataloguée, appelée dans le JCL. Habituellement, à des fins de test ou pour résoudre un incident, il peut être nécessaire d'utiliser des ensembles de données différents de ceux spécifiés dans la procédure cataloguée. Dans ce cas, l'ensemble de données de la procédure peut être remplacé dans le JCL.
//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//JSTEP1 EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
//*
//* The cataloged procedure is as below:
//*
//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//STEP1 EXEC PGM=&PROG
//STEPLIB DD DSN=&BASELB,DISP=SHR
//IN1 DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2 EXEC PGM=SORTDans l'exemple ci-dessus, l'ensemble de données IN1 utilise le fichier MYDATA.URMI.INPUT dans le PROC, qui est remplacé dans le JCL. Par conséquent, le fichier d'entrée utilisé lors de l'exécution est MYDATA.OVER.INPUT. Veuillez noter que l'ensemble de données est appelé STEP1.IN1. S'il n'y a qu'une seule étape dans le JCL / PROC, alors l'ensemble de données peut être référencé uniquement avec le nom DD. De même, s'il existe plusieurs étapes dans le JCL, l'ensemble de données doit être remplacé par JSTEP1.STEP1.IN1.
//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
// DD DUMMY
// DD DUMMY
//*Dans l'exemple ci-dessus, sur les trois ensembles de données concaténés dans IN1, le premier est remplacé dans le JCL et le reste est conservé comme celui présent dans PROC.
Définition des GDG dans un JCL
Les groupes de données de génération (GDG) sont des groupes d'ensembles de données liés les uns aux autres par un nom commun. Le nom commun est appelé base GDG et chaque ensemble de données associé à la base est appelé version GDG.
Par exemple, MYDATA.URMI.SAMPLE.GDG est le nom de base GDG. Les ensembles de données sont nommés MYDATA.URMI.SAMPLE.GDG.G0001V00, MYDATA.URMI.SAMPLE.GDG.G0002V00 et ainsi de suite. La dernière version du GDG est appelée MYDATA.URMI.SAMPLE.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.URMI.SAMPLE.GDG (+1) dans le JCL.
Créer / modifier GDG dans un JCL
Les versions GDG peuvent avoir des paramètres DCB identiques ou différents. Un modèle initial DCB peut être défini pour être utilisé par toutes les versions, mais il peut être remplacé lors de la création de nouvelles versions.
//GDGSTEP1 EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN DD *
DEFINE GDG(NAME(MYDATA.URMI.SAMPLE.GDG) -
LIMIT(7) -
NOEMPTY -
SCRATCH)
/*
//GDGSTEP2 EXEC PGM=IEFBR14
//GDGMODLD DD DSN=MYDATA.URMI.SAMPLE.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 de l'ensemble 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écataloge la génération la moins récente.
SCRATCH supprime physiquement la génération lorsqu'elle n'est pas cataloguée.
NOSCRATCH ne supprimez pas le jeu de données, c'est-à-dire qu'il peut être référencé en utilisant les paramètres UNIT et VOL.
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 à l'aide de la commande SYSIN sont ALTER MYDATA.URMI.SAMPLE.GDG LIMIT(15) EMPTY.
Supprimer GDG dans un JCL
En utilisant l'utilitaire IEFBR14, nous pouvons supprimer une seule version d'un GDG.
//GDGSTEP3 EXEC PGM=IEFBR14
//GDGDEL DD DSN=MYDATA.URMI.SAMPLE.GDG(0),
// DISP=(OLD,DELETE,DELETE)Dans l'exemple ci-dessus, la dernière version de MYDATA.URMI.SAMPLE.GDG est supprimée. Veuillez noter que le paramètre DISP à l'achèvement normal du travail est codé comme DELETE. Par conséquent, l'ensemble de données est supprimé lorsque l'exécution du travail est terminée.
IDCAMS peut être utilisé pour supprimer le GDG et ses versions associées à l'aide de la commande SYSIN DELETE(MYDATA.URMI.SAMPLE.GDG) GDG FORCE/PURGE.
FORCEsupprime 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 la base GDG est donc conservée.
PURGE supprime les versions GDG et la base GDG quelle que soit la date d'expiration.
Utilisation de GDG dans un JCL
Dans l'exemple suivant, la dernière version de MYDATA.URMI.SAMPLE.GDG est utilisée comme entrée du programme et une nouvelle version de MYDATA.URMI.SAMPLE.GDG est créée en tant que sortie.
//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=MYCOBB
//IN1 DD DSN=MYDATA.URMI.SAMPLE.GDG(0),DISP=SHR
//OUT1 DD DSN=MYDATA.URMI.SAMPLE.GDG(+1),DISP=(,CALTG,DELETE)
// LRECL=100,RECFM=FBIci, si le GDG avait été référencé par le nom réel tel que MYDATA.URMI.SAMPLE.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.
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 et écrire la sortie reçue d'un JCL. En mode batch, aucune interaction utilisateur n'est requise, mais les périphériques d'entrée et de sortie et l'organisation requise sont définis dans le JCL et soumis.
Entrée de données dans un JCL
Il existe différentes manières de transmettre les données à un programme à l'aide de JCL et ces méthodes ont été expliquées ci-dessous:
DONNÉES INSTREAM
Les données Instream vers un programme peuvent être spécifiées à l'aide d'une instruction SYSIN DD.
//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID
//* Example 1:
//STEP10 EXEC PGM=MYPROG
//IN1 DD DSN=SAMPLE.INPUT1,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FB
//SYSIN DD *
//CUST1 1000
//CUST2 1001
/*
//*
//* Example 2:
//STEP20 EXEC PGM=MYPROG
//OUT1 DD DSN=SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FB
//SYSIN DD DSN=SAMPLE.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 dans le flux.
"CUST1 1000" est enregistrement1 et "CUST2 1001" est enregistrement2. 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ù SAMPLE.SYSIN.DATA est un fichier PS, qui peut contenir un ou plusieurs enregistrements de données.
Entrée de données via des fichiers
Comme mentionné dans la plupart des exemples des chapitres précédents, l'entrée de données dans un programme peut être fournie via des fichiers PS, VSAM ou GDG, avec le nom DSN et les paramètres DISP appropriés ainsi que des instructions DD.
Dans l'exemple 1, SAMPLE.INPUT1 est le fichier d'entrée via lequel les données sont transmises à MYPROG. Il est appelé IN1 dans le programme.
Sortie de données dans un JCL
La sortie d'un JCL peut être cataloguée dans un jeu de données ou transmise au SYSOUT. Comme mentionné dans le chapitre sur les déclarations 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 journaux de travaux
En précisant MSGCLASS=Yenregistre le journal des travaux dans le JMR (Joblog Management and Retrieval). L'ensemble du journal JOB peut être redirigé vers le SPOOL et peut être enregistré dans un ensemble de données en donnant la commande XDC par rapport au nom du travail 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. Le journal des travaux peut ensuite être sauvegardé en donnant la définition PS ou PDS appropriée.
Les journaux de travaux peuvent également être enregistrés dans un ensemble de données en mentionnant un ensemble de données déjà créé pour SYSOUT et SYSPRINT. Mais l'ensemble du journal des travaux ne peut pas être capturé de cette manière (c'est-à-dire que JESMSG ne sera pas catalogué) comme cela est fait dans JMR ou XDC.
//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=MYPROG
//IN1 DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD DSN=MYDATA.URMI.SYSOUT,DISP=SHR
//SYSPRINT DD DSN=MYDATA.URMI.SYSPRINT,DISP=SHR
//SYSIN DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2 EXEC PGM=SORTDans l'exemple ci-dessus, SYSOUT est catalogué dans MYDATA.URMI.SYSOUT et SYSPRINT dans MYDATA.URMI.SYSPRINT.
Compilation de programmes COBOL
Afin d'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 deJCLLIB ou STEPLIB.
Il existe de nombreux utilitaires de compilation mainframe disponibles pour compiler un programme COBOL. Certaines entreprises utilisent des outils de gestion du changement commeEndevor, 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.URMI.SOURCES(MYCOBB),DISP=SHR
//SYSLIB DD DSN=MYDATA.URMI.COPYBOOK(MYCOPY),DISP=SHR
//SYSLMOD DD DSN=MYDATA.URMI.LOAD(MYCOBB),DISP=SHR
//SYSPRINT DD SYSOUT=*
//*IGYCRCTL est un utilitaire de compilation IBM COBOL. Les options du compilateur sont transmises à l'aide du paramètre PARM. Dans l'exemple ci-dessus, RMODE indique au compilateur d'utiliser le mode d'adressage relatif dans le programme. Le programme COBOL est transmis à l'aide du paramètre SYSIN et le cahier est la bibliothèque utilisée par le programme dans SYSLIB.
Ce JCL produit le module de chargement du programme comme sortie qui est utilisé comme entrée du JCL d'exécution.
Exécution de programmes COBOL
Ci-dessous, un exemple JCL où le programme MYPROG est exécuté à l'aide du fichier d'entrée MYDATA.URMI.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.URMI.LOADLIB,DISP=SHR
//INPUT1 DD DSN=MYDATA.URMI.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.URMI.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 de commandes 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.URMI.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:
Lors de la compilation d'un programme COBOL-DB2, un DBRM (Database Request Module) est créé avec le module de chargement. Le DBRM contient les instructions SQL des programmes COBOL dont la syntaxe a été vérifiée.
Le DBRM est lié à la région DB2 (environnement) dans laquelle le COBOL sera exécuté. 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é en utilisant 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.URMI.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(PLANNAME) PARM(parameters to cobol program) -
LIB('MYDATA.URMI.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 de 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 STEPLIB.
Utilitaires IBM Dataset
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 besoins quotidiens, organiser et maintenir les données. Quelques-uns d'entre eux sont répertoriés ci-dessous avec leurs fonctionnalités:
| Nom de l'utilitaire | Fonctionnalité |
|---|---|
| IEHMOVE | Déplace ou copie des ensembles de données séquentiels. |
| IEHPROGM | Supprimer et renommer des ensembles de données; catalogues ou ensembles de données non catalogués autres que VSAM. < |
| IEHCOMPR | Compare les données dans des ensembles de données séquentiels. |
| IEBCOPY | Copiez, fusionnez, compressez, sauvegardez ou restaurez PDS. |
| IEFBR14 | Aucun utilitaire de fonctionnement. Utilisé pour renvoyer le contrôle à l'utilisateur et terminer. Il est généralement utilisé pour créer un ensemble de données vide ou supprimer un ensemble de données existant. Par exemple, si un ensemble de données est passé en entrée à un programme IEFBR14 avec DISP = (OLD, DELETE, DELETE), l'ensemble de données est supprimé à la fin du travail. |
| IEBEDIT | Utilisé pour copier des parties sélectionnées d'un JCL. Par exemple, si un JCL comporte 5 étapes et que nous devons exécuter uniquement les étapes 1 et 3, alors un JCL IEBEDIT peut être codé avec un ensemble de données contenant 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 étapes STEP1 et STEP3 du JCL réel. |
| IDCAMS | Créer, supprimer, renommer, cataloguer, décataloguer des ensembles de données (autres que PDS). Habituellement utilisé pour gérer les ensembles de données VSAM. |
Ces programmes utilitaires doivent être utilisés avec les instructions DD appropriées dans un JCL afin d'obtenir la fonctionnalité spécifiée.
Présentation de DFSORT
DFSORT est un puissant utilitaire IBM utilisé pour copier, trier ou fusionner des ensembles de données. Les instructions SORTIN et SORTINnn DD sont utilisées pour spécifier les ensembles de données d'entrée. Les instructions SORTOUT et OUTFIL sont utilisées pour spécifier les données de sortie.
L'instruction SYSIN DD est utilisée pour spécifier les conditions de tri et de fusion. DFSORT est généralement utilisé pour réaliser les fonctionnalités ci-dessous:
TRIER le (s) fichier (s) d'entrée dans l'ordre de la position des champs spécifiés dans le fichier.
INCLUDE ou OMIT les enregistrements du (des) fichier (s) d'entrée en fonction de la condition spécifiée.
TRIER FUSION le (s) fichier (s) d'entrée dans l'ordre de la position des champs spécifiés dans le fichier.
SORT JOIN deux fichiers d'entrée ou plus en fonction d'une clé de jointure spécifiée (champ (s) dans chaque fichier d'entrée).
Lorsqu'un traitement supplémentaire doit être effectué sur les fichiers d'entrée, un programme USER EXIT peut être appelé à partir du programme SORT. Par exemple, s'il existe un en-tête / une fin à ajouter au fichier de sortie, un programme COBOL écrit par USER peut être appelé à partir du programme SORT pour exécuter cette fonctionnalité. À l'aide d'une carte de contrôle, les données peuvent être transmises au programme COBOL.
À l'inverse, un SORT peut être appelé en interne à partir d'un programme COBOL pour organiser le fichier d'entrée dans un ordre particulier avant d'être traité. En règle générale, cela n'est pas recommandé compte tenu des performances des fichiers volumineux.
Présentation d'ICETOOL
ICETOOL est un utilitaire DFSORT polyvalent utilisé pour effectuer diverses opérations sur des ensembles de données. Les ensembles de données d'entrée et de sortie peuvent être définis à l'aide de noms DD définis par l'utilisateur. Les opérations sur les fichiers sont spécifiées dans l'instruction TOOLIN DD. Des conditions supplémentaires peuvent être spécifiées dans les instructions DD «CTL» définies par l'utilisateur.
Peu des utilitaires d'ICETOOL sont donnés ci-dessous:
ICETOOL peut réaliser toutes les fonctionnalités de DFSORT dans une ou plusieurs conditions.
SPLICE est une opération puissante d'ICETOOL qui est similaire à SORT JOIN, mais avec des fonctionnalités supplémentaires. Il peut comparer deux fichiers ou plus sur des champs spécifiés et créer un ou plusieurs fichiers de sortie comme un fichier avec des enregistrements correspondants, un fichier avec des enregistrements non correspondants, etc.
Les données d'un fichier dans une position particulière peuvent être superposées dans une autre position dans le même fichier ou dans un fichier différent.
Un fichier peut être divisé en n fichiers en fonction d'une condition spécifiée. Par exemple, un fichier contenant les noms des employés peut être divisé en 26 fichiers, chacun contenant les noms commençant par A, B, C et ainsi de suite.
Différentes combinaisons de manipulation de fichiers sont possibles en utilisant ICETOOL avec une petite exploration de l'outil.
Présentation de SYNCSORT
SYNCSORT est utilisé pour copier, fusionner ou trier des ensembles de données avec une haute performance. Il permet une meilleure utilisation des ressources système et un fonctionnement efficace dans les espaces d'adressage 31 bits et 64 bits.
Il peut être utilisé dans les mêmes lignes de DFSORT et peut atteindre les mêmes fonctionnalités. Il peut être appelé par un JCL ou depuis un programme codé en COBOL, PL / 1 ou en langage Assembler. Il prend également en charge les programmes d'exit utilisateur à appeler à partir du programme SYNCSORT.
Les astuces de tri fréquemment utilisées utilisant ces utilitaires sont expliquées dans le chapitre suivant. Des exigences complexes, qui nécessitent une programmation énorme dans COBOL / ASSEMBLER, peuvent être atteintes en utilisant les utilitaires ci-dessus en étapes simples.
Les exigences des applications quotidiennes dans un monde d'entreprise qui peuvent être satisfaites à l'aide de programmes utilitaires sont illustrées ci-dessous:
1. A file has 100 records. The first 10 records need to be written to output file.
//JSTEP020 EXEC PGM=ICETOOL
//TOOLMSG DD SYSOUT=*
//DFSMSG DD SYSOUT=*
//IN1 DD DSN=MYDATA.URMI.STOPAFT,DISP=SHR
//OUT1 DD SYSOUT=*
//TOOLIN DD *
COPY FROM(IN1) TO(OUT1) USING(CTL1)
/*
//CTL1CNTL DD *
OPTION STOPAFT=10
/*L'option STOPAFT arrêtera la lecture du fichier d'entrée après le 10e enregistrement et terminera le programme. Par conséquent, 10 enregistrements sont écrits en sortie.
2. Input file has one or more records for same employee number. Write unique records to output.
//STEP010 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//SORTIN DD DSN=MYDATA.URMI.DUPIN,DISP=SHR
//SORTOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=(1,15,ZD,A)
SUM FIELDS=NONE
/*SUM FIELDS = NONE supprime les doublons sur les champs spécifiés dans SORT FIELDS. Dans l'exemple ci-dessus, le numéro d'employé est dans la position de champ 1,15. Le fichier de sortie contiendra les numéros d'employés uniques triés par ordre croissant.
3. Overwrite input record content.
//JSTEP010 EXEC PGM=SORT
//SORTIN DD DSN= MYDATA.URMI.SAMPLE.MAIN,DISP=SHR
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
OPTION COPY
INREC OVERLAY=(47:1,6)
/*Dans le fichier d'entrée, le contenu en position 1, 6 est écrasé à la position 47, 6 puis copié dans le fichier de sortie. L'opération INREC OVERLAY est utilisée pour réécrire les données dans le fichier d'entrée avant de les copier vers la sortie.
4. Adding a sequence number to the output file.
//JSTEP010 EXEC PGM=SORT
//SORTIN DD *
data1
data2
data3
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
OPTION COPY
BUILD=(1:1,5,10:SEQNUM,4,ZD,START=1000,INCR=2)
/*La sortie sera:
data1 1000
data2 1002
data3 1004Le numéro de séquence à 4 chiffres est ajouté dans la sortie à la position 10, commençant à 1000 et incrémenté de 2 pour chaque enregistrement.
5. Adding Header/Trailer to output file.
//JSTEP010 EXEC PGM=SORT
//SORTIN DD *
data1
data2
data3
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=COPY
OUTFIL REMOVECC,
HEADER1=(1:C'HDR',10:X'020110131C'),
TRAILER1=(1:C'TRL',TOT=(10,9,PD,TO=PD,LENGTH=9))
/*La sortie sera:
HDR 20110131
data1
data2
data3
TRL 000000003TOT calcule le nombre d'enregistrements dans le fichier d'entrée. HDR et TRL sont ajoutés en tant qu'identificateurs à l'en-tête / à la fin, qui est défini par l'utilisateur et peut être personnalisé selon les besoins des utilisateurs.
6. Conditional Processing
//JSTEP010 EXEC PGM=SORT
//SORTIN DD *
data1select
data2
data3select
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
INREC IFTHEN=(WHEN=(6,1,CH,NE,C' '),BUILD=(1:1,15),
IFTHEN=(WHEN=(6,1,CH,EQ,C' '),BUILD=(1:1,5,7:C'EMPTY ')
OPTION COPY
/*La sortie sera:
data1select
data2 EMPTY
data3selectBasé sur la 6ème position du fichier, la BUILD du fichier de sortie varie. Si la 6ème position est ESPACES, alors le texte "VIDE" est ajouté à l'enregistrement d'entrée. Sinon, l'enregistrement d'entrée est écrit dans la sortie, tel quel.
7. Backing up a file
//JSTEP001 EXEC PGM=IEBGENER
//SYSPRINT DD SYSOUT=*
//SYSIN DD *
//SYSOUT DD SYSOUT=*
//SORTOUT DD DUMMY
//SYSUT1 DD DSN=MYDATA.URMI.ORIG,DISP=SHR
//SYSUT2 DD DSN=MYDATA.URMI.BACKUP,DISP=(NEW,CATLG,DELETE),
// DCB=*.SYSUT1,SPACE=(CYL,(50,1),RLSE)IEBGENER copie le fichier dans SYSUT1 dans un fichier dans SYSUT2. Veuillez noter que le fichier dans SYSUT2 prend le même DCB que celui de SYSUT1 dans l'exemple ci-dessus.
8. File Comparison
//STEP010 EXEC PGM=SORT
//MAIN DD *
1000
1001
1003
1005
//LOOKUP DD *
1000
1002
1003
//MATCH DD DSN=MYDATA.URMI.SAMPLE.MATCH,DISP=OLD
//NOMATCH1 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH1,DISP=OLD
//NOMATCH2 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH2,DISP=OLD
//SYSOUT DD SYSOUT=*
//SYSIN DD *
JOINKEYS F1=MAIN,FIELDS=(1,4,A)
JOINKEYS F2=LOOKUP,FIELDS=(1,4,A)
JOIN UNPAIRED,F1,F2
REFORMAT FIELDS=(?,F1:1,4,F2:1,4)
OPTION COPY
OUTFIL FNAMES=MATCH,INCLUDE=(1,1,CH,EQ,C'B'),BUILD=(1:2,4)
OUTFIL FNAMES=NOMATCH1,INCLUDE=(1,1,CH,EQ,C'1'),BUILD=(1:2,4)
OUTFIL FNAMES=NOMATCH2,INCLUDE=(1,1,CH,EQ,C'2'),BUILD=(1:2,4)
/*JOINKEYS spécifie le champ sur lequel les deux fichiers sont comparés.
CHAMPS DE REFORMAT =? place 'B' (enregistrements correspondants), '1' (présent dans fichier1, mais pas dans fichier2) ou '2' (présent dans fichier2 mais pas dans fichier1) à la 1ère position de la sortie BUILD.
JOIN UNPAIRED effectue une jointure externe complète sur les deux fichiers.
La sortie sera:
MATCH File
1000
1003
NOMATCH1 File
1001
1005
NOMATCH2 File
1002La même fonctionnalité peut également être obtenue en utilisant ICETOOL.