Unión de ficheros "a lo ancho" con Easytrieve

En muchas ocasiones nos habéis preguntado como unir dos ficheros con JCL de la siguiente forma:

Fichero 1       Fichero 2
aaaaa           xxxxx
bbbbb           yyyyy
ccccc           zzzzz

Unión de los dos ficheros
aaaaaxxxxx
bbbbbyyyyy
ccccczzzzz


Una solución para aquellos que dispongáis de Easytrieve sería usar un paso sencillo como este:

//CONSULL JOB (EASY),'easy',CLASS=A,MSGCLASS=X,
//      MSGLEVEL=(1,1),REGION=0M,COND=(4,LT)
//JOBLIB   DD  DSN=LIB.EJECUCION.EJEM,DISP=SHR
//****************************************************
//* OBTIENE REGISTRO DE CONTRIOL DE TRANSMISION      *
//****************************************************
//EASY0001 EXEC PGM=EZTPA00
//SYSOUT   DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//EZTVFM   DD UNIT=SYSDA,SPACE=(CYL,(40,10))
//ENTRADA1 DD DSN=FICHERO.ENTRADA.NUMERO1,DISP=SHR
//ENTRADA2 DD DSN=FICHERO.ENTRADA.NUMERO2,DISP=SHR           
//SALIDA   DD DSN=FICHERO.SALIDA.EASY,           
//            DISP=(,CATLG,DELETE),                           
//            SPACE=(CYL,(150,50),RLSE),    
//            DCB=(RECFM=FB,LRECL=200,BLKSIZE=0)
//SYSIN    DD *                             
FILE ENTRADA1
           ENTRADA1-TS     1      100      A
*                                           
FILE ENTRADA2                               
           ENTRADA2-TS     1      100      A
*                                           
FILE SALIDA                                 
           SALIDA-TS1      1      100      A
           SALIDA-TS2    101      200      A
*                                           
JOB INPUT NULL                              
      GET ENTRADA1                          
      GET ENTRADA2                          
      DO WHILE (NOT EOF ENTRADA1)           
          SALIDA-TS1 = ENTRADA1-TS          
          SALIDA-TS2 = ENTRADA2-TS          
          PUT SALIDA                        
          GET ENTRADA1                      
          GET ENTRADA2                      
      END-DO  
          STOP  



En este JOB podéis ver que el programa que se ejecuta es el  EZTPA00. Este programa es el compilador de easytrieve.

Será en la sysin donde incluiremos el código easytrieve propiamente dicho:
En primer lugar declaramos los ficheros de entrada ENTRADA1 y ENTRADA2 de longitud 100 en ambos casos. Definimos también el fichero de salida SALIDA como la suma de los 2, en total 200 posiciones de longitud.
En segundo lugar escribimos el código del programa:
Leer fichero: con la instrucción GET.
Escribir en el fichero de salida: con la instrucción PUT.

Lo hacemos dentro de un bucle donde vamos informando el área de salida, escribimos y leemos el siguiente registro de ambos ficheros.

Y listo! Nuestro paso de JCL nos ha ahorrado un programa cobol : )

Se os ocurren otras formas de hacerlo? Esperamos sugerencias!

EASYTRIEVE(I): Cruce ficheros 1:1

Este es le primero de una serie de artículos que presentaremos para explicar esta potente herramienta para el manejo de ficheros.

Empezaremos con un programa sencillo un cruce 1:1 de dos ficheros, para ello examinaremos el siguiente código EASYTRIEVE.

Supongamos el siguiente problema: Determinar que productos ha pedido al almacén un determinado empleado.

Para ellos contaremos con dos ficheros de información.
Fichero IN1 en el que tenemos la información de solicitudes de productos de empleados (producto viene especificado por su código):

FILE IN1
   IN1-NUMCLI          1    4 N 0
   IN1-NUMPROD         5    3 N 0
   IN1-FECALTA         8   10 A

Fichero IN2 en el que tenemos la información de las descripciones de los distintos productos:

FILE IN2
   IN2-NUMPROD         1    3 N 0
   IN2-DESPROD         4   14 A

Nuestro fichero de salida tendrá las decripciones de los productos de las solicitudes hechas por un empleado (lo que no se nos planteaba en el problema):

FILE OUT
   OUT-NUMCLI          1    4 N 0
   OUT-NUMPROD         5    3 N 0
   OUT-DESPROD         8   14 A

Vemos que se trata de un cruce 1:1 donde el campo clave (campo por el que se hace el cruce es el código del producto)
En el siguiente código se especifica los campos por los cuales se hace el enfrentamiento de los ficheros:

JOB INPUT (IN1 KEY (IN1-NUMPROD) +
          IN2 KEY (IN2-NUMPROD)) +
    FINISH PFINAL

Con la sentencia MATCHED tendremos todos aquellos registros donde el NUMPROD de IN1 = NUMPROD de IN2:

IF MATCHED
   OUT-NUMCLI = IN1-NUMCLI
   OUT-NUMPROD = IN1-NUMPROD
   OUT-DESPROD = IN2-DESPROD
   PUT OUT
END-IF
PFINAL . PROC
  DISPLAY '******************** FINAL ********************'
END-PROC

La sentencia PUT nos escribe en el fichero de salida

Nuestro problemas quedaría resuelto, pero vamos ir un poco mas allá, extrayendo un poco mas de información, para ver las posibilidades que nos ofrece EASYTRIEVE de una manera sencilla y muy rápida

IF NOT MATCHED Con esta sentencia tendremos todos aquellos registros donde el NUMPROD de IN1 <> NUMPROD de IN2

IF NOT MATCHED
   IF IN1 Con esta sentencia tendremos todos aquellos registros donde el NUMPROD de IN1 < NUMPROD de IN2
   IF IN2 Con esta sentencia tendremos todos aquellos registros donde el NUMPROD de IN1 > NUMPROD de IN2

Todo esto lo podemos ver mas claro viendo el siguiente ejemplo:
Supongamos el siguiente cruce de ficheros

 SECUEN.   IN1   IN2    
--------  ----- ------   
   1       1    N/A     
   2       2     2      
   3       3     3     
   4       4     4                
   5       5    N/A     
   6      N/A    6     
   7      N/A    7     
   8      N/A    8   
   9      N/A    9      
  10      N/A    10    
  11      11    N/A     
  12      12    N/A     
  13      13    N/A          
  14      14    N/A 

IF MATCHED Nos devolvería los registros cuyos secuenciales son: 2, 3, 4 

IF NOT MATCHED
   IF IN1 Nos devolvería los registros cuyos secuenciales son: 1, 5, 11, 12, 13, 14
   IF IN2 Nos devolvería los registros cuyos secuenciales son: 6, 7, 8, 9, 10

Esto es una manera sencilla y rápida de hacer un cruce de dos ficheros 1 a 1. En posteriores artículos veremos como tratar otro tipo de cruces 1:n y n:n.

En breve colgaremos para descargar el JCL, los ficheros de entrada, y el fichero de salida.

Y ahí lo tenéis:
JCL con easytrieve.