Saltar al contenido
Entender conceptos

Principiante11 min de lectura

El mapa del mainframe: dataset, PDS, copy, JCL y job

Vienes de una PC con archivos y carpetas. Aquí está el mapa de las piezas que vas a tocar en el mainframe, qué es cada una y, sobre todo, con qué nombre se conecta con la siguiente.

Al terminar sabrás

  • Qué es un dataset, cómo se nombra y por qué no es un archivo de texto de PC.
  • Qué es una librería (PDS o PDSE), qué se guarda ahí y qué es un copy.
  • Qué hacen las tres sentencias del JCL y qué pasa desde el submit hasta el spool.
  • Cómo se conecta todo: del fuente en su librería al job que lo ejecuta y los datasets que lee y escribe.

Antes de empezar

Vienes de una PC: archivos con extensión, carpetas dentro de carpetas, doble clic para ejecutar. El mainframe tiene equivalentes para casi todo, pero ninguno es igual. Esta guía es el mapa: qué es cada pieza, qué tiene de parecido con lo que ya conoces y, en cada una, dónde deja de servir la comparación. Ahí es donde se esconden los tropiezos del primer proyecto.

Aquí conoces a CALCNOM1, el programa inventado que acumula la nómina y que te acompaña a lo largo de las guías. Al final lo vas a seguir desde su fuente hasta su salida.

Dataset: el “archivo” que no es un archivo

Un dataset es un conjunto de registros con nombre. Es lo más parecido a un archivo, y así lo vas a llamar en la práctica. Tres cosas lo hacen distinto.

El nombre no lleva carpeta. Se forma con calificadores separados por punto, hasta 44 caracteres en total, cada calificador de 1 a 8 y empezando por letra o por #, @ o $:

NOMINA.PRUEBAS.EMPLEADOS

El primero es el high-level qualifier (HLQ). No es una carpeta, aunque lo parezca: el sistema lo usa para saber en qué catálogo buscar el dataset. Qué HLQ usa cada equipo, proyecto o ambiente lo decide cada instalación; pregunta antes de inventar uno.

No es texto con saltos de línea. Un dataset son registros, y en los que vas a usar al empezar todos miden lo mismo. El formato de registro es el RECFM (F de fijo, FB fijo en bloques) y el largo es el LRECL. Un archivo RECFM=FB,LRECL=80 es una fila de registros de 80 bytes, uno tras otro, sin ningún carácter que marque el final de cada uno: el final es que se acabaron los 80. Por eso un copy que no coincide con el archivo te da basura y no un error. También existen registros de longitud variable (RECFM=V); los verás cuando te toquen.

Hay dos organizaciones que vas a usar. El dataset secuencial es la fila de registros que se leen en orden, del primero al último: así son los archivos de entrada y salida de un programa batch. El particionado es el que tiene miembros adentro, y tiene su propia sección abajo. VSAM es otra organización, y la verás cuando te toque.

Una pieza más: el catálogo. Es el índice donde el sistema guarda en qué disco está cada dataset. Gracias a él, en el JCL basta con escribir el nombre. Un dataset nuevo se cataloga cuando el JCL lo pide: es lo que hace el CATLG del DISP=(NEW,CATLG,DELETE) que vas a ver en el ejemplo de más abajo.

Ojo con esto: la comparación con un archivo de PC sirve hasta que abres el dataset en el editor y ves “líneas”. Son registros. Nada de lo que escribas después de la columna del LRECL existe, y un registro no se puede hacer “más largo” por su cuenta.

PDS y PDSE: la librería y sus miembros

Un PDS (partitioned data set) es un dataset con un directorio y miembros. Cada miembro tiene un nombre de hasta 8 caracteres y es, por dentro, una secuencia de registros. Se escribe así:

NOMINA.FUENTES(CALCNOM1)

Es lo más parecido a una carpeta, y por eso a los PDS se les llama librerías. Lo que vas a encontrar en ellas: fuentes COBOL, copys, JCL y programas ejecutables. Por convención cada tipo va en una librería distinta; los nombres (FUENTES, COPYS, JCL, LOADLIB) cambian en cada instalación.

Dónde deja de servir la comparación con la carpeta: no hay subcarpetas, un miembro no puede contener otro; y todos los miembros comparten el RECFM y el LRECL de la librería. Una librería de fuentes suele ser FB de 80, y por eso tu programa COBOL vive en registros de 80 columnas.

El PDSE (partitioned data set extended) es la versión moderna: mismo uso y mismos miembros, pero su directorio crece solo y reutiliza el espacio de los miembros que borras, cosa que el PDS no hace. Hay una diferencia que sí te toca: los programas ejecutables de Enterprise COBOL (desde la versión 5) se generan como program objects, y un program object solo puede guardarse en un PDSE (o en un archivo de z/OS UNIX, que aquí no usamos). Tu librería de loads, donde viven los programas ejecutables, es por lo tanto un PDSE.

Copy: el pedazo de programa que se comparte

Un copy (o copybook) es un trozo de código COBOL guardado como miembro de una librería de copys, para que varios programas lo incluyan sin copiarlo a mano. Lo más común es la definición de un registro: el layout de un archivo que leen diez programas vive en un solo copy, y si el archivo cambia, cambias el copy y recompilas los diez.

Este es CPEMPLEA, el copy con el registro de empleado que usa CALCNOM1, guardado como NOMINA.COPYS(CPEMPLEA):

       01  WS-EMPLEADO.
           05  WS-NUM-EMPLEADO      PIC 9(6).
           05  WS-NOMBRE            PIC X(40).
           05  WS-TIPO-EMPLEADO     PIC X.
           05  WS-IMPORTE           PIC S9(7)V99 COMP-3.

Y así lo incluye el programa, con la sentencia COPY y su punto:

       WORKING-STORAGE SECTION.
           COPY CPEMPLEA.

Al compilar, el texto del copy se pega donde está el COPY. En el listado de compilación lo ves ya expandido, con sus propios números de línea; de eso hablamos en Cómo leer un listado de compilación. Cómo encuentra el compilador la librería del copy lo vemos en el recorrido, más abajo.

JCL: las tres sentencias

El JCL (job control language) es como le dices al sistema qué programa ejecutar y con qué archivos. Se parece a un script, y ahí termina la comparación: casi no tiene lógica, no hay ciclos ni variables como en un programa, y lo poco que tiene (condiciones entre steps) lo ves en Del fuente a la ejecución. Cada línea empieza con // en las columnas 1 y 2. Un JCL mínimo para ejecutar CALCNOM1:

//NOMINA01 JOB (CUENTA),'CALCULO NOMINA',CLASS=A,MSGCLASS=X
//PASO01   EXEC PGM=CALCNOM1
//STEPLIB  DD DSN=NOMINA.PRUEBAS.LOADLIB,DISP=SHR
//EMPLEADO DD DSN=NOMINA.PRUEBAS.EMPLEADOS,DISP=SHR
//TOTALES  DD DSN=NOMINA.PRUEBAS.TOTALES,
//            DISP=(NEW,CATLG,DELETE),
//            SPACE=(TRK,(5,5)),
//            DCB=(RECFM=FB,LRECL=80)
//SYSOUT   DD SYSOUT=*

Tres tipos de sentencia y nada más:

  • JOB marca el inicio del job y le da nombre, NOMINA01. Hay una sola por job. Lo demás en esa línea es información administrativa (cuenta, clase, dónde va la salida), y cada instalación tiene la suya.
  • EXEC marca el inicio de un step y dice qué programa ejecutar: PGM=CALCNOM1. Un job con tres programas tiene tres EXEC, y cada uno es un step con su nombre.
  • DD (data definition) describe un dataset que el step va a usar. Cada DD tiene un nombre a la izquierda, el ddname (EMPLEADO, TOTALES), y a la derecha qué dataset es (DSN=) y qué hacer con él (DISP=: SHR para compartir uno que existe, NEW para crearlo). SYSOUT=* significa “esto no va a un dataset, va al spool”, el almacén donde JES guarda la salida de los jobs.

Dos ddnames del ejemplo son especiales. STEPLIB lo reconoce el sistema: es la librería donde busca el programa del PGM=. SYSOUT no es del sistema sino de COBOL: es el ddname al que van los DISPLAY por omisión, porque el compilador asume la opción OUTDD(SYSOUT).

Ojo con esto: el programa no conoce el nombre del dataset. Solo conoce el ddname. Esa es la conexión más importante de toda esta guía y tiene su párrafo en el recorrido.

Job, step y JES: del submit al spool

Cuando haces submit del JCL, se lo entregas a JES (job entry subsystem), el componente de z/OS que recibe los jobs, los encola y administra su salida; los steps los ejecuta el sistema, uno tras otro y en el orden del JCL. El job corre en el fondo y tu sesión queda libre: eso es batch.

Cada step termina con un return code, y el del job es el más alto de sus steps. Todo lo que el job produce que no sea un dataset (los mensajes del sistema, los DISPLAY, cualquier SYSOUT=*) queda en el spool. Ahí lo ves con SDSF o con la herramienta que use tu instalación: la lista de jobs, su return code y, dentro de cada uno, el JESMSGLG y el JESYSMSG (los mensajes de JES y del sistema) y el SYSOUT de cada step. Si el job tronó, la guía Me tronó en ejecución te dice en qué orden leerlos.

Cómo se conecta todo: el recorrido de CALCNOM1

Este es el mapa completo, de arriba hacia abajo. Junto a cada flecha está el nombre que une una pieza con la siguiente; cuando algo no corre, casi siempre es uno de esos nombres el que no coincide.

NOMINA.FUENTES(CALCNOM1)       NOMINA.COPYS(CPEMPLEA)
librería de fuentes            librería de copys
        |                              |
        |          COPY CPEMPLEA       |
        |  <---------------------------+
        v
compilar y linkeditar          (Del fuente a la ejecución)
        |
        |  miembro CALCNOM1
        v
NOMINA.PRUEBAS.LOADLIB(CALCNOM1)
librería de loads (PDSE)
        |
        |  PGM=CALCNOM1 y STEPLIB
        v
NOMINA.JCL(NOMINA01)
JOB -> EXEC -> DD
        |
        |  EMPLEADO = NOMINA.PRUEBAS.EMPLEADOS
        |  TOTALES  = NOMINA.PRUEBAS.TOTALES
        v
job NOMINA01 corriendo
lee EMPLEADO, escribe TOTALES
        |
        |  SYSOUT=* y mensajes
        v
spool de JES (lo ves en SDSF)

Del fuente al copy. CALCNOM1 es un miembro de la librería de fuentes. Adentro tiene un COPY CPEMPLEA, y CPEMPLEA es un miembro de la librería de copys. El compilador busca el copy en las librerías que el job de compilación le indica con un DD llamado SYSLIB; si el miembro no está en ninguna, obtienes la cascada de nombres sin definir que se explica en Los errores de compilación más comunes.

Del fuente al ejecutable. Compilar y linkeditar (completar el programa con las rutinas que le faltan) convierten el fuente en un program object, el “load”, y lo dejan como miembro de la librería de loads, con el mismo nombre: CALCNOM1. Los pasos y su JCL están en Del fuente a la ejecución; por ahora basta con saber que existen y que el resultado vive en un PDSE.

Del ejecutable al JCL. El EXEC PGM=CALCNOM1 nombra al miembro, y el DD STEPLIB nombra la librería donde buscarlo. Si compilaste hacia otra librería, o escribiste mal el nombre, el step termina con S806 antes de ejecutar una sola línea.

Del programa a sus archivos, por el ddname. Esta es la conexión que más cuesta ver. En el programa, cada archivo se declara con un SELECT que le da un nombre interno y, después de ASSIGN TO, el ddname:

           SELECT ENTRADA ASSIGN TO EMPLEADO
                  FILE STATUS IS WS-FS-ENTRADA.

Y en el JCL, un DD con ese mismo ddname dice qué dataset es:

//EMPLEADO DD DSN=NOMINA.PRUEBAS.EMPLEADOS,DISP=SHR

El programa solo sabe que lee “ENTRADA”, y que ENTRADA se llama EMPLEADO hacia afuera. El JCL es quien decide que hoy EMPLEADO es NOMINA.PRUEBAS.EMPLEADOS y mañana, en producción, otro dataset con el mismo layout. El programa no cambia. Si el ddname del ASSIGN TO y el del DD no coinciden letra por letra, el OPEN devuelve file status 35.

Y cuando el DSN del DD apunta a un miembro de una librería (por ejemplo DSN=NOMINA.PARAMS(QUINCENA)) y ese miembro no existe, el OPEN truena con un S013. Los datasets de este recorrido son secuenciales, así que ese caso aquí no se da.

Del job al spool. Al hacer submit, JES toma el JCL, lo encola y el sistema ejecuta PASO01: abre EMPLEADO, lee registro por registro con el layout de CPEMPLEA, acumula, escribe en TOTALES. Los DISPLAY van al SYSOUT, que es SYSOUT=*, es decir, al spool. Cuando termina, NOMINA.PRUEBAS.TOTALES queda catalogado y en SDSF ves el job con su return code y toda su salida.

Cinco nombres sostienen el recorrido: el miembro del fuente, el del copy, el del ejecutable, los ddnames y los datasets. Cuando algo no corre, revísalos en ese orden.

Mini glosario

  • Dataset: conjunto de registros con nombre; el “archivo” del mainframe.
  • Calificador: cada parte del nombre de un dataset separada por punto; el primero es el HLQ.
  • Catálogo: índice del sistema que sabe en qué disco está cada dataset.
  • RECFM: formato de registro; FB es fijo en bloques, V es variable.
  • LRECL: largo del registro en bytes.
  • Secuencial: dataset cuyos registros se leen en orden, del primero al último.
  • PDS: dataset particionado; un directorio y miembros. Se le dice librería.
  • PDSE: PDS extendido; crece solo, reutiliza espacio y es donde viven los program objects.
  • Miembro: cada elemento de un PDS o PDSE, con nombre de hasta 8 caracteres.
  • Copy: trozo de código COBOL guardado como miembro y traído con COPY.
  • Program object: el programa ya compilado y linkeditado, listo para ejecutarse; el “load”.
  • JCL: lenguaje con el que le dices al sistema qué ejecutar y con qué datasets.
  • Job: unidad de trabajo que mandas con submit; empieza con una sentencia JOB.
  • Step: cada programa que ejecuta un job; empieza con una sentencia EXEC.
  • DD: sentencia que conecta un ddname con un dataset o con el spool.
  • ddname: nombre con el que el programa conoce un archivo; el del ASSIGN TO y el del DD.
  • STEPLIB: ddname que el sistema reconoce; dice en qué librería buscar el programa del PGM=.
  • SYSOUT: ddname al que COBOL manda los DISPLAY por omisión (opción OUTDD).
  • JES: componente de z/OS que recibe los jobs, los encola y guarda su salida.
  • Spool: almacén de JES donde queda la salida de los jobs hasta que la ves o la borras.
  • Submit: entregar un JCL a JES para que corra como job.
  • SDSF: herramienta para ver los jobs en el spool, su return code y su salida.