JCL ABDISPCC en la práctica en z/OS

ABDISPCC es una incorporación reciente a JCL porque resuelve un problema operativo real: un paso puede terminar normalmente, pero con un código de retorno lo bastante alto como para que su salida deje de ser fiable. En JCL más antiguo, eso normalmente implicaba lógica adicional de limpieza en pasos posteriores o trabajo procedural fuera del job.

Este artículo es deliberadamente práctico. Usa pequeños jobs de IDCAMS que terminan con códigos de retorno controlados y muestra exactamente cómo ABDISPCC cambia el resultado de disposition de un data set recién asignado.

1. Objetivos del laboratorio

Al final de este laboratorio debería poder:

• Explicar qué hace ABDISPCC en la sentencia EXEC
• Distinguir el control de disposition del control de flujo entre pasos
• Probar el comportamiento base sin ABDISPCC
• Usar ABDISPCC=(8,GE) para impedir que una salida dudosa sea catalogada
• Entender la diferencia entre GT y GE

2. Entorno necesario

Para este laboratorio, use:

• z/OS 2.5 o posterior
• JES2
• acceso TSO/ISPF con permiso para enviar jobs batch
• un ID de usuario que pueda asignar data sets de prueba catalogados con el prefijo &SYSUID

Nota importante:

• IBM documenta ABDISPCC como una palabra clave más reciente de EXEC y también indica que no está soportada en entornos JES3
• La función fue entregada por el APAR OA63081 para HBB77C0 y superiores
• Nivel mínimo práctico:
• z/OS 2.5 con PTF UJ93787
• z/OS 3.1 con PTF UJ93788
• z/OS 3.2 con PTF UJ93785

Si su sistema no reconoce la palabra clave ABDISPCC, la causa más probable es que el mantenimiento requerido no esté instalado.

3. Qué cambia ABDISPCC

Sin ABDISPCC, un paso que termina normalmente siempre usa la disposition de fin normal definida en DISP o PATHDISP, aunque el código de retorno sea indeseable.

Con ABDISPCC, puede escribir:

//STEP1 EXEC PGM=program-name,ABDISPCC=(code,operator)

El sistema compara el código de finalización del paso actual con la condición:

Cuando la condición coincide, z/OS aplica la lógica de disposition de fin anormal a las sentencias DD de ese paso, aunque el paso haya terminado normalmente.

Ese es todo el valor de ABDISPCC: permite decir, en JCL, “un RC 8 o superior es suficientemente malo para que la salida se trate como salida fallida.”

4. Distinción importante: control de disposition no es control de flujo

ABDISPCC no controla si se ejecuta el siguiente paso. Solo afecta al procesamiento de disposition de las DD del paso actual.

Use los siguientes mecanismos para finalidades diferentes:

5. Cómo funciona el laboratorio

Vamos a enviar cuatro pequeños jobs:

Los cuatro jobs asignan un nuevo data set secuencial con:

DISP=(NEW,CATLG,DELETE)

Después, el paso ejecuta IDCAMS y fija un código de retorno controlado mediante SET MAXCC=8 o SET MAXCC=12.

Esto hace que el resultado sea fácil de observar:

• si se aplica la disposition normal, el data set se cataloga
• si se aplica la disposition anormal, el data set se elimina

6. Job 1: comportamiento base sin ABDISPCC

Cree un miembro JCL como ABDNOCC con el siguiente contenido:

//ABDNOCC  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.NOCC,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Envíe el job e inspeccione la salida:

• el paso debe terminar normalmente
• el código de finalización del paso debe ser 8

Ahora verifique si el data set existe. Puede hacerlo en ISPF 3.4, o con un pequeño job de comprobación IDCAMS como este:

//ABDCHK1  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.NOCC')
/*

Resultado esperado:

• &SYSUID..ABDISPCC.NOCC existe

Por qué:

• el paso terminó normalmente
• no había ABDISPCC
• por tanto, z/OS usó la disposition normal, que es CATLG

Este es el comportamiento base que a menudo sorprende: un job puede devolver RC 8 y aun así catalogar su salida.

7. Job 2: usar ABDISPCC=(8,GE)

Cree un segundo miembro como ABDGE8:

//ABDGE8   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GE)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GE8,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Envíelo y revise el resultado:

• el paso debe volver a terminar normalmente con código de finalización 8

Ahora verifique el estado en catálogo:

//ABDCHK2  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GE8')
/*

Resultado esperado:

• no se debe encontrar el data set

Por qué:

• el paso terminó normalmente con RC 8
• ABDISPCC=(8,GE) coincidió
• z/OS aplicó entonces la disposition de fin anormal
• el tercer subparámetro de DISP es DELETE

Este es el patrón de producción más útil de forma inmediata:

DISP=(NEW,CATLG,DELETE)

combinado con:

ABDISPCC=(8,GE)

Eso significa: “catalogue la salida solo si el paso ha terminado realmente con calidad suficiente.”

8. Job 3: GT es diferente de GE

Ahora cree ABDGT8:

//ABDGT8   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GT)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GT8,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=8
/*

Envíe el job y verifique:

//ABDCHK3  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GT8')
/*

Resultado esperado:

• el data set existe

Por qué:

• RC 8 no es mayor que 8
• ABDISPCC=(8,GT) no coincide
• z/OS sigue usando la disposition normal

Esta es la diferencia exacta:

9. Job 4: ABDISPCC=(8,GT) con un código de retorno más alto

Cree un último miembro, ABDGT12:

//ABDGT12  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS,ABDISPCC=(8,GT)
//TESTOUT  DD  DSN=&SYSUID..ABDISPCC.GT12,
//             DISP=(NEW,CATLG,DELETE),
//             SPACE=(TRK,(1,1)),
//             DCB=(RECFM=FB,LRECL=80,BLKSIZE=0)
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  SET MAXCC=12
/*

Verifíquelo:

//ABDCHK4  JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  LISTCAT ENTRIES('&SYSUID..ABDISPCC.GT12')
/*

Resultado esperado:

• no se encuentra el data set

Por qué:

• RC 12 es mayor que 8
• ABDISPCC=(8,GT) coincide
• z/OS aplica la disposition anormal y elimina el data set

10. Dónde es más útil ABDISPCC

Los casos de uso más prácticos son:

• pasos batch que asignan un nuevo data set de salida y solo deben catalogarlo para códigos de retorno aceptables
• pasos de generación de informes donde RC 4 puede ser aceptable pero RC 8 debe descartar la salida
• pasos de descarga, extracción o transformación que pueden terminar normalmente pero aun así producir resultados inutilizables
• procesamiento de ficheros z/OS UNIX con PATHDISP, porque la misma lógica también se aplica allí

Desde el punto de vista del diseño, ABDISPCC permite mantener la política de código de retorno cerca del paso que crea la salida.

11. Error común que debe evitar

No trate ABDISPCC como sustituto de COND o IF/THEN/ELSE.

Esta es una forma incorrecta de pensar:

• “Usé ABDISPCC, así que los pasos siguientes no se ejecutarán.”

Esta es la forma correcta de pensar:

• “Usé ABDISPCC, así que la salida de este paso se eliminará en lugar de catalogarse cuando el código de retorno sea demasiado alto.”

Si además necesita detener u omitir pasos posteriores, añada por separado la lógica normal de control de flujo en JCL.

12. Cleanup

Si quiere eliminar cualquier data set creado durante el laboratorio, envíe:

//ABDCLN   JOB ,'ABDISPCC LAB',CLASS=A,MSGCLASS=X,NOTIFY=&SYSUID
//STEP1    EXEC PGM=IDCAMS
//SYSPRINT DD  SYSOUT=*
//SYSIN    DD  *
  DELETE '&SYSUID..ABDISPCC.NOCC'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GE8'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GT8'
  IF LASTCC = 8 THEN SET MAXCC = 0
  DELETE '&SYSUID..ABDISPCC.GT12'
  IF LASTCC = 8 THEN SET MAXCC = 0
/*

Resumen

ABDISPCC es pequeño, pero muy útil desde el punto de vista operativo. Permite convertir un umbral de código de retorno normal en una decisión de disposition sin pasos extra de limpieza.

El patrón práctico principal es:

//STEP1   EXEC PGM=program-name,ABDISPCC=(8,GE)
//OUTDD   DD   DSN=...,DISP=(NEW,CATLG,DELETE)

Eso significa:

• catalogar la salida solo cuando el paso termina con calidad suficiente
• en caso contrario, eliminarla, aunque el paso haya terminado normalmente

Documentación útil de IBM

• Parámetro ABDISPCC
• Sentencia EXEC
• Resumen de cambios en z/OS 3.1
• Resumen del procesamiento de disposition
• Comando IDCAMS SET
• Comando LISTCAT
• APAR OA63081 - nueva función para ABDISPCC