MAINFRAMES TUTORIAL, JCL TUTORIAL, VSAM TUTORIAL, COBOL TUTORIAL, DB2 TUTORIAL, CICS

CA-7 Commands

2010-07-25T06:31:00.001+05:30

Q. What is CA-7 Scheduler? Where did CA-7 come from?

Think of jobs as, Flights taking off from an Airport. On a busy airport, when the clock strikes 09:00 AM, all jobs that were scheduled to depart at 09:00 AM take-off. CA-7 Scheduler manages and oversees all of this.

In the Production Environment(where things are running live), you don’t type SUB on a Production Job and give it to the Mainframe Computer for Processing. Production Jobs are generally scheduled – they auto-start at a given time. The CA-7 Scheduler on Mainframes maintains a periodic Time-table, a database or chart of which jobs run when?

A company had made CA-7 in the United States for their own internal use, under the name SASS. You would still see programs like SASSBSTR and SASS Messages today. Universal Computing Company(UCC) bought the product SASS and renamed it UCC-7. In 1987, Computer Associates(CA) bought UCC, and it was their policy to name all their products with CA Prefix, so UCC-7 became CA-7.

Q. What is the CA-7 Queueing System?

CA-7 has different staging areas called Queues, where jobs could be. The CA-7 Queues are the (1) Request Queue (2) Ready Queue and (3) Active Queue. These queues are like traffic signals on a road. First the job has got to wait in the Request Queue(Red Signal). Next, the job has to wait in the Ready Queue(Orange Signal) – this means the job is almost ready to run. When the job is currently running, we say its in the Active Queue(Green Signal).

(1) The Database holds the Timetable of when the jobs run. CA-7 periodically scans the database(timetable) for which jobs are likely to run in the next few minutes.

(2) When the clock strikes 09:00 HRS, the Job A enters into the Request Queue. The JCL of the Job is picked up from the JCL Library and added to the Trailer of the CA-7 Request. Each Job in the Request Queue, waits for certain requirements to met.

(3) When all conditions and requirements are met, the job progresses ahead to the WLB(Workload Balancing).

(4) When there are enough initiators to pick up the Job from the Queue, the job is sent to the JES2. While a job is on WLB or JES2, its shown on the
Ready Queue.

(5) An SMF Type 20 or 30 record(job initialization) is received by CA-7, and the job is moved to the Active Queue, and will start execution in an address space.

(6) The job will remain on the Active Queue, until an SMF Type 5 or 30(job completion) is received by CA-7. On receipt of the job completion, if the job is successful, the Prior Run Queue(PRRN) Queue will be updated with the details of the execution. This serves as a last run-time record for the job. However, if the job fails, it will be returned to the Request Queue(REQ).

Q. How a job enters into the Request(REQ) Queue?

There are 3 ways, a job can enter into the Request Queue[REQ]. A job can be Scheduled, triggered or demanded out.

(1) Scheduled(SSCN) – Jobs can be scheduled to run at a fixed time – for example, Reporting job runs every month-end at 08:00 PM, Load jobs run every-day at 05:00 AM and so on.

(2) Triggered(AUTO) – A parent job X, when it runs to successful completion, can TRIGGER another child job Y. A TRIGGER automatically brings Job Y into the REQ Queue.

(3) Demanded(DEMD) – A Job X can programmatically Demand out another Job Y. For example,
Job X has the following code :

If Input File contains DATA
Demand Job Y
Else
Continue
End-if

Here, Job Y is brought into the Request Queue[REQ], only if the Input-file has data records. If the Input file is empty; if there’s no data to process, the job is not demanded out. So, in this fashion, you can exercise more control, over how the job kicks off.

Q. How to know Job’s information in CA-7?

You type the command LJOB,JOB=jobname,LIST=ALL to find all the information about a job. Look at how I’ve found all the information about my job GEMPAIAS on CA-7.

This shows all the information about my job GEMPAIAS – which jobs does it trigger, which are the successor jobs, what are the steps in this job etc.

To know, if a job is Scheduled, or Triggered or Demanded out, the CA-7 Commands are
Scheduled – LSCHD,JOB=jobname,LIST=CALS
Triggered – LJOB,JOB=jobname,LIST=TRIG
Demanded – Unfortunately, there’s no direct way no this, as Demand Information is not stored in CA-7, but in JCL. However, if the Job is demanded out into the REQ Queue, it shows up as DEMD in the Entry Mode column. Sometimes, you can use LJOB,JOB=jobname,LIST=PROS option of the LJOB Command to find out information about the Demanding job.

Q. How to know, if a job is scheduled?

The quick way to know if a Job is Scheduled, is to use the List Schedule[LSCHD] Command, with LIST=CALS(Calendar) option. This opens up a Calendar view, and tells us, what time and on what calendar days of the year, your job is going to run.

In the clipping below, my job GMSBDRQ1 runs on all week-days, Monday-to-Friday at 23:00 hrs.

Q. How to know, if a job is triggered?

A job X can be brought in the REQ(Request) Queue, when it is triggered by
Job Y. How do you know, the Triggering Job or Parent Job. You can code LIST=TRIG(Triggers) option on the LJOB Command, to find out the
triggering job. In the below clipping, my job XRPDGLPS is triggered by the parent job GMSBDRQ1. When GMSBDRQ1 completes, my job XRPDGLPS would be brought into the REQ(Request) Queue.

Q. How to know if a Job is Demanded out?

A job can be programmatically demanded out by another job, based on given condition. If the condition is true, the job is demanded out into the REQ(Request) Queue. If the condition is false, the job is not demanded out. Generally, information about the Demanding job is not stored in CA-7. Sometimes, the LIST=PROSE option of the LJOB command, may give details about the Demanding job. In the below clipping, my job GEMIATAL job is demanded out by GMLIASXA.

Q. How long does a job wait in REQ Queue, before it enters RDY Queue?

A job has to wait in the CA-7 REQ(Request) Queue, until all of the requirements it has are satisfied. Requirements are like additional promises, which must be fulfilled, before a job is allowed to run. Requirements could be anything like, Completion of another job, Arrival(creation) of a file(Dataset), Submit Time, User Hold or a Negative Dependency. Its only when all the Requirements, of a job are fulfilled or posted, the job is brought to the Ready Queue(RDY).

Check out this example. A Job X triggers Job Y. Job X completes everyday at 08:00 AM. Job Y has 2 requirements – R1 and R2. Job R1 completes at 07:00 AM and Job R2 completes at 09:00 AM. The question is, when does Job Y kick-off? I would say, when Job X completes at 08:00 AM, it triggers Job Y, so it brought to the Request Queue at 08:00 AM. The requirement R1 of Job Y is satisfied, but it will wait in Request Queue[REQ], till R2 is satisfied. When R2 completes at 09:00 AM, both the requirements are satisfied, and Job Y will be brought to the Ready Queue[RDY].

Q. What are predecessors and successors of a Job?

Think of a relay-race with three participants – Arnold, Danny and Carol. The three participants are scheduled to start running, but spaced apart in intervals of 15 minutes each. Arnold is scheduled to start running when the timer is 00:00 hrs. Danny is scheduled to start running when the time is 00:15 Hrs. Carol is scheduled to start running, when the time is 00:30 Hrs.

Requirement of Danny – Danny is allowed to start running, only after Arnold completes the race, and passes on the baton to him.

Dependent Carol – Danny owes a favour to Carol, he has a commitment towards her. He must complete the race and pass on the baton to her, before she can start off.

Arnold –> Danny –> Carol

Danny’s predecessor is Arnold. Danny’s successor(dependent) is Carol.

You can use the LIST=RQMT option on LJOB Command, to find out the requirements or predecessors of a job. You use the LIST=DEPJ option on the LJOB Command, to find the successors of a job.

In the above video clipping, my job GEMTOPR3 has the requirement
(pred job) AXMYTOPV. When GEMTOPR3 enters into CA-7 REQ(Request) Queue, its gonna wait for the Requirement AXMYTOPV to be satisfied. Only, when the requirements are met, my job GEMTOPR3 can enter into RDY(Ready) Queue. Moreover, the jobs GEMCNSTL, GMCNTODL and QRPDR3PA are the successors of GEMTOPR3. This implies that the jobs GEMCNSTL, GEMCNTODL and QRPDR3PA have my job GEMTOPR3 as a requirement.

Predecessor job-names may be preceded by a slash(/) to indicate
Negative dependency. A conditional Dependency is indicated by prefixing the predecessor job-name with a question-mark(?). If a job A is conditionally dependent on Job B, then Job A will have dependency(requirement) on Job B, only if Job B is in the REQ(Request) Queue, RDY(Ready) Queue or ACT(Active) Queue. The dependency is conditionally applied, provided the pred-job is in
CA-7 Queue.

Q. What is Lead Time? What are Look-back issues?

Lead Time is the period(in hours)[time-window], that a job looks back in time, to check if all its requirements(promises) are fulfilled. See the below example. Here, my job GEMPAIAS has a requirement on PZCPDWKY, with a Lead Time of 5 hours.

JOB=GEMPAIAS LIST=RQMT

NAME ID MEMBER -NAME- -ID -ID- DSNBR DSNBR STP DDS RUNS DATE/TIME

JOB=PZCPDWKY SCHID=000 VRSN=10176/1131 LEADTM=05
JOB=/GEMPAIMG SCHID=000 VRSN=98258/0010 LEADTM=99
JOB=/GEMCNS6L SCHID=000 VRSN=95334/0012 LEADTM=99

Suppose, my job GEMPAIAS is a scheduled job, it is scanned out everyday, and enters the REQ(Request) Queue at 07:00 AM in the mornings. Now, the GEM* Job is going to check for its requirement of Pee-zee(PZ*) job. Has the Pee-Zee(PZ*) Job completed in the last 5 hours? Thus, the GEM* Job searches for its requirement Pee-Zee(PZ*) job’s completion in the time-window of 02:00 AM to 07:00 AM. If the Pee-Zee(PZ*) Job would have completed in the time-frame[02:00-07:00 AM], the requirement is satisfied.

However, if the Pee-Zee(PZ*) Job completes, say at 00:00 Hrs, this doesn’t fall in the time-window 02:00-07:00 AM, so the requirement shall not be satisfied. The GEM* Job merely keeps waiting in REQ(Request) Queue(even though the PZ* Job ran, but ran at 00:00 Hrs). This is a classic example of a Look-back Issue.

Very often, there is too large a time-gap that elapses between a predecessor job A's completion, and its dependent B's starting out. When B is brought into the REQ(Request) Queue, if A's completion doesn’t fall in the Look-back(Lead-time) window, B keeps waiting in the REQ Queue. These are called Look-back Issues. CA-7 Look-back issues generally happen in the Production Environment, generally due to delays in Batch Cycle, holidays etc.

Lead-Time could take several values.

00 – No special consideration for the amount of time elapsed, between the pred-job and dependent job's runs.
99 – The requirement is never to be considered as already satisfied, when the job enters the Queue.
nn – Since, the last run of the job, each predecessor job must have run within the last nn hours. Values for nn may be from 1 to 98.

Q. What is a Negative Dependency?

Sometimes, you wish - I hope these two jobs don't collide, don't run at the same time. If a Job P has a Negative Dependency N, Job P and Job N can't run together(mutually exclusive). So there are 2 possibilities -

1. Job P can run, if Job N has not started.
2. Job P can run, if Job N has completed.

In the snapshot below, my job GEMTOPR3 has a negative-dependency on XRPDR3PA.

GEMTOPR3 000 GEMTOPR3 GEMIDB   005 SY2 007743 *NONE* 002 000 1326 10194/2315
       --------------------------- SUCCESSOR JOBS ----------------------------
        JOB=GEMCNSTL SCHID=000
        JOB=GMCNTODL SCHID=000
        JOB=QRPDR3PA SCHID=000
        JOB=/XRPDR3PA SCHID=000    (Negative dependency)

Generally, Negative Dependencies are used in the Production Environment, to prevent contention problems. Say, for example, if two jobs access the same
DB2 Table, it’s a good idea, to have a negative dependency created amongst them.

Q. What are the advanced CA-7 Commands?

You can type CA-7 advanced Forecast commands, to find out the hierarchy of jobs in the forward order, or reverse-order. FSTRUC Command gives the complete list of triggered jobs, at all levels, top-to-bottom. FRJOB gives the complete list of triggered jobs, at all levels in the reverse order, bottom-up fashion. Look, how I’ve found the complete hierarchy of jobs triggered by my job GEMCAL00.

This is how it works. GEMCAL00 triggers GEMCAPHDR(Header job). GEMCAPHDR on the other hand triggers GEMCARAL and GEMCAR1L. The AL triggers a complete stream or wave of my jobs – GEMCARBL, which triggers the *CL, triggering *EL and so on.

Q. What is Job Monitoring? How to check if a job has completed?

When a Mainframe Job completes successfully, it goes to the Log-Area[LRLOG]. The log-area stores tracking-information – the log of the completed job of the past 5 days. The CA-7 LRLOG Command is used to retrieve from the logs, information about the previous runs of a job. I have scribbled below, how you can code several different options on the LRLOG Paragraph.

LRLOG,JOB=job-name,DATE=*
Log of the job, for the past 5 days.

LRLOG,JOB=job-name,DATE=10200
Log of the job, for the run on 2010-07-19(Julian Date 197 day of the year 2010).

When a job abends at a particular step, you may re-start the job from the next successive step, you may force-complete the job, or you may cancel the job. Force completing a job, force-fully marks the job as complete(even if the job has not run entirely successfully). All triggered down-stream jobs are brought into the CA-7 Queue.

Cancelling the job off, is like stopping the job altogether. With this the entire job-cycle downstream will be held up/hung.

LRLOG,ST=RSTR,SPAN=24
This command tells, which jobs abended and were restarted in last 24 hours.

LRLOG,ST=FORCE,SPAN=24
This command tells, which jobs abended and were force-completed in last 24 hours.

LRLOG,ST=CANCEL,SPAN=24
This command tells, which jobs abended and were cancelled off in last 24 hours.

LPRRN,JOB=job-name
This command is used find out information about the Last job-run.

COBOL-DB2 Program - Introduction

2010-07-11T07:32:00.001+05:30

Q. What are DB2 Storage Areas?

When you write COBOL Programs, that read data records from Files, and store Output results to a File, you must declare Input and Output Storage Areas for the files in the COBOL Program.

COBOL has a strict rule – first Declare, then use. Look at the picture above. Firstly whenever, you access data from Files in COBOL, you need to declare(announce) the file-names in COBOL. Moreover, you also declare COBOL Storage Areas for sending data to and receiving data from files. The Input Storage Area is the place in the COBOL Program, where the data arrives and get stored, from a File, out here for the INPUT-FILE it is EMPLOYEE-INPUT-RECORD. When you do a READ INPUT-FILE, the input record QUASAR 1000 20-10-06 is read from the file, and received and stored in EMPLOYEE-INPUT-RECORD Storage Area. Similarly, the Output Storage Area is the place in the COBOL Program, from where the data departs and is output to the File, here for the OUTPUT-FILE it is EMPLOYEE-OUTPUT-RECORD. So, when you do a WRITE EMPLOYEE-OUTPUT-RECORD, whatever’s stored in EMPLOYEE-OUTPUT-RECORD is written to the file.

In the same fashion, when you access data from DB2 Tables in a COBOL Program, you need to first DECLARE(announce) the TABLE in the COBOL Program. Suppose there’s an EMPLOYEE DB2 Table, that you want to access in the COBOL Program. The EMPLOYEE DB2 Table looks like this -

Before using EMPLOYEE Table, you must DECLARE the SQL EMPLOYEE TABLE at the top of the COBOL Program in the DATA DIVISION. You can DECLARE EMPLOYEE TABLE as shown in the picture below -

The DECLARE EMPLOYEE TABLE in the COBOL Program makes a statement – hey pal, this COBOL Program uses the EMPLOYEE table, which is broken into EMPID, ENAME, SALARY and JDATE SQL-Fields(columns). Since, this is SQL, and not COBOL Statements, you embed them – put them inside a EXEC SQL and END-EXEC Block.

When you fetch data from these SQL Fields(columns) into the COBOL, there is should also be corresponding COBOL Variables to receive and hold the fetched data. For every SQL-Field, you must declare a corresponding COBOL Variable(Storage Area).

EMPLOYEE-ID is the receiving COBOL Variable which will hold the values fetched from the SQL Field EMPID. The SQL Type INTEGER(4 Bytes) translates to
S9(09) COMP(4 Bytes) in COBOL. EMPLOYEE-NAME is the receiving COBOL Variable, that shall hold the values fetched from the SQL Field ENAME. The SQL Type CHAR(n) translates in COBOL as PIC X(n), where n is the size. EMPLOYEE-NAME is the receiving COBOL variable that shall, store the data fetched from SQL Field SALARY. For the SQL Type DECIMAL(7,2), 7 is the total width, 2 is the digits after the decimal point. Therefore, digits before the decimal point would be
7-2=5. Thus, in COBOL it translates to PIC 9(05)V99 COMP-3. EMPLOYEE-JDATE is the receiving COBOL Variable, for the values retrieved from JDATE SQL Field. Generally, DATE in SQL becomes a PIC X(10) in COBOL, TIME is a PIC X(08), and TIMESTAMP is a PIC X(26).

Specifying the table-name, SQL Fields and the corresponding COBOL Variables at the top of the COBOL Program is called Declaration. You can write DB2 Declaration manually, the way I’ve written, or you can auto-generate it. The tool that auto-generates Declarations, so that you can avoid the manual labour of writing it at the top of the COBOL Program, is called Declaration Generator Tool(DCLGEN Tool).

Q. How do you use DCLGEN tool, to auto-generate Declarations?

The Declarations Generator(DCLGEN) tool can be found inside the DB2I(DB2 Interactive) Menu 2.

I have typed the Table-name EMPLOYEE. I have also keyed in the output file(should be a member of a pds/library), in which the auto-generated DB2 Declarations are stored by the DCLGEN Tool. After hitting ENTER, you should get a message, EXECUTION COMPLETE.

This is how the DB2 Declarations auto-generated in the AGY0157.DEMO.DCLGEN(EMPLOYEE) file look like -

Q. How to use Cursors to retrieve data from DB2 Tables in COBOL?

When you fetch Data from DB2 Tables in COBOL, you cannot directly fetch all the rows from the table in one shot, in one go. Once you execute the query, the results of the Query are fetched from the DB2 Table, and are brought into another temporary, rough-work area – called Cursor Area. The Cursor Area is like a rough scratch-pad area. A marker(pointer) is set to point to the beginning/1st row in Cursor area. Now, when you fetch the data from the cursor, it reads the data-row, to which the marker(pointer) is currently set. After each FETCH, the marker(pointer) is incremented(set) to the next row. This way you FETCH data from the cursor area, row-by-row, until you’ve read all the rows, and reached the end of the Cursor Area.

In this fashion in COBOL-DB2 Programs, whenever the result of a SQL Query is multiple-rows, you must use cursors to fetch the data results row-by-row one at a time.

There are 4 steps to use a Cursor. First, you must DECLARE the Cursor Query. DECLARE C1 CURSOR merely tells, what query to run. Second, you OPEN the cursor. When you OPEN the cursor, the cursor Query is executed, and rows are fetched from the DB2 Table into the Cursor Area. Third, you FETCH data from the Cursor area into the COBOL Program row-by-row, until you reach the End of the Cursor. Fourth and last, you CLOSE the Cursor.

Whenever you perform any SQL Operation, like an OPEN cursor, FETCH data from the cursor, or a CLOSE cursor, the DB2 System returns back a 3-digit status-code to indicate the Success or Failure of the SQL operation. This 3-digit status-code is stored in a Communication Area shared between DB2 and your COBOL Program. This Shared communication-area is called SQLCA. The SQLCA is a 01-level variable(storage-area) in COBOL, that is broken down into two parts – SQLCODE and SQLSTATE.

Q. Could you show me a COBOL Program to read data-rows from a DB2 Table?

First, you need to declare the Cursor Query. DECLARE C1 CURSOR FOR is the statement used to declare a cursor. I am going to declare a cursor, which can retrieve Employee-id, name, salary and joining-date from the Employee-table.

You also need to supply the SQLCA COBOL Variable, that shall hold the results of the OPEN, FETCH and CLOSE Cursor operations. You want to be sure, that OPEN, FETCH and CLOSE Cursor operations go clean, without any errors, so you need SQLCA to check on that. You generally type an INCLUDE SQLCA entry.

Now, you begin type executable COBOL Instructions in the PROCEDURE DIVISION. Essentially, the task of fetching data-rows from the DB2 Table can be divided into 3-paragraphs 1. OPENing the Cursor 2. FETCHing data from the Cursor row-by-row and 3. CLOSEing Cursor. I have typed the MAIN Paragraph in the PROCEDURE DIVISION like this -

Line 37 performs the Open paragraph, to open the cursor.

When you do a FETCH in SQL, it returns(retrieves) back the row, the cursor is currently pointing to. Every-time you FETCH, the current-row is returned, and the cursor is incremented(set to the next row). A SQLCODE=+0 signals a successful FETCH. This sequential row-after-row process of FETCH’ing, continues on and on. But, how do you know, how many rows you want to fetch – 5, 10, 15, how many to be precise. You don’t!

The situation where the cursor points to the Last row, and there is no more data to get, is detected using the special SQLCODE=+100. A SQLCODE=+100 is the special, exceptional condition, where the cursor points to the last row, and there are no more data-rows to FETCH. You should do as many FETCH’s until, you hit SQLCODE=+100.

Line 38 in the PROCEDURE DIVISION, performs FETCH paragraph to get one row at a time, repeatedly until SQLCODE is set to +100.

Line 39 performs the Close, to close the cursor.

To Open a Cursor(and execute the Cursor query), in SQL you type OPEN cursor-name. I have coded 100-OPEN Paragraph below, which executes the SQL instruction, OPEN EMP_CSR on Line 44. When you OPEN EMP_CSR, it means

SELECT EMPID,ENAME,SALARY,JDATE
FROM EMPLOYEE

query will run. The results will be stored in a SQL Area – EMP_CSR. The contents pf the Cursor Area EMP_CSR are

--> 1    RAM    1000    2010-06-09
    2    RAJ    2000    2005-01-03
    3    RAKESH 3000    2005-02-27

A marker or a pointer is set to the first row in the Cursor-Area. This pointer position, tells what’s the next row to be read?

To fetch(receive) data-rows from the SQL Cursor-area into the COBOL Program, in SQL you type

FETCH cursor-area-name
INTO COBOL-variables

The 200-FETCH Paragraph from Lines 48-56 fetches 1 single row from the Cursor Area EMP_CSR. So, this reads the row [1   RAM    1000    2010-06-09]. But, when this data arrives in the COBOL Program, where is it stored? So you also supply a list of COBOL Variables corresponding to each SQL Data-value received. In the picture below, EMPLOYEE-ID COBOL Variable will receive the value 1, EMPLOYEE-NAME COBOL Variable will receive the value RAM, EMPLOYEE-SALARY COBOL Variable will receive the value 1000, and EMPLOYEE-JDATE COBOL Variable will receive the value 2010-06-09. FETCH cursor-area-name is a SQL Instruction. When you want to use COBOL Variables(non-SQL Variables) like EMPLOYEE-ID, EMPLOYEE-NAME etc. in a SQL Instruction, you prefix them with a :(Colon). I have DISPLAYed the recently fetched EMPLOYEE-INPUT-RECORD. After the FETCH Operation is completed successfully, the SQLCODE is set to +0. The pointer is incremented and set to the next row in the cursor area.

    1    RAM    1000    2010-06-09
--> 2    RAJ    2000    2005-01-03
    3    RAKESH 3000    2005-02-27

The 200-FETCH Paragraph is performed over and over again, till you’ve read the last row, until SQLCODE=+100. The 2nd FETCH will store 2 in EMPLOYEE-ID, RAJ in EMPLOYEE-NAME, 2000 in EMPLOYEE-SALARY and 2005-01-03 in EMPLOYEE-JDATE.

After you’re done with retrieving/working with all the data rows in the cursor-area, you must CLOSE the Cursor-area. To close the SQL Cursor-area, in SQL you type -

CLOSE cursor-area-name

The 300-CLOSE Paragraph on Lines 59-63 executes the CLOSE EMP_CSR SQL Instruction to close the cursor.

Pseudo-conversational Programs and DFHCOMMAREA

2010-06-24T23:36:00.001+05:30

Q. Is there a trade-off between Conversational and Pseudo-conversational Programs?

COBOL Programs that run in Online mode on CICS Software could be Conversational or Pseudo-Conversational. How the COBOL Programmer has written and designed the COBOL Program, determines if its Conversational or Pseudo-conversational. Conversational Programs are more resource-hungry and costly in terms of Mainframe computer time as opposed to Pseudo-conversational Programs.

Let’s say that you wanna book a Railway-Ticket to Varanasi. When you type the Transaction TBOOK on the Terminal, you get the MAIN MENU Input Screen. Now, you can either type options 1, 2 or 3 to book, cancel or view your ticket respectively. During the time you decide which option to choose, and stare at the screen, the COBOL Program is still alive, it is only in a Paused or Halted State, it is still living in the CICS region. The COBOL Program keeps on waiting, expecting User Input. The moment, you type Option '1' and hit ENTER, the COBOL Program resumes, receives the Input Data from MAIN MENU Screen, process the data, and sends the BOOK MENU Output Screen, and pauses, hits the breaks, and waits for you to type Input. But, it is live and Loaded into CICS Region, it has not stopped running. As the user fills in the Passenger details and train no., in the meanwhile the COBOL Program is still waiting. Once, you’ve filled in your Travel Plan details, and hit ENTER, the COBOL Program resumes, receives the Input Data from BOOK MENU Screen, processes the data, books(reserves)/marks the seat for you in the train compartment, and display the Output CONFIRMATION TICKET Screen to you.

The gist of the concept, is that right from when you type TBOOK and invoke the Booking Transaction, till the time you type EXIT(or press PF3 Key on MAIN MENU Screen), the COBOL Program keeps on running, it is alive and loaded into CICS Region, for the entire Length of the User Session. Even when the User is staring at the CICS GUI Screen, thinking what input to type next, the COBOL Program is still alive and kicking, running, but waiting for your Input. The COBOL Program doesn’t get killed, terminated till your Interaction(Session) is complete.

This is called a Conversationaal Program.

During the time-frame, when one CICS Output Screen is displayed on terminal, and the User is staring at the screen, thinking what Input Data Values to fill up, and then hits ENTER, the COBOL Program is alive and is kept in CICS Memory(Region), waiting for User Input. This sounds good and rosy-rosy, when it’s just a couple of users who want to Book tickets. Conversational Programs are good, when there’s just one user who needs service.

Keeping the COBOL Program loaded into Memory, while the user is looking at the screen deciding what to type - the COBOL program just sits idle on the CPU, is a sheer wastage of Mainframe Computer Time, especially when there are hundreds and thousands of People around the country who want to book tickets and need to be serviced concurrently. This is where, Pseudo-conversational Programs come into picture.

Q. How do Pseudo-conversational Programs work?

In Pseudo-Conversational Programs, every time you type Input data on a CICS Screen, and hit ENTER, the COBOL Program starts from the PROCEDURE DIVISION, validates and processes your data, and displays the next Output Screen. After displaying the Output Screen, the COBOL Program gets killed, terminated – doesn’t remain active, it is off-loaded from the CICS Region.

Thus, unlike conversational programs, Pseudo-conversational programs do not remain paused, or keep waiting in the CICS Region, listening for User Input. Instead, when you type Input and hit ENTER(Press any of the Attention Identifier AID Keys), the COBOL Program re-starts all over again from the top at the PROCEDURE DIVISION. Once the processing is complete, and the Output screen is displayed to you, to COBOL Program stops running and is killed.

Given below is how Pseudo-conversational Programs compare with their Conversational Counterparts.

Q. What is DFHCOMMAREA? Why is it a Linkage Section Storage Area?

When the user types Input text Data on the CICS GUI Input Screen – say he presses Option 1 on the MAIN MENU Screen, and hits ENTER, the COBOL Program starts from the top at the PROCEDURE DIVISION, processes the data, and sends the next CICS Output Screen say BOOK MENU Screen, and gets killed(terminated). This is called one Invocation of the COBOL Online Program.

The User stares at the BOOK MENU screen, decides what Input to type, and then after filling in the passenger details on the BOOK MENU Input Screen, hits ENTER. The COBOL Online Program restarts all over again from the PROCEDURE DIVISION, processes the Passenger Details and reserves a ticket, and sends the next CICS Output Screen say CONFIRMATION TICKET Screen, and gets killed. This is the second invocation of the COBOL Online Program.

Every time, the COBOL Program starts from the PROCEDURE DIVISION, receives data from the Input Screen, processes the data, and sends the next output screen, and finally stops running. The Start-Receive Input-Process-Send Output-Stop cycle keeps repeating till you are done with your task. Each time you type data and hit ENTER, you invoke or run the COBOL Program to process your inputs.

Sometimes, you need to save(remember) data between two successive runs, or invocations of the COBOL Online Program. Such data cannot be stored in Working Storage Areas of the COBOL Program. Working Storage Areas are created when the COBOL Program starts, and deleted when the COBOL Program stops. Working Storage Areas are rough-work areas(scratch-pad) of the COBOL Program, that live only as long as the COBOL Program runs.

The requirement however, is to store(save) data across multiple invocations(runs) of the COBOL Online Program. When you want to store(save) data which is globally accessible across several runs a COBOL Program, you use Linkage Section Storage Areas.

Given below is a simple picture that depicts how Linkage Section Storage areas differ from Working section storage areas. You’ve got a simple Storage Area A containing the value 0. You write a COBOL Program to ADD +1 TO A.

Case 1: If A were to be a Storage Area in the WORKING-STORAGE SECTION.

Each time the COBOL Program starts WS-A Storage Area is created with value 0, and the COBOL Program adds +1 to WS-A, so WS-A becomes 1. After the COBOL Program stops, WS-A is deleted. So, this doesn’t offer you memory of the past feature, with working storage areas you don’t remember, what was stored in WS-A previously, the last time the COBOL Program ran.

Case 2: If A were to be a Storage Area in the LINKAGE SECTION.

Here WS-A Storage which is globally accessible and shared across the 1st run, 2nd run and the 3rd run of the COBOL. WS-A is a Linkage section Area, so this Storage area is independent of the COBOL Program. It helps to remember data of the past, pass data from one invocation(run) to the next successive invocation(run).

DFHCOMMAREA is a Linkage Section Storage Area that helps to store(save) data, pass data around from one invocation(run) to another invocation of a COBOL Online Program in CICS. Thus, Linkage-section storage area DFHCOMMAREA plays an important role to remember and retain data between two successive invocations.

Introduction to CICS

2010-06-15T22:01:00.001+05:30

Q. I have been wondering, how does Online Mode of Processing work as opposed to Batch Mode?

COBOL Programs generally process Data in Batch Mode(Offline Mode). In Batch mode - you must tell all the Inputs, Outputs at the very beginning, right at outset, even before the Program actually starts. On the buzzer, once you hit SUB(Submit) and give your job(task) to the Mainframe Computer for processing, there’s no turning back. The Mainframe Computer processes your data, according to its own convenience. It can take a long time for the program to generate outputs – you don’t have any clue. During this time, there is no interaction between the COBOL Program and the user. There is no manual intervention from the time, the COBOL Program begins to run, until it completes.

Once the COBOL Program completes, it alerts you – notifies you, of the results. In other words, the COBOL Program is run Offline – it wouldn’t provide immediate outputs/results to the Inputs, you supply. So, in Batch mode, don’t expect a COBOL Program to give you immediate outputs/results to your Inputs, on the spur of the moment, on the go.

Contrast this, with running a COBOL Program in Online Mode. In Online(Interactive) mode, you give some input, the COBOL Program processes your Data Input, produces some output, then you type some more input, that the COBOL Program processes and you get some more output. This Input, Process, Output cycle continues, until you arrive at the final solution. In Online mode, the Program give immediate(quick) response or output, to the Inputs you supply, on the go, on the spur of the moment. You don’t have to wait too long in Online, unlike Batch Mode(Offline).

Can you run a COBOL Program in an Online, Interactive Manner on a Mainframe Computer? What is CICS Software?

CICS Software can be used to run COBOL Programs in an Online Interactive manner, on a Mainframe Computer. CICS stands for Customer Information Control System. CICS Software is a giant, robust Transaction Server. Let’s think about Flight Reservations. Zillions of people around the globe, who want to travel send their requests for Booking Tickets. It is CICS Software that handles, manages these requests, passes them on, and gets them processed using the correct COBOL Program, immediately, on-the-fly, and sends the Output Response back to the Client. CICS Software is robust server, that can humungous volumes, huge loads of Transactions at a time. IMS-DC and TPF are examples of some other Transaction Monitors on IBM Mainframes.

Role of CICS Software : Bear in mind, that when you run a COBOL Program in online-mode, it runs under the supervision of CICS Software. So, a COBOL Program in Online Mode, directly doesn’t run on its own, stand-alone. It is the CICS Software that handles all the activities on behalf of the COBOL Program.

Where does the COBOL Program come into picture : The entire Data Processing Logic(Business Rules) is written in the COBOL Program. CICS Server is just an intermediary, which delegates and passes on requests of folks to the COBOL Program for Processing. The actual data-processing is done by the COBOL Program.

Q. What are Transactions? How do you run COBOL Programs in CICS? What are CICS Tables?

In Windows, you double-click a Program, to start it in the Online-Mode. However, in CICS, a user cannot directly start a Program. Instead, you define a Transaction, which in turn will run the COBOL Program in Online Mode. Every transaction has a 4-byte Unique identification number called Transaction ID. You wanna to run COBOL Programs in Online mode on CICS, transactions are the way.

How do you run a COBOL Program on CICS? On a CICS Terminal(like a Web-browser), when you type the Transaction-ID, and hit ENTER, the COBOL Program is loaded, immediately started in the online-mode. This is called invoking the Transaction. For example, if the COBOL-online Program is BOOKTKT, and the Transaction-ID is TBOOK, when you type TBOOK, and hit ENTER, CICS Software will find the the COBOL Program BOOKTKT on the Disk, and Load into the CICS Region and execute it in Online Mode. Similar to TSO, CICS Software serves many users simultaneously. CICS is a very robust Transaction Monitor (keeps listening for transactions) – it can handle trillions of transactions at a time.

When you invoke a transaction, by typing say TBOOK, it starts a COBOL Program like BOOKTKT. But how does the CICS Software, which COBOL Program to start for the transaction TBOOK? Moreover, the CICS Software also needs to know the place(location) to look for your COBOL Program. What is the PDS, Folder or library on the Disk in which the COBOL Load Module BOOKTKT resides, so that CICS Software can pick up the Load, and start running it. Now, all this extra-information is stored in CICS Tables.

The important CICS Tables are :
PCT – For Transactions
PPT – For COBOL Programs
FCT – For Files
RCT – For DB2 Connections

When you type the Transaction ID – TBOOK, on the Terminal, the CICS Software will look-up the Transaction in the PCT.

Transaction	Program
TBOOK	BOOKTKT
TABC	PROGR01
TDEF	PROG02
...	...

PCT Table(Program Control Table) tells the COBOL-CICS Program for any Transaction.

Program	Load Pointer
BUA21	AGY0157.CICS.LOADS
BUA22	AGY0157.CICS.LOADS
BOOKTKT	AGY0157.DEMO.CICS.LOADLIB
BUA23	AGY0157.DEMO.CICS.LOADLIB

PPT Table(Process Program Table) tells the location(Load Library) from which the COBOL Program(Load) must be picked up, and loaded into the CICS Region.

Q. How do you add entries/remove entries from PCT and PPT, for your Transaction and COBOL Program?

Just as you can write your own custom Transactions(Online COBOL Programs), IBM supplies some ready-made, pre-written transactions for doing some common day-to-day tasks. For example, you can use the Ready-made transaction CEDA, to add your Transaction’s entry into the CICS PCT Table. Such ready-made transactions supplied to you by IBM for doing routine tasks are called Utility Transactions.

CEDA – CEDA is the ready-made Utility Transaction, to DEFINE(add) new entries in the CICS Tables.

CEMT – CEMT is the ready-made Utility Transaction, to ENQUIRE(Search), or query the entries(rows) in CICS Tables.

A second more important use of CEMT is to refresh the Load Pointer. Whenever you make changes(modifications) to a CICS Transaction(COBOL Online Program), you also need to reset(refresh) the Pointer in PCT Table, disconnect it from the Old Load, and point it to the new Load Module.

CECI – CECI is the ready-made Transaction, that stands for CICS Command Level Interpreter. Essentially, when you want to execute(run) and test some CICS Instructions, outside a COBOL Program(without writing a complete COBOL Program), you can use CECI ready-made transaction. For example, after designing CICS GUI Screens, when you want to test them, display the screens and see how they look, you would use the ready-made transaction CECI.

KSDS Files – Random Processing – Updating records in a VSAM File

2010-04-03T14:39:00.000+05:30

Q. What are the COBOL Instructions for randomly updating a KSDS File?

The REWRITE statement in COBOL is used to change the records in a KSDS File. You have to merely supply new values for the record-fields, and the record in the KSDS file gets updated. How does the REWRITE statement achieve this magnificent feat?

The ingredients that make up a RE-WRITE statement are (i) REad followed by (ii)WRITE. When a REWRITE statement is executed, what happens is this. Initially, it REads the record(you intend to modify) from the file into a temporary scratch-pad area or rough-work area. You specify the record you intend to modify, by mentioning its key-value. The modifications(new values) that you supply, are applied to the record that’s brought into the scratch-pad area. The old-values are wiped out(erased off), and the new values take their place. It finally WRITEs the updated record back to the file.

Q. Is there any structured approach, or systematic procedure that can be followed to update records in a KSDS File?

Let's say, you want to update this KSDS File, containing a list of Employee details. The Employee record has following layout -

Here’s the contents of the EMPLOYEE-KSDS-MASTER file, that I intend to update currently -

Its great to follow a general procedure to update(change) the logical records in a KSDS File.

1. First of all, you tell VSAM, what’s the record you want to modify. You MOVE the key of the record to be changed in RECORD KEY field. So, let’s say I want to update the details of QUASAR, bearing Employee ID=70. Just do a,
MOVE 70 TO EMP-ID.

2. Next, supply the new values for the rest of the fields - EMP-NAME, EMP-AGE, EMP-SALARY, and EMP-JDATE. Assume that, I want the age to be 25, salary to 26000 and date-of-joining to be 20081208. So, I should be MOVE'ing these new values to the corresponding fields in the EMPLOYEE-KSDS-RECORD record area.
MOVE 'QUASAR' TO EMP-NAME
MOVE 25 TO EMP-AGE
MOVE 2600000 TO EMP-SALARY
MOVE 20081208 TO EMP-JDATE

3. Essentially, we have now prepared, constructed the record that we want to update. What remains is, to overlay this brand-new record on top of the old-one in the file. To REWRITE the employee-record in the KSDS File, we
REWRITE EMPLOYEE-KSDS-RECORD.

The reader should understand, at the face of it, this step looks pretty simple. However, the elements that constitute REWRITE'ing operation are (i) REading the old-record from the file into the temp. scratch-pad area (ii) applying the modifications and changes mentioned in the COBOL Program (iii) WRITEing the updated record back to the file.

Q. Could you list a COBOL Program for randomly updating the records in KSDS File?

I have written a COBOL Program that reads the records to be updated(transactions) from a Transactions-file, and updates them in KSDS Master file. These are the transactions or records that I want to update.

The Random Update COBOL Program uses flags and switch variables, to detect exceptional conditions.

Any input-output operation on KSDS Files – leaves behind a signature – a two digit code – that indicates the result of the operation. The variable FILE-STATUS-CODES is used to store(hold) the result of File Operations. It is defined as follows :

A status code 0, indicates that the file operation was successful, and the VSAM-FILE-OPERATION-SUCCESS flag is set to TRUE. A non-zero status code, represents an error, and the VSAM-FILE-OPERATION-FAILED flag is set to TRUE.

Moreover, when reading records from a file sequentially, I use a flag variable to indicate – denote the End-of-file condition(all the records have been read). The END-OF-FILE-SWITCH variable is defined as follows :

The task of updating records in a KSDS File, has been broken down into 3 parts – B100-OPEN-FILES paragraph, C100-PROCESS paragraph and D100-CLOSE-FILES paragraph.

On Line 70, B100-OPEN-FILES paragraph opens the files for processing. The
VSAM-FILE-OPERATION-SUCCESS flag is tested, to check if File OPEN operation was successful. If the OPEN operation succeeded, you proceed to process the files, and then close the files. If the OPEN operation failed, the control is transferred to the ELSE block, and a message 'ERROR WHILE READING FROM VSAM FILE' along with the two-digit status code is DISPLAYed – that’ll tell the exact cause(Reason) behind the error.

Next, we have the B100-OPEN-FILES paragraph.

You OPEN the EMPLOYEE-KSDS-MASTER file for I-O, for updating records. You open the EMPLOYEE-TRANSACTION-FILE for reading INPUT transaction records sequentially, one-by-one.

The C100-PROCESS paragraph reads a transaction record from the
EMPLOYEE-TRANSACTION-FILE. The WS-INPUT-TRANSACTIONS-CNT is a counter that keeps track of the no. of transactions that have been read, so far. Each time a record is read, the count increases by 1.

We are going to use the EMPLOYEE-KSDS-RECORD area to hold, the new, modified record. Lines 94-95 MOVE the data from the transaction-record, to the EMPLOYEE-KSDS-RECORD area, field-by-field. Once the move is complete, the EMPLOYEE-KSDS-RECORD constructed, represents the new record.

Line 96 REWRITEs(overlays) the new EMPLOYEE-KSDS-RECORD just constructed, on top of the old record in KSDS Master file. But what if, the record you intend to update, is not found in the master-file. This error-condition when it occurs, can be detected using INVALID KEY clause on Line 97. Lines 98-99 DISPLAY(print) a message for logging purposes – saying the record was not found. On Line 101, the NOT INVALID KEY represents the condition, when the REWRITE operation is successful. The counter WS-RECS-UPDATED-CNT is used to keep track of the no. of records updated in the Master-file. This process of reading a record from a transaction file, and updating it in the master file, repeated several times again and again, until you have reached the end of the transactions file – all the transactions have been read.

The D100-CLOSE-FILE paragraph closes the EMPLOYEE-KSDS-MASTER file and the EMPLOYEE-TRANSACTION-FILE.

KSDS Files – Random Processing – Adding records to VSAM File

2010-03-22T00:37:00.000+05:30

Q. Adding records to a file, sequentially or randomly, what’s the difference?

KSDS Files can be updated sequentially as well as Randomly. How does
Random addition of records to a file, score over sequential addition of records?

In Sequential Addition(ACCESS MODE IS SEQUENTIAL), new records get added to the tail-end of the KSDS File. A file contains 3 employees – 10,20,30. You add a new employee record 40, the file becomes 10,20,30,40. You want to add employee-id 35. Not possible as you’ve been working in Sequential mode.

Ever played a game of Playing Cards? There are Spades, Hearts, Diamonds, and Clubs. When you pick a queen of Diamonds, you first find the suit – in this case Diamonds, to which the card should be added, and then insert it into the right slot. Like putting cards into the right suit, in random access(ACCESS MODE IS RANDOM), new records can be inserted, interspersed into the file. Random mode finds right-slot for each record.

Q. What are the COBOL instructions for adding records to KSDS Files?

The Employee-records stored in a KSDS File, have the following record layout -

COBOL Program can add(insert) new logical records to a KSDS File.

(i) You MOVE the key of the record that you want to add, to the RECORD KEY field(employee-id) in the 01-level record-descriptor. For example, if you want to add the employee (45,’RAHUL’,35,4000,’23-12-2005’), you place the key 45 in the key-field EMP-ID.

(ii) Next, fill in the rest of the fields in the record. So, put ‘RAHUL’ in EMP-NAME, 35 in EMP-AGE, 4000 goes into EMP-SALARY and ‘23-12-2005’ goes into EMP-JDATE.

(iii) The COBOL WRITE verb is used to add the record to the file.

In response to the COBOL WRITE instruction, VSAM performs a full-index search - to find the target Control Interval(CI) where the record should go. Once the Control Interval(CI) is located, the record is placed in the free-space available, while re-arranging the other records as necessary. Recollect, that the records in a Control-Interval are always sorted in key-sequence.

The format of the COBOL WRITE statement is -

WRITE record-name
KEY IS name-of-key-field
INVALID KEY
what-to-do-if-duplicate-field
NOT INVALID KEY
what-to-do-if-insert-is-successful

The WRITE statement includes the record-name(Record to be added). The INVALID KEY clause serves as red-signal, an indicator that things went wrong while adding the record. Generally, the INVALID KEY condition occurs, when you try to WRITE a duplicate record into a file. Like you try to add an Employee 100, who’s already there in the file. VSAM won’t allow you to over-write it, and throws back an error. You can trap(catch) this exceptional condition, error by INVALID KEY. NOT INVALID KEY represents the condition, if the record is successfully added to the file. You would use NOT INVALID KEY condition for record-keeping(printing messages) in the logs, it’ll run only if the record is successfully inserted into the file.

Q. Could you show me a simple COBOL Program to add records to a VSAM File?

I have a KSDS File, containing a list of Employees. The contents of the KSDS File AGY0157.EMPLOYEE.KSDS are shown below -

I want to add the following records to the Employees KSDS File -

The flag-variables to detect end-of-file condition, and error-condition are shown below.

All I/O operations(OPEN,READ,WRITE,CLOSE) on the Employees KSDS File, leave behind a 2-digit Status Code(a trail), indicating the results of the Operation(Success/failed). FILE-STATUS-CODES variable stores the I/O Status Code.

VSAM-FILE-OPERATION-SUCCESS condition represents '00' status code - indicating I/O Operation is Successful. VSAM-FILE-OPERATION-FAILED condition represent non-zero I/O status code – indicating I/O Error.

For record-keeping purposes

The starting point of the Program with the PROCEDURE DIVISION. We shall break up the task of adding records to Employee KSDS File into 3 paragraphs – OPEN-FILE, PROCESS and CLOSE-FILE.

Line 69 opens the Employee KSDS File for adding records. The VSAM-FILE-OPERATION-SUCESS 88-level condition checks status of the OPEN operation. If the file was OPENed successfully, the VSAM-FILE-OPERATION-SUCCESS switch is turned on(TRUE).

Lines 70-71 transfer the control to C100-PROCESS and D100-CLOSE-FILE para, to process the files and close them.

If the OPEN operation fails, you DISPLAY a message 'ERROR OPENING VSAM FILE', and file-status-code is printed.

Let’s go to B100-OPEN-FILE paragraph.

I shall read records from the EMPLOYEE-TRANSACTION-FILE and add them randomly to the EMPLOYEE-KSDS-MASTER file. As I am reading the records from
EMPLOYEE-TRANSACTION-FILE, I open it for INPUT. For making changes, I OPEN the EMPLOYEE-KSDS-MASTER file for I-O.

Immediately following the B100-OPEN-FILE, the MAIN-PARA performs
C100-PROCESS. This paragraph is reads 1 record from the Input transactions file and writes it to the Output Employee KSDS File. If there are 5 transactions to be added, this C100-PROCESS must be repeated 5 times. In other words, we iterate through C100-PROCESS for all the transactions one-by-one, in a cyclic way, till we reach the end of the transactions.

The C100-PROCESS paragraph looks like this -

Lines 86-90 READ a record from the EMPLOYEE-TRANSACTION-FILE. The READ block contains an AT END indicator. This condition becomes true when the all transactions from Input Transaction file have been read. At this point, you turn the AT-END switch on, so that the cyclic process of
PERFORM’ing C100-PROCESS comes to a halt.

Every-time you read a record, you increment the counter WS-INPUT-REC-CNT by 1. This kinda keeps track of, how many records you read off the input-file. This is shown in Line 91. Having done this for logging purposes, Line 92 copies the Input-file’s record EMPLOYEE-TRANSACTION-RECORD to the output-file’s record area EMPLOYEE-KSDS-RECORD.

Lines 93-99 write the EMPLOYEE-KSDS-RECORD to the Ouput Employee KSDS File. The INVALID KEY condition represents a duplicate record found error. The NOT INVALID KEY condition is true, when the employee-record is successfully written to the Output Employee KSDS file. Line 97 increments the counter
WS-INSERT-RECS-CNT by 1. This counter on the other hand, keeps track of the no. of records inserted successfully. All the records should get inserted.

The D100-CLOSE-FILE closes the files, and releases them. We also print the counts of the records read WS-INPUT-RECS-CNT and the records inserted into the Employee KSDS File WS-INSERT-RECS-CNT to the log, for error-tracking or bug-fixing purposes.

KSDS Files – Random Processing – Retrieving Records

2010-03-16T13:31:00.001+05:30

Q. What are the Environment Division considerations for random processing of KSDS File?

When you want to do random processing of the records in a KSDS File, the COBOL SELECT statement has the following syntax :

SELECT filename
   ASSIGN TO ddname
   ORGANIZATION IS INDEXED
   ACCESS MODE IS RANDOM
   RECORD KEY IS name-of-key-field-in-record
   FILE STATUS IS file-status-area

The Key field that is used to uniquely identify each employee is the Employee Identification no. – EMP-ID field.

Q. How Random retrieval of KSDS Files works?

For the sake of example, let’s assume that we have a KSDS File containing Employee records. The contents of the KSDS file are -

The record-layout for the Employees KSDS file is as shown below -

For random retrieval of records, you just spell out the key-value(Employee identification no.) of the employee you wanna find, to VSAM and in a jiffy, VSAM fetches the Employee details for you. Now, let’s look at what happens in the background.

The key value(employee-id) of the Employee record, you want to fetch is first placed in the key-field area(EMP-ID). Let’s assume you want to retrieve the details – name, age, salary and joining date of the Employee No. 70.

VSAM compares the RECORD KEY value(Employee-id) specified in the program, to the entries in the root index set record. The first entry in the root index record >= RECORD KEY value, is used to point to the next lower level index set record. The entries in this index record is then compared to the RECORD KEY. Again the first entry >= RECORD KEY value is found, and points to a next lower level index set record.

This search process continues downward through the index levels, until an index entry points to a sequence set record. The first sequence set entry which is greater than or equal to the (RECORD KEY)Employee No. 70, points to the Control Interval(CI) in the KSDS Data file. This Control Interval(CI) must hold the record(if it is in the file). The CI is now retrieved and searched for the desired logical record.

Q. What are the PROCEDURE DIVISION statements for random retrieval of records in KSDS file.

You are going to write a COBOL Program to search the details of Employee No. 70 in the Employee KSDS File. The COBOL Program can be broken down into three paragraphs – open, fetch, close.

The 1000-MAIN-PARA performs 3 steps -

Line 51 performs 2000-OPEN-FILE-PARA, which would open the KSDS File for reading the records.

Lines 52-55 are executed, only if the Open operation on the KSDS File is successful. If the Open operation fails, a message stating ERROR OPENING VSAM FILE is displayed, and the error code is printed to the log.

If the OPEN operation is successful, you go ahead and fetch the logical-record you want, and then close the files, once you are done.

The 2000-OPEN-FILE paragraph OPENs the EMPLOYEE-KSDS-FILE containing Employee records in INPUT mode. The INPUT mode is used to read the records from a file. It also OPENs the OUTPUT-FILE in OUTPUT mode. The OUTPUT-FILE points to the log(print output) of the job, and we shall print the details of the Employee we want, to the OUTPUT-FILE.

The 3000-FETCH-RECORD paragraph will retrieve(search) the details of Employee-ID 70.

We begin by placing the key value(employee-id) of the employee, we would like to search in the RECORD KEY field – EMP-ID. Lines 68 places the value '070' in the Key-field EMP-ID.

On Line 69, the COBOL READ Statement, causes VSAM to perform a random search on the EMPLOYEE-KSDS-FILE for the record with EMP-ID 70. If the search returns positive results - Employee record with EMP-ID=70 is found, the
NOT INVALID KEY clause is executed, and a message ‘RECORD FOUND’ is printed to the log. If the search is a failure – there is no Employee record in the KSDS File with EMP-ID=70, the INVALID KEY clause is executed, and a message ‘RECORD NOT FOUND’ is printed to the log.

We then store the data present in the EMPLOYEE-KSDS-RECORD area into
OUTPUT-RECORD area. Line 77 write the OUTPUT-RECORD, details of the Employee no. 70 to the OUTPUT-FILE.

The 4000-CLOSE-PARA closes the files, and releases them.

KSDS Files – Sequential Processing

2010-03-07T00:56:00.001+05:30

Q. What are the ENVIRONMENT DIVISION considerations for sequential processing of KSDS File?

The SELECT statement in COBOL assigns a Symbolic-name(second name), to the actual TSO-file. So, I could use the symbolic file-name OUTPUT-FILE in COBOL, to refer to my file AGY0157.EMPLOYEE.KSDS.

SELECT Statement describes the file - (i) what’s the file-layout, the organization (ii) and the mode of processing(how are you going to process it).

File organization - Is the file sequential or does it also have an index, is it indexed. You also want to tell, how the records should be processed in a file – do you traverse the records one-by-one sequentially, and process the file from start-to-end, till you find the desired record – that’s sequential processing. On the other hand, you can directly jump(hop) or fly over-to the desired record(that’s a lot quicker) and process it – that’s random processing. For sequential processing of records, you must set the ACCESS MODE to Sequential.

The SELECT statement highlights the RECORD KEY. The value in record key field provides a unique identification for each record in the file. Every record will have a unique value in record key field. For example, in the Employees KSDS File, the record key is EMP-ID. This is because, every employee has a unique EMP-ID. No two employees have same EMP-ID.

First up, in the picture below, see what the SELECT statement for KSDS file has -

Now, the File descriptor and record-layout(the various fields in Employee record) for the Employees KSDS file is shown in the picture :

Q. How do you perform initial loading of records in KSDS file?

When you create an empty KSDS file, you want to store some meaningful data in the file. Storing records, or populating an empty KSDS file with records is called Initial Load. You write records out one-by-one sequentially to the KSDS file. Thus, for the Initial load, the access mode is set to Sequential. During Initial Load, the records must be loaded in increasing(ascending) sequence of the RECORD KEY.

We are going to load records sequentially in the Employee KSDS File. To begin with, here are the Working storage section variables -

Lines 42-44 define the END-OF-INPUT-FILE flag variable. This variable behaves like a switch, initially it is in NOT-AT-END state. When you have read all the records in the file, it flips over to AT-END state.

Lines 46-48 define the STATUS CODE area for the KSDS File. Whenever you perform a VSAM operation, like opening the file, writing to the file, or closing the file, it leaves behind a 2-digit code number. 00 indicates a successful operation and non-zero code indicates failure.

Make it a habit to use File Status codes because, trapping errors, and nipping them in the bud, helps your program to recover from the dangerous run-time errors, which could crash your program and leave your files or database in an inconsistent state.

Lines 50-51 define the counter variable which keeps track of the number of input records processed.

The procedure for sequentially loading a KSDS file, is as follows
1. OPEN OUTPUT filename
2. WRITE record-name
FROM data-area
INVALID KEY what to do
3. CLOSE filename

The WRITE statement in COBOL is used to write a record to a KSDS file. When you initially load a KSDS file, the RECORD KEY must be increasing(ascending) order. What happens when this condition is not met? The WRITE is aborted, and a STATUS CODE is set. The INVALID KEY clause is executed, when the WRITE operation fails. Thus, key-violation is automatically detected by the INVALID KEY clause. Thus, INVALID KEY Routine can be used to trap duplicate key, or out-of-sequence record errors.

The picture below shows the PROCEDURE DIVISION statements -

Line 55 performs the OPEN-FILE routine, which opens the KSDS file.

The conditional IF block(Lines 56-63) tests the value of FILE-STATUS-CODES variable. If the Open operation leaves behind a STATUS CODE 00(VSAM-FILE-OPERATION-OK), a loop is generated to load the records in the KSDS file and then close it. If a non-zero status code is left behind(ELSE block), you print a message to the log which says 'Unable to open indexed file'.

Lines 66-69 is the OPEN-FILE routine. EMPLOYEE-KSDS-FILE is opened for output on line 68.

Lines 71-81 is the load a record into the Employees file. Line 72 reads a record from the input data. The record is placed in the INPUT-RECORD area. Once the record has been read, the counter WS-EMLOYEE-CNT is incremented. The WRITE statement in line 77 attempts to add this record to the file. WRITE automatically sequence checks the records on the RECORD KEY field. If WRITE operation fails, it is because of duplicate key, or out-of-sequence error. A message is DISPLAYed on line 80.

Here, I have just assumed that the WRITE operation fails because of key-violation. However, this may not always be the case(e.g. if the file fills up and no more space is available, or hardware I/O error). Ideally speaking, the STATUS CODE must be tested to differentiate between possible errors.

Lines 83-92 CLOSE the KSDS file, after the loading is complete. The CLOSE operation leaves behind a STATUS CODE. If the CLOSE is successful, a message is DISPLAYed 'VSAM FILE CREATION COMPLETED'. The number of records processed are also displayed. If the CLOSE fails, the message 'VSAM FILE NOT PROPERLY CLOSED'.

CICS Tutorials

2010-03-01T02:14:00.000+05:30

Tutorial Link	Downloads
Introduction to CICS	Word,PDF
Pseudo-conversational Programs and DFHCOMMAREA	Word,PDF
Constructing CICS GUI Screens
Writing, compiling and preparing CICS Transaction in COBOL
Transfer of Control – RETURN, XCTL, LINK, CALL, START and ABEND
Saving data between transactions – DFHCOMMAREA, Temporary Storage Queues(TSQ) and

IDCAMS – LISTCAT Command

2010-02-25T13:03:00.000+05:30

Q. What is a Catalog? What is meant by cataloging or un-cataloging a file?

Data on computers is stored in Files. The files are generally scattered everywhere haphazardly in Computer Memory. Well, let's say you want to see, or read the file in which you stored your Birthday photographs. The file containing the birthday photographs could be placed anywhere in the Computer Memory. How do you know, the location of your file(where is it) in this vast galaxy of Computer Memory space? It’s like finding a needle in a haystack.

The MVS Operating System keeps a diary/register, which contains name of each file, and its location in the computer memory. This diary/register is like your map around the Mainframe's memory land. You want to find a file, just see the MVS operating system’s diary, and it will tell you the location of your file.

This diary or map, which you consult to find a file on a Mainframe computer, is called Catalog. The Catalog contains entries for each file, a file-name and a pointer to the physical memory location, where the file is present.

Not all the files present on a Mainframe may have an entry in the Catalog. If a given file’s entry is not present in the Catalog, you will have to find the file manually, by explicitly specifying the UNIT and VOLUME parameters on the DD Statements. Adding an entry for a file i.e. File name and its location to Catalog, is called cataloging a file. Deleting the entry of a file, from the Catalog is called uncataloging the file.

Actually, the Catalog itself is a VSAM File. So, you can use the ready-made IBM Supplied program IDCAMS to read the contents of the Catalog.

Q. What is the LISTCAT command in IDCAMS?

LISTCAT command stands for List Catalog. It is the control-instruction or order to IDCAMS, to display the contents of the Catalog.

LISTCAT command of IDCAMS is a very powerful tool. You can use LISTCAT command to ask a Yes/No Question. Is there a file by the name of AGY0157.DEMO.FILE on the system? If such a file exists, the answer returned is yes. If the file does not exist the answer returned is no.

The LISTCAT command has the following syntax :

LISTCAT ENTRIES(your.file.name) ALL

I have written a JCL, to test if a given file is available on the system. Take a look at it –

In the above JCL, I have asked a question, is there a file called AGY0157.DEMO.FILE available? If yes, then IDCAMS will leave behind a Condition Code = 0. If the file does not exist, then IDCAMS will sign off with a return Code > 0.

Since, I do have a file called AGY0157.DEMO.FILE, IDCAMS will print a description about the file to the log. The Log shows various details – like the catalog in which the file's entry is present, when the file was created, the file’s location(On which volume the file resides?) etc.

Upon scrolling down to the bottom of the log, you would find that, IDCAMS has left a trail – the condition code is set to 0.

Q. Wait a minute, you are asking me to use LISTCAT command, just to know if the file’s availability. In TSO/ISPF, I would just navigate to Dataset List Menu 3.4, and perform a simple search to check availability. What’s the difference?

That’s a good question, why use LISTCAT Command, when you can just use Dataset List Menu 3.4. Let me set things straight. The Dataset List Menu 3.4 is an ISPF Screen, where you type the name of the file, and press <ENTER>, you get the list of files, and details(description) about them.

Actually, Dataset List Menu 3.4 is just a GUI Front-end or screen. It presents a nice, friendly user-interface for checking the availability of a file. In background, there is a ready-made template JCL. The file-name you typed on the 3.4 screen is substituted in this template JCL. This template JCL, uses LISTCAT command to find infomation from the catalog. This template JCL is ready-made, you don’t have to write it. When you press <ENTER>, this template Job is submitted to the MVS Operating System. After the job completes, the results of this job, are populated on the ISPF Screen.

Using the TSO/ISPF Menu 3.4, is equivalent to submitting a job in background which uses LISTCAT command to query the Catalog, and check the availability of the file.

In fact, just to let you guys know, behind every ISPF Menu screen, there is a corresponding skeleton or template JCL that runs in the background. ISPF Screen is just a presentation layer, a front-end.

Q. Well that sounds good in theory. Is the LISTCAT command used in real production environment, in projects?

In most projects/sites, there is a complex relationship amongst systems. As an example, suppose there are two Jobs(systems) 1 and 2. Suppose, the JOB 1 produces an Output file. This Output file is fed as Input to JOB 2. In other words, the Job1 is the feeder system of Job 2. Generally in projects, they would express this fact as, Job 2 has a dependency on Job 1.

Suppose Job 2 has been scheduled to run at 12 o'clock. Remember, that Job 2 expects to pick up a file, which Job 1 will produce as Output. If this file is not available by 12 o'clock, when the Job 2 is about to start, the Job 2 will fail(abnormally end) or abend.

Many-a-times, Job 1 gets delayed, and does not make it within the cut-off time - 12 o'clock. In this unfortunate situation, Job 2 abends(fails). How could you prevent this incident?

You could add a condition to the Job 2, to first check if the file is available. Provided the file is available, the Job 2 should process it. If the file is not yet available, the Job 2 should bypass it, avoid processing it. Take a look at the JCL, I have written below -

Here, I have used LISTCAT command to check the availability of the file AGY0157.DEMO.FILE. If the file exists, the step //CHECK01 leaves behind a condition code=0. If the file is not available, I set the
MAX Condition Code = 4. The next step //PROCESS will execute if, the condition code of //CHECK01 is 0. If the condition code of //CHECK01 is 4, meaning the file is not available, the next step //PROCESS is bypassed. The job will however not fail or abend.

Submitting Job

2010-02-12T01:13:00.001+05:30

Q. How do you submit a Job on Mainframes for execution?

On Mainframes, when you want to perform any task, you write a Job, and give it to the Mainframe Computer for processing. This is called submitting a job.

However, contrary to what you might fancy, your job doesn’t run immediately. Picture this - there are hundreds and thousands of Jobs, that are submitted on a Mainframe, minute-by-minute, every second, by different folks. How would the Mainframe computer decide which job goes first, and then which goes next and so on..

The MVS Operating System prepares a pretty time-table, a schedule, that goes something like this - JOB 1 runs at 12 o’ clock, JOB 2 runs at 1 o’ clock, JOB 3 runs at 2 o’ clock and so on.. Thus every job is allotted a time-slot(period) in the Mainframe's Calendar/time-table.

To submit a JOB on Mainframes, you must type SUBMIT command or just SUB, on the command line of the editor. I have shown below, how you submit a job on Mainframes.

When you press <Enter>, the Job AGY015A gets submitted to the Mainframe computer for processing. This is indicated by a *** message displayed at the bottom of the screen. The *** indicates, that TSO is waiting for me to read the message. As soon as you press <Enter> key again, the message goes away.

A common practise adopted by most Mainframe Programmers, is to code the NOTIFY parameter on the JOB Statement. Coding this parameter is quite useful, as it gives you an alert, a notification message, saying "The job AGY0157A has completed".

Q. How do you see the Job Print Output in TSO/ISPF?

I submitted the simple 3-Step JCL, by typing the SUBMIT command. Shortly after, MVS also alerted me, by sending a message, that my job AGY0157A completed.

But, I don’t know for sure, whether my job completed successfully, or it failed(and the reason why it failed). MVS Operating System prints messages to a log, as the job is processed. These run-time messages which get recorded to the log, helps track, if the Job completed successfully or it failed. Further, they also contain error-messages that point out why the job fails.

To see the print output/log of any Batch Job, you use a software called SDSF. SDSF stands for Spooler Display and Search Facility – its a software for seeing the output in the Spool.

What is Spool? Well, generally, the log of a Job, when it runs on Mainframes, are to be sent to a printer. But prior to sending the log to the printer, the logs have to wait(buffered) in a staging area(in a queue), because hundreds of jobs complete every minute, and the logs gotta be printed. Not all logs can be printed at once. The logs have to wait in a Queue/staging area. This staging area is called Spool(Queue). The Mainframe printer will pick up the log from the spool one-by-one and print it.

Before TSO and SDSF was invented, you couldn’t see the output till the time, it got printed. Waiting for it to get printed, could take hours on end. Now-a-days, TSO makes this easy, it’s possible to view the logs in the Spool(Queue).

To view the log of a Job in the Spool(Queue), type START SDSF and press <Enter>. This shows the shows the SDSF Screen. To see the log of Job, you must type ST on the SDSF menu and press <Enter>.

A list of the logs for all jobs in Spool(Output Queue) is displayed. By default, this list will displayed only those jobs submitted via your
TSO User-id. For example, if my TSO User-id is AGY0157, it will display all jobs starting with(prefix) AGY0157*.

The screen displays a list of logs of all jobs, you have submitted. For each job that you submit, there is an entry, and it shows various details like the job-name, owner, class and priority.

If your job is complete, and its log is ready to be dispatched to the printer, the log is on the PRINT Queue. On the other hand, if the job is still running, then it is still in the EXECUTION Queue.

Mostly, all jobs that you submit, their logs would be dumped here in the Spool. To view the contents any particular job log, you can type ? against the job=name and press <Enter>. This takes you inside the log.

The log(print output) of a job, contains several sections. You can type S(Show) against each section, and view the contents of it.

The Input Queue and Output Queue are analogous to the run-ways on an Airport. The Input Queue is runway from where the Jobs take-off. After their flight is complete, the jobs land on the runway called the Output Queue.But who's the Air Traffic Controller(ATC) on this Airport?

The JES(Job Entry Sub-System) is a software that manages the Input Queue and Output Queue. The JES acts like Traffic Controllers(Traffic cops). Without them, two airplanes or jobs could collide. The JES is a part of the MVS Operating System that decides, what time a job can takeoff safely from the Input Queue(Takeoff runway). Thus, it monitors the traffic in the Input Queue(Runway) and prepares the time-table, a chart or a schedule for Jobs entering the system.

On the Input Queue side, the JES(Job Entry Subsystem) welcomes all Jobs that enter into the Input Queue, reads the Jobs' JCL, converts it into an internal format known to MVS, and schedules the job for takeoff at 2 o’clock or 3 o’clock, till the Job takes off, and begins its flight(execution).

Sometimes, on the Output Queue(Staging area) side contains logs(outputs) of old jobs. Such old logs(print outputs) of a job, are deleted from time-to-time periodically by JES. So, JES ensures that the Output Queue clean and tidy.

The JES Message Log contains the following messages -

The Job Entry Subsystem(JES) reads the Job’s JCL Statements. My Job had 24 lines of JCL Code, so JES reports this as 24 cards read.

Once the job takes off from the Input Queue, it executes, and lands at Output Queue. The log(print output) of Job, is referred as SYSOUT. This contains 125 lines of text. JES reports this as 125 SYSOUT Print records. This implies, the log(print output) of the job, contains 125 lines of text, in the Output Queue(Staging area), waiting to get printed.

MVS numbers the JCL Statements that you submitted as part of the job.

ALLOC tells you which devices and how much memory was allocated for the job-step. As you know, one step runs one program. It also informs you about the CPU time required to process a Job-step. Every Job-step leaves behind a trail, a COND CODE in the range of 0000 to 4095.

But apart from this , when you want to write your own extra notes to the logs(diary), you code a SYSOUT=* parameter on the DD Statement. For the 3-step job-stream that I have written, I have set the //SYSUT2 DD statement to point to the logs. This means that, the outputs of //STEP01 and //STEP03 shall be jotted down in the logs. The first step prints/copies the contents of the Unsorted Input file to the log. The second step

These are the contents of the Unsorted Input File, written to the log -

These are the contents of the Sorted Output, written to the log -

Multi-step Job Streams

2010-02-01T07:48:00.001+05:30

Q. Can Job run just one program? What if I want the output of one program, to be fed as input to a second program?

Yes, your intuition is absolutely correct. A job can have many(multiple) steps, each step runs a program. The output of 1st step can be fed to the 2nd step, the output of 2nd step can be fed to the 3rd step and so on..

You already know the general pattern of any Job. It has a JOB statement at the beginning that describes the job, EXEC to run the program, followed by DD Statements that represent the files/datasets, from which the program accesses data. It looks like this -

//name	JOB	parameters
//name	EXEC	parameters
//name	DD	parameters..
//name	DD	parameters..
//name	DD	parameters..

The above was a very simple, single-step Job. However, in most production environments in real Projects, a Job has multiple steps. Each step runs a program, that reads input data, processes it, and produces some output. Thus, typically the job would be a stream, a inter-linked chain of several steps.

The best way to understand a multi-step job-stream is to think of an Indian railways train.

The JOB Statement is the locomotive engine. Each program to run is inside a train compartment, and the last bogie/compartment would be null card – indicating the end of the JOB Train.

In this job train, each step runs a program, that receives input feed from the preceding step(step before that), processes it, and gives an output, which is fed to the next succeeding step. This way, the data is processed step-by-step, and you arrive at the final output, once the last step is complete.

Q. Vow, that was fun! Tell me more about these multi-step jobs.

Well, to learn more about multi-step jobs, you need to take some existing jobs and analyse them, how they work. This would give you a far better view of how multi-step jobs work.

But, first to understand any multi-step job, you need to know how to draw JCL flow-charts.

I am going to take a 3-step job, for the sake of example. I have given the skeleton of this 3-step job below.

If you can graphically draw what a JCL would do(does), it helps a lot to understand the JCL. Now, each step is gonna read one/more datasets, do some processing, and produce reports and write output to one/more datasets. First let me draw a simple diagram for the above JCL Skeleton.

Now, you can enrich this basic diagram by adding some more flowchart symbols, as shown below -

You must be familiar with flowcharting symbols such as decision-box and loop statements. However, understand that JCL is not a programming language, and hence you do not have such symbols out here.

Q. Often, I see a lot of these DD * and DD DUMMY Statements. Could you just give me a crash course, before telling me more about job-streams?

Before you proceed ahead, here’s a crash course on two parameters that you often code on DD Statement – * and DUMMY.

1. DD * - What if you wanted to give special commands(instructions), to IEBGENER. Like "Copy only those employee records whose name starts with A". Note, that this is not data, so you don’t supply it in a file. These are commands, or instructions(orders) to IEBGENER telling it what records to copy. Such direct commands or instructions to the EXEC PGM program, that influence(control) the way the PGM works are called Control Instructions.

Usually, the custom adopted is to hard-code(or embed) the control instructions in the body of the JCL itself(instead of putting them in a separate file). When you want to directly hard-code any stuff in JCL, you must use *(wild-card) as a parameter on the DD Statement.

//name DD *
Control instruction 1 -
Control instruction 2 -
...
/*

You indicate the end of the control instructions by putting /* statement.

2. DD DUMMY – What if you wanted to shut off the input fed to a particular Program. As an example, you don’t want to supply any input data file to IEBGENER. Shutting off input or output isn’t that easy, because IEBGENER would expect you to write //SYSUT1 DD Statement. Omitting //SYSUT1 isn’t an option(that would be a JCL Error). You can’t do away with it, just like that. So, you code a DUMMY parameter on the DD Statement. DUMMY implies, that this is just a DUMMY input or output file. In other words, that input/output feed is shut off(you have just sealed it off!).

DD * and DD DUMMY should come in handy while understanding a complete job-stream.

Q. Can you put together piece-by-piece, how the flow of a 3-step job looks like?

Alright friends, we shall go about it like this. We are first going to construct (pieces)blocks one-by-one, and them put them all together, assemble them to build a complete job.

The toy job shown here does the following
1. STEP01 – Read EMPLOYEE Data stored in a disk file(AGY0157.EMPLOYEE.INPUT) and print a list of all employees to the log for information purposes.
2. STEP02 - Arrange the records of the EMPLOYEE Data file in alphabetical order i.e. sort the EMPLOYEEs data
3. STEP03 – Print a report of the sorted output EMPLOYEE Data to the logs.

The first Step01 of the toy job, runs IEBGENER.
a) IEBGENER expects to read the input file at //SYSUT1 DD Statement.
b) IEBGENER copies the contents, and prints it to the dataset represented by //SYSUT2 DD Statement. We would like the input file’s contents are printed to the log just for informative purposes(so it helps tracking), //SYSUT2 file must point to the log(code the parameter SYSOUT=*).
c) IEBGENER expects to receive control instructions, at the //SYSIN DD Statement. Since, we are not gonna issue any control instruction, and want this functionality turned off, you can code a DUMMY parameter on the //SYSIN DD Statement.
d) Also, MVS Operating System, expects to write messages about the execution of the program at the dataset represented by //SYSPRINT DD Statement. Usually, you would want these messages to be printed to the log, so I would code SYSOUT=* as a parameter on the //SYSPRINT DD Card.

Okay, with that background, let me show you the JCL for the first step STEP01.

The second step STEP02 of the toy job, runs SORT. Essentially, SORT utility takes the input file records, and arranges them in order(in sequence), ascending or descending.

1. SORT pgm. expects to reads records from the //SORTIN DD Statement. The //SORTIN DD Statement points to the File – AGY0157.INPUT.DATA.
2. SORT Pgm. sorts the input records in this file, as per the special control instructions(commands) that are supplied in the //SYSIN DD statement. I have instructed/commanded SORT Pgm, to apply sort on the field starting from columns 1 to 4, the data must be treated as a textual string(Character), and it should be sorted in ascending order(A).
SORT FIELDS=(1,4,CH,A)

For your reference, the input file’s records are shown below.

3. SORT Pgm. writes the sorted(ordered) output to the file represented by the //SORTOUT DD Statement. Here, I’ve created a new file, to which the sorted output records are written. This is one of the most difficult category of DD Statements to compose. Instead of specifying an actual output file-name, the &&OUTPUT on the SYSOUT DD Statement indicates a temporary file. This temporary output file, will be deleted, after the job completes.

4. Once again, the MVS Operating System, generates a report at how the SORT PGM ran, at //SYSOUT DD Statement. We would write this messages to log, by coding SYSOUT=* Parameter.

The third step STEP03 of the toy job, runs IEBGENER, a second time.
1. IEBGENER reads the input from the //SYSUT1 file – this is temporary output file &&OUTPUT containing the Sorted Output Records from the preceding Step STEP02. Thus, temp output file of the previous step is picked up as input for the next step.

2. IEBGENER copies these sorted records from the temporary file, to the //SYSUT2 DD File. The //SYSUT2 DD Statement points to the log - SYSOUT=*. Thus, the list of sorted records are written to the log.

3. Since, I have not given any special commands or instructions to IEBGENER, I have turned off the //SYSIN DD functionality, by coding DUMMY Parameter on it.

4. The report generated MVS about the execution of IEBGENER, is written to the file represented by //SYSPRINT DD Statement. I have set //SYSPRINT DD to point to the log(SYSOUT=*). As a consequence, the Status Report of MVS, of how the IEBGENER PGM ran, is printed to the log.

The crux of this entire job-stream is -
- It picks up unsorted,un-arranged input records from the file AGY0157.INPUT.DATA.
- It sorts, arranges the data in ascending order, on the key field from
cols 1-4.
- It writes the sorted, ordered output records to the Log.

Putting it all together, and assembling, the below flow-diagram gives a gist of the entire job-stream.

Basic Framework of JCL

2010-01-22T12:30:00.001+05:30

Q. My head’s spinning around the 3 JCL Statements : JOB, EXEC and DD. Could you tell me something more about them?

So, you’ve got the gist of the concept behind JCL, all the JCL that you going to write from hereon, maybe for the next 10-20 years, would be composed of three main statements :

//name	JOB	parameters...
//name	EXEC	parameters...
//name	DD	parameters...

Each of this JCL Statements have a label – a symbolic name assigned to them. Its like naming kids. Well, there could be so many boys in your area, but how do distinguish them? Of course, by their names.

In the same way, a JCL may contain a bunch of DD Statements, one for Input file, one for the output file, one for the error file. How do you tell them apart, by naming them. As a good practice, we always give names to all our JCL Statements. Names kinda help you to refer back to these statements in the future. You want to point out a particular JCL Statement to your friend, just spell out its name.

But, notice carefully, each label(name) is preceded with two slashes //. The two slashes are a JCL Statement’s signature. They indicate that the statement is a JCL Statement(one of JOB, EXEC, DD). Every JCL Statement wear the two slashes //. A naked statement without // won’t be treated as a JCL Statement.

Now, every JOB, EXEC and DD Statement has got these whole lot of parameters. What you’ll be learning throughout these tutorials is mostly the parameters. Parameters add stuff and meaning to the JCL Statement.

Now, let me give you a booster, that’s going to help you organise the way you think about this JCL.

- JCL is made up of mainly JOB, EXEC and DD.
- JOB is easy to learn and use.
- EXEC is easy and fun to use.
- DD Statements take three forms
   1. DD Statements to read a file.(easy)
   2. DD Statements to write to the logs.(easy)
   3. DD Statements to create a new file(hard!); you’d have to learn parameters such as DISP, UNIT, DCB, SPACE and several others to code this.

Have a good look at this chart :

Q. Let’s set this straight. You’ve got to give me an overview of the JOB Statement.

You code the JOB Statement at the start of any JCL you write. It tells the MVS Operating system, who’s the guy requesting the program to be sent to MVS for execution, where MVS should send the print output, how much reporting(level of detail) should MVS provide, and how important is the Job as opposed to other competing jobs.

You can even indicate things like memory and processing time limits on the JOB Statement.

You write the JOB statement starting with a name, which becomes the JOB Name. JOB Names are a big deal, because MVS keeps track of thousands of Jobs using Job Names.

The most general form of the JOB Statement is this :
//AGY0157A JOB ...other parameters

As a programmer or developer, when you code some jobs for executing the programs that you’ve written, the job-name that follows the slashes, is your TSO-userid followed by a single letter. Like my TSO-userid happens to be AGY0157, so I’ve coded the job-name as AGY0157A. By doing so, anyone who happens to look at these jobs will deduce, all Jobs of the format AGY0157* belong to(are owned by) the TSO User-id AGY0157. It becomes so much each easier to trace back/revert back to the owner. God forbidding, should your job fail for some reason, the operator can immediately find out, to whom the job belongs and contact the respective owner.

The content of your JOB Statement usually very stable. Once, you have established a JOB Statement, you can use it for most of your work. Sometimes, your project leader or client Manager may give you an account-number to use, so that the resources used to run your job, maybe charged to an appropriate account.(The example, I have written is going to use the Account-no A123)

You are going to use other parameters like CLASS, MSGCLASS, MSGLEVEL, NOTIFY, REGION, TIME, and PRTY in you JOB Statements. Hey wait, don’t hit on the gas right now, hold on for a while, I am going to discuss the JOB Statement at length in the next tutorial.

In the figure below, I’ve reproduced the JCL, I wrote to copy one file to another using IEBGENER Utility program. Notice, the two different styles of coding the parameters. You can code just one parameter on each line to make it more readable.

(a) You can code JCL with a compact JOB Statement and put several parameters on the same line (b) An easier to read-style, is to code one parameter on each line, leaving room for comments.

Q. Could you give me a brief idea about EXEC Statement too..?

The EXEC Statement is the engine of your JOB. The EXEC statement tells the MVS, which program to run. So, you use EXEC JCL Statement, to announce to the MVS, which program, you want to run.

//STEP01 EXEC PGM=IEBGENER

Like any other JCL Statement, you write the EXEC Statement starting with two slashes //. You assign a name/label to the EXEC Statement, for unique identification like STEP01, which is called Step-name.

Let us make no mistake in understanding that -
1. The step-name is just a name given to the EXEC Statement. The step-name could be omitted as well. However, its always good to name all your EXEC steps, so that you can always refer back to step later. This would count a lot, pretty important stuff, when you write multi-step jobs.

2. AS Shakespeare has said, what’s in a name? A step-name is just a name given to the EXEC Step. The name could be possibly anything at all, it doesn’t need to always start with //STEP prefix. You could also name your step as //QUASAR or //BARABARA or //COPYSTEP or any name of your choice. But most people would use a step-name which is meaningful, and conveys the meaning of the step.

3. The executable program that you want to run, should be specified after PGM.

You can code a lot of extra things on the EXEC Statement, such as REGION, TIME, COND, PARM and ACCT. I’ll give many more inputs to my readers, about these extra parameters, as you progress through the tutorials.

In the above JCL, to copy the contents of a file to another file, using IEBGENER, when you take a glance at the JOB Statement, you would find that I’ve coded REGION and TIME Parameters on the JOB Statement. REGION and TIME specify memory space limit and time limit on the JOB. But guess what, if you code the REGION and TIME Parameter on the EXEC Statement, that allows you to specify a memory limit and time limit for that program or step only.

Q. Could you give me a brief overview of how DD Statement refers to files?

A program executed at a step can access zero, one or more Files(Datasets). For each dataset, the program accesses, you must code a DD Statement.

MVS frees and relieves the programmer/developer, from having to know the actual(real) name of the file, and other details about the files, while writing a COBOL or PL/I Program. The programmer is unaware of the real file. Instead in COBOL, he refers to the input file(s) and output file(s) only by their symbolic DD-names. COBOL Program refers to files by their smbolic dd-names. It is through the DD Statement in JCL, that assign actual physical files to these symbolic dd-names. Thus, the dd-names serve as an indirect reference to the actual file.

How symbolic dd-names are associated with actual, physical files, is explained in the diagram below.

The COBOL Program refers to the files as INPUT-FILE and OUTPUT-FILE. In the JCL, you specify the actual(real) files in the DD-Statement, AGY0157.INPUT.DATA and AGY0157.OUTPUT.DATA. The common connecting link/bridge between them is the dd-name INPUTDD and OUTPUTDD.

In the COBOL Program, the INPUT-FILE and OUTPUT-FILE shall represent the file whose dd-names are INPUTDD and OUTPUTDD. In the Job JCL, the ddnames //INPUTDD and //OUTPUTDD are set to point to the files AGY0157.INPUT.DATA and AGY0157.OUTPUT.DATA. Thus, this helps establish a relationship. Thus, the COBOL Programmer and the one who writes the JOB; there should be common agreement amongst them, with regards to the dd-names. If the COBOL program expects an input file, with dd-name INPUTDD, which is not supplied in the JCL, this would be a JCL-Error.

The same applies to the IBM-supplied Utility programs like IEBGENER, SORT, IEBCOPY etc. The developers of IEBGENER assumed dd-name of input file as SYSUT1, and output file as SYSUT2. The //SYSUT1 and //SYSUT2 DD Statements must appear in your JCL. Thus, for built-in IBM Utility programs, there are some pre-defined dd-names, which you have to stick to.

Q. Could you give me a short description of the 3 different types of DD-Statements?

As I mentioned before, the 3 general categories of DD Statements are :
1. A DD Statement for reading a file/dataset
2. A DD Statement for recording/writing to the log(diary). MVS operating System keeps a log, a diary of notes of how each job ran, whether it was successful or a failure. With this DD Statement, you can scribble and write anything you wish to the log
3. A DD Statement for creating a new dataset, and writing to the file(dataset).

Let me explain this, with a concrete example -

Reading a file or Dataset
The IEBGENER program expects to read the records from the Input file at the //SYSUT1 DD Statement. There’s nothing much to it, DD statement for reading records from an Input file is damn easy.

Creating a new Dataset, and writing records to it(Hard!!)
The IEBGENER program expects to write the records to the output file at the //SYSUT2 DD Statement. To create a new file/dataset in JCL, as you can observe, you need to code a lot of extra parameters like SPACE, UNIT, DCB etc.

Writing to the log
To make note in the logs(diary), to write any text to the logs, you code a parameter on the DD Statement called SYSOUT=*. Logs are indicated by coding the parameter SYSOUT=* on the DD Statement.

While running your job, ,MVS keeps prepares a status report about how your program is running, its status, whether it succeeded or failed. Thus, this status report report messages are important, because they tell you whether the Job ran fine.

The MVS OS expects to write status report messages to the output file at //SYSPRINT DD Statement. By coding the SYSOUT=* parameter on //SYSPRINT DD statement, you redirect all MVS Messages to be recorded in the logs.

The Structure of JCL

2010-01-21T10:02:00.001+05:30

Q. What is Job Control Language?

Job Control Language(JCL) is used to tell the computer what programs to run, which files these programs will use, to read input data and write output data.

Mainframes are different from your Windows PC, where you give an input command, and the computer produces some output, then you give some more input, the computer produces another output and so on, this interactive input-process-output cycle continues, until all the processing is done and your task is completed. On the Windows PC, programs run in an online interactive mode. Generally there is only 1 user to a PC, and it provides immediate response(output) to a user Input.

On the other hand, millions of people send request, feed inputs to a Mainframe. Thus, Mainframes don’t like to talk to people interactively. Instead, Mainframes process your data in Batch Mode.

Batch Mode means, that you need to tell the Mainframe, right at the start, what is the program you want to run, in which file the input data is stored, what will be the output files, everything right at the beginning, even before the Mainframe starts with your task. Specify the program, the input source files, the output destination files, before the program commences to run.

Once the Mainframe knows all the details about your task – Program to be run, Input files, Output files(to store results), error files etc., it accepts the task. The task may take an indefinite amount of time to complete, the Mainframe schedules the task for a particular time, depending on which time-slot is available. Just like you, there would be millions of other guys, whose tasks have to be completed. On Mainframes, you would not get immediate output results(immediate service) on the spur of the moment(on the go). Instead, the Mainframe performs the task as per its convenience, and notifies you, alerts you, once your task is completed.

Q. Isn’t TSO/ISPF interactive? I give some input, and it immediately displays some output screen.

You might be tempted to think so, because you used TSO to deal interactively with a Mainframe via a 3270 terminal or PC. However, what you need to realize, is that, TSO itself is a program that’s being run on the Mainframe. It’s actually a Giant Word-Processor, that lets you key in(type in) your programs and Job Control Language into the computer. It actually converts your programs and JCL, into machine-readable form, an internal format which the MVS Operating System can understand. Thus, TSO is just a messenger/carrier to the MVS Operating System.

If you want to talk to the MVS Operating System, your messages, instructions or commands must be in a language called Job Control Language(JCL). JCL is the only way to talk and give instructions to the MVS Operating System!

Q. How does JCL execute Programs?

A Program is sequence of instructions to the computer, that performs some task/function. A Program is usually written in a High-Level language like Assembler, COBOL, PL/I, C, C++, Java etc. Your program statements are then translated into binary machine language, which IBM Mainframes understand. These machine language programs are stored as members in Partitioned datasets. The Partitioned Dataset(PDS), whose members are Machine Language Programs is called Load Module Library, and each such binary program, or member is called Load Module.

To execute a program, you specify which Load Module, and load library in the JCL.

Q. How does MVS Operating System think about Programs?

MVS Operating system doesn’t know about the internals of your COBOL Program. It simply looks at it as a Black-box, which expects some inputs and produces some outputs(without bothering about what’s there inside the box).

Just as you write your own COBOL Programs, to perform some tasks, IBM provides some pre-written ready-made programs, that you can directly lift and use in order to perform some common, basic functionalities. For example, when YOU want to create a copy of a file, you want to sort the contents of a file, there are ready-made programs supplied by IBM, which can do these tasks for you. Such pre-written, ready-to-use programs shipped along with Mainframe computers are called Utility Programs.

One of the ready-made utility programs provided by IBM is IEBGENER. IEBGENER is used to copy the contents of one file to another. It basically creates a shadow copy of a file.

All COBOL programs(whether your own program, or pre-written & ready-made utility) refer to the input and output files that they access, not by the actual(physical) file name, but using a short symbolic name. The short (alias) symbolic name merely refers to the actual file name values. Through JCL, you will be attaching the actual physical file-names to the symbols.

The IBM Utility – IEBGENER expects 4 files :
Symbolic file name     Description
1. SYSUT1              Where IEBGENER expects to read Input Data
2. SYSUT2              Where IEBGENER expects to write Output Data
3. SYSIN               Where IEBGENER expects to receive any special and optional instructions
4. SYSPRINT            Where IEBGENER expects to write a simple report, about the task it’s done for you, whether it got completed successfully or not, and much more.

Thus, IEBGENER reads input from //SYSUT1 file, and copies it to //SYSUT2 file. It is a simple copy utility.

Q. What are the different statement types in JCL?

JCL is very simple and easy to master. There are only eight different JCL statement Types. JCL is is actually a piece of cake, because you use only three of these JCL statements most often – JOB, EXEC and DD.

You’ll use these very often!

//name	JOB	parameters ...
//name	EXEC	parameters ...
//name	DD	parameters ...

You’ll use these to “gift-wrap” and pack your JCLs into PROCs

//name	PROC	parameters ...
//name	PEND	parameters ...

These are [optional] -

//*	comment
/*	delimiter
//	null ending statement

Now, I shall focus mostly on the 3 important statement types – JOB, EXEC and DD first, so that you can start to write JCL’s and become productive soon. In the later course of this tutorial, I shall also explain to you how to pack JCLs into Procedures using PROC and PEND.

The next figure shows how I use JOB, EXEC and DD Statements to copy a file using IEBGENER Program. Below you shall find a stripped down, bare-bones version of the same.

General format:

//AGY0157A	JOB	parameters..
//*
//STEP01	EXEC	parameters..
//SYSUT1	DD	parameters..
//SYSUT2	DD	parameters..
//SYSPRINT	DD	parameters..
//SYSIN	DD	parameters..
//

I hope you recognized this pattern – JOB, EXEC followed by one or more DD Statements. The JCL for all you Batch Jobs will start with one JOB Statement. Following this, the EXEC statement tells which program to run. And, then you code several DD(Data Device) statements, for specifying the input and output files being used by the program. The DD Statement, would assign a symbolic name to an actual dataset name.

Given below is the JCL that executes the IEBGENER Program to copy the contents of the Physical sequential(PS) file AGY0157.INPUT.DATA to AGY0157.OUTPUT.DATA.

Mainframe Information Representation and Storage

2010-01-16T01:50:00.001+05:30

Q. How do Mainframe Computers store Data?

On computers, data is stored in the form of bits - 0’s and 1’s(binary). Characters like A,B,C,...,Z are formed with 8 bits called as Bytes. When you press a key on the keyboard, the key emits out eight bits from the cable.

Every key is represented with a unique combination of 0s and 1s. Because, we use 8 bits to store a character, a total of 2^8 = 256 patterns are possible. IBM Mainframe’s designers assigned a unique 8-bit pattern to each character. This scheme of representing characters and data in Mainframe Computers is called Extended Binary Coded Decimal Interchange Code(EBCDIC).

Q. What are Fields, Records, Files and Datasets?

Data such as Customer Name, Customer Address, Phone-numbers are nothing but, just a sequence or group of characters. A group of characters that represent a data-item is called a Field. For example, Customer-name is one field, Customer Address is another such field and so on.

When you group fields like Customer’s name, address and phone-number together, to represent all the information about 1 single customer, it is called a Record. A record can contain of any number of fields. Thus, you can have a record which 100 bytes long, 200 bytes long,..., but records of length 80-byte are common in Mainframes, as in early, input data was fed to Mainframes using Punched Cards which had 80-columns.

When you store a group of records, say 1000 customer records of a Bank, it is called a File. A File is then, just a sequence of records.

IBM Mainframes use the term Dataset instead of File.

Generally, Datasets(Files) are stored on Computer Storage Devices. In Mainframes, there are two popular storage devices – Disk and Tape.

INFORMATION STORAGE HIERARCHY

Q. How do you form Dataset Names?

In a Mainframe computer, there would be thousands of files(datasets). It is obvious, to name each Dataset differently. Mainframes support very large dataset names. In Mainframes, a dataset name can be 44 characters long in this format :
XXXXXXXX.XXXXXXXX.XXXXXXXX.XXXXXXXX.XXXXXXXX

You can form a dataset name by taking groups of upto 8 characters. Each of the group must start with a capital letter(alphabet).

Generally, it is a good practice to give meaningful names to your dataset. For example, if you are storing Employees data in a file, you can name it as EMPLOYEE.DATA

The MVS Operating System keeps track of groups of datasets by referring to their names, which are called Qualifiers. The first part of the dataset name is called High-level Qualifier(HLQ).

Generally, when you access or log-in to Mainframes, you are given a USER-ID, just as on Windows PC, you need a userid to login. Most professionals or software engineers who work in Mainframe Projects would have a TSO user-ID. When you use a TSO-id, a special requirement applies to most datasets(files) that belong to you.

Suppose your TSO-id is AGY0157, then all your datasets should have the High-level qualifier AGY0157. Thus, the files that belong to you should start with AGY0157. For example, the name of Employees file would be

AGY0157.EMPLOYEE.DATA

You must understand that, mostly in projects, you can identify the files that belong to you, your application or your system by seeing the High-level Qualifier.

In fact, Mainframes are also installed with Security Software(like RACF), that controls access to files by seeing the High-Level Qualifiers. Thus, although you can see your buddy’s files on a Mainframe, you cannot make any changes to it.

Q. What are Sequential Datasets?

You can think of sequential datasets as a Music cassette, on which music songs are stored one after the other. When you play the cassette, you listen to the music, one song and then the next song and so on.. till you reach the end of the cassette. You cannot directly jump to, or fly to the 5th song, or last song. Thus, a music cassette is accessed sequentially.

On the same lines, records in Sequential files are stored after the other in a series. In a sequential file, you need to read through all the records one by one, step-by-step till you reach the desired record.

Thus, a sequential dataset is the simplest form of dataset. In Mainframes MVS Operating System, sequential dataset is known as PS Dataset, PS stands for Physical Sequential.

Q. How do you create a file in ISPF?

ISPF organises most common functionalities that you need to perform on Mainframes – like creating a new file/folder, editing a file, searching for files, taking backup etc. in the form of menus, just like a Nokia Cellular Phone.

To create a new file, you have to go to the menu 3.2 in ISPF. You enter the dataset name here on ISPF Screen.

Q. What is a Partitioned Dataset(PDS)?

When you create a sequential dataset(PS), it occupies a large amount of storage space(minimum 50,000 bytes). Sometimes for doing trivial tasks, storing only a few records, you would not be utilising the entire space available in a sequential file. Thus most of the space in the Sequential file is wasted and is blocked.

IBM provides a way to split or partition up the space in a sequential data-set. IBM Software engineers invented the Partitioned Dataset, often called PDS. Each part is called a Member. A Partitioned Dataset can have many members(parts). Each member behaves like a sequential file on it own.

How does the PDS then keep track of its members? A Partitioned Dataset(PDS) includes a directory(like a telephone directory), which is a diary or journal, where MVS Operating system keeps track of the members in a PDS. The members of a PDS can be scattered haphazardly anywhere in the vast computer storage space. Well-then, you consult the directory to find out the members in the PDS. Just like in a book, the index tells you, the keyword you are looking for, and the page no. where it can be found, the same way, the directory tells you the member name, and the computer memory address where you can find it. Thus, the directory maintains the list of member-names and pointers to the actual physical place in Computer Memory where they are stored.

Not just this, but the directory also keeps track of its statistics, like when each member was created, when was it last changed/viewed by somebody, how much space it occupies, which TSO-userid created it and bla bla..

On the Windows Operating System, we generally keep related files together in a folder. On the same lines, you keep related members together in one PDS. Thus, a Partitioned Dataset is Mainframes-counterpart of Folders on Windows Operating System. Folders contain many related files. A PDS contains many related members.

When create this special type of partitioned sequential file – Partitioned Dataset, you need to decide, how big its directory is going to be. The bigger the directory, the more no. of partitions(members) it will support. You express this in terms of Directory Blocks. Generally, 1 directory block can store information about 5 members. The directory always remains fixed, can’t grow bigger on the fly, so you need to careful when specifying the directory blocks, and you have to do it in advance.

To sum up, a Partitioned Dataset(PDS) is a specialised type of sequential file, which is divided into members, each member being a sequential dataset by itself. Thus, a PDS acts like a library which houses several related files.

Q. While creating a new file in ISPF, how do I specify whether is Sequential file(PS), or a Partitioned Dataset(PDS)?

A sequential PS File doesn’t have any partitions or members(0 members). So, it doesn’t have a directory to look upto. Thus, the space allocated to a directory, in terms of Directory Blocks for a Sequential PS File is 0.

On the other hand, for Partitioned Dataset(PDS), it can contain 1 or more members. So, it needs a directory to record the whereabouts(location) of its members, which are scattered throughout the memory randomly. You need to allocate space in terms of Directory Blocks to a Directory in Partitioned Dataset(PDS). Thus, Directory Blocks for a PDS should be some finite number, say 5 blocks, or 10 blocks.

Suppose you are creating a new File AGY0157.EMPLOYEE.DATA. You specify the Directory Blocks on the ISPF Menu 3.2 screen, as follows -

1. If you want the file AGY0157.EMPLOYEE.DATA to be a Physical Sequential File(PS), then fill the Directory Blocks field = 0.

2. On the other hand, if you want the file AGY0157.EMPLOYEE.DATA to be a Partitioned Dataset(PDS), having 1 or many members, and a directory, specify Directory Blocks field = 1,2,3 or ...(any finite value) blocks. In the figure below, I have put Directory Blocks = 5 Blocks.

Q. How do I find the file I want on Mainframes? How do you find/list files in ISPF?

You want to search and locate a file. Finding the file on MVS Operating System is done using, ISPF Menu 3.4, called Dataset List Utility. Go to ISPF Menu 3.4 screen, and type the name of the dataset that you want to search and hit Ctrl.

For example, if you want to search for the file AGY0157.EMPLOYEE.DATA, then type AGY0157.EMPLOYEE.DATA in Dsname field.

Upon hitting the Ctrl button, you would find list of files displayed before. Note that, Dataset List Utility(DSLIST) works by searching for all files that match a pattern. So, when you type AGY0157.EMPLOYEE.DATA, what you actually specify is a pattern.

All files matching this pattern will be displayed. So, if there is a file – AGY0157.EMPLOYEE.DATA.MASTER, it also matches the pattern. Thus, it will also be listed.

In fact, if you don’t know the exact name of your file, you can just specify the pattern followed by a wild-card. Say, for example, if you want to search for all the files starting with AGY0157.DEMO.something, then you can specify it as AGY0157.DEMO.*

When you hit Ctrl, you would get the list of all datasets(files), whose names start with AGY0157.DEMO.

Q. What if the file is Partitioned Dataset? How do you search the directory for the members in the PDS Library?

To see the directory of a PDS Library, you need to type M against the name of the Partitioned Dataset(PDS). The M Command tells the MVS Operating System to display the directory of the Partitioned Dataset(PDS).

Suppose, you want to see the directory(List of all the members) of the Partitioned Dataset(Library) AGY0157.DEMO.SRCLIB. Then, type an M against its name in the DSLIST Utility ISPF Menu 3.4 screen.

Upon hitting the Ctrl Button, you get to see the directory of the Partitioned Dataset(PDS) AGY0157.DEMO.SRCLIB – you can see the entire list of members in the PDS.

Generally, you will keep your program, jobs, REXX scripts assorted in Libraries or Partitioned Datasets(PDS). Here, I have stored all my COBOL Programs in this library.

Q. How do code member names of a Partitioned Dataset in JCL?

To refer to a member of a Partitioned Dataset in JCL, you code the dataset name with the member name in parenthesis. Here, is how you code my dataset name in JCL, when I have to refer to a job named PROGRAM1 in my SRCLIB (Source Library).

AGY0157.DEMO.SRCLIB(PROGRAM1)

Q. How do you store some data in file? How do open and edit the contents of a file?

In the next few tutorials, I’ll show you how to use JCL to run programs, read file, send output to printer, create and delete files. But, before this you need to key in some data into your computer system. This data consists of 80-byte records.

After creating a file, you need to an ‘E’ against the file-name to edit the file. Let’s assume that you wanted to key in Employee Data in Physical Sequential file – AGY0157.EMPLOYEE.DATA. Here goes. After you’ve found the file using ISPF Dataset List Utility 3.4, just type E against that dataset, and hit Ctrl.

Just as on Windows, the default editor in Notepad, typing E against the dataset name, causes the file AGY0157.EMPLOYEE.DATA to open in the editing mode. The editing mode allows you to change the contents of the file – add new data, modify the data, or delete the data. On the other hand, you can also open the file in View Mode (type V) or Browse Mode (type B). View Mode or Browse mode is a read-only mode(You cannot change the contents).

Generally, when you open Production Files(Files which are being used, when the Mainframe application is running live), it’s always a good practice to open them in read-only mode.

Initially, the file AGY0157.EMPLOYEE.DATA is empty. When you open it, in Editing mode, it looks like this -

You can now key in your data in the file, and save it by typing the SAVE Command on the command line field.

What on Earth is a Mainframe

2010-01-15T22:57:00.001+05:30

Tutorial Name	Download Links
Introduction to Mainframes - What is a Mainframe? - How did IBM Mainframe Machines evolve? - What does a Mainframe Computer look like? - Like Windows, which is the Operating System on Mainframes? - Are Mainframes faster than Supercomputers? - What is a Batch Job? - Like Desktop, how do you interact with a Mainframe Computer? - What is ISPF?	PDF Word
Mainframe Information Representation and Storage - How do Mainframes represent data? - What are fields, records, files and Datasets? - How do you form File(Dataset) names? - What are High-level Qualifiers? - What are Sequential Files(Datasets)? - What are Partitioned Datasets? - Your TSO Libraries - Coding Member names in JCL - Storing some data in File using TSO/ISPF	PDF Word
Structure of JCL - How does JCL Execute Programs? - How MVS thinks about Programs? - What are the different Statement types in JCL?	PDF Word
Basic Framework of JCL - Overview of JOB Statement - Overview of EXEC Statement - Overview of three kinds of DD Statements - Common JCL Error : Using Column 72 - Summary of Coding Rules for JCL Statements - Misspelling a JCL Statement Type - JOB ABEND(Abnormal End Processing)	PDF Word
Multi-step Job Streams - JCL and Flowcharting - A three-step job stream - Three step job stream JCL	PDF Word
Submitting a Job - SUBMIT Command - Input Queue, Spool and SDSF	PDF Word

Table Handling

2010-01-14T14:34:00.001+05:30

Q. What is table in COBOL? How do you define a Table?

In COBOL, you’ve learnt how to store a simple integer number, real number, text-strings etc. in Computer Memory. A simple variable can hold only one, single data-item. For example, a PIC X(10) variable can store the text-string ‘HELLOWORLD’, a PIC 9(03) variable can store the integer number 125, and so on.

However, in your day-to-day life, you often come across a list of items, say your shopping list, your phone-book(list of contacts), your favourite books(list of books) etc. What if, you want to store a list of data-items in Computer Memory? Say, for example like a collection of 5 PIC X(10) text-string’s, or 100 PIC 9(03) numbers.

Table can be used to store a list of data-items. An table is a list, a collection of similar data-items. So, Tables store multiple data-items of the same type. Take data-items, which are logically-related to each other, and put them together, in a table. For example, a table of integer numbers = {1, 2, 5, 8, -6}. Thus, in essence, a table is a set of data-items of the same type.

A table must be assigned a unique name. Say, for example, you can take a table, a set of PIC 9(04) numbers {1000, 2000, 5000, 8000, 6000} and assign it the name INCOME-TABLE. Then INCOME-TABLE = {1000, 2000, 5000, 8000, 6000}. The table INCOME-TABLE is said to have five members – 1000, 2000, 5000, 8000 and 6000. These are called elements of the Table. The number of elements in an table is called the size of the table, or table length.

Q. How do you refer to individual elements of a table?

Consider the table INCOME-TABLE = {1000, 2000, 5000, 8000, 6000}. You access the elements of a table, by specifying the position. The element at the 1st position is 1000, 2nd position is 2000, 3rd position is 5000 and so on... So, if you were to ask a question, “Give the element at position 4”, the answer would be 8000.

Q. Could you demonstrate via an example, how to create a simple table and retrieve data from it?

Suppose you want to store the names of you 5 friends in a COBOL Table. To create a table in COBOL, you must understand 3 important things -

Q1. Assigning a unique name to the table
A. FRIENDS-TABLE is the unique name of the table

Q2. What is the data being recorded in this table, and how many data-items it contains?
A. The data generally stored in this table represents your friends information. So the name of the record should be FRIEND-RECORD. The FRIEND-RECORD should store information about 5 friends. So, it contains 5 cells.

3. What is the specification/PICTURE clause for each such data-item?
Each such cell contains FRIEND-NAME, which is textual-string and can be 20 characters long.

In COBOL, you would write

01 FRIENDS-TABLE
02 FRIEND-RECORD OCCURS 5 TIMES
03 FRIEND-NAME PIC X(20)

Understand that the OCCURS Clause is used to specify, how many items(cells) are contained in the record.

Now, you can access the elements of this table as follows :

To access your first friend’s name, you write FRIEND-NAME(1)
To access your second friend’s name,you write FRIEND-NAME(2)
...
To access your fifth friend’s name, you write FRIEND-NAME(5)

The COBOL Definition of the above friend’s table, would look like this :

Given below is a simple COBOL Program, that shows how to store data in the Friends table, and display the contents of the table.

Upon running the above COBOL Program, you should get the following output -

Note: Since, FRIEND-RECORD is a group consisting of only one sub-item, you can use FRIEND-RECORD and FRIEND-NAME interchangeably. Which means,
FRIEND-RECORD(1) and FRIEND-NAME(1), both would work.

Q. Can the elements of the table be more complex group-items?

The elements of a table can be simple data-items like a number PIC 9(04), or a text-string PIC X(10). On the other hand, they may also be complex group-data-items, like 01 EMPLOYEE item, which in turn consists of a 02 EMP-NAME PIC X(20) text-string and 02 SALARY PIC 9(04) number. So, you can have a table of 50 numbers, 100 text-strings or 3 employees.

In the example, given here, I have created a table, that stores the data of 3 employees. The temporary variables defined in the Working Storage Section of the COBOL Program.

Now, the table EMPLOYEE-TABLE can contain the data of 3 employees. Now, you can write a COBOL Program, to store some data in the Employee Table, and then display its contents.

Look at the sample COBOL Program, given below.

Upon running the above COBOL Program, you get the following output -

Q. What are two-dimensional tables? How do you create them?

A table is a collection/list of data-items. Each data-item can be a simple data-item, or a complex group-item. What if the data-item is a table? Thus, you have a “Table of tables”. A 2-dimensional table looks like a matrix of cells, consisting of rows and columns. To access any cell at the intersection of a row and column, you need to know the row-no and the column-no.

Suppose, we wish to setup a table, which will represent the below statistic. The table below gives the class-wise and year-wise breakup of the spending capacity of an Indian Household.

Spending of an Average Indian Household annually in Rs.

First let me show, how to create Working-Storage definition for this table in COBOL. You need to create a 5 x 4 table(5 rows, each having 4 cells)

1. You need to assign a unique name to the table, so say the name of the table is AVERAGE-INDIAN-SPEND-TABLE.

01 AVERAGE-INDIAN-SPEND-TABLE.

2. Next, we have collected statistics for 5 different classes. So, the table will contain 5 records – one for each class.

01 AVERAGE-INDIAN-SPEND-TABLE
    02 SOCIAL-CLASS OCCURS 5 TIMES

3. Next, each of the classes, Upper, Upper-Middle, Middle-Middle, Lower-Middle and Lower class give the year-wise breakup of the money spend for 4 years (2007,2008,2009,2010). So, each row contains 4 cells.

01 AVERAGE-INDIAN-SPEND-TABLE
    02 SOCIAL-CLASS 5 TIMES
       03 YEAR OCCURS 4 TIMES

4. Moreover, the actual data in each cell is the money spend in Rupees. So, in general, each cell has the format PIC 9(4)V99.

01 AVERAGE-INDIAN-SPEND-TABLE
    02 SOCIAL-CLASS OCCURS 5 TIMES
       03 YEAR OCCURS 4 TIMES
          04 AMOUNT PIC 9(5)V99

In COBOL, you can in-fact go a level further, and create 3-dimensional cubes, 4,5,.. upto 7-dimensional tables as per COBOL-85 Standard.

Q. Can you suggest any general formula for creating two-dimensional tables in COBOL?

Consider the following working-storage definition of a table

    02 A OCCURS r TIMES
       03 B OCCURS c TIMES
          04 CELL PIC p (p = field size)

In general, the above formula holds to create a table of size r rows x c columns, where each cell has PICTURE Clause PIC P.

The PICTURE Clause is used at the lowest hierarchical level of a table.

Q. Could you show me a complete example of how to store data and retrieve data from 2-dimensional tables?

Let’s take the example of the AVERAGE-INDIAN-SPEND-TABLE. The COBOL Definition of this table is shown below -

The below COBOL Program, shows how to fill up AVERAGE-INDIAN-SPEND-TABLE with values. You can refer to any cell of this 2-dimensional table by using (row,col). For example, to refer to the amount in 2nd row, 4th column, you would write AMOUNT(2,4).

The COBOL Program is divided into 2 parts :-
1) Filling(Initialising) the Table
2) Displaying the contents of the Table

The next COBOL Paragraph displays values in the AVERAGE-INDIAN-SPEND-TABLE on the screen.

Upon running the above COBOL Program, you get the contents of the table
displayed on the screen.

EVALUATE Statement – Part II

2010-01-07T01:08:00.000+05:30

Q. What values the Subject and Object in the EVALUATE and WHEN Clauses can take?

In the EVALUATE Statement, the subject and object may equate to one of the below -
1) TRUE or FALSE – The subject or object may contain TRUE/FALSE constant. Also, if the Subject or object is condition, then its value would be either true or false.

2) A Value – The subject or object may specify an expression(A + B – C) or variables like AGE, whose result is a definite value. Moreover, it may also specify a literal-data value directly like 35.

3) A range of values – The object may also be specified as a range of values, for example, to specify a range or values (3,4,5,..,7), you could simply write 3 THRU 7.

Q. Could you explain the above idea simple and easy-to-remember example?

Suppose you want to write a COBOL Program, to calculate your income-tax payable in India for the financial year 2009-10, as per the slab in which your income falls.

RATE-OF-TAX	STATUS	TAX-SLAB
0 percent	MALE	0-1,60,000
	FEMALE	0-1,90,000
	SENIOR-CITIZEN	0-2,40,000
10 percent	MALE	1,60,001-3,00,000
	FEMALE	1,90,001-3,00,000
	SENIOR-CITIZEN	2,40,001-3,00,000
20 percent	ANY	3,00,001-5,00,000
30 percent	ANY	5,00,001 and above

The necessary working-storage variables for the above COBOL Program are as shown below-

The EVALUATE statement in COBOL, which calculates the Income-tax according to the above given rules, is as follows :

In the above COBOL Program, I have assumed that the taxable income of the individual is 2.5 lacs, and she is female. 2.5 lacs salary for a female falls into the second tax slab, where the income tax rate is 10 percent. Upon running the above COBOL Program, you should get the following output :

EVALUATE Statement – Program Flow Control

2010-01-06T12:32:00.001+05:30

Q. What is the EVALUATE Statement used for? How does it work?

When there are multiple options to choose from, the EVALUATE statement works best. When there are several choices to be made, IF-ELSE logic can become very complicated. To avoid writing complex nested IF Conditionals(condition-within-condition), the EVALUATE Statement can be used. The EVALUATE statement is the COBOL equivalent of switch-case in most conventional programming languages.

The general format of the EVALUATE Statement is as follows :

Syntax:

EVALUATE <expression>
   WHEN condition-1
     Statement-1
     ...

   WHEN condition-2
     Statement-2
     ...

   WHEN OTHER
     Statement-n
     ...
END-EVALUATE
STATEMENT-X

Interpretation:

The EVALUATE computes the value of the main expression.

1. If the value satisfies condition-1, then Statement-1 is performed, and after execution, control jumps to STATEMENT-X(Outside the EVALUATE Block).

2. Else If the value satisfies condition-2, then Statement-2 is performed, and after execution, control jumps to STATEMENT-X(Outside the EVALUATE Block).

...

n. If the values satisfies none of the above conditions, then by default WHEN OTHER case is executed(Statement-n), and then the control jumps to STATEMENT-X.(Outside the EVALUATE Block)

Thus, at each level of the EVALUATE block, the condition is checked, if it holds true, the case is executed, if it doesn’t hold true, you descend to the next lower level and so on... This is called a fall-through.

Example:

Upon running the above COBOL Program, you should get the following output-

Q. What are subjects and objects in the EVALUATE Block? How are they used?

Generally, the expression being tested, specified by EVALUATE Clause is called the subject. The values against which it is tested, specified by the WHEN Clause is called the object. Thus, you test a subject expression against an object value using the EVALUATE case structure.

The EVALUATE Block allows you to specify the multiple subjects and objects. Each subject in the EVALUATE Clause would be tested against the corresponding object-value in the WHEN Clause.

Example:
Suppose you want to write a simple COBOL Program to decide the pay of an employee. The pay of the employee is calculated as per this table.

CONDITION DESIGNATION LEVEL-OF-EXP FLEXIBLE	Salary
ACCOUNTANT EXPERIENCED WILLING-TO-TRAVEL	2000
ACCOUNTANT INEXPERIENCED WANTS-TO-STAY-PUT	1000
COMPUTER-SCIENTIST ANY ANY	3000
SYSTEMS-ANALYST EXPERIENCED ANY	4000
ANY EXPERIENCED ANY	500

There are 3 subjects that you need to evaluate in above table, to decide the salary of the employee. The variables for the above data in COBOL are as shown below:

To calculate the salary of the employee according to the above decision chart, I have written the following code in COBOL :

Now, in the above COBOL Program, I have set ACCOUNTANT flag to true, and he is INEXPERIENCED, and wants to STAYPUT. For such a condition, the salary should be 1000. Upon running the above COBOL Program, you should get the following output :

Program Flow Control

2010-01-01T12:48:00.000+05:30

Q. What does one mean by ‘Program Flow Control’? Why is it important?

COBOL allows programmers to write computer programs in a systematic manner. You can divide and organize your programs into sections and paragraphs. Each section or paragraph is dedicated to perform a specific task or function. While writing a particular section or paragraph, you can focus and put all your energy, towards the task you want to perform, without bothering about the rest of the program.

When the control first enters into the Program, depending upon what task is to be performed, you accordingly just direct/transfer the control to the appropriate section or paragraph, jump to the relevant para. This idea is called Program Flow Control.

You have written the program, in a well-organised manner. If an error occurs in particular task/functionality, you only need to search and rectify the error in that section or paragraph corresponding to this functionality(You don’t need to search the whole program).

Q. How do you write SECTION’s and PARAGRAPH’s in COBOL?

Just as DIVISION’s start in Area A(Columns 8-11), Section names and Paragraph names should begin in Area A. Every Section name and paragraph name should end with a period.

Moreover, it is customary to follow a naming-convention for paragraph-names. Generally, the naming convention for COBOL Para’s used by most programmers(in different shops) is to prefix the paragraph name with a number. For example, if your program has 2 paragraphs INDIA and CHINA, then name them as 0100-INDIA and 0200-CHINA. This way, it becomes easier to identify them.

Given below is simple example of a typical COBOL Program that is divided into two sections READ-FILE-SECTION and WRITE-FILE-SECTION, each of them containing one paragraph.

Example:

Think what if, you executed this COBOL Program. The starting point of the program is the PROCEDURE DIVISION. Each statement is executed by the computer one-by-one sequentially. It is terminated at STOP RUN. Thus, the output on the screen(SYSOUT Dataset) should be

Q. What is PERFORM Statement used for? How does it control the program flow?

One of the statements in COBOL, to control the flow of the program is PERFORM Statement. The PERFORM Statement basically transfers control(jumps) to the specified paragraph or section.

The general syntax of PERFORM Statement is :
PERFORM <procedure-name>

The procedure-name refers to the name of the paragraph or section that, you want jump to.

Example:
Consider the following COBOL Program, that consists of a 0100-MAIN-PARA and 0200-INDIA-PARA.

The starting point is PROCEDURE DIVISION.
1. The DISPLAY ‘START OF PROGRAM’ statement causes START OF PROGRAM to be displayed.
2. PERFORM 0200-INDIA-PARA causes transfers the control(jumps) to the 0200-INDIA-PARA. All the statements in this paragraph are executed one-by-one. DISPLAY ‘INDIA’ prints INDIA to the output. After the 0200-INDIA-PARA is complete, the control returns back to the point(0100-MAIN-PARA) from where it had left off.
3. The next statement DISPLAY ‘END OF PROGRAM’ causes END OF PROGRAM to be printed to the output. The program terminates at STOP RUN.

Upon running the above COBOL Program, you should get the following output -

The procedure to which the PERFORM statement transfers control, can be a 1 single para, or multi-paragraph procedure.

The general syntax to perform a multi-paragraph procedure is:
PERFORM paragraph-A THRU paragraph-Z

Suppose you have written a sequence of paragraphs : PARAGRAPH-A, PARAGRAPH-B, PARAGRAPH-C,...,upto PARAGRAPH-Z. The above PERFORM Statement transfers control(jumps) to the starting point – PARAGRAPH-A, then all the intermediate paragraphs B,C,D,...,Y between A to Z are also executed. Then, the last paragraph PARAGRAPH-Z is executed, before the control returns back to the point from where it had left off.

Example:

Upon running the above COBOL Program, you should get the following output -

The PERFORM statement can also be used to execute a complete SECTION consisting of several paragraphs.

Example:

Upon executing the above COBOL Code, you should get the following output -

Q. Is it possible to execute a procedure repetitively over and over again? Can PERFORM statement be used to loop through a procedure?

PERFORM Statement can be used to execute a procedure(set of paragraphs) 1 time, 2 times, 3 times, and so on.. repetitively. Performing the same task over and over again, can be done using PERFORM Statement.

When you write a PERFORM Statement to loop/repeat a task again and again, you need to specify, how many times you want to perform the task. Now, specifying how many times, you want to do something – once, twice,thrice, 5 times, 10 times... is sometimes difficult.

For example, assume that you want to read data from a file.

Read 1st record
Read 2nd record
Read 3rd record
...
Read last record

To Read a record is the task to be performed again and again. So, you can write a PERFORM Statement to do the task - READ a record, again and again till, you reach the end of the file(all the data-records have been read).

PERFORM as (i=1,2,3,..,??)
READ ith record

How many read’s would you do? You don’t know this upper-bound, as you don’t know the exact no. of records in the file before-hand. Instead, you could type a boundary-condition, saying that, Stop reading when you reach End-of-file.

Thus, you can specify exactly how many no. of times to perform a loop, or you may specify a boundary(termination) condition.

1. To specify the no. of times, you want to perform a loop, you use TIMES option.
2. To specify a boundary(termination) condition for a loop, you use UNTIL option.

The general syntax for the PERFORM Statement used to do a task again and again many times is,

PERFORM <procedure-name> <n> TIMES

Example-

Upon executing the above COBOL Code, you should get the following output -

Decision Making in COBOL

2009-12-25T11:07:00.001+05:30

Q. How does the IF Condition in COBOL work? What’s the syntax for it..?

The IF-condition is used for decision-making in COBOL. The basic IF-condition has following structure -

IF <test-condition> THEN
   Statement-1
   Statement-2
   ...
END-IF
Statement-X

The entire IF END-IF construct along with all its statements, Statement-1, Statement-2 constitute a single unit, a BLOCK. Upon entry into the IF Block, the test-condition is checked. The statements inside the IF Block constitute the body of the IF Block. Thus, the test-condition guards entry into the IF Body.

The <test-condition> expression is evaluated. If the test-condition expression equals = true, then the Statement-1, Statement-2,... are executed, i.e. the statements in the body of the IF-Block are executed. Once, the IF-Block has been completed, the next successive statement following the IF-Block, say Statement-X will be executed.

When test-condition expression equals = false, the control jumps directly to Statement-X, after the IF-Block.

Example:
01 AIR-FARE PIC 9(5).
01 BAGGAGE-WEIGHT PIC 9(5).
01 MAXIMUM-ALLOWED PIC 9(5) VALUE 20.
01 DIFFERENCE PIC 9(5).
01 EXCESS-CHARGE PIC 9(5).
...
...
MOVE 1000 TO AIR-FARE
IF BAGGAGE-WEIGHT > MAXIMUM-ALLOWED THEN
   COMPUTE DIFFERENCE = BAGGAGE-WEIGHT – MAXIMUM-ALLOWED
   COMPUTE EXCESS-CHARGE = DIFFERENCE * 300;
   COMPUTE AIR-FARE = AIR-FARE + EXCESS-CHARGE
END-IF
DISPLAY ‘AIR-FARE : ‘ AIR-FARE

Explanation:
In a flight, the maximum weight of luggage allowed = 20 kgs. The passengers have to pay a Total fare = Basic Fare + Any extra charges for excess baggage above 20 kgs. How to code this logic in COBOL?

First, the MOVE statement stores the value 1000 in AIR-FARE variable. Now, if the baggage-weight exceeds 20 kgs., then you got to pay extra for the excess baggage. The IF condition checks, whether the weight is greater than 20.

Say, the baggage-weight = 24 kgs. Then, baggage-weight > 20, so difference = 24 – 20 = 4 kgs. The excess-charge would be 300 multiplied 4 times = Rs. 1200. So, the air-fare = 1000 + 1200 = 2200. Finally, the DISPLAY statement displays AIR-FARE=2200.

Say, the baggage-weight = 18 kgs. Then, baggage-weight < 20, so the test-condition fails. Thus, the control directly to the DISPLAY statement after the IF-block, and the Air-Fare is displayed as Rs. 1000.

Upon running the above COBOL Program, you get the following output -

Q. How do you use the IF-THEN ELSE construct in COBOL?

The IF-THEN ELSE construct in COBOL, has the following syntax :

IF <test-condition> THEN
   Statement-1
   Statement-2
   ...
ELSE
   Statement-3
   Statement-4
   ...
END-IF
Statement-X

The IF-THEN ELSE construct is simple – when the test-condition = true, the IF-part is performed. When the test-condition = false, the ELSE-part is performed. Thus, the IF part and ELSE part are mutually exclusive. Either one of them is performed, based on the truth or falsity of the condition.

The statement-1/statement-2 could be a simple COBOL Statement, or it could be another IF Else block. One IF-ELSE Block can sit right inside another IF or ELSE. This is called as Nested Conditional.

Example:
Let’s study the working of a deeply nested conditional. The data in the program used are :

The logic used to calculate the RATE-OF-TAX is as follows -

	Salary upto 20k	Salary>20k
Salaried Employee	08 percent	10 percent
Self-employed Professional	20 percent	20 percent

This decision-table is used to determine the rate of tax. You can implement this logic COBOL Code as follows -

The data presented tells you, the Salary is 18000. The program starts with SET SALARIED TO TRUE, which turns on the SALARIED switch. Thus, the control goes to the next statement, IF SALARIED. When this condition is evaluated(as SALARIED switch is turned on), it returns true. So, control enters into the the IF Block. The control reaches IF SALARY > 2000. Salary equals 18k, so
(SALARY > 20000) = false, the control goes to the ELSE part. The statement MOVE 08 to Rate is performed, which stores the value 08 in Rate. The Inner IF Block terminates. The control jumps to the DISPLAY statement, that displays the RATE = 08 percent.

Q. What are the Relational/Comparision Conditions?

To compare two quantities, which is larger one, which is smaller amongst them, are the two quantities equal in magnitude, you would use Relational Conditions. The different relational operators available in COBOL, are tabulated below :

Relational Operator	Symbol
IS LESS THAN	<
IS EQUAL TO	=
IS GREATER THAN	>
IS LESS THAN OR EQUAL TO	<=
IS GREATER THAN OR EQUAL TO	>=

A relational condition would have the following form:

data-item-1 relational-condition data-item-2

The data-items could be variables or literal constant values. Moreover, in relational conditions you can use the complete relational operator spelled out in words, or as an alternative the symbolic representation for it. So, for example you may write 2 < 3, or you may as well write 2 IS LESS THAN 3.

What happens, when you compare two data-items, which are non-numeric. In this case, the result of comparision depends on the collating sequence.

Q. Well in COBOL, how do you combine 2 or more conditions? Like, you wanna check if AGE >= 20 and AGE =< 35(Age lies in the range 20 to 35)?

In COBOL, you can write a simple condition or a Complex Condition. Two or more simple conditions connected by Logical Operators give a Complex condition. For example, you can use the Logical operator AND to combine two conditions. For example, to check whether Age is in the range 20-35, you write

IF (AGE >= 20) AND (AGE <= 35)
<condition-1>     <condition-2>

The Logical Operators in COBOL, are briefly discussed below :
1. IF BALANCE IS NEGATIVE AND DAYS-OVERDUE > 30
      PERFORM 1100-SEND-OVERDUE-NOTICE

In the above example, the PERFORM statement is executed, only when both the conditions balance is less than 0, as well as, DAYS-OVERDUE exceeds 30 are satisfied. The AND operator returns true, only if both the conditions are true.

2. IF PHONE-NUMBER IS NOT NUMERIC OR NAME-IS-MISSING
      PERFORM INVALID-DATA

In the above example, the PERFORM Statement is executed, when either the phone-number field is non-numeric or the name field is missing. Thus, the OR Operator returns true, even if one of the conditions is true. If both the conditions are true, well and good, but even if one of them is true, OR returns true.

3. IF WEIGHT-1 NOT = WEIGHT-2
      PERFORM INEQUAL-WEIGHTS

In the above example, the PERFORM Statement is executed, when the first weight does NOT equal the second weight. The NOT Operator is used to negate any condition.

Q. What are Class Conditions in COBOL?

Class Conditions help determine, what type of data is present in a variable. Thus, it checks the contents stored in a variable, is it alphabetic, numeric or alpha-numeric... Suppose, you want to check, whether the name is alphabetic, or age of the person is numeric, then you should use Class Conditions. The general format for Class conditions is given below -

Data is Alphabetic implies that it contains only characters from A-Z and/or blanks. Alphabetic data cannot contain numerals(0,1,2,...,9). On the other, when you say that data is numeric in COBOL, it can contain digits from 0-9, with/without a sign.

ALPHABETIC-LOWER and ALPHABETIC-UPPER are the same as alphabetic, except that they also take the case into account; whether it is lower-case or upper-case. So, if the variable WS-TEXT contains ‘HELLO’, and you test IF WS-TEXT IS ALPHABETIC-UPPER, it returns true.

Q. Hey pal, how do you check if the data input in a COBOL Program is alphanumeric? Alphabetic is cool, numeric is awesome, but alphanumeric?

Let’s assume, you want to check, if the ADDRESS-FIELD is alpha-numeric. To do this, take it one at a time, (i) First check, if ADDRESS-FIELD is alphabetic. (ii)Next check, if ADDRESS-FIELD is numeric.

IF ADDRESS-FIELD IS NOT ALPHABETIC THEN
   IF ADDRESS-FIELD IS NOT NUMERIC THEN
      PERFORM INVALID-ADDRESS
   END-IF
END-IF

Q. What are Condition-name conditions?

Suppose the variable WS-GENDER stores the values ‘M’ for Male or ‘F’ for female. You may want to associate the values ‘M’ or ‘F’ with some meaningful names such as MALE or FEMALE. To do this, you use 88-Level Condition names. Consider the following :

--1----+----2----+----3----+----4----+----5----+----6----+----7--
DATA DIVISION.
WORKING-STORAGE SECTION.
01 GENDER                            PIC X.
    88 MALE                           VALUE 'M'.
    88 FEMALE                         VALUE 'F'.
PROCEDURE DIVISION.
    SET MALE TO TRUE
    IF MALE THEN
       DISPLAY 'GENDER IS MALE'
    ELSE
       DISPLAY 'GENDER IS FEMALE'
    END-IF
    STOP RUN.

In the above code snippet, I have assigned the values ‘M’ and ‘F’, the symbolic names MALE and FEMALE respectively using 88-level entries. 88-Level entries act as flags. To turn the flag on, you use the SET Statement. SET MALE TO TRUE, turns MALE flag on, and ‘M’ is stored in GENDER variable. To check if the gender is male, you may write IF GENDER = ‘M’ or you could use the condition name - IF MALE; both are equivalent.

Q. What are Sign-conditions?

Sign conditions are used to find if a numeric quantity is positive(>0) or negative(<0). Thus, they are used to check for the sign of a numeric variable.

The general syntax for Sign condition is given below -

The quantity which is being test could be stored in a Variable, or it could also be the result of an expression. A variable is POSITIVE, if it is greater than > 0. On the other hand, the variable is NEGATIVE, if it is less than 0.

Example:
IF BALANCE IS NEGATIVE
PEFORM SEND-CREDIT-OVERLIMIT-NOTICE
END-IF

COBOL Tutorial – USAGE Clause

2009-12-19T19:38:00.001+05:30

Q. What is USAGE Clause? Could you cite an example, where one would employee USAGE Clause?

USAGE Clause signifies, how the computer internally stores or represents DATA. Memory space calculation is done by the computer, on looking at the USAGE Clause. Thus, USAGE Clause answers the question, How much storage space does a data-item occupy? 1 byte, 2bytes, 4 bytes,… well how much? Depending upon the type of data – whether alphabetic or numeric, you should choose a USAGE(internal representation) that suits your purpose.

USAGE	Purpose
DISPLAY	When you want to work with characters, manipulate them, work on textual string data
COMPUTATIONAL	More appropriate, when you want to perform arithmetic computations, specially on numbers – integers and fractional numbers

When there is no explicit USAGE clause, it defaults to USAGE IS DISPLAY.

Q. How do computers internally store data?

Computers store data in Binary digits 0 and 1. Thus, all the data you enter into the computer is represented as 0’s and 1’s. The computer is said to understand and speak binary language.

Text data such as ‘HELLO’, ‘I HOPE YOU ARE IN THE PINK OF HEALTH’,’QUASAR CHUNAWALA’ are stored using a collating sequence(ASCII or EBCDIC). The collating sequence assigns a unique code number to each character. For example, A is assigned ASCII code 65, B = 66, C = 67, and so on. Now, when you type A on the computer, the computer interprets it as ASCII Code 65, which gets stored as 0100 0001.

Numeric data can be held as Text Digits(ASCII Digits), or as pure Binary numbers, or as Binary Coded Decimal(BCD), or as Real Numbers(IEEE Format).

Q. What is the USAGE IS DISPLAY Clause?

USAGE IS DISPLAY is mainly used with Text Data such as ‘HELLO’,’HOW ARE YOU’ and numeric data, which is not used in computation such as Street no. ‘2530’, phone numbers like ’17654094509’.

Text-data(strings) are made up of several characters. For example, the text-string ‘HELLO’ is composed of the characters ‘H’,’E’,’L’,’L’ and ‘O’. When you apply USAGE IS DISPLAY, the text-data is stored as ASCII/EBCDIC Characters.

Generally, when Text-data is stored on PC, the collating sequence used is ASCII. On Mainframes, Text-Data is stored in EBCDIC Format.

Example:

01 WS-TEXT PIC X(5) VALUE ‘HELLO’ USAGE IS DISPLAY.

Here, ‘H’, ‘E’, ‘L’, ‘L’ and ‘O’ are stored ASCII/EBCDIC Characters. A picture of how they look is shown below :

Each ASCII/EBCDIC Character requires 1 byte. So, the text-data ‘HELLO’ occupies 5 bytes of storage.

Q. Is there any problem, if I store numeric data, which is used in computations with a USAGE IS DISPLAY?

01 WS-VAR PIC 9 VALUE 2.

Since no USAGE clause is explicitly specified, it defaults to USAGE IS DISPLAY.

When numeric data is specified with USAGE IS DISPLAY, these text-digits of the number are stored as ASCII/EBCDIC digits. Thus, the Text-digit 2 would be stored in computer memory as shown below -

Each text-digit is stored in ASCII/EBCDIC Form, so it will occupy 1 byte. Hence, if you store 12345.67 with USAGE IS DISPLAY, it will occupy 7 bytes.

Imagine a scenario, where you want to read and process a data-file containing 1 million phone-numbers, each phone-number being a PIC 9(10). Each phone number occupies 10 bytes of storage.

For processing 1 million phone numbers,

1 MILLION x(multiplied by) 10 bytes for each phone number = 10 million bytes.

This is quite computationally expensive in terms of storage space, time and bandwidth. Reading and processing a file as large as 10 million bytes(10 MB) takes time. This is why, USAGE IS DISPLAY is not good choice for storing numeric data.

USAGE is DISPLAY, is more suited to working on a character-by-character level on Text data-items. When you want to perform character-level manipulations, use DISPLAY.

Q. What is the USAGE IS COMP/COMPUTATIONAL/BINARY Clause?

USAGE IS COMPUTATIONAL is more appropriate when you are dealing with integer numbers. USAGE IS COMPUTATIONAL indicates that the data-item shall be stored as pure binary numbers.

Example:
01 WS-NUMBER PIC 9(04) VALUE 1327 USAGE IS COMPUTATIONAL.

USAGE IS COMPUTATIONAL indicates that 1327 is stored in pure binary form. A picture of how 1327 is stored, is given below :

The pure binary equivalent of 1,327 occupies 2 bytes.

The memory space calculation is done by the computer, as follows:

Integer Number Range	PICTURE Clause	Storage Space
-32,768 to +32,767	S9(01) to S9(04)	2 Bytes
-2 billion to +2 billion	S9(05) to S9(09)	4 Bytes
-1.8 x 10^19 to +1.8 x 10^19	S(09) to S9(18)	8 Bytes

For numbers upto 32,767, 2 bytes of memory space is reserved. What if, you wanted to store an even larger integer number like 50,000? The pure binary equivalent of such numbers would then not fit into 16 bits(2 bytes). A 2-bytes bucket would not be large enough to accommodate it. They would spill over. They would need a big tumbler(say 4 bytes capacity). So, automatically 4 bytes of memory space would be reserved. What if, you store a mammoth number like a hundred billion? A hundred billion would have a picture clause S9(11), so it would occupy 8 bytes.

As you may observe on the table, based on the ranges, we can draw a correlation between the PICTURE Clause of the data-item and the Storage space.

Consider the following simple example, in which the variables WS-VAR-1 and WS-VAR-2 are declared as COMPUTATIONAL. As the USAGE IS COMPUTATIONAL, the numbers 10 and -12 are stored internally in binary format.

Upon the addition Of these two integers, 10 and -12, the COBOL Code shows the following output. 10 added to –12 gives a sum of –2. Note, that sign is stored as part of the rightmost digit. K stands for minus(-ve) 2. So, 1K means –12 and 0K means –2.

Q. What is the USAGE IS COMP-1/COMP-2 Clause?

When you want to work with fractional numbers, numbers containing a decimal point, you must employ USAGE IS COMP-1. USAGE IS COMP-1 is used to store floating point numbers(real numbers). COMP-1 occupies 4 bytes of memory space. Floating point(real numbers) are divided into 2 parts : mantissa part and exponent. For example, 123.456 can be represented as mantissa = 123456 e -3. The mantissa part is occupies 3 bytes. The exponent part occupies 1 byte.

On the other hand, if you have an extremely huge number like a googol, 1 e +100, you would need more space. Moreover, you a number 23 e -50 is a extremely tiny number(quite close to zero, but not zero), to store it require lot of precision and accuracy. For such numbers, you would use COMP-2. COMP-2 is used for real fractional numbers which are extremely large, and very small. COMP-2 occupies 8 bytes of memory space.

Q. What is the USAGE IS COMP-3 Clause?

As most references quote, COMP-3 is used mainly for packed decimal values(BCD Format). I would say, on most computer systems, running COBOL Applications, COMP-3 is the general standard. The reason behind this is, COMP-3 packs, two digits in 1 single byte. This is really cool, and it saves a lot of space.

Let me show ya, how COMP-3 achieves this remarkable feat. In the decimal number system, any digit can take a value ranging from 0-9, there are in all 10 possibilities. Thus, you can represent any digit with 4 bits(16 possibilities, 4 bits = 1 nibble). So, in COMP-3 format, each digit occupies only 4 bits. You must find the binary representation for each digit separately. For example, the number

4 5 9 8 1 2 . 5 6 would be stored as
0100 0101 1001 1000 0001 0010 0101 0110.

One can infer, in COMP-3 format, two digits are packed into a single byte. So, 459812.56, a number, which is composed of 8 digits would take only 4 bytes of computer storage. There’s a general formula for memory space calculation, in COMP-3 format -
S9(4) COMP-3 would occupy 2 bytes.
S9(6) COMP-3 would occupy 3 bytes.
S9(7) COMP-3 would occupy 4 bytes.
S9(n) COMP-3 would occupy (n+1)/2 bytes.

VSAM Tutorial 04 – Loading Records in VSAM KSDS

2009-12-12T22:09:00.001+05:30

Q. How do you load data into VSAM KSDS Dataset?

Storing data in a VSAM KSDS file, is known as Loading. Initially, to begin with the KSDS File is empty, it doesn’t contain any records. Based on, the Control Interval Size, that you’d have specified, while creating the KSDS File, the MVS Operating System books and reserves empty Control Intervals of that size in the KSDS Cluster. These are yet to be filled up,populated with data-records.

To actually load data-records into a VSAM KSDS file, you use IBM Supplied Utility IDCAMS. Instruct the IDCAMs utility, what’s the task you would like to perform by providing an appropriate control statement(as instream data). The IDCAMS utility picks up the Control Commands, and acts accordingly. So, the control command used to Load Data records in VSAM KSDS File is REPRO Command. In this tutorial, effectively, you are going to REPRO in the data records from a plain Sequential file into a KSDS Dataset. At the same time you’ll also learn, how to unload the contents KSDS Dataset back to a plain sequential file.

Q. Hey, tell me what’s the syntax for the REPRO Command? How do I write a Batch Job/JCL with IDCAMS and REPRO Command?

The REPRO Command in it’s simplest form looks like this -

REPRO INFILE(input-ddname)
OUTFILE(output-ddname)

In the above syntax, the input-ddname is DD Card for the Input Dataset, which happens to be the Physical Sequential(PS) Dataset, the source which currently holds the data-records. The output-ddname is the DD Card for the Output Dataset, which should be the destination VSAM KSDS File. So, let me quickly put together an example, that’ll show how to load records in a dataset. I am going to create a KSDS Dataset, to store the data of Employees working in an Organisation. I would like to store their ENo, EName, Salary, JDate(Joining Date). Assume that, you’ve stored the following Employees Data in a sequential file -

PS SEQUENTIAL FILE – AGY0157.SEQ.EMPLOYEE

As you can observe, all the data-records have a length = 23. Moreover, the Employee ID, is 2 digits. This can be used to uniquely identify each employee. Hence, this will acts as a Key in the VSAM KSDS Cluster. Note that all the Input Data Records are increasing(ascending) order of the Key(EMPLOYEE ID). If the records are out of order, it will throw an error. When you load data records in KSDS Dataset, it should always be Sequential Load.

Given below is the definition of the VSAM KSDS File : AGY0157.KSDS.EMPLOYEE, which will be used to store the Employee Records -

Notice, that the name of the VSAM KSDS Cluster is AGY0157.KSDS.EMPLOYEE. It has RECORDSIZE 23, and the Key values begin from column 0(offset) and are 2 columns wide. The word INDEXED is used to create KSDS.

To load or REPRO IN the Employee Data from PS Sequential File, AGY0157.SEQ.EMPLOYEE to VSAM KSDS File AGY0157.KSDS.EMPLOYEE, you would use the REPRO Command of the IDCAMS utility as follows :

Upon submitting this Job, the records are loaded successfully, and this can be verified by seeing the JOB SYSOUT Dataset.

You can see in bold that the NUMBER OF RECORDS PROCESSED WAS 6. This implies all the 6 records were successfully loaded into the VSAM KSDS File with Maximum Condition Code 0.

COBOL Tutorial – Arithmetic Operators

2009-09-26T18:19:00.001+05:30

Q. How do you perform Arithmetic in COBOL? For example, how do you write a simple program that calculates the Interest to be paid on a Principal p?

You often need to do Math in COBOL. You can perform Arithmetic in COBOL using Arithmetic Operators. When you perform some arithmetic on two or more numeric quantities, such an expression is called an Arithmetic Expressions. There are 4 main Arithmetic Operators in COBOL – ADD, SUBTRACT, MULTIPLY and DIVIDE.

You can even write complex arithmetic expressions by using the COMPUTE verb. I have written about the syntax of each operator, followed by examples and some results.

Q. How’z the ADD Operator used in COBOL. Show me some stuff...

The ADD operator can be used to add two or more quantities. In the assembly language, we write the instruction ADD A B to find the sum of A and B. The final sum is stored in A. On the same lines, the ADD Operator in COBOL has the following syntax :

Syntax

ADD one-quantity TO second-quantity

The final sum result is stored in the second-variable. For example, if A=10, and I write

ADD 5 TO A

After performing the above step, the computer adds 5 to the value of A, so A=15. Suppose a variable B=5, then I may also write

ADD B TO A

Syntax

ADD A B C TO SUM

In this case, all the three group of numbers A B and C, would be added to SUM. So, assuming A=10, B=15, and C=20, if initially RESULT = 100, after addition of A, B and C to SUM, the value of RESULT = 100 + (10+15+20) = 145.

Example

Result

Syntax

ADD A B GIVING RESULT

If you would like the final result of arithmetic to be stored in a separate resultant variable, you can always write a GIVING clause at the end. Thus, if A=5 and B=10, the sum(addition of A and B), would yield 15. This sum 15 is stored in the RESULT Variable. On omitting the GIVING Clause, the sum is stored in one of the operands being added. GIVING Clause allows you to specify a separate destination(receiving variable) which shall hold the final result of computation.

Example

Result

Syntax

ADD A B C GIVING D E

The GIVING Clause may also specify a list of destination/receiving variables. In that case, sum(addition) is copied to the each of the variables mentioned in the GIVING Clause. For example,
Assume that A = 10, B = 15 and C=20.

Now the sum of A B C = 10 + 15 + 20 = 45. The sum 45 is stored in each of the variables mentioned in the list(D, E). Thus,
D = 45 and E = 45, after the above statement is executed.

Example :

Result :

Comparing GIVING Clause with TO Clause :

Suppose RESULT = 100.

ADD 10 20 GIVING RESULT.
After the operation, RESULT = 30 (Old value is overwritten with the new value)

ADD 10 20 TO RESULT.
After the operation, RESULT = 130 (Old value is merely added to the operands, to arrive at the new value)

Q. How does the SUBTRACT Operator work in COBOL?

When you want to find the difference of two or more quantities in COBOL, you use the SUBTRACT operator. The SUBTRACT operator subtracts one quantity from another, and finds out the result. In its simplest form, SUBTRACT has the following syntax :

Syntax

SUBTRACT one-quantity FROM second-quantity

For example,

SUBTRACT WS-VAR-2 FROM WS-VAR-1

Consider the variable WS-VAR-1 = 10, WS-VAR-2=30, subtracting WS-VAR-2 from WS-VAR-1 would result in the difference between 30 and 10. The answer is 20. This final result is stored in WS-VAR-2. SUBTRACT B FROM A is equivalent to the statement A = A – B.

The example above is shown in the code snippet below :

The output of the above code snippet would look like this :

However, at times, you would like to store the difference between these two quantities in a separate third variable. To do so, you would put the following syntax to use :

Syntax

SUBTRACT variable-1 FROM variable-2 GIVING variable-3

For example, you would write SUBTRACT WS-VAR-1 FROM WS-VAR-2 GIVING WS-VAR-3, with WS-VAR-1=30, WS-VAR-2=10, you get WS-VAR-3 = WS-VAR-2 minus WS-VAR-1, i.e. WS-VAR-3 = 30 – 10 = 20.

Consider the code snippet given below :

Upon running the above code snippet, you would get the following output :

COBOL also gives you the facility to subtract a group of numbers from a given quantity. For example, let’s assume that you want to subtract a group of numbers 4 5 1 from a given sum 25. You compute the result as follows :
25 - (4 + 5 + 1) = 15.
In COBOL you would write it as,

SUBTRACT 4 5 1 FROM 25

Syntax

SUBTRACT item-1 item-2 item-3 ... FROM SUM [GIVING OUTPUT]

The example below shows, how to use this syntax in COBOL

The output of the above code-snippet, when you would run, should look like this -

Q. How does MULTIPLY Verb compute the product of two numbers in COBOL?

The MULTIPLY Verb is used to multiply two quantities together, that results in a Product. Let us assume the following data-variables, that’ll help us to understand the example.

The general form of MULTIPLY Verb is :

Syntax:

MULTIPLY number-1 BY number-2

This simple statement, multiplies the number-2 by number-1. For example, if A = 5, MULTIPLY 2 BY A, would result in A getting doubled, so the new value of A=10.

Result

Syntax:

MULTIPLY number-1 BY number-2 GIVING result

As you know, the GIVING Clause specifies a separate destination or receiving variable. So, the product is stored in the GIVING Clause variable result. For example, if A = 10, B = 20, MULTIPLY A BY B GIVING C, results in
10 x 20 = 200 getting stored in C.

Example

Result

Syntax:

MULTIPLY A BY B C D

This format of MULTIPLY Statement specifies that, A is to be multiplied each of the variables B, C and D, so that it results in the products A x B, A x C, A x D. The final resulting three products are stored in B, C and D itselves. If A = 10, and B = 2, C = 3 and D = 4, after the executing this MULTIPLY instruction, B, C and D become ten-folds, B = 20, C=30 and D=40.

Example

Result

Syntax:

MULTIPLY A BY B C GIVING D E

In this form of the MULTIPLY statement, as you would guess there would be 2 products : A x B (A times B) and
A x C(A times C). These final products would be stored in separate receiving variables D and E, as specified by the GIVING Clause.

Q. How does DIVIDE Verb divide a one operand by another? How do you find the remainder(what’s left over)?

The DIVIDE verb in COBOL, is used compute the quotient, upon the division of two numbers. The DIVIDE Verb has several forms available.

DIVIDE A INTO B

Here, the DIVIDE Operator is used to perform simple Division. You divide B into ‘A’ equal parts, how many parts do you get? In other words, this statement calculates the fraction B/A. Assume that you have a chocolate that’s 100 length. If you were to divide it into 5 cm long bars, you would get 100/5 = 20 bars to eat. To do this you would write,

DIVIDE 5 INTO 100

DIVIDE A INTO B C

You may also divide the multiple dividends(operands) by the same divisor, using a single statement. Suppose A=2, and B=58,C=156. Then, DIVIDE A INTO B C would mean that you are trying to divide 2 into 58 and 156. So, both 58 and 156 would be halved to 29 and 78.

DIVIDE A INTO B C GIVING D E

GIVING Clause can be used optionally to specify separate receiving/destination variables for storing the results.

DIVIDE B BY A GIVING C

You can also use the BY Clause to specify the dividend first and then the divisor.

REDEFINES Clause, RENAMES Clause

2009-09-02T08:50:00.001+05:30

Contents

REDEFINES Clause
1. Simple Program to show how REDEFINES Works
RENAMES Clause
1. Simple Program to show how RENAMES Clause works

Q. What is the REDEFINES Clause in COBOL? Why is it used?

REDFINES Clause can be used to define two group data-items which point to the same storage area. You can use both the data-items in the same COBOL Program.

Suppose, we have a storage area defined in the Working Storage section as

01 EMPLOYEE-DETAILS.
   02 EMP-NAME PIC X(30).
   02 EMP-NAME-DETAILS REDEFINES EMP-NAME.
      03 EMP-FNAME PIC X(10).
      03 EMP-MNAME PIC X(10).
      03 EMP-LNAME PIC X(10).
   02 EMP-ADDRESS PIC X(26).
   02 EMP-ADDRESS-DETAILS REDEFINES EMP-ADDRESS.
      03 EMP-STREET PIC X(10).
      03 EMP-CITY PIC X(10).
      03 EMP-PINCODE PIC X(6).
   02 EMP-CONTACT PIC X(20).

   02 EMP-CONTACT-DETAILS REDEFINES EMP-CONTACT.
      03 EMP-PHONE1 PIC 9(10).
      03 EMP-PHONE2 PIC 9(10).

Note that :
1) In the above example, EMP-NAME has been redefined as EMP-NAME-DETAILS, EMP-ADDRESS is redefined as EMP-ADDRESS-DETAILS and EMP-CONTACT is redefined as
EMP-CONTACT-DETAILS. So, EMP-NAME occupies 30 bytes of storage area. The same 30-byte storage area is also pointed to by EMP-NAME-DETAILS, and it provides a breakup into FNAME, MNAME and LNAME. This is a common and typical use of REDEFINES clause.

2) One cannot use the REDFINES clause with 01-level(root-level) data-items in the FILE SECTION. It also should not be used 66-level(renames clause) and 88-level(condition names).

3) The data-item which you want to redefine should not have a OCCURS Clause.

4) Note that, the original data-items and redefined ones both refer to the same memory location in storage area. Hence, in the above example, the total space occupied by EMPLOYEE-DETAILS still remains the same = 30+26+20 = 76.

Q. Show me a COBOL Program that demonstrates how to use the REDEFINES Clause.

Given below is a COBOL Program that shows a practical use of REDEFINES.

Upon running the above COBOL Program LOAD, we get the following output in the SYSOUT Dataset -

Q. What is the RENAMES Clause? Is it a good practice to use the RENAMES Clause?

The RENAMES clause is used to regroup data-items. The RENAMES Clause entry always must have level no. 66. You can take existing Data-items, and re-group them, and create a new copy in the memory under a new data-name. Note, that both the copies – the memory locations always remain in sync. While using the RENAMES clause, one must follow certain rules in COBOL. They are as follows :

1) RENAMES clause has the following syntax

66 new-data-name RENAMES data-item-1 THRU data-item-2
2) The 66 level RENAMES entry should immediately follow data-items 1 and 2.

3) The Data-Items 1 and 2 should not be 01-Level record entries.

4) The Data-Items 1 and 2 should be contiguous.

5) The new-data name should be one logical level higher than the data-item-1 and data-item-2.

6) The use of RENAMES Clause has often been debated in COBOL, and its considered a malpractice to use the RENAMES Clause now-a-days. Instead, one must opt for REDEFINES Clause.

Q. Show me a simple working example of the RENAMES Clause..

Given below is a basic COBOL Program, that shows how to use the RENAMES Clause.

In the above example, there are two copies of FIELD-B, one in record-1 and another in record-3. Note that both copies of FIELD-B will always contain the same value/contents. Any changes to FIELD-B will affect record-1 as well as record-3. Note that, unlike REDEFINES clause, RENAMES clause occupies actual physical storage space. Upon submitting the above COBOL Program LOAD, we get the following output in the SYSOUT Dataset.