JCL - คู่มือฉบับย่อ

ควรใช้ JCL เมื่อใด

JCL ถูกใช้ในสภาพแวดล้อมเมนเฟรมเพื่อทำหน้าที่สื่อสารระหว่างโปรแกรม (ตัวอย่าง: COBOL, Assembler หรือ PL / I) และระบบปฏิบัติการ ในสภาพแวดล้อมเมนเฟรมโปรแกรมสามารถทำงานในโหมดแบตช์และออนไลน์ได้ ตัวอย่างของระบบแบทช์สามารถประมวลผลธุรกรรมธนาคารผ่านไฟล์ VSAM (Virtual Storage Access Method) และนำไปใช้กับบัญชีที่เกี่ยวข้อง ตัวอย่างระบบออนไลน์อาจเป็นหน้าจอ Back office ที่พนักงานในธนาคารใช้เพื่อเปิดบัญชี ในโหมดแบตช์โปรแกรมจะถูกส่งไปยังระบบปฏิบัติการเป็นงานผ่าน JCL

การประมวลผลแบบกลุ่มและแบบออนไลน์แตกต่างกันในด้านของอินพุตเอาต์พุตและคำขอดำเนินการโปรแกรม ในการประมวลผลแบบแบทช์ลักษณะเหล่านี้จะถูกป้อนเข้าใน JCL ซึ่งระบบปฏิบัติการจะได้รับ

การประมวลผลงาน

งานคือหน่วยของงานที่สามารถประกอบด้วยขั้นตอนงานหลายขั้นตอน แต่ละขั้นตอนของงานระบุไว้ใน Job Control Language (JCL) ผ่านชุดของ Job Control Statements

ระบบปฏิบัติการใช้ Job Entry System (JES) เพื่อรับงานเข้าสู่ระบบปฏิบัติการเพื่อกำหนดเวลาสำหรับการประมวลผลและเพื่อควบคุมเอาต์พุต

การประมวลผลงานจะดำเนินไปตามขั้นตอนต่างๆดังที่ระบุด้านล่าง:

  • Job Submission - การส่ง JCL ให้ JES

  • Job Conversion - JCL พร้อมกับ PROC จะถูกแปลงเป็นข้อความที่ตีความเพื่อให้ JES เข้าใจและจัดเก็บไว้ในชุดข้อมูลซึ่งเราเรียกว่า SPOOL

  • Job Queuing -JES ตัดสินใจลำดับความสำคัญของงานโดยพิจารณาจากพารามิเตอร์ CLASS และ PRTY ในคำสั่ง JOB (อธิบายไว้ในJCL - JOB Statement Chapter) ตรวจสอบข้อผิดพลาด JCL และงานจะถูกกำหนดเวลาไว้ในคิวงานหากไม่มีข้อผิดพลาด

  • Job Execution -เมื่องานมีลำดับความสำคัญสูงสุดงานจะถูกนำไปดำเนินการจากคิวงาน JCL ถูกอ่านจาก SPOOL โปรแกรมจะถูกเรียกใช้งานและเอาต์พุตจะถูกเปลี่ยนทิศทางไปยังปลายทางเอาต์พุตที่เกี่ยวข้องตามที่ระบุไว้ใน JCL

  • Purging -เมื่องานเสร็จสมบูรณ์ทรัพยากรที่จัดสรรและพื้นที่ JES SPOOL จะถูกปล่อยออกมา ในการจัดเก็บบันทึกงานเราจำเป็นต้องคัดลอกบันทึกงานไปยังชุดข้อมูลอื่นก่อนที่จะออกจาก SPOOL

การติดตั้ง JCL บน Windows / Linux

มีตัวจำลองเมนเฟรมฟรีมากมายสำหรับ Windows ซึ่งสามารถใช้ในการเขียนและเรียนรู้ JCL ตัวอย่างได้

ตัวจำลองหนึ่งตัวคือ Hercules ซึ่งสามารถติดตั้งได้อย่างง่ายดายใน Windows โดยทำตามขั้นตอนง่ายๆที่ระบุด้านล่าง:

  • ดาวน์โหลดและติดตั้งโปรแกรมจำลอง Hercules ซึ่งมีให้จากเว็บไซต์หลักของ Hercules -: www.hercules-390.eu

  • เมื่อคุณติดตั้งแพคเกจบนเครื่อง Windows มันจะสร้างโฟลเดอร์เช่น C:\Mainframes.

  • เรียกใช้ Command Prompt (CMD) และไปที่ไดเร็กทอรี C: \ Mainframes บน CMD

  • คำแนะนำฉบับสมบูรณ์เกี่ยวกับคำสั่งต่างๆในการเขียนและดำเนินการ JCL มีอยู่ใน URL www.jaymoseley.com/hercules/installmvs/instmvs2.htm

Hercules คือการใช้งานซอฟต์แวร์โอเพ่นซอร์สของสถาปัตยกรรมระบบเมนเฟรม / 370 และ ESA / 390 นอกเหนือจาก z / สถาปัตยกรรม 64 บิตล่าสุด Hercules ทำงานภายใต้ Linux, Windows, Solaris, FreeBSD และ Mac OS X

ใช้ JCL บนเมนเฟรม

ผู้ใช้สามารถเชื่อมต่อกับเซิร์ฟเวอร์เมนเฟรมได้หลายวิธีเช่นไคลเอ็นต์แบบบางเทอร์มินัลดัมมี่ระบบไคลเอนต์เสมือน (VCS) หรือระบบเดสก์ท็อปเสมือน (VDS)

ผู้ใช้ที่ถูกต้องทุกคนจะได้รับรหัสล็อกอินเพื่อเข้าสู่อินเทอร์เฟซ Z / OS (TSO / E หรือ ISPF) ในอินเทอร์เฟซ Z / OS JCL สามารถเข้ารหัสและจัดเก็บเป็นสมาชิกใน Partitioned Dataset (PDS) เมื่อส่ง JCL จะถูกดำเนินการและผลลัพธ์ที่ได้รับตามที่อธิบายไว้ในส่วนการประมวลผลงานของบทก่อนหน้า

โครงสร้างของ JCL

โครงสร้างพื้นฐานของ JCL พร้อมข้อความทั่วไปมีดังต่อไปนี้:

//SAMPJCL JOB 1,CLASS=6,MSGCLASS=0,NOTIFY=&SYSUID          (1)
//*                                                        (2)
//STEP010  EXEC PGM=SORT                                   (3) 
//SORTIN   DD DSN=JCL.SAMPLE.INPUT,DISP=SHR                (4)
//SORTOUT  DD DSN=JCL.SAMPLE.OUTPUT,                       (5)
//         DISP=(NEW,CATLG,CATLG),DATACLAS=DSIZE50                
//SYSOUT   DD SYSOUT=*                                     (6) 
//SYSUDUMP DD SYSOUT=C                                     (6) 
//SYSPRINT DD SYSOUT=*                                     (6) 
//SYSIN    DD *                                            (6) 
  SORT FIELDS=COPY                                    
  INCLUDE COND=(28,3,CH,EQ,C'XXX')                                    
/*                                                         (7)

คำอธิบายโปรแกรม

คำสั่ง JCL ที่มีหมายเลขอธิบายไว้ด้านล่าง:

(1) JOB statement - ระบุข้อมูลที่จำเป็นสำหรับ SPOOLing ของงานเช่นรหัสงานลำดับความสำคัญของการดำเนินการรหัสผู้ใช้ที่จะได้รับแจ้งเมื่อเสร็จสิ้นงาน

(2) //* statement - นี่คือข้อความแสดงความคิดเห็น

(3) EXEC statement- ระบุ PROC / โปรแกรมที่จะดำเนินการ ในตัวอย่างข้างต้นโปรแกรม SORT กำลังดำเนินการ (เช่นการจัดเรียงข้อมูลอินพุตตามลำดับที่ระบุ)

(4) Input DD statement- ระบุประเภทของอินพุตที่จะส่งผ่านไปยังโปรแกรมที่กล่าวถึงใน (3) ในตัวอย่างข้างต้นไฟล์ฟิสิคัลซีเควนเชียล (PS) จะถูกส่งเป็นอินพุตในโหมดแชร์ (DISP = SHR)

(5) Output DD statement- ระบุประเภทของเอาต์พุตที่จะสร้างโดยโปรแกรมเมื่อดำเนินการ ในตัวอย่างข้างต้นไฟล์ PS ถูกสร้างขึ้น หากคำสั่งขยายเกินตำแหน่งที่ 70 ในบรรทัดหนึ่งคำสั่งนั้นจะดำเนินต่อไปในบรรทัดถัดไปซึ่งควรขึ้นต้นด้วย "//" ตามด้วยช่องว่างอย่างน้อยหนึ่งช่อง

(6)สามารถมีคำสั่ง DD ประเภทอื่นเพื่อระบุข้อมูลเพิ่มเติมให้กับโปรแกรม (ในตัวอย่างข้างต้น: เงื่อนไขการจัดเรียงถูกระบุในคำสั่ง SYSIN DD) และเพื่อระบุปลายทางสำหรับบันทึกข้อผิดพลาด / การดำเนินการ (ตัวอย่าง: SYSUDUMP / SYSPRINT) คำสั่ง DD สามารถอยู่ในชุดข้อมูล (ไฟล์เมนเฟรม) หรือในข้อมูลสตรีม (ข้อมูลที่เข้ารหัสภายใน JCL) ตามที่ระบุในตัวอย่างข้างต้น

(7) /* ทำเครื่องหมายจุดสิ้นสุดของข้อมูลในสตรีม

คำสั่ง JCL ทั้งหมดยกเว้นในข้อมูลสตรีมเริ่มต้นด้วย // ควรมีช่องว่างอย่างน้อยหนึ่งช่องก่อนและหลังคีย์เวิร์ด JOB, EXEC และ DD และไม่ควรมีช่องว่างในส่วนที่เหลือของคำสั่ง

ประเภทพารามิเตอร์ของงาน

แต่ละคำสั่ง JCL จะมาพร้อมกับชุดของพารามิเตอร์เพื่อช่วยระบบปฏิบัติการในการดำเนินการโปรแกรมให้เสร็จสมบูรณ์ พารามิเตอร์สามารถมีได้สองประเภท:

พารามิเตอร์ตำแหน่ง

  • ปรากฏที่ตำแหน่งและลำดับที่กำหนดไว้ล่วงหน้าในคำสั่ง ตัวอย่าง: พารามิเตอร์ข้อมูลทางการบัญชีสามารถปรากฏต่อจากไฟล์JOBคำหลักและก่อนพารามิเตอร์ชื่อโปรแกรมเมอร์และพารามิเตอร์คำหลัก หากไม่ระบุพารามิเตอร์ตำแหน่งพารามิเตอร์จะต้องถูกแทนที่ด้วยลูกน้ำ

  • พารามิเตอร์ตำแหน่งมีอยู่ในคำสั่ง JOB และ EXEC ในตัวอย่างข้างต้น PGM คือพารามิเตอร์ตำแหน่งที่เข้ารหัสหลังEXEC คำสำคัญ.

พารามิเตอร์คำหลัก

  • ซึ่งจะถูกเข้ารหัสหลังพารามิเตอร์ตำแหน่ง แต่สามารถปรากฏในลำดับใดก็ได้ สามารถละเว้นพารามิเตอร์คำหลักได้หากไม่ต้องการ ไวยากรณ์ทั่วไปเป็นคำสำคัญ = ค่า ตัวอย่าง: MSGCLASS = X กล่าวคือบันทึกงานจะถูกเปลี่ยนเส้นทางไปยังเอาต์พุต SPOOL หลังจากงานเสร็จสิ้น

  • ในตัวอย่างข้างต้น CLASS, MSGCLASS และ NOTIFY เป็นพารามิเตอร์คีย์เวิร์ดของคำสั่ง JOB สามารถมีพารามิเตอร์คำหลักในคำสั่ง EXEC ได้เช่นกัน

พารามิเตอร์เหล่านี้มีรายละเอียดในบทต่อ ๆ ไปพร้อมกับตัวอย่างที่เหมาะสม

JOB Statement เป็นคำสั่งควบคุมแรกใน JCL สิ่งนี้ให้ข้อมูลประจำตัวของงานแก่ระบบปฏิบัติการ (OS) ในสปูลและในตัวกำหนดตารางเวลา พารามิเตอร์ในคำสั่ง JOB ช่วยระบบปฏิบัติการในการจัดสรรตัวกำหนดตารางเวลาที่เหมาะสมเวลา CPU ที่ต้องการและการแจ้งเตือนให้กับผู้ใช้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL JOB:

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

คำอธิบาย

ให้เราดูคำอธิบายของคำที่ใช้ในไวยากรณ์คำสั่ง JOB ข้างต้น

ชื่องาน

สิ่งนี้จะให้ id ของงานในขณะที่ส่งไปยัง OS มีความยาวได้ตั้งแต่ 1 ถึง 8 โดยมีอักขระที่เป็นตัวเลขและตัวอักษรและเริ่มหลังจาก //

งาน

นี่คือคีย์เวิร์ดเพื่อระบุว่าเป็นคำสั่ง JOB

ตำแหน่ง - พารามิเตอร์

มีพารามิเตอร์ตำแหน่งซึ่งสามารถมีได้สองประเภท:

พารามิเตอร์ตำแหน่ง คำอธิบาย
Account information หมายถึงบุคคลหรือกลุ่มที่ค้างเวลา CPU มันถูกกำหนดตามกฎของ บริษัท ที่เป็นเจ้าของเมนเฟรม หากระบุเป็น (*) จะใช้รหัสของผู้ใช้ที่ล็อกอินเข้าสู่ Mainframe Terminal
Programmer name ข้อมูลนี้ระบุบุคคลหรือกลุ่มที่รับผิดชอบ JCL นี่ไม่ใช่พารามิเตอร์บังคับและสามารถแทนที่ได้ด้วยลูกน้ำ

คีย์เวิร์ด - พารามิเตอร์

ต่อไปนี้เป็นพารามิเตอร์คีย์เวิร์ดต่างๆซึ่งสามารถใช้ในคำสั่ง JOB คุณสามารถใช้พารามิเตอร์อย่างน้อยหนึ่งพารามิเตอร์ตามข้อกำหนดและคั่นด้วยเครื่องหมายจุลภาค:

พารามิเตอร์คำหลัก คำอธิบาย
CLASS

ตามระยะเวลาและจำนวนทรัพยากรที่งานต้องการ บริษัท ต่างๆจะกำหนดชั้นงานที่แตกต่างกัน สิ่งเหล่านี้สามารถมองเห็นเป็นตัวกำหนดตารางเวลาแต่ละตัวที่ OS ใช้เพื่อรับงาน การวางงานในตัวกำหนดตารางเวลาที่เหมาะสมจะช่วยในการดำเนินงานได้ง่าย บาง บริษัท มีชั้นเรียนที่แตกต่างกันสำหรับงานในสภาพแวดล้อมการทดสอบและการผลิต

ค่าที่ถูกต้องสำหรับพารามิเตอร์ CLASS คืออักขระ A ถึง Z และตัวเลข 0 ถึง 9 (ของความยาว 1) ต่อไปนี้เป็นไวยากรณ์:

CLASS=0 to 9 | A to Z

PRTY

เพื่อระบุลำดับความสำคัญของงานภายในระดับงาน หากไม่ได้ระบุพารามิเตอร์นี้งานจะถูกเพิ่มที่ส่วนท้ายของคิวใน CLASS ที่ระบุ ต่อไปนี้เป็นไวยากรณ์:

PRTY=N

โดยที่ N คือตัวเลขที่อยู่ระหว่าง 0 ถึง 15 และตัวเลขที่สูงกว่าจะมีลำดับความสำคัญสูงกว่า

NOTIFY

ระบบส่งข้อความความสำเร็จหรือความล้มเหลว (รหัสเงื่อนไขสูงสุด) ไปยังผู้ใช้ที่ระบุในพารามิเตอร์นี้ ต่อไปนี้เป็นไวยากรณ์:

NOTIFY="userid | &SYSUID"

ที่นี่ระบบจะส่งข้อความไปยังผู้ใช้ "userid" แต่ถ้าเราใช้ NOTIFY = & SYSUID ข้อความจะถูกส่งไปยังผู้ใช้ที่ส่ง JCL

MSGCLASS

เพื่อระบุปลายทางเอาต์พุตสำหรับระบบและข้อความงานเมื่องานเสร็จสมบูรณ์ ต่อไปนี้เป็นไวยากรณ์:

MSGCLASS=CLASS

ค่าที่ถูกต้องของ CLASS สามารถอยู่ในช่วง "A" ถึง "Z" และ "0" ถึง "9" MSGCLASS = Y สามารถตั้งค่าเป็นคลาสเพื่อส่งบันทึกงานไปยัง JMR (JOBLOG Management and Retrieval: ที่เก็บภายในเมนเฟรมเพื่อเก็บสถิติงาน)

MSGLEVEL

ระบุชนิดของข้อความที่จะเขียนไปยังปลายทางเอาต์พุตที่ระบุใน MSGCLASS ต่อไปนี้เป็นไวยากรณ์:

MSGLEVEL=(ST, MSG)

ST = ประเภทของคำสั่งที่เขียนลงในบันทึกเอาต์พุต

  • เมื่อST = 0 คำสั่งงานเท่านั้น

  • เมื่อST = 1, JCL พร้อมกับพารามิเตอร์สัญลักษณ์ขยาย

  • เมื่อST = 2 ป้อน JCL เท่านั้น

MSG = ประเภทของข้อความที่เขียนลงในบันทึกผลลัพธ์

  • เมื่อMSG = 0 ข้อความการจัดสรรและการเลิกจ้างเขียนเมื่องานเสร็จผิดปกติ

  • เมื่อMSG = 1 ข้อความการจัดสรรและการเลิกจ้างเขียนขึ้นโดยไม่คำนึงถึงลักษณะของการเสร็จงาน

TYPRUN

ระบุการประมวลผลพิเศษสำหรับงาน ต่อไปนี้เป็นไวยากรณ์:

TYPRUN = SCAN | HOLD

โดยที่ SCAN และ HOLD มีคำอธิบายดังต่อไปนี้

  • TYPRUN = SCAN ตรวจสอบข้อผิดพลาดทางไวยากรณ์ของ JCL โดยไม่ต้องดำเนินการ

  • TYPRUN = HOLD ทำให้งานอยู่ใน HOLD ในคิวงานในการปล่อยงานคุณสามารถพิมพ์ "A" เทียบกับงานใน SPOOL ซึ่งจะนำงานไปสู่การดำเนินการ

TIME

ระบุช่วงเวลาที่โปรเซสเซอร์จะใช้เพื่อดำเนินการงาน ต่อไปนี้เป็นไวยากรณ์:

TIME=(mm, ss) or TIME=ss

โดยที่ mm = minutes และ ss = seconds

พารามิเตอร์นี้มีประโยชน์ในขณะทดสอบโปรแกรมที่เข้ารหัสใหม่ เพื่อให้แน่ใจว่าโปรแกรมจะไม่ทำงานเป็นเวลานานเนื่องจากข้อผิดพลาดในการวนซ้ำสามารถเข้ารหัสพารามิเตอร์เวลาเพื่อให้โปรแกรมหยุดทำงานเมื่อถึงเวลา CPU ที่ระบุ

REGION

ระบุพื้นที่แอดเดรสที่จำเป็นในการรันขั้นตอนงานภายในงาน ต่อไปนี้เป็นไวยากรณ์:

REGION=nK | nM

ในที่นี้สามารถระบุภูมิภาคเป็น nK หรือ nM โดยที่ n คือตัวเลข K คือกิโลไบต์และ M คือเมกะไบต์

เมื่อ REGION = 0K หรือ 0M พื้นที่แอดเดรสที่ใหญ่ที่สุดจะถูกจัดเตรียมไว้สำหรับการดำเนินการในแอปพลิเคชันที่สำคัญห้ามใช้การเข้ารหัส 0K หรือ 0M เพื่อหลีกเลี่ยงการเสียพื้นที่แอดเดรส

ตัวอย่าง

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

ที่นี่คำสั่ง JOB จะขยายออกไปเกินตำแหน่งที่ 70 ในบรรทัดดังนั้นเราจึงดำเนินการต่อในบรรทัดถัดไปซึ่งควรเริ่มต้นด้วย "//" ตามด้วยช่องว่างอย่างน้อยหนึ่งช่อง

พารามิเตอร์เบ็ดเตล็ด

มีพารามิเตอร์อื่น ๆ อีกเล็กน้อยที่สามารถใช้กับ JOB Statement ได้ แต่มักไม่ได้ใช้:

ADDRSPC ประเภทของที่เก็บข้อมูลที่ใช้: เสมือนหรือจริง
BYTES ขนาดของข้อมูลที่จะเขียนลงในบันทึกเอาต์พุตและการดำเนินการที่ต้องดำเนินการเมื่อเกินขนาด
LINES จำนวนบรรทัดสูงสุดที่จะพิมพ์ในบันทึกเอาต์พุต
PAGES จำนวนหน้าสูงสุดที่จะพิมพ์ในบันทึกเอาต์พุต
USER รหัสผู้ใช้ที่ใช้ในการส่งงาน
PASSWORD รหัสผ่านของรหัสผู้ใช้ที่ระบุในพารามิเตอร์ USER
COND and RESTART สิ่งเหล่านี้ใช้ในการประมวลผลขั้นตอนงานแบบมีเงื่อนไขและอธิบายโดยละเอียดในขณะที่พูดถึงการประมวลผลตามเงื่อนไข

JCL แต่ละงานสามารถทำได้หลายขั้นตอน แต่ละขั้นตอนของงานสามารถเรียกใช้โปรแกรมได้โดยตรงหรือสามารถเรียกขั้นตอนซึ่งจะดำเนินการโปรแกรมอย่างน้อยหนึ่งโปรแกรม (ขั้นตอนงาน) คำสั่งซึ่งเก็บข้อมูลโปรแกรมขั้นตอนงาน / ขั้นตอนคือEXEC statement.

วัตถุประสงค์ของคำสั่ง EXEC คือเพื่อให้ข้อมูลที่จำเป็นสำหรับโปรแกรม / ขั้นตอนที่ดำเนินการในขั้นตอนงาน พารามิเตอร์ที่เข้ารหัสในคำสั่งนี้สามารถส่งผ่านข้อมูลไปยังโปรแกรมในการดำเนินการสามารถแทนที่พารามิเตอร์บางอย่างของคำสั่ง JOB และสามารถส่งผ่านพารามิเตอร์ไปยังโพรซีเดอร์ได้หากคำสั่ง EXEC เรียกใช้โพรซีเดอร์แทนที่จะเรียกใช้โปรแกรมโดยตรง

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL EXEC:

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

คำอธิบาย

ให้เราดูคำอธิบายของคำศัพท์ที่ใช้ในไวยากรณ์คำสั่ง EXEC ข้างต้น

ขั้นตอนที่ชื่อ

สิ่งนี้ระบุขั้นตอนงานภายใน JCL สามารถมีความยาวได้ตั้งแต่ 1 ถึง 8 โดยมีอักขระที่เป็นตัวเลขและตัวอักษร

EXEC

นี่คือคีย์เวิร์ดที่ระบุว่าเป็นคำสั่ง EXEC

POSITIONAL-PARAM

นี่คือพารามิเตอร์ตำแหน่งซึ่งมีได้สองประเภท:

พารามิเตอร์ตำแหน่ง คำอธิบาย
PGM หมายถึงชื่อโปรแกรมที่จะดำเนินการในขั้นตอนงาน
PROC นี่หมายถึงชื่อโพรซีเดอร์ที่จะดำเนินการในขั้นตอนงาน เราจะพูดถึงบทที่แยกต่างหาก

คีย์เวิร์ด - PARAM

ต่อไปนี้เป็นพารามิเตอร์คีย์เวิร์ดต่างๆสำหรับคำสั่ง EXEC คุณสามารถใช้พารามิเตอร์อย่างน้อยหนึ่งพารามิเตอร์ตามข้อกำหนดและคั่นด้วยเครื่องหมายจุลภาค:

พารามิเตอร์คำหลัก คำอธิบาย
PARM

ใช้เพื่อจัดเตรียมข้อมูลพาราเมทริกให้กับโปรแกรมที่กำลังดำเนินการในขั้นตอนงาน นี่เป็นฟิลด์ที่ขึ้นกับโปรแกรมและไม่มีกฎที่แน่นอนยกเว้นว่าต้องรวมค่า PARM ไว้ในใบเสนอราคาในกรณีที่มีอักขระพิเศษ

ตัวอย่างเช่นด้านล่างค่า "CUST1000" จะถูกส่งเป็นค่าตัวเลขและตัวอักษรไปยังโปรแกรม หากโปรแกรมอยู่ใน COBOL ค่าที่ส่งผ่านพารามิเตอร์ PARM ใน JCL จะได้รับใน LINKAGE SECTION ของโปรแกรม

ADDRSPC

สิ่งนี้ใช้เพื่อระบุว่าขั้นตอนงานต้องการหน่วยเก็บเสมือนหรือจริงสำหรับการดำเนินการ หน่วยเก็บข้อมูลเสมือนสามารถกำหนดเพจได้ในขณะที่หน่วยเก็บข้อมูลจริงไม่ได้และถูกวางไว้ในหน่วยความจำหลักเพื่อดำเนินการ ขั้นตอนงานซึ่งต้องการการดำเนินการที่เร็วขึ้นสามารถวางไว้ในที่จัดเก็บข้อมูลจริง ต่อไปนี้เป็นไวยากรณ์:

ADDRSPC=VIRT | REAL

เมื่อไม่มีการเข้ารหัส ADDRSPC VIRT จะเป็นค่าเริ่มต้น

ACCT

ข้อมูลนี้ระบุข้อมูลการบัญชีของขั้นตอนงาน ต่อไปนี้เป็นไวยากรณ์:

ACCT=(userid)

ซึ่งคล้ายกับพารามิเตอร์ตำแหน่ง accounting informationในคำสั่ง JOB หากมีการเข้ารหัสทั้งในคำสั่ง JOB และ EXEC ข้อมูลการบัญชีในคำสั่ง JOB จะใช้กับขั้นตอนงานทั้งหมดที่ไม่มีการเข้ารหัสพารามิเตอร์ ACCT พารามิเตอร์ ACCT ในคำสั่ง EXEC จะแทนที่ค่าที่มีอยู่ในคำสั่ง JOB สำหรับขั้นตอนงานนั้นเท่านั้น

พารามิเตอร์คีย์เวิร์ดทั่วไปของ EXEC และ JOB Statement

พารามิเตอร์คำหลัก คำอธิบาย
ADDRSPC ADDRSPC ที่เข้ารหัสในคำสั่ง JOB จะแทนที่ ADDRSPC ที่เข้ารหัสในคำสั่ง EXEC ของขั้นตอนงานใด ๆ
TIME ถ้า TIME ถูกเข้ารหัสในคำสั่ง EXEC จะใช้กับขั้นตอนงานนั้นเท่านั้น หากมีการระบุไว้ในคำสั่ง JOB และ EXEC ทั้งสองอย่างจะมีผลและอาจทำให้เกิดข้อผิดพลาดการหมดเวลาเนื่องจากข้อผิดพลาดอย่างใดอย่างหนึ่ง ไม่แนะนำให้ใช้พารามิเตอร์ TIME ทั้งในคำสั่ง JOB และ EXEC ร่วมกัน
REGION

หากมีการเข้ารหัส REGION ในคำสั่ง EXEC จะใช้กับขั้นตอนงานนั้นเท่านั้น

รหัส REGION ในคำสั่ง JOB จะแทนที่ REGION ที่เข้ารหัสในคำสั่ง EXEC ของขั้นตอนงานใด ๆ

COND

ใช้เพื่อควบคุมการดำเนินการขั้นตอนงานตามรหัสส่งคืนของขั้นตอนก่อนหน้า

ถ้าพารามิเตอร์ COND ถูกเข้ารหัสในคำสั่ง EXEC ของขั้นตอนงานพารามิเตอร์ COND ของคำสั่ง JOB (ถ้ามี) จะถูกละเว้น การทดสอบต่างๆที่สามารถทำได้โดยใช้พารามิเตอร์ COND ได้อธิบายไว้ในการประมวลผลตามเงื่อนไข

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างง่ายๆของสคริปต์ JCL พร้อมกับคำสั่ง JOB และ EXEC:

//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,
//      NOTIFY=&SYSUID
//*
//STEP010 EXEC PGM=MYCOBOL,PARAM=CUST1000,
//      ACCT=(XXXX),REGION=8K,ADDRSPC=REAL,TIME=1440

ชุดข้อมูลคือไฟล์เมนเฟรมที่มีการจัดระเบียบในรูปแบบเฉพาะ ชุดข้อมูลจะถูกเก็บไว้ใน Direct Access Storage Device (DASD) หรือเทปของเมนเฟรมและเป็นพื้นที่จัดเก็บข้อมูลพื้นฐาน หากข้อมูลเหล่านี้จำเป็นต้องใช้ / สร้างในโปรแกรมแบตช์ชื่อฟิสิคัลของไฟล์ (เช่นชุดข้อมูล) พร้อมกับรูปแบบไฟล์และองค์กรจะถูกเข้ารหัสใน JCL

คำจำกัดความของชุดข้อมูลแต่ละชุดที่ใช้ใน JCL จะได้รับโดยใช้ DD statement. ทรัพยากรอินพุตและเอาต์พุตที่ต้องการโดยขั้นตอนงานจำเป็นต้องได้รับการอธิบายไว้ในคำสั่ง DD พร้อมข้อมูลเช่นองค์กรชุดข้อมูลข้อกำหนดในการจัดเก็บและความยาวของบันทึก

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL DD:

//DD-name DD Parameters

คำอธิบาย

ให้เราดูคำอธิบายของคำศัพท์ที่ใช้ในไวยากรณ์คำสั่ง DD ข้างต้น

DD-NAME

DD-NAME ระบุชุดข้อมูลหรือทรัพยากรอินพุต / เอาต์พุต หากนี่เป็นไฟล์อินพุต / เอาต์พุตที่ใช้โดยโปรแกรม COBOL / Assembler ไฟล์จะถูกอ้างอิงโดยชื่อนี้ภายในโปรแกรม

DD

นี่คือคีย์เวิร์ดสำหรับระบุว่าเป็นคำสั่ง DD

พารามิเตอร์

ต่อไปนี้เป็นพารามิเตอร์ต่างๆสำหรับคำสั่ง DD คุณสามารถใช้พารามิเตอร์อย่างน้อยหนึ่งพารามิเตอร์ตามข้อกำหนดและคั่นด้วยเครื่องหมายจุลภาค:

พารามิเตอร์ คำอธิบาย
DSN

พารามิเตอร์ DSN อ้างถึงชื่อชุดข้อมูลจริงของชุดข้อมูลที่สร้างขึ้นใหม่หรือที่มีอยู่ ค่า DSN สามารถประกอบด้วยชื่อย่อยแต่ละชื่อที่มีความยาว 1 ถึง 8 อักขระคั่นด้วยจุดและความยาวรวม 44 อักขระ (ตัวเลขและตัวอักษร) ต่อไปนี้เป็นไวยากรณ์:

DSN=Physical Dataset Name

Temporary datasetsต้องการพื้นที่จัดเก็บสำหรับระยะเวลางานเท่านั้นและจะถูกลบเมื่องานเสร็จสิ้น ชุดข้อมูลดังกล่าวแสดงเป็นDSN=&name หรือเพียงไม่ระบุ DSN

หากจะใช้ชุดข้อมูลชั่วคราวที่สร้างขึ้นโดยขั้นตอนงานในขั้นตอนงานถัดไปชุดข้อมูลดังกล่าวจะอ้างอิงเป็น DSN=*.stepname.ddname. นี้เรียกว่า Backward Referencing.

DISP

พารามิเตอร์ DISP ใช้เพื่ออธิบายสถานะของชุดข้อมูลการจัดการเมื่อสิ้นสุดขั้นตอนงานในการเสร็จสิ้นปกติและผิดปกติ ไม่จำเป็นต้องใช้ DISP ในคำสั่ง DD ก็ต่อเมื่อชุดข้อมูลถูกสร้างและลบในขั้นตอนงานเดียวกัน (เช่นชุดข้อมูลชั่วคราว) ต่อไปนี้เป็นไวยากรณ์:

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

ต่อไปนี้เป็นค่าที่ถูกต้องสำหรับ status:

  • NEW: ชุดข้อมูลถูกสร้างขึ้นใหม่โดยขั้นตอนงาน OUTPUT1 ในตัวอย่างด้านบน

  • OLD: ชุดข้อมูลถูกสร้างขึ้นแล้วและจะถูกเขียนทับในขั้นตอนงาน ขั้นตอนงานจะได้รับสิทธิ์การเข้าถึงพิเศษในชุดข้อมูลและไม่มีงานอื่นใดที่สามารถเข้าถึงชุดข้อมูลนี้ได้จนกว่าขั้นตอนงานจะเสร็จสิ้น

  • SHR: ชุดข้อมูลถูกสร้างขึ้นแล้วและจะอ่านในขั้นตอนงาน ชุดข้อมูลสามารถอ่านได้จากหลายงานในเวลาเดียวกัน ตัวอย่าง: INPUT1 และ INPUT2

  • MOD: ชุดข้อมูลถูกสร้างขึ้นแล้ว การจัดการนี้จะถูกใช้เมื่อจำเป็นต้องต่อท้ายระเบียนใหม่เข้ากับชุดข้อมูลที่มีอยู่ (ระเบียนที่มีอยู่จะไม่ถูกเขียนทับ)

normal-disposition พารามิเตอร์สามารถรับค่าใดค่าหนึ่งต่อไปนี้

  • CATLG, UNCATLG, DELETE, PASS และ KEEP

abnormal-disposition พารามิเตอร์สามารถรับค่าใดค่าหนึ่งต่อไปนี้

  • CATLG, UNCATLG, DELETE และ KEEP

นี่คือคำอธิบายของพารามิเตอร์ CATLG, UNCATLG, DELETE, PASS และ KEEP:

  • CATLG : ชุดข้อมูลจะถูกเก็บไว้พร้อมกับรายการในแค็ตตาล็อกระบบ

  • UNCATLG : ชุดข้อมูลยังคงอยู่ แต่รายการแค็ตตาล็อกระบบจะถูกลบออก

  • KEEP: ชุดข้อมูลจะถูกเก็บไว้โดยไม่เปลี่ยนแปลงรายการแค็ตตาล็อกใด ๆ KEEP เป็นเพียงการจัดการที่ถูกต้องสำหรับไฟล์ VSAM ซึ่งจะใช้สำหรับชุดข้อมูลถาวรเท่านั้น

  • DELETE : ชุดข้อมูลถูกลบออกจากแค็ตตาล็อกผู้ใช้และระบบ

  • PASS: สิ่งนี้ใช้ได้สำหรับการจัดการตามปกติเท่านั้น ใช้เมื่อชุดข้อมูลจะถูกส่งผ่านและประมวลผลโดยขั้นตอนงานถัดไปใน JCL

เมื่อไม่ได้ระบุพารามิเตอร์ย่อยของ DISP ค่าเริ่มต้นจะเป็นดังนี้:

  • status : NEW คือค่าเริ่มต้น

  • normal-disposition : หากสถานะเป็นใหม่การจัดการปกติเริ่มต้นคือ DELETE มิฉะนั้นจะเป็น KEEP

  • abnormal-disposition : เหมือนกับการจัดการปกติ

DCB

พารามิเตอร์ Data Control Block (DCB) ให้รายละเอียดลักษณะทางกายภาพของชุดข้อมูล พารามิเตอร์นี้จำเป็นสำหรับชุดข้อมูลที่สร้างขึ้นใหม่ในขั้นตอนงาน

LRECL คือความยาวของแต่ละเร็กคอร์ดที่อยู่ในชุดข้อมูล

RECFM คือรูปแบบบันทึกของชุดข้อมูล RECFM สามารถเก็บค่า FB, V หรือ VB FB เป็นองค์กรบล็อกแบบคงที่ซึ่งมีการจัดกลุ่มระเบียนเชิงตรรกะตั้งแต่หนึ่งรายการขึ้นไปภายในบล็อกเดียว V คือการจัดระเบียบแบบแปรผันที่มีการวางเร็กคอร์ดตรรกะความยาวตัวแปรหนึ่งไว้ในบล็อกทางกายภาพ VB คือองค์กร Variable Block ที่มีบันทึกตรรกะความยาวตัวแปรตั้งแต่หนึ่งตัวขึ้นไปภายในบล็อกทางกายภาพ

BLKSIZE คือขนาดของบล็อกจริง ยิ่งบล็อกมีขนาดใหญ่จำนวนระเบียนสำหรับไฟล์ FB หรือ VB ก็ยิ่งมากขึ้น

DSORG คือประเภทขององค์กรชุดข้อมูล DSORG สามารถเก็บค่า PS (Physical Sequential), PO (Partitioned Organization) และ DA (Direct Organization)

เมื่อมีความจำเป็นต้องจำลองค่า DCB ของชุดข้อมูลหนึ่งไปยังอีกชุดหนึ่งภายในขั้นตอนงานเดียวกันหรือ JCL จะระบุเป็น DCB = * stepname.ddname โดยที่ stepname คือชื่อของขั้นตอนงานและ ddname คือชุดข้อมูลที่ DCB ถูกคัดลอก

ตรวจสอบตัวอย่างด้านล่างโดยที่ RECFM = FB, LRECL = 80 สร้าง DCB ของชุดข้อมูล OUTPUT1

SPACE

พารามิเตอร์ SPACE ระบุพื้นที่ที่ต้องการสำหรับชุดข้อมูลใน DASD (Direct Access Storage Disk) ต่อไปนี้เป็นไวยากรณ์:

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

นี่คือคำอธิบายของพารามิเตอร์ที่ใช้ทั้งหมด:

  • spcunits : อาจเป็นหนึ่งใน CYL (Cylinder), TRK (Tracks) หรือ BLKSIZE (Block Size)

  • pri : นี่คือพื้นที่หลักที่จำเป็นสำหรับชุดข้อมูล

  • sec : นี่คือพื้นที่เพิ่มเติมที่จำเป็นเมื่อพื้นที่หลักไม่เพียงพอ

  • ir : นี่คือบล็อกไดเร็กทอรีที่จำเป็นหากชุดข้อมูลเป็น PDS (Partitioned Dataset) ที่มีสมาชิกอยู่ภายใน

  • RLSE : ใช้เพื่อปล่อยพื้นที่ที่ไม่ได้ใช้เมื่องานเสร็จสิ้น

UNIT

พารามิเตอร์ UNIT และ VOL แสดงอยู่ในแค็ตตาล็อกระบบสำหรับชุดข้อมูลที่ทำแค็ตตาล็อกและด้วยเหตุนี้จึงสามารถเข้าถึงได้ด้วยชื่อ DSN ที่มีอยู่จริง แต่สำหรับชุดข้อมูลที่ไม่ได้บันทึกรายการคำสั่ง DD ควรมีพารามิเตอร์เหล่านี้ สำหรับชุดข้อมูลใหม่ที่จะสร้างขึ้นสามารถระบุพารามิเตอร์ UNIT / VOL หรือ Z / OS จะจัดสรรอุปกรณ์และโวลุ่มที่เหมาะสม

พารามิเตอร์ UNIT ระบุประเภทของอุปกรณ์ที่จัดเก็บชุดข้อมูล สามารถระบุประเภทอุปกรณ์ได้โดยใช้ Hardware Address หรือ Device type group ต่อไปนี้เป็นไวยากรณ์:

UNIT=DASD | SYSDA

โดยที่ DASD ย่อมาจาก Direct Access Storage Device และ SYSDA ย่อมาจาก System Direct Access และหมายถึงอุปกรณ์จัดเก็บดิสก์ที่มีอยู่ถัดไป

VOL

พารามิเตอร์ VOL ระบุหมายเลขโวลุ่มบนอุปกรณ์ที่ระบุโดยพารามิเตอร์ UNIT ต่อไปนี้เป็นไวยากรณ์:

VOL=SER=(v1,v2)

โดยที่ v1, v2 คือหมายเลขซีเรียลของโวลุ่ม คุณสามารถใช้ไวยากรณ์ต่อไปนี้ได้เช่นกัน:

VOL=REF=*.DDNAME

โดยที่ REF คือการอ้างอิงย้อนกลับไปยังหมายเลขซีเรียลของไดรฟ์ข้อมูลของชุดข้อมูลในขั้นตอนงานก่อนหน้านี้ใน JCL

SYSOUT

พารามิเตอร์คำสั่ง DD ที่กล่าวถึงนั้นสอดคล้องกับข้อมูลที่จัดเก็บในชุดข้อมูล พารามิเตอร์ SYSOUT กำหนดทิศทางข้อมูลไปยังอุปกรณ์เอาต์พุตตามคลาสที่ระบุ ต่อไปนี้เป็นไวยากรณ์

SYSOUT=class

โดยที่ถ้าคลาสเป็น A จะส่งเอาต์พุตไปยังเครื่องพิมพ์และถ้าคลาสเป็น * จากนั้นนำเอาต์พุตไปยังปลายทางเดียวกันกับพารามิเตอร์ MSGCLASS ในคำสั่ง JOB

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างซึ่งใช้ประโยชน์จากคำสั่ง DD พร้อมกับพารามิเตอร์ต่างๆที่อธิบายข้างต้น:

//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,
//         NOTIFY=&SYSUID
//*
//STEP010  EXEC PGM=ICETOOL,ADDRSPC=REAL
//*
//INPUT1   DD DSN=TUTO.SORT.INPUT1,DISP=SHR
//INPUT2   DD DSN=TUTO.SORT.INPUT2,DISP=SHR,UNIT=SYSDA,
//         VOL=SER=(1243,1244)
//OUTPUT1  DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
//         RECFM=FB,LRECL=80,SPACE=(CYL,(10,20))
//OUTPUT2  DD SYSOUT=*

Base Libraryคือ Partitioned Dataset (PDS) ซึ่งเก็บโมดูลโหลดของโปรแกรมที่จะดำเนินการใน JCL หรือโพรซีเดอร์แค็ตตาล็อกซึ่งเรียกว่าในโปรแกรม สามารถระบุไลบรารีฐานสำหรับ JCL ทั้งหมดในไฟล์JOBLIB ไลบรารีหรือสำหรับขั้นตอนงานเฉพาะในไฟล์ STEPLIB คำให้การ.

ประกาศ JOBLIB

JOBLIBคำสั่งใช้เพื่อระบุตำแหน่งของโปรแกรมที่จะดำเนินการใน JCL คำสั่ง JOBLIB ถูกระบุไว้หลังคำสั่ง JOB และก่อนคำสั่ง EXEC สามารถใช้สำหรับขั้นตอนและโปรแกรมในสตรีมเท่านั้น

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL JOBLIB:

//JOBLIB DD DSN=dsnname,DISP=SHR

คำสั่ง JOBLIB ใช้ได้กับคำสั่ง EXEC ทั้งหมดภายใน JCL โปรแกรมที่ระบุในคำสั่ง EXEC จะถูกค้นหาในไลบรารี JOBLIB ตามด้วยไลบรารีระบบ

ตัวอย่างเช่นถ้าคำสั่ง EXEC กำลังเรียกใช้โปรแกรม COBOL โมดูลโหลดของโปรแกรม COBOL ควรอยู่ในไลบรารี JOBLIB

คำชี้แจง STEPLIB

STEPLIBคำสั่งถูกใช้เพื่อระบุตำแหน่งของโปรแกรมที่จะดำเนินการภายใน Job Step คำสั่ง STEPLIB ถูกระบุไว้หลังคำสั่ง EXEC และก่อนคำสั่ง DD ของขั้นตอนงาน

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL STEPLIB:

//STEPLIB DD DSN=dsnname,DISP=SHR

โปรแกรมที่ระบุในคำสั่ง EXEC จะถูกค้นหาในไลบรารี STEPLIB ตามด้วยไลบรารีระบบ STEPLIB ที่เข้ารหัสในขั้นตอนงานจะแทนที่คำสั่ง JOBLIB

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงการใช้คำสั่ง JOBLIB และ STEPLIB:

//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID
//*
//JOBLIB DD DSN=MYPROC.BASE.LIB1,DISP=SHR
//*
//STEP1 EXEC PGM=MYPROG1
//INPUT1 DD DSN=MYFILE.SAMPLE.INPUT1,DISP=SHR
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
//           RECFM=FB,LRECL=80
//*
//STEP2 EXEC PGM=MYPROG2
//STEPLIB DD DSN=MYPROC.BASE.LIB2,DISP=SHR
//INPUT2 DD DSN=MYFILE.SAMPLE.INPUT2,DISP=SHR
//OUTPUT2 DD DSN=MYFILES.SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
//           RECFM=FB,LRECL=80

ที่นี่โมดูลโหลดของโปรแกรม MYPROG1 (ในขั้นตอนที่ 1) ถูกค้นหาใน MYPROC.SAMPLE.LIB1 หากไม่พบจะถูกค้นหาในไลบรารีระบบ ในขั้นตอนที่ 2 STEPLIB จะแทนที่ JOBLIB และโหลดโมดูลของโปรแกรม MYPROG2 จะถูกค้นหาใน MYPROC.SAMPLE.LIB2 จากนั้นในไลบรารีระบบ

รวมคำชี้แจง

ชุดคำสั่ง JCL ที่เข้ารหัสภายในสมาชิกของ PDS สามารถรวมเข้ากับ JCL โดยใช้ไฟล์ INCLUDEคำให้การ. เมื่อ JES ตีความ JCL ชุดของคำสั่ง JCL ภายในสมาชิก INCLUDE จะแทนที่คำสั่ง INCLUDE

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL INCLUDE:

//name INCLUDE MEMBER=member-name

วัตถุประสงค์หลักของคำสั่ง INCLUDE คือการนำกลับมาใช้ใหม่ ตัวอย่างเช่นไฟล์ทั่วไปที่จะใช้ใน JCL จำนวนมากสามารถเข้ารหัสเป็นคำสั่ง DD ภายในสมาชิก INCLUDE และใช้ใน JCL

คำสั่ง Dummy DD, ข้อมูลจำเพาะของการ์ดข้อมูล, PROCs, JOB, คำสั่ง PROC ไม่สามารถเข้ารหัสได้ภายในสมาชิก INCLUDE คำสั่ง INLCUDE สามารถเข้ารหัสได้ภายในสมาชิก INCLUDE และการซ้อนเพิ่มเติมสามารถทำได้ถึง 15 ระดับ

คำชี้แจง JCLLIB

JCLLIBคำสั่งใช้เพื่อระบุไลบรารีส่วนตัวที่ใช้ในงาน สามารถใช้ได้ทั้งกับขั้นตอนในสตรีมและแคตตาล็อก

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของคำสั่ง JCL JCLLIB:

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

ไลบรารีที่ระบุในคำสั่ง JCLLIB จะถูกค้นหาตามลำดับที่กำหนดเพื่อค้นหาโปรแกรมโพรซีเดอร์และ INCLUDE สมาชิกที่ใช้ในงาน JCLLIB สามารถมีได้เพียงคำสั่งเดียวใน JCL ระบุไว้หลังคำสั่ง JOB และก่อนคำสั่ง EXEC และ INCLUDE แต่ไม่สามารถเข้ารหัสได้ภายในสมาชิก INCLUDE

ตัวอย่าง

ในตัวอย่างต่อไปนี้โปรแกรม MYPROG3 และ INCLUDE สมาชิก MYINCL จะถูกค้นหาตามลำดับ MYPROC.BASE.LIB1, MYPROC.BASE.LIB2, ไลบรารีระบบ

//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID
//*
//MYLIB JCLLIB ORDER=(MYPROC.BASE.LIB1,MYPROC.BASE.LIB2)
//*
//STEP1 EXEC PGM=MYPROG3
//INC INCLUDE MEMBER=MYINCL
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
//           RECFM=FB,LRECL=80
//*

JCL Proceduresเป็นชุดคำสั่งภายใน JCL ที่จัดกลุ่มเข้าด้วยกันเพื่อทำหน้าที่เฉพาะ โดยปกติส่วนคงที่ของ JCL จะถูกเข้ารหัสในขั้นตอน ส่วนที่แตกต่างกันของงานถูกเข้ารหัสไว้ใน JCL

คุณสามารถใช้ขั้นตอนเพื่อให้เกิดการทำงานแบบขนานของโปรแกรมโดยใช้ไฟล์อินพุตหลายไฟล์ สามารถสร้าง JCL สำหรับไฟล์อินพุตแต่ละไฟล์และสามารถเรียกใช้โพรซีเดอร์เดียวพร้อมกันได้โดยส่งชื่อไฟล์อินพุตเป็นพารามิเตอร์สัญลักษณ์

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของการกำหนดโพรซีเดอร์ JCL:

//*
//Step-name EXEC procedure name

เนื้อหาของโพรซีเดอร์จะอยู่ใน JCL สำหรับโพรซีเดอร์ในสตรีม เนื้อหาจะถูกเก็บไว้ภายในสมาชิกอื่นของไลบรารีฐานสำหรับโพรซีเดอร์ที่ทำแค็ตตาล็อก บทนี้จะอธิบายขั้นตอนสองประเภทที่มีอยู่ใน JCL และสุดท้ายเราจะมาดูกันว่าเราสามารถซ้อนขั้นตอนต่างๆได้อย่างไร

ขั้นตอนการสตรีม

เมื่อโพรซีเดอร์ถูกเข้ารหัสภายในสมาชิก JCL เดียวกันจะเรียกว่า Instream Procedure ควรเริ่มต้นด้วยคำสั่ง PROC และลงท้ายด้วยคำสั่ง PEND

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//INSTPROC   PROC                //*START OF PROCEDURE
//PROC1		EXEC PGM=SORT
//SORTIN	DD DSN=&DSNAME,DISP=SHR
//SORTOUT	DD SYSOUT=*MYINCL
//SYSOUT	DD SYSOUT=*
//SYSIN		DD DSN=&DATAC LRECL=80
//           PEND               //*END OF PROCEDURE
//*
//STEP1      EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT1,
//           DATAC=MYDATA.BASE.LIB1(DATA1)
//*
//STEP2      EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT2
//           DATAC=MYDATA.BASE.LIB1(DATA1)
//*

ในตัวอย่างข้างต้นโพรซีเดอร์ INSTPROC ถูกเรียกใน STEP1 และ STEP2 โดยใช้ไฟล์อินพุตที่แตกต่างกัน พารามิเตอร์ DSNAME และ DATAC สามารถเข้ารหัสด้วยค่าที่แตกต่างกันในขณะที่เรียกโพรซีเดอร์และสิ่งเหล่านี้เรียกว่าsymbolic parameters. อินพุตที่แตกต่างกันไปยัง JCL เช่นชื่อไฟล์ดาต้าการ์ดค่า PARM ฯลฯ จะถูกส่งผ่านเป็นพารามิเตอร์สัญลักษณ์ไปยังโพรซีเดอร์

ในขณะที่เข้ารหัสพารามิเตอร์สัญลักษณ์ห้ามใช้ KEYWORDS, PARAMETERS หรือ SUB-PARAMETERS เป็นชื่อสัญลักษณ์ ตัวอย่าง: อย่าใช้ TIME = & TIME แต่ใช่คุณสามารถใช้ TIME = & TM ได้และถือว่าเป็นวิธีการเข้ารหัสสัญลักษณ์ที่ถูกต้อง

เรียกใช้พารามิเตอร์สัญลักษณ์ที่ผู้ใช้กำหนด JCL Symbols. มีสัญลักษณ์บางอย่างที่เรียกว่าsystem symbolsซึ่งใช้สำหรับการดำเนินการล็อกออนงาน สัญลักษณ์ระบบเดียวที่ใช้ในชุดงานโดยผู้ใช้ปกติคือ&SYSUID และใช้ในพารามิเตอร์ NOTIFY ในคำสั่ง JOB

ขั้นตอนการลงรายการบัญชี

เมื่อแยกโพรซีเดอร์ออกจาก JCL และเข้ารหัสในที่เก็บข้อมูลอื่นจะเรียกว่าไฟล์ Cataloged Procedure. คำสั่ง PROC ไม่จำเป็นต้องเขียนโค้ดในขั้นตอนการลงรายการบัญชี ต่อไปนี้เป็นตัวอย่างของ JCL ที่เรียกขั้นตอน CATLPROC:

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

ที่นี่ขั้นตอน CATLPROC อยู่ในรายการ MYCOBOL.BASE.LIB1 PROG, DATAC และ DSNAME ถูกส่งผ่านเป็นพารามิเตอร์สัญลักษณ์ไปยังโพรซีเดอร์ CATLPROC

//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//PROC1     EXEC PGM=&PROG
//STEPLIB   DD DSN=&BASELB,DISP=SHR
//IN1       DD DSN=&DSNAME,DISP=SHR
//OUT1      DD SYSOUT=*
//SYSOUT    DD SYSOUT=*
//SYSIN     DD DSN=&DATAC
//*

ภายในขั้นตอนพารามิเตอร์สัญลักษณ์ PROG และ BASELB จะถูกเข้ารหัส โปรดทราบว่าพารามิเตอร์ PROG ภายในโพรซีเดอร์ถูกแทนที่ด้วยค่าใน JCL และด้วยเหตุนี้ PGM จึงรับค่า CATPRC1 ในระหว่างการดำเนินการ

ขั้นตอนที่ซ้อนกัน

การเรียกโพรซีเดอร์จากภายในโพรซีเดอร์เรียกว่า a nested procedure. ขั้นตอนสามารถซ้อนกันได้ถึง 15 ระดับ การซ้อนสามารถอยู่ในสตรีมหรือแค็ตตาล็อกได้อย่างสมบูรณ์ เราไม่สามารถเขียนโค้ดขั้นตอนในสตรีมได้

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//SETNM     SET DSNM1=INPUT1,DSNM2=OUTPUT1
//INSTPRC1  PROC               //* START OF PROCEDURE 1
//STEP1        EXEC PGM=SORT,DISP=SHR
//SORTIN       DD DSN=&DSNM1,DISP=SHR
//SORTOUT      DD DSN=&DSNM2,DISP=(,PASS)
//SYSOUT       DD SYSOUT=*
//SYSIN        DD DSN=&DATAC
//*
//STEP2        EXEC PROC=INSTPRC2,DSNM2=MYDATA.URMI.OUTPUT2
//          PEND               //* END OF PROCEDURE 1
//*
//INSTPRC2  PROC               //* START OF PROCEDURE 2
//STEP1        EXEC PGM=SORT
//SORTIN       DD DSN=*.INSTPRC1.STEP1.SORTOUT
//SORTOUT      DD DSN=&DSNM2,DISP=OLD
//SYSOUT       DD SYSOUT=*
//SYSIN        DD DSN=&DATAC
//          PEND               //* END OF PROCEDURE 2
//*
//JSTEP1    EXEC INSTPRC1,DSNM1=MYDATA.URMI.INPUT1,
//          DATAC=MYDATA.BASE.LIB1(DATA1)
//*

ในตัวอย่างข้างต้น JCL เรียกโพรซีเดอร์ INSTPRC1 ใน JSTEP1 และโพรซีเดอร์ INSTPRC2 ถูกเรียกภายในโพรซีเดอร์ INSTPRC1 ที่นี่เอาต์พุตของ INSTPRC1 (SORTOUT) จะถูกส่งผ่านเป็นอินพุต (SORTIN) ไปยัง INSTPRC2

SET statementใช้เพื่อกำหนดสัญลักษณ์ที่ใช้กันทั่วไปในขั้นตอนหรือขั้นตอนงาน เริ่มต้นค่าก่อนหน้าในชื่อสัญลักษณ์ ต้องมีการกำหนดก่อนการใช้ชื่อสัญลักษณ์ใน JCL เป็นครั้งแรก

ลองดูคำอธิบายด้านล่างเพื่อทำความเข้าใจเพิ่มเติมเกี่ยวกับโปรแกรมข้างต้น:

  • พารามิเตอร์ SET เริ่มต้น DSNM1 = INPUT1 และ DSNM2 = OUTPUT1

  • เมื่อเรียก INSTPRC1 ใน JSTEP1 ของ JCL, DSNM1 = MYDATA.URMI.INPUT1 และ DSNM2 = OUTPUT1 กล่าวคือค่าเริ่มต้นในคำสั่ง SET จะถูกรีเซ็ตด้วยค่าที่กำหนดในขั้นตอน / ขั้นตอนงานใด ๆ

  • เมื่อเรียก INSTPRC2 ในขั้นตอนที่ 2 ของ INSTPRC1, DSNM1 = MYDATA.URMI.INPUT1 และ DSNM2 = MYDATA.URMI.OUTPUT2

ระบบป้อนงานใช้สองวิธีในการประมวลผลแบบมีเงื่อนไขใน JCL เมื่องานเสร็จสิ้นรหัสส่งคืนจะถูกตั้งค่าตามสถานะของการดำเนินการ รหัสส่งคืนอาจเป็นตัวเลขระหว่าง 0 (การดำเนินการสำเร็จ) ถึง 4095 (ที่ไม่ใช่ศูนย์แสดงเงื่อนไขข้อผิดพลาด) ค่าทั่วไปที่พบบ่อยที่สุดคือ:

  • 0 = ปกติ - ตกลงทั้งหมด

  • 4 = คำเตือน - ข้อผิดพลาดหรือปัญหาเล็กน้อย

  • 8 = ข้อผิดพลาด - ข้อผิดพลาดหรือปัญหาที่สำคัญ

  • 12 = ข้อผิดพลาดที่รุนแรง - ข้อผิดพลาดหรือปัญหาที่สำคัญผลลัพธ์ไม่ควรเชื่อถือได้

  • 16 = Terminal error - ปัญหาร้ายแรงมากอย่าใช้ผลลัพธ์

การดำเนินการขั้นตอนงานสามารถควบคุมได้ตามรหัสส่งคืนของขั้นตอนก่อนหน้าโดยใช้ COND พารามิเตอร์และ IF-THEN-ELSE สร้างซึ่งได้อธิบายไว้ในบทช่วยสอนนี้

พารามิเตอร์ COND

CONDสามารถเข้ารหัสพารามิเตอร์ในคำสั่ง JOB หรือ EXEC ของ JCL เป็นการทดสอบโค้ดส่งคืนของขั้นตอนงานก่อนหน้านี้ หากการทดสอบได้รับการประเมินว่าเป็นจริงการดำเนินการขั้นตอนงานปัจจุบันจะถูกข้าม การข้ามเป็นเพียงการละเว้นขั้นตอนงานและไม่ใช่การเลิกจ้างที่ผิดปกติ สามารถมีเงื่อนไขได้สูงสุดแปดเงื่อนไขในการทดสอบเดียว

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของพารามิเตอร์ JCL COND:

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

นี่คือคำอธิบายของพารามิเตอร์ที่ใช้:

  • rc : นี่คือรหัสส่งคืน

  • logical-operator : อาจเป็น GT (มากกว่า), GE (มากกว่าหรือเท่ากับ), EQ (เท่ากับ), LT (น้อยกว่า), LE (น้อยกว่าหรือเท่ากับ) หรือ NE (ไม่เท่ากับ)

  • stepname : นี่คือขั้นตอนงานที่ใช้รหัสส่งคืนในการทดสอบ

สองเงื่อนไขสุดท้าย (a) COND = แม้และ (b) COND = เท่านั้นได้อธิบายไว้ด้านล่างในบทช่วยสอนนี้

COND สามารถเข้ารหัสได้ทั้งในคำสั่ง JOB หรือคำสั่ง EXEC และในทั้งสองกรณีจะทำงานแตกต่างกันดังที่อธิบายไว้ด้านล่าง:

COND ภายในคำสั่ง JOB

เมื่อมีการเข้ารหัส COND ในคำสั่ง JOB เงื่อนไขจะถูกทดสอบสำหรับทุกขั้นตอนของงาน เมื่อเงื่อนไขเป็นจริงในขั้นตอนงานใดขั้นตอนหนึ่งระบบจะข้ามไปพร้อมกับขั้นตอนงานที่ตามมา ต่อไปนี้เป็นตัวอย่าง:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID,COND=(5,LE)
//*
//STEP10 EXEC PGM=FIRSTP  
//* STEP10 executes without any test being performed.

//STEP20 EXEC PGM=SECONDP 
//* STEP20 is bypassed, if RC of STEP10 is 5 or above. //* Say STEP10 ends with RC4 and hence test is false. //* So STEP20 executes and lets say it ends with RC16.

//STEP30 EXEC PGM=SORT
//* STEP30 is bypassed since 5 <= 16.

COND ภายในคำสั่ง EXEC

เมื่อ COND ถูกเข้ารหัสในคำสั่ง EXEC ของขั้นตอนงานและพบว่าเป็นจริงขั้นตอนงานนั้นเท่านั้นที่จะถูกข้ามและการดำเนินการจะดำเนินต่อจากขั้นตอนงานถัดไป

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),(10,GT,STP02))
//* In STP03, first condition fails and hence STP03 executes. //* Since STP02 is bypassed, the condition (10,GT,STP02) in //* STP03 is not tested.

COND = แม้

เมื่อมีการเข้ารหัส COND = EVEN ขั้นตอนงานปัจจุบันจะถูกดำเนินการแม้ว่าขั้นตอนก่อนหน้านี้จะยุติลงอย่างผิดปกติก็ตาม หากมีการเข้ารหัสเงื่อนไข RC อื่น ๆ พร้อมกับ COND = EVEN ขั้นตอนงานจะดำเนินการหากไม่มีเงื่อนไข RC ใดเป็นจริง

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)
//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),EVEN)
//* In STP03, condition (10,LT,STP01) evaluates to true, //* hence the step is bypassed.

COND = เท่านั้น

เมื่อมีการเข้ารหัส COND = ON เท่านั้นขั้นตอนงานปัจจุบันจะถูกดำเนินการเฉพาะเมื่อขั้นตอนก่อนหน้านี้ยุติอย่างผิดปกติ หากมีการเข้ารหัสเงื่อนไข RC อื่น ๆ พร้อมด้วย COND = ONLY ขั้นตอนงานจะดำเนินการหากไม่มีเงื่อนไข RC ใดเป็นจริงและขั้นตอนงานก่อนหน้านี้ล้มเหลวอย่างผิดปกติ

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(4,EQ,STP01)
//* In STP02, condition evaluates to FALSE, step is executed //* and assume the step abends.

//STP03 EXEC PGM=IEBGENER,COND=((0,EQ,STP01),ONLY)
//* In STP03, though the STP02 abends, the condition //* (0,EQ,STP01) is met. Hence STP03 is bypassed.

IF-THEN-ELSE สร้าง

อีกวิธีหนึ่งในการควบคุมการประมวลผลงานคือการใช้โครงสร้าง IF-THEN-ELSE สิ่งนี้ให้ความยืดหยุ่นมากขึ้นและวิธีการประมวลผลตามเงื่อนไขที่เป็นมิตรกับผู้ใช้

ไวยากรณ์

ต่อไปนี้เป็นไวยากรณ์พื้นฐานของ JCL IF-THEN-ELSE Construct:

//name IF condition THEN
list of statements //* action to be taken when condition is true
//name ELSE 
list of statements //* action to be taken when condition is false
//name ENDIF

ต่อไปนี้เป็นคำอธิบายของข้อกำหนดที่ใช้ใน IF-THEN-ELSE Construct ด้านบน:

  • name : นี่เป็นทางเลือกและชื่อสามารถมีอักขระที่เป็นตัวเลขและตัวอักษรได้ 1 ถึง 8 ตัวโดยขึ้นต้นด้วยตัวอักษร #, $ หรือ @

  • Condition : เงื่อนไขจะมีรูปแบบ: KEYWORD OPERATOR VALUE, ที่ไหน KEYWORDSสามารถเป็น RC (Return Code), ABENDCC (System หรือรหัสการเติมข้อมูลของผู้ใช้), ABEND, RUN (ขั้นตอนที่เริ่มดำเนินการ) อันOPERATOR สามารถเป็นตัวดำเนินการเชิงตรรกะ (AND (&), OR (|)) หรือตัวดำเนินการเชิงสัมพันธ์ (<, <=,>,> =, <>)

ตัวอย่าง

ต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้ IF-THEN-ELSE:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//PRC1   PROC
//PST1	   EXEC PGM=SORT
//PST2	   EXEC PGM=IEBGENER
//       PEND
//STP01  EXEC PGM=SORT 
//IF1    IF STP01.RC = 0 THEN
//STP02     EXEC PGM=MYCOBB1,PARM=123
//       ENDIF
//IF2    IF STP01.RUN THEN
//STP03a    EXEC PGM=IEBGENER
//STP03b    EXEC PGM=SORT
//       ENDIF
//IF3    IF STP03b.!ABEND THEN
//STP04     EXEC PGM=MYCOBB1,PARM=456
//       ELSE
//       ENDIF
//IF4    IF (STP01.RC = 0 & STP02.RC <= 4) THEN
//STP05     EXEC PROC=PRC1
//       ENDIF
//IF5    IF STP05.PRC1.PST1.ABEND THEN
//STP06     EXEC PGM=MYABD
//       ELSE
//STP07     EXEC PGM=SORT
//       ENDIF

ลองดูโปรแกรมด้านบนเพื่อทำความเข้าใจในรายละเอียดเพิ่มเติมเล็กน้อย:

  • รหัสส่งคืนของ STP01 ถูกทดสอบใน IF1 ถ้าเป็น 0 แสดงว่า STP02 ถูกเรียกใช้งาน มิฉะนั้นการประมวลผลจะไปที่คำสั่ง IF ถัดไป (IF2)

  • ใน IF2 ถ้า STP01 เริ่มดำเนินการแล้ว STP03a และ STP03b จะถูกเรียกใช้งาน

  • ใน IF3 ถ้า STP03b ไม่ ABEND แสดงว่า STP04 จะดำเนินการ ใน ELSE ไม่มีงบ เรียกว่าคำสั่ง NULL ELSE

  • ใน IF4 ถ้า STP01.RC = 0 และ STP02.RC <= 4 เป็น TRUE จะดำเนินการ STP05

  • ใน IF5 ถ้า PST1 ขั้นตอน proc ใน PROC PRC1 ในขั้นตอนงาน STP05 ABEND จะดำเนินการ STP06 อื่น STP07 ถูกเรียกใช้งาน

  • หาก IF4 ประเมินว่าเป็นเท็จ STP05 จะไม่ถูกดำเนินการ ในกรณีนั้นจะไม่มีการทดสอบ IF5 และขั้นตอน STP06, STP07 จะไม่ถูกดำเนินการ

IF-THEN-ELSE จะไม่ถูกดำเนินการในกรณีที่มีการยกเลิกงานอย่างผิดปกติเช่นผู้ใช้ยกเลิกงานหมดเวลางานหรือชุดข้อมูลถูกอ้างอิงย้อนหลังไปยังขั้นตอนที่ข้ามไป

การตั้งค่าจุดตรวจ

คุณสามารถตั้งค่าชุดข้อมูลจุดตรวจภายในโปรแกรม JCL ของคุณโดยใช้ SYSCKEOV, ซึ่งเป็นคำสั่ง DD

CHKPTคือพารามิเตอร์ที่เข้ารหัสสำหรับชุดข้อมูล QSAM แบบหลายวอลุ่มในคำสั่ง DD เมื่อ CHKPT ถูกเข้ารหัสเป็น CHKPT = EOV จุดตรวจจะถูกเขียนไปยังชุดข้อมูลที่ระบุในคำสั่ง SYSCKEOV ที่ส่วนท้ายของแต่ละโวลุ่มของชุดข้อมูลหลายโวลุ่มอินพุต / เอาต์พุต

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01     EXEC PGM=MYCOBB
//SYSCKEOV  DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1       DD DSN=SAMPLE.IN,DISP=SHR
//OUT1      DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
//          CHKPT=EOV,LRECL=80,RECFM=FB

ในตัวอย่างข้างต้นจุดตรวจจะถูกเขียนในชุดข้อมูล SAMPLE.CHK ที่ส่วนท้ายของแต่ละโวลุ่มของชุดข้อมูลเอาต์พุต SAMPLE.OUT

เริ่มการประมวลผลใหม่

คุณสามารถรีสตาร์ทการประมวลผลอีเธอร์โดยใช้วิธีอัตโนมัติโดยใช้ไฟล์ RD parameter หรือคู่มือโดยใช้ RESTART parameter.

RD parameter ถูกเข้ารหัสในคำสั่ง JOB หรือ EXEC และช่วยในการรีสตาร์ท JOB / STEP อัตโนมัติและสามารถเก็บค่าหนึ่งในสี่ค่า: R, RNC, NR หรือ NC

  • RD=R อนุญาตให้รีสตาร์ทอัตโนมัติและพิจารณาจุดตรวจที่เข้ารหัสในพารามิเตอร์ CHKPT ของคำสั่ง DD

  • RD=RNC อนุญาตให้รีสตาร์ทอัตโนมัติ แต่แทนที่ (ละเว้น) พารามิเตอร์ CHKPT

  • RD=NRระบุว่างาน / ขั้นตอนไม่สามารถเริ่มต้นใหม่โดยอัตโนมัติ แต่เมื่อรีสตาร์ทด้วยตนเองโดยใช้พารามิเตอร์ RESTART พารามิเตอร์ CHKPT (ถ้ามี) จะได้รับการพิจารณา

  • RD=NC ปิดการใช้งานการรีสตาร์ทอัตโนมัติและการประมวลผลจุดตรวจ

หากมีข้อกำหนดในการรีสตาร์ทอัตโนมัติสำหรับรหัสหยุดเฉพาะเท่านั้นก็สามารถระบุได้ในไฟล์ SCHEDxx สมาชิกของไลบรารี parmlib ระบบ IBM

RESTART parameterถูกเข้ารหัสในคำสั่ง JOB หรือ EXEC และช่วยในการรีสตาร์ท JOB / STEP ด้วยตนเองหลังจากงานล้มเหลว RESTART สามารถมาพร้อมกับ checkid ซึ่งเป็นจุดตรวจที่เขียนในชุดข้อมูลที่เข้ารหัสในคำสั่ง SYSCKEOV DD เมื่อมีการเข้ารหัส checkid คำสั่ง SYSCHK DD ควรถูกเข้ารหัสเพื่ออ้างอิงชุดข้อมูลจุดตรวจหลังจากคำสั่ง JOBLIB (ถ้ามี) อื่น ๆ หลังจากคำสั่ง JOB

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID,RESTART=(STP01,chk5)
//*
//SYSCHK    DD DSN=SAMPLE.CHK,DISP=OLD
//STP01     EXEC PGM=MYCOBB
//*SYSCKEOV	DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1       DD DSN=SAMPLE.IN,DISP=SHR
//OUT1      DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
//          CHKPT=EOV,LRECL=80,RECFM=FB

ในตัวอย่างข้างต้น chk5 คือ checkid กล่าวคือ STP01 ถูกรีสตาร์ทที่จุดตรวจ 5 โปรดทราบว่ามีการเพิ่มคำสั่ง SYSCHK และคำสั่ง SYSCKEOV ถูกแสดงความคิดเห็นในโปรแกรมก่อนหน้านี้ที่อธิบายไว้ในส่วนการตั้งค่าจุดตรวจ

ชื่อชุดข้อมูลระบุชื่อของไฟล์และแสดงโดย DSN ใน JCL พารามิเตอร์ DSN อ้างถึงชื่อชุดข้อมูลจริงของชุดข้อมูลที่สร้างขึ้นใหม่หรือที่มีอยู่ ค่า DSN สามารถประกอบด้วยชื่อย่อยแต่ละชื่อที่มีความยาว 1 ถึง 8 อักขระคั่นด้วยจุดและความยาวรวม 44 อักขระ (ตัวเลขและตัวอักษร) ต่อไปนี้เป็นไวยากรณ์:

DSN=&name | *.stepname.ddname

Temporary datasetsต้องการพื้นที่จัดเก็บสำหรับระยะเวลางานเท่านั้นและจะถูกลบเมื่องานเสร็จสิ้น ชุดข้อมูลดังกล่าวแสดงเป็นDSN=&name หรือเพียงไม่ระบุ DSN

หากจะใช้ชุดข้อมูลชั่วคราวที่สร้างขึ้นโดยขั้นตอนงานในขั้นตอนงานถัดไปชุดข้อมูลดังกล่าวจะอ้างอิงเป็น DSN=*.stepname.ddname. นี้เรียกว่าBackward Referencing.

การเชื่อมต่อชุดข้อมูล

หากมีชุดข้อมูลที่มีรูปแบบเดียวกันมากกว่าหนึ่งชุดข้อมูลเหล่านี้สามารถเชื่อมต่อกันและส่งผ่านเป็นอินพุตไปยังโปรแกรมในชื่อ DD เดียวได้

//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID
//*
//STEP10    EXEC PGM=SORT
//SORTIN    DD DSN=SAMPLE.INPUT1,DISP=SHR
//          DD DSN=SAMPLE.INPUT2,DISP=SHR
//          DD DSN=SAMPLE.INPUT3,DISP=SHR
//SORTOUT   DD DSN=SAMPLE.OUTPUT,DISP=(,CATLG,DELETE),
//          LRECL=50,RECFM=FB

ในตัวอย่างข้างต้นชุดข้อมูลสามชุดจะเชื่อมต่อกันและส่งผ่านเป็นอินพุตไปยังโปรแกรม SORT ในชื่อ SORTIN DD ไฟล์จะถูกรวมเรียงลำดับบนฟิลด์คีย์ที่ระบุแล้วเขียนลงในไฟล์เอาต์พุตเดียว SAMPLE.OUTPUT ในชื่อ SORTOUT DD

การลบล้างชุดข้อมูล

ใน JCL ที่เป็นมาตรฐานโปรแกรมที่จะดำเนินการและชุดข้อมูลที่เกี่ยวข้องจะถูกวางไว้ในโพรซีเดอร์ที่ทำแค็ตตาล็อกซึ่งเรียกว่าใน JCL โดยปกติแล้วสำหรับวัตถุประสงค์ในการทดสอบหรือเพื่อการแก้ไขเหตุการณ์อาจจำเป็นต้องใช้ชุดข้อมูลอื่นนอกเหนือจากที่ระบุไว้ในขั้นตอนการจัดทำแค็ตตาล็อก ในกรณีนั้นชุดข้อมูลในโพรซีเดอร์สามารถแทนที่ได้ใน JCL

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//JSTEP1    EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
//          DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
//*
//* The cataloged procedure is as below:
//*
//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//STEP1     EXEC PGM=&PROG
//STEPLIB   DD DSN=&BASELB,DISP=SHR
//IN1       DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1      DD SYSOUT=*
//SYSOUT    DD SYSOUT=*
//SYSIN     DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2     EXEC PGM=SORT

ในตัวอย่างข้างต้นชุดข้อมูล IN1 ใช้ไฟล์ MYDATA.URMI.INPUT ใน PROC ซึ่งถูกแทนที่ใน JCL ดังนั้นไฟล์อินพุตที่ใช้ในการดำเนินการคือ MYDATA.OVER.INPUT โปรดทราบว่าชุดข้อมูลเรียกว่า STEP1.IN1 หากมีเพียงขั้นตอนเดียวใน JCL / PROC ชุดข้อมูลสามารถอ้างอิงได้ด้วยชื่อ DD ในทำนองเดียวกันหากมีมากกว่าหนึ่งขั้นตอนใน JCL ชุดข้อมูลจะถูกแทนที่เป็น JSTEP1.STEP1.IN1

//SAMPINST  JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP      EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
//          DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
//          DD DUMMY
//          DD DUMMY
//*

ในตัวอย่างข้างต้นจากชุดข้อมูลสามชุดที่ต่อกันใน IN1 ชุดข้อมูลแรกจะถูกแทนที่ใน JCL และส่วนที่เหลือจะถูกเก็บไว้ตามที่มีอยู่ใน PROC

การกำหนด GDG ใน JCL

Generation Data Groups (GDG) คือกลุ่มของชุดข้อมูลที่เกี่ยวข้องกันโดยใช้ชื่อสามัญ ชื่อสามัญเรียกว่าฐาน GDG และชุดข้อมูลแต่ละชุดที่เกี่ยวข้องกับฐานเรียกว่าเวอร์ชัน GDG

ตัวอย่างเช่น MYDATA.URMI.SAMPLE.GDG คือชื่อฐาน GDG ชุดข้อมูลมีชื่อเป็น MYDATA.URMI.SAMPLE.GDG.G0001V00, MYDATA.URMI.SAMPLE.GDG.G0002V00 เป็นต้น GDG เวอร์ชันล่าสุดเรียกว่า MYDATA.URMI.SAMPLE.GDG (0) เวอร์ชันก่อนหน้านี้เรียกว่า (-1), (-2) เป็นต้น เวอร์ชันถัดไปที่จะสร้างในโปรแกรมจะอ้างอิงเป็น MYDATA.URMI.SAMPLE.GDG (+1) ใน JCL

สร้าง / แก้ไข GDG ใน JCL

เวอร์ชัน GDG สามารถมีพารามิเตอร์ DCB เหมือนกันหรือต่างกันได้ DCB รุ่นเริ่มต้นสามารถกำหนดให้ใช้ได้กับทุกเวอร์ชัน แต่สามารถแทนที่ได้เมื่อสร้างเวอร์ชันใหม่

//GDGSTEP1 EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
           DEFINE GDG(NAME(MYDATA.URMI.SAMPLE.GDG)   -
           LIMIT(7)                           -
           NOEMPTY                            -
           SCRATCH)
/*
//GDGSTEP2 EXEC PGM=IEFBR14
//GDGMODLD DD  DSN=MYDATA.URMI.SAMPLE.GDG,
//         DISP=(NEW,CATLG,DELETE),
//         UNIT=SYSDA,
//         SPACE=(CYL,10,20),
//         DCB=(LRECL=50,RECFM=FB)
//

ในตัวอย่างข้างต้นยูทิลิตี้ IDCAMS กำหนดฐาน GDG ใน GDGSTEP1 ด้วยพารามิเตอร์ด้านล่างที่ส่งผ่านในคำสั่ง SYSIN DD:

  • NAME ระบุชื่อชุดข้อมูลจริงของฐาน GDG

  • LIMIT ระบุจำนวนเวอร์ชันสูงสุดที่ฐาน GDG สามารถรองรับได้

  • EMPTY ไม่ได้รับการบันทึกทุกรุ่นเมื่อถึง LIMIT

  • NOEMPTY Uncataloges รุ่นล่าสุดน้อยที่สุด

  • SCRATCH ลบการสร้างทางกายภาพเมื่อไม่มีการบันทึกข้อมูล

  • NOSCRATCH อย่าลบชุดข้อมูลกล่าวคือสามารถอ้างถึงได้โดยใช้พารามิเตอร์ UNIT และ VOL

ใน GDGSTEP2 ยูทิลิตี้ IEFBR14 ระบุพารามิเตอร์ DD รุ่นที่จะใช้กับทุกเวอร์ชัน

IDCAMS สามารถใช้เพื่อเปลี่ยนพารามิเตอร์นิยามของ GDG เช่นการเพิ่ม LIMIT การเปลี่ยน EMPTY เป็น NOEMPTY เป็นต้นและเวอร์ชันที่เกี่ยวข้องโดยใช้คำสั่ง SYSIN คือ ALTER MYDATA.URMI.SAMPLE.GDG LIMIT(15) EMPTY.

ลบ GDG ใน JCL

เมื่อใช้ยูทิลิตี้ IEFBR14 เราสามารถลบ GDG เวอร์ชันเดียวได้

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

ในตัวอย่างข้างต้นเวอร์ชันล่าสุดของ MYDATA.URMI.SAMPLE.GDG จะถูกลบ โปรดทราบว่าพารามิเตอร์ DISP เมื่อเสร็จสิ้นงานปกติถูกเข้ารหัสเป็น DELETE ดังนั้นชุดข้อมูลจะถูกลบเมื่องานเสร็จสิ้นการดำเนินการ

IDCAMS สามารถใช้เพื่อลบ GDG และเวอร์ชันที่เกี่ยวข้องโดยใช้คำสั่ง SYSIN DELETE(MYDATA.URMI.SAMPLE.GDG) GDG FORCE/PURGE.

  • FORCEลบเวอร์ชัน GDG และฐาน GDG หาก GDG เวอร์ชันใด ๆ ถูกตั้งค่าด้วยวันที่หมดอายุซึ่งยังไม่หมดอายุจะไม่มีการลบออกดังนั้นจึงยังคงฐาน GDG ไว้

  • PURGE ลบเวอร์ชัน GDG และฐาน GDG โดยไม่คำนึงถึงวันที่หมดอายุ

ใช้ GDG ใน JCL

ในตัวอย่างต่อไปนี้เวอร์ชันล่าสุดของ MYDATA.URMI.SAMPLE.GDG ถูกใช้เป็นอินพุตของโปรแกรมและ MYDATA.URMI.SAMPLE.GDG เวอร์ชันใหม่ถูกสร้างขึ้นเป็นเอาต์พุต

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID
//*
//STP01   EXEC PGM=MYCOBB
//IN1     DD DSN=MYDATA.URMI.SAMPLE.GDG(0),DISP=SHR
//OUT1    DD DSN=MYDATA.URMI.SAMPLE.GDG(+1),DISP=(,CALTG,DELETE)
//        LRECL=100,RECFM=FB

ที่นี่หาก GDG ถูกอ้างถึงด้วยชื่อจริงเช่น MYDATA.URMI.SAMPLE.GDG.G0001V00 ก็จะนำไปสู่การเปลี่ยน JCL ทุกครั้งก่อนดำเนินการ การใช้ (0) และ (+1) ทำให้แทนที่เวอร์ชัน GDG แบบไดนามิกสำหรับการดำเนินการ

โปรแกรมแบตช์ใด ๆ ที่ดำเนินการผ่าน JCL จำเป็นต้องมีการป้อนข้อมูลซึ่งได้รับการประมวลผลและสร้างเอาต์พุต มีวิธีการป้อนข้อมูลเข้าสู่โปรแกรมและการเขียนเอาต์พุตที่ได้รับจาก JCL หลายวิธี ในโหมดแบตช์ไม่จำเป็นต้องมีการโต้ตอบกับผู้ใช้ แต่อุปกรณ์อินพุตและเอาต์พุตและองค์กรที่จำเป็นจะถูกกำหนดไว้ใน JCL และส่ง

การป้อนข้อมูลใน JCL

มีหลายวิธีในการป้อนข้อมูลไปยังโปรแกรมโดยใช้ JCL และวิธีการเหล่านี้ได้อธิบายไว้ด้านล่าง:

ติดตั้งข้อมูล

ข้อมูลในสตรีมไปยังโปรแกรมสามารถระบุได้โดยใช้คำสั่ง SYSIN DD

//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID
//* Example 1:
//STEP10 EXEC PGM=MYPROG
//IN1    DD DSN=SAMPLE.INPUT1,DISP=SHR
//OUT1   DD DSN=SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
//       LRECL=50,RECFM=FB
//SYSIN  DD *
//CUST1  1000
//CUST2  1001
/*
//*
//* Example 2:
//STEP20 EXEC PGM=MYPROG
//OUT1   DD DSN=SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
//       LRECL=50,RECFM=FB
//SYSIN  DD DSN=SAMPLE.SYSIN.DATA,DISP=SHR
//*

ในตัวอย่างที่ 1 อินพุตไปยัง MYPROG จะถูกส่งผ่าน SYSIN ข้อมูลมีให้ภายใน JCL บันทึกข้อมูลสองรายการจะถูกส่งไปยังโปรแกรม โปรดทราบว่า / * เป็นจุดสิ้นสุดของข้อมูล SYSIN ในสตรีม

"CUST1 1000" คือ record1 และ "CUST2 1001" คือ record2 สิ้นสุดเงื่อนไขข้อมูลเมื่อพบสัญลักษณ์ / * ขณะอ่านข้อมูล

ในตัวอย่างที่ 2 ข้อมูล SYSIN จะถูกเก็บไว้ภายในชุดข้อมูลโดยที่ SAMPLE.SYSIN.DATA เป็นไฟล์ PS ซึ่งสามารถเก็บบันทึกข้อมูลได้ตั้งแต่หนึ่งรายการขึ้นไป

การป้อนข้อมูลผ่านไฟล์

ดังที่ได้กล่าวไว้ในตัวอย่างส่วนใหญ่ในบทก่อนหน้าการป้อนข้อมูลไปยังโปรแกรมสามารถจัดเตรียมผ่านไฟล์ PS, VSAM หรือ GDG พร้อมชื่อ DSN ที่เกี่ยวข้องและพารามิเตอร์ DISP พร้อมกับคำสั่ง DD

ในตัวอย่างที่ 1 SAMPLE.INPUT1 คือไฟล์อินพุตที่ข้อมูลถูกส่งผ่านไปยัง MYPROG เรียกว่า IN1 ภายในโปรแกรม

เอาต์พุตข้อมูลใน JCL

เอาต์พุตใน JCL สามารถแค็ตตาล็อกลงในชุดข้อมูลหรือส่งผ่านไปยัง SYSOUT ดังที่กล่าวไว้ในบทคำสั่ง DDSYSOUT=* เปลี่ยนเส้นทางเอาต์พุตไปยังคลาสเดียวกันกับที่กล่าวถึงในพารามิเตอร์ MSGCLASS ของคำสั่ง JOB

การบันทึกบันทึกงาน

การระบุ MSGCLASS=Yบันทึกบันทึกงานใน JMR (Joblog Management and Retrieval) บันทึก JOB ทั้งหมดสามารถเปลี่ยนทิศทางไปยัง SPOOL และสามารถบันทึกลงในชุดข้อมูลโดยให้คำสั่ง XDC เทียบกับชื่องานใน SPOOL เมื่อกำหนดคำสั่ง XDC ใน SPOOL หน้าจอการสร้างชุดข้อมูลจะเปิดขึ้น จากนั้นสามารถบันทึกบันทึกงานได้โดยให้คำจำกัดความ PS หรือ PDS ที่เหมาะสม

นอกจากนี้ยังสามารถบันทึกบันทึกงานลงในชุดข้อมูลได้โดยกล่าวถึงชุดข้อมูลที่สร้างไว้แล้วสำหรับ SYSOUT และ SYSPRINT แต่ไม่สามารถบันทึกบันทึกงานทั้งหมดด้วยวิธีนี้ (กล่าวคือ JESMSG จะไม่ถูกจัดทำรายการ) เหมือนที่ทำใน JMR หรือ XDC

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID
//*
//STEP1    EXEC PGM=MYPROG
//IN1      DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1     DD SYSOUT=*
//SYSOUT   DD DSN=MYDATA.URMI.SYSOUT,DISP=SHR
//SYSPRINT DD DSN=MYDATA.URMI.SYSPRINT,DISP=SHR
//SYSIN    DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2    EXEC PGM=SORT

ในตัวอย่างข้างต้น SYSOUT ถูกจัดทำรายการใน MYDATA.URMI.SYSOUT และ SYSPRINT ใน MYDATA.URMI.SYSPRINT

การรวบรวมโปรแกรม COBOL

ในการดำเนินการโปรแกรม COBOL ในโหมดแบตช์โดยใช้ JCL โปรแกรมจะต้องมีการคอมไพล์และสร้างโมดูลโหลดด้วยโปรแกรมย่อยทั้งหมด JCL ใช้โมดูลโหลดไม่ใช่โปรแกรมจริงในขณะดำเนินการ ไลบรารีโหลดจะเชื่อมต่อกันและมอบให้กับ JCL ในขณะที่ดำเนินการโดยใช้JCLLIB หรือ STEPLIB.

มียูทิลิตี้คอมไพเลอร์เมนเฟรมจำนวนมากที่พร้อมใช้งานเพื่อรวบรวมโปรแกรม COBOL บริษัท บางแห่งใช้เครื่องมือการจัดการการเปลี่ยนแปลงเช่นEndevorซึ่งรวบรวมและจัดเก็บโปรแกรมทุกเวอร์ชัน สิ่งนี้มีประโยชน์ในการติดตามการเปลี่ยนแปลงที่เกิดขึ้นกับโปรแกรม

//COMPILE   JOB ,CLASS=6,MSGCLASS=X,NOTIFY=&SYSUID             
//*            
//STEP1     EXEC IGYCRCTL,PARM=RMODE,DYNAM,SSRANGE
//SYSIN     DD DSN=MYDATA.URMI.SOURCES(MYCOBB),DISP=SHR
//SYSLIB    DD DSN=MYDATA.URMI.COPYBOOK(MYCOPY),DISP=SHR
//SYSLMOD   DD DSN=MYDATA.URMI.LOAD(MYCOBB),DISP=SHR
//SYSPRINT  DD SYSOUT=*
//*

IGYCRCTL เป็นยูทิลิตี้คอมไพเลอร์ IBM COBOL อ็อพชันคอมไพเลอร์ถูกส่งผ่านโดยใช้พารามิเตอร์ PARM ในตัวอย่างข้างต้น RMODE สั่งให้คอมไพเลอร์ใช้โหมดการกำหนดแอดเดรสสัมพัทธ์ในโปรแกรม โปรแกรม COBOL ถูกส่งผ่านโดยใช้พารามิเตอร์ SYSIN และสมุดลอกเป็นไลบรารีที่ใช้โดยโปรแกรมใน SYSLIB

JCL นี้สร้างโมดูลโหลดของโปรแกรมเป็นเอาต์พุตซึ่งใช้เป็นอินพุตในการดำเนินการ JCL

กำลังเรียกใช้โปรแกรม COBOL

ด้านล่างตัวอย่าง JCL ที่โปรแกรม MYPROG ทำงานโดยใช้ไฟล์อินพุต MYDATA.URMI.INPUT และสร้างไฟล์เอาต์พุตสองไฟล์ที่เขียนไปยังสปูล

//COBBSTEP  JOB CLASS=6,NOTIFY=&SYSUID
//
//STEP10    EXEC PGM=MYPROG,PARM=ACCT5000
//STEPLIB   DD DSN=MYDATA.URMI.LOADLIB,DISP=SHR
//INPUT1    DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1      DD SYSOUT=*
//OUT2      DD SYSOUT=*
//SYSIN     DD *
//CUST1     1000
//CUST2     1001
/*

โมดูลโหลดของ MYPROG อยู่ใน MYDATA.URMI.LOADLIB สิ่งนี้เป็นสิ่งสำคัญที่ต้องทราบว่า JCL ข้างต้นสามารถใช้กับโมดูล COBOL ที่ไม่ใช่ DB2 เท่านั้น

การส่งผ่านข้อมูลไปยังโปรแกรม COBOL

อินพุตข้อมูลไปยังโปรแกรมแบทช์ COBOL สามารถผ่านไฟล์พารามิเตอร์ PARAM และคำสั่ง SYSIN DD ในตัวอย่างด้านบน:

  • บันทึกข้อมูลจะส่งผ่านไปยัง MYPROG ผ่านไฟล์ MYDATA.URMI.INPUT ไฟล์นี้จะถูกอ้างถึงในโปรแกรมโดยใช้ชื่อ DD INPUT1 ไฟล์สามารถเปิดอ่านและปิดได้ในโปรแกรม

  • ข้อมูลพารามิเตอร์ PARM ACCT5000 ได้รับในส่วน LINKAGE ของโปรแกรม MYPROG ในตัวแปรที่กำหนดภายในส่วนนั้น

  • ข้อมูลในคำสั่ง SYSIN ได้รับผ่านคำสั่ง ACCEPT ในส่วน PROCEDURE ของโปรแกรม ทุกคำสั่ง ACCEPT จะอ่านหนึ่งระเบียนทั้งหมด (เช่น CUST1 1000) ในตัวแปรหน่วยเก็บข้อมูลที่ทำงานซึ่งกำหนดไว้ในโปรแกรม

เรียกใช้โปรแกรม COBOL-DB2

สำหรับการรันโปรแกรม COBOL DB2 ยูทิลิตี้ IBM เฉพาะจะถูกใช้ใน JCL และโปรแกรม ภูมิภาค DB2 และพารามิเตอร์ที่ต้องการจะถูกส่งเป็นอินพุตไปยังยูทิลิตี้

ทำตามขั้นตอนด้านล่างในการรันโปรแกรม COBOL-DB2:

  • เมื่อคอมไพล์โปรแกรม COBOL-DB2 DBRM (Database Request Module) จะถูกสร้างขึ้นพร้อมกับโหลดโมดูล DBRM ประกอบด้วยคำสั่ง SQL ของโปรแกรม COBOL โดยตรวจสอบไวยากรณ์แล้วว่าถูกต้อง

  • DBRM ถูกผูกไว้กับภูมิภาค DB2 (สภาพแวดล้อม) ที่ COBOL จะทำงาน สามารถทำได้โดยใช้ยูทิลิตี้ IKJEFT01 ใน JCL

  • หลังจากขั้นตอนการโยงโปรแกรม COBOL-DB2 จะรันโดยใช้ IKJEFT01 (อีกครั้ง) โดยมีโหลดไลบรารีและไลบรารี DBRM เป็นอินพุตไปยัง JCL

//STEP001  EXEC PGM=IKJEFT01
//*
//STEPLIB  DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY  DD SYSOUT=*
//SYSOUT   DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN  DD *
    DSN SYSTEM(SSID)
    RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
    LIB('MYDATA.URMI.LOADLIB')
    END
/*

ในตัวอย่างข้างต้น MYCOBB คือโปรแกรม COBOL-DB2 ที่รันโดยใช้ IKJEFT01 โปรดทราบว่าชื่อโปรแกรม DB2 Sub-System Id (SSID) ชื่อแผน DB2 จะถูกส่งผ่านภายในคำสั่ง SYSTSIN DD ไลบรารี DBRM ถูกระบุใน STEPLIB

IBM Dataset Utilities

โปรแกรมยูทิลิตี้เป็นโปรแกรมที่เขียนไว้ล่วงหน้าซึ่งใช้กันอย่างแพร่หลายในเมนเฟรมโดยโปรแกรมเมอร์ระบบและนักพัฒนาแอพพลิเคชั่นเพื่อให้บรรลุข้อกำหนดในแต่ละวันการจัดระเบียบและการดูแลรักษาข้อมูล มีอยู่สองสามรายการด้านล่างพร้อมฟังก์ชันการทำงาน:

ชื่อยูทิลิตี้ ฟังก์ชันการทำงาน
IEHMOVE ย้ายหรือคัดลอกชุดข้อมูลตามลำดับ
IEHPROGM การลบและเปลี่ยนชื่อชุดข้อมูล แค็ตตาล็อกหรือชุดข้อมูล Uncatalog นอกเหนือจาก VSAM
IEHCOMPR เปรียบเทียบข้อมูลในชุดข้อมูลตามลำดับ
IEBCOPY คัดลอกผสานบีบอัดสำรองหรือกู้คืน PDS
IEFBR14

ไม่มียูทิลิตี้การทำงาน ใช้เพื่อคืนการควบคุมให้กับผู้ใช้และยุติ โดยปกติจะใช้เพื่อสร้างชุดข้อมูลว่างหรือลบชุดข้อมูลที่มีอยู่

ตัวอย่างเช่นถ้าชุดข้อมูลถูกส่งเป็นอินพุตไปยังโปรแกรม IEFBR14 ด้วย DISP = (OLD, DELETE, DELETE) ชุดข้อมูลจะถูกลบเมื่องานเสร็จสิ้น

IEBEDIT ใช้เพื่อคัดลอกส่วนที่เลือกของ JCL ตัวอย่างเช่นหาก JCL มี 5 ขั้นตอนและเราต้องการดำเนินการขั้นตอนที่ 1 และ 3 เท่านั้นดังนั้น IEBEDIT JCL สามารถเข้ารหัสด้วยชุดข้อมูลที่มี JCL จริงที่จะดำเนินการ ใน SYSIN ของ IEBEDIT เราสามารถระบุ STEP1 และ STEP3 เป็นพารามิเตอร์ได้ เมื่อดำเนินการ JCL นี้จะดำเนินการขั้นตอนที่ 1 และขั้นตอนที่ 3 ของ JCL จริง
IDCAMS สร้างลบเปลี่ยนชื่อแค็ตตาล็อกชุดข้อมูล Uncatalog (นอกเหนือจาก PDS) โดยปกติจะใช้เพื่อจัดการชุดข้อมูล VSAM

โปรแกรมยูทิลิตี้เหล่านี้จำเป็นต้องใช้กับคำสั่ง DD ที่เหมาะสมใน JCL เพื่อให้บรรลุฟังก์ชันที่ระบุ

ภาพรวม DFSORT

DFSORT เป็นยูทิลิตี้ IBM ที่มีประสิทธิภาพซึ่งใช้ในการคัดลอกเรียงลำดับหรือรวมชุดข้อมูล คำสั่ง SORTIN และ SORTINnn DD ใช้เพื่อระบุชุดข้อมูลอินพุต คำสั่ง SORTOUT และ OUTFIL ใช้เพื่อระบุข้อมูลเอาต์พุต

คำสั่ง SYSIN DD ใช้เพื่อระบุเงื่อนไขการเรียงลำดับและการผสาน โดยทั่วไปแล้ว DFSORT จะใช้เพื่อให้บรรลุฟังก์ชันด้านล่าง:

  • จัดเรียงไฟล์อินพุตตามลำดับของตำแหน่งฟิลด์ที่ระบุในไฟล์

  • รวมเร็กคอร์ดหรือ OMIT จากอินพุตไฟล์ตามเงื่อนไขที่ระบุ

  • จัดเรียงไฟล์อินพุตผสานตามลำดับของตำแหน่งฟิลด์ที่ระบุในไฟล์

  • จัดเรียงเข้าร่วมไฟล์อินพุตตั้งแต่สองไฟล์ขึ้นไปตาม JOIN KEY (ฟิลด์) ที่ระบุในไฟล์อินพุตแต่ละไฟล์)

  • เมื่อมีการประมวลผลเพิ่มเติมที่ต้องดำเนินการกับไฟล์อินพุตสามารถเรียกโปรแกรม USER EXIT จากโปรแกรม SORT ตัวอย่างเช่นหากมีการเพิ่มส่วนหัว / ส่วนท้ายลงในไฟล์เอาต์พุตสามารถเรียกใช้โปรแกรม COBOL ที่เขียนโดย USER จากโปรแกรม SORT เพื่อดำเนินการฟังก์ชันนี้ได้ การใช้การ์ดควบคุมข้อมูลสามารถส่งผ่านไปยังโปรแกรม COBOL

  • ในทางกลับกัน SORT สามารถเรียกภายในจากโปรแกรม COBOL เพื่อจัดเรียงไฟล์อินพุตตามลำดับเฉพาะก่อนที่จะประมวลผล โดยปกติแล้วไม่แนะนำให้ใช้ในแง่ของประสิทธิภาพสำหรับไฟล์ขนาดใหญ่

ภาพรวม ICETOOL

ICETOOL เป็นยูทิลิตี้ DFSORT อเนกประสงค์ที่ใช้ในการดำเนินการต่างๆกับชุดข้อมูล ชุดข้อมูลอินพุตและเอาต์พุตสามารถกำหนดได้โดยใช้ชื่อ DD ที่ผู้ใช้กำหนด การดำเนินการของไฟล์ระบุไว้ในคำสั่ง TOOLIN DD เงื่อนไขเพิ่มเติมสามารถระบุได้ในคำสั่ง DD 'CTL' ที่ผู้ใช้กำหนด

ยูทิลิตี้บางส่วนของ ICETOOL มีดังต่อไปนี้:

  • ICETOOL สามารถบรรลุฟังก์ชันทั้งหมดของ DFSORT ในเงื่อนไขอย่างน้อยหนึ่งเงื่อนไข

  • SPLICE เป็นการทำงานที่มีประสิทธิภาพของ ICETOOL ซึ่งคล้ายกับการเรียงลำดับเข้าร่วม แต่มีคุณสมบัติเพิ่มเติม สามารถเปรียบเทียบไฟล์ตั้งแต่สองไฟล์ขึ้นไปในฟิลด์ที่ระบุและสร้างไฟล์เอาต์พุตอย่างน้อยหนึ่งไฟล์เช่นไฟล์ที่มีเร็กคอร์ดที่ตรงกันไฟล์ที่มีเร็กคอร์ดที่ไม่ตรงกันเป็นต้น

  • ข้อมูลในไฟล์หนึ่งในตำแหน่งหนึ่ง ๆ สามารถซ้อนทับไปยังตำแหน่งอื่นในไฟล์เดียวกันหรือต่างกันได้

  • A File can be split into n files based on a specified condition. For example, a file containing names of employees can be split into 26 files, each containing the names starting with A, B, C and so on.

  • Different combination of file manipulation is possible using ICETOOL with a little exploration of the tool.

SYNCSORT Overview

SYNCSORT is used to copy, merge or sort datasets with a high performance. It gives best utilization of system resources and efficient operation in 31-bit and 64-bit address spaces.

It can be used in the same lines of DFSORT and can achieve the same features. It can be invoked by a JCL or from within a program coded in COBOL, PL/1 or Assembler language. It also supports User Exit programs to be called from the SYNCSORT program.

Frequently used sort tricks using these utilities are explained in the next chapter. Complex requirements, which requires a huge programming in COBOL/ASSEMBLER can be achieved using the above utilities in simple steps.

The day-to-day application requirements in a corporate world that can be achieved using Utility Programs are illustrated below:

1. A file has 100 records. The first 10 records need to be written to output file.

//JSTEP020 EXEC PGM=ICETOOL                                          
//TOOLMSG  DD SYSOUT=*                                               
//DFSMSG   DD SYSOUT=*                                               
//IN1      DD DSN=MYDATA.URMI.STOPAFT,DISP=SHR    
//OUT1	   DD SYSOUT=*
//TOOLIN   DD *                                                      
  COPY FROM(IN1) TO(OUT1) USING(CTL1)                                  
/*
//CTL1CNTL DD *                        
  OPTION STOPAFT=10               
/*

The option STOPAFT will stop reading the input file after 10th record and terminates the program. Hence, 10 records are written to output.

2. Input file has one or more records for same employee number. Write unique records to output.

//STEP010  EXEC PGM=SORT 
//SYSOUT   DD SYSOUT=*                                                
//SORTIN   DD DSN=MYDATA.URMI.DUPIN,DISP=SHR
//SORTOUT  DD SYSOUT=*
//SYSIN    DD *            
  SORT FIELDS=(1,15,ZD,A) 
  SUM FIELDS=NONE          
/*

SUM FIELDS=NONE removes duplicates on fields specified in SORT FIELDS. In the above example, employee number is in the field position 1,15. The output file will contain the unique employee numbers sorted in ascending order.

3. Overwrite input record content.

//JSTEP010 EXEC PGM=SORT                                             
//SORTIN   DD DSN= MYDATA.URMI.SAMPLE.MAIN,DISP=SHR       
//SORTOUT  DD SYSOUT=*                 
//SYSPRINT DD SYSOUT=*                                               
//SYSOUT   DD SYSOUT=*                                               
//SYSIN    DD *                                                      
 OPTION COPY                                                         
  INREC OVERLAY=(47:1,6)                      
/*

In the input file, the content in position 1,6 is overwritten to the position 47,6 and then copied to the output file. INREC OVERLAY operation is used in order to rewrite data in input file before copying to output.

4. Adding a sequence number to the output file.

//JSTEP010 EXEC PGM=SORT                                             
//SORTIN   DD *
  data1
  data2
  data3
/*
//SORTOUT  DD SYSOUT=*                 
//SYSPRINT DD SYSOUT=*                                               
//SYSOUT   DD SYSOUT=*                                               
//SYSIN    DD *                                                      
 OPTION COPY                                                         
 BUILD=(1:1,5,10:SEQNUM,4,ZD,START=1000,INCR=2)                      
/*

The output will be:

data1    1000
data2    1002
data3    1004

4-digit sequence number is added in output at position 10, starting at 1000 and incremented by 2 for every record.

5. Adding Header/Trailer to output file.

//JSTEP010 EXEC PGM=SORT                                             
//SORTIN   DD *
  data1
  data2
  data3
/*
//SORTOUT  DD SYSOUT=*                 
//SYSPRINT DD SYSOUT=*                                               
//SYSOUT   DD SYSOUT=*                                               
//SYSIN    DD *                                                      
 SORT FIELDS=COPY                                                     
  OUTFIL REMOVECC,                                                     
  HEADER1=(1:C'HDR',10:X'020110131C'),                    
  TRAILER1=(1:C'TRL',TOT=(10,9,PD,TO=PD,LENGTH=9)) 
/*

The output will be:

HDR       20110131
data1    
data2    
data3 
TRL       000000003

TOT calculates the number of records in the input file. HDR and TRL are added as identifiers to header/trailer, which is user defined and can be customised as per the users' needs.

6. Conditional Processing

//JSTEP010 EXEC PGM=SORT                                             
//SORTIN   DD *
  data1select
  data2
  data3select
/*
//SORTOUT  DD SYSOUT=*                 
//SYSPRINT DD SYSOUT=*                                               
//SYSOUT   DD SYSOUT=*                                               
//SYSIN    DD *           
  INREC  IFTHEN=(WHEN=(6,1,CH,NE,C' '),BUILD=(1:1,15),
         IFTHEN=(WHEN=(6,1,CH,EQ,C' '),BUILD=(1:1,5,7:C'EMPTY    ') 
  OPTION COPY                                                     
/*

The output will be:

data1select   
data2 EMPTY  
data3select

Based on the 6th position of the file, the BUILD of output file varies. If 6th position is SPACES, then text "EMPTY" is appended to input record. Else, the input record is written to output, as-is.

7. Backing up a file

//JSTEP001 EXEC PGM=IEBGENER                                       
//SYSPRINT DD SYSOUT=*                                             
//SYSIN    DD *                                                    
//SYSOUT   DD SYSOUT=*                                             
//SORTOUT  DD DUMMY                                                
//SYSUT1   DD DSN=MYDATA.URMI.ORIG,DISP=SHR                     
//SYSUT2   DD DSN=MYDATA.URMI.BACKUP,DISP=(NEW,CATLG,DELETE),
//             DCB=*.SYSUT1,SPACE=(CYL,(50,1),RLSE)

IEBGENER copies the file in SYSUT1 to file in SYSUT2. Please note that file in SYSUT2 takes the same DCB as that of the SYSUT1 in the above example.

8. File Comparison

//STEP010  EXEC PGM=SORT                                              
//MAIN     DD *
  1000
  1001
  1003
  1005
//LOOKUP   DD *
  1000
  1002
  1003
//MATCH    DD DSN=MYDATA.URMI.SAMPLE.MATCH,DISP=OLD
//NOMATCH1 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH1,DISP=OLD
//NOMATCH2 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH2,DISP=OLD 
//SYSOUT   DD SYSOUT=*                                                       
//SYSIN    DD *                                                       
  JOINKEYS F1=MAIN,FIELDS=(1,4,A)                            
  JOINKEYS F2=LOOKUP,FIELDS=(1,4,A)                               
  JOIN UNPAIRED,F1,F2                                                 
  REFORMAT FIELDS=(?,F1:1,4,F2:1,4)                                
  OPTION COPY                                                         
  OUTFIL FNAMES=MATCH,INCLUDE=(1,1,CH,EQ,C'B'),BUILD=(1:2,4)                                                
  OUTFIL FNAMES=NOMATCH1,INCLUDE=(1,1,CH,EQ,C'1'),BUILD=(1:2,4) 
  OUTFIL FNAMES=NOMATCH2,INCLUDE=(1,1,CH,EQ,C'2'),BUILD=(1:2,4) 
/*
  • JOINKEYS specifies the field on which the two files are compared.

  • REFORMAT FIELDS=? places 'B' (matched records), '1' (present in file1, but not in file2), or '2' (present in file2 but not in file1) in the 1st position of the output BUILD.

  • JOIN UNPAIRED does a full outer join on the two files.

The output will be:

MATCH File
1000
1003

NOMATCH1 File
1001
1005

NOMATCH2 File
1002

The same functionality can be achieved using ICETOOL also.