DD Statement

DSN (Dataset Name)

Specifies the name of the dataset to be processed:

1
2
3
4
DSN=dataset.name
DSN=&&temporary
DSN=*.stepname.ddname
DSN=dataset.name(member)

1
2
3
4
//DD1 DD DSN=SYS1.PROCLIB,DISP=SHR
//DD2 DD DSN=&&TEMP,DISP=(NEW,PASS)
//DD3 DD DSN=*.STEP1.DD1,DISP=SHR
//DD4 DD DSN=MY.PDS(MEMBER1),DISP=SHR

• Dataset names can be up to 44 characters long
• Segments are separated by periods (maximum 22 segments)
• Each segment can be 1-8 characters (A-Z, 0-9, @, #, $)
• Double ampersand (&&) denotes a temporary dataset
• *.stepname.ddname references a dataset defined in a previous step
• Member name in parentheses for partitioned datasets

DISP (Disposition)

Controls dataset status, what happens after normal completion, and what happens after abnormal termination:

1
2
3
4
DISP=(status,normal,abnormal)
DISP=status
DISP=(status,normal)
DISP=OLD | SHR | NEW | MOD

1
2
3
4
//DD1 DD DSN=MYFILE,DISP=SHR
//DD2 DD DSN=NEWFILE,DISP=(NEW,CATLG,DELETE)
//DD3 DD DSN=MASTER,DISP=(OLD,KEEP)
//DD4 DD DSN=TEMPFILE,DISP=(MOD,DELETE)

UNIT and VOL

UNIT specifies the device type, and VOL specifies volume information:

1
2
UNIT=device-type | UNIT=device-name | UNIT=group-name
VOL=SER=volume-serial | VOL=(,,,n) | VOL=REF=*.stepname.ddname

1
2
3
4
//DD1 DD DSN=FILE1,DISP=OLD,UNIT=SYSDA,VOL=SER=VOL001
//DD2 DD DSN=FILE2,DISP=NEW,UNIT=TAPE,VOL=(,,,2)
//DD3 DD DSN=FILE3,DISP=NEW,UNIT=3390,VOL=SER=SYS001
//DD4 DD DSN=FILE4,DISP=NEW,VOL=REF=*.STEP1.DD1

• UNIT=SYSDA generally refers to online disk devices
• VOL=SER specifies the volume serial number
• VOL=(,,,n) requests n volumes for a dataset
• VOL=REF refers to a volume used in a previous DD statement

DCB (Data Control Block)

Specifies dataset characteristics:

1
DCB=(attribute1=value1,attribute2=value2,...)

1
2
3
//DD1 DD DSN=NEWFILE,DISP=(NEW,CATLG,DELETE),
//         UNIT=SYSDA,SPACE=(TRK,(10,5)),
//         DCB=(RECFM=FB,LRECL=80,BLKSIZE=3120,DSORG=PS)

SPACE

Allocates space for a new dataset on direct access storage:

1
2
3
4
SPACE=(unit,(primary,secondary,directory),RLSE,CONTIG,ROUND)
SPACE=(TRK,(10,5))
SPACE=(CYL,(5,2,10))
SPACE=(blksize,(100,50))

• unit can be TRK (tracks), CYL (cylinders), or block size
• primary is the initial allocation amount
• secondary is the additional allocation when primary is filled
• directory is the number of directory blocks (for partitioned datasets)
• RLSE releases unused space when the dataset is closed
• CONTIG requests contiguous space
• ROUND rounds up to complete cylinders

1
2
3
4
5
6
7
8
// Basic allocation in tracks
//DD1 DD SPACE=(TRK,(20,10))
 
// Cylinder allocation with directory blocks for PDS
//DD2 DD SPACE=(CYL,(5,2,10))
 
// Block allocation with release of unused space
//DD3 DD SPACE=(6160,(500,100),RLSE)

SYSOUT

Directs output to a system output device (printer or online output):

1
2
3
SYSOUT=class
SYSOUT=(class,program,form)
SYSOUT=*

1
2
3
4
//PRINT1 DD SYSOUT=A
//PRINT2 DD SYSOUT=*
//PRINT3 DD SYSOUT=(A,,SPEC)
//REPORT DD SYSOUT=A,DEST=REMOTE1

• class is a single character (A-Z, 0-9) that defines the output class
• SYSOUT=* uses the MSGCLASS from the JOB statement
• program specifies an output writer program
• form specifies a special forms requirement
• DEST can be added to route output to a specific destination

DUMMY

Creates a dummy dataset that's recognized by the program but doesn't actually exist:

1
2
DUMMY
DUMMY,other-parameters

1
2
//INPUT  DD DUMMY
//CHECK  DD DUMMY,DCB=(RECFM=FB,LRECL=80)

• For input files, reads are simulated as end-of-file
• For output files, write operations are acknowledged but discarded
• Useful for testing or bypassing processing without changing the program
• Equivalent to specifying DSN=NULLFILE
• Any parameters after DUMMY are checked for syntax but ignored

* (In-stream Data)

Includes data directly in the JCL stream:

1
2
3
4
5
6
* 
data lines
/*
* ,DLM=delimiter
data lines
delimiter

1
2
3
4
5
6
7
8
9
10
11
//SYSIN   DD *
SORT FIELDS=(1,10,CH,A)
/*
//CARDS   DD *,DCB=BLKSIZE=80
CARD DATA LINE 1
CARD DATA LINE 2
/*
//DATA    DD *,DLM=##
THIS IS SPECIAL DATA
WITH A CUSTOM DELIMITER
##

• Data follows immediately after the DD statement
• Terminated by /* (default) or custom delimiter (DLM=)
• Commonly used with SYSIN for program control statements
• Limited to 80 characters per line unless otherwise specified
• Cannot be continued like normal JCL statements

Dataset Concatenation

Combines multiple datasets to be processed as a single dataset:

1
2
3
//ddname   DD DSN=dataset1,DISP=SHR
//         DD DSN=dataset2,DISP=SHR
//         DD DSN=dataset3,DISP=SHR

1
2
3
//LIBRARY  DD DSN=SYS1.MACLIB,DISP=SHR
//         DD DSN=SYS1.AMODGEN,DISP=SHR
//         DD DSN=USER.MACLIB,DISP=SHR

• Only the first DD statement has a DDname
• Subsequent DD statements start with // (without a name)
• Datasets are processed in the order they appear
• When end-of-file is reached on one dataset, the next is processed
• Commonly used for libraries and input files

Creating a New Permanent Dataset

1
2
3
4
5
//OUTPUT  DD DSN=USER.DATA.FILE,
//            DISP=(NEW,CATLG,DELETE),
//            UNIT=SYSDA,
//            SPACE=(TRK,(50,20),RLSE),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=3120)

Creates a new fixed-block dataset with 80-byte records. It allocates 50 tracks initially with 20 tracks of secondary space. The dataset will be cataloged if the step is successful or deleted if the step fails.

Creating a Partitioned Dataset (PDS)

1
2
3
4
5
//OUTPDS  DD DSN=USER.SOURCE.COBOL,
//            DISP=(NEW,CATLG,DELETE),
//            UNIT=SYSDA,
//            SPACE=(TRK,(100,50,20)),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=3120,DSORG=PO)

Creates a new partitioned dataset (library) with 20 directory blocks. The DSORG=PO parameter indicates a partitioned organization, and the third value in the SPACE parameter allocates directory space.

Accessing an Existing Dataset

1
2
//INPUT   DD DSN=PROD.MASTER.FILE,DISP=SHR
//BACKUP  DD DSN=PROD.MASTER.BACKUP,DISP=OLD

The first statement accesses an existing dataset in shared mode, allowing other jobs to use it simultaneously. The second statement accesses an existing dataset in exclusive mode, preventing other jobs from using it.

GDG (Generation Data Group) Example

1
2
3
4
5
6
//OLDGEN  DD DSN=USER.PAYROLL.DATA(0),DISP=SHR
//NEWGEN  DD DSN=USER.PAYROLL.DATA(+1),
//            DISP=(NEW,CATLG,DELETE),
//            UNIT=SYSDA,
//            SPACE=(CYL,(5,2)),
//            DCB=(RECFM=FB,LRECL=200,BLKSIZE=6000)

Accesses the current generation (0) of a GDG and creates a new generation (+1). Generation data groups are useful for maintaining multiple versions of related datasets, such as daily, weekly, or monthly backups.

Temporary Dataset

1
2
3
4
5
//TEMPDD  DD DSN=&&TEMP,
//            DISP=(NEW,PASS),
//            UNIT=SYSDA,
//            SPACE=(TRK,(10,5)),
//            DCB=(RECFM=FB,LRECL=80,BLKSIZE=800)

Creates a temporary dataset using the double ampersand notation. The dataset is passed to subsequent steps (DISP=PASS) but will be automatically deleted at the end of the job.

JOBLIB and STEPLIB

1
2
3
4
5
//JOBLIB  DD DSN=USER.LOADLIB,DISP=SHR
//        DD DSN=TEAM.LOADLIB,DISP=SHR
 
//STEP1   EXEC PGM=SPECIAL
//STEPLIB DD DSN=SPECIAL.LOADLIB,DISP=SHR

JOBLIB defines libraries to search for programs used throughout the job. STEPLIB defines libraries for a specific step, overriding JOBLIB for that step.