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 = ประเภทของคำสั่งที่เขียนลงในบันทึกเอาต์พุต
MSG = ประเภทของข้อความที่เขียนลงในบันทึกผลลัพธ์
|
| TYPRUN | ระบุการประมวลผลพิเศษสำหรับงาน ต่อไปนี้เป็นไวยากรณ์: TYPRUN = SCAN | HOLD โดยที่ SCAN และ HOLD มีคำอธิบายดังต่อไปนี้
|
| 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:
ก normal-disposition พารามิเตอร์สามารถรับค่าใดค่าหนึ่งต่อไปนี้
ก abnormal-disposition พารามิเตอร์สามารถรับค่าใดค่าหนึ่งต่อไปนี้
นี่คือคำอธิบายของพารามิเตอร์ CATLG, UNCATLG, DELETE, PASS และ KEEP:
เมื่อไม่ได้ระบุพารามิเตอร์ย่อยของ DISP ค่าเริ่มต้นจะเป็นดังนี้:
|
| 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) นี่คือคำอธิบายของพารามิเตอร์ที่ใช้ทั้งหมด:
|
| 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.ddnameTemporary 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 10044-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 000000003TOT 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
data3selectBased 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
1002The same functionality can be achieved using ICETOOL also.