JCL Execution Groups

What are Execution Groups?

Execution Groups in JCL are logical collections of job steps that are treated as a unit for conditional processing. They provide a powerful way to organize complex job flows and implement sophisticated error handling strategies.

Unlike individual job steps, execution groups allow you to apply conditional logic to multiple steps at once, making it easier to control job flow and implement recovery procedures in complex batch applications.

Creating Execution Groups

Execution groups are defined using the IF/THEN/ELSE/ENDIF construct or by enclosing a set of steps within CNTL/ENDCNTL statements. Each approach offers different capabilities and is suited to different situations.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//MYJOB    JOB (ACCT),'MY NAME',CLASS=A
//         IF (RC=0) THEN             /* IF the return code from previous step is 0 */
//* ----- BEGINNING OF GROUP -----
//STEP1    EXEC PGM=PROGRAM1
//...DD statements...
//STEP2    EXEC PGM=PROGRAM2
//...DD statements...
//         ENDIF                      /* END OF GROUP */
 
//         IF (RC >= 4) THEN          /* IF return code is 4 or greater */
//* ----- BEGINNING OF ERROR HANDLING GROUP -----
//ERRLOG   EXEC PGM=ERRLOGPGM
//...DD statements...
//NOTIFY   EXEC PGM=SENDMAIL
//...DD statements...
//         ENDIF                      /* END OF GROUP */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//MYJOB    JOB (ACCT),'MY NAME',CLASS=A
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN    DD *
  DELETE dataset.name SCRATCH PURGE
  SET MAXCC=0
/*
//STEP2    EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN    DD *
  /* Beginning of control group */
  IF LASTCC=0 THEN DO
    DEFINE CLUSTER(...) -
           DATA(...) -
           INDEX(...)
  END
  ELSE DO
    /* Error handling within control group */
    SET MAXCC=8
  END
/*

Common Use Cases for Execution Groups

1
2
3
4
5
6
7
8
//         IF (RC >= 8) THEN
//BACKUP   EXEC PGM=BAKUPPGM
//...
//RESTORE  EXEC PGM=RESTPGM
//...
//NOTIFY   EXEC PGM=MAILPGM
//...
//         ENDIF

1
2
3
4
5
6
7
8
9
10
11
//         IF (RC = 0) THEN
//NORMAL   EXEC PGM=NORMPRC
//...
//UPDTMST  EXEC PGM=UPDATE
//...
//         ELSE
//ERRPROC  EXEC PGM=ERRORPRC
//...
//LOGFAIL  EXEC PGM=LOGFAIL
//...
//         ENDIF

1
2
3
4
5
6
7
8
9
10
11
// SET SYSID=&SYSUID
//         IF (&SYSID = 'PROD') THEN
//PRODSTEP EXEC PGM=PRODPGM
//...
//         ELSE IF (&SYSID = 'TEST') THEN
//TESTSTEP EXEC PGM=TESTPGM
//...
//         ELSE
//DEVSTEP  EXEC PGM=DEVPGM
//...
//         ENDIF

Nesting Execution Groups

Execution groups can be nested within each other to create complex conditional logic. This allows for sophisticated job flows that can handle a variety of conditions and scenarios.

1
2
3
4
5
6
7
8
9
10
11
12
13
//         IF (RC = 0) THEN
//STEP1    EXEC PGM=PROGRAM1
//...
//         IF (DSN='PROD.MASTER') THEN
//PRODPROC EXEC PGM=PRODPGM
//...
//         ELSE
//TESTPROC EXEC PGM=TESTPGM
//...
//         ENDIF
//STEP2    EXEC PGM=PROGRAM2
//...
//         ENDIF

You can nest up to 15 levels of IF statements in z/OS JCL, though keeping nesting to a reasonable depth improves readability and maintainability.

Execution Groups vs Individual Conditions

Best Practices for Execution Groups

• Keep it readable: Use comments to clearly mark the beginning and end of execution groups, especially in complex JCL.
• Avoid excessive nesting: While nesting is supported, deep nesting can make JCL difficult to maintain. Try to limit nesting to 3-4 levels.
• Group related steps: Put logically related steps in the same execution group to make the job flow clearer.
• Include error handling: Use ELSE clauses to handle error conditions explicitly, rather than letting steps fail silently.
• Document conditions: Add comments that explain the purpose of each condition, especially for complex business rules.

Execution Groups Exercises

Examples of Complex Execution Groups

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
//DATAJOB  JOB (ACCT),'DATA PIPELINE',CLASS=A,MSGCLASS=X
//* --------- EXTRACTION PHASE ---------
//EXTRACT  EXEC PGM=DATAXTRCT
//SYSOUT   DD SYSOUT=*
//INPUT    DD DSN=PROD.SOURCE.DATA,DISP=SHR
//OUTPUT   DD DSN=WORK.EXTRACT.DATA,DISP=(,PASS)
//* --------- CONDITIONAL PROCESSING BASED ON EXTRACTION ---------
//         IF (EXTRACT.RC = 0) THEN
//* ----- NORMAL PROCESSING PATH -----
//VALIDATE EXEC PGM=DATAVAL
//SYSOUT   DD SYSOUT=*
//INPUT    DD DSN=WORK.EXTRACT.DATA,DISP=(OLD,PASS)
//OUTPUT   DD DSN=WORK.VALID.DATA,DISP=(,PASS)
//*
//         IF (VALIDATE.RC = 0) THEN
//PROCESS  EXEC PGM=DATAPROC
//SYSOUT   DD SYSOUT=*
//INPUT    DD DSN=WORK.VALID.DATA,DISP=(OLD,DELETE)
//OUTPUT   DD DSN=PROD.OUTPUT.DATA,DISP=(NEW,CATLG)
//         ELSE
//VALIDERR EXEC PGM=ERRLOGGER
//SYSOUT   DD SYSOUT=*
//INPUT    DD DSN=WORK.VALID.DATA,DISP=(OLD,DELETE)
//ERRFILE  DD DSN=PROD.ERROR.LOG,DISP=MOD
//MESSAGE  DD *
DATA VALIDATION FAILED - PROCESS TERMINATED
/*
//         ENDIF
//*
//         ELSE
//* ----- ERROR HANDLING PATH -----
//EXTRERR  EXEC PGM=ERRLOGGER
//SYSOUT   DD SYSOUT=*
//ERRFILE  DD DSN=PROD.ERROR.LOG,DISP=MOD
//MESSAGE  DD *
DATA EXTRACTION FAILED - PROCESS TERMINATED
/*
//         ENDIF
//*
//* --------- NOTIFICATION ALWAYS RUNS ---------
//NOTIFY   EXEC PGM=NOTIFYPGM
//SYSOUT   DD SYSOUT=*
//MSGFILE  DD DSN=PROD.MESSAGES,DISP=MOD

Frequently Asked Questions

Related Pages

• JCL Conditional Execution
• IF/THEN/ELSE Constructs
• JCL Job Dependencies
• JCL Return Codes
• JCL COND Parameter