Z/Os Mainframe

JCL stands for Job Control Language. JCL is a means of communication between operating system and source program. (source programms can be written in COBOL, Assembler or PLI).

Structure of JCL :

JCL consists of below fields –

1) Identification Field – It starts from column 1 and length is 2 bytes. Two forward slashes (//) starting form 1st column is name field.

2) Name field – Name field starts from column 3 and will be of 1 to 8 alphanumeric characters.

3)Operational field : It starts from column 12.

4)Parameters field : it starts after end of operational field followed by one or more than one space.

---

There are two types of parameters –

1) Positional Parameters : These parameters have fixed position, Position cann’t be shifted.

a) Accounting information

b) Programmers name

c) PGM

d) PROC

Note : PGM & PROC are two execptional positional fields which have equal sign.

2) Keyword Parameters : These parameters have equal sign with some values, position of these fields can be shifted.

a) CLASS

b) MSGCLASS

c) MSGLEVEL

d) NOTIFY

e) USER

f) OWNER

g) TIME

h) REGION

i) COND

j) RESTART
k) PRTY
l) PARM

Some parameters can be coded on JOB statement and some can be or EXEC statement like TIME, REGION, COND & PARM.

Accounting Information :

Accounting information is realted to billing, dollar cost of job will be decided on this parameter. Maximum size 142 charecters.

//OZA201AS JOB (GENERAL),

Note :If position of Acccounting information is changed then job will give syntax error.

Programmers name :

Programmer name filed tells the name of programmer. Maximum length is 20 charecters.

//OZA201AS JOB (GENERAL), 'SANDIP WALSINGE',

Note :If position of programmer's name is changed then job will give syntax error.

PGM :

PGM is positional parameter which is coded on exec statement. It tells the system which program (Load module or Utility ) needs to be executed.

//STEP010 EXEC PGM=TESTPROG

PROC :

PROC is positional parameter which is coded on exec statement. It tell system which procedure needs to be executed.

//STEP010 EXEC PROC=CATPROC

//STEP010 EXEC CATPROC - It has same meaning as previous statement.

CLASS :

Class parameters tell system about nature of job, if job is simple I/O type then lower class can be allocated to the job, if job is complex calculation related then higher class can be allocated to the job.

Values : A to Z or 0(Zero) to 9.

//OZA201AS JOB (GENERAL),'SANDIP',CLASS=A

MSGCLASS :

MSGCLASS parameter tells system where output messages should or job should be routed/transfered after execution.

Values : A to Z or 0(zero) to 9.

//OZA201AS JOB (GENERAL),'SANDIP',MSGCLASS=J

This will route job & messages to JHS (JHS is CA tool ). If nothing is coded then job will go to spool area.

MSGLEVEL :
MSGLEVEL parameter tells system how JCL, allocation messages and termination messages are printed in job listing after execution of job.
MSGLEVEL=(x,y)

X can have below values -
x=0,1,2
0 - Only JOB statement will printed after execution JESJCL step.
1 - JOB, JCL and expanded procedures will be printed JESJCL step.
2 - JOB & JCL statements will be printed in JESJCL step.

y Can have below values -
y=0,1
0 - JCL messages & allocation will be printed if job terminates abnormally.
1 - JCL messages & allocation will be printed if job terminates normally or abnormally.

NOTIFY :
NOTIFY Parameter gives notification to the user on successful or unsuccessful completion of job.

NOTIFY=USERID OR (It will notification to the user whose userid is provided here as a user id)
NOTIFY=&SYSUID (It will notification to user who is executing the job.)

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',NOTIFY=OZA201

USER :

This parameter is rarely used parameter. This is to identify user.
//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',USER=OZA201

OWNER :

Owner is same as USER parameter, it will tell about owner of the job.
//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',OWNER=OZA201

TIME :
TIME parameter allocates maximum CPU time to the job or step. If job/step takes more time to execute than time provided in TIME parameter then job will abend with S322 abend code.

Job parameter can be coded on both JOB and EXEC statement.

*TIME parameter coded on EXEC will override TIME parameter coded on JOB statement.

Syntax :
TIME=(min,sec) or
TIME=(,)              - It will give system defined time.
TIME=1440          - It will give unlimited time.
TIME=NOLIMIT - It will give unlimited time.
TIME=MAXIMUM - Job will run maximum 248.55 days.

//OZA201AS  JOB (GENERAL),'SANDIP WALSINGE',TIME=(min,sec)

//STEP1 EXEC PGM=TESTPROG,TIME=(2,20)

REGION :
REGION parameter allocates storage space for execution of the job. It can be coded on both JOB & EXEC statement. It can be coded either in Kilobytes (K) or Megabytes (M). When coded in Kilobytes or Megabytes it should be in multiple of 4. Maximum 2GB storage space can be allocated in REGION Parameter.

*REGION coded on JOB statement will override REGION on EXEC statement.

//OZA201 JOB (GENERAL),'SANDIP WALSINGE',REGION=0M

//STEP1 EXEC PGM=TESTPROG,REGION=0M

If REGION specified in JOB is not sufficient then job abends with S422 or S822 abend code.

COND :
COND parameter is coded to control execution of steps from job.

Ex : In 1st step account holder's transaction data is getting copied from transaction file to some output file for bkup purpose, in 2nd step transction file is getting deleted.

If step1 fails due to some reason without copying data, but in step2 trandaction file will be deleted, so we will miss important data without taking bkup, in order to avoid such scenarios COND parameters are used.

*COND paramter can be coded on both JOB & EXEC statement.

Syntax :

COND=(comparison code, condition code)
EX: COND=(0,EQ)
Comparison code can have values like 0,4,8,12,16.
Condition code can be GT,LT,EQ,GE,LE.

COND=(comparison code, condition code, stepname)
EX: COND=(0,EQ,STEP1)

COND=(comparision code, condition code, PROCNAME.STEPNAME)
EX: COND=(0,EQ,TESTPROC.STEP1)

*IF Condition is TRUE then step will be skipped.
*IF condition is FALSE then step will be executed.

COND=EVEN - Step on which this condition is coded will execute when previous step terminates normally or abnormally.

COND=ONLY - Step on which this condition is coded will execute when previous step terminates only abnormally.

*COND coded on JOB statement will override COND on EXEC statement.

System first checks COND parameter from JOB statement, if it is true, then it will not check COND parameter from EXEC step(It will ignore COND parameter of EXEC step). If COND parameter from JOB step is false then it will check COND parameter from EXEC step.

//OZA201AS JOB (GENERAL),'COND TEST',
//         CLASS=8,
//         PRTY=15,
//         TIME=(5),
//         MSGCLASS=Q,
//         MSGLEVEL=(1,1),
//         REGION=0M,
//         COND=(0,NE),
//         NOTIFY=&SYSUID
//*
//STEP1        EXEC PGM=SORT
//SYSPRINT DD    SYSOUT=*
//SYSOUT   DD    SYSOUT=*
//SORTIN    DD    *
STEP1   OUTPUT
//SORTOUT  DD    SYSOUT=*
//SYSIN    DD    *
    SORT FIELDS=COPY
/*
//STEP2     EXEC PGM=SORT,COND=(0,EQ)
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTIN DD *
STEP2   OUTPUT
//SORTOUT DD SYSOUT=*
//SYSIN DD *
     SORT FIELDS=COPY
/*
//STEP3   EXEC PGM=SORT
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTIN DD *
STEP3 OUTPUT
//SORTOUT DD SYSOUT=*
//SYSIN DD *
     SORT FIELDS=COPY
/*

Output :
1) STEP1 will execute with MAXCC=0,
2) For STEP2 execution it will check JOB condition 0 NE 0, condition does not satisfy, so it will check EXEC condition 0 EQ 0, here condition satisfies so it will not execute STEP2.
3) For STEP3 execution again it will check JOB cond 0 NE 0 (STEP1 return code), condition not satisfied, so it will execute STEP3.

EX 2:

//OZA201AS JOB (GENERAL),'COND TEST',
// CLASS=8,
// PRTY=15,
// TIME=(5),
// MSGCLASS=Q,
// MSGLEVEL=(1,1),
// REGION=0M,
// COND=(0,EQ),
// NOTIFY=&SYSUID
//*
//STEP1 EXEC PGM=SORT
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTIN DD *
STEP1 OUTPUT
//SORTOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=COPY
/*
//STEP2 EXEC PGM=SORT,COND=(0,NE)
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTIN DD *
STEP2 OUTPUT
//SORTOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=COPY
/*
//STEP3 EXEC PGM=SORT
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SORTIN DD *
STEP3 OUTPUT
//SORTOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=COPY
/*

Output :
1) STEP1 will execute with MAXCC=0.

2) For STEP2 execution it will check JOB cond 0 EQ 0, here condition satifies so it will not execute STEP2 though EXEC cond is false ( 0 NE 0), it ignores EXEC cond as JOB cond is satisfied.

3) STEP3 will not execute as JOB cond (0 EQ 0) is true.

RESTART :

Restart parameter is used to restart the job from perticular step.

Syntax : RESTART=stepname or procname.stepname

ex:

//JOB1 JOB (GENERAL),'SANDIP',RESTART=STEP2

//STEP1 EXEC PGM=PROG1

//STEP2 EXEC PGM=PROG2

//STEP3 EXEC PGM=PROG3

Here job will be restarted from step2.

PRTY :
//OZA201AS JOB (GENERAL),'SANDIP',PRTY=15

It decides priority of the job, higher the priority job will execute sooner, if priority is same for jobs then job will execute on first come first serve basis.

Value ranges from 0 to 15, (14 & 15 are higher Priority). It is coded on JOB statement.

PARM :
//STEP010 EXEC PGM=TESTPRG,PARM='WELCOME TO COBOL'

It is used to pass value from JCL to application program, it is coded on EXEC statement. Maximum 100 characters can be passed thru this parameter.

Receive PARM value in COB program :
LINKAGE SECTION.
01 PARM-VAR.
05 PARM-LN             PIC S9(04) COMP.
05 PARM-TX             PIC X(25).
PROCEDURE DIVISION USING PARM-VAR.
  DISPLAY PARM-TX.

STOP RUN.

DD statement Parameters :

1) DISP

2) UNIT

3) DCB

4) SPACE

5) VOLUME

6) DATACLASS

DISP=(x,y,z)

x- Indicates status of job

x can have values NEW, SHR, OLD or MOD.

y - Can have values CATLG, DELETE,UNCATLG,KEEP,PASS

z - Can have values CATLG, DELETE,UNCATLG,KEEP.

NEW - It indicates dataset is new.

SHR - It's used for already existing dataset, generally coded for input

datasets, so that other jobs can share the dataset simultaneously.

OLD - It's used for already existing dataset, generally coded for output datasets so that other jobs can not use this datasets. If records are already present in output file and tried to copy the data in the same file then existing data will be overriden.

MOD - It's used for already existing dataset, generally coded for output datasets so that other jobs can not use this datasets. If records are already present in output file and tried to copy the data in the same file then existing data will be apended.

UNIT=SYADA or TAPE

UNIT parameters tells the system where dataset is residing or where datasets needs to created.

DCB :

DCB parameter gives information of dataset related record length, record format, blocksize, dataset organization.

DCB=(LRECL=80,RECFM=FB,BLKSIZE=800,DSORG=PS)

LRECL -

It tells information about length of record. 80 bytes is standard record length. Generally all source libs copylibs will have record length as 80 and RECFM as FB.

RECFM -

It tells information about record format of dataset.

RECFM Can be FB,VB,U,FBA,VBA.

FB - Fixed blocked (Records will have same length).

VB - Variable blocked ( Records will be of variable length)

4 bytes will be reserved for storing information about record length.

U - Undefined. This RECFM is used for loadlibs.

FBA - Fixed blocked attirbute. This RECFM is used for report gengeration purpose.

VBA - Variable blocked attribute.

BLKSIZE -

BLKSIZE parameter gives information about how many records can be stored in one block.

if BLKSIZE=800 and LRECL=80 then one block will contain 10 records.

When BLKSIZE=0 is provided it means that system will allocated best BLKSIZE on it's own.

DSORG -

DSORG=PS - Sequential dataset (PS)

DSORG=PO - Partitioned dataset (PDS)

SPACE :

SPACE=(a,(x,y,z),RLSE,CONTIG,ROUND)

a - Can have values TRK,CYL,BYTE

x - Priamry quantity space allocation ( in numbers like 1 2 3 )

y - Seconday quantity space allocation ( in numbers like 1 2 3 )

z - space for directory block (Required for PDS file only not applicable in case of PS files.

SPACE Calculation :
SAPCE=(CYL,(2,3)) - PS
2 * 1 + 3 * 15 = 2 + 45 = 47 Cyclinders will be acllocated.

SPACE=(CYL,(2,3,4)) - PDS
2 * 1 + 3 * 15 = 47 cylinders will be allocated and
4 * 5 = 20 maximum members can be allocated in one dataset.

Parameters RLSE, CONTIG and ROUND are optional.

RLSE : It releases unused storage spaces of the dataset. It releases unused space of primary quantity only not of secondary.

ex: SPACE=(TRK,(2000,3000),RLSE)

Let's say data from this dataset requires only 10 TRACKS then primary quantity 1890 tracks will be released, This dataset will have 10 + 3000 = 3010 TRACKS after execution of the job.

CONTIG: It tells system to allocate storage space contiguously. Again it is applicable for Primary quantity only. If Contiguous space is not available for primary quantity then job will abend.

ROUND: It allocates entire cylinder for the dataset.

SYSTEM NAMES IN JCL:

//STEP1 EXEC PGM=SORT

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//SYMNAMES DD *

MDT,S'&LYR2.&LMON.&LDAY'

SDT,S'&LYR4.&LMON.&LDAY'

TIM,S'&LHR.&LMIN.&LSEC'

//SORTIN DD *

TEST1 DATA

//SORTOUT DD DSN=OZA234A.TEST.OUT1,DISP=OLD

//SYSIN DD *

SORT FIELDS=COPY

OUTREC FIELDS=(01:C'SANDIP TEST',01X,MDT,

01X,SDT,01X,TIM,36:01,10,34X)

//*

OUPUT OF JOB:

SANDIP TEST 210502 20210502 091704 TEST1 DATA

You can find different SYSTEM NAMES by typing SYM in spool area, it will give list of all system names.

Symbolic and overriding parameters in JCL :

SYMBOLIC PARAMETER:

CATPROC Cataloged Procedure

OZA7489.SOURCE.PROCLIB - PROCLIB NAME

//CATPROC PROC QUAL1=OZA7489, <== Symbolic parameter

// QUAL2=TEST, <== Symbolic parameter

// PGM1=SORT <== Symbolic parameter

//*

//DATA EXEC PGM=&PGM1

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//SORTIN DD DSN=&QUAL..&QUAL2..INFB,DISP=SHR

//SORTOUT DD DSN=&QUAL1..&QUAL2...IN2,DISP=OLD

//SYSIN DD *

SORT FIELDS=COPY

//*

JOB TO EXECUTE ABOVE PROC

//OZA7489S (BUA0,S,T),'CALLPROC',CLASS=B,MSGCLASS=O,

// NOTIFY=&SYSUID

//LIB JCLLIB ORDER=OZA7489.SOURCE.PROCLIB

//*

//STEP1 EXEC CATPROC

//*

OVERRIDING PARAMETER:

//OZA7489S (BUA0,S,T),'CALLPROC',CLASS=B,MSGCLASS=O,

// NOTIFY=&SYSUID

//LIB JCLLIB ORDER=OZA7489.SOURCE.PROCLIB

//*

//STEP1 EXEC CATPROC

//DATA.SORTIN DD DSN=OZA7489.TEST.IN1, <= OVERRIDING PARAMTER

// DISP=OLD

//*

Compulsary Statements :
1) JOB statement - Job statement will tell information about job.
2) EXEC statement - Exec statement will tell what needs to be executed.
3) DD statement - DD statement will provide information about input and output files from job.

Other statements :
1) JCLLIB - It provides path of Cataloged procedure.
2) STEPLIB - It provides path of LOAD libraries.STEPLIB is for perticular step.
3) JOBLIB - It provides path LOAD libraries. JOBLIB is for entire job.

//JOB1 JOB
//JOBLIB DD DSN=OZA201.JOB.LOADLIB,DISP=SHR
//STEP1 EXEC PGM=PROG1
//STEPLIB DD DSN=OZA201.STEP.LOADLIB,DISP=SHR

In this JOB both JOBLIB and STEPLIB are coded. while executing STEP1 system will search for PROG1 load module in STEPLIB library, if it is not present in STEPLIB library then it will search in JOBLIB library.
If it is found in JOBLIB then STEP1 will be executed by using load module form JOBLIB library.
If LOAD module is not present in JOBLIB library then job will abned with S806 abend code.

Special DD names :
1) SYSIN - If we want to provide input to JCL then we can provide it in SYSIN statement.
2) SYSABEND - It will give abend messages after abnormal termination
3) SYSUDUMP - It will give abend messages after abnormal termination
4) SYSPRINT - It will print jcl/allocation messages.
5) SYSOUT - It will route jcl/allocation messages to spool area.

IBM Utilities are system defined utilities which will be invoked and executed when provided on step statement by PGM=Utility. Utilities are nothing but the load modules(Executable source in machin language which only machine will understand) which are defined by IBM (or system defined) there no need to provide path of load libraries for these Utilities.

Commonly used Utilities are as below -
1) IEFBR14     - To create, delete catlg or uncatlg datasets(PS or PDS).
2) IEBGENER - To copy data from PS file to PS file.
3) IEBCOPY   - To copy data from PDS file to PDS file.
4) IDCAMS    - Mainly IDCAMS utility is used to do operations like create & delete for VSAM or GDGs and copy for VSAM, GDGs or PS files.
5) SORT         - There are many operations that can be performed thru SORT utility like - to sort file, to format output file or to copy records.
There are two types of SORT -
1) DFSORT        - DFSORT is IBM product.
2) SYNCSORT - SYNCSORT is SYNCSORT product.

From sysout messages we can identify which sort is getting invokded.

Like -
END SYNCSORT - OZA201AS ( for SYNCSORT )
END OF DFSORT - OZA201AS ( for DFSORT)

IEFBR14 :
Create PS file

//OZA201AS JOB (GENERAL),'IEFBR14',CLASS=A,NOTIFY=OZA201
//*
//STEP1 EXEC  PGM=IEFBR14
//SYSPRINT DD  SYSOUT=*
//SYSOUT   DD   SYSOUT=*
//DD1 DD   DSN=OZA201.TEST.OUT,
// DISP=(NEW,CATLG,DELETE),
// SPACE=(TRK,(2,4)),UNIT=SYSDA,
// DCB=(LRECL=80,RECFM=FB,BLKSIZE=800,DSORG=PS)
//*

Output : This step will create PS file - OZA201.TEST.OUT.

IEBGENER :
IEBGENER utility is used to copy data from PS file to PS file.

//OZA201AS JOB (GENERAL),'IEBGENER',CLASS=A,NOTIFY=OZA201
//*
//STEP1 EXEC  PGM=IEBGENER
//SYSPRINT DD  SYSOUT=*
//SYSOUT   DD   SYSOUT=*
//SYSUT1   DD   DSN=OZA201.TEST.IN,DISP=SHR
//SYSUT2   DD   DSN=OZA201.TEST.OUT,
// DISP=(NEW,CATLG,DELETE),
// SPACE=(TRK,(2,4)),UNIT=SYSDA,
// DCB=(LRECL=80,RECFM=FB,BLKSIZE=800,DSORG=PS)
//SYSIN DD  DUMMY
/*

Output : This JCL will copy data from input file to output file.


IEBCOPY :
IEBCOPY is used to copy data from PDS file to PDS file.

//OZA201AS JOB (GENERAL),'IEBCOPY',CLASS=A,NOTIFY=OZA201
//*
//STEP1   EXEC  PGM=IEBCOPY
//SYSPRINT DD  SYSOUT=*
//SYSOUT DD  SYSOUT=*
//IN01 DD  DSN=OZA201.TEST.IN.PDS,DISP=SHR
//OUT01 DD  DSN=OZA201.TEST.OUT.PDS,DISP=OLD
//SYSIN   DD  *
COPY INDD=IN01,OUTDD=OUT01
/*
//

Output : If 3 members are present in input PDS file then it will copy all 3 members in outpput file.

   COPY INDD=IN01,OUTDD=OUT01
SELECT MEMBER=(MEM1,MEM2)

Output : This will copy MEM1 & MEM2 members in output file.

COPY INDD=IN01,OUTDD=OUT01
EXCLUDE MEMBER=MEM1

Output : This will copy all members except MEM1.

IDCAMS :
IDCAMS is used to perform create, delete and copy operations on VSAM files. PS files also can be copied by using IDCAMS. GDG base is created with IDCAMS utility.

1) Below JCL will perform below listed operations.
Copy data from PS file to PS
Copy data from VSAM file to VSAM
Copy data from VSAM file to PS
Copy data from PS file to VSAM file.

//OZA201AS JOB (GENERAL),'IDCAMS',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=IDCAMS
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//DD1      DD DSN=OZA201.TEST.IN1,
//             DISP=SHR
//DD2      DD DSN=OZA201.TEST.OUT,DISP=OLD
//SYSIN    DD *
    REPRO INFILE(DD1) OUTFILE(DD2)

/*
//*

2) To check whether file is empty or not. If file is empty job will give MAXX=04 and file is contains data it will give MAXCC=00 and will display first record in SYSPRINT.

//OZA201AS JOB (GENERAL),'IDCAMS',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=IDCAMS
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//DD1      DD DSN=OZA201.TEST.IN,DISP=SHR
//SYSIN    DD *
    PRINT INFILE(DD1) CHAR COUNT(1)
/*
//*

NOTE : VSAM fiie operations and GDG creation will be covered later in respective topics.

SORT :
SORT can be used for many opertations like COPY output record formation, remove duplicates, copy selected rows or columns, comapre two files.

1) Sort file on the basis of emp-code

Input file Layout :
21400       sandip
21200       mandip
21100       randip

emp-code starts from 1st column and length is 5 chars, emp-name starts from 7th column and lenght is 6 chars.

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD
//SYSIN    DD *
    SORT FIELDS=(01,05,CH,A)
/*
//*

Output :
21100       randip
21200       mandip
21400       sandip

Note : Both input and output files are FB, if input and output files are VB then 4 bytes needs to added in starting position field.
ex : (05,05,CH,A)

2) SORT to copy the data as it is
//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD
//SYSIN    DD *
    SORT FIELDS=COPY
/*
//*

Output : This sort will copy data from input file to output file as it is.

3) SORT to copy required number of records

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD  SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD
//SYSIN       DD *
    SORT FIELDS=COPY,
    SKIPREC=02,STOPAFT=05
/*
//*

SKIPREC will skip the records and STOPAFT will stop copyin records.

Input file data :
aaa rec1
bbb rec2
ccc rec4
ddd rec5
eee rec6
ggg rec7
hhh rec8
kkk rec9

Output file data :
ccc rec4
ddd rec5
eee rec6
ggg rec7
hhh rec8

4) SORT to format output data :

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR    *(LRECL=80,RECFM=FB)
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input)
//SYSIN      DD *
    SORT FIELDS=COPY
    OUTREC FIELDS=(01:01,03,05:05,03,1X,10:C'OUTPUT RECS',61X)
/*
//*

Input file data :
AAA REC
BBB REC

Output file data :
AAA REC OUTPUT RECS
BBB REC OUTPUT RECS

5) SORT to remove duplicate records :

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR    *(LRECL=80,RECFM=FB)
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input)
//SYSIN    DD *
    SORT FIELDS=(07,06,CH,A)
    SUM FIELDS=NONE
/*
//*

Input File data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21400 SANDIP
21500 SANDIP
21200 RANDIP
21300 MANDIP
21700 KULDIP
21800 MANDIP
21900 MANDIP

Output file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21700 KULDIP
21800 MANDIP
21200 RANDIP
21400 SANDIP

6) SORT to copy duplicate records in seaperate file :

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN   DD DSN=OZA201.SORT.IN,DISP=SHR    *(LRECL=80,RECFM=FB)
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input)
//SORTXSUM DD  DSN=OZA201.SORT.XSUM,DISP=OLD *(same as of input)
//SYSIN    DD *
    SORT FIELDS=(07,06,CH,A)
    SUM FIELDS=NONE,XSUM
/*
//*

Input File data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21400 SANDIP
21500 SANDIP
21200 RANDIP
21300 MANDIP
21700 KULDIP
21800 MANDIP
21900 MANDIP

Output file data (SORTOUT) :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21700 KULDIP
21800 MANDIP
21200 RANDIP
21400 SANDIP

Output file data (SORTXSUM) :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21900 MANDIP
21300 MANDIP
21500 SANDIP

NOTE : SORTXSUM functionality doesn't work with DFSORT product, it only works with SYNCSORT.

7) SORT to compare two input files for matching records :This sort will compare two input files on the basis emp-code field, if matches it will write records to output file.

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTJNF1 DD DSN=OZA201.SORT.IN1,DISP=SHR  *(LRECL=80,RECFM=FB)
//SORTJNF2 DD DSN=OZA201.SORT.IN2,DISP=SHR *(same as of input1)
//SORTOUT DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input1)
//SYSIN    DD *
      JOINKEYS FILE=F1,FIELDS=(01,05,A)
      JOINKEYS FILE=F2,FIELDS=(01,05,A)
      REFORMAT FIELDS=(F1:01,80)
      SORT FIELDS=COPY
/*

//

Input1 file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21400 SANDIP KPO
21200 RANDIP BPO
21300 MANDIP BPO
21700 KULDIP KPO

Input2 file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21400
21200
21500
21900

Output file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21200 RANDIP BPO
21400 SANDIP KPO

To copy unmatching records in output file.

      JOINKEYS FILE=F1,FIELDS=(01,05,A)
      JOINKEYS FILE=F2,FIELDS=(01,05,A)
      JOIN UNPAIRED,F1,ONLY
      REFORMAT FIELDS=(F1:01,80)
      SORT FIELDS=COPY

Output file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
21300 MANDIP BPO
21700 KULDIP KPO

1) Compare two files and write all matching records to output file. (INNER JOIN - ONLY MATCHING ROWS)

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SYSIN DD *

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOINKEYS FILE=F1,FIELDS=(1,5,A)

REFORMAT FIELDS=(F1:1,13,F2:1,12)

SORT FIELDS=COPY

//*

OUTPUT:

21400 SANDIP 21400 PUNE

21500 RANDIP 21500 MUMBAI

=======================================================================

2) Compare two files and write matching as well as non-matching rows from File1 (LEFT OUTER JOIN - Matching and non-matching from F1)

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F1

REFORMAT FIELDS=(F1:01,13,F2:01,12)

SORT FIELDS=COPY

//*

OUTPUT

21400 SANDIP 21400 PUNE

21500 RANDIP 21500 MUMBAI

21600 KULDIP

21800 MANDIP

21900 BALDIP

=======================================================================

3) Compare two files and write NON-MATCHING rows from F1 ONLY.

F2 we should not use in REFORMAT it will blank values

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F1,ONLY

REFORMAT FIELDS=(F1:01,13)

SORT FIELDS=COPY

//*

OUTPUT:

21600 KULDIP

21800 MANDIP

21900 BALDIP

=======================================================================

4) Compare two files and write matching as well as non-matching rows from File2 (RIGHT OUTER JOIN - Matching and non-matching from F2)

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F2

REFORMAT FIELDS=(F2:01,13)

SORT FIELDS=COPY

//*

OUTPUT:

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

=======================================================================

5) Compare two files and write ONLY non-matching rows from File2

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F2,ONLY

REFORMAT FIELDS=(F2:01,13)

SORT FIELDS=COPY

//*

OUTPUT:

22100 THANE

22200 KALYAN

=======================================================================

6) Compare two files and write matching as well non-matching rows (FULL OUTER JOIN)

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//MATCH DD SYSOUT=*

//NOMATCH1 DD SYSOUT=*

//NOMATCH2 DD SYSOUT=*

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F1,F2

REFORMAT FIELDS=(F1:01,13,

F2:01,13,?)

SORT FIELDS=COPY

OUTFIL FNAMES=MATCH,

INCLUDE=(27,01,CH,EQ,C'B'),

BUILD=(01,27,)

OUTFIL FNAMES=NOMATCH1,

INCLUDE=(27,01,CH,EQ,C'1'),

BUILD=(01,13,27,01)

OUTFIL FNAMES=NOMATCH2,

INCLUDE=(27,01,CH,EQ,C'2'),

BUILD=(14,13,27,01)

//*

OUTPUT:

MATCH:

21400 SANDIP 21400 PUNE B

21500 RANDIP 21500 MUMBAI B

NOMATCH1:

21600 KULDIP 1

21800 MANDIP 1

21900 BALDIP 1

NOMATCH2:

22100 THANE 2

22200 KALYAN 2

*****Similar type to above ****

Write matching and unmatching both records from both files in two output files -

//SORTJNF1 DD *

21400 SANDIP PUNE

21500 BALDIP MUMBAI

21600 KULDIP HYDERABAD

21700 RANDIP THANE

//SORTJNF2 DD *

21400 TIETO

21700 SYNTEL

21800 TCS

21900 HSBC

//MATCH DD SYSOUT=*

//NOMTACH DD SYSOUT=*

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

REFORMAT FIELDS=(F1:01,25,F2:01,15,?)

SORT FIELDS=COPY

OUTFIL FNAMES=MATCH,INCLUDE=(41,01,CH,EQ,C'B'),

BUILD=(01,40,40X)

OUTFIL FNAMES=NOMATCH,INCLUDE=(41,01,CH,EQ,C'1',OR,

41,01,CH,EQ,C'2'),

IFTHEN=(WHEN=(41,CH,EQ,C'1'),BUILD=(1,25)),

IFTHEN=(WHEN=(41,CH,EQ,C'2'),BUILD=(26,15))

//*

MATCH OUTPUT

21400 SANDIP PUNE 21400 TIETO

21600 KULDIP THANE 21700 SYNTEL

NOMATCH OUTPUT

21500 BALDIP MUMBAI

21600 KULDIP HYDERABAD

21800 TCS

21900 HSBC

=======================================================================

7) Compare two files and write ONLY non-matching rows from F1 & F2

//SORTJNF1

21400 SANDIP

21500 RANDIP

21600 KULDIP

21800 MANDIP

21900 BALDIP

//SORTJNF2

21400 PUNE

21500 MUMBAI

22100 THANE

22200 KALYAN

//SORTOUT DD SYSOUT=*

//SYSIN DD *

JOINKEYS FILE=F1,FIELDS=(1,5,A)

JOINKEYS FILE=F2,FIELDS=(1,5,A)

JOIN UNPAIRED,F1,F2,ONLY

REFORMAT FIELDS=(F1:01,13,

F2:01,13,?)

SORT FIELDS=COPY

OUTPUT:

MATCH:

21600 KULDIP 1

21800 MANDIP 1

21900 BALDIP 1

22100 THANE 2

22200 KALYAN 2

1 in the output file is printed because "?" was given in REFROMAT FIELDS.

==================================================

8) SORT to replace value of repetitive field :

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN    DD DSN=OZA201.SORT.IN,DISP=SHR    *(LRECL=80,RECFM=FB)
//SORTOUT  DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input)
//SYSIN     DD *
    SORT FIELDS=COPY
    OUTREC FINDREP=(IN=C'ABCD',OUT=C'ZZZZ')
/*

Input file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
SSSSSABCDSSSSSSSABCDSSSSSSSSSS

Output file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
SSSSSZZZZSSSSSSSZZZZSSSSSSSSSS

9) SORT to separate Odd and Even records from file :

This SORT will separate records on the basis of record number, if record number is odd, it will write record to ODD file, if record number is even then it will add record to EVEN file.

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN    DD DSN=OZA201.SORT.IN,DISP=SHR   *(LRECL=80,RECFM=FB)
//ODD        DD DSN=OZA201.SORT.ODD,DISP=OLD *(same as of input)
//EVEN       DD DSN=OZA201.SORT.EVEN,DISP=OLD *(same as of input)
//SYSIN      DD *
    SORT FIELDS=COPY
    OUTFIL FNAMES=(ODD,EVEN),SPLIT
/*
//

Input file data :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
AAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFF

Output file data (ODD) :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
AAAAAAAAAAAAAAAAAAAAAAAAAA
CCCCCCCCCCCCCCCCCCCCCCCCCC
EEEEEEEEEEEEEEEEEEEEEEEEEE

Output file data (EVEN) :
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
BBBBBBBBBBBBBBBBBBBBBBBBBB
DDDDDDDDDDDDDDDDDDDDDDDDDD
FFFFFFFFFFFFFFFFFFFFFFFFFF

10) SORT to do addition of numeric field :

This SORT will perform addition of numeric field.

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN    DD DSN=OZA201.SORT.IN,DISP=SHR   *(LRECL=80,RECFM=FB)
//SORTOUT DD DSN=OZA201.SORT.OUT,DISP=OLD *(same as of input)
//SYSIN    DD *
   SORT FIELDS=(05,01,CH,A)
    SUM FIELDS=(14,05,ZD)
/*
//

Input File data :
21300 SANDIP 10000
21400 MANDIP 15000
21500 RANDIP 15000
21600 KULDIP 20000
21700 BALDIP 25000

Output File data :
21300 SANDIP 85000

11) SORT to copy all duplicate records in one file and unique records in one file - For Syncsort v1.4 :

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SORTIN    DD *
01 SANDIP
02 MANDIP
03 RANDIP
04 BALDIP
//   DD *
02 MANDIP
04 MANJIT

//SORTOUT DD SYSOUT=*

//SORTXDUP DD SYSOUT=*

//SYSIN    DD *
   SORT FIELDS=(01,09,CH,A)
DUPKEYS ALLDUPS,XDUP
/*
//

11) SORT to add header & trailer in sort alongwith dates in different formats. ( used DFSORT)

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//STEP010  EXEC PGM=SORT
//SYSOUT   DD SYSOUT=*
//SYSPRINT   DD SYSOUT=*
//SYSNAMES DD *
MDT,S'&YR4.&LMON.&LDAY'
SDT,S'&LYR2.&LMON.&LDAY'

//SORTIN DD *

21400 SANDIP PUNE
21500 MANDIP PUNE
//SORTOUT DD SYSOUT=*

//SYSIN DD *

SORT FIELDS=COPY
OUTFIL FILES=OUT,
HEADER1=('00HEADER','YYYYMMDD:',MDT,'YYMMDD:',SDT),
TRAILER1=('99TRAILER',COUNT=(M11,LENGTH=8)),REMOVECC
/*
//

SORTOUT data :
00HEADERYYYYMMDD:20140219YYMMDD:140219
21400 SANDIP PUNE
21500 MANDIP PUNE
99TRAILER00000002

Instead of MDT & SDT If we give
DATENS=(4MD) ==> 20140219 (YYYYMMDD)
DATENS=(DM4) ==> 19022014 (DDMMYYYY)
DATE=(4MD-) ==> 2014-02-19 (YYYY-MM-DD)
DATE=(DM4-) ==> 19-02-2014 (DD-MM-YYYY)
DATE=(4MD/) ==> 2014/02/19 (YYYY/MM/DD)

DATE=(DM4/) ==> 19/02/2014 (DD/MM/YYYY)

Format for time

//SYSNAMES DD *
TIM,S'&LHR.&LMIN.&LSEC'

NOTE : We can use SYSNAMES not only for header record but also for detail record also.

Type SYM command in spool area and press ENTER it will show system names available.

ICETOOL :
ICETOOL to find out number of records present in the file.

//OZA201AS JOB (GENERAL),'SANDIP WALSINGE',CLASS=A,
//         NOTIFY=OZA201
//*
//SANDIP   EXEC PGM=ICETOOL
//TOOLMSG  DD SYSOUT=*
//DFSMSG   DD SYSOUT=*
//IN            DD DSN=OZA201.TEST.IN,DISP=SHR
//TOOLIN    DD *
    COUNT FROM(IN)
/*

OutPput:

    COUNT FROM(IN)                            SYNCSORT CALLED WITH IDENTIFIER "0001"
NUMBER OF RECORDS PROCESSED: 000000000000008
OPERATION COMPLETED WITH RETURN CODE 0

SYNCTOOL PROCESSING COMPLETED WITH RETURN CODE 0

6) HOW to reverse file in JCL SORT:

//STEP1 EXEC PGM=SORT

//SORTIN DD *

SANDIP 123 DDD AAAAAAAA

MANDIP 345 AAA BBBBBBBBBBBBBBBBBBBBB

RANDIP 456 HHH QQQQQQQQQQQQQ

KULDIP GGGGG AAAAAAAAAA

//SORTOUT DD SYSOUT=*

//SYSIN DD *

INREC FIELDS=(01,80,SEQNUM,08,ZD)

SORT FIELDS=(81,08,ZD,D)

OUTREC FIELDS=(01,80)

//*

OUTPUT:

KULDIP GGGGG AAAAAAAAAA

RANDIP 456 HHH QQQQQQQQQQQQQ

MANDIP 345 AAA BBBBBBBBBBBBBBBBBBBBB

SANDIP 123 DDD AAAAAAAA

Procedures :

when same code is used repetitively, then that code is coded seperately either in instream of JCL or as a member of PDS, which can be called in JCL.

There are two tyes of procedures

1) Cataloged procedures :
Procedures which are saved as member of PDS. It doesn't have PEND statement at end.

CATPROC procedure saved in XX7384A.CATPROC.LIB

//CATPROC PROC

//STEP1 EXEC PGM=IEFBR14

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//DD1 DD DSN=XX7384A.NEW.PS,

// DISP=(NEW,CATLG,DELETE),

// UNIT=SYSDA,

// DCB=(LRECL=80,RECFM=FB,BLKSIZE=800),

// SPACE=(CYL,(2,3))

//*

JCL to execute CATPROC procedure -

//OZA201AS JOB (GENERAL),'CATPROC CALL',CLASS=A,NOTIFY=OZA201

//*

// JCLLIB ORDER=XX7384A.CATPROC.LIB

//STEP1 EXEC CATPROC

//*

in this JCL CATPROC cataloged proceure is executed.

2) Instream procedures :

Procedure written instream of JCL is known as Instream procedure. Instream procedures are defined before exec statement. It starts with PROC statement and ends with PEND statment. Maximum 15 Instream procedures can be coded in on JOB.

//OZA201AS JOB (GENERAL),'INPROC CALL',CLASS=A,NOTIFY=OZA201

//*

//INPROC PROC

//STEP1 EXEC PGM=IEFBR14

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//DD1 DD DSN=XX7384A.NEW.PS,

// DISP=(NEW,CATLG,DELETE),

// UNIT=SYSDA,

// DCB=(LRECL=80,RECFM=FB,BLKSIZE=800),

// SPACE=(CYL,(2,3))

// PEND

//*

//STEPX EXEC INPROC

//*

Here stepx is executing INPROC procedure.

GDG : Generation data groups

In production there are daily, weekly, quarterly, monthly or yearly running jobs, so in order to take BKUP of data, generally we use GDGs, there is no need to provide different names to datasets when you create, system on it's own will take care of it.

These datasets are chronologically and functionally similar datasets.

Note : Under one GDG base datasets can be created with different combination of record length, record formats.

to create GDG datasets first we need to create GDG base, then GDG dataset can be created.
Maximum 255 datasets can be defined under one GDG base.

1) Create GDG base

//OZA201AS JOB (GENERAL),'CRE GDG BASE',CLASS=A,
// NOTIFY=OZA201

//*
//STEP1 EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN   DD *
DEFINE GDG -
(NAME(XA7384A.GDG.BASE) -
LIMIT(10) -
NOEMPTY -
SCRATCH -
)
//*

This JCL will create GDG base.

Parameters :
1) LIMIT -
It specifies maximum number of datasets that can be created under one GDG base.

2) NOEMPTY - It specifies older version.
3) EMPTY - It specifies all versions.
Either EMPTY or NOEMPTY can be used at one time.

4) SCRATCH - It will delete dataset.
5) NOSCRATCH - It will uncatalog dataset.
Either SCRATCH or NOSCRATCH can be used at one time.

Different combinations -
LIMIT(10)
NOEMPTY
SCRATCH
This combination will allow to create maximum 10 datasets when 11th dataset will be created it will delete 1st dataset(Older version).

LIMIT(10)
NOEMPTY
NOSCRATCH

This combination will allow to create maximum 10 datasets when 11th dataset will be created it will Uncatalog 1st dataset(Older version).

LIMIT(10)
EMPTY
SCRATCH

This combination will allow to create maximum 10 datasets when 11th dataset will be created it will Delete all previous 10 versions.

LIMIT(10)
EMPTY
NOSCRATCH

This combination will allow to create maximum 10 datasets when 11th dataset will be created it will Uncatalog all previous 10 versions.

JCL to create GDG dataset :

//OZA201AS JOB (GENERAL),'CRE GDG DS',CLASS=A,
// NOTIFY=OZA201
//*
//STEP1 EXEC PGM=IEFBR14
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//DD1 DD DSN=XX7384A.GDG.BASE(+1),
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,
// DCB=(LRECL=80,RECFM=FB,BLKSIZE=800),
// SPACE=(CYL,(2,3))
//*

here +1 indicates new version,
0 indicates current version
-1 indicates previous version
-2 older then -1 and so on....

XA7384A.GDG.BASE
XA7384A.GDG.BASE.G0001V00
XA7384A.GDG.BASE.G0002V00
XA7384A.GDG.BASE.G0003V00

Note : GDG dataset will be updated after completion of JCL only.

Abends :

When JCL/JOB terminates abnormally/unsuccessfully, it is called as job abend. It will give some specific abend code for specific reasons.

for example :
1) S322 - Time abend, when sufficient time is not provided to job.
2) SOC7 - Bad data
3) SO13 - Member not found
4) S806 - load module not found
5) S722 - When there is no space to write ouput in sysout.
6) S222 - Cancelled by operator.

Job to take unload of table -

//YSWATEST JOB (GENERAL),'DB2 UNLOAD',
// CLASS=A,
// MSGCLASS=Q,
// NOTIFY=&SYSUID,
// MSGLEVEL=(1,1),
// TIME=(0,1),
// PRTY=8
//*
//STEP1 EXEC  PGM=IKJEFT01
//SYSTSPRT DD   SYSOUT=*
//SYSPRINT DD   SYSOUT=*
//SYSOUT DD   SYSOUT=*
//SYSIN DD   *
SELECT *
FROM EMP_TABLE
WHERE EMP_NAME = 'SANDIP'
WITH UR;
//*
//SYSTSIN DD   *
   DSN SYSTEM(DBG2)
RUN PROGRAM(DSNTIAUL) PLAN(DSNTIAUL) PARMS('SQL')
//* DATA FILE
//SYSREC00 DD DSN=YSWA.DEV.DATA1X,
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(CYL,(1,1))
//* CTRL FILE
//SYSPUNCH DD DSN=YSWA.DEV.CTRL1X,
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,SPACE=(CYL,(1,1))
//*

Execute JCL from JCL:

//NA7384AS JOB (UNIT TEST),'EXEC JCL',

// CLASS=C,MSGCLASS=O,NOTIFY=&SYSUID

//*

//* THIS JCL WILL EXECUTE ANOTHER JCL FROM THIS JCL,

//* THIS IS JCL WITHIN JCL.

//*

//EXECJCL EXEC PGM=IEBGENER

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//SYSUT2 DD SYSOUT=(A,INTRDR)

//SYSIN DD DUMMY

//*

//SYSUT1 DD DATA,DLM=$$

//NA7384AS JOB (UNIT TEST),'INSIDE JCL',

// CLASS=C,MSGCLASS=O,NOTIFY=&SYSUID,REGION=4096K

//*

//**********************************************************************

//* THIS IS INSIDE JCL, THIS JCL WILL BE EXECUTD FROM ABOVE JCL

//**********************************************************************

//*

//SORTSTEP EXEC PGM=SORT

//SYSPRINT DD SYSOUT=*

//SYSOUT DD SYSOUT=*

//SORTIN DD DSN=NA7384A.TEST.IN1,DISP=SHR

//SORTOUT DD DSN=NA7384A.TEST.OUT1,DISP=OLD

//SYSIN DD *

SORT FIELDS=COPY

//*

Find Commands in Dataset:

C ALL P'========' ' ' 73
This command will change all unknown characters from 73rd position to spaces.

F P'=' This command will find unknown characters.

Sunday, 8 August 2021

JCL