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
LRECLexiste, 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:
JOBmarca 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.EXECmarca el inicio de un step y dice qué programa ejecutar:PGM=CALCNOM1. Un job con tres programas tiene tresEXEC, y cada uno es un step con su nombre.DD(data definition) describe un dataset que el step va a usar. CadaDDtiene un nombre a la izquierda, el ddname (EMPLEADO,TOTALES), y a la derecha qué dataset es (DSN=) y qué hacer con él (DISP=:SHRpara compartir uno que existe,NEWpara 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;
FBes fijo en bloques,Ves 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 TOy el delDD. - STEPLIB: ddname que el sistema reconoce; dice en qué librería buscar el programa del
PGM=. - SYSOUT: ddname al que COBOL manda los
DISPLAYpor omisión (opciónOUTDD). - 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.