Code: |
250 1000 657 9800 12 567 700 |
Code: |
250 1000 657 9800 12 567 700 |
Code: |
//STEP030 EXEC PGM=ICETOOL,COND=(4,LT) //STEPLIB DD DSN=SYS1.SYSTEMS.XANTH.LINKLIB,DISP=SHR // DD DSN=SYS1.SICELPA,DISP=SHR // DD DSN=SYS1.SICELINK,DISP=SHR //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //SYSOUT DD SYSOUT=* //INFL1 DD DSN=input file,DISP=SHR //TEMPFL1 DD DSN=&&TEMPFL1, // DISP=(MOD,PASS),UNIT=SYSDA, // SPACE=(CYL,(1,1),RLSE), // DCB=*.INFL1 //OUTFL1 DD DSN=output file, // DISP=(,CATLG,DELETE),UNIT=SYSDA, // SPACE=(CYL,(1,1),RLSE), // DCB=*.INFL1 //SORTWK01 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK02 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK03 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK04 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK05 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK06 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK07 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //SORTWK08 DD UNIT=SYST,SPACE=(CYL,(5,5),,CONTIG) //* //TOOLIN DD * COPY FROM(INFL1) USING(CTL1) COPY FROM(INFL1) USING(CTL2) COPY FROM(INFL1) USING(CTL3) SPLICE FROM(TEMPFL1) TO(OUTFL1) ON(81,8,ZD) WITHEACH - WITH(5,4) WITH(9,4) USING(CTL4) /* //* //CTL1CNTL DD * OPTION COPY OUTFIL FNAMES=TEMPFL1,STARTREC=1,SAMPLE=(3,1), OUTREC=(1,4,76X,81:SEQNUM,8,ZD) /* //CTL2CNTL DD * OPTION COPY OUTFIL FNAMES=TEMPFL1,STARTREC=2,SAMPLE=(3,1), OUTREC=(4X,5:1,4,72X,81:SEQNUM,8,ZD) /* //CTL3CNTL DD * OPTION COPY OUTFIL FNAMES=TEMPFL1,STARTREC=3,SAMPLE=(3,1), OUTREC=(8X,9:1,4,62X,81:SEQNUM,8,ZD) /* //CTL4CNTL DD * OUTFIL FNAMES=OUTFL1,OUTREC=(1,4,1X,5,4,1X,9,4,66X) /* |
Code: |
//STEP0100 EXEC PGM=ICETOOL //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //IN DD * 250 1000 657 9800 12 567 700 //T1 DD DSN=&T1,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //T2 DD DSN=&T2,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //T3 DD DSN=&T3,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //CON DD DSN=&T1,DISP=OLD,VOL=REF=*.T1 // DD DSN=&T2,DISP=OLD,VOL=REF=*.T2 // DD DSN=&T3,DISP=OLD,VOL=REF=*.T3 //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(IN) USING(CTL1) SPLICE FROM(CON) TO(OUT) ON(81,8,ZD) KEEPNODUPS WITHEACH - WITH(5,4) WITH(9,4) USING(CTL2) //CTL1CNTL DD * OUTFIL FNAMES=T1,STARTREC=1,SAMPLE=(3,1), OUTREC=(1,4,76X,81:SEQNUM,8,ZD) OUTFIL FNAMES=T2,STARTREC=2,SAMPLE=(3,1), OUTREC=(4X,5:1,4,72X,81:SEQNUM,8,ZD) OUTFIL FNAMES=T3,STARTREC=3,SAMPLE=(3,1), OUTREC=(8X,9:1,4,62X,81:SEQNUM,8,ZD) //CTL2CNTL DD * OUTFIL FNAMES=OUT,OUTREC=(1,4,X,5,4,X,9,4,80:X) /* |
Code: |
//R010 EXEC PGM=SORT //SYSOUT DD SYSOUT=* //SYSPRINT DD SYSOUT=* //DFSMSG DD SYSOUT=* //SORTIN DD DISP=SHR,DSN=MY.INPUT.FILE //SORTOF01 DD DISP=SHR,DSN=MY.TEMP.FILE1 //SORTOF02 DD DISP=SHR,DSN=MY.TEMP.FILE2 //SORTOF03 DD DISP=SHR,DSN=MY.TEMP.FILE3 //SYSIN DD * OPTION COPY OUTFIL FILES=(01,02,03),SPLIT /* //* //* //R020 EXEC PGM=SYNCTOOL //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //IN1 DD DSN=MY.TEMP.FILE1,DISP=SHR //IN2 DD DSN=MY.TEMP.FILE2,DISP=SHR //IN3 DD DSN=MY.TEMP.FILE3,DISP=SHR //T1 DD DSN=&T1,DISP=(,PASS) //T2 DD DSN=&T2,DISP=(,PASS) //T3 DD DSN=&T3,DISP=(,PASS) //INTF DD DSN=&T1,VOL=REF=*.T1,DISP=(OLD,PASS) // DD DSN=&T2,VOL=REF=*.T2,DISP=(OLD,PASS) // DD DSN=&T3,VOL=REF=*.T3,DISP=(OLD,PASS) //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(IN1) TO(T1) USING(CTL1) COPY FROM(IN2) TO(T2) USING(CTL2) COPY FROM(IN3) TO(T3) USING(CTL3) SORT FROM(INTF) TO(OUT) USING(CTL4) //CTL1CNTL DD * OUTREC FIELDS=(1:1,4,X,C'0',4X,C'0',72:X,73:SEQNUM,8,ZD) //CTL2CNTL DD * OUTREC FIELDS=(C'0',4X,6:1,4,C'0',72:X,73:SEQNUM,8,ZD) //CTL3CNTL DD * OUTREC FIELDS=(C'0',4X,C'0',4X,11:1,4,72:X,73:SEQNUM,8,ZD) //CTL4CNTL DD * SORT FIELDS=(73,8,CH,A) SUM FIELDS=(1,1,ZD,6,1,ZD,11,1,ZD) OUTREC FIELDS=(1:1,72,8X) //* |
Quote: |
This solution took 2 Steps and 5 passes over the input file. It also required 6 temporary files to get to the result. The developer used the OUTFIL SPLIT option to a good extent to split the records easily across three temp files, but he took 5 passes of the input.
|
Code: |
//R010 EXEC PGM=SORT //SYSPRINT DD SYSOUT=* //SORTIN DD DSN=MY.INPUT.FILE,DISP=SHR //SORTOUT DD DSN=MY.TEMP.FILE1.R010,DISP=SHR //SYSIN DD * INREC FIELDS=(SEQNUM,4,ZD,START=0,INCR=1, SEQNUM,4,ZD,START=0,INCR=1,1,4) SORT FIELDS=COPY OUTREC FIELDS=(1,4,ZD,SUB,((1,4,ZD,DIV,+3),MUL,+3), 5,4,ZD,DIV,+3,9,4) //SYSOUT DD SYSOUT=* //* //* //R020 EXEC PGM=SORT //SYSPRINT DD SYSOUT=* //SORTIN DD DSN=MY.TEMP.FILE1.R010,DISP=SHR //OUT1 DD DSN=MY.TEMP.FILE1.R020,DISP=SHR //OUT2 DD DSN=MY.TEMP.FILE2.R020,DISP=SHR //OUT3 DD DSN=MY.TEMP.FILE3.R020,DISP=SHR //SYSIN DD * SORT FIELDS=COPY OUTFIL FNAMES=OUT1,INCLUDE=(1,15,FS,EQ,0), OUTREC=(16,16,33,4,FS,ZD,C'00000000',52X) OUTFIL FNAMES=OUT2,INCLUDE=(1,15,FS,EQ,1), OUTREC=(16,16,C'0000',33,4,FS,ZD,C'0000',52X) OUTFIL FNAMES=OUT3,INCLUDE=(1,15,FS,EQ,2), OUTREC=(16,16,C'00000000',33,4,FS,ZD,52X) //SYSOUT DD SYSOUT=* //* //* //R030 EXEC PGM=SORT //SYSPRINT DD SYSOUT=* //SORTIN DD DSN=MY.TEMP.FILE1.R020,DISP=SHR // DD DSN=MY.TEMP.FILE2.R020,DISP=SHR // DD DSN=MY.TEMP.FILE3.R020,DISP=SHR //SORTOUT DD DSN=MY.OUTPUT.FILE,DISP=SHR //SYSIN DD * SORT FIELDS=(1,16,FS,A) SUM FIELDS=(17,4,ZD,21,4,ZD,25,4,ZD) OUTREC FIELDS=(17,4,ZD,EDIT=(IIII),X,21,4,ZD,EDIT=(IIII),X,25,4, ZD,EDIT=(IIII)) //SYSOUT DD SYSOUT=* |
Quote: |
This solution took 3 Steps, 3 passes & 4 Temporary files to get to the result. The First 2 steps could have been easily merged into 1 using OUTFIL SPLIT parameters in the same step.
|
Code: |
//R001 EXEC PGM=SYNCTOOL //DFSMSG DD SYSOUT=* //TOOLMSG DD SYSOUT=* //INPUT DD * 100 5500 2000 25 250 0001 809 790 /* //L1 DD DSN=&&T1,DISP=(,PASS) //L2 DD DSN=&&T2,DISP=(,PASS) //L3 DD DSN=&&T3,DISP=(,PASS) //CON DD DSN=&&T1,DISP=SHR,VOL=REF=*.L1 // DD DSN=&&T2,DISP=SHR,VOL=REF=*.L2 // DD DSN=&&T3,DISP=SHR,VOL=REF=*.L3 //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(INPUT) USING(CTL1) SORT FROM(CON) TO(OUT) USING(CTL2) /* //CTL1CNTL DD * INREC FIELDS=(1,80,SEQNUM,8,ZD,START=4,INCR=1) SORT FIELDS=COPY OUTREC FIELDS=(01,80, 81,8,ZD,SUB,(+3,MUL,(81,8,ZD,DIV,+3)),EDIT=(T)) OUTFIL FNAMES=L1,INCLUDE=(81,1,CH,EQ,C'1'), OUTREC=(1,4,10Z,80:X,SEQNUM,8,ZD) OUTFIL FNAMES=L2,INCLUDE=(81,1,CH,EQ,C'2'), OUTREC=(5Z,1,4,5Z,80:X,SEQNUM,8,ZD) OUTFIL FNAMES=L3,INCLUDE=(81,1,CH,EQ,C'0'), OUTREC=(10Z,1,4,80:X,SEQNUM,8,ZD) /* //CTL2CNTL DD * OPTION EQUALS SORT FIELDS=(81,8,CH,A) SUM FIELDS=(5,4,9,4,13,2),FORMAT=BI OUTREC FIELDS=(1,80) /* |
Quote: |
The first two solutions was written to handle only numeric data, since the developers used ZD summation to merge the records. Kolusu's solution is more generic. It supports Numeric as well as non-numeric data in the input file. Solution 2 is a bit similar to this but Kolusu's one is more efficient since the no. of passes required is just 2. |
Code: |
//R001 EXEC PGM=SYNCTOOL //DFSMSG DD SYSOUT=* //TOOLMSG DD SYSOUT=* //INPUT DD * 0001 0002 0003 0004 0005 0006 0007 0008 0009 0010 0011 0012 0013 0014 0015 0016 0017 0018 0019 0020 /* //TEMP DD DSN=&&T1,DISP=(,PASS) //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(INPUT) TO(TEMP) USING(CTL1) SORT FROM(TEMP) TO(OUT) USING(CTL2) /* //CTL1CNTL DD * INREC FIELDS=(1,4, SEQNUM,8,ZD,START=0) OUTREC FIELDS=(1,4, 5,8,ZD,SUB,(5,8,ZD,DIV,+3),MUL,+3,EDIT=(TTTT), 5,8,ZD,DIV,+3,EDIT=(TTTTTTTT)) OUTFIL OUTREC=(5,4,CHANGE=(4,X'F0F0F0F1',X'00000000', X'F0F0F0F2',X'00000000'), NOMATCH=(1,4),X, 5,4,CHANGE=(4,X'F0F0F0F0',X'00000000', X'F0F0F0F2',X'00000000'), NOMATCH=(1,4),X, 5,4,CHANGE=(4,X'F0F0F0F0',X'00000000', X'F0F0F0F1',X'00000000'), NOMATCH=(1,4),X,9,8,80:X) /* //CTL2CNTL DD * SORT FIELDS=(16,8,ZD,A) SUM FIELDS=(1,4,BI,6,4,BI,11,4,BI) OUTREC FIELDS=(1,15,80:X) /* |
Code: |
The solution takes 1 step, 2 passes and just 1 Temp. file to achieve the desired result.
Pass # 1: --------- a. Use INREC to Insert a 8 digit sequence number (starting at 00000000) at the end of the record layout. b. In OUTREC, use arithmetic operators over the Sequence no. field and generate two different types of sequence nos in the record. 5,8,ZD,SUB,(5,8,ZD,DIV,+3),MUL,+3,EDIT=(TTTT) - This will generate a set of numbers in the sequence 0000, 0001, 0002, 0000, 0001, 0002, 0000 and so on. (Basically this is similar to using MOD operator). 5,8,ZD,DIV,+3,EDIT=(TTTTTTTT) - This will produce a set of numbers in the sequence 00000000, 00000000, 00000000, 00000001, 00000001, 00000001, 00000002 & so on. This is used to group 3 records together in the next pass. Output of OUTREC will be as shown below: ----+----1----+----2 0001000000000000 0002000100000000 0003000200000000 0004000000000001 0005000100000001 0006000200000001 0007000000000002 0008000100000002 0009000200000002 0010000000000003 0011000100000003 0012000200000003 0013000000000004 0014000100000004 0015000200000004 0016000000000005 0017000100000005 0018000200000005 0019000000000006 0020000100000006 c. The final OUTFIL OUTREC statement uses CHANGE operator to reformat the input record depending on the seqnum at position 5 to 8. If 5 to 8 contains 0000, then convert the record as <4 char data> <space> <4 low-value> <space> <4 low-value> <space> <seqnum 2> If 5 to 8 contains 0001, then convert the record as <4 low-value> <space> <4 char data> <space> <4 low-value> <space> <seqnum 2> If 5 to 8 contains 0002, then convert the record as <4 low-value> <space> <4 low-value> <space> <4 char data> <space> <seqnum 2> ----+----1----+----2----+ 0001 00000000 0002 00000000 0003 00000000 0004 00000001 0005 00000001 0006 00000001 0007 00000002 0008 00000002 0009 00000002 0010 00000003 0011 00000003 0012 00000003 0013 00000004 0014 00000004 0015 00000004 0016 00000005 0017 00000005 0018 00000005 0019 00000006 0020 00000006 Pass # 2: --------- a. Sort the records on the seqnum order (at Pos 16 to 23) so that 3 records are grouped at a time. b. Sum the data portion (1,4, 6,4 and 11,4) using BI summation so that the records are merged together. c. Strip off the seqnum before writing to output. |
Code: |
//STEP0100 EXEC PGM=ICETOOL //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //IN DD * 250 1000 657 9800 12 567 700 //L1 DD DSN=&L1,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //L2 DD DSN=&L2,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //L3 DD DSN=&L3,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //CON DD DSN=&L1,DISP=OLD,VOL=REF=*.L1 // DD DSN=&L2,DISP=OLD,VOL=REF=*.L2 // DD DSN=&L3,DISP=OLD,VOL=REF=*.L3 //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(IN) USING(CTL1) SPLICE FROM(CON) TO(OUT) ON(81,8,ZD) KEEPNODUPS WITHEACH - WITH(6,5) WITH(11,5) USING(CTL2) //CTL1CNTL DD * INREC FIELDS=(1,80,SEQNUM,8,ZD,START=4,INCR=1) OUTREC FIELDS=(1,80,81,8,ZD,MOD,+3,TO=ZD,LENGTH=1) OUTFIL FNAMES=L1,INCLUDE=(81,1,CH,EQ,C'1'), OUTREC=(1,5,80:X,SEQNUM,8,ZD) OUTFIL FNAMES=L2,INCLUDE=(81,1,CH,EQ,C'2'), OUTREC=(5X,1,5,80:X,SEQNUM,8,ZD) OUTFIL FNAMES=L3,INCLUDE=(81,1,CH,EQ,C'0'), OUTREC=(10X,1,5,80:X,SEQNUM,8,ZD) //CTL2CNTL DD * OUTFIL FNAMES=OUT,OUTREC=(1,80) /* |
Code: |
//STEP0100 EXEC PGM=ICETOOL //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //IN DD * 250 1000 657 9800 12 567 700 //T1 DD DSN=&T1,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(IN) USING(CTL1) SPLICE FROM(T1) TO(OUT) ON(81,1,ZD) KEEPNODUPS WITHEACH - WITH(6,5) WITH(11,5) USING(CTL2) //CTL1CNTL DD * INREC FIELDS=(1,4, SEQNUM,8,ZD,START=0) OUTREC FIELDS=(1,4, 5,8,ZD,SUB,(5,8,ZD,DIV,+3),MUL,+3,EDIT=(T), 5,8,ZD,DIV,+3,EDIT=(T)) OUTFIL FNAMES=T1, OUTREC=(5,1,CHANGE=(4,C'1',C' ', C'2',C' '), NOMATCH=(1,4),X, 5,1,CHANGE=(4,C'0',C' ', C'2',C' '), NOMATCH=(1,4),X, 5,1,CHANGE=(4,C'0',C' ', C'1',C' '), NOMATCH=(1,4),X,80:X,6,1) //CTL2CNTL DD * OUTFIL FNAMES=OUT,OUTREC=(1,80) /* |
Code: |
//STEP0100 EXEC PGM=ICETOOL //TOOLMSG DD SYSOUT=* //DFSMSG DD SYSOUT=* //IN DD * 250 1000 657 9800 12 567 700 //T1 DD DSN=&T1,DISP=(,PASS),SPACE=(CYL,(1,1),RLSE) //OUT DD SYSOUT=* //TOOLIN DD * COPY FROM(IN) USING(CTL1) SPLICE FROM(T1) TO(OUT) ON(81,1,ZD) KEEPNODUPS WITHEACH - WITH(6,5) WITH(11,5) USING(CTL2) //CTL1CNTL DD * INREC FIELDS=(1,4, SEQNUM,8,ZD,START=0) OUTREC FIELDS=(1,4, 5,8,ZD,MOD,+3,TO=ZD,LENGTH=1, 5,8,ZD,DIV,+3,EDIT=(T)) OUTFIL FNAMES=T1, OUTREC=(5,1,CHANGE=(4,C'1',C' ', C'2',C' '), NOMATCH=(1,4),X, 5,1,CHANGE=(4,C'0',C' ', C'2',C' '), NOMATCH=(1,4),X, 5,1,CHANGE=(4,C'0',C' ', C'1',C' '), NOMATCH=(1,4),X,80:X,6,1) //CTL2CNTL DD * OUTFIL FNAMES=OUT,OUTREC=(1,80) /* |
Code: |
//STEP01 EXEC PGM=SYNCSORT
//SYSOUT DD SYSOUT=* //SORTIN DD DSN=INPUT DATASET, // DCB=(RECFM=FB,LRECL=240,BLKSIZE=27840), // DISP=SHR //SORTOUT DD DSN=OUTPUT DATASET, // DISP=(NEW,CATLG,DELETE), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=0), // SPACE=(CYL,(100,100),RLSE) //SYSIN DD * SORT FIELDS=COPY OUTREC FIELDS=(1:1,4,5:81,4,9:161,4,13:68X) /* |
Quote: |
Though your solution has a limitation on the input file record count, it is good for everyone to the different possible alternatives. |
Code: |
The Blocksize should be a multiple of the lrecl you are trying to override. |
Code: |
//S1 EXEC PGM=ICEMAN //SYSOUT DD SYSOUT=* //SORTIN DD * 0001 0002 0003 0004 0005 0006 0007 0008 0009 0010 0011 0012 0013 0014 0015 0016 0017 0018 AAAA BBBB /* //SORTOUT DD SYSOUT=* //SYSIN DD * OPTION EQUALS * Init. records to: INREC IFTHEN=(WHEN=INIT, * aaaa zzzz zzzz ... 00000001 * bbbb zzzz zzzz ... 00000002 * cccc zzzz zzzz ... 00000003 * dddd zzzz zzzz ... 00000004 * eeee zzzz zzzz ... 00000005 * ffff zzzz zzzz ... 00000006 * ... * where zzzz is 4 binary zeros. OVERLAY=(6:4Z,11:4Z,81:SEQNUM,8,ZD,START=0, * Use MOD to convert seqnum to 0, 1 or 2 to get: * aaaa zzzz zzzz ... 0 * bbbb zzzz zzzz ... 1 * cccc zzzz zzzz ... 2 * dddd zzzz zzzz ... 0 * eeee zzzz zzzz ... 1 * ffff zzzz zzzz ... 2 * ... 81:81,8,ZD,MOD,+3,TO=ZD,LENGTH=1)), * Set seqnum for 0 records to get: * aaaa zzzz zzzz ... 00000001 * dddd zzzz zzzz ... 00000002 * ... IFTHEN=(WHEN=(81,1,CH,EQ,C'0'), OVERLAY=(81:SEQNUM,8,ZD)), * Set seqnum for 1 records and reformat to get: * zzzz bbbb zzzz ... 00000001 * zzzz eeee zzzz ... 00000002 * ... IFTHEN=(WHEN=(81,1,CH,EQ,C'1'), OVERLAY=(6:1,4,1:4Z,81:SEQNUM,8,ZD)), * Set seqnum for 2 records and reformat to get: * zzzz zzzz cccc ... 00000001 * zzzz zzzz ffff ... 00000002 * ... IFTHEN=(WHEN=(81,1,CH,EQ,C'2'), OVERLAY=(11:1,4,1:4Z,81:SEQNUM,8,ZD)) * Sort on seqnum to get: * aaaa zzzz zzzz ... 00000001 * zzzz bbbb zzzz ... 00000001 * zzzz zzzz cccc ... 00000001 * dddd zzzz zzzz ... 00000002 * zzzz eeee zzzz ... 00000002 * zzzz zzzz ffff ... 00000002 * ... SORT FIELDS=(81,8,ZD,A) * SUM with binary zeros to get: * aaaa bbbb cccc ... 00000001 * dddd eeee ffff ... 00000002 * ... SUM FORMAT=BI,FIELDS=(1,4,6,4,11,4) * Replace binary zeros in 6-9 or 11-14 with blanks (takes care of * record count that is not a multiple of 3). OUTREC IFTHEN=(WHEN=(6,4,BI,EQ,+0),OVERLAY=(6:4X),HIT=NEXT), IFTHEN=(WHEN=(11,4,BI,EQ,+0),OVERLAY=(11:4X)), * Remove seqnum. IFOUTLEN=80 /* |
output generated using printer-friendly topic mod. All times are GMT - 5 Hours