JCL - Guida rapida

Quando utilizzare JCL

JCL viene utilizzato in un ambiente mainframe per fungere da comunicazione tra un programma (Esempio: COBOL, Assembler o PL / I) e il sistema operativo. In un ambiente mainframe, i programmi possono essere eseguiti in batch e in modalità online. Un esempio di un sistema batch può essere l'elaborazione delle transazioni bancarie tramite un file VSAM (Virtual Storage Access Method) e l'applicazione ai conti corrispondenti. Un esempio di un sistema online può essere una schermata di back office utilizzata dal personale di una banca per aprire un conto. In modalità batch, i programmi vengono inviati al sistema operativo come lavoro tramite un JCL.

L'elaborazione in batch e in linea differisce nell'aspetto della richiesta di input, output e esecuzione del programma. Nell'elaborazione batch, questi aspetti vengono inseriti in un JCL che viene a sua volta ricevuto dal sistema operativo.

Elaborazione del lavoro

Un lavoro è un'unità di lavoro che può essere composta da molte fasi di lavoro. Ogni fase del lavoro viene specificata in un JCL (Job Control Language) tramite una serie di istruzioni di controllo del lavoro.

Il sistema operativo utilizza Job Entry System (JES) per ricevere i lavori nel sistema operativo, per programmarli per l'elaborazione e per controllare l'output.

L'elaborazione del lavoro passa attraverso una serie di passaggi come indicato di seguito:

  • Job Submission - Invio del JCL a JES.

  • Job Conversion - Il JCL insieme al PROC viene convertito in un testo interpretato per essere compreso da JES e memorizzato in un set di dati, che chiamiamo SPOOL.

  • Job Queuing -JES decide la priorità del lavoro in base ai parametri CLASS e PRTY nell'istruzione JOB (spiegata nel capitolo JCL - Istruzione JOB ). Gli errori JCL vengono controllati e il lavoro viene pianificato nella coda dei lavori se non ci sono errori.

  • Job Execution -Quando il lavoro raggiunge la sua massima priorità, viene avviato per l'esecuzione dalla coda dei lavori. Il JCL viene letto da SPOOL, il programma viene eseguito e l'output viene reindirizzato alla destinazione di output corrispondente come specificato nel JCL.

  • Purging -Quando il lavoro è completo, le risorse allocate e lo spazio JES SPOOL vengono rilasciati. Per memorizzare il registro del lavoro, è necessario copiare il registro del lavoro in un altro set di dati prima che venga rilasciato da SPOOL.

Installazione di JCL su Windows / Linux

Sono disponibili molti emulatori mainframe gratuiti per Windows che possono essere utilizzati per scrivere e apprendere JCL di esempio.

Uno di questi emulatori è Hercules, che può essere facilmente installato in Windows seguendo alcuni semplici passaggi indicati di seguito:

  • Scarica e installa l'emulatore Hercules, disponibile dal sito principale di Hercules -: www.hercules-390.eu

  • Una volta installato il pacchetto sulla macchina Windows, creerà una cartella come C:\Mainframes.

  • Eseguire il prompt dei comandi (CMD) e raggiungere la directory C: \ Mainframes su CMD.

  • La guida completa sui vari comandi per scrivere ed eseguire un JCL può essere trovata su URL www.jaymoseley.com/hercules/installmvs/instmvs2.htm

Hercules è un'implementazione software open source delle architetture mainframe System / 370 ed ESA / 390, oltre alla più recente z / Architecture a 64 bit. Hercules funziona su Linux, Windows, Solaris, FreeBSD e Mac OS X.

Esecuzione di JCL su mainframe

Un utente può connettersi a un server mainframe in diversi modi, ad esempio thin client, terminale fittizio, Virtual Client System (VCS) o Virtual Desktop System (VDS).

A ogni utente valido viene assegnato un ID di accesso per accedere all'interfaccia Z / OS (TSO / E o ISPF). Nell'interfaccia Z / OS, il JCL può essere codificato e memorizzato come membro in un PDS (Partitioned Dataset). Quando il JCL viene inviato, viene eseguito e l'output ricevuto come spiegato nella sezione sull'elaborazione del lavoro del capitolo precedente.

Struttura di un JCL

Di seguito viene fornita la struttura di base di un JCL con le istruzioni comuni:

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

Descrizione del programma

Le istruzioni JCL numerate sono state spiegate di seguito:

(1) JOB statement - Specifica le informazioni richieste per lo SPOOLing del lavoro come ID lavoro, priorità di esecuzione, ID utente da notificare al completamento del lavoro.

(2) //* statement - Questa è una dichiarazione di commento.

(3) EXEC statement- Specifica il PROC / Programma da eseguire. Nell'esempio precedente, viene eseguito un programma SORT (ovvero, l'ordinamento dei dati di input in un ordine particolare)

(4) Input DD statement- Specifica il tipo di input da passare al programma menzionato in (3). Nell'esempio precedente, un file PS (Physical Sequential) viene passato come input in modalità condivisa (DISP = SHR).

(5) Output DD statement- Specifica il tipo di output che deve essere prodotto dal programma durante l'esecuzione. Nell'esempio sopra, viene creato un file PS. Se un'istruzione si estende oltre la 70a posizione in una riga, viene continuata nella riga successiva, che dovrebbe iniziare con "//" seguita da uno o più spazi.

(6)Possono essere presenti altri tipi di istruzioni DD per specificare informazioni aggiuntive al programma (Nell'esempio precedente: la condizione SORT è specificata nell'istruzione SYSIN DD) e per specificare la destinazione per il log di errore / esecuzione (Esempio: SYSUDUMP / SYSPRINT). Le istruzioni DD possono essere contenute in un set di dati (file mainframe) o come nei dati di flusso (informazioni hardcoded all'interno del JCL) come indicato nell'esempio precedente.

(7) /* segna la fine dei dati nel flusso.

Tutte le istruzioni JCL tranne nei dati di flusso iniziano con //. Dovrebbe esserci almeno uno spazio prima e dopo le parole chiave JOB, EXEC e DD e non dovrebbero esserci spazi nel resto dell'istruzione.

Tipi di parametri JOB

Ciascuna delle istruzioni JCL è accompagnata da una serie di parametri per aiutare i sistemi operativi a completare l'esecuzione del programma. I parametri possono essere di due tipi:

Parametri posizionali

  • Appare nella posizione e nell'ordine predefiniti nell'istruzione. Esempio: Informazioni contabili Il parametro può essere visualizzato solo dopo ilJOBparola chiave e prima del parametro del nome del programmatore e dei parametri della parola chiave. Se un parametro posizionale viene omesso, deve essere sostituito con una virgola.

  • I parametri posizionali sono presenti nelle istruzioni JOB ed EXEC. Nell'esempio precedente, PGM è un parametro posizionale codificato dopoEXEC parola chiave.

Parametri delle parole chiave

  • Sono codificati dopo i parametri posizionali, ma possono apparire in qualsiasi ordine. I parametri delle parole chiave possono essere omessi se non richiesti. La sintassi generica è KEYWORD = value . Esempio: MSGCLASS = X, ovvero la registrazione del lavoro viene reindirizzata all'output SPOOL dopo il completamento del lavoro.

  • Nell'esempio precedente, CLASS, MSGCLASS e NOTIFY sono parametri parola chiave dell'istruzione JOB. Possono essere presenti anche parametri di parole chiave nell'istruzione EXEC.

Questi parametri sono stati descritti in dettaglio nei capitoli successivi insieme ad esempi appropriati.

L'istruzione JOB è la prima istruzione di controllo in un JCL. Questo fornisce l'identità del lavoro al sistema operativo (OS), nello spool e nello scheduler. I parametri nell'istruzione JOB aiutano i sistemi operativi ad allocare il giusto scheduler, il tempo di CPU richiesto e l'emissione di notifiche all'utente.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JOB JCL:

//Job-name JOB Positional-param, Keyword-param

Descrizione

Vediamo la descrizione dei termini usati nella sintassi dell'istruzione JOB sopra.

Nome del lavoro

Questo fornisce un ID al lavoro mentre lo invia al sistema operativo. Può essere lungo da 1 a 8 con caratteri alfanumerici e inizia subito dopo //.

LAVORO

Questa è la parola chiave per identificarlo come un'istruzione JOB.

Parametro posizionale

Esistono parametri posizionali, che possono essere di due tipi:

Parametro posizionale Descrizione
Account information Si riferisce alla persona o al gruppo a cui è dovuto il tempo della CPU. È impostato secondo le regole della società proprietaria dei mainframe. Se è specificato come (*), prende l'ID dell'utente, che ha attualmente effettuato l'accesso al Terminale Mainframe.
Programmer name Questo identifica la persona o il gruppo che è responsabile del JCL. Questo non è un parametro obbligatorio e può essere sostituito da una virgola.

Keyword-param

Di seguito sono riportati i vari parametri delle parole chiave, che possono essere utilizzati nell'istruzione JOB. È possibile utilizzare uno o più parametri in base ai requisiti e sono separati da virgola:

Parametro parola chiave Descrizione
CLASS

In base alla durata e al numero di risorse richieste dal lavoro, le aziende assegnano diverse classi di lavoro. Questi possono essere visualizzati come pianificatori individuali utilizzati dal sistema operativo per ricevere i lavori. Posizionare i lavori nello scheduler giusto aiuterà nella facile esecuzione dei lavori. Alcune aziende hanno classi diverse per i lavori in ambiente di test e produzione.

I valori validi per il parametro CLASS sono caratteri da A a Z e da 0 a 9 numerici (di lunghezza 1). La seguente è la sintassi:

CLASS=0 to 9 | A to Z

PRTY

Per specificare la priorità del lavoro all'interno di una classe di lavoro. Se questo parametro non è specificato, il lavoro viene aggiunto alla fine della coda nella CLASS specificata. La seguente è la sintassi:

PRTY=N

Dove N è un numero compreso tra 0 e 15 e maggiore è il numero, maggiore è la priorità.

NOTIFY

Il sistema invia il messaggio di esito positivo o negativo (codice condizione massima) all'utente specificato in questo parametro. La seguente è la sintassi:

NOTIFY="userid | &SYSUID"

Qui il sistema invia il messaggio all'utente "userid" ma se usiamo NOTIFY = & SYSUID, il messaggio viene inviato all'utente che invia il JCL.

MSGCLASS

Per specificare la destinazione di output per il sistema e i messaggi di lavoro al termine del lavoro. La seguente è la sintassi:

MSGCLASS=CLASS

I valori validi di CLASS possono essere da "A" a "Z" e da "0" a "9". MSGCLASS = Y può essere impostato come classe per inviare il log del lavoro a JMR (JOBLOG Management and Retrieval: un repository all'interno di mainframe per memorizzare le statistiche del lavoro).

MSGLEVEL

Specifica il tipo di messaggi da scrivere nella destinazione di output specificata in MSGCLASS. La seguente è la sintassi:

MSGLEVEL=(ST, MSG)

ST = Tipo di istruzioni scritte nel registro di output

  • Quando ST = 0, solo istruzioni Job.

  • Quando ST = 1, JCL insieme ai parametri simbolici espansi.

  • Quando ST = 2, solo ingresso JCL.

MSG = Tipo di messaggi scritti nel registro di output.

  • Quando MSG = 0, i messaggi di allocazione e terminazione scritti al completamento anomalo del lavoro.

  • Quando MSG = 1, i messaggi di allocazione e risoluzione vengono scritti indipendentemente dalla natura del completamento del lavoro.

TYPRUN

Specifica un'elaborazione speciale per il lavoro. La seguente è la sintassi:

TYPRUN = SCAN | HOLD

Dove SCAN e HOLD ha la seguente descrizione

  • TYPRUN = SCAN controlla gli errori di sintassi del JCL senza eseguirlo.

  • TYPRUN = HOLD mette il lavoro in HOLD nella coda dei lavori. Per rilasciare il lavoro, "A" può essere digitato contro il lavoro nello SPOOL, che porterà il lavoro in esecuzione.

TIME

Specifica l'intervallo di tempo che deve essere utilizzato dal processore per eseguire il lavoro. La seguente è la sintassi:

TIME=(mm, ss) or TIME=ss

Dove mm = minuti e ss = secondi

Questo parametro può essere utile durante il test di un programma appena codificato. Per garantire che il programma non venga eseguito a lungo a causa di errori di loop, è possibile codificare un parametro time in modo che il programma si interrompa in modo anomalo quando viene raggiunto il tempo CPU specificato.

REGION

Specifica lo spazio indirizzo richiesto per eseguire una fase di lavoro all'interno del lavoro. La seguente è la sintassi:

REGION=nK | nM

Qui, la regione può essere specificata come nK o nM dove n è un numero, K è kilobyte e M è Megabyte.

Quando REGION = 0K o 0M, viene fornito lo spazio di indirizzi più grande per l'esecuzione. Nelle applicazioni critiche, la codifica di 0K o 0M è vietata per evitare di sprecare lo spazio di indirizzi.

Esempio

//URMISAMP JOB (*),"tutpoint",CLASS=6,PRTY=10,NOTIFY=&SYSUID, 
//   MSGCLASS=X,MSGLEVEL=(1,1),TYPRUN=SCAN, 
//   TIME=(3,0),REGION=10K

Qui, l'istruzione JOB viene estesa oltre la 70a posizione in una riga, quindi continuiamo nella riga successiva che dovrebbe iniziare con "//" seguita da uno o più spazi.

Parametri vari

Ci sono pochi altri parametri che possono essere usati con l'istruzione JOB ma non sono usati frequentemente:

ADDRSPC Tipo di archiviazione utilizzato: virtuale o reale
BYTES Dimensione dei dati da scrivere nel registro di output e azione da intraprendere quando la dimensione viene superata.
LINES Numero massimo di righe da stampare nel registro di output.
PAGES Numero massimo di pagine da stampare sul registro di output.
USER ID utente utilizzato per inviare il lavoro
PASSWORD Password dell'id utente specificato nel parametro USER.
COND and RESTART Questi vengono utilizzati nell'elaborazione della fase di lavoro condizionale e vengono spiegati in dettaglio durante la discussione dell'elaborazione condizionale.

Ogni JCL può essere composto da molte fasi di lavoro. Ogni fase di lavoro può eseguire direttamente un programma o può chiamare una procedura, che a sua volta esegue uno o più programmi (fasi di lavoro). L'istruzione, che contiene le informazioni sul programma / procedura della fase di lavoro, èEXEC statement.

Lo scopo dell'istruzione EXEC è fornire le informazioni richieste per il programma / procedura eseguita nella fase del lavoro. I parametri codificati in questa istruzione possono passare dati al programma in esecuzione, possono sovrascrivere alcuni parametri dell'istruzione JOB e possono passare parametri alla procedura se l'istruzione EXEC chiama una procedura invece di eseguire direttamente un programma.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JCL EXEC:

//Step-name EXEC Positional-param, Keyword-param

Descrizione

Vediamo la descrizione dei termini usati nella sintassi dell'istruzione EXEC sopra.

STEP-NAME

Ciò identifica la fase di lavoro all'interno del JCL. Può avere una lunghezza compresa tra 1 e 8 con caratteri alfanumerici.

EXEC

Questa è la parola chiave per identificarlo come un'istruzione EXEC.

PARAMETRI POSIZIONALI

Questi sono parametri posizionali, che possono essere di due tipi:

Parametro posizionale Descrizione
PGM Si riferisce al nome del programma da eseguire nella fase del lavoro.
PROC Si riferisce al nome della procedura da eseguire nella fase del lavoro. Ne discuteremo in un capitolo a parte.

PAROLA CHIAVE

Di seguito sono riportati i vari parametri delle parole chiave per l'istruzione EXEC. È possibile utilizzare uno o più parametri in base ai requisiti e sono separati da virgola:

Parametro parola chiave Descrizione
PARM

Utilizzato per fornire dati parametrizzati al programma che viene eseguito nella fase di lavoro. Questo è un campo dipendente dal programma e non ha regole definite, tranne per il fatto che il valore PARM deve essere incluso nella citazione in caso di caratteri speciali.

Ad esempio riportato di seguito, il valore "CUST1000" viene passato al programma come valore alfanumerico. Se il programma è in COBOL, il valore passato attraverso un parametro PARM in un JCL viene ricevuto nella SEZIONE COLLEGAMENTO del programma.

ADDRSPC

Viene utilizzato per specificare se la fase di lavoro richiede una memoria virtuale o reale per l'esecuzione. La memoria virtuale è paginabile mentre quella reale non lo è e viene collocata nella memoria principale per l'esecuzione. Le fasi del lavoro, che richiedono un'esecuzione più rapida, possono essere collocate nella memoria reale. La seguente è la sintassi:

ADDRSPC=VIRT | REAL

Quando un ADDRSPC non è codificato, VIRT è quello predefinito.

ACCT

Specifica le informazioni contabili della fase di lavoro. La seguente è la sintassi:

ACCT=(userid)

Questo è simile al parametro posizionale accounting informationnell'istruzione JOB. Se è codificato sia nell'istruzione JOB che nell'istruzione EXEC, le informazioni contabili nell'istruzione JOB si applicano a tutte le fasi del lavoro in cui un parametro ACCT non è codificato. Il parametro ACCT in un'istruzione EXEC sovrascriverà quello presente nell'istruzione JOB solo per quella fase di lavoro.

Parametri delle parole chiave comuni dell'istruzione EXEC e JOB

Parametro parola chiave Descrizione
ADDRSPC ADDRSPC codificato nell'istruzione JOB sovrascrive l'ADDRSPC codificato nell'istruzione EXEC di qualsiasi fase del lavoro.
TIME Se TIME è codificato in un'istruzione EXEC, si applica solo a quella fase di lavoro. Se è specificato sia nell'istruzione JOB che nell'istruzione EXEC, entrambe saranno attive e possono causare un errore di timeout a causa di una delle due. Non è consigliabile utilizzare il parametro TIME sia nell'istruzione JOB che in quella EXEC insieme.
REGION

Se REGION è codificato in un'istruzione EXEC, si applica solo a quella fase di lavoro.

REGION codificato nell'istruzione JOB sovrascrive la REGION codificato nell'istruzione EXEC di qualsiasi fase del lavoro.

COND

Utilizzato per controllare l'esecuzione della fase di lavoro in base al codice di ritorno della fase precedente.

Se un parametro COND è codificato in un'istruzione EXEC di una fase di lavoro, il parametro COND dell'istruzione JOB (se presente) viene ignorato. I vari test che possono essere eseguiti utilizzando un parametro COND sono spiegati in Elaborazione condizionale.

Esempio

Di seguito è riportato un semplice esempio di script JCL insieme alle istruzioni JOB ed 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=1440

I set di dati sono file mainframe con record organizzati in un formato specifico. I set di dati sono archiviati sul DASD (Direct Access Storage Device) o sui nastri del mainframe e sono aree di archiviazione dati di base. Se è necessario utilizzare / creare questi dati in un programma batch, il nome fisico del file (ovvero, il set di dati) insieme al formato e all'organizzazione del file vengono codificati in un JCL.

La definizione di ogni set di dati utilizzato nel JCL viene fornita utilizzando il DD statement. Le risorse di input e output richieste da una fase di lavoro devono essere descritte all'interno di un'istruzione DD con informazioni quali l'organizzazione del set di dati, i requisiti di archiviazione e la lunghezza del record.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione DD JCL:

//DD-name DD Parameters

Descrizione

Vediamo la descrizione dei termini utilizzati nella sintassi dell'istruzione DD sopra.

DD-NAME

Un DD-NAME identifica il set di dati o la risorsa di input / output. Se si tratta di un file di input / output utilizzato da un programma COBOL / Assembler, al file viene fatto riferimento con questo nome all'interno del programma.

DD

Questa è la parola chiave per identificarlo come un'istruzione DD.

PARAMETRI

Di seguito sono riportati i vari parametri per l'istruzione DD. È possibile utilizzare uno o più parametri in base ai requisiti e sono separati da virgola:

Parametro Descrizione
DSN

Il parametro DSN fa riferimento al nome del set di dati fisico di un set di dati appena creato o esistente. Il valore DSN può essere composto da sotto-nomi di lunghezza da 1 a 8 caratteri ciascuno, separati da punti e di lunghezza totale di 44 caratteri (alfanumerici). La seguente è la sintassi:

DSN=Physical Dataset Name

Temporary datasetsnecessitano di archiviazione solo per la durata del lavoro e vengono eliminati al completamento del lavoro. Tali set di dati sono rappresentati comeDSN=&name o semplicemente senza un DSN specificato.

Se un set di dati temporaneo creato da una fase di lavoro deve essere utilizzato nella fase di lavoro successiva, viene indicato come DSN=*.stepname.ddname. Questo è chiamato Backward Referencing.

DISP

Il parametro DISP viene utilizzato per descrivere lo stato del set di dati, la disposizione alla fine della fase di lavoro al completamento normale e anormale. DISP non è richiesto in un'istruzione DD solo quando il set di dati viene creato ed eliminato nella stessa fase del lavoro (come i set di dati temporanei). La seguente è la sintassi:

DISP=(status, normal-disposition, abnormal-disposition)

Di seguito sono riportati i valori validi per status:

  • NEW: Il set di dati viene appena creato dalla fase di lavoro. OUTPUT1 nell'esempio sopra.

  • OLD: Il set di dati è già stato creato e verrà sovrascritto nella fase di lavoro. La fase di lavoro ottiene l'accesso esclusivo al set di dati e nessun altro lavoro può accedere a questo set di dati fino al completamento della fase di lavoro.

  • SHR: Il set di dati è già stato creato e verrà letto nella fase di lavoro. Il set di dati può essere letto da più lavori contemporaneamente. Esempio: INPUT1 e INPUT2.

  • MOD: Il set di dati è già stato creato. Questa disposizione verrà utilizzata quando è necessario aggiungere nuovi record al set di dati esistente (i record esistenti non verranno sovrascritti).

UN normal-disposition parametro può assumere uno dei seguenti valori

  • CATLG, UNCATLG, DELETE, PASS e KEEP

UN abnormal-disposition parametro può assumere uno dei seguenti valori

  • CATLG, UNCATLG, DELETE e KEEP

Ecco la descrizione dei parametri CATLG, UNCATLG, DELETE, PASS e KEEP:

  • CATLG : Il set di dati viene conservato con una voce nel catalogo di sistema.

  • UNCATLG : Il set di dati viene conservato ma la voce del catalogo di sistema viene rimossa.

  • KEEP: Il set di dati viene conservato senza modificare le voci di catalogo. KEEP è l'unica disposizione valida per i file VSAM. Deve essere utilizzato solo per set di dati permanenti.

  • DELETE : Il set di dati viene eliminato dal catalogo utente e di sistema.

  • PASS: Questo è valido solo per la disposizione normale. Viene utilizzato quando il set di dati deve essere passato ed elaborato dalla fase di lavoro successiva in un JCL

Quando uno qualsiasi dei sottoparametri di DISP non è specificato, i valori predefiniti sono i seguenti:

  • status : NUOVO è il valore predefinito.

  • normal-disposition : Se lo stato è NUOVO, la disposizione normale predefinita è DELETE, altrimenti è KEEP.

  • abnormal-disposition : Uguale alla disposizione normale.

DCB

Il parametro Data Control Block (DCB) descrive in dettaglio le caratteristiche fisiche di un set di dati. Questo parametro è richiesto per i set di dati appena creati nella fase di lavoro.

LRECL è la lunghezza di ogni record contenuto nel set di dati.

RECFM è il formato di registrazione del set di dati. RECFM può contenere valori FB, V o VB. FB è un'organizzazione a blocchi fissi in cui uno o più record logici sono raggruppati in un unico blocco. V è un'organizzazione variabile in cui un record logico di lunghezza variabile è posizionato all'interno di un blocco fisico. VB è un'organizzazione a blocchi variabili in cui uno o più record logici di lunghezza variabile sono inseriti in un blocco fisico.

BLKSIZE è la dimensione del blocco fisico. Più grande è il blocco, maggiore è il numero di record per un file FB o VB.

DSORG è il tipo di organizzazione del set di dati. DSORG può contenere valori PS (Physical Sequential), PO (Partitioned Organization) e DA (Direct Organization).

Quando è necessario replicare i valori DCB di un dataset su un altro all'interno dello stesso jobtep o JCL, viene specificato come DCB = *. Stepname.ddname dove stepname è il nome della fase di lavoro e ddname è il dataset da cui il DCB viene copiato.

Controlla l'esempio sotto dove RECFM = FB, LRECL = 80 forma il DCB del dataset OUTPUT1.

SPACE

Il parametro SPACE specifica lo spazio richiesto per il set di dati nel DASD (Direct Access Storage Disk). La seguente è la sintassi:

SPACE=(spcunits, (pri, sec, dir), RLSE)

Di seguito la descrizione di tutti i parametri utilizzati:

  • spcunits : Può essere uno dei CYL (cilindro), TRK (tracce) o BLKSIZE (dimensione blocco).

  • pri : Questo è lo spazio principale richiesto per il set di dati.

  • sec : Questo è lo spazio aggiuntivo richiesto, quando lo spazio principale non è sufficiente.

  • ir : Si tratta dei blocchi di directory richiesti, se il dataset è un PDS (Partitioned Dataset) con membri al suo interno.

  • RLSE : Viene utilizzato per liberare lo spazio inutilizzato al completamento del lavoro.

UNIT

I parametri UNIT e VOL sono elencati nel catalogo di sistema per i dataset catalogati e quindi è possibile accedervi solo con il nome DSN fisico. Ma per i set di dati non catalogati, l'istruzione DD dovrebbe includere questi parametri. Per creare nuovi set di dati, è possibile specificare i parametri UNIT / VOL o Z / OS alloca il dispositivo e il volume adatti.

Il parametro UNIT specifica il tipo di dispositivo su cui è archiviato il set di dati. Il tipo di dispositivo può essere identificato utilizzando l'indirizzo hardware o il gruppo di tipi di dispositivo. La seguente è la sintassi:

UNIT=DASD | SYSDA

Dove DASD sta per Direct Access Storage Device e SYSDA sta per System Direct Access e si riferisce al successivo dispositivo di archiviazione su disco disponibile.

VOL

Il parametro VOL specifica il numero di volume sul dispositivo identificato dal parametro UNIT. La seguente è la sintassi:

VOL=SER=(v1,v2)

Dove v1, v2 sono i numeri di serie del volume. Puoi anche usare la seguente sintassi:

VOL=REF=*.DDNAME

Dove REF è il riferimento a ritroso al numero di serie del volume di un set di dati in uno dei passaggi di lavoro precedenti nel JCL.

SYSOUT

I parametri dell'istruzione DD discussi finora corrispondono ai dati archiviati in un set di dati. Il parametro SYSOUT indirizza i dati al dispositivo di output in base alla classe specificata. Di seguito è riportata la sintassi

SYSOUT=class

Dove se la classe è A, indirizza l'output alla stampante e se la classe è * quindi indirizza l'output alla stessa destinazione di quella del parametro MSGCLASS nell'istruzione JOB.

Esempio

Di seguito è riportato un esempio, che utilizza le istruzioni DD insieme a vari parametri spiegati sopra:

//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 Libraryè il Partitioned Dataset (PDS), che contiene i moduli di caricamento del programma da eseguire nel JCL o la procedura catalogata, che viene richiamata nel programma. Le librerie di base possono essere specificate per l'intero JCL in un fileJOBLIB libreria o per una particolare fase di lavoro in un file STEPLIB dichiarazione.

Dichiarazione JOBLIB

UN JOBLIBviene utilizzata per identificare la posizione del programma da eseguire in un JCL. L'istruzione JOBLIB viene specificata dopo l'istruzione JOB e prima dell'istruzione EXEC. Può essere utilizzato solo per le procedure e i programmi in-stream.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JOBLIB JCL:

//JOBLIB DD DSN=dsnname,DISP=SHR

L'istruzione JOBLIB è applicabile a tutte le istruzioni EXEC all'interno del JCL. Il programma specificato nell'istruzione EXEC verrà cercato nella libreria JOBLIB seguita dalla libreria di sistema.

Ad esempio, se l'istruzione EXEC sta eseguendo un programma COBOL, il modulo di caricamento del programma COBOL dovrebbe essere inserito nella libreria JOBLIB.

Dichiarazione STEPLIB

UN STEPLIBviene utilizzata per identificare la posizione del programma da eseguire all'interno di una fase di lavoro. L'istruzione STEPLIB viene specificata dopo l'istruzione EXEC e prima dell'istruzione DD della fase di lavoro.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JCL STEPLIB:

//STEPLIB DD DSN=dsnname,DISP=SHR

Il programma specificato nell'istruzione EXEC verrà cercato nella libreria STEPLIB seguita dalla libreria di sistema. STEPLIB codificato in una fase di lavoro sovrascrive l'istruzione JOBLIB.

Esempio

L'esempio seguente mostra l'utilizzo delle istruzioni JOBLIB e 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=80

Qui, il modulo di caricamento del programma MYPROG1 (in STEP1) viene cercato nel MYPROC.SAMPLE.LIB1. Se non viene trovato, viene cercato nella libreria di sistema. In STEP2, STEPLIB sovrascrive JOBLIB e il modulo di caricamento del programma MYPROG2 viene cercato in MYPROC.SAMPLE.LIB2 e quindi nella libreria di sistema.

Dichiarazione INCLUDE

Un insieme di istruzioni JCL codificate all'interno di un membro di un PDS può essere incluso in un JCL utilizzando un file INCLUDEdichiarazione. Quando JES interpreta il JCL, l'insieme di istruzioni JCL all'interno del membro INCLUDE sostituisce l'istruzione INCLUDE.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JCL INCLUDE:

//name INCLUDE MEMBER=member-name

Lo scopo principale dell'istruzione INCLUDE è la riusabilità. Ad esempio, i file comuni da utilizzare in molti JCL possono essere codificati come istruzioni DD all'interno del membro INCLUDE e utilizzati in un JCL.

Le istruzioni DD fittizie, le specifiche della scheda dati, le istruzioni PROC, JOB, PROC non possono essere codificate all'interno di un membro INCLUDE. Un'istruzione INLCUDE può essere codificata all'interno di un membro INCLUDE e l'ulteriore nidificazione può essere eseguita fino a 15 livelli.

Dichiarazione JCLLIB

UN JCLLIBviene utilizzata per identificare le librerie private utilizzate nel lavoro. Può essere utilizzato sia con procedure in-stream che catalogate.

Sintassi

Di seguito è riportata la sintassi di base di un'istruzione JCL JCLLIB:

//name JCLLIB ORDER=(library1, library2....)

Le librerie specificate nell'istruzione JCLLIB verranno ricercate nell'ordine indicato per individuare i programmi, le procedure e il membro INCLUDE utilizzati nel lavoro. Può esserci una sola istruzione JCLLIB in una JCL; specificato dopo un'istruzione JOB e prima dell'istruzione EXEC e INCLUDE ma non può essere codificato all'interno di un membro INCLUDE.

Esempio

Nell'esempio seguente, la ricerca del programma MYPROG3 e del membro INCLUDE MYINCL viene eseguita nell'ordine MYPROC.BASE.LIB1, MYPROC.BASE.LIB2, libreria di sistema.

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

Il JCL Proceduressono un insieme di istruzioni all'interno di un JCL raggruppate insieme per eseguire una particolare funzione. Di solito, la parte fissa del JCL è codificata in una procedura. La parte variabile del lavoro è codificata all'interno del JCL.

È possibile utilizzare una procedura per ottenere l'esecuzione parallela di un programma utilizzando più file di input. È possibile creare un JCL per ogni file di input e una singola procedura può essere chiamata simultaneamente passando il nome del file di input come parametro simbolico.

Sintassi

Di seguito è riportata la sintassi di base della definizione di una procedura JCL:

//*
//Step-name EXEC procedure name

I contenuti della procedura vengono conservati all'interno del JCL per una procedura in-stream. I contenuti sono conservati all'interno di un diverso membro della libreria di base per una procedura catalogata. Questo capitolo spiegherà due tipi di procedure disponibili in JCL e poi finalmente vedremo come possiamo annidare varie procedure.

Procedura in-stream

Quando la procedura è codificata all'interno dello stesso membro JCL, viene chiamata procedura Instream. Dovrebbe iniziare con un'istruzione PROC e terminare con un'istruzione 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)
//*

Nell'esempio precedente, la procedura INSTPROC viene chiamata in STEP1 e STEP2 utilizzando file di input diversi. I parametri DSNAME e DATAC possono essere codificati con valori diversi durante la chiamata della procedura e questi sono chiamati comesymbolic parameters. L'input variabile al JCL come nomi di file, schede dati, valori PARM, ecc., Vengono passati come parametri simbolici alle procedure.

Durante la codifica dei parametri simbolici, non utilizzare KEYWORDS, PARAMETERS o SUB-PARAMETERS come nomi simbolici. Esempio: non usare TIME = & TIME ma sì puoi usare TIME = & TM e si presume che sia un modo corretto di codificare i simboli.

Vengono chiamati i parametri simbolici definiti dall'utente JCL Symbols. Ci sono alcuni simboli chiamatisystem symbols, che vengono utilizzati per le esecuzioni dei lavori di accesso. L'unico simbolo di sistema utilizzato nei lavori batch da utenti normali è&SYSUID e questo viene utilizzato nel parametro NOTIFY nell'istruzione JOB.

Procedura catalogata

Quando la procedura viene separata dal JCL e codificata in un archivio dati diverso, viene chiamata a Cataloged Procedure. Un'istruzione PROC non è obbligatoria per essere codificata in una procedura catalogata. Di seguito è riportato un esempio di JCL in cui sta chiamando la procedura CATLPROC:

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

Qui, la procedura CATLPROC è catalogata in MYCOBOL.BASE.LIB1. PROG, DATAC e DSNAME vengono passati come parametri simbolici alla procedura 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
//*

All'interno della procedura vengono codificati i parametri simbolici PROG e BASELB. Si noti che il parametro PROG all'interno della procedura viene sovrascritto dal valore nel JCL e quindi PGM assume il valore CATPRC1 durante l'esecuzione.

Procedure annidate

La chiamata di una procedura dall'interno di una procedura è chiamata a nested procedure. Le procedure possono essere annidate fino a 15 livelli. L'annidamento può essere completamente in-stream o catalogato. Non possiamo codificare una procedura in-stream all'interno di una procedura catalogata.

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

Nell'esempio precedente, JCL chiama la procedura INSTPRC1 in JSTEP1 e la procedura INSTPRC2 viene chiamata all'interno della procedura INSTPRC1. Qui, l'output di INSTPRC1 (SORTOUT) viene passato come input (SORTIN) a INSTPRC2.

UN SET statementviene utilizzato per definire i simboli comunemente usati nelle fasi o procedure del lavoro. Inizializza i valori precedenti nei nomi simbolici. Deve essere definito prima del primo utilizzo dei nomi simbolici nel JCL.

Diamo un'occhiata alla descrizione seguente per capire un po 'di più sul programma sopra:

  • Il parametro SET inizializza DSNM1 = INPUT1 e DSNM2 = OUTPUT1.

  • Quando INSTPRC1 viene richiamato in JSTEP1 di JCL, DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = OUTPUT1., Ovvero il valore inizializzato nell'istruzione SET viene reimpostato con il valore impostato in una qualsiasi delle fasi / procedure del lavoro.

  • Quando INSTPRC2 viene chiamato in STEP2 di INSTPRC1, DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = MYDATA.URMI.OUTPUT2.

Il Job Entry System utilizza due approcci per eseguire l'elaborazione condizionale in un JCL. Quando un lavoro viene completato, viene impostato un codice di ritorno in base allo stato di esecuzione. Il codice di ritorno può essere un numero compreso tra 0 (esecuzione riuscita) e 4095 (diverso da zero mostra la condizione di errore). I valori convenzionali più comuni sono:

  • 0 = Normale - tutto OK

  • 4 = Avviso - errori o problemi minori.

  • 8 = Errore - errori o problemi significativi.

  • 12 = Errore grave: errori o problemi gravi, i risultati non dovrebbero essere considerati attendibili.

  • 16 = Errore del terminale - problemi molto gravi, non utilizzare i risultati.

È possibile controllare l'esecuzione di una fase di lavoro in base al codice di ritorno delle fasi precedenti utilizzando l'estensione COND parametro e IF-THEN-ELSE costrutto, che è stato spiegato in questo tutorial.

Parametro COND

UN CONDparametro può essere codificato nell'istruzione JOB o EXEC di JCL. È un test sul codice di ritorno dei passaggi di lavoro precedenti. Se il test viene valutato come vero, l'esecuzione della fase di lavoro corrente viene ignorata. Il bypass è solo un'omissione della fase di lavoro e non una conclusione anomala. Possono esserci al massimo otto condizioni combinate in un unico test.

Sintassi

Di seguito è riportata la sintassi di base di un parametro COND JCL:

COND=(rc,logical-operator)
or
COND=(rc,logical-operator,stepname)
or
COND=EVEN
or 
COND=ONLY

Ecco la descrizione dei parametri utilizzati:

  • rc : Questo è il codice di ritorno

  • logical-operator : Può essere GT (maggiore di), GE (maggiore o uguale a), EQ (uguale a), LT (minore di), LE (minore o uguale a) o NE (diverso da).

  • stepname : Questa è la fase del lavoro il cui codice di ritorno viene utilizzato nel test.

Le ultime due condizioni (a) COND = EVEN e (b) COND = ONLY, sono state spiegate di seguito in questo tutorial.

Il COND può essere codificato all'interno dell'istruzione JOB o dell'istruzione EXEC e in entrambi i casi si comporta in modo diverso come spiegato di seguito:

COND all'interno dell'istruzione JOB

Quando COND è codificato nell'istruzione JOB, la condizione viene verificata per ogni fase del lavoro. Quando la condizione è vera in una particolare fase del lavoro, viene ignorata insieme alle fasi del lavoro che la seguono. Di seguito è riportato un esempio:

//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 all'interno dell'istruzione EXEC

Quando COND è codificato nell'istruzione EXEC di una fase di lavoro e risulta essere vera, solo quella fase di lavoro viene ignorata e l'esecuzione prosegue dalla fase di lavoro successiva.

//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 = EVEN

Quando COND = EVEN è codificato, il passo del lavoro corrente viene eseguito, anche se uno qualsiasi dei passi precedenti termina in modo anomalo. Se qualsiasi altra condizione RC è codificata insieme a COND = EVEN, la fase di lavoro viene eseguita se nessuna delle condizioni RC è vera.

//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 = SOLO

Quando COND = ONLY è codificato, il passo del lavoro corrente viene eseguito, solo quando uno qualsiasi dei passi precedenti termina in modo anomalo. Se qualsiasi altra condizione RC è codificata insieme a COND = ONLY, la fase di lavoro viene eseguita se nessuna delle condizioni RC è vera e una qualsiasi delle fasi di lavoro precedenti ha esito negativo in modo anomalo.

//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.

SE-ALLORA-ALTRO Costruisci

Un altro approccio per controllare l'elaborazione del lavoro consiste nell'utilizzare i costrutti IF-THEN-ELSE. Ciò offre maggiore flessibilità e modalità di elaborazione condizionale intuitiva.

Sintassi

La seguente è la sintassi di base di un costrutto 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 ENDIF

Di seguito è riportata la descrizione dei termini utilizzati nel costrutto IF-THEN-ELSE sopra:

  • name : Questo è facoltativo e un nome può contenere da 1 a 8 caratteri alfanumerici che iniziano con alfabeto, #, $ o @.

  • Condition : Una condizione avrà un formato: KEYWORD OPERATOR VALUE, dove KEYWORDSpuò essere RC (codice di ritorno), ABENDCC (codice di completamento del sistema o dell'utente), ABEND, RUN (esecuzione avviata del passaggio). UnOPERATOR può essere operatore logico (AND (&), OR (|)) o operatore relazionale (<, <=,>,> =, <>).

Esempio

Di seguito è riportato un semplice esempio che mostra l'utilizzo di 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
//       ENDIF

Proviamo a esaminare il programma sopra per capirlo in modo un po 'più dettagliato:

  • Il codice di ritorno di STP01 viene testato in IF1. Se è 0, viene eseguito STP02. Altrimenti, l'elaborazione passa alla successiva istruzione IF (IF2).

  • In IF2, se STP01 ha avviato l'esecuzione, vengono eseguiti STP03a e STP03b.

  • In IF3, se STP03b non si ABEND, viene eseguito STP04. In ELSE, non ci sono dichiarazioni. Si chiama istruzione NULL ELSE.

  • In IF4, se STP01.RC = 0 e STP02.RC <= 4 sono TRUE, viene eseguito STP05.

  • In IF5, se il passo di elaborazione PST1 in PROC PRC1 nel passo di lavoro STP05 ABEND, viene eseguito STP06. Altrimenti viene eseguito STP07.

  • Se IF4 restituisce false, STP05 non viene eseguito. In tal caso, IF5 non viene testato e le fasi STP06, STP07 non vengono eseguite.

IF-THEN-ELSE non verrà eseguito in caso di interruzione anomala del lavoro, ad esempio l'annullamento del lavoro da parte dell'utente, la scadenza del tempo di lavoro o un set di dati viene rinviato a un passaggio che viene ignorato.

Impostazione dei punti di controllo

È possibile impostare il set di dati del punto di controllo all'interno del programma JCL utilizzando SYSCKEOV, che è un'istruzione DD.

UN CHKPTè il parametro codificato per i set di dati QSAM a più volumi in un'istruzione DD. Quando un CHKPT è codificato come CHKPT = EOV, un checkpoint viene scritto nel dataset specificato nell'istruzione SYSCKEOV alla fine di ogni volume del dataset multi-volume di input / output.

//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=FB

Nell'esempio precedente, un checkpoint è scritto nel set di dati SAMPLE.CHK alla fine di ogni volume del set di dati di output SAMPLE.OUT.

Riavvia l'elaborazione

È possibile riavviare l'elaborazione ether utilizzando il modo automatizzato utilizzando il RD parameter o manuale utilizzando il RESTART parameter.

RD parameter è codificato nell'istruzione JOB o EXEC e aiuta nel riavvio automatico di JOB / STEP e può contenere uno dei quattro valori: R, RNC, NR o NC.

  • RD=R consente i riavvii automatici e considera il checkpoint codificato nel parametro CHKPT dell'istruzione DD.

  • RD=RNC consente i riavvii automatici, ma sovrascrive (ignora) il parametro CHKPT.

  • RD=NRspecifica che il lavoro / passaggio non può essere riavviato automaticamente. Ma quando viene riavviato manualmente utilizzando il parametro RESTART, verrà considerato il parametro CHKPT (se presente).

  • RD=NC non consente il riavvio automatico e l'elaborazione del checkpoint.

Se è necessario eseguire il riavvio automatico solo per codici di fine anomala specifici, è possibile specificarlo nel file SCHEDxx membro della libreria parmlib di sistema IBM.

RESTART parameterè codificato nell'istruzione JOB o EXEC e aiuta nel riavvio manuale del JOB / STEP dopo il fallimento del lavoro. RESTART può essere accompagnato da un checkid, che è il checkpoint scritto nel dataset codificato nell'istruzione SYSCKEOV DD. Quando un checkid è codificato, l'istruzione SYSCHK DD dovrebbe essere codificata per fare riferimento al dataset del checkpoint dopo l'istruzione JOBLIB (se presente), altrimenti dopo l'istruzione 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=FB

Nell'esempio precedente, chk5 è il checkid, ovvero STP01 viene riavviato al checkpoint5. Si noti che viene aggiunta un'istruzione SYSCHK e l'istruzione SYSCKEOV è commentata nel programma precedente spiegato nella sezione Impostazione del punto di controllo.

Un nome del set di dati specifica il nome di un file ed è indicato da DSN in JCL. Il parametro DSN fa riferimento al nome del set di dati fisico di un set di dati appena creato o esistente. Il valore DSN può essere composto da sotto-nomi di lunghezza da 1 a 8 caratteri ciascuno, separati da punti e di lunghezza totale di 44 caratteri (alfanumerici). La seguente è la sintassi:

DSN=&name | *.stepname.ddname

Temporary datasetsnecessitano di archiviazione solo per la durata del lavoro e vengono eliminati al completamento del lavoro. Tali set di dati sono rappresentati comeDSN=&name o semplicemente senza un DSN specificato.

Se un set di dati temporaneo creato da una fase di lavoro deve essere utilizzato nella fase di lavoro successiva, viene indicato come DSN=*.stepname.ddname. Questo è chiamatoBackward Referencing.

Set di dati concatenati

Se è presente più di un set di dati dello stesso formato, è possibile concatenarli e passare come input al programma in un unico nome 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=FB

Nell'esempio precedente, tre set di dati vengono concatenati e passati come input al programma SORT nel nome DD SORTIN. I file vengono uniti, ordinati nei campi chiave specificati e quindi scritti in un unico file di output SAMPLE.OUTPUT nel nome DD SORTOUT.

Sostituzione dei set di dati

In un JCL standardizzato, il programma da eseguire e i relativi set di dati vengono inseriti in una procedura catalogata, che viene richiamata nel JCL. Di solito, a scopo di test o per risolvere un incidente, potrebbe essere necessario utilizzare set di dati diversi da quelli specificati nella procedura catalogata. In tal caso, il set di dati nella procedura può essere sovrascritto nel 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=SORT

Nell'esempio precedente, il set di dati IN1 utilizza il file MYDATA.URMI.INPUT in PROC, che viene sovrascritto in JCL. Quindi, il file di input utilizzato in esecuzione è MYDATA.OVER.INPUT. Si noti che il set di dati è denominato STEP1.IN1. Se è presente un solo passaggio in JCL / PROC, è possibile fare riferimento al set di dati solo con il nome DD. Allo stesso modo, se sono presenti più passaggi nel JCL, il set di dati deve essere sovrascritto come 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
//*

Nell'esempio precedente, dei tre set di dati concatenati in IN1, il primo viene sovrascritto in JCL e il resto viene mantenuto come quello presente in PROC.

Definizione di GDG in un JCL

I gruppi di dati di generazione (GDG) sono gruppi di set di dati correlati tra loro da un nome comune. Il nome comune è indicato come base GDG e ogni set di dati associato alla base è chiamato versione GDG.

Ad esempio, MYDATA.URMI.SAMPLE.GDG è il nome di base GDG. I set di dati sono denominati MYDATA.URMI.SAMPLE.GDG.G0001V00, MYDATA.URMI.SAMPLE.GDG.G0002V00 e così via. L'ultima versione del GDG è denominata MYDATA.URMI.SAMPLE.GDG (0), le versioni precedenti sono indicate come (-1), (-2) e così via. La prossima versione da creare in un programma è denominata MYDATA.URMI.SAMPLE.GDG (+1) nella JCL.

Crea / modifica GDG in un JCL

Le versioni GDG possono avere parametri DCB uguali o diversi. Un modello DCB iniziale può essere definito per essere utilizzato da tutte le versioni, ma può essere sovrascritto durante la creazione di nuove versioni.

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

Nell'esempio precedente, l'utilità IDCAMS definisce la base GDG in GDGSTEP1 con i seguenti parametri passati nell'istruzione SYSIN DD:

  • NAME specifica il nome del dataset fisico della base GDG.

  • LIMIT specifica il numero massimo di versioni che la base GDG può contenere.

  • EMPTY disincatalizza tutte le generazioni quando viene raggiunto il LIMITE.

  • NOEMPTY uncataloges la generazione meno recente.

  • SCRATCH elimina fisicamente la generazione quando non è catalogata.

  • NOSCRATCH non eliminare il dataset, ovvero è possibile fare riferimento utilizzando i parametri UNIT e VOL.

In GDGSTEP2, l'utilità IEFBR14 specifica i parametri DD del modello che devono essere utilizzati da tutte le versioni.

IDCAMS può essere utilizzato per modificare i parametri di definizione di un GDG come aumentare LIMIT, cambiare EMPTY in NOEMPTY, ecc. E le sue versioni correlate utilizzando il comando SYSIN è ALTER MYDATA.URMI.SAMPLE.GDG LIMIT(15) EMPTY.

Elimina GDG in un JCL

Utilizzando l'utility IEFBR14, possiamo eliminare una singola versione di un GDG.

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

Nell'esempio precedente, l'ultima versione di MYDATA.URMI.SAMPLE.GDG viene eliminata. Notare che il parametro DISP al normale completamento del lavoro è codificato come DELETE. Pertanto, il set di dati viene eliminato quando il lavoro completa l'esecuzione.

IDCAMS può essere utilizzato per eliminare il GDG e le sue versioni correlate utilizzando il comando SYSIN DELETE(MYDATA.URMI.SAMPLE.GDG) GDG FORCE/PURGE.

  • FORCEcancella le versioni GDG e la base GDG. Se una delle versioni GDG è impostata con una data di scadenza che deve ancora scadere, quelle non vengono eliminate e quindi la base GDG viene mantenuta.

  • PURGE cancella le versioni GDG e la base GDG indipendentemente dalla data di scadenza.

Utilizzo di GDG in un JCL

Nell'esempio seguente, l'ultima versione di MYDATA.URMI.SAMPLE.GDG viene utilizzata come input per il programma e una nuova versione di MYDATA.URMI.SAMPLE.GDG viene creata come output.

//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=FB

Qui, se il GDG fosse stato indicato con il nome effettivo come MYDATA.URMI.SAMPLE.GDG.G0001V00, allora porta a cambiare il JCL ogni volta prima dell'esecuzione. L'uso di (0) e (+1) sostituisce dinamicamente la versione GDG per l'esecuzione.

Qualsiasi programma batch eseguito tramite un JCL richiede l'input dei dati, che viene elaborato e viene creato un output. Esistono diversi metodi per inviare l'input al programma e scrivere l'output ricevuto da un JCL. In modalità batch, non è richiesta alcuna interazione da parte dell'utente, ma i dispositivi di input e output e l'organizzazione richiesta sono definiti in JCL e inviati.

Input di dati in un JCL

Esistono vari modi per inviare i dati a un programma utilizzando JCL e questi metodi sono stati spiegati di seguito:

DATI INSTREAM

I dati in-stream in un programma possono essere specificati utilizzando un'istruzione 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
//*

Nell'esempio 1, l'input a MYPROG viene passato tramite SYSIN. I dati vengono forniti all'interno di JCL. Due record di dati vengono passati al programma. Si noti che / * contrassegna la fine dei dati SYSIN in-stream.

"CUST1 1000" è record1 e "CUST2 1001" è record2. La condizione di fine dati viene soddisfatta quando viene rilevato il simbolo / * durante la lettura dei dati.

Nell'esempio 2, i dati SYSIN sono contenuti in un set di dati, dove SAMPLE.SYSIN.DATA è un file PS, che può contenere uno o più record di dati.

Input di dati tramite file

Come menzionato nella maggior parte degli esempi nei capitoli precedenti, l'input dei dati a un programma può essere fornito tramite file PS, VSAM o GDG, con il nome DSN e i parametri DISP pertinenti insieme alle istruzioni DD.

Nell'esempio 1, SAMPLE.INPUT1 è il file di input attraverso il quale i dati vengono passati a MYPROG. Viene indicato come IN1 all'interno del programma.

Uscita dati in un JCL

L'output in un JCL può essere catalogato in un set di dati o passato a SYSOUT. Come menzionato nel capitolo delle istruzioni DD,SYSOUT=* reindirizza l'output alla stessa classe di quella menzionata nel parametro MSGCLASS dell'istruzione JOB.

Salvataggio dei registri dei lavori

Specificare MSGCLASS=Ysalva la registrazione lavori in JMR (Gestione e recupero log lavori). L'intero registro JOB può essere reindirizzato a SPOOL e può essere salvato in un set di dati fornendo il comando XDC contro il nome del lavoro in SPOOL. Quando il comando XDC viene fornito in SPOOL, viene visualizzata una schermata di creazione del set di dati. La registrazione del lavoro può quindi essere salvata fornendo la definizione PS o PDS appropriata.

I registri lavori possono anche essere salvati in un set di dati menzionando un set di dati già creato per SYSOUT e SYSPRINT. Ma l'intero log del lavoro non può essere acquisito in questo modo (ovvero, JESMSG non verrà catalogato) come fatto in JMR o 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=SORT

Nell'esempio precedente, SYSOUT è catalogato in MYDATA.URMI.SYSOUT e SYSPRINT in MYDATA.URMI.SYSPRINT.

Compilazione di programmi COBOL

Per eseguire un programma COBOL in modalità batch utilizzando JCL, il programma deve essere compilato e viene creato un modulo di caricamento con tutti i sottoprogrammi. JCL utilizza il modulo di caricamento e non il programma effettivo al momento dell'esecuzione. Le librerie di caricamento vengono concatenate e fornite al JCL al momento dell'esecuzione utilizzandoJCLLIB o STEPLIB.

Sono disponibili molte utilità di compilazione mainframe per compilare un programma COBOL. Alcune società aziendali utilizzano strumenti di gestione del cambiamento comeEndevor, che compila e archivia ogni versione del programma. Ciò è utile per tenere traccia delle modifiche apportate al programma.

//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 è un'utilità di compilazione COBOL IBM. Le opzioni del compilatore vengono passate utilizzando il parametro PARM. Nell'esempio precedente, RMODE indica al compilatore di utilizzare la modalità di indirizzamento relativo nel programma. Il programma COBOL viene passato utilizzando il parametro SYSIN e il quaderno è la libreria utilizzata dal programma in SYSLIB.

Questo JCL produce il modulo di caricamento del programma come output che viene utilizzato come input per l'esecuzione JCL.

Esecuzione di programmi COBOL

Di seguito un esempio JCL in cui il programma MYPROG viene eseguito utilizzando il file di input MYDATA.URMI.INPUT e produce due file di output scritti nello 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
/*

Il modulo di caricamento di MYPROG si trova in MYDATA.URMI.LOADLIB. Questo è importante per notare che il JCL sopra può essere utilizzato solo per un modulo COBOL non DB2.

Passaggio di dati ai programmi COBOL

L'input dei dati al programma batch COBOL può avvenire tramite file, parametro PARAM e istruzione SYSIN DD. Nell'esempio sopra:

  • I record di dati vengono passati a MYPROG tramite il file MYDATA.URMI.INPUT. Questo file verrà indicato nel programma utilizzando il nome DD INPUT1. Il file può essere aperto, letto e chiuso nel programma.

  • Il dato del parametro PARM ACCT5000 viene ricevuto nella sezione LINKAGE del programma MYPROG in una variabile definita all'interno di quella sezione.

  • I dati nell'istruzione SYSIN vengono ricevuti tramite l'istruzione ACCEPT nella divisione PROCEDURE del programma. Ogni istruzione ACCEPT legge un intero record (cioè, CUST1 1000) in una variabile di memorizzazione di lavoro definita nel programma.

Esecuzione di un programma COBOL-DB2

Per eseguire il programma COBOL DB2, viene utilizzata un'utilità IBM specializzata in JCL e nel programma; La regione DB2 ei parametri richiesti vengono passati come input al programma di utilità.

I passaggi seguenti sono seguiti nell'esecuzione di un programma COBOL-DB2:

  • Quando viene compilato un programma COBOL-DB2, viene creato un DBRM (Database Request Module) insieme al modulo di caricamento. Il DBRM contiene le istruzioni SQL dei programmi COBOL con la sua sintassi verificata per essere corretta.

  • Il DBRM è associato alla regione (ambiente) DB2 in cui verrà eseguito COBOL. Questa operazione può essere eseguita utilizzando l'utilità IKJEFT01 in un JCL.

  • Dopo la fase di bind, il programma COBOL-DB2 viene eseguito utilizzando IKJEFT01 (di nuovo) con la libreria di caricamento e la libreria DBRM come input per 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
/*

Nell'esempio precedente, MYCOBB è il programma COBOL-DB2 eseguito utilizzando IKJEFT01. Notare che il nome del programma, DB2 Sub-System Id (SSID), il nome del piano DB2 vengono passati all'interno dell'istruzione SYSTSIN DD. La libreria DBRM è specificata in STEPLIB.

IBM Dataset Utilities

I programmi di utilità sono programmi pre-scritti, ampiamente utilizzati nei mainframe dai programmatori di sistema e dagli sviluppatori di applicazioni per soddisfare i requisiti quotidiani, organizzare e mantenere i dati. Alcuni di loro sono elencati di seguito con le loro funzionalità:

Nome utilità Funzionalità
IEHMOVE Sposta o copia set di dati sequenziali.
IEHPROGM Eliminazione e ridenominazione di set di dati; dataset catalog o non catalogati diversi da VSAM. <
IEHCOMPR Confronta i dati in set di dati sequenziali.
IEBCOPY Copiare, unire, comprimere, eseguire il backup o ripristinare PDS.
IEFBR14

Nessuna utilità operativa. Utilizzato per restituire il controllo all'utente e terminare. Di solito viene utilizzato per creare un set di dati vuoto o eliminare un set di dati esistente.

Ad esempio, se un set di dati viene passato come input a un programma IEFBR14 con DISP = (OLD, DELETE, DELETE), il set di dati viene eliminato al completamento del lavoro.

IEBEDIT Utilizzato per copiare parti selezionate di un JCL. Ad esempio, se un JCL ha 5 passaggi e si richiede di eseguire solo i passaggi 1 e 3, un JCL IEBEDIT può essere codificato con un set di dati che contiene il JCL effettivo da eseguire. Nel SYSIN di IEBEDIT, possiamo specificare STEP1 e STEP3 come parametri. Quando questo JCL viene eseguito, esegue lo STEP1 e lo STEP3 del JCL effettivo.
IDCAMS Creare, eliminare, rinominare, catalogare, non catalogare set di dati (diversi da PDS). Solitamente utilizzato per gestire i set di dati VSAM.

Questi programmi di utilità devono essere utilizzati con le istruzioni DD appropriate in un JCL per ottenere la funzionalità specificata.

Panoramica di DFSORT

DFSORT è una potente utility IBM utilizzata per copiare, ordinare o unire i set di dati. Le istruzioni SORTIN e SORTINnn DD vengono utilizzate per specificare i set di dati di input. Le istruzioni SORTOUT e OUTFIL vengono utilizzate per specificare i dati di output.

L'istruzione SYSIN DD viene utilizzata per specificare le condizioni di ordinamento e unione. DFSORT viene generalmente utilizzato per ottenere le seguenti funzionalità:

  • ORDINA i file di input nell'ordine della posizione dei campi specificati nel file.

  • INCLUDI o OMIT i record dai file di input in base alla condizione specificata.

  • SORT MERGE file di input nell'ordine della posizione dei campi specificati nel file.

  • SORT JOIN due o più file di input in base a uno specifico JOIN KEY (campo / i in ogni file di input).

  • Quando è necessario eseguire un'ulteriore elaborazione sui file di input, è possibile richiamare un programma USER EXIT dal programma SORT. Ad esempio, se è presente un'intestazione / trailer da aggiungere al file di output, è possibile richiamare un programma COBOL scritto da USER dal programma SORT per eseguire questa funzionalità. Utilizzando una scheda di controllo, i dati possono essere passati al programma COBOL.

  • Al contrario, un SORT può essere chiamato internamente da un programma COBOL per disporre il file di input in un ordine particolare prima di essere elaborato. Di solito, questo non è consigliato in considerazione delle prestazioni per file di grandi dimensioni.

Panoramica di ICETOOL

ICETOOL è un'utilità DFSORT multiuso utilizzata per eseguire una varietà di operazioni sui set di dati. I set di dati di input e output possono essere definiti utilizzando nomi DD definiti dall'utente. Le operazioni sui file sono specificate nell'istruzione TOOLIN DD. È possibile specificare condizioni aggiuntive nelle istruzioni DD "CTL" definite dall'utente.

Di seguito sono riportate alcune delle utilità di ICETOOL:

  • ICETOOL può realizzare tutte le funzionalità di DFSORT in una o più condizioni.

  • SPLICE è una potente operazione di ICETOOL che è simile a SORT JOIN, ma con funzionalità aggiuntive. Può confrontare due o più file su campi specificati e creare uno o più file di output come file con record corrispondenti, file con record non corrispondenti, ecc.

  • I dati in un file in una posizione particolare possono essere SOVRAPPOSTI in un'altra posizione nello stesso file o in un file diverso.

  • Un file può essere suddiviso in n file in base a una condizione specificata. Ad esempio, un file contenente i nomi dei dipendenti può essere suddiviso in 26 file, ciascuno contenente i nomi che iniziano con A, B, C e così via.

  • Diverse combinazioni di manipolazione dei file sono possibili utilizzando ICETOOL con una piccola esplorazione dello strumento.

Panoramica di SYNCSORT

SYNCSORT viene utilizzato per copiare, unire o ordinare set di dati con prestazioni elevate. Offre il miglior utilizzo delle risorse di sistema e un funzionamento efficiente in spazi di indirizzi a 31 bit e 64 bit.

Può essere utilizzato nelle stesse linee di DFSORT e può ottenere le stesse funzionalità. Può essere richiamato da un JCL o da un programma codificato in linguaggio COBOL, PL / 1 o Assembler. Supporta inoltre i programmi di uscita utente da chiamare dal programma SYNCSORT.

I trucchi di ordinamento usati di frequente che utilizzano queste utilità sono spiegati nel prossimo capitolo. Requisiti complessi, che richiedono un'enorme programmazione in COBOL / ASSEMBLER, possono essere raggiunti utilizzando le utilità di cui sopra in semplici passaggi.

Di seguito sono illustrati i requisiti delle applicazioni quotidiane in un mondo aziendale che possono essere raggiunti utilizzando i programmi di utilità:

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'opzione STOPAFT interromperà la lettura del file di input dopo il decimo record e terminerà il programma. Quindi, vengono scritti 10 record nell'output.

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 rimuove i duplicati sui campi specificati in SORT FIELDS. Nell'esempio precedente, il numero del dipendente è nella posizione del campo 1,15. Il file di output conterrà i numeri univoci dei dipendenti ordinati in ordine crescente.

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

Nel file di input, il contenuto nella posizione 1,6 viene sovrascritto nella posizione 47,6 e quindi copiato nel file di output. L'operazione INREC OVERLAY viene utilizzata per riscrivere i dati nel file di input prima di copiarli nell'output.

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

L'output sarà:

data1    1000
data2    1002
data3    1004

Il numero di sequenza a 4 cifre viene aggiunto nell'output alla posizione 10, a partire da 1000 e incrementato di 2 per ogni record.

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

L'output sarà:

HDR       20110131
data1    
data2    
data3 
TRL       000000003

TOT calcola il numero di record nel file di input. HDR e TRL vengono aggiunti come identificatori all'intestazione / trailer, che è definito dall'utente e può essere personalizzato secondo le esigenze degli utenti.

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

L'output sarà:

data1select   
data2 EMPTY  
data3select

In base alla 6a posizione del file, la COSTRUZIONE del file di output varia. Se la sesta posizione è SPACES, il testo "EMPTY" viene aggiunto al record di input. Altrimenti, il record di input viene scritto nell'output, così com'è.

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 copia il file in SYSUT1 nel file in SYSUT2. Si noti che il file in SYSUT2 accetta lo stesso DCB di quello di SYSUT1 nell'esempio precedente.

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 specifica il campo su cui vengono confrontati i due file.

  • CAMPI DI RIFORMATURA =? inserisce "B" (record corrispondenti), "1" (presente in file1, ma non in file2) o "2" (presente in file2 ma non in file1) nella prima posizione dell'output BUILD.

  • JOIN UNPAIRED esegue un outer join completo sui due file.

L'output sarà:

MATCH File
1000
1003

NOMATCH1 File
1001
1005

NOMATCH2 File
1002

La stessa funzionalità può essere ottenuta anche utilizzando ICETOOL.