Syncsort, DFSORT en JCL: Ejemplos de uso

Si trabajas en Mainframe, seguramente conoces sobre las herramientas de ordenación, sobre ICETOOL, ICEMAN,  etc. o SORT a secas.

Estas herramientas en realidad, resuelven a las herramientas producto instaladas en el Mainframe como DFSORT o Syncsort.

En mi trabajo, usábamos DFSORT, luego por alguna razón notamos que nos cambiamos a Syncsort, y dos años después, volvimos a DFSORT. DFSORT es la herramienta de ordenación de IBM. Mientras que Syncsort es la herramienta de la empresa del mismo nombre.

Una costumbre habitual es circunscribir nuestros desarrollos a los modelos y ejemplos ya realizados por los demás. Y con el tiempo suponer que esa es la única forma de hacer las cosas. No lo hagas. Duda, investiga, intenta siempre hacer las cosas de manera diferente.

Por ejemplo, era costumbre en mi trabajo usar los STEP de un JCL solo para llamar a programas COBOL, y a lo más, para hacer ordenaciones sencillas. Para todo los demás, como por ejemplo para la mezcla de archivos en un archivo único (el famoso matching), debíamos usar programas COBOL.

Entonces, con la llegada de Syncsort, se me ocurrió entrar a la web, y lo que encontré fue a miles de personas haciendo las cosas no solo de otra manera, sino que esa otra manera era más eficiente, más rápida y más confiable, es decir, mejor.

Conseguí el manual de Syncsort, y desde ese momento, y poco a poco, en mi equipo ahora se usan muchos STEP de ordenaciones cada vez más complejos. Si el criterio antes era “usa los JCL para llamar a programas y para hacer ordenaciones simples“, ahora ha cambiado a “usa los JCL todo lo que puedas excepto para acceso a datos y decisiones complejas“.

"Sí jefe..."
“Sí jefe, tres días para hacer un programa que haga matching de dos archivos y grabe en la salida solo los registros que hagan match.”

Aquí algunos ejemplos tipo:

1. letf outer join (Es decir, para dos archivos A y B, obtener A – B)

//STEP1 EXEC PGM=SORT
//SORTJNF1 DD DSN=INPUT.FILE1 (VB/255)
//SORTJNF2 DD DSN=INPUT.FILE2 (VB/255)
//SORTOUT DD DSN=OUTPUT.FILE (VB/255)
//SYSOUT DD SYSOUT=*
//SYSIN DD *
JOINKEYS FILES=F1,FIELDS=(5,6,A,12,4,A,19,1,A)
JOINKEYS FILES=F2,FIELDS=(5,6,A,32,4,A,50,1,A)
JOIN UNPAIRED,F1
REFORMAT FIELDS=(F1:5,251,F2:5,251)
SORT FIELDS=COPY
OUTFIL FILES=OUT,
IFTHEN=(WHEN=(252,1,CH,EQ,C’ ‘),BUILD=(1,251)),
IFTHEN=(WHEN=(252,1,CH,NE,C’ ‘),BUILD=(1,251,/,252,251)),
FTOV
/*

2. Únicos y repetidos (Es decir, de una entrada dada, dejar dos archivos: Uno con los repetidos y otro con los de una sola ocurrencia).

//STEP1 EXEC PGM=SORT
//SORTIN DD *
0001
0002
0002
0003
0004
0005
0005
//SORTXDUP DD DSN=&&XDUP,DISP=(NEW,PASS)
//SORTOF01 DD DSN=&&OUT1,DISP=(NEW,PASS)
//SORTOF02 DD DSN=UNIQUE.RECORDS
//SYSOUT DD SYSOUT=*
//SYSIN DD *
INREC OVERLAY=(81:X’F1′)
SORT FIELDS=(1,5,CH,A)
DUPKEYS SUM=(81,1,ZD),XDUP
OUTFIL FILES=01,INCLUDE=(81,1,ZD,GT,1)
OUTFIL FILES=02,INCLUDE=(81,1,ZD,EQ,1),BUILD=(1,80)
/*
//STEP2 EXEC PGM=SORT
//SORTIN01 DD DSN=&&XDUP,DISP=SHR
//SORTIN02 DD DSN=&&OUT1,DISP=SHR
//SORTOUT DD DSN=ALLDUPS
//SYSOUT DD SYSOUT=*
//SYSIN DD *
INREC BUILD=(1,80)
MERGE FIELDS=(1,5,CH,A)
/*

3. Tres archivos: match, f1-f2 y f2-f1 (Es decir, dadas dos entradas F1 y F2, tener tres salidas: Lo común, F1 – F2 y F2 -F1)

//SYSIN DD *
JOINKEYS FILE=F1,FIELDS=(1,30,A)
JOINKEYS FILE=F2,FIELDS=(7,30,A)
JOIN UNPAIRED
REFORMAT FIELDS=(F2:1,93,F1:1,1717),FILL=X’FF’,
SORT FIELDS=COPY
OUTFIL FILES=03,INCLUDE=(1,1,CH,EQ,X’FF’),BUILD=(94,1717)
OUTFIL FILES=02,INCLUDE=(94,1,CH,EQ,X’FF’),BUILD=(1,93)
OUTFIL FILES=01,SAVE,BUILD=(1,93)
/*

4. Completar datos de una entrada, si no encontró, agregar texto

//STEP1 EXEC PGM=SORT
//SORTJNF1 DD *
A00001
A00002
A00003
A00004
//SORTJNF2 DD *
A00001. 90
A00003. 39
//SORTOUT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
JOINKEYS FILES=F1,FIELDS=(1,6,A)
JOINKEYS FILES=F2,FIELDS=(1,6,A)
JOIN UNPAIRED,F1
REFORMAT FIELDS=(F1:1,6,F2:7,8)
SORT FIELDS=COPY
OUTREC IFTHEN=(WHEN=(7,8,CH,EQ,C’ ‘),OVERLAY=(7:C’. 00′))
/*

5. Formatear packed decimal (conversión a valores editados)

//SYSIN DD *
SORT FIELDS=COPY
OUTREC IFTHEN=(WHEN=(31,4,CH,EQ,C’1130′),
OVERLAY=(36:36,10,PD,EDIT=(STTTTTTTTTTTTTTTTTTT.TT),SIGNS=(+,-))),
IFTHEN=(WHEN=(31,4,CH,EQ,C’1131′),
OVERLAY=(46:36,10,PD,EDIT=(STTTTTTTTTTTTTTTTTTT.TT),SIGNS=(+,-))),
IFTHEN=(WHEN=(31,4,CH,EQ,C’1132′),
OVERLAY=(55:36,10,PD,EDIT=(STTTTTTTTTTTTTTTTTTT.TT),SIGNS=(+,-)))

6. Convertir PD (packed decimal) a zd (zoned decimal) (o desempaquetar un numérico)

//SYSIN DD *
SORT FIELDS=COPY
OUTREC FIELDS=(325,7,PD,TO=ZD,LENGTH=13)
/*

7. Convertir ZD a PD, según condición de entrada (o empaquetar un numérico)

OPTION COPY
INREC IFTHEN=(WHEN=(1,2,CH,EQ,C’30’),
OVERLAY=(3:3,8,FS,TO=PD,LENGTH=5,3X))
/*

8. Formatear una salida (construir un archivo de salida a partir de los archivos de entrada y otras condiciones)

OUTREC BUILD=(5,2,5C’*’,18,6,C’ABC’,+30,TO=BI,LENGTH=4,X’01’,80:X)

9. Finder dentro de un master (buscar una muestra dentro de un todo)

//JOIN EXEC PGM=SYNCSORT
//SORTJNF1 DD DSN=YOUR.INPUT.MASTER.FILE
//SORTJNF2 DD DSN=YOUR.FINDER.FILE
//SORTOUT DD DSN=YOUR.DESIRED.OUTPUT.FILE
//SYSOUT DD SYSOUT=*
//SYSIN DD *
JOINKEYS FILE=F1,FIELDS=(22,15,CH,A),SORTED
JOINKEYS FILE=F2,FIELDS=(1,15,CH,A),SORTED
REFORMAT FIELDS=(F1:1,3400)
SORT FIELDS=COPY
END
/*

Estos ejemplos en realidad funcionan en cualquier herramienta de ordenación. Todos estos ejemplos fueron tomados de Internet, y los fui ubicando a medida que los necesitaba.

¿Y cuál es la diferencia con hacer un programa COBOL que realice lo mismo? Total, también hay modelos ¿no?. Bueno, estas herramientas son tipo comandos a los que hay que cambiar los parámetros, y estamos seguros que los matching, conteos, sumas, restas u formateos no fallan. Las pruebas se enfocan en ver que hayamos puestos los parámetros de forma correcta y obtener la salida esperada. En cambio, cuando un programa COBOL hace un matching, hay que hacer varios tests de prueba, antes de estar seguros que el programa hacer el matching adecuadamente. Luego recién haremos las pruebas funcionales para ver que obtener la salida esperada. Ha habido más de una incidencia, cuya causa estaba asociada a defectos encontrados en estos programas COBOL. Una última ventaja, pasar un JCL por un circuito de cambios y de pase a Producción es más sencillo.

El motivo de este post es dejar en línea estos ejemplos tipo. Los apuntes se pierden con el tiempo.

[2017-12-09] Actualización: Comencé a añadir nuevos posts sobre estos temas. Join entre archivos con SyncSort  y Filtrar y ordenar archivos con SyncSort inician la serie.

Nos vemos en la red.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s