Canal Visual Basic .NET

Para todos los que trabajan con Visual Basic .NET (o lo estudian) os interesa conocer la página web llamada canal visual basic .net que podréis encontrar en la sección Páginas de interés de este mismo blog.

Concurso Master the Mainframe España 2012

El Concurso Master the Mainframe España 2012 es una iniciativa de IBM para acercar a los universitarios de todo el mundo a la tecnología mainframe.

Tal y como se indica en la introducción del concurso, y citaré textualmente:

Para participar no es necesario contar con experiencia en el mundo del mainframe.

El concurso se desarrolla durante ocho semanas (del 22 de Octubre al 21 de Diciembre), con una dedicación total de 30 horas, y se divide en tres etapas en las que se desarrollarán ejercicios de dificultad creciente, trabajando sobre servidores reales. Para poder completar los ejercicios los participantes reciben documentación e instrucciones precisas

Lo único que se necesita para participar es espíritu competitivo y deseos de pertenecer a la comunidad tecnológica de IBM System z.

¿Por qué participar? ¡Por los premios!

Parte 1: Un teclado y ratón Lenovo para los 15 primeros participantes en resolver el ejercicio.
Parte 2: Un eBook para los 6 participantes con las más altas valoraciones del ejercicio.

Parte 3: - Tercero, cuarto y quintos clasificados: Un Tablet Samsung
             - Segundo clasificado: Un thinkpad Lenovo
             - Primer clasificado: Asistencia en el laboratorio de IBM de 
               Poughkeepsie (NY, USA) a un seminario sobre tecnología 
               Mainframe, junto con los ganadores del concurso de USA y 
               Sudamérica, compartiendo experiencias con expertos y ejecutivos 
               de IBM. (Días 27 a 29 de Marzo de 2013)

Si estás interesad@, aquí tienes la información para saber cómo participar.

Apuntes en pdf de java

He reunido algunos apuntes en pdf de java que he encontrado en internet. Adjunto enlaces:

http://informatica.utem.cl/~mcast/sw/apuntes/apuntesJava.pdf

http://www.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/Java/Java2.pdf

Espero que os sean de utilidad.

El futuro de los ordenadores

De acuerdo al siguiente artículo de yahoo que puedes leer pinchando aquí se plantea si estamos ante el final de los PC's.

Según el artículo los ordenadores podrían llegar a ser sustituidos por otros gadgets (smartphones o tabletas) por las ventajas de estos últimos.

A pesar del auge de ciertos gadgets parece improbable, por lo menos en un futuro inmediato, que puedan llegar a sustituir a los ordenadores. Si a ello le añadimos que un ordenador con conexión a internet suele usarse para la descarga de películas y canciones, todavía parece más raro aún la sustitución del mismo por otro tipo de artilugios ya que, ¿dejarías un smartphone encendido toda la noche para descargarte una película con el riesgo de que se agote la batería a la mitad de la descarga? Creo que no. Lo mismo se podría  decir de una tableta. Esto último en lo referente al entorno doméstico. En el entorno laboral, el ordenador aún sigue ofreciendo una serie de características que le hacen, al menos por ahora, insustituible.

Por lo tanto, en el futuro inmediato que nos espera el ordenador no será sustituido por otros gadgets (smartphones o tabletas). Seguirán siendo complementarios.

Libros informática en pdf

     He encontrado la siguiente página web con libros de informática en pdf:

               http://www.librospdf.net/c/inform%C3%A1tica/1/

     Espero que te sirva de utilidad y encuentres algún libro de tu interés.

Cobol: Utilizar sentencias SQL: count

Si queremos realizar un select count(*), la sentencia sería:

              SELECT COUNT(*) INTO :NUM-REG :IND-NULL
              FROM {TABLA,}[WHERE CONDICIÓN]

Teniendo en cuenta lo siguiente:

• Se deben definir NUM-REG e IND-NULL como PIC S9(04) COMP
• A la hora de controlar el SQLCODE devuelto por esta sentencia SQL es muy importante la variable IND-NULL por lo siguiente:

               IF SQLCODE EQUAL ZEROES

                      IF IND-NULL EQUAL -1

                          MOVE ZEROES TO NUM-REG

                      END-IF

               ELSE

                   PERFORM ERROR-DB2

               END-IF

Esto es todo lo que hay que tener en cuenta sobre esta sentencia SQL.

Formación

     He creado una nueva página en este blog llamada Formación en la que encontrarás diversas páginas web relacionadas con, como indica el título de la sección, formación y podrás encontrar cursos y másteres de todo tipo relacionados con las nuevas tecnologías.

     Algunas de las páginas incluidas las he eliminado de la sección Páginas web de interés en donde permanecerán páginas web que te puedan ser útiles en caso de querer consultar alguna duda o saber cómo se hace algo en concreto en un determinado lenguaje de programación.

     Espero que te sea de utilidad si quieres ampliar conocimientos.

Manuales para aprender desde 0

He encontrado una serie de manuales para aprender desde 0:

• Oracle ---> http://www.oracleya.com.ar/
• HTML ---> http://www.htmlya.com.ar/
• CSS ---> http://www.cssya.com.ar/
• JavaScript ---> http://www.javascriptya.com.ar/
• DHTML ---> http://www.dhtmlya.com.ar/
• PHP ---> http://www.phpya.com.ar/
• ASP ---> http://www.aspya.com.ar/
• ASP .NET ---> http://www.aspnetya.com.ar/
• Python ---> http://pythonya.appspot.com/
• MySQL ---> http://www.mysqlya.com.ar/
• SQL Server ---> http://www.sqlserverya.com.ar/
• Postgre SQL ---> http://www.postgresqlya.com.ar/
• Ajax ---> http://www.ajaxya.com.ar/

Espero que os sean de utilidad estos manuales si queréis aprender algo de lo aquí listado y empezáis desde 0.

Libro recomendado del mes

     El libro que os voy a recomendar en esta ocasión es Programación en C de los autores Luis Joyanes Aguilar e Ignacio Zahonero Martinez (editorial McGraw-Hill).

    Este libro es muy útil para todos aquellos estudiantes que estén comenzando con C. Empieza desde lo más básico (variables, tipos de datos, arrays, registros, ficheros...) hasta lo más complejo (punteros y estructuras dinámicas como listas, pilas, colas,...). Incluso tiene una introducción a C++.

     Este libro lo utilicé cuando aprendí a programar en C y gracias a ese libro, si lo sigues de principio a fin, puedes acabar con unos buenos conocimientos de programación en C. Os lo recomiendo totalmente.

Consultar dudas

     He encontrado la siguiente página web: http://www.w3schools.com/

     Dicha página me ha sido muy útil cuando he tenido alguna duda acerca de sentencias SQL.

     Pero esta página no sólo tiene una sección dedica a SQL sino a muchas cosas más como HTML, XML, ASP o JavaScript por mencionar una pequeña parte.

     Espero que esta página os sea tan útil como me lo ha resultado a mí.

Buscador cursos informática

     Os dejo un enlace de un buscador de cursos en el que podréis buscar cursos relacionados con el sector de la informática y FP. Espero que os sirva de utilidad y podáis encontrar un curso que os guste:

          http://www.cursosformacionprofesionalfp.com/

JCL: SORT - Curiosidades I

     Hay algunas cosas del SORT que es interesante conocer. Una de ellas es que las condiciones de ordenación pueden estar guardadas en un fichero. ¿Lo sabías? Pues sí, pueden estar en un fichero.

     Solemos estar acostumbrados a ver los pasos de sort con un fichero en el SORTIN, otro en el SORTOUT  y la cláusula SYSIN en donde ponemos:

                      SORT FIELDS=COPY
                      INCLUDE COND=(1,4,ZD,GT,28)

     O lo que proceda en cada caso. Pero también se puede sustituir por lo siguiente:

             //SYSIN DSN=FICHERO.CONDICIONES.SORT,DISP=SHR

     

      En dicho fichero tendríamos el SORT, INCLUDE,...

     Espero que esta entrada os haya servido para aprender una cosa nueva y que sea de utilidad si tenéis dudas de cómo hacer referencia en un paso de SORT a un fichero que contiene las condiciones de ordenación necesarias para ese paso. 

Trucos de informática y programación

     Existen diferentes páginas con trucos de informática y de programación. A continuación paso a detallar una serie de páginas que pueden serte útiles:

• Trucos de Windows (trucos del sistema operativo, de office, ...) y Trucos de Programación (Visual Basic 6 y .NET, C#, ASP .NET,  ...). Estos trucos los encontrarás en: http://www.mistrucos.net/
• Más trucos todavía para ayudarte con la informática e internet. Todos estos trucos los encontrarás en: http://www.trucostecnicos.com/
• Todos los trucos que puedas imaginar acerca de Windows los encontrarás en la siguiente página web: http://www.trucoswindows.com/

     Estas páginas las encontrarás en la sección Trucos de este mismo blog para que no tengas que acceder a esta entrada cada vez que quieras consultar cualquiera de las páginas mencionadas anteriormente. Cada vez que encuentre una página de trucos la incluiré en la sección Trucos.

Cursos TIC con inserción laboral

     Os adjunto link a la página Web de Microforum, página dedicada a cursos TIC con inserción laboral grantizada: http://www.microforum.es/

     Espero que os sea de utilidad.

¿Cómo convertir un VSAM a fichero secuencial?

     En determinados casos nos veremos en la situación de convertir un fichero VSAM en un fichero secuencial.

     Te preguntarás que cómo se hace. Es muy fácil y sencillo: mediante un simple paso de SORT lo podemos conseguir.

     Imagínate que tienes un fichero VSAM llamado FIC.VS.INFORMA

     Para pasar el mencionado fichero a uno secuencial sólo tienes que emplear un paso de SORT en el que hagas algo como lo siguiente:

          //SORT01 EXEC PGM=SORT
          //SORTIN    DD DSN=FIC.VS.INFORMA,DISP=SHR
         //SORTOUT DD DSN=FICH.VSINFORMA.SECUEN,
          //                    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 en la línea del SORTIN se ponde el fichero VSAM y en el SORTOUT se pone el fichero secuencial que se generará al ejecutarse dicho paso de SORT. El fichero secuencial se generará de acuerdo a lo indicado en el SORT FIELDS.

Cobol: Lista de FILE STATUS en pdf

     Hace más de un año adjunté un enlace con la lista de los FILE STATUS. Ahora os podeis descargar la Lista de FILE STATUS en pdf, simplemente teneis que ir a la sección de Descargas HOST existente en este mismo blog. 

Cobol: Lista de SQLCODE en pdf

     Hace más de un año adjunté un enlace con la lista de los SQLCODES. Ahora os podeis descargar la Lista de SQLCODE en pdf, simplemente teneis que ir a la sección de Descargas HOST existente en este mismo blog.

Cobol: Lista de errores en excel

     Cuando un programa Cobol utiliza DB2, ficheros, IMS o DLI se pueden producir una serie de errores en la utilización de dichos elementos. También existen otro tipo de errores como los errores de usuario o los del sistema.

     Ahora os podeis descargar desde la sección de Descargas HOST existente en este mismo blog un archivo comprimido (.zip) que contiene una hoja excel con diferentes tipos de errores como por ejemplo errores DB2, errores de usuario, errores VSAM, errores de sistema, errores IMS y tabla de códigos de retorno DLI. El nombre del archivo es Lista de errores HOST en Excel.

     Espero que os sirva de utilidad.

Dónde estudiar ciclo formativo

Si queréis saber dónde estudiar un ciclo formativo, sólo tenéis que pinchar aquí para acceder a la entrada del blog titulado Blog de Formación Profesional. 

Espero que sirva de utilidad a todos los que queráis estudiar un ciclo formativo de FP.

FP en informática

Os recomiendo la siguiente página acerca de la FP de informática, muy interesante para todos los que quieran estudiar informática en FP:

          http://www.fp-informatica.es/

JCL: Eliminar bloques de filas mediante SORT

     Si de un fichero queremos eliminar las, por ejemplo, 100 primeras filas (dicho fichero tiene N+100 filas) supone que debemos copiar desde la fila 101. Para ello 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,RLSE),
          //                   DCB=(RECFM=FB,BLKSIZE=6144,LRECL=64)
          //                   UNIT=SYSDA
          //SORTWK01 DD UNIT=SYSDA,SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              OPTION SKIPREC = 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,RLSE),
          //                   DCB=(RECFM=FB,BLKSIZE=6144,LRECL=64)
          //                   UNIT=SYSDA
          //SORTWK01 DD UNIT=SYSDA,SPACE=(CYL,(1,1),RLSE)
          //SYSOUT     DD SYSOUT=*
          //SYSIN        DD *
              SORT FIELDS=COPY
                 SKIPREC = 100

Fíjate en lo marcado en azul, ya que eso es lo que hace que se ignoren las 100 primeras filas y se empiece a copiar a partir de la 101.

Estudiar Ingeniería Informática

     Si estáis pensando en estudiar ingeniería informática, os recomiendo la siguiente página web: http://www.gradomania.com/

     Si pincháis en el link anterior, veréis la siguiente pantalla:

     En Ingeniería y Arquitectura están detalladas todas las carreras relacionadas con la ingeniería y la arquitectura. Si hacéis clic en Ingeniería  en Informática, aparecerá un listado de todas las universidades españolas que ofrecen dicha titulación.

     Pero si lo preferís, en caso de que esteis interesados en saber si una  determinada universidad imparte la titulación de ingeniería informática, podéis ir a la sección Universidades (situada a la izquierda de la anterior pantalla) y hacer clic en la comunidad autónoma a la que pertenezca dicha universidad. Tras hacer clic aparece un listado de las universidades existentes en la comunidad autónoma elegida, de ese listado no tenéis más que hacer clic en la universidad que prefiráis y ver si imparte dicha titulación.

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)