JCL: Copiar bloques de filas mediante SORT

     Si de un fichero queremos copiar las, por ejemplo, 100 primeras filas (dicho fichero tiene N+100 filas), ejecutaremos un paso de SORT como el siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              OPTION STOPAFT = 100
              SORT FIELDS=COPY

O como el siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
               STOPAFT = 100

Fíjate en lo marcado en azul, ya que eso es lo que hace que se copien las 100 primeras filas.

JCL: Obtener fichero en claro mediante SORT

     Los ficheros pueden contener campos numéricos en hexadecimal. Si los editamos no veremos números sino caracteres extraños. Si quisiéramos ver el valor de dichos campos tendríamos que ejecutar el comando HEX ON. Si ese fichero con campos numéricos en hexadecimal tuviéramos que enviarlo a un usuario, y no quisiéramos que viera esos caracteres extraños, deberíamos ponerlo en claro. Ese fichero que se ha generado en claro es el que se envía puesto que los campos numéricos se ven con números y no con caracteres extraños. ¿Y cómo se pone un fichero en claro? Muy fácil. Se hace con un simple paso de SORT como el siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              OUTREC FIELDS=(1,10,
                                         11,8,
                                         19,2,BI,M11,LENGTH=4,
                                         21,2,BI,M11,LENGTH=4,
                                         23,2,
                                         25,2,
                                         27,3,PD,M11,LENGTH=5,
                                         30,5,PD,M11,LENGTH=9,
                                         35,26,
                                         61,8)

     Lo que está marcado en rosa es para campos alfanuméricos (PIC X(-)). Como verás, todos tienen dos números: el primero indica la posición donde empieza el campo en el fichero FICH.PRUEBA.ENTRADA y el segundo indica la longitud del campo.

     Lo que está marcado en morado son campos numéricos de tipo:
          S9(4)COMP

     Lo que está marcado en azul es un campo numérico de tipo:
          S9(3)V9(2)COMP-3

     Lo que está marcado en verde oscuro es un campo numérico de tipo:
         S9(9)COMP-3

     Como observarás, al inicio de todas las filas que hacen referencia a campos numéricos empiezan con dos números: el primero indica la posición donde empieza el campo en el fichero FICH.PRUEBA.ENTRADA y el segundo indica la longitud del campo.

     Con el anterior paso de SORT, a partir de un fichero con campos numéricos en hexadecimal llamado FICH.PRUEBA.ENTRADA, generamos un fichero en claro llamado FICH.PRUEBA.SALIDA en el que los campos numéricos no se visualizan en hexadecimal sino que se representan mediante números.

Libro recomendado del mes

     Voy a comenzar a recomendar libros de informática que os puedan ser útil, ya sea en el día a día de vuestros estudios o en vuestro trabajo.

     El primer libro que os voy a recomendar es Algoritmos + Estructuras de datos = Programas de Niklaus Wirth (editorial Del Castillo). Este libro de 1986 es muy útil para todos aquellos estudiantes que estén dando sus primeros pasos en Pascal.

Master en creación de videojuegos

     Voy a adjuntar un enlace con información acerca de un master en creación de videojuegos. Lo podrás realizar de manera on-line y el certificado es expedido por Deusto Formación. El enlace mencionado es el siguiente:

http://www.deustoformacion.com/master-creacion-videojuegos.asp?c=I10653M9999

     También puedes acceder por este otro enlace:

                              www.deustoformacion.com/VideoJuegos

     Según la información indicada, tiene buena pinta el curso. Aunque Deusto Formación no es el único que oferta un master en creación de videojuegos. También puedes realizar dicho master en:

                              www.uem.es/Programacion_Videojuegos
                              www.evolisnet.com/programacion

Si eres programador, ¿acabarás de analista?

http://orientacion-laboral.infojobs.net/programador-informatico-analista

Artículo de infojobs acerca del futuro profesional de los programadores informáticos.

JCL: Introducción Sort (continuación)

     Hemos visto diferentes casos en los que se usa el paso de SORT pero aún hay más casos en los que se utiliza, como por ejemplo:

• Crear un fichero en claro
• Generar un fichero de salida que contenga las X primeras filas del fichero de entrada
• Generar un fichero de salida que no contenga las X primeras filas del fichero de entrada

     En próximas entradas iremos viendo ejemplos de cada uno de los casos indicados anteriomente.

Manuales en pdf

     He encontrado una página desde la cual te puedes descargar manuales en pdf de dreamweaver, fireworks, flash y muchos más.

     El enlace es el siguiente: http://www.manualespdf.es/

JCL: Obtener un fichero más pequeño mediante SORT

     Para obtener un fichero más pequeño mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              OUTREC FIELDS=(1,30)

     Obsérvese que para generar un fichero más pequeño se utiliza lo siguiente OUTREC FIELDS=(1,30) => esto supone que nos vamos a quedar con las primeras 30 posiciones del fichero de entrada y dichas posiciones serán las que se guarden en el fichero FICH.PRUEBA.SALIDA (importante: el valor que aparece en la segunda posición del OUTREC debe coincidir con la longitud del fichero resultante).

JCL: Obtener dos ficheros mediante SORT

     Para obtener dos ficheros en los que cada uno de ellos tengamos registros distintos mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN   DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SALIDA1  DD DSN=FICH.PRUEBA.SALID1,
          //                    DISP=(,CATLG,DELETE),
          //                    SPACE=(CYL,1,1)
          //SALIDA2  DD DSN=FICH.PRUEBA.SALID2,
          //                    DISP=(,CATLG,DELETE),
          //                    SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              OUTFIL FNAMES=SALIDA1,INCLUDE=(18,2,CH,EQ,C'XX')
              OUTFIL FNAMES=SALIDA2,INCLUDE=(18,2,CH,EQ,C'XY')

     Obsérvese que para generar dos ficheros, FICH.PRUEBA.SALID1 y FICH.PRUEBA.SALID2, en los que uno de ellos contendrá una serie de registros y el otro contendrá el resto de registros existentes en el fichero de entrada debemos incluir las dos sentencias marcadas en malva.

     Esto sirve cuando tenemos un fichero de entrada en el que todos sus registros, empezando en la posición 18, hay una cadena de caracteres cuya longitud es 2 y los posibles valores son XX o XY. Al realizar lo indicado en el ejemplo tenemos que aquellos registros del fichero FICH.PRUEBA.ENTRADA que, empezando en la posición 18, contengan la cadena XX irán al fichero FICH.PRUEBA.SALID1 mientras que los que contangan la cadena XY irán al fichero FICH.PRUEBA.SALID2
     Si queremos generar ambos ficheros y además ordenarlos por un determinado campo debemos sustituir el SORT FIELDS=COPY por lo indicado en la entrada de título JCL: Ordenar un fichero mediante SORT.

JCL: Eliminar/Incluir registros que cumplan una condición

     Para eliminar aquellos registros de un fichero que cumplan una determinada condición mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                   SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              OMIT COND=(18,2,CH,EQ,C'99')

     Obsérvese que para eliminar los registros duplicados se utiliza lo siguiente OMIT COND=(18,2,CH,EQ,C'99') => esto supone que aquellos registros que, empezando en la posición 18, tengan una cadena cuyo valor sea 99 serán eliminados y, por tanto, no estarán en el fichero FICH.PRUEBA.SALIDA

     Para eliminar los que sean iguales a 99 o a otro valor como, por ejemplo, 09 tendríamos algo como lo siguiente:

          OMIT COND=(18,2,CH,EQ,C'99',OR,18,2,CH,EQ,C'09')

     Para incluir, es decir, para generar un fichero en el que tengamos aquellos registros que cumplan una condición habría que sustituir el OMIT por el INCLUDE. Ejemplos:

          INCLUDE COND=(18,2,CH,EQ,C'99')
          INCLUDE COND=(18,2,CH,EQ,C'99',OR,18,2,CH,EQ,C'09')

     Por lo tanto, el paso de SORT quedaría como se indica a continuación:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              INCLUDE COND=(18,2,CH,EQ,C'99')

     Si queremos eliminar/incluir registros que cumplan una condición y además ordenar el fichero resultante debemos sustituir el SORT FIELDS=COPY por lo indicado en la entrada de título JCL: Ordenar un fichero mediante SORT.

JCL: Eliminar duplicados mediante SORT

     Para eliminar duplicados de un fichero mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
              SUM FIELDS=NONE

     Obsérvese que para eliminar los registros duplicados del fichero de entrada FICH.PRUEBA.ENTRADA se utiliza lo siguiente: SUM FIELDS=NONE
     En el fichero de salida FICH.PRUEBA.SALIDA tendremos una copia exacta del fichero FICH.PRUEBA.ENTRADA pero habiendo eliminado los registros duplicados.

     Si queremos eliminar duplicados y además ordenar el fichero resultante debemos sustituir el SORT FIELDS=COPY por lo indicado en la entrada de título JCL: Ordenar un fichero mediante SORT.

JCL: Copiar un fichero mediante SORT

Para copiar un fichero mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                    DISP=(,CATLG,DELETE),
          //                    SPACE=(CYL,1,1)
          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY

Obsérvese que para copiar el fichero FICH.PRUEBA.ENTRADA se utiliza lo siguiente: SORT FIELDS=COPY => esto supone que vamos a hacer una copia exacta en el fichero de salida FICH.PRUEBA.SALIDA

14/12/2018 - Actualización. Ahora bien, si queremos copiar muchos archivos en uno solo, ¿cómo se haría? Muy fácil, partimos del ejemplo anterior y procedemos a copiar, por ejemplo, 5 ficheros en uno solo. El paso de sort quedaría así:

          //SORT01 EXEC PGM=SORT

          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA1,DISP=SHR

          //              DD DSN=FICH.PRUEBA.ENTRADA2,DISP=SHR

          //              DD DSN=FICH.PRUEBA.ENTRADA3,DISP=SHR

          //              DD DSN=FICH.PRUEBA.ENTRADA4,DISP=SHR

          //              DD DSN=FICH.PRUEBA.ENTRADA5,DISP=SHR

          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,

          //                    DISP=(,CATLG,DELETE),

          //                    SPACE=(CYL,1,1)

          //SORTWK01 DD SPACE=(CYL,(1,1),RLSE)

          //SYSOUT     DD SYSOUT=*

          //SYSIN        DD *

              SORT FIELDS=COPY

Como resultado tendríamos un fichero de salida, FICH.PRUEBA.SALIDA, en donde tendríamos la información de los 5 ficheros de entrada e iría concatenada una detrás de otra; es decir, primero irían los registros del primer fichero, después los registros del segundo fichero, a continuación los registros del tercer fichero, los del cuarto fichero y finalmente estarían los del quinto fichero.

JCL: Ordenar un fichero mediante SORT

     Para ordenar un fichero mediante un paso de SORT se haría lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FICH.PRUEBA.ENTRADA,DISP=SHR
          //SORTOUT DD DSN=FICH.PRUEBA.SALIDA,
          //                     DISP=(,CATLG,DELETE),
          //                     SPACE=(CYL,1,1)
          //SORTWK01 SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=(1,10,CH,A)

     Obsérvese que para ordenar el fichero FICH.PRUEBA.ENTRADA se utiliza lo siguiente: SORT FIELDS=(1,10,CH,A) => esto supone que se va a ordenar por un campo que empieza en la posición 1, dicho campo es de 10 posiciones, es un campo alfanumérico -CH- y se va a ordenar de forma ascendente -A-

     El resultado de la ordenación se guarda en el fichero FICH.PRUEBA.SALIDA

     Para ordenar de forma descendente habría que sustituir la A por una D.

     Ahora bien, ¿qué pasa sin en lugar de tener un campo alfanumérico (razón por la cual usamos CH) tenemos un campo cuyo tipo es distinto? Pues entonces tendríamos que sustituir CH por:

• BI si el campo a ordenar es un campo numérico: PIC S9(-)
• ZD si el campo a ordenar es un campo numérico: PIC 9(-)
• PD si el campo a ordenar es un campo numérico empaquetado: PIC S9(-)COMP-3

Resumen: para ordenar un fichero en otro debemos utilizar lo siguiente:

               SORT FIELDS (X1,X2,TD,ORD)

siendo X1 la posición en la que empieza el campo a ordenar dentro del fichero

          X2 la longitud del campo a ordenar

          TD el tipo de dato del campo a ordenar (CH, ZD, PD,...)

          ORD el tipo de ordenación (A - Ascendente, D - Descendente)

JCL: Introducción Sort

     En los JCL's es muy común incluir pasos en los que se utilice el comando SORT. El SORT no sólo es utilizado para ordenar un fichero sino también para realizar todo lo siguiente:

• copiar de un fichero a otro
• eliminar duplicados de un fichero
• eliminar registros que cumplan una determinada condición
• incluir registros que cumplan una determinada condición
• obtener dos ficheros en los que cada uno de ellos tengamos registros distintos (por ejemplo, tenemos un fichero principal en el que los registros pueden clasificarse en dos grupos y los que pertenezcan a un grupo irán a un fichero y los que pertenezcan al otro grupo irán al otro fichero)
• generar un fichero más pequeño debido a que quitamos los últimos campos del fichero principal

     En futuras entradas iremos viendo todas estas cosas y muchas más sobre el SORT.